Exécuter une Action

Déclenchez l'exécution d'une action de manière programmatique dans mindzieStudio.

Vue d'ensemble

Le point d'accès Execute Action vous permet de déclencher une action spécifique dans mindzieStudio. Les actions sont mises en file d'attente pour une exécution asynchrone et vous recevez un ID d'exécution pour suivre la progression.

Exécuter une Action

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

Exécute une action spécifique par son ID. L'action est ajoutée à une file d'exécution et traitée de manière asynchrone.

Requête

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

Paramètres de chemin

Paramètre	Type	Obligatoire	Description
tenantId	GUID	Oui	Identifiant de votre locataire
projectId	GUID	Oui	Identifiant de votre projet
actionId	GUID	Oui	L'action à exécuter

Réponse

Succès (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
}

Champs de la réponse

Champ	Type	Description
actionId	GUID	L'ID de l'action en cours d'exécution
actionExecutionId	GUID	Identifiant unique de cette instance d'exécution
dateStarted	datetime	Date à laquelle l'exécution a été mise en file d'attente
dateEnded	datetime	Date de fin d'exécution (null si toujours en cours)
status	string	Statut actuel de l'exécution
notes	string	Notes supplémentaires d'exécution ou messages d'erreur

Réponses d'erreur

Action non trouvée (404) :

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

Échec de création d'exécution (404) :

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

Non autorisé (401) :

HTTP/1.1 401 Unauthorized

{message d'erreur décrivant l'échec d'autorisation}

Valeurs du statut d'exécution

Statut	Description
Queued	L'action est en file d'attente et attend d'être traitée
Running	L'action est en cours d'exécution
Completed	L'action s'est terminée avec succès
Failed	L'exécution de l'action a échoué

Exemples d'implémentation

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('Action mise en file :', result);
      console.log('ID d\'exécution :', result.actionExecutionId);
      return result;
    } else if (response.status === 404) {
      const error = await response.json();
      console.error('Action non trouvée :', error);
      throw new Error(error.error);
    } else {
      throw new Error(`Échec de l'exécution : ${response.status}`);
    }
  } catch (error) {
    console.error('Erreur lors de l\'exécution de l\'action :', error);
    throw error;
  }
};

// Exemple d'utilisation
executeAction('aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee', 'your_token')
  .then(result => {
    // Stocker actionExecutionId pour le suivi
    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):
    """Exécuter une action et retourner les détails de l'exécution."""
    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'Action mise en file : {result}')
        print(f'ID d\'exécution : {result["actionExecutionId"]}')
        return result
    elif response.status_code == 404:
        error = response.json()
        print(f'Action non trouvée : {error}')
        raise Exception(error['error'])
    else:
        raise Exception(f'Échec de l\'exécution : {response.status_code}')

# Exemple d'utilisation
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($"Action mise en file. ID d'exécution : {result.ActionExecutionId}");
            return result;
        }
        else if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
        {
            throw new Exception($"Action {actionId} non trouvée");
        }
        else
        {
            throw new Exception($"Échec de l'exécution : {response.StatusCode}");
        }
    }
}

Bonnes pratiques

• Stocker l'ID d'exécution : Stockez toujours le actionExecutionId retourné pour suivre la progression de l'exécution
• Vérifier que l'action existe : Utilisez d'abord le point d'accès Get Action pour vérifier que l'action existe et est activée
• Gérer la nature asynchrone : Les actions s'exécutent de manière asynchrone - la réponse indique que l'action a été mise en file d'attente, pas qu'elle est terminée
• Gestion des erreurs : Implémentez une gestion d'erreurs appropriée pour les réponses 404 (action non trouvée) et 401 (non autorisé)
• Idempotence : Chaque appel crée une nouvelle exécution - évitez les appels en double si ce n'est pas voulu