Gestion du Tableau de Bord

Lister et Récupérer les Tableaux de Bord

Accédez aux tableaux de bord qui contiennent des panneaux de visualisation pour les insights de fouille de processus, les KPI et les analyses. Les tableaux de bord sont des conteneurs pour afficher vos résultats analytiques de manière organisée et partageable.

Test de Connectivité

Ping Non Autorisé

GET /api/{tenantId}/{projectId}/dashboard/unauthorized-ping

Point de terminaison de test qui ne nécessite pas d'authentification. Utilisez-le pour vérifier que l'API Dashboard est accessible.

Réponse

Ping Successful

Ping Authentifié

GET /api/{tenantId}/{projectId}/dashboard/ping

Point de terminaison de ping authentifié pour vérifier l'accès à l'API pour un locataire et un projet spécifiques.

Réponse (200 OK)

Ping Successful (tenant id: {tenantId})

Réponse (401 Unauthorized)

{error message describing authorization failure}

Lister Tous les Tableaux de Bord

GET /api/{tenantId}/{projectId}/dashboard

Récupère une liste paginée de tous les tableaux de bord dans le projet spécifié. Chaque tableau de bord inclut les métadonnées, le nombre de panneaux et une URL partageable.

Paramètres de Chemin

Paramètre	Type	Obligatoire	Description
tenantId	GUID	Oui	Identifiant du locataire
projectId	GUID	Oui	Identifiant du projet

Paramètres de Requête

Paramètre	Type	Par défaut	Description
page	entier	1	Numéro de la page pour la pagination
pageSize	entier	50	Nombre d'éléments par page (max recommandé : 100)

Réponse (200 OK)

{
  "dashboards": [
    {
      "dashboardId": "880e8400-e29b-41d4-a716-446655440000",
      "projectId": "660e8400-e29b-41d4-a716-446655440000",
      "name": "Process Overview Dashboard",
      "description": "Tableau de bord principal affichant les métriques clés du processus",
      "panelCount": 8,
      "url": "https://your-instance.com/dashboard/880e8400-e29b-41d4-a716-446655440000",
      "dateCreated": "2024-01-15T10:30:00Z",
      "dateModified": "2024-01-20T14:45:00Z",
      "createdBy": "user@example.com",
      "modifiedBy": "user@example.com"
    }
  ],
  "totalCount": 25,
  "page": 1,
  "pageSize": 50
}

Champs de la Réponse

Champ	Type	Description
dashboards	tableau	Liste d'objets tableau de bord
totalCount	entier	Nombre total de tableaux de bord
page	entier	Numéro de la page courante
pageSize	entier	Nombre d'éléments par page

Champs de l'Objet Tableau de Bord

Champ	Type	Description
dashboardId	GUID	Identifiant unique du tableau de bord
projectId	GUID	Projet auquel appartient ce tableau de bord
name	chaîne	Nom affiché du tableau de bord
description	chaîne	Description du tableau de bord
panelCount	entier	Nombre de panneaux dans le tableau de bord
url	chaîne	URL partageable du tableau de bord
dateCreated	datetime	Date de création du tableau de bord
dateModified	datetime	Date de dernière modification du tableau de bord
createdBy	chaîne	Utilisateur ayant créé le tableau de bord
modifiedBy	chaîne	Utilisateur ayant modifié le tableau de bord en dernier

Obtenir les Détails d'un Tableau de Bord

GET /api/{tenantId}/{projectId}/dashboard/{dashboardId}

Récupère des informations complètes sur un tableau de bord spécifique, incluant les métadonnées, le nombre de panneaux et une URL partageable.

Paramètres de Chemin

Paramètre	Type	Obligatoire	Description
tenantId	GUID	Oui	Identifiant du locataire
projectId	GUID	Oui	Identifiant du projet
dashboardId	GUID	Oui	Identifiant du tableau de bord

Réponse (200 OK)

{
  "dashboardId": "880e8400-e29b-41d4-a716-446655440000",
  "projectId": "660e8400-e29b-41d4-a716-446655440000",
  "name": "Process Overview Dashboard",
  "description": "Tableau de bord principal affichant les métriques clés du processus et les indicateurs de performance",
  "panelCount": 8,
  "url": "https://your-instance.com/dashboard/880e8400-e29b-41d4-a716-446655440000",
  "dateCreated": "2024-01-15T10:30:00Z",
  "dateModified": "2024-01-20T14:45:00Z",
  "createdBy": "user@example.com",
  "modifiedBy": "user@example.com"
}

Réponses d'Erreur

Non trouvé (404) :

{
  "Error": "Tableau de bord introuvable",
  "DashboardId": "880e8400-e29b-41d4-a716-446655440000"
}

Création de Tableaux de Bord

La création de tableaux de bord est gérée via l'interface mindzieStudio car elle nécessite un contexte d'investigation et des relations avec les notebooks. Voir Présentation du Tableau de Bord pour plus de détails.

Exemples d'Implémentation

cURL

# Tester la connectivité (pas d'authentification)
curl -X GET "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/dashboard/unauthorized-ping"

# Tester la connectivité (authentifié)
curl -X GET "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/dashboard/ping" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

# Lister tous les tableaux de bord
curl -X GET "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/dashboard?page=1&pageSize=50" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

# Obtenir un tableau de bord spécifique
curl -X GET "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/dashboard/880e8400-e29b-41d4-a716-446655440000" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

JavaScript/Node.js

const TENANT_ID = '12345678-1234-1234-1234-123456789012';
const PROJECT_ID = '87654321-4321-4321-4321-210987654321';
const BASE_URL = 'https://your-mindzie-instance.com';

class DashboardManager {
  constructor(token) {
    this.headers = {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json'
    };
  }

