Bloktypen

Categorieën van Analyseblokken

Ontdek verschillende bloktypen, waaronder filters, rekenmachines en meldingsconfiguraties. Leer over de mogelijkheden van elk type, configuratie-opties en aanmaakendpunten.

Filterblokken

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

Filterblokken passen gegevensfiltercriteria toe op datasets, waardoor de data wordt gereduceerd door voorwaarden zoals datumbereiken, waarde-filters of logische expressies. Ze vormen de basis voor gerichte analyses op specifieke subsets van data.

Mogelijkheden

• Filtering op datumbereik: Data filteren binnen specifieke tijdsperiodes
• Filtering op activiteit: Bepaalde procesactiviteiten opnemen of uitsluiten
• Filtering op case-attributen: Filteren op basis van case-eigenschappen en metadata
• Filtering op waardebereik: Numerieke en tekstwaardenvoorwaarden toepassen
• Complexe logica: Meerdere filters combineren met EN/OF-operatoren

Request Body

{
  "notebookId": "660e8400-e29b-41d4-a716-446655440000",
  "blockTitle": "Filter datumbereik",
  "blockDescription": "Filtert procesdata voor de laatste 30 dagen"
}

Configuratievoorbeelden

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

// Configuratie activiteit-filter
{
  "filterType": "activity",
  "include": ["Order Created", "Payment Processed"],
  "exclude": ["System Log"]
}

// Configuratie case-attribuut filter
{
  "filterType": "caseAttribute",
  "attribute": "customerType",
  "operator": "equals",
  "value": "Premium"
}

Rekenkundige Blokken

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

Rekenkundeblokken voeren wiskundige bewerkingen en analytische berekeningen uit op datasets. Ze berekenen metrische gegevens, aggregaties, statistische maten en afgeleide waarden voor procesmininganalyses.

Mogelijkheden

• Duur berekeningen: Proces cyclustijden en doorlooptijden
• Frequentie analyse: Activiteitvoorkomens en patronen
• Prestatiemaatstaven: Doorvoer, efficiëntie en benutting
• Statistische analyse: Gemiddelde, mediaan, percentielen en verdelingen
• Aangepaste formules: Complexe wiskundige expressies en KPI’s

Request Body

{
  "notebookId": "660e8400-e29b-41d4-a716-446655440000",
  "blockTitle": "Procesduurcalculator",
  "blockDescription": "Berekent gemiddelde case-duur en cyclustijden"
}

Configuratievoorbeelden

// Configuratie duur berekening
{
  "calculationType": "duration",
  "startActivity": "Order Created",
  "endActivity": "Order Completed",
  "unit": "hours",
  "aggregation": "average"
}

// Configuratie frequentie berekening
{
  "calculationType": "frequency",
  "groupBy": "activity",
  "timeWindow": "daily",
  "metric": "count"
}

// Configuratie aangepaste KPI berekening
{
  "calculationType": "custom",
  "formula": "(completedCases / totalCases) * 100",
  "resultUnit": "percentage",
  "name": "Voltooiingspercentage"
}

Alert Blokken

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

Alertblokken monitoren data-condities en activeren meldingen wanneer specifieke criteria zijn bereikt. Ze bieden geautomatiseerde monitoring en uitzonderingsdetectie voor procesmining workflows en compliance-eisen.

Mogelijkheden

• Drempelbewaking: Alert bij overschrijding van gedefinieerde limieten voor metrische gegevens
• Patroonherkenning: Identificeer afwijkende procesgedragspatronen
• Compliance monitoring: Volg naleving van bedrijfsregels
• Prestatiealerts: Houd SLA-overtredingen en prestatieverslechteringen in de gaten
• Realtime notificaties: Directe waarschuwingen bij kritieke situaties

Request Body

{
  "notebookId": "660e8400-e29b-41d4-a716-446655440000",
  "blockTitle": "SLA-overtredingsalert",
  "blockDescription": "Waarschuwt wanneer case-duur SLA-drempel overschrijdt"
}

Configuratievoorbeelden

// Configuratie drempelalert
{
  "alertType": "threshold",
  "metric": "caseDuration",
  "operator": "greaterThan",
  "threshold": 48,
  "unit": "hours",
  "severity": "high"
}

