Découverte des Types de Blocs

Point de Terminaison Unifié des Types de Bloc

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

Découvrez tous les types de blocs disponibles (filtres, calculateurs et enrichissements) en un seul appel API. Ce point de terminaison unifié est la méthode recommandée pour récupérer des informations complètes sur toutes les capacités d’analyse disponibles dans mindzieStudio.

Pourquoi Utiliser le Point de Terminaison Unifié ?

Le point de terminaison unifié offre plusieurs avantages par rapport à l’interrogation des points de terminaison individuels par catégorie :

• Requête Unique : Obtenez tous les types de blocs en un seul appel API au lieu de multiples requêtes
• Métadonnées Complètes : Inclut les enrichissements qui ne sont pas disponibles via les points de terminaison spécifiques à une catégorie
• Réponse Groupée : Résultats organisés par catégorie de bloc pour un traitement facile
• Métadonnées Riches : Chaque type de bloc comprend des URL de documentation, des notes d’utilisation et des blocs associés
• Intégration IA : Optimisé pour les assistants de codage IA et l’intégration serveur MCP

Requête

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

Paramètres de Chemin

Paramètre	Type	Obligatoire	Description
tenantId	GUID	Oui	L’identifiant du locataire
projectId	GUID	Oui	L’identifiant du projet

Réponse

Structure de la Réponse

{
  "BlockTypes": [...],
  "Categories": ["Filtres d'Attributs", "Filtres Temporels", "Calculateurs", ...],
  "TotalCount": 45,
  "ByBlockCategory": {
    "Filter": [...],
    "Calculator": [...],
    "Enrichment": [...]
  }
}

Champs de la Réponse

Champ	Type	Description
BlockTypes	Array	Tous les types de blocs avec métadonnées complètes
Categories	Array	Liste de toutes les catégories uniques
TotalCount	Integer	Nombre total de types de blocs disponibles
ByBlockCategory	Object	Types de blocs groupés par Filtre/Calculateur/Enrichissement

Objet Type de Bloc

Chaque type de bloc dans le tableau BlockTypes contient :

Champ	Type	Description
OperatorName	String	Identifiant unique du type de bloc (ex. : "CaseAttributeFilter")
DisplayName	String	Nom lisible affiché dans l’interface utilisateur
Description	String	Brève description de la fonction du bloc
Category	String	Catégorie fonctionnelle (ex. : "Filtres d'Attributs", "Filtres Temporels")
BlockType	String	Classification principale : "Filter", "Calculator", ou "Enrichment"
DocumentationUrl	String	URL vers la page de documentation pour ce type de bloc
UsageFrequency	String	Fréquence d’utilisation de ce type de bloc ("High", "Medium", "Low")
ExcludeFromOrFilter	Boolean	Indique si ce filtre peut être utilisé dans des combinaisons OU
AutoTitleEnabled	Boolean	Indique si la génération automatique de titre est prise en charge
SupportedDisplayTypes	Array	Types de visualisation supportés pour les résultats
UsageNotes	String	Conseils supplémentaires pour utiliser ce type de bloc
RelatedBlocks	Array	Liste des types de blocs associés
CommonUseCases	Array	Scénarios typiques où ce type de bloc est utile

Exemple de Réponse

{
  "BlockTypes": [
    {
      "OperatorName": "CaseAttributeFilter",
      "DisplayName": "Filtre d'Attribut de Cas",
      "Description": "Filtrer les cas selon les valeurs d'attributs telles que le type de client, la région ou le niveau de priorité",
      "Category": "Filtres d'Attributs",
      "BlockType": "Filter",
      "DocumentationUrl": "/mindzie_studio/filters/case-attribute-filter",
      "UsageFrequency": "High",
      "ExcludeFromOrFilter": false,
      "AutoTitleEnabled": true,
      "SupportedDisplayTypes": ["table", "chart"],
      "UsageNotes": "Supporte la correspondance exacte, contient, et les motifs regex",
      "RelatedBlocks": ["EventAttributeFilter", "CaseIdFilter"],
      "CommonUseCases": [
        "Filtrer par segment de client",
        "Se concentrer sur des régions spécifiques",
        "Analyser les cas prioritaires"
      ]
    },
    {
      "OperatorName": "CaseDurationCalculator",
      "DisplayName": "Calculateur de Durée de Cas",
      "Description": "Calculer la durée totale des cas du début à la fin",
      "Category": "Calculateurs Temporels",
      "BlockType": "Calculator",
      "DocumentationUrl": "/mindzie_studio/calculators/case-duration-calculator",
      "UsageFrequency": "High",
      "ExcludeFromOrFilter": false,
      "AutoTitleEnabled": true,
      "SupportedDisplayTypes": ["histogram", "table", "boxplot"],
      "UsageNotes": "La durée est calculée dans l’unité de temps configurée du projet",
      "RelatedBlocks": ["ActivityDurationCalculator", "WaitTimeCalculator"],
      "CommonUseCases": [
        "Analyser les temps de cycle des cas",
        "Identifier les cas lents",
        "Comparer l'efficacité des processus"
      ]
    },
    {
      "OperatorName": "CaseStageCalculator",
      "DisplayName": "Calculateur d'Étape de Cas",
      "Description": "Attribuer des étiquettes d’étape aux cas selon les motifs d’activité et les règles",
      "Category": "Analyse des Étapes",
      "BlockType": "Enrichment",
      "DocumentationUrl": "/mindzie_studio/enrichments/case-stage-calculator",
      "UsageFrequency": "Medium",
      "ExcludeFromOrFilter": false,
      "AutoTitleEnabled": true,
      "SupportedDisplayTypes": ["sankey", "table"],
      "UsageNotes": "Nécessite que les définitions d’étapes soient configurées",
      "RelatedBlocks": ["CaseStatusEnrichment", "MilestoneDetector"],
      "CommonUseCases": [
        "Suivre la progression des cas à travers les étapes",
        "Identifier les étapes goulots d’étranglement",
        "Surveiller les transitions d’étape"
      ]
    }
  ],
  "Categories": [
    "Filtres d'Attributs",
    "Filtres Temporels",
    "Filtres d'Activité",
    "Calculateurs Temporels",
    "Calculateurs de Comptage",
    "Analyse des Étapes",
    "Enrichissement de Données"
  ],
  "TotalCount": 45,
  "ByBlockCategory": {
    "Filter": [
      { "OperatorName": "CaseAttributeFilter", "DisplayName": "Filtre d'Attribut de Cas", ... },
      { "OperatorName": "DateRangeFilter", "DisplayName": "Filtre de Plage de Dates", ... }
    ],
    "Calculator": [
      { "OperatorName": "CaseDurationCalculator", "DisplayName": "Calculateur de Durée de Cas", ... }
    ],
    "Enrichment": [
      { "OperatorName": "CaseStageCalculator", "DisplayName": "Calculateur d'Étape de Cas", ... }
    ]
  }
}

