Paneelinformatie

Toegang tot Dashboard Paneelconfiguraties

Bekijk en maak visualisatiepanelen aan in dashboards, inclusief hun opmaak, positie en configuratie-instellingen.

Dashboardpanelen Opvragen

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

Haalt alle geconfigureerde visualisatiepanelen op in een dashboard, inclusief paneltypen, posities, afmetingen en configuratie-instellingen.

Padparameters

Parameter	Type	Vereist	Beschrijving
tenantId	GUID	Ja	De tenant identificator
projectId	GUID	Ja	De projectidentificator
dashboardId	GUID	Ja	De dashboardidentificator

Reactie (200 OK)

{
  "dashboardId": "880e8400-e29b-41d4-a716-446655440000",
  "panels": [
    {
      "panelId": "990e8400-e29b-41d4-a716-446655440000",
      "name": "Process Flow Chart",
      "panelType": "DashboardPanelProcessMap",
      "position": "Row: 1, Col: 1",
      "width": 6,
      "height": 4,
      "configuration": "{\"dataSource\": \"MainProcess\", \"visualization\": \"flow\"}"
    },
    {
      "panelId": "aa0e8400-e29b-41d4-a716-446655440000",
      "name": "KPI Summary",
      "panelType": "DashboardPanelSingleValue",
      "position": "Row: 1, Col: 7",
      "width": 3,
      "height": 2,
      "configuration": "{\"metric\": \"avgCycleTime\", \"format\": \"duration\"}"
    }
  ]
}

Response Velden

Veld	Type	Beschrijving
dashboardId	GUID	Het dashboard dat deze panelen bevat
panels	array	Lijst met paneelobjecten

Paneelobjectvelden

Veld	Type	Beschrijving
panelId	GUID	Unieke identificator voor het paneel
name	string	Weergavetitel van het paneel
panelType	string	Type visualisatie (zie sectie Paneltypen)
position	string	Positie in het grid als "Row: X, Col: Y"
width	integer	Breedte van het paneel in grid-eenheden
height	integer	Hoogte van het paneel in grid-eenheden
configuration	string	JSON-string met paneelspecifieke instellingen

Foutresponstypes

Niet Gevonden (404):

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

Dashboardpaneel Maken

POST /api/{tenantId}/{projectId}/dashboard/{dashboardId}/panel

Maakt een nieuw visualisatiepaneel aan in een dashboard. De API maakt automatisch het geschikte selectorblok aan op basis van het paneeltype en de opgegeven instellingen.

Padparameters

Parameter	Type	Vereist	Beschrijving
tenantId	GUID	Ja	De tenant identificator
projectId	GUID	Ja	De projectidentificator
dashboardId	GUID	Ja	De dashboardidentificator

Request Body

{
  "title": "string (verplicht)",
  "description": "string (optioneel)",
  "panelType": "string (verplicht)",
  "blockId": "GUID (verplicht voor datapunten)",
  "row": "integer (verplicht, 0-gebaseerd)",
  "column": "integer (verplicht, 0-gebaseerd)",
  "width": "integer (verplicht, 1-12)",
  "height": "integer (verplicht, 1-20)",
  "settings": "string (optioneel, JSON voor selectorconfiguratie)"
}

Request Body Velden

Veld	Type	Vereist	Beschrijving
title	string	Ja	Weergavetitel van het paneel
description	string	Nee	Optionele beschrijving
panelType	string	Ja	Paneeltype klassennaam (zie sectie Paneltypen)
blockId	GUID	Ja*	Calculatorblok ID voor weergave (*niet vereist voor DashboardPanelDashboardNote)
row	integer	Ja	Rijpositie (0-gebaseerd)
column	integer	Ja	Kolompositie (0-gebaseerd)
width	integer	Ja	Paneelbreedte in grid-eenheden (1-12)
height	integer	Ja	Paneelhoogte in grid-eenheden (1-20)
settings	string	Nee	JSON-string met selectorconfiguratie