// Configuratie patroonafwijkingsalert
{
  "alertType": "patternDeviation",
  "baselinePattern": "Order -> Payment -> Fulfillment",
  "deviationTolerance": 0.1,
  "minOccurrences": 10
}

// Configuratie compliance alert
{
  "alertType": "compliance",
  "rule": "approvalRequired",
  "condition": "amount > 1000",
  "requiredActivity": "Manager Approval"
}

Vergelijking Bloktypen

Kies het juiste bloktype voor jouw analysetaken:

Bloktype	Primaire Doelstelling	Input	Output	Gebruikssituaties
Filter	Datareductie en focussering	Volledige dataset	Gefilterde dataset	Analyse van tijdsperiodes, specifieke procespaden
Calculator	Berekening van metrics en KPI’s	Dataset (gefilterd of volledig)	Berekende waarden/metrics	Prestatiemeting, statistische analyse
Alert	Monitoring en meldingen	Metrics of dataset	Alertcondities/meldingen	SLA monitoring, detectie uitzonderingen

Voorbeeld: Compleet Blok Workflow

Dit voorbeeld toont het aanmaken van verschillende bloktypen voor een uitgebreide analyse:

// Maak een filterblok aan om te focussen op recente data
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 laatste 30 dagen',
      blockDescription: 'Focus analyse op recente procesdata'
    })
  });
  return await response.json();
};

// Maak een rekenblok aan om metrics te berekenen
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: 'Gemiddelde duur calculator',
      blockDescription: 'Bereken gemiddelde case verwerkingsduur'
    })
  });
  return await response.json();
};

// Maak een alertblok aan voor monitoring
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-overtredingsalert',
      blockDescription: 'Monitor SLA-overtredingen'
    })
  });
  return await response.json();
};

// Bouw volledige analyse workflow
const buildAnalysisWorkflow = async (notebookId) => {
  try {
    // 1. Filter data naar recente periode
    const filterBlock = await createDateFilter(notebookId);
    console.log('Filterblok aangemaakt:', filterBlock.blockId);

    // 2. Bereken prestatie metrics
    const calculatorBlock = await createDurationCalculator(notebookId);
    console.log('Rekenblok aangemaakt:', calculatorBlock.blockId);

    // 3. Stel monitoring alerts in
    const alertBlock = await createSLAAlert(notebookId);
    console.log('Alertblok aangemaakt:', alertBlock.blockId);

    return {
      filter: filterBlock,
      calculator: calculatorBlock,
      alert: alertBlock
    };
  } catch (error) {
    console.error('Fout bij het bouwen van workflow:', error);
    throw error;
  }
};

Python Implementatie

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]:
        """Maak een filterblok aan voor datareductie"""
        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]:
        """Maak een rekenblok aan voor metric berekeningen"""
        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]:
        """Maak een alertblok aan voor monitoring"""
        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]:
        """Maak een volledige analyse pijplijn aan met alle bloktypen"""
        pipeline = {}

        # Maak filterblok aan
        pipeline['filter'] = self.create_filter_block(
            notebook_id,
            'Datafilter',
            'Filter dataset voor analysekader'
        )

        # Maak rekenblok aan
        pipeline['calculator'] = self.create_calculator_block(
            notebook_id,
            'Prestatiecalculator',
            'Bereken kernprestatiemetrics'
        )

        # Maak alertblok aan
        pipeline['alert'] = self.create_alert_block(
            notebook_id,
            'Prestatiealert',
            'Monitor prestatiedrempels'
        )

        return pipeline

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

# Maak volledige analyse pijplijn aan
pipeline = block_manager.create_analysis_pipeline('notebook-guid')
print(f"Pijplijn aangemaakt met {len(pipeline)} blokken")

Belangrijke Opmerkingen

Blokafhankelijkheden: Blokken kunnen aan elkaar gekoppeld worden waarbij filterblokken data reduceren, rekenblokken metrics berekenen en alertblokken de resultaten monitoren op uitzonderingen.

Beste Praktijk: Begin met filterblokken om de datareikwijdte te beperken, gebruik daarna rekenblokken voor analyse en voeg tot slot alertblokken toe voor continue monitoring en meldingen.