Blockergebnisse

Analyseergebnisse abrufen

Greifen Sie auf die Ausführungshistorie und Ergebnisse abgeschlossener Blockausführungen zu. Erhalten Sie verarbeitete Ergebnisse von Filtern, Berechnungen und Alarmen.

Blockergebnisse abrufen

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

Ruft Metadaten der Ausführungshistorie für einen bestimmten Block ab. Die Ergebnisse enthalten Ausführungszeitstempel und Statusinformationen.

Pfadparameter

Parameter Typ Erforderlich Beschreibung
tenantId GUID Ja Die Mandantenkennung
projectId GUID Ja Die Projektkennung
blockId GUID Ja Die Blockkennung

Antwort (200 OK)

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

Antwortcodes

  • 200 OK - Anfrage erfolgreich
  • 401 Unauthorized - Ungültige Authentifizierung oder unzureichende Berechtigungen
  • 404 Not Found - Block nicht gefunden oder kein Zugriff
  • 500 Internal Server Error - Serverfehler aufgetreten

Block-Ausgabedaten abrufen

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

Ruft den vom Block erzeugten transformierten Datensatz ab.

Wichtig: Dieser Endpunkt liefert eine Anleitung zur Verwendung des ExecutionController-Workflows für den tatsächlichen Abruf der Ausgabedaten, da Block-Ausgabedaten nur über den im Arbeitsspeicher befindlichen Projektcache verfügbar sind.

Pfadparameter

Parameter Typ Erforderlich Beschreibung
tenantId GUID Ja Die Mandantenkennung
projectId GUID Ja Die Projektkennung
blockId GUID Ja Die Blockkennung

Antwort (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"
}

Empfohlener Workflow für Blockausgabe

Um die tatsächlichen Blockausgabedaten abzurufen, folgen Sie diesem Workflow unter Verwendung der Execution API:

  1. Projekt in den Cache laden

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

  2. Notebook ausführen

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

  3. Notebook-Ergebnisse abrufen

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

Siehe Execution API für die vollständige Dokumentation.

Implementierungsbeispiele

cURL

# Metadaten der Blockergebnisse abrufen
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"

# Versuch, Ausgabedaten abzurufen (liefert Anleitung)
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(`Fehler beim Abrufen der Ergebnisse: ${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 });

    // Hinweis: Dieser Endpunkt liefert 501 mit Anleitung
    return await response.json();
  }
}

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

// Metadaten der Ergebnisse abrufen
const results = await client.getBlockResults('block-guid');
console.log(`Block: ${results.blockId}`);
console.log(`Ausführungen: ${results.executions.length}`);

// Anleitung zu Ausgabedaten prüfen
const outputInfo = await client.getBlockOutputData('block-guid');
console.log(`Empfehlung: ${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):
        """Metadaten der Blockausführungsergebnisse abrufen."""
        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'Fehler beim Abrufen der Ergebnisse: {response.status_code}')

    def get_block_output_data(self, block_id):
        """Anleitung zum Abrufen der Block-Ausgabedaten."""
        url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/block/{block_id}/output-data'
        response = requests.get(url, headers=self.headers)
        return response.json()

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

# Ergebnisse abrufen
results = client.get_block_results('block-guid')
print(f"Block: {results['blockId']}")

# Anleitung für Ausgabedaten abrufen
output_info = client.get_block_output_data('block-guid')
print(f"Empfehlung: {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($"Fehler beim Abrufen der Ergebnisse: {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);

        // Liefert 501 mit Anleitung
        var json = await response.Content.ReadAsStringAsync();
        return JsonDocument.Parse(json);
    }
}

Wichtige Hinweise

  • Results-Endpunkt: Gibt derzeit Metadaten der Ausführungshistorie zurück. Die vollständige Ausführungshistorie wird entwickelt.
  • Ausgabedaten: Block-Ausgabedaten sind nur über den im Arbeitsspeicher befindlichen Projektcache verfügbar. Verwenden Sie den ExecutionController-Workflow für den tatsächlichen Datenabruf.
  • Beste Vorgehensweise: Für vollständige Blockausgaben laden Sie das Projekt, führen das Notebook aus und rufen die Ergebnisse über die Execution API ab.