Opérations sur les Blocs de Carnet

Créez et gérez des blocs d’analyse au sein des carnets. Les blocs sont les éléments constitutifs des flux d’analyse.

Types de Bloc

Type Description
Filter Restreindre les données à des cas ou événements spécifiques
Calculator Calculer des métriques, durées et valeurs dérivées
Opportunity Identifier des opportunités d’amélioration
Insight Générer des visualisations et statistiques
Dashboard Créer des panneaux de rapport partageables
Alert Définir des alertes de surveillance

Lister les Blocs

GET /api/{tenantId}/{projectId}/notebook/{notebookId}/blocks

Retourne tous les blocs d’un carnet dans l’ordre d’exécution.

Paramètres de Chemin

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

Réponse (200 OK)

{
  "notebookId": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
  "blocks": [
    {
      "blockId": "11111111-1111-1111-1111-111111111111",
      "blockType": "Filter",
      "operatorName": "ActivityFilter",
      "name": "Select Key Activities",
      "description": "Filter to main process activities",
      "parentId": null,
      "order": 0,
      "configuration": "{\"activities\": [\"Create Order\", \"Approve\", \"Ship\"]}",
      "dateCreated": "2024-01-15T10:30:00Z",
      "createdBy": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
      "dateModified": "2024-01-15T10:30:00Z",
      "isActive": true
    },
    {
      "blockId": "22222222-2222-2222-2222-222222222222",
      "blockType": "Calculator",
      "operatorName": "DurationCalculator",
      "name": "Case Duration",
      "description": "Calculate total case duration",
      "parentId": "11111111-1111-1111-1111-111111111111",
      "order": 0,
      "configuration": "{\"unit\": \"days\"}",
      "dateCreated": "2024-01-15T10:35:00Z",
      "createdBy": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
      "dateModified": "2024-01-15T10:35:00Z",
      "isActive": true
    }
  ],
  "totalCount": 2
}

Champs des Blocs

Champ Type Description
blockId GUID Identifiant unique du bloc
blockType string Type (Filter, Calculator, etc.)
operatorName string Nom spécifique de l’opérateur
name string Nom affiché du bloc
description string Description du bloc
parentId GUID ID du bloc parent (les données proviennent du parent)
order integer Indication de l’ordre d’exécution
configuration string Configuration JSON de l’opérateur
dateCreated datetime Date de création
createdBy GUID ID de l’utilisateur créateur
dateModified datetime Date de dernière modification
isActive boolean Indique si le bloc est activé

Créer un Bloc

POST /api/{tenantId}/{projectId}/notebook/{notebookId}/blocks

Crée un nouveau bloc d’analyse dans le carnet.

Paramètres de Chemin

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

Corps de la Requête

{
  "blockType": "Filter",
  "operatorName": "ActivityFilter",
  "name": "Filter by Status",
  "description": "Keep only completed orders",
  "configuration": "{\"activities\": [\"Complete\", \"Shipped\"]}",
  "insertAfterBlockId": "11111111-1111-1111-1111-111111111111"
}

Champs de la Requête

Champ Type Obligatoire Description
blockType string Non Type (Filter, Calculator, etc.) Par défaut : Filter
operatorName string Oui Opérateur spécifique à utiliser
name string Oui Nom affiché du bloc
description string Non Description du bloc
configuration string Non Configuration JSON de l’opérateur
insertAfterBlockId GUID Non Insérer après ce bloc (par défaut : fin)

Réponse (201 Created)

{
  "blockId": "33333333-3333-3333-3333-333333333333",
  "blockType": "Filter",
  "operatorName": "ActivityFilter",
  "name": "Filter by Status",
  "description": "Keep only completed orders",
  "parentId": "11111111-1111-1111-1111-111111111111",
  "order": 0,
  "configuration": "{\"activities\": [\"Complete\", \"Shipped\"]}",
  "dateCreated": "2024-03-01T10:00:00Z",
  "createdBy": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "dateModified": "2024-03-01T10:00:00Z",
  "isActive": true
}

Obtenir l’Ordre des Blocs

GET /api/{tenantId}/{projectId}/notebook/{notebookId}/blocks/order

Retourne l’ordre actuel d’exécution des blocs.

Réponse (200 OK)

{
  "notebookId": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
  "blockCount": 3,
  "blockOrder": [
    {
      "blockId": "11111111-1111-1111-1111-111111111111",
      "parentId": null,
      "position": 1
    },
    {
      "blockId": "22222222-2222-2222-2222-222222222222",
      "parentId": "11111111-1111-1111-1111-111111111111",
      "position": 2
    },
    {
      "blockId": "33333333-3333-3333-3333-333333333333",
      "parentId": "22222222-2222-2222-2222-222222222222",
      "position": 3
    }
  ]
}

Réorganiser les Blocs

PUT /api/{tenantId}/{projectId}/notebook/{notebookId}/blocks/order

Modifie l’ordre d’exécution des blocs dans le carnet.

Corps de la Requête

{
  "blockIds": [
    "11111111-1111-1111-1111-111111111111",
    "33333333-3333-3333-3333-333333333333",
    "22222222-2222-2222-2222-222222222222"
  ]
}

Champs de la Requête

Champ Type Obligatoire Description
blockIds array Oui IDs des blocs selon l’ordre d’exécution souhaité

Réponse (200 OK)

Retourne l’ordre des blocs mis à jour.

Flux d’Exécution des Blocs

Les blocs forment une chaîne où chaque bloc reçoit les données de son parent :

[Début de l’Enquête]
       |
       v
[Filter : Filtre d’Activité] -> Filtre vers des activités spécifiques
       |
       v
