Aktionsausführungsverlauf

Verfolgen und überwachen Sie den Verlauf der Aktionsausführung und laden Sie Ergebnis-Pakete herunter.

Übersicht

Die Action Execution API bietet Endpunkte zum Nachverfolgen des Verlaufs der Aktionsausführung, zur Statusüberwachung und zum Herunterladen von Ausführungsergebnissen. Diese API verwendet einen separaten Controller von der Haupt-Actions-API.

Basis-URL: /api/{tenantId}/{projectId}/actionexecution

Ausführungsverlauf für eine Aktion abrufen

GET /api/{tenantId}/{projectId}/actionexecution/action/{actionId}

Rufen Sie den vollständigen Ausführungsverlauf für eine bestimmte Aktion ab.

Anfrage

GET https://your-mindzie-instance.com/api/{tenantId}/{projectId}/actionexecution/action/{actionId}
Authorization: Bearer {your-access-token}

Pfadparameter

Parameter Typ Erforderlich Beschreibung
tenantId GUID Ja Ihre Mandanten-ID
projectId GUID Ja Ihre Projekt-ID
actionId GUID Ja Die Aktion, für die der Ausführungsverlauf abgerufen wird

Antwort

Erfolg (200 OK):

{
  "items": [
    {
      "actionId": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
      "actionExecutionId": "11111111-2222-3333-4444-555555555555",
      "dateStarted": "2024-01-15T10:30:00Z",
      "dateEnded": "2024-01-15T10:32:15Z",
      "status": "Completed",
      "notes": null
    },
    {
      "actionId": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
      "actionExecutionId": "22222222-3333-4444-5555-666666666666",
      "dateStarted": "2024-01-14T10:30:00Z",
      "dateEnded": "2024-01-14T10:31:45Z",
      "status": "Completed",
      "notes": null
    }
  ]
}

Letzte Ausführung für eine Aktion abrufen

GET /api/{tenantId}/{projectId}/actionexecution/lastaction/{actionId}

Rufen Sie die zuletzt erfolgte Ausführung für eine bestimmte Aktion ab.

Anfrage

GET https://your-mindzie-instance.com/api/{tenantId}/{projectId}/actionexecution/lastaction/{actionId}
Authorization: Bearer {your-access-token}

Pfadparameter

Parameter Typ Erforderlich Beschreibung
tenantId GUID Ja Ihre Mandanten-ID
projectId GUID Ja Ihre Projekt-ID
actionId GUID Ja Die Aktion, für die die letzte Ausführung abgerufen wird

Antwort

Erfolg (200 OK):

{
  "actionId": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
  "actionExecutionId": "11111111-2222-3333-4444-555555555555",
  "dateStarted": "2024-01-15T10:30:00Z",
  "dateEnded": "2024-01-15T10:32:15Z",
  "status": "Completed",
  "notes": null
}

Nicht gefunden (404):

{
  "error": "Can't find action",
  "actionId": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
}

Details zu einer bestimmten Ausführung abrufen

GET /api/{tenantId}/{projectId}/actionexecution/{executionId}

Rufen Sie Details zu einer bestimmten Ausführung anhand der Ausführungs-ID ab.

Anfrage

GET https://your-mindzie-instance.com/api/{tenantId}/{projectId}/actionexecution/{executionId}
Authorization: Bearer {your-access-token}

Pfadparameter

Parameter Typ Erforderlich Beschreibung
tenantId GUID Ja Ihre Mandanten-ID
projectId GUID Ja Ihre Projekt-ID
executionId GUID Ja Die auszuführende Ausführung

Antwort

Erfolg (200 OK):

{
  "actionId": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
  "actionExecutionId": "11111111-2222-3333-4444-555555555555",
  "dateStarted": "2024-01-15T10:30:00Z",
  "dateEnded": "2024-01-15T10:32:15Z",
  "status": "Completed",
  "notes": null
}

Nicht gefunden (404):

{
  "error": "Can't find action",
  "executionId": "11111111-2222-3333-4444-555555555555"
}

Ausführungspaket herunterladen

GET /api/{tenantId}/{projectId}/actionexecution/downloadpackage/{executionId}

Laden Sie das Ergebnis-Paket (ZIP-Datei) für eine abgeschlossene Ausführung herunter.

Anfrage

GET https://your-mindzie-instance.com/api/{tenantId}/{projectId}/actionexecution/downloadpackage/{executionId}
Authorization: Bearer {your-access-token}

Pfadparameter

Parameter Typ Erforderlich Beschreibung
tenantId GUID Ja Ihre Mandanten-ID
projectId GUID Ja Ihre Projekt-ID
executionId GUID Ja Die Ausführung, deren Ergebnisse heruntergeladen werden sollen

Antwort

Erfolg (200 OK):

Gibt einen ZIP-Datei-Download mit Ausführungsergebnissen, Berichten und Artefakten zurück.

HTTP/1.1 200 OK
Content-Type: application/zip
Content-Disposition: attachment; filename="{executionId}.zip"

[binary ZIP file content]

Nicht gefunden (404):

{
  "error": "Execution not found",
  "executionId": "11111111-2222-3333-4444-555555555555"
}

{
  "error": "Zip file not found",
  "executionId": "11111111-2222-3333-4444-555555555555"
}

Felder der Ausführungsantwort

Feld Typ Beschreibung
actionId GUID Die ausgeführte Aktion
actionExecutionId GUID Eindeutige Kennung für diese Ausführung
dateStarted datetime Wann die Ausführung gestartet wurde
dateEnded datetime Wann die Ausführung abgeschlossen wurde (null, falls noch laufend)
status string Aktueller Ausführungsstatus
notes string Ausführungsnotizen oder Fehlermeldungen

