Exécution des Blocs
Exécuter des Blocs d'Analyse
Exécutez les blocs individuellement de manière asynchrone et surveillez leur état de traitement. Les blocs traitent les données selon leur type et leur configuration.
Exécuter un Bloc
POST /api/{tenantId}/{projectId}/block/{blockId}/execute
Place un bloc dans la file d'attente pour une exécution asynchrone. Le bloc traitera les données selon son type et sa configuration (filtre, calculateur, alerte, etc.). Retourne un ID d'exécution pour suivre la progression.
Paramètres de Chemin
| Paramètre | Type | Obligatoire | Description |
|---|---|---|---|
tenantId |
GUID | Oui | L'identifiant du locataire |
projectId |
GUID | Oui | L'identifiant du projet |
blockId |
GUID | Oui | L'identifiant du bloc à exécuter |
Corps de la Requête (Optionnel)
{
"parameters": {
"dateFrom": "2024-01-01",
"dateTo": "2024-12-31",
"threshold": 1000
}
}
Réponse (202 Accepté)
{
"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"
}
Champs de la Réponse
| Champ | Type | Description |
|---|---|---|
blockId |
GUID | Le bloc qui a été placé en file d'attente |
executionId |
GUID | Identifiant unique de cette exécution |
status |
string | État actuel de l'exécution |
dateQueued |
datetime | Date à laquelle l'exécution a été mise en file d'attente |
dateStarted |
datetime | Date de début de l'exécution (null si non démarrée) |
dateEnded |
datetime | Date de fin de l'exécution (null si non terminée) |
result |
object | Données du résultat de l'exécution (null jusqu'à la fin) |
errorMessage |
string | Détails d'erreur si l'exécution a échoué |
message |
string | Message d'état lisible par l'humain |
Réponses d'Erreur
Non Trouvé (404) :
{
"Error": "Block not found",
"BlockId": "550e8400-e29b-41d4-a716-446655440000"
}
Non Autorisé (401) :
{message d'erreur décrivant l'échec d'autorisation}
Valeurs des Statuts d'Exécution
L'exécution d'un bloc progresse à travers ces états :
| Statut | Description |
|---|---|
Queued |
Le bloc est en attente dans la file d'exécution |
Running |
Le bloc est en cours de traitement des données |
Success |
Le bloc a terminé l'exécution avec succès |
Failed |
L'exécution du bloc a échoué avec des erreurs |
Cancelled |
L'exécution du bloc a été annulée |
Exemples d'Implémentation
cURL
# Exécuter un bloc sans paramètres
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"
# Exécuter un bloc avec paramètres
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(`Échec de l'exécution : ${response.statusText}`);
}
}
// Utilisation
const executor = new BlockExecutor('your-auth-token');
// Exécuter sans paramètres
const result = await executor.executeBlock('block-guid');
console.log(`Exécution en file d'attente : ${result.executionId}`);
// Exécuter avec paramètres
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):
"""Met en file d'exécution le bloc."""
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'Échec de l\'exécution du bloc : {response.text}')
# Utilisation
executor = BlockExecutor('your-auth-token')
# Exécuter sans paramètres
result = executor.execute_block('block-guid')
print(f"Exécution en file d'attente : {result['executionId']}")
# Exécuter avec paramètres
result = executor.execute_block('block-guid', {
'dateFrom': '2024-01-01',
'dateTo': '2024-12-31',
'threshold': 1000
})
print(f"Statut : {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($"Échec de l'exécution du bloc : {response.StatusCode}");
}
}
// Utilisation
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");
// Exécuter le bloc
var result = await executor.ExecuteBlockAsync(
Guid.Parse("block-guid"),
new { dateFrom = "2024-01-01", dateTo = "2024-12-31" });
Console.WriteLine($"Exécution en file d'attente : {result.ExecutionId}");
Bonnes Pratiques
- Vérifiez le statut du bloc : Assurez-vous que le bloc n'est pas désactivé avant l'exécution
- Utilisez les paramètres avec sagesse : Passez des paramètres d'exécution pour personnaliser l’exécution sans modifier la configuration du bloc
- Gérez la nature asynchrone : L'exécution des blocs est asynchrone - utilisez le point de terminaison des résultats pour vérifier la fin
- Surveillez l'exécution : Pour les blocs de longue durée, interrogez régulièrement le point de terminaison des résultats pour suivre la progression