[Calculator : Durée] -> Calcule les durées pour les données filtrées
       |
       v
[Insight : Statistiques] -> Génère des statistiques sur les données calculées

Lorsque vous réorganisez les blocs, la chaîne parentale est mise à jour automatiquement.

Exemples d’Implémentation

Python

import requests
import json

BASE_URL = 'https://your-mindzie-instance.com'
TENANT_ID = '12345678-1234-1234-1234-123456789012'
PROJECT_ID = '87654321-4321-4321-4321-210987654321'

class BlockManager:
    def __init__(self, api_key):
        self.headers = {
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        }

    def list_blocks(self, notebook_id):
        """Lister tous les blocs d’un carnet."""
        url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/notebook/{notebook_id}/blocks'
        response = requests.get(url, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def create_block(self, notebook_id, block_type, operator_name, name,
                     description=None, configuration=None, insert_after=None):
        """Créer un nouveau bloc."""
        url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/notebook/{notebook_id}/blocks'
        data = {
            'blockType': block_type,
            'operatorName': operator_name,
            'name': name,
            'description': description,
            'configuration': json.dumps(configuration) if configuration else None,
            'insertAfterBlockId': insert_after
        }
        response = requests.post(url, json=data, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def get_block_order(self, notebook_id):
        """Obtenir l’ordre d’exécution actuel des blocs."""
        url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/notebook/{notebook_id}/blocks/order'
        response = requests.get(url, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def reorder_blocks(self, notebook_id, block_ids):
        """Réorganiser les blocs dans le carnet."""
        url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/notebook/{notebook_id}/blocks/order'
        response = requests.put(url, json={'blockIds': block_ids}, headers=self.headers)
        response.raise_for_status()
        return response.json()

# Utilisation
manager = BlockManager('your-api-key')
notebook_id = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'

# Lister les blocs
blocks = manager.list_blocks(notebook_id)
print(f"Trouvé {blocks['totalCount']} blocs")

# Créer un bloc filtre
filter_block = manager.create_block(
    notebook_id,
    block_type='Filter',
    operator_name='ActivityFilter',
    name='Select Key Activities',
    configuration={'activities': ['Create Order', 'Approve', 'Ship']}
)
print(f"Filtre créé : {filter_block['blockId']}")

# Créer un bloc calculateur après le filtre
calc_block = manager.create_block(
    notebook_id,
    block_type='Calculator',
    operator_name='DurationCalculator',
    name='Case Duration',
    configuration={'unit': 'days'},
    insert_after=filter_block['blockId']
)
print(f"Calculateur créé : {calc_block['blockId']}")

# Vérifier l’ordre d’exécution
order = manager.get_block_order(notebook_id)
print(f"Ordre des blocs : {[b['blockId'] for b in order['blockOrder']]}")

JavaScript/Node.js

const BASE_URL = 'https://your-mindzie-instance.com';
const TENANT_ID = '12345678-1234-1234-1234-123456789012';
const PROJECT_ID = '87654321-4321-4321-4321-210987654321';

class BlockManager {
  constructor(apiKey) {
    this.headers = {
      'Authorization': `Bearer ${apiKey}`,
      'Content-Type': 'application/json'
    };
  }

  async listBlocks(notebookId) {
    const url = `${BASE_URL}/api/${TENANT_ID}/${PROJECT_ID}/notebook/${notebookId}/blocks`;
    const response = await fetch(url, { headers: this.headers });
    if (!response.ok) throw new Error(`Échec : ${response.status}`);
    return response.json();
  }

  async createBlock(notebookId, blockType, operatorName, name, options = {}) {
    const url = `${BASE_URL}/api/${TENANT_ID}/${PROJECT_ID}/notebook/${notebookId}/blocks`;
    const body = {
      blockType,
      operatorName,
      name,
      description: options.description,
      configuration: options.configuration ? JSON.stringify(options.configuration) : null,
      insertAfterBlockId: options.insertAfter
    };
    const response = await fetch(url, {
      method: 'POST',
      headers: this.headers,
      body: JSON.stringify(body)
    });
    if (!response.ok) throw new Error(`Échec : ${response.status}`);
    return response.json();
  }

  async reorderBlocks(notebookId, blockIds) {
    const url = `${BASE_URL}/api/${TENANT_ID}/${PROJECT_ID}/notebook/${notebookId}/blocks/order`;
    const response = await fetch(url, {
      method: 'PUT',
      headers: this.headers,
      body: JSON.stringify({ blockIds })
    });
    if (!response.ok) throw new Error(`Échec : ${response.status}`);
    return response.json();
  }
}

// Utilisation
const manager = new BlockManager('your-api-key');
const notebookId = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee';

// Lister les blocs
const blocks = await manager.listBlocks(notebookId);
console.log(`Trouvé ${blocks.totalCount} blocs`);

// Créer des blocs
const filter = await manager.createBlock(notebookId, 'Filter', 'ActivityFilter', 'Key Activities', {
  configuration: { activities: ['Create', 'Approve'] }
});

const calc = await manager.createBlock(notebookId, 'Calculator', 'DurationCalculator', 'Duration', {
  insertAfter: filter.blockId
});

Bonnes Pratiques

  1. L’ordre des blocs est important : les données circulent du parent vers l’enfant - planifiez votre flux de travail
  2. Utilisez des modèles : pour les flux complexes, créez à partir de modèles
  3. Configuration JSON : stockez les paramètres spécifiques de l’opérateur sous forme de chaînes JSON
  4. InsertAfter : utilisez insertAfterBlockId pour contrôler le positionnement
  5. Exécution : après création des blocs, exécutez le carnet pour voir les résultats