Blocktypen

Kategorien von Analyseblöcken

Entdecken Sie verschiedene Blocktypen, darunter Filter, Rechner und Alarmkonfigurationen. Erfahren Sie mehr über die Fähigkeiten, Konfigurationsmöglichkeiten und Erstellungsendpunkte jedes Typs.

Filterblöcke

POST /api/{tenantId}/{projectId}/block/filter

Filterblöcke wenden Datenfilterkriterien auf Datensätze an und reduzieren Daten durch Bedingungen wie Datumsbereiche, Wertefilter oder logische Ausdrücke. Sie bilden die Grundlage für fokussierte Analysen auf bestimmte Teilmengen von Daten.

Fähigkeiten

• Datumsbereichsfilter: Filterung von Daten innerhalb bestimmter Zeiträume
• Aktivitätsfilter: Ein- oder Ausschluss spezifischer Prozessaktivitäten
• Fallattributfilter: Filterung basierend auf Fall-Eigenschaften und Metadaten
• Wertebereichsfilter: Anwendung numerischer und textlicher Wertbedingungen
• Komplexe Logik: Kombination mehrerer Filter mit UND/ODER-Verknüpfungen

Anfrageinhalt

{
  "notebookId": "660e8400-e29b-41d4-a716-446655440000",
  "blockTitle": "Datumsbereichsfilter",
  "blockDescription": "Filtert Prozessdaten der letzten 30 Tage"
}

Konfigurationsbeispiele

// Konfiguration Datumsbereichsfilter
{
  "filterType": "dateRange",
  "startDate": "2024-01-01T00:00:00Z",
  "endDate": "2024-01-31T23:59:59Z",
  "dateField": "timestamp"
}

// Konfiguration Aktivitätsfilter
{
  "filterType": "activity",
  "include": ["Order Created", "Payment Processed"],
  "exclude": ["System Log"]
}

// Konfiguration Fallattributfilter
{
  "filterType": "caseAttribute",
  "attribute": "customerType",
  "operator": "equals",
  "value": "Premium"
}

Rechnerblöcke

POST /api/{tenantId}/{projectId}/block/calculator

Rechnerblöcke führen mathematische Operationen und analytische Berechnungen auf Datensätzen durch. Sie ermitteln Kennzahlen, Aggregationen, statistische Maße und abgeleitete Werte für die Prozessmining-Analyse.

Fähigkeiten

• Dauerberechnungen: Prozesszykluszeiten und Durchlaufzeiten
• Häufigkeitsanalyse: Auftretensraten und Muster von Aktivitäten
• Leistungskennzahlen: Durchsatz, Effizienz und Auslastung
• Statistische Analyse: Mittelwerte, Mediane, Perzentile und Verteilungen
• Benutzerdefinierte Formeln: Komplexe mathematische Ausdrücke und KPIs

Anfrageinhalt

{
  "notebookId": "660e8400-e29b-41d4-a716-446655440000",
  "blockTitle": "Berechnung der Prozessdauer",
  "blockDescription": "Berechnet durchschnittliche Falldauer und Zykluszeiten"
}

Konfigurationsbeispiele

// Konfiguration Dauerberechnung
{
  "calculationType": "duration",
  "startActivity": "Order Created",
  "endActivity": "Order Completed",
  "unit": "hours",
  "aggregation": "average"
}

// Konfiguration Häufigkeitsberechnung
{
  "calculationType": "frequency",
  "groupBy": "activity",
  "timeWindow": "daily",
  "metric": "count"
}

// Konfiguration benutzerdefinierte KPI-Berechnung
{
  "calculationType": "custom",
  "formula": "(completedCases / totalCases) * 100",
  "resultUnit": "percentage",
  "name": "Fertigstellungsrate"
}

Alarmblöcke

POST /api/{tenantId}/{projectId}/block/alert

