Block Typ Entdeckung

Einheitlicher Blocktypen-Endpunkt

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

Entdecken Sie alle verfügbaren Blocktypen (Filter, Rechner und Anreicherungen) mit einem einzigen API-Aufruf. Dieser einheitliche Endpunkt ist der empfohlene Weg, vollständige Informationen über alle Analysefähigkeiten, die in mindzieStudio verfügbar sind, abzurufen.

Warum den einheitlichen Endpunkt verwenden?

Der einheitliche Endpunkt bietet gegenüber der Abfrage einzelner Kategorien folgende Vorteile:

Einzelner Request: Erhalten Sie alle Blocktypen in einem API-Aufruf statt in mehreren Anfragen
Vollständige Metadaten: Beinhaltet Anreicherungen, die über kategoriespezifische Endpunkte nicht verfügbar sind
Gruppierte Antwort: Ergebnisse sind nach Blockkategorie organisiert für eine einfache Verarbeitung
Reiche Metadaten: Jeder Blocktyp enthält Dokumentations-URLs, Nutzungshinweise und verwandte Blöcke
KI-Integration: Optimiert für KI-Coding-Assistenten und MCP-Server-Integration

Anfrage

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

Pfadparameter

Parameter	Typ	Erforderlich	Beschreibung
`tenantId`	GUID	Ja	Die Mandanten-ID
`projectId`	GUID	Ja	Die Projekt-ID

Antwort

Struktur der Antwort

{
  "BlockTypes": [...],
  "Categories": ["Attributfilter", "Zeitfilter", "Rechner", ...],
  "TotalCount": 45,
  "ByBlockCategory": {
    "Filter": [...],
    "Calculator": [...],
    "Enrichment": [...]
  }
}

Antwortfelder

Feld	Typ	Beschreibung
`BlockTypes`	Array	Alle Blocktypen mit vollständigen Metadaten
`Categories`	Array	Liste aller einzigartigen Kategorien
`TotalCount`	Integer	Gesamtzahl der verfügbaren Blocktypen
`ByBlockCategory`	Objekt	Blocktypen gruppiert nach Filter/Rechner/Anreicherung

Block Typ Objekt

Jeder Blocktyp im BlockTypes-Array enthält:

Feld	Typ	Beschreibung
`OperatorName`	String	Eindeutiger Bezeichner für den Blocktyp (z.B. "CaseAttributeFilter")
`DisplayName`	String	Benutzerfreundlicher Name, der in der UI angezeigt wird
`Description`	String	Kurze Beschreibung der Funktion des Blocks
`Category`	String	Funktionale Kategorie (z.B. "Attributfilter", "Zeitfilter")
`BlockType`	String	Oberste Klassifikation: "Filter", "Calculator" oder "Enrichment"
`DocumentationUrl`	String	URL zur Dokumentationsseite für diesen Blocktyp
`UsageFrequency`	String	Wie häufig dieser Blocktyp verwendet wird ("Hoch", "Mittel", "Niedrig")
`ExcludeFromOrFilter`	Boolean	Ob dieser Filter in ODER-Kombinationen verwendet werden darf
`AutoTitleEnabled`	Boolean	Ob automatische Titelerstellung unterstützt wird
`SupportedDisplayTypes`	Array	Unterstützte Visualisierungstypen für Ergebnisse
`UsageNotes`	String	Zusätzliche Hinweise zur Verwendung dieses Blocktyps
`RelatedBlocks`	Array	Liste verwandter Blocktypen
`CommonUseCases`	Array	Typische Anwendungsfälle, in denen dieser Blocktyp nützlich ist

Beispielantwort

{
  "BlockTypes": [
    {
      "OperatorName": "CaseAttributeFilter",
      "DisplayName": "Case Attribute Filter",
      "Description": "Filtert Fälle basierend auf Attributwerten wie Kundentyp, Region oder Prioritätsstufe",
      "Category": "Attributfilter",
      "BlockType": "Filter",
      "DocumentationUrl": "/mindzie_studio/filters/case-attribute-filter",
      "UsageFrequency": "Hoch",
      "ExcludeFromOrFilter": false,
      "AutoTitleEnabled": true,
      "SupportedDisplayTypes": ["table", "chart"],
      "UsageNotes": "Unterstützt exakte Übereinstimmung, Enthalten und Regex-Muster",
      "RelatedBlocks": ["EventAttributeFilter", "CaseIdFilter"],
      "CommonUseCases": [
        "Filter nach Kundensegment",
        "Fokus auf bestimmte Regionen",
        "Analyse von Hochprioritätsfällen"
      ]
    },
    {
      "OperatorName": "CaseDurationCalculator",
      "DisplayName": "Case Duration Calculator",
      "Description": "Berechnet die Gesamtdauer von Fällen von Beginn bis Ende",
      "Category": "Zeitrechner",
      "BlockType": "Calculator",
      "DocumentationUrl": "/mindzie_studio/calculators/case-duration-calculator",
      "UsageFrequency": "Hoch",
      "ExcludeFromOrFilter": false,
      "AutoTitleEnabled": true,
      "SupportedDisplayTypes": ["histogram", "table", "boxplot"],
      "UsageNotes": "Die Dauer wird in der im Projekt konfigurierten Zeiteinheit berechnet",
      "RelatedBlocks": ["ActivityDurationCalculator", "WaitTimeCalculator"],
      "CommonUseCases": [
        "Analyse der Fallzykluszeiten",
        "Identifizierung langsam verlaufender Fälle",
        "Vergleich der Prozesseffizienz"
      ]
    },
    {
      "OperatorName": "CaseStageCalculator",
      "DisplayName": "Case Stage Calculator",
      "Description": "Weist Fällen auf Basis von Aktivitätsmustern und Regeln Phasenlabels zu",
      "Category": "Phasenanalyse",
      "BlockType": "Enrichment",
      "DocumentationUrl": "/mindzie_studio/enrichments/case-stage-calculator",
      "UsageFrequency": "Mittel",
      "ExcludeFromOrFilter": false,
      "AutoTitleEnabled": true,
      "SupportedDisplayTypes": ["sankey", "table"],
      "UsageNotes": "Erfordert konfigurierbare Phasendefinitionen",
      "RelatedBlocks": ["CaseStatusEnrichment", "MilestoneDetector"],
      "CommonUseCases": [
        "Verfolgung des Fallfortschritts durch Phasen",
        "Identifizierung von Engpassphasen",
        "Überwachung von Phasenübergängen"
      ]
    }
  ],
  "Categories": [
    "Attributfilter",
    "Zeitfilter",
    "Aktivitätsfilter",
    "Zeitrechner",
    "Zählrechner",
    "Phasenanalyse",
    "Datenanreicherung"
  ],
  "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-Beispiel

// Entdecke alle verfügbaren Blocktypen
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(`Fehler beim Entdecken der Blocktypen: ${response.status}`);
  }

  const data = await response.json();

  console.log(`Entdeckte ${data.TotalCount} Blocktypen:`);
  console.log(`- Filter: ${data.ByBlockCategory.Filter.length}`);
  console.log(`- Rechner: ${data.ByBlockCategory.Calculator.length}`);
  console.log(`- Anreicherungen: ${data.ByBlockCategory.Enrichment.length}`);

  return data;
}

