Résultats des Blocs

Récupérer les Résultats d'Analyse

Accédez à l'historique d'exécution et aux résultats des exécutions de blocs terminées. Obtenez les résultats traités des filtres, calculs et alertes.

Obtenir les Résultats d'un Bloc

GET /api/{tenantId}/{projectId}/block/{blockId}/results

Récupère les métadonnées de l'historique d'exécution pour un bloc spécifique. Les résultats incluent les horodatages d'exécution et les informations de statut.

Paramètres de Chemin

Paramètre Type Obligatoire Description
tenantId GUID Oui L'identifiant du locataire
projectId GUID Oui L'identifiant du projet
blockId GUID Oui L'identifiant du bloc

Réponse (200 OK)

{
  "blockId": "550e8400-e29b-41d4-a716-446655440000",
  "message": "Historique d'exécution du bloc pas encore implémenté",
  "executions": []
}

Codes de Réponse

  • 200 OK - Requête réussie
  • 401 Unauthorized - Authentification invalide ou permissions insuffisantes
  • 404 Not Found - Bloc non trouvé ou accès refusé
  • 500 Internal Server Error - Erreur serveur survenue

Obtenir les Données de Sortie du Bloc

GET /api/{tenantId}/{projectId}/block/{blockId}/output-data

Récupère le jeu de données transformé produit par le bloc.

Important : Ce point de terminaison retourne des instructions pour utiliser le workflow ExecutionController afin de récupérer les données de sortie réelles, car les données de sortie du bloc sont uniquement disponibles via le cache mémoire du projet.

Paramètres de Chemin

Paramètre Type Obligatoire Description
tenantId GUID Oui L'identifiant du locataire
projectId GUID Oui L'identifiant du projet
blockId GUID Oui L'identifiant du bloc

Réponse (501 Not Implemented)

{
  "Error": "Récupération des données de sortie du bloc non implémentée via l'API base de données",
  "BlockId": "550e8400-e29b-41d4-a716-446655440000",
  "Message": "Pour récupérer les données de sortie du bloc, utilisez le workflow ExecutionController : 1. Chargez le projet dans le cache via ProjectController.LoadProject, 2. Exécutez le notebook via ExecutionController.ExecuteNotebook, 3. Récupérez les résultats via ExecutionController.GetNotebookResults",
  "Recommendation": "GET /api/{tenantId}/{projectId}/execution/notebook/{notebookId}/results"
}

Workflow Recommandé pour la Sortie de Bloc

Pour récupérer les données de sortie réelles du bloc, suivez ce workflow en utilisant l'API Execution :

  1. Charger le Projet dans le Cache

    GET /api/{tenantId}/{projectId}/project/{projectId}/load

  2. Exécuter le Notebook

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

  3. Obtenir les Résultats du Notebook

    GET /api/{tenantId}/{projectId}/execution/notebook/{notebookId}/results

Voir API Execution pour la documentation complète.

Exemples d'Implémentation

cURL

# Obtenir les métadonnées des résultats du bloc
curl -X GET "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/block/550e8400-e29b-41d4-a716-446655440000/results" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

# Tentative d'obtention des données de sortie (retourne des instructions)
curl -X GET "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/block/550e8400-e29b-41d4-a716-446655440000/output-data" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

JavaScript/Node.js

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

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

  async getBlockResults(blockId) {
    const url = `${BASE_URL}/api/${TENANT_ID}/${PROJECT_ID}/block/${blockId}/results`;
    const response = await fetch(url, { headers: this.headers });

    if (response.ok) {
      return await response.json();
    }

    throw new Error(`Échec de récupération des résultats : ${response.status}`);
  }

  async getBlockOutputData(blockId) {
    const url = `${BASE_URL}/api/${TENANT_ID}/${PROJECT_ID}/block/${blockId}/output-data`;
    const response = await fetch(url, { headers: this.headers });

    // Note : Ce point de terminaison retourne 501 avec des instructions
    return await response.json();
  }
}

// Utilisation
const client = new BlockResultsClient('your-auth-token');

// Obtenir les métadonnées des résultats
const results = await client.getBlockResults('block-guid');
console.log(`Bloc : ${results.blockId}`);
console.log(`Exécutions : ${results.executions.length}`);

// Vérifier les instructions pour les données de sortie
const outputInfo = await client.getBlockOutputData('block-guid');
console.log(`Recommandation : ${outputInfo.Recommendation}`);

Python

import requests

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

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

    def get_block_results(self, block_id):
        """Récupérer les métadonnées des résultats d'exécution du bloc."""
        url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/block/{block_id}/results'
        response = requests.get(url, headers=self.headers)

        if response.ok:
            return response.json()
        else:
            raise Exception(f'Échec de récupération des résultats : {response.status_code}')

    def get_block_output_data(self, block_id):
        """Récupérer les instructions des données de sortie du bloc."""
        url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/block/{block_id}/output-data'
        response = requests.get(url, headers=self.headers)
        return response.json()

# Utilisation
client = BlockResultsClient('your-auth-token')

# Obtenir les résultats
results = client.get_block_results('block-guid')
print(f"Bloc : {results['blockId']}")

# Obtenir les instructions pour les données de sortie
output_info = client.get_block_output_data('block-guid')
print(f"Recommandation : {output_info.get('Recommendation', 'N/A')}")

C#

using System;
using System.Net.Http;
using System.Text.Json;
using System.Threading.Tasks;

public class BlockResultsClient
{
    private readonly HttpClient _httpClient;
    private readonly string _baseUrl;
    private readonly Guid _tenantId;
    private readonly Guid _projectId;

    public BlockResultsClient(string baseUrl, Guid tenantId, Guid projectId, string accessToken)
    {
        _baseUrl = baseUrl;
        _tenantId = tenantId;
        _projectId = projectId;
        _httpClient = new HttpClient();
        _httpClient.DefaultRequestHeaders.Authorization =
            new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", accessToken);
    }

    public async Task<JsonDocument> GetBlockResultsAsync(Guid blockId)
    {
        var url = $"{_baseUrl}/api/{_tenantId}/{_projectId}/block/{blockId}/results";
        var response = await _httpClient.GetAsync(url);

        if (response.IsSuccessStatusCode)
        {
            var json = await response.Content.ReadAsStringAsync();
            return JsonDocument.Parse(json);
        }

        throw new Exception($"Échec de récupération des résultats : {response.StatusCode}");
    }

    public async Task<JsonDocument> GetBlockOutputDataAsync(Guid blockId)
    {
        var url = $"{_baseUrl}/api/{_tenantId}/{_projectId}/block/{blockId}/output-data";
        var response = await _httpClient.GetAsync(url);

        // Retourne 501 avec instructions
        var json = await response.Content.ReadAsStringAsync();
        return JsonDocument.Parse(json);
    }
}

Notes Importantes

  • Point de terminaison des résultats : Retourne actuellement les métadonnées de l'historique d'exécution. La récupération complète de l'historique est en cours de développement.
  • Données de sortie : Les données de sortie des blocs sont uniquement disponibles via le cache mémoire du projet. Utilisez le workflow ExecutionController pour récupérer les données réelles.
  • Bonne pratique : Pour obtenir la sortie complète d'un bloc, chargez le projet, exécutez le notebook et récupérez les résultats via l'API Execution.