Aktion ausführen

Führen Sie die Aktion programmatisch innerhalb von mindzieStudio aus.

Übersicht

Der Execute Action-Endpunkt ermöglicht es Ihnen, eine bestimmte Aktion innerhalb von mindzieStudio auszulösen. Aktionen werden zur asynchronen Ausführung in eine Warteschlange gestellt und Sie erhalten eine Ausführungs-ID, um den Fortschritt zu verfolgen.

Aktion ausführen

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

Führen Sie eine bestimmte Aktion anhand ihrer ID aus. Die Aktion wird zur Ausführungs-Warteschlange hinzugefügt und asynchron verarbeitet.

Anfrage

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

Pfadparameter

Parameter	Typ	Erforderlich	Beschreibung
tenantId	GUID	Ja	Ihre Mandantenkennung
projectId	GUID	Ja	Ihre Projektkennung
actionId	GUID	Ja	Die auszuführende Aktion

Antwort

Erfolgreich (200 OK):

{
  "actionId": "87654321-4321-4321-4321-210987654321",
  "actionExecutionId": "11111111-2222-3333-4444-555555555555",
  "dateStarted": "2024-01-15T10:30:00Z",
  "dateEnded": null,
  "status": "Queued",
  "notes": null
}

Antwortfelder

Feld	Typ	Beschreibung
actionId	GUID	Die ID der ausgeführten Aktion
actionExecutionId	GUID	Eindeutige Kennung für diese Ausführungsinstanz
dateStarted	datetime	Zeitpunkt, zu dem die Ausführung in die Warteschlange gestellt wurde
dateEnded	datetime	Zeitpunkt, zu dem die Ausführung abgeschlossen wurde (null, wenn noch in Bearbeitung)
status	string	Aktueller Ausführungsstatus
notes	string	Zusätzliche Ausführungsnotizen oder Fehlermeldungen

Fehlermeldungen

Aktion nicht gefunden (404):

{
  "error": "Action not found",
  "actionId": "87654321-4321-4321-4321-210987654321"
}

Ausführung konnte nicht erstellt werden (404):

{
  "error": "Action can't create execution",
  "actionId": "87654321-4321-4321-4321-210987654321"
}

Nicht autorisiert (401):

HTTP/1.1 401 Unauthorized

{Fehlermeldung, die den Autorisierungsfehler beschreibt}

Werte für Ausführungsstatus

Status	Beschreibung
Queued	Aktion ist in der Warteschlange und wartet auf Verarbeitung
Running	Aktion wird derzeit ausgeführt
Completed	Aktion wurde erfolgreich abgeschlossen
Failed	Ausführung der Aktion fehlgeschlagen

Implementierungsbeispiele

cURL

curl -X GET "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/action/execute/aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" \
  -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';

const executeAction = async (actionId, token) => {
  const url = `${BASE_URL}/api/${TENANT_ID}/${PROJECT_ID}/action/execute/${actionId}`;

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

    if (response.ok) {
      const result = await response.json();
      console.log('Aktion in Warteschlange:', result);
      console.log('Ausführungs-ID:', result.actionExecutionId);
      return result;
    } else if (response.status === 404) {
      const error = await response.json();
      console.error('Aktion nicht gefunden:', error);
      throw new Error(error.error);
    } else {
      throw new Error(`Ausführung fehlgeschlagen: ${response.status}`);
    }
  } catch (error) {
    console.error('Fehler bei der Ausführung der Aktion:', error);
    throw error;
  }
};

// Beispielhafte Nutzung
executeAction('aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee', 'your_token')
  .then(result => {
    // actionExecutionId zur Nachverfolgung speichern
    const executionId = result.actionExecutionId;
  });

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 execute_action(action_id, token):
    """Führt eine Aktion aus und gibt Ausführungsdetails zurück."""
    url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/action/execute/{action_id}'
    headers = {
        'Authorization': f'Bearer {token}'
    }

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

    if response.ok:
        result = response.json()
        print(f'Aktion in Warteschlange: {result}')
        print(f'Ausführungs-ID: {result["actionExecutionId"]}')
        return result
    elif response.status_code == 404:
        error = response.json()
        print(f'Aktion nicht gefunden: {error}')
        raise Exception(error['error'])
    else:
        raise Exception(f'Ausführung fehlgeschlagen: {response.status_code}')

# Beispielhafte Nutzung
result = execute_action('aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee', 'your_token')
execution_id = result['actionExecutionId']

C#

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

public class ActionExecutionResult
{
    public Guid ActionId { get; set; }
    public Guid ActionExecutionId { get; set; }
    public DateTime? DateStarted { get; set; }
    public DateTime? DateEnded { get; set; }
    public string Status { get; set; }
    public string Notes { get; set; }
}

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

    public ActionApiClient(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<ActionExecutionResult> ExecuteActionAsync(Guid actionId)
    {
        var url = $"{_baseUrl}/api/{_tenantId}/{_projectId}/action/execute/{actionId}";
        var response = await _httpClient.GetAsync(url);

        if (response.IsSuccessStatusCode)
        {
            var json = await response.Content.ReadAsStringAsync();
            var result = JsonSerializer.Deserialize<ActionExecutionResult>(json,
                new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
            Console.WriteLine($"Aktion in Warteschlange. Ausführungs-ID: {result.ActionExecutionId}");
            return result;
        }
        else if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
        {
            throw new Exception($"Aktion {actionId} nicht gefunden");
        }
        else
        {
            throw new Exception($"Ausführung fehlgeschlagen: {response.StatusCode}");
        }
    }
}

Best Practices

• Speichern Sie die Ausführungs-ID: Speichern Sie stets die zurückgegebene actionExecutionId, um den Ausführungsfortschritt zu verfolgen
• Überprüfen Sie, ob die Aktion existiert: Verwenden Sie zuerst den Get Action-Endpunkt, um sicherzustellen, dass die Aktion existiert und aktiviert ist
• Beachten Sie die asynchrone Ausführung: Aktionen werden asynchron ausgeführt – die Antwort zeigt an, dass die Aktion in die Warteschlange gestellt wurde, jedoch nicht abgeschlossen ist
• Fehlerbehandlung: Implementieren Sie eine geeignete Fehlerbehandlung für 404-Antworten (Aktion nicht gefunden) und 401 (nicht autorisiert)
• Idempotenz: Jeder Aufruf erstellt eine neue Ausführung – vermeiden Sie doppelte Aufrufe, wenn dies nicht beabsichtigt ist