Blockausführung
Analyse-Blöcke ausführen
Führen Sie einzelne Blöcke asynchron aus und überwachen Sie deren Verarbeitungsstatus. Blöcke verarbeiten Daten entsprechend ihrem Typ und ihrer Konfiguration.
Block ausführen
POST /api/{tenantId}/{projectId}/block/{blockId}/execute
Stellt einen Block für die asynchrone Ausführung in die Warteschlange. Der Block verarbeitet Daten entsprechend seinem Typ und seiner Konfiguration (Filter, Rechner, Alarm, etc.). Gibt eine Ausführungs-ID zurück, um den Fortschritt zu verfolgen.
Pfadparameter
| Parameter | Typ | Erforderlich | Beschreibung |
|---|---|---|---|
tenantId |
GUID | Ja | Die Mandanten-ID |
projectId |
GUID | Ja | Die Projekt-ID |
blockId |
GUID | Ja | Die Block-ID, die ausgeführt werden soll |
Anfragetext (Optional)
{
"parameters": {
"dateFrom": "2024-01-01",
"dateTo": "2024-12-31",
"threshold": 1000
}
}
Antwort (202 Accepted)
{
"blockId": "550e8400-e29b-41d4-a716-446655440000",
"executionId": "770e8400-e29b-41d4-a716-446655440000",
"status": "Queued",
"dateQueued": "2024-01-15T10:30:00Z",
"dateStarted": null,
"dateEnded": null,
"result": null,
"errorMessage": null,
"message": "Block execution has been queued"
}
Antwortfelder
| Feld | Typ | Beschreibung |
|---|---|---|
blockId |
GUID | Der in die Warteschlange gestellte Block |
executionId |
GUID | Eindeutige Kennung für diese Ausführung |
status |
string | Aktueller Ausführungsstatus |
dateQueued |
datetime | Zeitpunkt, zu dem die Ausführung in die Warteschlange gestellt wurde |
dateStarted |
datetime | Zeitpunkt, zu dem die Ausführung begann (null, falls nicht gestartet) |
dateEnded |
datetime | Zeitpunkt, zu dem die Ausführung abgeschlossen wurde (null, falls nicht beendet) |
result |
object | Ausführungsergebnisdaten (null bis zum Abschluss) |
errorMessage |
string | Fehlermeldung bei Ausführungsfehlern |
message |
string | Menschlich lesbare Statusnachricht |
Fehlerantworten
Nicht gefunden (404):
{
"Error": "Block not found",
"BlockId": "550e8400-e29b-41d4-a716-446655440000"
}
Nicht autorisiert (401):
{Fehlermeldung zur fehlgeschlagenen Autorisierung}
Statuswerte der Ausführung
Die Ausführung eines Blocks durchläuft folgende Statuswerte:
| Status | Beschreibung |
|---|---|
Queued |
Block wartet in der Ausführungswarteschlange |
Running |
Block verarbeitet aktuell Daten |
Success |
Block hat die Ausführung erfolgreich abgeschlossen |
Failed |
Blockausführung ist mit Fehlern fehlgeschlagen |
Cancelled |
Blockausführung wurde abgebrochen |
Implementierungsbeispiele
cURL
# Block ohne Parameter ausführen
curl -X POST "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/block/550e8400-e29b-41d4-a716-446655440000/execute" \
-H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
-H "Content-Type: application/json"
# Block mit Parametern ausführen
curl -X POST "https://your-mindzie-instance.com/api/12345678-1234-1234-1234-123456789012/87654321-4321-4321-4321-210987654321/block/550e8400-e29b-41d4-a716-446655440000/execute" \
-H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
-H "Content-Type: application/json" \
-d '{"parameters": {"dateFrom": "2024-01-01", "dateTo": "2024-12-31"}}'
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 BlockExecutor {
constructor(token) {
this.headers = {
'Authorization': `Bearer ${token}`,
'Content-Type': 'application/json'
};
}
async executeBlock(blockId, parameters = null) {
const url = `${BASE_URL}/api/${TENANT_ID}/${PROJECT_ID}/block/${blockId}/execute`;
const body = parameters ? JSON.stringify({ parameters }) : null;
const response = await fetch(url, {
method: 'POST',
headers: this.headers,
body: body
});
if (response.status === 202) {
return await response.json();
}
throw new Error(`Ausführung fehlgeschlagen: ${response.statusText}`);
}
}
// Verwendung
const executor = new BlockExecutor('your-auth-token');
// Ausführen ohne Parameter
const result = await executor.executeBlock('block-guid');
console.log(`Ausführung in Warteschlange: ${result.executionId}`);
// Ausführen mit Parametern
const resultWithParams = await executor.executeBlock('block-guid', {
dateFrom: '2024-01-01',
dateTo: '2024-12-31'
});
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 BlockExecutor:
def __init__(self, token):
self.headers = {
'Authorization': f'Bearer {token}',
'Content-Type': 'application/json'
}
def execute_block(self, block_id, parameters=None):
"""Block zur Ausführung in die Warteschlange stellen."""
url = f'{BASE_URL}/api/{TENANT_ID}/{PROJECT_ID}/block/{block_id}/execute'
payload = {'parameters': parameters} if parameters else {}
response = requests.post(url, json=payload, headers=self.headers)
if response.status_code == 202:
return response.json()
else:
raise Exception(f'Blockausführung fehlgeschlagen: {response.text}')
# Verwendung
executor = BlockExecutor('your-auth-token')
# Ausführen ohne Parameter
result = executor.execute_block('block-guid')
print(f"Ausführung in Warteschlange: {result['executionId']}")
# Ausführen mit Parametern
result = executor.execute_block('block-guid', {
'dateFrom': '2024-01-01',
'dateTo': '2024-12-31',
'threshold': 1000
})
print(f"Status: {result['status']}")
C#
using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
public class ExecuteBlockReturn
{
public Guid BlockId { get; set; }
public Guid ExecutionId { get; set; }
public string Status { get; set; }
public DateTime DateQueued { get; set; }
public DateTime? DateStarted { get; set; }
public DateTime? DateEnded { get; set; }
public object Result { get; set; }
public string ErrorMessage { get; set; }
public string Message { get; set; }
}
public class BlockExecutorClient
{
private readonly HttpClient _httpClient;
private readonly string _baseUrl;
private readonly Guid _tenantId;
private readonly Guid _projectId;
public BlockExecutorClient(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<ExecuteBlockReturn> ExecuteBlockAsync(Guid blockId, object parameters = null)
{
var url = $"{_baseUrl}/api/{_tenantId}/{_projectId}/block/{blockId}/execute";
var payload = parameters != null ? new { parameters } : new { };
var content = new StringContent(
JsonSerializer.Serialize(payload),
Encoding.UTF8,
"application/json");
var response = await _httpClient.PostAsync(url, content);
if (response.StatusCode == System.Net.HttpStatusCode.Accepted)
{
var json = await response.Content.ReadAsStringAsync();
return JsonSerializer.Deserialize<ExecuteBlockReturn>(json,
new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
}
throw new Exception($"Blockausführung fehlgeschlagen: {response.StatusCode}");
}
}
// Verwendung
var executor = new BlockExecutorClient(
"https://your-mindzie-instance.com",
Guid.Parse("12345678-1234-1234-1234-123456789012"),
Guid.Parse("87654321-4321-4321-4321-210987654321"),
"your-access-token");
// Block ausführen
var result = await executor.ExecuteBlockAsync(
Guid.Parse("block-guid"),
new { dateFrom = "2024-01-01", dateTo = "2024-12-31" });
Console.WriteLine($"Ausführung in Warteschlange: {result.ExecutionId}");
Best Practices
- Blockstatus prüfen: Stellen Sie sicher, dass der Block nicht deaktiviert ist, bevor Sie ihn ausführen
- Parameter sinnvoll verwenden: Übergeben Sie Laufzeitparameter, um die Ausführung anzupassen, ohne die Blockkonfiguration zu ändern
- Asynchrone Natur berücksichtigen: Die Blockausführung ist asynchron – verwenden Sie den Ergebnis-Endpunkt, um den Abschluss zu überprüfen
- Ausführung überwachen: Bei lang laufenden Blöcken sollten Sie den Ergebnis-Endpunkt regelmäßig abfragen, um den Fortschritt zu verfolgen