Alarmblöcke überwachen Datenbedingungen und lösen Benachrichtigungen aus, wenn bestimmte Kriterien erfüllt sind. Sie bieten automatisiertes Monitoring und Ausnahmeerkennung für Prozessmining-Workflows und Compliance-Anforderungen.

Fähigkeiten

• Schwellenwertüberwachung: Alarm bei Überschreitung definierter Grenzwerte
• Musterdetektion: Erkennung ungewöhnlicher Prozessverhaltensmuster
• Compliance-Überwachung: Überwachung der Einhaltung von Geschäftsregeln
• Leistungsalarme: Überwachung von SLA-Verstößen und Leistungsabfällen
• Echtzeitbenachrichtigungen: Sofortige Alarme bei kritischen Zuständen

Anfrageinhalt

{
  "notebookId": "660e8400-e29b-41d4-a716-446655440000",
  "blockTitle": "SLA-Verstoß-Alarm",
  "blockDescription": "Alarmiert, wenn Falldauer SLA-Grenzwert überschreitet"
}

Konfigurationsbeispiele

// Konfiguration Schwellenwert-Alarm
{
  "alertType": "threshold",
  "metric": "caseDuration",
  "operator": "greaterThan",
  "threshold": 48,
  "unit": "hours",
  "severity": "high"
}

// Konfiguration Musterabweichungs-Alarm
{
  "alertType": "patternDeviation",
  "baselinePattern": "Order -> Payment -> Fulfillment",
  "deviationTolerance": 0.1,
  "minOccurrences": 10
}

// Konfiguration Compliance-Alarm
{
  "alertType": "compliance",
  "rule": "approvalRequired",
  "condition": "amount > 1000",
  "requiredActivity": "Manager Approval"
}

Vergleich der Blocktypen

Wählen Sie den passenden Blocktyp für Ihre Analyseanforderungen:

Blocktyp	Hauptzweck	Eingabe	Ausgabe	Anwendungsfälle
Filter	Datenreduktion und Fokussierung	Gesamter Datensatz	Gefilterter Datensatz	Zeitraumanalyse, spezifische Prozesspfade
Rechner	Berechnung von Kennzahlen und KPIs	Datensatz (gefiltert oder ganz)	Berechnete Werte/Kennzahlen	Leistungsbewertung, statistische Analyse
Alarm	Monitoring und Benachrichtigungen	Kennzahlen oder Datensatz	Alarmbedingungen/Benachrichtigungen	SLA-Überwachung, Ausnahmeerkennung

Beispiel: Vollständiger Block-Workflow

Dieses Beispiel zeigt die Erstellung verschiedener Blocktypen für eine umfassende Analyse:

// Erstellen eines Filterblocks zur Fokussierung auf aktuelle Daten
const createDateFilter = async (notebookId) => {
  const response = await fetch(`/api/${tenantId}/${projectId}/block/filter`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`
    },
    body: JSON.stringify({
      notebookId: notebookId,
      blockTitle: 'Filter letzte 30 Tage',
      blockDescription: 'Fokussiert die Analyse auf aktuelle Prozessdaten'
    })
  });
  return await response.json();
};

// Erstellen eines Rechnerblocks zur Berechnung von Kennzahlen
const createDurationCalculator = async (notebookId) => {
  const response = await fetch(`/api/${tenantId}/${projectId}/block/calculator`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`
    },
    body: JSON.stringify({
      notebookId: notebookId,
      blockTitle: 'Durchschnittlicher Dauerrechner',
      blockDescription: 'Berechnet durchschnittliche Bearbeitungszeit pro Fall'
    })
  });
  return await response.json();
};

