Types de Blocs

Catégories de Blocs d'Analyse

Explorez différents types de blocs incluant les filtres, calculateurs et configurations d'alertes. Découvrez les capacités de chaque type, les options de configuration, et les points de création.

Blocs de Filtre

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

Les blocs de filtre appliquent des critères de filtrage aux ensembles de données, réduisant les données en appliquant des conditions telles que des plages de dates, des filtres de valeurs ou des expressions logiques. Ils constituent la base pour une analyse ciblée sur des sous-ensembles spécifiques de données.

Capacités

Filtrage par Plage de Dates : Filtrer les données dans des périodes précises
Filtrage par Activité : Inclure ou exclure des activités de processus spécifiques
Filtrage par Attribut de Cas : Filtrer selon les propriétés et métadonnées du cas
Filtrage par Plage de Valeurs : Appliquer des conditions sur les valeurs numériques et textuelles
Logique Complexe : Combiner plusieurs filtres avec des opérations ET/OU

Corps de la Requête

{
  "notebookId": "660e8400-e29b-41d4-a716-446655440000",
  "blockTitle": "Filtre Plage de Dates",
  "blockDescription": "Filtre les données du processus des 30 derniers jours"
}

Exemples de Configuration

// Configuration de filtre par plage de dates
{
  "filterType": "dateRange",
  "startDate": "2024-01-01T00:00:00Z",
  "endDate": "2024-01-31T23:59:59Z",
  "dateField": "timestamp"
}

// Configuration de filtre par activité
{
  "filterType": "activity",
  "include": ["Order Created", "Payment Processed"],
  "exclude": ["System Log"]
}

// Configuration de filtre par attribut de cas
{
  "filterType": "caseAttribute",
  "attribute": "customerType",
  "operator": "equals",
  "value": "Premium"
}

Blocs de Calculateur

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

Les blocs de calculateur effectuent des opérations mathématiques et des calculs analytiques sur les ensembles de données. Ils calculent des métriques, des agrégations, des mesures statistiques et des valeurs dérivées pour l'analyse de la fouille de processus.

Capacités

Calculs de Durée : Temps de cycle et délais des processus
Analyse de Fréquence : Taux et motifs d’occurrence des activités
Métriques de Performance : Débit, efficacité et utilisation
Analyse Statistique : Moyenne, médiane, percentiles, et distributions
Formules Personnalisées : Expressions mathématiques complexes et indicateurs clés

Corps de la Requête

{
  "notebookId": "660e8400-e29b-41d4-a716-446655440000",
  "blockTitle": "Calculateur Durée de Processus",
  "blockDescription": "Calcule la durée moyenne des cas et les temps de cycle"
}

Exemples de Configuration

// Configuration de calcul de durée
{
  "calculationType": "duration",
  "startActivity": "Order Created",
  "endActivity": "Order Completed",
  "unit": "hours",
  "aggregation": "average"
}

// Configuration de calcul de fréquence
{
  "calculationType": "frequency",
  "groupBy": "activity",
  "timeWindow": "daily",
  "metric": "count"
}

// Configuration de calcul KPI personnalisé
{
  "calculationType": "custom",
  "formula": "(completedCases / totalCases) * 100",
  "resultUnit": "percentage",
  "name": "Taux de Complétion"
}

Blocs d'Alerte

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

Les blocs d'alerte surveillent les conditions de données et déclenchent des notifications lorsque des critères spécifiques sont remplis. Ils offrent une surveillance automatisée et une détection d’exception pour les flux de travail de fouille de processus et les exigences de conformité.

Capacités

Surveillance de Seuils : Alerte lorsque les métriques dépassent des limites définies
Détection de Motifs : Identification des comportements inhabituels du processus
Surveillance de Conformité : Suivi de l’adhésion aux règles métier
Alertes de Performance : Surveillance des violations de SLA et dégradation des performances
Notifications en Temps Réel : Alertes immédiates en cas de conditions critiques

Corps de la Requête

{
  "notebookId": "660e8400-e29b-41d4-a716-446655440000",
  "blockTitle": "Alerte Violation SLA",
  "blockDescription": "Alerte lorsque la durée du cas dépasse le seuil SLA"
}

Exemples de Configuration

// Configuration d’alerte par seuil
{
  "alertType": "threshold",
  "metric": "caseDuration",
  "operator": "greaterThan",
  "threshold": 48,
  "unit": "hours",
  "severity": "high"
}