Reactie (201 Created)

{
  "panelId": "5b54172c-b15c-4dd9-bab6-6cfceb7389df",
  "title": "My KPI Panel",
  "dashboardPanelClassName": "DashboardPanelSingleValue",
  "row": 0,
  "column": 0,
  "width": 2,
  "height": 1,
  "blockId": "db0dd1b9-63b5-4754-92b1-2764f4a3fb68"
}

Opmerking: De blockId in de reactie is het SELECTOR blok-ID, niet het originele calculatorblok-ID. De API maakt automatisch een selectorblok dat de calculator wikkelt.

Foutresponstypes

Bad Request (400) - Ontbrekend Blok:

{
  "Error": "VALIDATION_ERROR",
  "Message": "BlockId is required for panel type 'DashboardPanelSingleValue'"
}

Bad Request (400) - Ongeldig Paneeltype:

{
  "Error": "VALIDATION_ERROR",
  "Message": "Invalid panel type 'InvalidType'. Valid types: DashboardPanelSingleValue, DashboardPanelCalculator, ..."
}

Bad Request (400) - Blok Niet Gevonden:

{
  "Error": "VALIDATION_ERROR",
  "Message": "Block 'guid' does not exist"
}

Paneltypen

mindzieStudio dashboards ondersteunen de volgende paneeltypen:

Paneeltype Klasse	Gemaakt Selector	Beschrijving
DashboardPanelCalculator	SelectorFullCalculator	Volledige calculatoroutput (proceskaarten, trends, grafieken)
DashboardPanelSingleValue	SelectorSingleValueFromLabel	Enkelvoudige waarde / KPI-kaart
DashboardPanelHorizontalBarChart	SelectorMultiColumns	Horizontale staafgrafiek, gerangschikte lijsten
DashboardPanelDataTable	SelectorFullCalculator	Data tabweergave
DashboardPanelProcessMap	SelectorFullCalculator	Proceskaart visualisatie
DashboardPanelDashboardNote	(geen)	Tekst-/notitiepaneel (geen blockId vereist)
DashboardPanelRecommendationSentence	(geen)	AI aanbevelingsweergave

Paneelinstellingen per Type

DashboardPanelSingleValue (KPI-kaarten)

Wanneer panelType DashboardPanelSingleValue is, configureren de instellingen hoe een enkele waarde uit de calculatoroutput gehaald wordt:

{
  "tableIndex": 0,
  "labelColumnName": "Name",
  "labelName": "Total Case Count",
  "valueColumnName": "Value",
  "formatText": "N0"
}

Instelling	Type	Beschrijving
tableIndex	integer	Welke uitvoertabel te gebruiken (meestal 0)
labelColumnName	string	Kolom met labels (meestal "Name")
labelName	string	De te vinden label (bijv. "Total Case Count")
valueColumnName	string	Kolom met de waarde (meestal "Value")
formatText	string	.NET-formaatstring (N0, F2, P0, enz.)

Best gebruikt met: CalculatorDataInformation, CalculatorOverview

DashboardPanelHorizontalBarChart (Staafdiagrammen)

Wanneer panelType DashboardPanelHorizontalBarChart is, bevat settings columnNames om SelectorMultiColumns te activeren:

{
  "tableIndex": 0,
  "columnNames": ["ActivityName", "Count"],
  "sortColumnName": "Count",
  "sortAscending": false,
  "maxRows": 10
}

Instelling	Type	Beschrijving
tableIndex	integer	Welke uitvoertabel te gebruiken
columnNames	array	Kolommen die in de grafiek worden opgenomen (MOET overeenkomen met calculatoroutput)
sortColumnName	string	Kolom om op te sorteren
sortAscending	boolean	Sorteerrichting
maxRows	integer	Maximaal aantal weergegeven rijen

