Bloktype Ontdekking

Gecentraliseerd Bloktypen Endpoint

GET /api/tenant/{tenantId}/project/{projectId}/block/types/all

Ontdek alle beschikbare bloktypes (filters, calculators en verrijkingen) in één enkele API-aanroep. Dit gecentraliseerde endpoint is de aanbevolen manier om volledige informatie te verkrijgen over alle analysemogelijkheden beschikbaar in mindzieStudio.

Waarom het Gecentraliseerde Endpoint Gebruiken?

Het gecentraliseerde endpoint biedt verschillende voordelen ten opzichte van het opvragen van individuele categorie-endpoints:

Enkele Aanvraag: Ontvang alle bloktypes in één API-aanroep in plaats van meerdere verzoeken
Volledige Metadata: Inclusief verrijkingen die niet beschikbaar zijn via categorie-specifieke endpoints
Gegroepeerde Response: Resultaten zijn geordend per blokcategorie voor eenvoudige verwerking
Rijke Metadata: Elk bloktype bevat documentatie-URL's, gebruiksaanwijzingen en gerelateerde blokken
AI-integratie: Geoptimaliseerd voor AI-programmeerassistenten en MCP-server integratie

Aanvraag

GET /api/tenant/{tenantId}/project/{projectId}/block/types/all
Authorization: Bearer {token}

Padparameters

Parameter	Type	Verplicht	Omschrijving
`tenantId`	GUID	Ja	De tenant-identificatie
`projectId`	GUID	Ja	De project-identificatie

Response

Response-structuur

{
  "BlockTypes": [...],
  "Categories": ["Attribute Filters", "Time Filters", "Calculators", ...],
  "TotalCount": 45,
  "ByBlockCategory": {
    "Filter": [...],
    "Calculator": [...],
    "Enrichment": [...]
  }
}

Response-velden

Veld	Type	Omschrijving
`BlockTypes`	Array	Alle bloktypes met volledige metadata
`Categories`	Array	Lijst van alle unieke categorieën
`TotalCount`	Integer	Totaal aantal beschikbare bloktypes
`ByBlockCategory`	Object	Bloktypes gegroepeerd per Filter/Calculator/Verrijking

Bloktype-object

Elk bloktype in de BlockTypes array bevat:

Veld	Type	Omschrijving
`OperatorName`	String	Unieke identificatie van het bloktype (bijv. "CaseAttributeFilter")
`DisplayName`	String	Menselijk leesbare naam die in de UI wordt getoond
`Description`	String	Korte beschrijving van wat het blok doet
`Category`	String	Functionele categorie (bijv. "Attribute Filters", "Time Filters")
`BlockType`	String	Topniveau classificatie: "Filter", "Calculator" of "Enrichment"
`DocumentationUrl`	String	URL naar de documentatiepagina voor dit bloktype
`UsageFrequency`	String	Hoe vaak dit bloktype wordt gebruikt ("High", "Medium", "Low")
`ExcludeFromOrFilter`	Boolean	Of dit filter gebruikt kan worden in OR-combinaties
`AutoTitleEnabled`	Boolean	Of automatische titelgeneratie ondersteund wordt
`SupportedDisplayTypes`	Array	Ondersteunde visualisatietypes voor resultaten
`UsageNotes`	String	Aanvullende richtlijnen voor het gebruik van dit bloktype
`RelatedBlocks`	Array	Lijst van gerelateerde bloktypes
`CommonUseCases`	Array	Typische scenario's waarin dit bloktype nuttig is

Voorbeeld Response