// Configuration d’alerte de déviation de motif
{
  "alertType": "patternDeviation",
  "baselinePattern": "Order -> Payment -> Fulfillment",
  "deviationTolerance": 0.1,
  "minOccurrences": 10
}

// Configuration d’alerte de conformité
{
  "alertType": "compliance",
  "rule": "approvalRequired",
  "condition": "amount > 1000",
  "requiredActivity": "Manager Approval"
}

Comparaison des Types de Blocs

Choisissez le type de bloc adapté à vos besoins d'analyse :

Type de Bloc	Objectif Principal	Entrée	Sortie	Cas d'Utilisation
Filtre	Réduction et focalisation des données	Ensemble complet de données	Ensemble filtré	Analyse par période temporelle, chemins spécifiques de processus
Calculateur	Calcul de métriques et KPI	Ensemble de données (filtré ou complet)	Valeurs/métriques calculées	Mesure de performance, analyse statistique
Alerte	Surveillance et notifications	Métriques ou ensemble de données	Conditions d’alerte/notifications	Surveillance SLA, détection d’exceptions

Exemple : Workflow Complet de Bloc

Cet exemple montre la création de différents types de blocs pour une analyse complète :

// Créer un bloc de filtre pour se concentrer sur les données récentes
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: 'Filtre Derniers 30 Jours',
      blockDescription: 'Concentrer l\'analyse sur les données récentes du processus'
    })
  });
  return await response.json();
};

// Créer un bloc calculateur pour calculer des métriques
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: 'Calculateur Durée Moyenne',
      blockDescription: 'Calculer la durée moyenne de traitement des cas'
    })
  });
  return await response.json();
};

// Créer un bloc d’alerte pour la surveillance
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: 'Alerte Violation SLA',
      blockDescription: 'Surveiller les dépassements de SLA'
    })
  });
  return await response.json();
};

// Construire un workflow complet d'analyse
const buildAnalysisWorkflow = async (notebookId) => {
  try {
    // 1. Filtrer les données pour la période récente
    const filterBlock = await createDateFilter(notebookId);
    console.log('Bloc de filtre créé :', filterBlock.blockId);

    // 2. Calculer les métriques de performance
    const calculatorBlock = await createDurationCalculator(notebookId);
    console.log('Bloc calculateur créé :', calculatorBlock.blockId);

    // 3. Configurer les alertes de surveillance
    const alertBlock = await createSLAAlert(notebookId);
    console.log('Bloc d’alerte créé :', alertBlock.blockId);

    return {
      filter: filterBlock,
      calculator: calculatorBlock,
      alert: alertBlock
    };
  } catch (error) {
    console.error('Erreur lors de la création du workflow :', error);
    throw error;
  }
};

Implémentation Python

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]:
        """Créer un bloc de filtre pour la réduction des données"""
        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]:
        """Créer un bloc calculateur pour le calcul des métriques"""
        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]:
        """Créer un bloc d’alerte pour la surveillance"""
        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]:
        """Créer un pipeline d’analyse complet avec tous les types de blocs"""
        pipeline = {}

        # Créer un bloc de filtre
        pipeline['filter'] = self.create_filter_block(
            notebook_id,
            'Filtre de Données',
            'Filtrer l’ensemble de données pour le périmètre d’analyse'
        )

        # Créer un bloc calculateur
        pipeline['calculator'] = self.create_calculator_block(
            notebook_id,
            'Calculateur de Performance',
            'Calculer les principales métriques de performance'
        )

        # Créer un bloc d’alerte
        pipeline['alert'] = self.create_alert_block(
            notebook_id,
            'Alerte de Performance',
            'Surveiller les seuils de performance'
        )

        return pipeline

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

# Créer un pipeline d’analyse complet
pipeline = block_manager.create_analysis_pipeline('notebook-guid')
print(f"Pipeline créé avec {len(pipeline)} blocs")

Notes Importantes

Dépendances des Blocs : Les blocs peuvent être chaînés ensemble, les blocs de filtre réduisant les données, les blocs calculateur calculant les métriques, et les blocs d’alerte surveillant les résultats pour les exceptions.

Bonne pratique : Commencez par les blocs de filtre pour restreindre le périmètre des données, utilisez ensuite les blocs calculateur pour l’analyse, et enfin ajoutez les blocs d’alerte pour la surveillance continue et les notifications.