BELANGRIJK: Kolomnamen moeten exact overeenkomen met de outputkolommen van de calculator. Bijvoorbeeld, CalculatorActivityFrequency gebruikt de activiteitskolomnaam uit de dataset (zoals "ActivityName"), niet een algemene "Activity".

Best gebruikt met: CalculatorActivityFrequency, CalculatorResourceFrequency

DashboardPanelCalculator (Volledige Visualisaties)

Voor volledige calculatoroutput (proceskaarten, trends) zijn geen speciale instellingen nodig:

{}

Of laat de settings parameter helemaal weg.

Paneelarchitectuur

Dashboardpanelen verbinden niet rechtstreeks met calculatorblokken. Ze gebruiken een driedelige architectuur:

Panel.InputBlockId -> Selector Block -> Calculator Block (via parent_id)

Waarom Selectors? Selectorblokken definiëren HOE de calculatoroutput wordt weergegeven:

• SelectorFullCalculator: Toon volledige output met visualisatie-instellingen
• SelectorSingleValueFromLabel: Haal één waarde op via label-opzoeking
• SelectorMultiColumns: Haal specifieke kolommen op met sorteren/limiteren

De API maakt automatisch het juiste selectorblok aan wanneer je een paneel aanmaakt dat naar een calculator verwijst.

Paneelindelingssysteem

Dashboardpanelen gebruiken een grid-gebaseerd indelingssysteem:

• Grideenheden: 12-koloms gridsysteem
• Positie: Rij- en kolomcoördinaten (0-gebaseerd)
• Grootte: Breedte (1-12 kolommen), Hoogte (1-20 rijen)
• Responsief: Automatische schaalverdeling op verschillende schermformaten

Implementatievoorbeelden

Dashboardpanelen Opvragen

cURL

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/panels" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

KPI Paneel Maken (Enkele Waarde)

curl -X POST "https://your-mindzie-instance.com/api/{tenantId}/{projectId}/dashboard/{dashboardId}/panel" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Total Cases",
    "panelType": "DashboardPanelSingleValue",
    "blockId": "calculator-data-information-guid",
    "row": 0,
    "column": 0,
    "width": 2,
    "height": 1,
    "settings": "{\"tableIndex\":0,\"labelColumnName\":\"Name\",\"labelName\":\"Total Case Count\",\"valueColumnName\":\"Value\",\"formatText\":\"N0\"}"
  }'

Horizontale Staafgrafiek Maken

curl -X POST "https://your-mindzie-instance.com/api/{tenantId}/{projectId}/dashboard/{dashboardId}/panel" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Activity Distribution",
    "panelType": "DashboardPanelHorizontalBarChart",
    "blockId": "calculator-activity-frequency-guid",
    "row": 1,
    "column": 0,
    "width": 6,
    "height": 3,
    "settings": "{\"tableIndex\":0,\"columnNames\":[\"ActivityName\",\"Count\"],\"sortColumnName\":\"Count\",\"sortAscending\":false,\"maxRows\":10}"
  }'

Volledig Calculator Paneel Maken

curl -X POST "https://your-mindzie-instance.com/api/{tenantId}/{projectId}/dashboard/{dashboardId}/panel" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Case Count",
    "panelType": "DashboardPanelCalculator",
    "blockId": "calculator-case-count-guid",
    "row": 0,
    "column": 2,
    "width": 2,
    "height": 1
  }'

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';

async function getDashboardPanels(dashboardId, token) {
  const url = `${BASE_URL}/api/${TENANT_ID}/${PROJECT_ID}/dashboard/${dashboardId}/panels`;

  const response = await fetch(url, {
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json'
    }
  });

  if (response.ok) {
    return await response.json();
  } else if (response.status === 404) {
    throw new Error('Dashboard niet gevonden');
  } else {
    throw new Error(`Kan panelen niet ophalen: ${response.status}`);
  }
}