  async getAllDashboards(page = 1, pageSize = 50) {
    const url = `${BASE_URL}/api/${TENANT_ID}/${PROJECT_ID}/dashboard?page=${page}&pageSize=${pageSize}`;
    const response = await fetch(url, { headers: this.headers });
    return await response.json();
  }

  async getDashboard(dashboardId) {
    const url = `${BASE_URL}/api/${TENANT_ID}/${PROJECT_ID}/dashboard/${dashboardId}`;
    const response = await fetch(url, { headers: this.headers });

    if (response.ok) {
      return await response.json();
    } else if (response.status === 404) {
      throw new Error('Tableau de bord introuvable');
    } else {
      throw new Error(`Échec de récupération du tableau de bord : ${response.status}`);
    }
  }

  async listAllDashboards() {
    const allDashboards = [];
    let page = 1;

    while (true) {
      const result = await this.getAllDashboards(page);
      allDashboards.push(...result.dashboards);

      if (allDashboards.length >= result.totalCount) {
        break;
      }
      page++;
    }

    return allDashboards;
  }
}

// Utilisation
const manager = new DashboardManager('your-auth-token');

// Obtenir tous les tableaux de bord
const result = await manager.getAllDashboards();
console.log(`Nombre de tableaux de bord trouvés : ${result.totalCount}`);

result.dashboards.forEach(d => {
  console.log(`- ${d.name} : ${d.panelCount} panneaux`);
  console.log(`  URL : ${d.url}`);
});

Python

import requests

TENANT_ID = '12345678-1234-1234-1234-123456789012'
PROJECT_ID = '87654321-4321-4321-4321-210987654321'
BASE_URL = 'https://your-mindzie-instance.com'

class DashboardManager:
    def __init__(self, token):
        self.headers = {
            'Authorization': f'Bearer {token}',
            'Content-Type': 'application/json'
        }

    def get_all_dashboards(self, page=1, page_size=50):
        """Obtenir la liste paginée des tableaux de bord."""
        url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/dashboard'
        params = {'page': page, 'pageSize': page_size}
        response = requests.get(url, headers=self.headers, params=params)
        return response.json()

    def get_dashboard(self, dashboard_id):
        """Obtenir les détails d'un tableau de bord."""
        url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/dashboard/{dashboard_id}'
        response = requests.get(url, headers=self.headers)

        if response.ok:
            return response.json()
        elif response.status_code == 404:
            raise Exception('Tableau de bord introuvable')
        else:
            raise Exception(f'Échec de récupération du tableau de bord : {response.status_code}')

    def list_all_dashboards(self):
        """Obtenir tous les tableaux de bord (gestion de la pagination)."""
        all_dashboards = []
        page = 1

        while True:
            result = self.get_all_dashboards(page=page)
            all_dashboards.extend(result['dashboards'])

            if len(all_dashboards) >= result['totalCount']:
                break
            page += 1

        return all_dashboards

# Utilisation
manager = DashboardManager('your-auth-token')

# Obtenir tous les tableaux de bord
dashboards = manager.get_all_dashboards()
print(f"Total des tableaux de bord : {dashboards['totalCount']}")

for dashboard in dashboards['dashboards']:
    print(f"\nTableau de bord : {dashboard['name']}")
    print(f"  Panneaux : {dashboard['panelCount']}")
    print(f"  URL : {dashboard['url']}")

C#

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text.Json;
using System.Threading.Tasks;

public class DashboardListReturn
{
    public List<DashboardReturn> Dashboards { get; set; }
    public int TotalCount { get; set; }
    public int Page { get; set; }
    public int PageSize { get; set; }
}

public class DashboardReturn
{
    public Guid DashboardId { get; set; }
    public Guid ProjectId { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
    public int PanelCount { get; set; }
    public string Url { get; set; }
    public DateTime DateCreated { get; set; }
    public DateTime DateModified { get; set; }
    public string CreatedBy { get; set; }
    public string ModifiedBy { get; set; }
}

public class DashboardApiClient
{
    private readonly HttpClient _httpClient;
    private readonly string _baseUrl;
    private readonly Guid _tenantId;
    private readonly Guid _projectId;

    public DashboardApiClient(string baseUrl, Guid tenantId, Guid projectId, string accessToken)
    {
        _baseUrl = baseUrl;
        _tenantId = tenantId;
        _projectId = projectId;
        _httpClient = new HttpClient();
        _httpClient.DefaultRequestHeaders.Authorization =
            new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", accessToken);
    }

    public async Task<DashboardListReturn> GetAllDashboardsAsync(int page = 1, int pageSize = 50)
    {
        var url = $"{_baseUrl}/api/{_tenantId}/{_projectId}/dashboard?page={page}&pageSize={pageSize}";
        var response = await _httpClient.GetAsync(url);

        if (response.IsSuccessStatusCode)
        {
            var json = await response.Content.ReadAsStringAsync();
            return JsonSerializer.Deserialize<DashboardListReturn>(json,
                new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
        }

        throw new Exception($"Échec de récupération des tableaux de bord : {response.StatusCode}");
    }

    public async Task<DashboardReturn> GetDashboardAsync(Guid dashboardId)
    {
        var url = $"{_baseUrl}/api/{_tenantId}/{_projectId}/dashboard/{dashboardId}";
        var response = await _httpClient.GetAsync(url);

        if (response.IsSuccessStatusCode)
        {
            var json = await response.Content.ReadAsStringAsync();
            return JsonSerializer.Deserialize<DashboardReturn>(json,
                new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
        }
        else if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
        {
            throw new Exception($"Tableau de bord {dashboardId} introuvable");
        }

        throw new Exception($"Échec de récupération du tableau de bord : {response.StatusCode}");
    }
}