Exemple JavaScript

// Découvrir tous les types de blocs disponibles
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(`Échec de la découverte des types de blocs : ${response.status}`);
  }

  const data = await response.json();

  console.log(`Découverte de ${data.TotalCount} types de blocs :`);
  console.log(`- Filtres : ${data.ByBlockCategory.Filter.length}`);
  console.log(`- Calculateurs : ${data.ByBlockCategory.Calculator.length}`);
  console.log(`- Enrichissements : ${data.ByBlockCategory.Enrichment.length}`);

  return data;
}

// Trouver les types de blocs par catégorie
function getBlockTypesByCategory(allTypes, category) {
  return allTypes.BlockTypes.filter(bt => bt.Category === category);
}

// Trouver les types de blocs à forte utilisation
function getHighUsageBlockTypes(allTypes) {
  return allTypes.BlockTypes.filter(bt => bt.UsageFrequency === 'High');
}

// Utilisation
const blockTypes = await discoverAllBlockTypes(tenantId, projectId, token);
const timeFilters = getBlockTypesByCategory(blockTypes, 'Filtres Temporels');
const popular = getHighUsageBlockTypes(blockTypes);

Exemple Python

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]:
        """Découvrir tous les types de blocs disponibles"""
        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]:
        """Obtenir tous les types de blocs filtres"""
        data = self.discover_all()
        return data.get('ByBlockCategory', {}).get('Filter', [])

    def get_calculators(self) -> List[Dict]:
        """Obtenir tous les types de blocs calculateurs"""
        data = self.discover_all()
        return data.get('ByBlockCategory', {}).get('Calculator', [])

    def get_enrichments(self) -> List[Dict]:
        """Obtenir tous les types de blocs enrichissements"""
        data = self.discover_all()
        return data.get('ByBlockCategory', {}).get('Enrichment', [])

    def find_by_use_case(self, keyword: str) -> List[Dict]:
        """Trouver les types de blocs correspondant à un mot-clé de cas d’utilisation"""
        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

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

# Découvrir tous les types de blocs
all_types = discovery.discover_all()
print(f"Nombre total de types de blocs : {all_types['TotalCount']}")

# Obtenir les types de blocs par catégorie
filters = discovery.get_filters()
calculators = discovery.get_calculators()
enrichments = discovery.get_enrichments()

# Trouver les types de blocs pour l’analyse de durée
duration_blocks = discovery.find_by_use_case('duration')

Points de Terminaison Spécifiques par Catégorie

Le point de terminaison unifié est recommandé pour la plupart des cas d’usage. Toutefois, les points de terminaison spécifiques par catégorie restent disponibles :

Point de terminaison	Description
GET /block/types?category=filters	Filtres uniquement
GET /block/types?category=calculators	Calculateurs uniquement
GET /block/types/{operatorName}	Détails d’un type de bloc unique
GET /block/types/{operatorName}/schema	Schéma de configuration d’un type de bloc

Intégration du Serveur MCP

Les assistants de codage IA peuvent utiliser le serveur mindzieAPI MCP pour découvrir les types de blocs de manière programmatique :

mindzie_list_block_types category="unified"

Cet appel MCP retourne la même réponse unifiée, facilitant la compréhension par les outils IA de toutes les capacités d’analyse disponibles.

Voir Intégration Serveur MCP pour la documentation complète.

Cas d’Utilisation

Construction d’Interfaces Dynamiques

Utilisez le point de terminaison unifié pour peupler des menus de sélection de types de blocs avec des informations complètes pour chaque option.

Analyse Assistée par IA

Les assistants IA peuvent découvrir les capacités d’analyse disponibles et suggérer des types de blocs appropriés selon les objectifs utilisateur.

Génération de Documentation

Générez dynamiquement une documentation en parcourant tous les types de blocs et leurs métadonnées.

Audit des Capacités

Énumérez toutes les capacités d’analyse disponibles pour un projet afin d’assurer une couverture complète.