async function createDashboardPanel(dashboardId, panelData, token) {
  const url = `${BASE_URL}/api/${TENANT_ID}/${PROJECT_ID}/dashboard/${dashboardId}/panel`;

  const response = await fetch(url, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(panelData)
  });

  if (response.ok) {
    return await response.json();
  } else {
    const error = await response.json();
    throw new Error(error.Message || `Kan paneel niet aanmaken: ${response.status}`);
  }
}

// Gebruik - Panelen ophalen
const panels = await getDashboardPanels('dashboard-guid', 'your-auth-token');
console.log(`Dashboard: ${panels.dashboardId}`);
console.log(`Panelen: ${panels.panels.length}`);

// Gebruik - KPI paneel aanmaken
const newPanel = await createDashboardPanel('dashboard-guid', {
  title: 'Total Cases',
  panelType: 'DashboardPanelSingleValue',
  blockId: 'calculator-data-information-guid',
  row: 0,
  column: 0,
  width: 2,
  height: 1,
  settings: JSON.stringify({
    tableIndex: 0,
    labelColumnName: 'Name',
    labelName: 'Total Case Count',
    valueColumnName: 'Value',
    formatText: 'N0'
  })
}, 'your-auth-token');

console.log(`Aangemaakt paneel: ${newPanel.panelId}`);

Python

import requests
import json

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

def get_dashboard_panels(dashboard_id, token):
    """Haal alle panelen in een dashboard op."""
    url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/dashboard/{dashboard_id}/panels'
    headers = {
        'Authorization': f'Bearer {token}',
        'Content-Type': 'application/json'
    }

    response = requests.get(url, headers=headers)

    if response.ok:
        return response.json()
    elif response.status_code == 404:
        raise Exception('Dashboard niet gevonden')
    else:
        raise Exception(f'Kan panelen niet ophalen: {response.status_code}')


def create_dashboard_panel(dashboard_id, panel_data, token):
    """Maak een nieuw paneel aan in een dashboard."""
    url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/dashboard/{dashboard_id}/panel'
    headers = {
        'Authorization': f'Bearer {token}',
        'Content-Type': 'application/json'
    }

    response = requests.post(url, headers=headers, json=panel_data)

    if response.ok:
        return response.json()
    else:
        error = response.json()
        raise Exception(error.get('Message', f'Kan paneel niet aanmaken: {response.status_code}'))


# Gebruik - Panelen ophalen
panels = get_dashboard_panels('dashboard-guid', 'your-auth-token')
print(f"Dashboard: {panels['dashboardId']}")
print(f"Aantal panelen: {len(panels['panels'])}")

# Gebruik - KPI paneel aanmaken
settings = {
    'tableIndex': 0,
    'labelColumnName': 'Name',
    'labelName': 'Total Case Count',
    'valueColumnName': 'Value',
    'formatText': 'N0'
}

new_panel = create_dashboard_panel('dashboard-guid', {
    'title': 'Total Cases',
    'panelType': 'DashboardPanelSingleValue',
    'blockId': 'calculator-data-information-guid',
    'row': 0,
    'column': 0,
    'width': 2,
    'height': 1,
    'settings': json.dumps(settings)
}, 'your-auth-token')

print(f"Aangemaakt paneel: {new_panel['panelId']}")

C#

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

public class DashboardPanelsResponse
{
    public Guid DashboardId { get; set; }
    public List<PanelInfo> Panels { get; set; }
}

public class PanelInfo
{
    public Guid PanelId { get; set; }
    public string Name { get; set; }
    public string PanelType { get; set; }
    public string Position { get; set; }
    public int Width { get; set; }
    public int Height { get; set; }
    public string Configuration { get; set; }
}

public class CreatePanelRequest
{
    public string Title { get; set; }
    public string Description { get; set; }
    public string PanelType { get; set; }
    public Guid BlockId { get; set; }
    public int Row { get; set; }
    public int Column { get; set; }
    public int Width { get; set; }
    public int Height { get; set; }
    public string Settings { get; set; }
}

