Blokuitvoering
Analyseblokken uitvoeren
Voer afzonderlijke blokken asynchroon uit en monitor hun verwerkingsstatus. Blokken verwerken gegevens volgens hun type en configuratie.
Blok uitvoeren
POST /api/{tenantId}/{projectId}/block/{blockId}/execute
Zet een blok in de wachtrij voor asynchrone uitvoering. Het blok verwerkt gegevens volgens het type en de configuratie (filter, calculator, waarschuwing, enz.). Geeft een uitvoerings-ID terug om de voortgang te volgen.
Padparameters
| Parameter | Type | Vereist | Beschrijving |
|---|---|---|---|
tenantId |
GUID | Ja | De tenant-identificatie |
projectId |
GUID | Ja | De projectidentificatie |
blockId |
GUID | Ja | De identificatie van het blok dat uitgevoerd moet worden |
Request Body (optioneel)
{
"parameters": {
"dateFrom": "2024-01-01",
"dateTo": "2024-12-31",
"threshold": 1000
}
}
Response (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"
}
Responsevelden
| Veld | Type | Beschrijving |
|---|---|---|
blockId |
GUID | Het blok dat in de wachtrij is geplaatst |
executionId |
GUID | Unieke identificatie voor deze uitvoering |
status |
string | Huidige uitvoeringsstatus |
dateQueued |
datetime | Wanneer de uitvoering in de wachtrij is geplaatst |
dateStarted |
datetime | Wanneer de uitvoering is gestart (null als nog niet gestart) |
dateEnded |
datetime | Wanneer de uitvoering is voltooid (null als nog niet afgerond) |
result |
object | Uitvoeringsresultaatdata (null tot voltooiing) |
errorMessage |
string | Foutdetails als de uitvoering mislukt is |
message |
string | Menselijk leesbare statusmelding |
Foutreacties
Niet gevonden (404):
{
"Error": "Block not found",
"BlockId": "550e8400-e29b-41d4-a716-446655440000"
}
Ongeautoriseerd (401):
{error message describing authorization failure}
Uitvoeringsstatuswaarden
De uitvoering van een blok doorloopt deze statuswaarden:
| Status | Beschrijving |
|---|---|
Queued |
Blok wacht in de uitvoeringswachtrij |
Running |
Blok is bezig met gegevensverwerking |
Success |
Blok is succesvol uitgevoerd |
Failed |
Blokuitvoering is mislukt met fouten |
Cancelled |
Blokuitvoering is geannuleerd |
Implementatievoorbeelden
cURL
# Blok uitvoeren zonder parameters
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"
# Blok uitvoeren met parameters
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(`Uitvoering mislukt: ${response.statusText}`);
}
}
// Gebruik
const executor = new BlockExecutor('your-auth-token');
// Uitvoeren zonder parameters
const result = await executor.executeBlock('block-guid');
console.log(`Uitvoering in wachtrij: ${result.executionId}`);
// Uitvoeren met parameters
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):
"""Zet blok in de wachtrij voor uitvoering."""
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'Blok uitvoeren mislukt: {response.text}')
# Gebruik
executor = BlockExecutor('your-auth-token')
# Uitvoeren zonder parameters
result = executor.execute_block('block-guid')
print(f"Uitvoering in wachtrij: {result['executionId']}")
# Uitvoeren met parameters
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($"Blok uitvoeren mislukt: {response.StatusCode}");
}
}
// Gebruik
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");
// Blok uitvoeren
var result = await executor.ExecuteBlockAsync(
Guid.Parse("block-guid"),
new { dateFrom = "2024-01-01", dateTo = "2024-12-31" });
Console.WriteLine($"Uitvoering in wachtrij: {result.ExecutionId}");
Beste praktijken
- Controleer Blokstatus: Controleer of het blok niet is uitgeschakeld voordat u het uitvoert
- Gebruik Parameters verstandig: Geef runtimeparameters mee om uitvoering aan te passen zonder de blokconfiguratie te wijzigen
- Houd rekening met asynchroon karakter: Blokuitvoering is asynchroon - gebruik de resultaten-endpoint om voltooiing te controleren
- Monitor uitvoering: Voor langlopende blokken, poll de resultaten-endpoint om de voortgang te volgen