Dashboardbeheer

Dashboards weergeven en opvragen

Toegang tot dashboards die visualisatiepanelen bevatten voor procesmininginzichten, KPI's en analyses. Dashboards zijn containers voor het georganiseerd en deelbaar weergeven van uw analytische resultaten.

Connectiviteitstesten

Onbevoegde Ping

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

Testendpoint dat geen authenticatie vereist. Gebruik dit om te verifiëren of de Dashboard API toegankelijk is.

Respons

Ping Successful

Geauthenticeerde Ping

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

Geauthenticeerde ping-endpoint om de API-toegang voor een specifieke tenant en project te controleren.

Respons (200 OK)

Ping Successful (tenant id: {tenantId})

Respons (401 Unauthorized)

{error message describing authorization failure}

Alle dashboards weergeven

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

Haalt een gepagineerde lijst op van alle dashboards binnen het gespecificeerde project. Elk dashboard bevat metadata, het aantal panelen en een deelbare URL.

Padparameters

Parameter	Type	Verplicht	Beschrijving
tenantId	GUID	Ja	De tenant-identificatie
projectId	GUID	Ja	De projectidentificatie

Queryparameters

Parameter	Type	Standaard	Beschrijving
page	integer	1	Paginanummer voor paginering
pageSize	integer	50	Aantal items per pagina (maximaal aanbevolen: 100)

Respons (200 OK)

{
  "dashboards": [
    {
      "dashboardId": "880e8400-e29b-41d4-a716-446655440000",
      "projectId": "660e8400-e29b-41d4-a716-446655440000",
      "name": "Process Overview Dashboard",
      "description": "Main dashboard showing key process metrics",
      "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
}

Responsvelden

Veld	Type	Beschrijving
dashboards	array	Lijst van dashboardobjecten
totalCount	integer	Totaal aantal dashboards
page	integer	Huidig paginanummer
pageSize	integer	Items per pagina

Dashboardobjectvelden

Veld	Type	Beschrijving
dashboardId	GUID	Unieke identificatie voor het dashboard
projectId	GUID	Project waartoe dit dashboard behoort
name	string	Weergavenaam van het dashboard
description	string	Beschrijving van het dashboard
panelCount	integer	Aantal panelen in het dashboard
url	string	Deelbare URL naar het dashboard
dateCreated	datetime	Wanneer het dashboard is aangemaakt
dateModified	datetime	Wanneer het dashboard laatst is aangepast
createdBy	string	Gebruiker die het dashboard heeft aangemaakt
modifiedBy	string	Gebruiker die het dashboard als laatste heeft aangepast

Dashboarddetails opvragen

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

Haalt uitgebreide informatie op over een specifiek dashboard, inclusief metadata, panelenaantal en deelbare URL.

Padparameters

Parameter	Type	Verplicht	Beschrijving
tenantId	GUID	Ja	De tenant-identificatie
projectId	GUID	Ja	De projectidentificatie
dashboardId	GUID	Ja	De dashboard-identificatie

Respons (200 OK)

{
  "dashboardId": "880e8400-e29b-41d4-a716-446655440000",
  "projectId": "660e8400-e29b-41d4-a716-446655440000",
  "name": "Process Overview Dashboard",
  "description": "Main dashboard showing key process metrics and performance indicators",
  "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"
}

Foutresponsen

Niet gevonden (404):

{
  "Error": "Dashboard not found",
  "DashboardId": "880e8400-e29b-41d4-a716-446655440000"
}

Dashboards aanmaken

Het aanmaken van dashboards wordt beheerd via de mindzieStudio UI omdat dit context van onderzoek en notitieboekrelaties vereist. Zie Dashboard Overview voor details.

Voorbeelden van implementatie

cURL

# Test connectiviteit (geen authenticatie)
curl -X GET "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/dashboard/unauthorized-ping"

# Test connectiviteit (geauthenticeerd)
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"

# Alle dashboards ophalen
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"

# Specifiek dashboard opvragen
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('Dashboard not found');
    } else {
      throw new Error(`Failed to get dashboard: ${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;
  }
}

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

// Alle dashboards ophalen
const result = await manager.getAllDashboards();
console.log(`Found ${result.totalCount} dashboards`);

result.dashboards.forEach(d => {
  console.log(`- ${d.name}: ${d.panelCount} panels`);
  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):
        """Haal een gepagineerde lijst van dashboards op."""
        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):
        """Haal details van een dashboard op."""
        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('Dashboard not found')
        else:
            raise Exception(f'Failed to get dashboard: {response.status_code}')

    def list_all_dashboards(self):
        """Haal alle dashboards op (met paginering)."""
        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

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

# Alle dashboards ophalen
dashboards = manager.get_all_dashboards()
print(f"Totaal dashboards: {dashboards['totalCount']}")

for dashboard in dashboards['dashboards']:
    print(f"\nDashboard: {dashboard['name']}")
    print(f"  Panels: {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($"Failed to get dashboards: {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($"Dashboard {dashboardId} not found");
        }

        throw new Exception($"Failed to get dashboard: {response.StatusCode}");
    }
}