// Finde Blocktypen nach Kategorie
function getBlockTypesByCategory(allTypes, category) {
  return allTypes.BlockTypes.filter(bt => bt.Category === category);
}

// Finde Blocktypen mit hoher Nutzung
function getHighUsageBlockTypes(allTypes) {
  return allTypes.BlockTypes.filter(bt => bt.UsageFrequency === 'Hoch');
}

// Verwendung
const blockTypes = await discoverAllBlockTypes(tenantId, projectId, token);
const timeFilters = getBlockTypesByCategory(blockTypes, 'Zeitfilter');
const popular = getHighUsageBlockTypes(blockTypes);

Python-Beispiel

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]:
        """Entdecke alle verfügbaren Blocktypen"""
        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]:
        """Hole alle Filter-Blocktypen"""
        data = self.discover_all()
        return data.get('ByBlockCategory', {}).get('Filter', [])

    def get_calculators(self) -> List[Dict]:
        """Hole alle Rechner-Blocktypen"""
        data = self.discover_all()
        return data.get('ByBlockCategory', {}).get('Calculator', [])

    def get_enrichments(self) -> List[Dict]:
        """Hole alle Anreicherungs-Blocktypen"""
        data = self.discover_all()
        return data.get('ByBlockCategory', {}).get('Enrichment', [])

    def find_by_use_case(self, keyword: str) -> List[Dict]:
        """Finde Blocktypen passend zu einem Anwendungsfall-Schlüsselwort"""
        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

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

# Entdecke alle Blocktypen
all_types = discovery.discover_all()
print(f"Gesamtanzahl Blocktypen: {all_types['TotalCount']}")

# Hole Blocktypen nach Kategorie
filters = discovery.get_filters()
calculators = discovery.get_calculators()
enrichments = discovery.get_enrichments()

# Finde Blocktypen für Daueranalysen
duration_blocks = discovery.find_by_use_case('duration')

Kategorien-spezifische Endpunkte

Der einheitliche Endpunkt wird für die meisten Anwendungsfälle empfohlen. Kategorien-spezifische Endpunkte sind jedoch weiterhin verfügbar:

Endpunkt	Beschreibung
`GET /block/types?category=filters`	Nur Filter
`GET /block/types?category=calculators`	Nur Rechner
`GET /block/types/{operatorName}`	Details eines einzelnen Blocktyps
`GET /block/types/{operatorName}/schema`	Konfigurationsschema für einen Blocktyp

MCP Server Integration

KI-Coding-Assistenten können den mindzieAPI MCP-Server verwenden, um Blocktypen programmatisch zu entdecken:

mindzie_list_block_types category="unified"

Dieser MCP-Tool-Aufruf gibt dieselbe einheitliche Antwort zurück, was es KI-Werkzeugen erleichtert, alle verfügbaren Analysefähigkeiten zu verstehen.

Siehe MCP Server Integration für die vollständige Dokumentation.

Anwendungsfälle

Erstellung dynamischer UIs

Verwenden Sie den einheitlichen Endpunkt, um Blocktyp-Auswahlmenüs mit vollständigen Informationen zu jeder Option zu füllen.

KI-gestützte Analyse

KI-Assistenten können verfügbare Analysefähigkeiten entdecken und basierend auf den Nutzerzielen passende Blocktypen vorschlagen.

Dokumentationserstellung

Generieren Sie dynamische Dokumentation, indem Sie alle Blocktypen und deren Metadaten durchlaufen.

Fähigkeiten-Audit

Listet alle verfügbaren Analysefähigkeiten für ein Projekt auf, um vollständige Abdeckung sicherzustellen.