public class CreatePanelResponse
{
    public Guid PanelId { get; set; }
    public string Title { get; set; }
    public string DashboardPanelClassName { get; set; }
    public int Row { get; set; }
    public int Column { get; set; }
    public int Width { get; set; }
    public int Height { get; set; }
    public Guid BlockId { get; set; }
}

public class DashboardPanelClient
{
    private readonly HttpClient _httpClient;
    private readonly string _baseUrl;
    private readonly Guid _tenantId;
    private readonly Guid _projectId;
    private readonly JsonSerializerOptions _jsonOptions;

    public DashboardPanelClient(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);
        _jsonOptions = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
    }

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

        if (response.IsSuccessStatusCode)
        {
            var json = await response.Content.ReadAsStringAsync();
            return JsonSerializer.Deserialize<DashboardPanelsResponse>(json, _jsonOptions);
        }
        else if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
        {
            throw new Exception($"Dashboard {dashboardId} niet gevonden");
        }

        throw new Exception($"Kan panelen niet ophalen: {response.StatusCode}");
    }

    public async Task<CreatePanelResponse> CreatePanelAsync(Guid dashboardId, CreatePanelRequest request)
    {
        var url = $"{_baseUrl}/api/{_tenantId}/{_projectId}/dashboard/{dashboardId}/panel";
        var json = JsonSerializer.Serialize(request, _jsonOptions);
        var content = new StringContent(json, Encoding.UTF8, "application/json");

        var response = await _httpClient.PostAsync(url, content);

        if (response.IsSuccessStatusCode)
        {
            var responseJson = await response.Content.ReadAsStringAsync();
            return JsonSerializer.Deserialize<CreatePanelResponse>(responseJson, _jsonOptions);
        }

        var errorJson = await response.Content.ReadAsStringAsync();
        throw new Exception($"Kan paneel niet aanmaken: {errorJson}");
    }
}

// Gebruik
var client = new DashboardPanelClient(
    "https://your-mindzie-instance.com",
    Guid.Parse("12345678-1234-1234-1234-123456789012"),
    Guid.Parse("87654321-4321-4321-4321-210987654321"),
    "your-access-token");

// Panelen ophalen
var panels = await client.GetDashboardPanelsAsync(Guid.Parse("dashboard-guid"));
Console.WriteLine($"Dashboard: {panels.DashboardId}");
foreach (var panel in panels.Panels)
{
    Console.WriteLine($"- {panel.Name} ({panel.PanelType})");
}

// KPI paneel aanmaken
var newPanel = await client.CreatePanelAsync(Guid.Parse("dashboard-guid"), new CreatePanelRequest
{
    Title = "Total Cases",
    PanelType = "DashboardPanelSingleValue",
    BlockId = Guid.Parse("calculator-data-information-guid"),
    Row = 0,
    Column = 0,
    Width = 2,
    Height = 1,
    Settings = JsonSerializer.Serialize(new
    {
        tableIndex = 0,
        labelColumnName = "Name",
        labelName = "Total Case Count",
        valueColumnName = "Value",
        formatText = "N0"
    })
});

Console.WriteLine($"Aangemaakt paneel: {newPanel.PanelId}");

Belangrijke Opmerkingen

API Mogelijkheden

• Leestoegang: Gebruik GET endpoint om paneelconfiguraties op te halen
• Maaaktoegang: Gebruik POST endpoint om nieuwe panelen te creëren met automatische selectorblok-aanmaak
• Wijzigtoegang: Panenwijziging gebeurt momenteel via de mindzieStudio UI
• Verwijdertoegang: Paneelverwijdering gebeurt momenteel via de mindzieStudio UI

Configuratie Parsing

Het veld configuration bevat een JSON-string die geparsed moet worden om instellingen te lezen.

Indelingssysteem

Paneelposities gebruiken een rij/kolom gridsysteem met flexibele grootte. Rij- en kolomwaarden zijn 0-gebaseerd bij het aanmaken van panelen.