{
  "BlockTypes": [
    {
      "OperatorName": "CaseAttributeFilter",
      "DisplayName": "Case Attribute Filter",
      "Description": "Filter cases op basis van attribuutwaarden zoals klanttype, regio of prioriteitsniveau",
      "Category": "Attribute Filters",
      "BlockType": "Filter",
      "DocumentationUrl": "/mindzie_studio/filters/case-attribute-filter",
      "UsageFrequency": "High",
      "ExcludeFromOrFilter": false,
      "AutoTitleEnabled": true,
      "SupportedDisplayTypes": ["table", "chart"],
      "UsageNotes": "Ondersteunt exacte match, bevat en regex patronen",
      "RelatedBlocks": ["EventAttributeFilter", "CaseIdFilter"],
      "CommonUseCases": [
        "Filteren op klantsegment",
        "Focus op specifieke regio's",
        "Analyseer cases met hoge prioriteit"
      ]
    },
    {
      "OperatorName": "CaseDurationCalculator",
      "DisplayName": "Case Duration Calculator",
      "Description": "Bereken de totale duur van cases van begin tot eind",
      "Category": "Time Calculators",
      "BlockType": "Calculator",
      "DocumentationUrl": "/mindzie_studio/calculators/case-duration-calculator",
      "UsageFrequency": "High",
      "ExcludeFromOrFilter": false,
      "AutoTitleEnabled": true,
      "SupportedDisplayTypes": ["histogram", "table", "boxplot"],
      "UsageNotes": "Duur wordt berekend in de tijdseenheid die in het project is ingesteld",
      "RelatedBlocks": ["ActivityDurationCalculator", "WaitTimeCalculator"],
      "CommonUseCases": [
        "Analyseer doorlooptijden van cases",
        "Identificeer langzaam lopende cases",
        "Vergelijk proces efficiëntie"
      ]
    },
    {
      "OperatorName": "CaseStageCalculator",
      "DisplayName": "Case Stage Calculator",
      "Description": "Ken fase-labels toe aan cases op basis van activiteitspatronen en regels",
      "Category": "Stage Analysis",
      "BlockType": "Enrichment",
      "DocumentationUrl": "/mindzie_studio/enrichments/case-stage-calculator",
      "UsageFrequency": "Medium",
      "ExcludeFromOrFilter": false,
      "AutoTitleEnabled": true,
      "SupportedDisplayTypes": ["sankey", "table"],
      "UsageNotes": "Vereist dat fase-definities zijn geconfigureerd",
      "RelatedBlocks": ["CaseStatusEnrichment", "MilestoneDetector"],
      "CommonUseCases": [
        "Volg de voortgang van cases door fases",
        "Identificeer knelpunten in fases",
        "Monitor faseovergangen"
      ]
    }
  ],
  "Categories": [
    "Attribute Filters",
    "Time Filters",
    "Activity Filters",
    "Time Calculators",
    "Count Calculators",
    "Stage Analysis",
    "Data Enrichment"
  ],
  "TotalCount": 45,
  "ByBlockCategory": {
    "Filter": [
      { "OperatorName": "CaseAttributeFilter", "DisplayName": "Case Attribute Filter", ... },
      { "OperatorName": "DateRangeFilter", "DisplayName": "Date Range Filter", ... }
    ],
    "Calculator": [
      { "OperatorName": "CaseDurationCalculator", "DisplayName": "Case Duration Calculator", ... }
    ],
    "Enrichment": [
      { "OperatorName": "CaseStageCalculator", "DisplayName": "Case Stage Calculator", ... }
    ]
  }
}

JavaScript Voorbeeld

// Ontdek alle beschikbare bloktypes
async function discoverAllBlockTypes(tenantId, projectId, token) {
  const response = await fetch(
    `/api/tenant/${tenantId}/project/${projectId}/block/types/all`,
    {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json'
      }
    }
  );

  if (!response.ok) {
    throw new Error(`Ontdekken van bloktypes mislukt: ${response.status}`);
  }

  const data = await response.json();

  console.log(`Ontdekt ${data.TotalCount} bloktypes:`);
  console.log(`- Filters: ${data.ByBlockCategory.Filter.length}`);
  console.log(`- Calculators: ${data.ByBlockCategory.Calculator.length}`);
  console.log(`- Verrijkingen: ${data.ByBlockCategory.Enrichment.length}`);

  return data;
}

