Resultados del Bloque

Recuperar Resultados de Análisis

Acceda al historial de ejecuciones y resultados de ejecuciones de bloques completadas. Obtenga resultados procesados de filtros, cálculos y alertas.

Obtener Resultados del Bloque

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

Recupera los metadatos del historial de ejecución para un bloque específico. Los resultados incluyen marcas de tiempo de ejecución e información de estado.

Parámetros de Ruta

Parámetro Tipo Requerido Descripción
tenantId GUID Sí El identificador del tenant
projectId GUID Sí El identificador del proyecto
blockId GUID Sí El identificador del bloque

Respuesta (200 OK)

{
  "blockId": "550e8400-e29b-41d4-a716-446655440000",
  "message": "Block execution history not yet implemented",
  "executions": []
}

Códigos de Respuesta

  • 200 OK - Solicitud exitosa
  • 401 Unauthorized - Autenticación inválida o permisos insuficientes
  • 404 Not Found - Bloque no encontrado o sin acceso
  • 500 Internal Server Error - Error interno del servidor

Obtener Datos de Salida del Bloque

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

Recupera el conjunto de datos transformado producido por el bloque.

Importante: Este endpoint devuelve indicaciones para usar el flujo de trabajo ExecutionController para la recuperación real de datos de salida, ya que los datos de salida del bloque sólo están disponibles a través del caché en memoria del proyecto.

Parámetros de Ruta

Parámetro Tipo Requerido Descripción
tenantId GUID Sí El identificador del tenant
projectId GUID Sí El identificador del proyecto
blockId GUID Sí El identificador del bloque

Respuesta (501 Not Implemented)

{
  "Error": "Block output data retrieval not implemented via database API",
  "BlockId": "550e8400-e29b-41d4-a716-446655440000",
  "Message": "To retrieve block output data, use the ExecutionController workflow: 1. Load project into cache via ProjectController.LoadProject, 2. Execute notebook via ExecutionController.ExecuteNotebook, 3. Retrieve results via ExecutionController.GetNotebookResults",
  "Recommendation": "GET /api/{tenantId}/{projectId}/execution/notebook/{notebookId}/results"
}

Flujo Recomendado para la Salida del Bloque

Para obtener los datos reales de salida del bloque, siga este flujo de trabajo utilizando la API de ejecución:

  1. Cargar Proyecto en Caché

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

  2. Ejecutar Notebook

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

  3. Obtener Resultados del Notebook

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

Consulte la API de Ejecución para la documentación completa.

Ejemplos de Implementación

cURL

# Obtener metadatos de resultados del bloque
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"

# Intentar obtener datos de salida (devuelve indicaciones)
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(`Failed to get results: ${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 });

    // Nota: Este endpoint devuelve 501 con indicaciones
    return await response.json();
  }
}

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

// Obtener metadatos de resultados
const results = await client.getBlockResults('block-guid');
console.log(`Bloque: ${results.blockId}`);
console.log(`Ejecuciones: ${results.executions.length}`);

// Verificar indicaciones de datos de salida
const outputInfo = await client.getBlockOutputData('block-guid');
console.log(`Recomendación: ${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):
        """Obtener metadatos de resultados de ejecución del bloque."""
        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'Error al obtener resultados: {response.status_code}')

    def get_block_output_data(self, block_id):
        """Obtener indicaciones sobre datos de salida del bloque."""
        url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/block/{block_id}/output-data'
        response = requests.get(url, headers=self.headers)
        return response.json()

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

# Obtener resultados
results = client.get_block_results('block-guid')
print(f"Bloque: {results['blockId']}")

# Obtener indicaciones de datos de salida
output_info = client.get_block_output_data('block-guid')
print(f"Recomendación: {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($"Error al obtener resultados: {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);

        // Devuelve 501 con indicaciones
        var json = await response.Content.ReadAsStringAsync();
        return JsonDocument.Parse(json);
    }
}

Notas Importantes

  • Endpoint de Resultados: Actualmente devuelve metadatos del historial de ejecución. La recuperación completa del historial de ejecución está en desarrollo.
  • Datos de Salida: Los datos de salida del bloque sólo están disponibles a través del caché en memoria del proyecto. Use el flujo de trabajo ExecutionController para la recuperación real de datos.
  • Mejor Práctica: Para salida completa del bloque, cargue el proyecto, ejecute el notebook y obtenga los resultados vía la API de ejecución.