// Erstellen eines Alarmblocks zur Überwachung
const createSLAAlert = async (notebookId) => {
  const response = await fetch(`/api/${tenantId}/${projectId}/block/alert`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${token}`
    },
    body: JSON.stringify({
      notebookId: notebookId,
      blockTitle: 'SLA-Verstoß-Alarm',
      blockDescription: 'Überwacht SLA-Verletzungen'
    })
  });
  return await response.json();
};

// Aufbau des vollständigen Analyse-Workflows
const buildAnalysisWorkflow = async (notebookId) => {
  try {
    // 1. Daten auf aktuellen Zeitraum filtern
    const filterBlock = await createDateFilter(notebookId);
    console.log('Filterblock erstellt:', filterBlock.blockId);

    // 2. Leistungskennzahlen berechnen
    const calculatorBlock = await createDurationCalculator(notebookId);
    console.log('Rechnerblock erstellt:', calculatorBlock.blockId);

    // 3. Überwachungsalarme einrichten
    const alertBlock = await createSLAAlert(notebookId);
    console.log('Alarmblock erstellt:', alertBlock.blockId);

    return {
      filter: filterBlock,
      calculator: calculatorBlock,
      alert: alertBlock
    };
  } catch (error) {
    console.error('Fehler beim Aufbau des Workflows:', error);
    throw error;
  }
};

Python-Implementierung

import requests
from typing import Dict, Any

class BlockTypeManager:
    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 create_filter_block(self, notebook_id: str, title: str, description: str) -> Dict[str, Any]:
        """Erstellt einen Filterblock zur Datenreduktion"""
        url = f"{self.base_url}/api/{self.tenant_id}/{self.project_id}/block/filter"
        payload = {
            'notebookId': notebook_id,
            'blockTitle': title,
            'blockDescription': description
        }
        response = requests.post(url, json=payload, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def create_calculator_block(self, notebook_id: str, title: str, description: str) -> Dict[str, Any]:
        """Erstellt einen Rechnerblock zur Berechnung von Kennzahlen"""
        url = f"{self.base_url}/api/{self.tenant_id}/{self.project_id}/block/calculator"
        payload = {
            'notebookId': notebook_id,
            'blockTitle': title,
            'blockDescription': description
        }
        response = requests.post(url, json=payload, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def create_alert_block(self, notebook_id: str, title: str, description: str) -> Dict[str, Any]:
        """Erstellt einen Alarmblock zur Überwachung"""
        url = f"{self.base_url}/api/{self.tenant_id}/{self.project_id}/block/alert"
        payload = {
            'notebookId': notebook_id,
            'blockTitle': title,
            'blockDescription': description
        }
        response = requests.post(url, json=payload, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def create_analysis_pipeline(self, notebook_id: str) -> Dict[str, Any]:
        """Erstellt eine vollständige Analyse-Pipeline mit allen Blocktypen"""
        pipeline = {}

        # Erstelle Filterblock
        pipeline['filter'] = self.create_filter_block(
            notebook_id,
            'Datenfilter',
            'Filtert Datensatz für Analyseumfang'
        )

        # Erstelle Rechnerblock
        pipeline['calculator'] = self.create_calculator_block(
            notebook_id,
            'Leistungsrechner',
            'Berechnet wichtige Leistungskennzahlen'
        )

        # Erstelle Alarmblock
        pipeline['alert'] = self.create_alert_block(
            notebook_id,
            'Leistungsalarm',
            'Überwacht Leistungsgrenzen'
        )

        return pipeline

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

# Erstelle vollständige Analyse-Pipeline
pipeline = block_manager.create_analysis_pipeline('notebook-guid')
print(f"Pipeline mit {len(pipeline)} Blöcken erstellt")

Wichtige Hinweise

Blockabhängigkeiten: Blöcke können miteinander verknüpft werden, wobei Filterblöcke Daten einschränken, Rechnerblöcke Kennzahlen berechnen und Alarmblöcke die Ergebnisse auf Ausnahmen überwachen.

Best Practice: Beginnen Sie mit Filterblöcken zur Eingrenzung des Datenumfangs, verwenden Sie dann Rechnerblöcke für die Analyse und ergänzen Sie abschließend Alarmblöcke für die kontinuierliche Überwachung und Benachrichtigung.