// Vind bloktypes per categorie
function getBlockTypesByCategory(allTypes, category) {
  return allTypes.BlockTypes.filter(bt => bt.Category === category);
}

// Vind bloktypes met hoog gebruik
function getHighUsageBlockTypes(allTypes) {
  return allTypes.BlockTypes.filter(bt => bt.UsageFrequency === 'High');
}

// Gebruik
const blockTypes = await discoverAllBlockTypes(tenantId, projectId, token);
const timeFilters = getBlockTypesByCategory(blockTypes, 'Time Filters');
const popular = getHighUsageBlockTypes(blockTypes);

Python Voorbeeld

import requests
from typing import Dict, List, Any

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

    def discover_all(self) -> Dict[str, Any]:
        """Ontdek alle beschikbare bloktypes"""
        url = f"{self.base_url}/api/tenant/{self.tenant_id}/project/{self.project_id}/block/types/all"
        response = requests.get(url, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def get_filters(self) -> List[Dict]:
        """Haal alle filter-bloktypes op"""
        data = self.discover_all()
        return data.get('ByBlockCategory', {}).get('Filter', [])

    def get_calculators(self) -> List[Dict]:
        """Haal alle calculator-bloktypes op"""
        data = self.discover_all()
        return data.get('ByBlockCategory', {}).get('Calculator', [])

    def get_enrichments(self) -> List[Dict]:
        """Haal alle verrijking-bloktypes op"""
        data = self.discover_all()
        return data.get('ByBlockCategory', {}).get('Enrichment', [])

    def find_by_use_case(self, keyword: str) -> List[Dict]:
        """Vind bloktypes die overeenkomen met een gebruiksscenario keyword"""
        data = self.discover_all()
        results = []
        for block_type in data['BlockTypes']:
            use_cases = block_type.get('CommonUseCases', [])
            if any(keyword.lower() in uc.lower() for uc in use_cases):
                results.append(block_type)
        return results

# Gebruik
discovery = BlockTypeDiscovery(
    'https://your-mindzie-instance.com',
    'tenant-guid',
    'project-guid',
    'your-auth-token'
)

# Ontdek alle bloktypes
all_types = discovery.discover_all()
print(f"Totaal bloktypes: {all_types['TotalCount']}")

# Haal bloktypes per categorie op
filters = discovery.get_filters()
calculators = discovery.get_calculators()
enrichments = discovery.get_enrichments()

# Vind bloktypes voor duur-analyse
duration_blocks = discovery.find_by_use_case('duration')

Categorie-specifieke Endpoints

Het gecentraliseerde endpoint wordt aanbevolen voor de meeste gebruiksscenario's. Echter, categorie-specifieke endpoints zijn nog steeds beschikbaar:

Endpoint	Beschrijving
`GET /block/types?category=filters`	Alleen filters
`GET /block/types?category=calculators`	Alleen calculators
`GET /block/types/{operatorName}`	Details van één bloktype
`GET /block/types/{operatorName}/schema`	Configuratieschema voor een bloktype

MCP Server Integratie

AI-programmeerassistenten kunnen de mindzieAPI MCP-server gebruiken om programmatisch bloktypes te ontdekken:

mindzie_list_block_types category="unified"

Deze MCP-tool-aanroep retourneert dezelfde gecentraliseerde response, waardoor AI-tools eenvoudig alle beschikbare analysemogelijkheden kunnen begrijpen.

Zie MCP Server Integratie voor volledige documentatie.

Gebruiksscenario's

Dynamische UIs Bouwen

Gebruik het gecentraliseerde endpoint om selectie-menu's voor bloktypes te vullen met volledige informatie over elke optie.

AI-gedreven Analyse

AI-assistenten kunnen beschikbare analysemogelijkheden ontdekken en passende bloktypes voorstellen op basis van gebruikersdoelen.

Documentatiegeneratie

Genereer dynamische documentatie door te itereren over alle bloktypes en hun metadata.

Capaciteit Auditing

Som alle beschikbare analysemogelijkheden voor een project op om volledige dekking te waarborgen.