Werte des Ausführungsstatus

Status Beschreibung
Queued Ausführung in Warteschlange, wartet auf Start
Running Ausführung läuft gerade
Completed Ausführung erfolgreich abgeschlossen
Failed Ausführung ist auf einen Fehler gestoßen

Implementierungsbeispiele

cURL

# Ausführungsverlauf für eine Aktion abrufen
curl -X GET "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/actionexecution/action/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

# Letzte Ausführung abrufen
curl -X GET "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/actionexecution/lastaction/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

# Bestimmte Ausführung abrufen
curl -X GET "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/actionexecution/11111111-2222-3333-4444-555555555555" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

# Ausführungspaket herunterladen
curl -X GET "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/actionexecution/downloadpackage/11111111-2222-3333-4444-555555555555" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -o execution_results.zip

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';

// Ausführungsverlauf für eine Aktion abrufen
const getExecutionHistory = async (actionId, token) => {
  const url = `${BASE_URL}/api/${TENANT_ID}/${PROJECT_ID}/actionexecution/action/${actionId}`;

  const response = await fetch(url, {
    headers: { 'Authorization': `Bearer ${token}` }
  });

  if (response.ok) {
    const result = await response.json();
    return result.items;
  }
  throw new Error(`Failed: ${response.status}`);
};

// Letzte Ausführung für eine Aktion abrufen
const getLastExecution = async (actionId, token) => {
  const url = `${BASE_URL}/api/${TENANT_ID}/${PROJECT_ID}/actionexecution/lastaction/${actionId}`;

  const response = await fetch(url, {
    headers: { 'Authorization': `Bearer ${token}` }
  });

  if (response.ok) {
    return await response.json();
  } else if (response.status === 404) {
    return null;
  }
  throw new Error(`Failed: ${response.status}`);
};

// Details zu einer spezifischen Ausführung abrufen
const getExecution = async (executionId, token) => {
  const url = `${BASE_URL}/api/${TENANT_ID}/${PROJECT_ID}/actionexecution/${executionId}`;

  const response = await fetch(url, {
    headers: { 'Authorization': `Bearer ${token}` }
  });

  if (response.ok) {
    return await response.json();
  }
  throw new Error(`Failed: ${response.status}`);
};

// Ausführungspaket herunterladen
const downloadPackage = async (executionId, token) => {
  const url = `${BASE_URL}/api/${TENANT_ID}/${PROJECT_ID}/actionexecution/downloadpackage/${executionId}`;

  const response = await fetch(url, {
    headers: { 'Authorization': `Bearer ${token}` }
  });

  if (response.ok) {
    const blob = await response.blob();
    // ZIP-Datei speichern oder verarbeiten
    return blob;
  }
  throw new Error(`Failed: ${response.status}`);
};

Python

import requests

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

def get_execution_history(action_id, token):
    """Alle Ausführungen für eine Aktion abrufen."""
    url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/actionexecution/action/{action_id}'
    headers = {'Authorization': f'Bearer {token}'}

    response = requests.get(url, headers=headers)
    response.raise_for_status()
    return response.json()['items']

def get_last_execution(action_id, token):
    """Die aktuellste Ausführung für eine Aktion abrufen."""
    url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/actionexecution/lastaction/{action_id}'
    headers = {'Authorization': f'Bearer {token}'}

    response = requests.get(url, headers=headers)
    if response.status_code == 404:
        return None
    response.raise_for_status()
    return response.json()

def get_execution(execution_id, token):
    """Details zu einer bestimmten Ausführung abrufen."""
    url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/actionexecution/{execution_id}'
    headers = {'Authorization': f'Bearer {token}'}

    response = requests.get(url, headers=headers)
    response.raise_for_status()
    return response.json()

def download_package(execution_id, token, output_path):
    """Das Ergebnis-Paket der Ausführung herunterladen."""
    url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/actionexecution/downloadpackage/{execution_id}'
    headers = {'Authorization': f'Bearer {token}'}

    response = requests.get(url, headers=headers)
    response.raise_for_status()

    with open(output_path, 'wb') as f:
        f.write(response.content)

    return output_path

# Beispiel: Überwachen der Ausführung bis zum Abschluss
def wait_for_completion(execution_id, token, max_wait_seconds=300):
    import time

    start_time = time.time()
    while time.time() - start_time < max_wait_seconds:
        execution = get_execution(execution_id, token)
        status = execution['status']

        if status == 'Completed':
            print(f'Ausführung erfolgreich abgeschlossen')
            return execution
        elif status == 'Failed':
            print(f'Ausführung fehlgeschlagen: {execution.get("notes", "Unbekannter Fehler")}')
            return execution
        else:
            print(f'Status: {status}, warte...')
            time.sleep(5)

    raise TimeoutError('Ausführung wurde nicht innerhalb der Zeit abgeschlossen')

Best Practices

  • Status abfragen: Nach der Ausführung einer Aktion den Ausführungsendpunkt zur Fortschrittsüberwachung abfragen
  • Lang laufende Aktionen berücksichtigen: Verwenden Sie geeignete Timeouts beim Warten auf den Abschluss
  • Ergebnisse herunterladen: Für Aktionen mit Ausgabedateien das Paket nach Abschluss herunterladen
  • Fehlerbehandlung: Prüfen Sie das Feld notes auf Fehlermeldungen, wenn der Status "Failed" ist
  • Ausführungsverlauf nutzen: Verwenden Sie Verlauf-Endpunkte zum Auditieren und Debuggen vergangener Ausführungen