FlowAPI : dans le champ d’application, global

  • Rversion finale: Yokohama
  • Mis à jour 30 janv. 2025
  • 45 minutes de lecture

    • FlowAPI fournit des méthodes pour exécuter des actions, des flux ou des flux secondaires dans des scripts côté serveur à l’aide de méthodes bloquantes ou non.

    Accédez aux méthodes FlowAPI dans des scripts globaux et définis dans le champ d’application à l’aide de l’espace de noms sn_fd . Créez des appels dans vos flux à l’aide de l’action Extrait de code dans Studio de workflow ou utilisez les méthodes détaillées ici pour mettre à jour manuellement les scripts.

    Remarque :
    Dans les instances séparées par domaine, les flux, les flux secondaires et les actions déclenchés par cette API s’exécutent dans le domaine de l’utilisateur qui a lancé le script. Par exemple, si un utilisateur dans le domaine ACME démarre un script qui déclenche un flux, le flux s’exécute dans le domaine ACME et ne peut accéder qu’aux données ACME, même si le flux s’exécute en tant qu’utilisateur système.
    Remarque :
    Pour optimiser les performances de l’instance, évitez d’appeler ces méthodes à partir d’un script de règle métier asynchrone. Créez plutôt un enregistrement de tâche planifiée dans l’interface Studio de workflow utilisateur.

    FlowAPI : cancel(String, contextId, String reason)

    Annule un flux, un flux secondaire ou une action en pause ou en cours d’exécution.

    Tableau 1. Paramètres
    Nom Type Description
    contextId Chaîne Sys_id de l’enregistrement des détails d’exécution du flux, du flux secondaire ou de l’action. Accédez aux détails de l’exécution en accédant à l’onglet Exécutions de flux dans Studio de workflowou transmettez la sys_id de l’enregistrement de contexte renvoyé par les méthodes startFlow(), startSubflow() ou startAction().
    Remarque :
    Il peut y avoir un léger délai d’annulation si le contexte cible s’exécute sur un autre nœud de l’instance. Les contextes s’exécutant sur le même nœud sont annulés immédiatement. Les contextes s’exécutant sur un autre nœud doivent d’abord attendre que l’annulation soit transférée au nœud approprié.
    motif Chaîne Facultatif. Motif d’annulation du flux, du flux secondaire ou de l’action. Apparaît dans le champ Message de la table Entrées de journal du moteur de flux [sys_flow_log].
    Tableau 2. Renvoie
    Type Description
    nul

    Cet exemple utilise la valeur de retour de la méthode startFlow() pour annuler les flux de longue durée.

    (function() { 

var now_GR = new GlideRecord('incident'); 
now_GR.addQuery('number', 'INC0000050'); 
now_GR.query(); 
now_GR.next(); 

      try { 
          var inputs = {}; 
          inputs['current'] = now_GR; // GlideRecord of table: 
          inputs['table_name'] = 'incident'; 

          // Starts the flow asynchronously.
          var result = sn_fd.FlowAPI.getRunner()
          .flow('global.myFlow')
          .inBackground()
          .withInputs(inputs)
          .run();

          var contextId = result.getContextId();
          var dateRun = result.getDate();
          var domainUsed = result.getDomainId();
          var flowName = result.getFlowObjectName();
          var flowObjectType = result.getFlowObjectType(); 

      } catch (ex) { 
          var message = ex.getMessage(); 
          gs.error(message); 
      } 
})();

 
// Call the cancel() method using the context Id returned from the startFlow() method
sn_fd.FlowAPI.cancel(contextId, 'Flow took too long to execute.');

    Cet exemple annule tous les flux nommés Test Flow.

    var now_GR = new GlideRecord("sys_flow_context");
now_GR.addQuery("name", "Test Flow");
now_GR.query();

while (now_GR.next()) {
sn_fd.FlowAPI.cancel(now_GR.getUniqueValue(), 'Canceling Test Flows');
}

    FlowAPI : executeAction (nom de chaîne, entrées de carte, délai d’expiration du numéro)

    Exécute une action à partir d’un script côté serveur de façon synchrone.

    Exécutez une action à partir d’une règle métier, d’un include de script ou de tout autre script côté serveur. Les actions exécutées à l’aide de cette méthode sont exécutées de manière synchrone, de sorte que la méthode a accès aux sorties créées par l’action. Utilisez startAction pour exécuter une action de manière asynchrone.
    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : dans le champ d’application, qui déconseille les méthodes existantes utilisées pour créer des objets et exécuter Studio de workflow des flux et des actions. Utilisez la méthode getRunner() dans la classe FlowAPI pour retourner un objet ScriptableFlowRunner et utiliser les méthodes associées. Utilisez les méthodes ScriptableFlowRunner si vous devez prendre en charge Séparation de domaine.
    Remarque :
    Cette méthode exécute l’action en tant qu’utilisateur qui initie la session.
    Tableau 3. Paramètres
    Nom Type Description
    nom Chaîne Le périmètre et le nom de l’action à exécuter, par exemple global.action_name.
    entrées Carte Paires nom-valeur qui définissent les entrées d’action. Utilisez le nom de l’entrée, pas l’étiquette d’entrée.
    timeout Numéro Facultatif. Délai d’expiration en millisecondes. Cette valeur remplace le délai par défaut de 30 secondes spécifié par la com.glide.hub.flow_api.default_execution_time propriété système. Une fois le délai expiré, une exception est levée.
    Tableau 4. Renvoie
    Type Description
    Objet Sorties d’action.

    Dans cet exemple, le script utilise sn_fd. FlowAPI.executeAction pour exécuter une action appelée actionforpassword2test dans le champ d’application global. Une variable appelée entrées contient les entrées de l’action. Dans ce cas, un nom et un mot de passe. Les sorties de l’action sont stockées dans la variable outputs, qui dans ce cas, est un objet de mot de passe chiffré. Le code est encapsulé dans une instruction try/catch pour capturer toute erreur pouvant se produire lors de l’exécution du flux.

    (function() {
	
  try {
    var inputs = {};
    inputs['name'] = ; // String 
    inputs['password2'] = ; // Password (2 Way Encrypted) 
		
    // Execute Synchronously: Run in foreground. Code snippet has access to outputs.
    // var timeout = ; //timeout in ms
    //sn_fd.FlowAPI.executeAction('global.actionforpassword2test', inputs, timeout)
    var outputs = sn_fd.FlowAPI.executeAction('global.actionforpassword2test', inputs);

    // Get Outputs:
    // Note: outputs can only be retrieved when executing synchronously.
    var output = outputs['output']; // Password (2 Way Encrypted)
		
  } catch (ex) {
    var message = ex.getMessage();
    gs.error(message);
  }
})();

    FlowAPI : executeActionQuick(nom de chaîne, entrées de carte, délai d’expiration du numéro)

    Exécutez une action à partir d’un script côté serveur de façon synchrone à partir de la session utilisateur actuelle sans créer de détails d’exécution ou d’autres enregistrements connexes. Améliorez les performances en éliminant les frais généraux de tenue d’enregistrement. Utilisez cette API pour augmenter la vitesse de traitement de gros volumes, par exemple plusieurs exécutions par seconde, dans un environnement de production.

    Reporting et enregistrements générés
    Cette méthode ne crée pas de détails d’exécution ni d’enregistrements de contexte, quels que soient les Studio de workflow paramètres.
    Assistance en attente
    Cette méthode ne prend pas en charge la mise en pause de l’action pour attendre les conditions. Les étapes qui mettent en pause pour des conditions d’attente telles que Demander l’approbation ou Attendre une condition ne sont pas prises en charge.
    Prise en charge de Serveur MID
    Cette méthode ne prend pas en charge la pause d’une action à exécuter à partir d’un Serveur MID.
    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : dans le champ d’application, qui déconseille les méthodes existantes utilisées pour créer des objets et exécuter Studio de workflow des flux et des actions. Utilisez la méthode getRunner() dans la classe FlowAPI pour retourner un objet ScriptableFlowRunner et utiliser les méthodes associées. Utilisez les méthodes ScriptableFlowRunner si vous devez prendre en charge Séparation de domaine.
    Tableau 5. Paramètres
    Nom Type Description
    nom Chaîne Périmètre et nom interne de l’action à exécuter. Par exemple, global.action_name. Localisez le champ Nom interne dans la liste d’actions Studio de workflow .
    entrées Carte Paires nom-valeur qui définissent les entrées d’action. Vous trouverez les entrées d’action disponibles et les types de données requis sous Entrées dans le plan d’action. Utilisez le nom de l’entrée, pas l’étiquette d’entrée. Par exemple, {'table' :'incident','sys_id' :'a39d8e3cf0212300964feeefe80ff0ed'}.
    timeout Numéro

    Facultatif. Délai d’expiration en millisecondes. Cette valeur remplace le délai par défaut de 30 secondes spécifié par la com.glide.hub.flow_api.default_execution_time propriété système. Une fois le délai expiré, une exception est levée.
    Tableau 6. Renvoie
    Type Description
    Objet Objet contenant les sorties définies par l’action. Vous trouverez les sorties de l’action sous Sorties dans le plan d’action. 
    (function() {
  try {

    var grIncident = new GlideRecord('incident');
    grIncident.get('57af7aec73d423002728660c4cf6a71c');

    var inputs = {};
    inputs['variable'] = grIncident;

    var outputs = sn_fd.FlowAPI.executeActionQuick('global.update_record_test', inputs);

    // Get Outputs:
    // Note: outputs can only be retrieved when executing synchronously.
    var output1 = outputs['output1']; 

  } catch (ex) { 
    var message = ex.getMessage();
    gs.error(message);
    }
	
})();

    FlowAPI : executeDataStreamAction(nom de chaîne, entrées de carte, délai d’expiration du numéro)

    Exécute une action de flux de données de façon synchrone à partir d’un script côté serveur et renvoie un objet ScriptableDataStream.

    Pour plus d’informations sur les actions de flux de données, voir Actions de flux de données et pagination.

    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : dans le champ d’application, qui déconseille les méthodes existantes utilisées pour créer des objets et exécuter Studio de workflow des flux et des actions. Utilisez la méthode getRunner() dans la classe FlowAPI pour retourner un objet ScriptableFlowRunner et utiliser les méthodes associées. Utilisez les méthodes ScriptableFlowRunner si vous devez prendre en charge Séparation de domaine.
    Remarque :
    Enveloppez toujours la logique de flux de données dans un bloc try/catch pour intercepter les erreurs. Incluez toujours une instruction finally qui se termine par la méthode close() de la classe ScriptableDataStream pour fermer le flux de données et éviter les problèmes de performances.
    Tableau 7. Paramètres
    Nom Type Description
    nom Chaîne Le périmètre et le nom de l’action de flux de données à exécuter. Par exemple, global.data_stream_action_name.
    entrées Carte Paires nom-valeur qui définissent les entrées d’action. Utilisez le nom de l’entrée, pas l’étiquette d’entrée. Si l’action n’a pas d’entrées, n’incluez pas ce paramètre.
    timeout Numéro Facultatif. Délai avant l’expiration de l’action. Une fois le délai expiré, une exception est levée. Le délai d’expiration s’applique uniquement à la méthode executeDataStreamAction , et non aux méthodes de la classe ScriptableDataStream .

    Valeur par défaut : 30 000, spécifiée par la propriété système com.glide.hub.flow_api.default_execution_time

    Unité : millisecondes
    Tableau 8. Renvoie
    Type Description
    ScriptableDataStream Objet utilisé pour itérer à travers les éléments du flux de données. Utilisez les méthodes de la classe ScriptableDataStream pour interagir avec cet objet. Consultez API ScriptableDataStream.

    Cet exemple crée un enregistrement d’incident pour chaque élément renvoyé dans le flux de données.

    (function() {
	
  try {

    // Execute Data Stream Action. 
    var stream = sn_fd.FlowAPI.executeDataStreamAction('x_my_scope.data_stream_name');

    // Process each item in the data stream
    while (stream.hasNext()) {

      // Get a single item from the data stream.
      var item = stream.next();

      // Use the item. 
      var now_GR = new GlideRecord('incident');
      now_GR.setValue('number',item.id);
      now_GR.setValue('short_description',item.name);
      now_GR.insert();
		
      // By default, this code snippet will terminate after 10 items.
      // Remove or modify this limit after testing your code.
      if (stream.getItemIndex() >= 9) {
        break;
      }
    }
  } catch (ex) {
    var message = ex.getMessage();
    gs.error(message);
  } finally {
    stream.close();
  }
	
})();

    FlowAPI : executeFlow(nom de chaîne, entrées de carte, délai d’expiration du numéro)

    Exécute un flux à partir d’un script côté serveur de façon synchrone.

    Exécutez un flux à partir d’une règle métier, d’un include de script ou de tout autre script côté serveur. Les flux s’exécutent à l’aide de cette méthode de façon synchrone. Utilisez startFlow pour exécuter un flux de manière asynchrone.
    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : dans le champ d’application, qui déconseille les méthodes existantes utilisées pour créer des objets et exécuter Studio de workflow des flux et des actions. Utilisez la méthode getRunner() dans la classe FlowAPI pour retourner un objet ScriptableFlowRunner et utiliser les méthodes associées. Utilisez les méthodes ScriptableFlowRunner si vous devez prendre en charge Séparation de domaine.
    Remarque :
    Cette méthode exécute le flux en tant qu’utilisateur spécifié dans les propriétés du flux.
    Tableau 9. Paramètres
    Nom Type Description
    nom Chaîne Le périmètre et le nom du flux à exécuter, par exemple global.flow_name.
    entrées Carte Paires nom-valeur qui définissent les entrées de déclenchement. Utilisez le nom de l’entrée, pas l’étiquette d’entrée.
    timeout Numéro Facultatif. Délai d’expiration en millisecondes. Cette valeur remplace le délai par défaut de 30 secondes spécifié par la com.glide.hub.flow_api.default_execution_time propriété système. Une fois le délai expiré, une exception est levée.
    Tableau 10. Renvoie
    Type Description
    Néant Le fonctionnement normal ne produit aucune valeur de retour.
    Exception : L’API lève une exception lorsqu’un flux appelé de manière synchrone s’interrompt. L’exécution actuelle est dans l’état En attente. Dans la plupart des cas, l’exception est supprimée lorsque le flux reprend. Toutefois, l’API ne peut pas reprendre un flux qui a été envoyé à un serveur MID.

    Cet exemple utilise sn_fd. FlowAPI.executeFlow pour exécuter un flux global appelé test_flow. Ce flux est normalement déclenché lorsqu’un enregistrement de la table d’incidents est mis à jour. Étant donné que vous activez le flux à partir d’un script, vous devez fournir ces informations. Le code crée une variable d’entrée contenant l’enregistrement actuel et la table de l’enregistrement. Le code est encapsulé dans une instruction try/catch pour capturer toute erreur pouvant se produire lors de l’exécution du flux.

    (function() {
  try {
    var inputs = {};
    inputs['current'] = ; // GlideRecord of table:  
    inputs['table_name'] = 'incident';

    // Execute Synchronously: Run in foreground.
    // var timeout = ; //timeout in ms
    //sn_fd.FlowAPI.executeFlow('global.test_flow', inputs, timeout)
    sn_fd.FlowAPI.executeFlow('global.test_flow', inputs);
  } catch (ex) {
    var message = ex.getMessage();
    gs.error(message);
  }
})();

    FlowAPI : executeFlowQuick(nom de chaîne, entrées de carte, délai d’expiration du numéro)

    Exécute un flux, un flux secondaire, une action ou une action de flux de données à partir d’un script côté serveur de façon synchrone ou asynchrone sans créer les détails de l’exécution ou d’autres enregistrements connexes. Améliore les performances en éliminant les frais généraux de tenue d’enregistrement. Utilisez cette API pour augmenter la vitesse de traitement de gros volumes, par exemple plusieurs exécutions par seconde, dans un environnement de production.

    Reporting et enregistrements générés
    Cette méthode ne crée pas de détails d’exécution ni d’enregistrements de contexte, quels que soient les Studio de workflow paramètres.
    Exécuter en tant qu'utilisateur
    Cette méthode exécute le flux en tant qu’utilisateur qui initie la session. Définir le flux pour qu’il s’exécute en tant qu’utilisateur système ou emprunter l’identité d’un utilisateur n’est pas pris en charge.
    Assistance en attente
    Cette méthode ne prend pas en charge la mise en pause du flux pour attendre les conditions. Les actions ou la logique de flux qui mettent en pause pour des conditions d’attente telles que Demander l’approbation, Attendre une condition ou Attendre pendant une durée ne sont pas prises en charge.
    Prise en charge de Serveur MID
    Cette méthode ne prend pas en charge la mise en pause d’un flux à exécuter à partir d’un serveur MID.
    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : dans le champ d’application, qui déconseille les méthodes existantes utilisées pour créer des objets et exécuter Studio de workflow des flux et des actions. Utilisez la méthode getRunner() dans la classe FlowAPI pour retourner un objet ScriptableFlowRunner et utiliser les méthodes associées. Utilisez les méthodes ScriptableFlowRunner si vous devez prendre en charge Séparation de domaine.
    Tableau 11. Paramètres
    Nom Type Description
    nom Chaîne Périmètre et nom interne du flux à exécuter. Par exemple, global.flow_name. Localisez le champ Nom interne dans la liste des Studio de workflow flux.
    entrées Carte Paires nom-valeur qui définissent les entrées de déclenchement. Vous trouverez les entrées de déclencheur disponibles et les types de données requis dans la section Déclencheur du flux. Utilisez le nom de l’entrée, pas l’étiquette d’entrée. Par exemple, {'table' :'incident','sys_id' :'a39d8e3cf0212300964feeefe80ff0ed'}.
    timeout Numéro Facultatif. Délai d’expiration en millisecondes. Cette valeur remplace le délai par défaut de 30 secondes spécifié par la com.glide.hub.flow_api.default_execution_time propriété système. Une fois le délai expiré, une exception est levée.
    Tableau 12. Renvoie
    Type Description
    nul 
    (function() {
	
  try {
    var grIncident = new GlideRecord('incident');
    grIncident.get('ed92e8d173d023002728660c4cf6a7bc');

    var inputs = {};
    inputs['current'] = grIncident;
    inputs['table_name'] = 'incident';
		
    sn_fd.FlowAPI.executeFlowQuick('global.test_quick_flow', inputs);
		
  } catch (ex) {
    var message = ex.getMessage();
    gs.error(message);
	}
	
})();

    FlowAPI : executeSubflow(nom de chaîne, entrées de carte, délai d’expiration du numéro)

    Exécute un flux secondaire à partir d’un script côté serveur de façon synchrone.

    Exécutez un flux secondaire à partir d’une règle métier, d’un include de script ou de tout autre script côté serveur. Les flux secondaires s’exécutent à l’aide de cette méthode de façon synchrone. Utilisez startSubflow pour exécuter un flux secondaire de manière asynchrone.
    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : dans le champ d’application, qui déconseille les méthodes existantes utilisées pour créer des objets et exécuter Studio de workflow des flux et des actions. Utilisez la méthode getRunner() dans la classe FlowAPI pour retourner un objet ScriptableFlowRunner et utiliser les méthodes associées. Utilisez les méthodes ScriptableFlowRunner si vous devez prendre en charge Séparation de domaine.
    Remarque :
    Cette méthode exécute le flux en tant qu’utilisateur spécifié dans les propriétés du flux.
    Tableau 13. Paramètres
    Nom Type Description
    nom Chaîne Périmètre et nom du flux secondaire à exécuter, par exemple global.subflow_name.
    entrées Carte Paires nom-valeur qui définissent les entrées de flux secondaire. Utilisez le nom de l’entrée, pas l’étiquette d’entrée.
    timeout Numéro Facultatif. Délai d’expiration en millisecondes. Cette valeur remplace le délai par défaut de 30 secondes spécifié par la com.glide.hub.flow_api.default_execution_time propriété système. Une fois le délai expiré, une exception est levée.
    Tableau 14. Renvoie
    Type Description
    Objet Objet contenant les sorties de flux secondaire.
    Exception : L’API lève une exception lorsqu’un flux appelé de manière synchrone s’interrompt. L’exécution actuelle est dans l’état En attente. Dans la plupart des cas, l’exception est supprimée lorsque le flux reprend. Toutefois, l’API ne peut pas reprendre un flux qui a été envoyé à un serveur MID.

    Dans cet exemple, le script utilise sn_fd. FlowAPI.executeSubflow pour exécuter un flux secondaire appelé subflowTest dans le champ d’application global. Une variable appelée entrées contient les entrées pour le flux secondaire. Dans ce cas, un nom et un mot de passe. Le code est encapsulé dans une instruction try/catch pour capturer toute erreur pouvant se produire lors de l’exécution du flux.

    
(function() {
	
	try {
		var inputs = {};
		inputs['name'] = ; // String 
		inputs['password2'] = ; // Password (2 Way Encrypted) 
		
		// Execute Synchronously: Run in foreground.
		// var timeout = ; //timeout in ms
              //sn_fd.FlowAPI.executeSubflow('global.subflowTest', inputs, timeout)
              var outputs = sn_fd.FlowAPI.executeSubflow('global.subflowTest', inputs);
		
	} catch (ex) {
		var message = ex.getMessage();
		gs.error(message);
	}	
})();

    FlowAPI : executeSubflowQuick(nom de chaîne, entrées de carte, délai d’expiration du numéro)

    Exécutez un flux secondaire à partir d’un script côté serveur de façon synchrone à partir de la session utilisateur actuelle sans créer les détails de l’exécution ou d’autres enregistrements connexes. Améliorez les performances en éliminant les frais généraux de tenue d’enregistrement. Utilisez cette API pour augmenter la vitesse de traitement de gros volumes, par exemple plusieurs exécutions par seconde, dans un environnement de production.

    Reporting et enregistrements générés
    Cette méthode ne crée pas de détails d’exécution ni d’enregistrements de contexte, quels que soient les Studio de workflow paramètres.
    Exécuter en tant qu'utilisateur
    Cette méthode exécute le flux en tant qu’utilisateur qui initie la session. Définir le flux pour qu’il s’exécute en tant qu’utilisateur système ou emprunter l’identité d’un utilisateur n’est pas pris en charge.
    Assistance en attente
    Cette méthode ne prend pas en charge la mise en pause du flux pour attendre les conditions. Les actions ou la logique de flux qui mettent en pause pour des conditions d’attente telles que Demander l’approbation, Attendre une condition ou Attendre pendant une durée ne sont pas prises en charge.
    Prise en charge de Serveur MID
    Cette méthode ne prend pas en charge la mise en pause d’un flux à exécuter à partir d’un serveur MID.
    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : dans le champ d’application, qui déconseille les méthodes existantes utilisées pour créer des objets et exécuter Studio de workflow des flux et des actions. Utilisez la méthode getRunner() dans la classe FlowAPI pour retourner un objet ScriptableFlowRunner et utiliser les méthodes associées. Utilisez les méthodes ScriptableFlowRunner si vous devez prendre en charge Séparation de domaine.
    Tableau 15. Paramètres
    Nom Type Description
    nom Chaîne Périmètre et nom interne du flux secondaire à exécuter. Par exemple, global.subflow_name. Localisez le champ Nom interne dans la liste des Studio de workflow flux secondaires.
    entrées Carte Paires nom-valeur qui définissent les entrées de flux secondaire. Vous trouverez les entrées de flux secondaire disponibles et les types de données requis sous Entrées dans le flux secondaire. Utilisez le nom de l’entrée, pas l’étiquette d’entrée. Par exemple, {'table' :'incident','sys_id' :'a39d8e3cf0212300964feeefe80ff0ed'}.
    timeout Numéro Facultatif. Délai d’expiration en millisecondes. Cette valeur remplace le délai par défaut de 30 secondes spécifié par la com.glide.hub.flow_api.default_execution_time propriété système. Une fois le délai expiré, une exception est levée.
    Tableau 16. Renvoie
    Type Description
    Objet Objet contenant des sorties définies par le flux secondaire. Vous trouverez les sorties du flux secondaire sous Entrées et sorties de flux secondaire dans le plan du flux secondaire. 
    (function() {

  try {
    var grIncident = new GlideRecord('incident');
    grIncident.get('57af7aec73d423002728660c4cf6a71c');

    var inputs = {};
    inputs['variable'] = grIncident;

    var outputs = sn_fd.FlowAPI.executeSubflowQuick('global.test_quick_run_subflow', inputs);

    // Get Outputs:
    // Note: outputs can only be retrieved when executing synchronously.
    var output1 = outputs['output1']; 
		
  } catch (ex) {
    var message = ex.getMessage();
    gs.error(message);
    }
	
})();

    FlowAPI : getErrorMessage(String contextId)

    Renvoie les messages d’erreur produits par un flux, un flux secondaire ou une action. Cette méthode ne peut pas renvoyer les messages des flux, des flux secondaires ou des actions exécutées avec l’API quick().

    Tableau 17. Paramètres
    Nom Type Description
    contextId Chaîne Le sys_id du flux, du flux secondaire ou de l’action dont vous souhaitez obtenir les messages d’erreur.
    Tableau 18. Renvoie
    Type Description
    Chaîne La dernière opération exécutée et le message d’erreur qu’elle a généré.

    Cet exemple démarre un flux secondaire global appelé test_error_subflow et renvoie tous les messages d’erreur qu’il produit. Normalement, un script unique n’exécute pas un flux et n’obtient pas ses messages d’erreur. En règle générale, un autre script ou Studio de workflow aurait déjà exécuté le flux. Le code est encapsulé dans une instruction try/catch pour capturer toute erreur pouvant se produire lors de l’exécution du flux.

    (function() {

  try {
    // Gather inputs to call flow
    var inputs = {};
    inputs['ah_task'] = myTaskRecord; // GlideRecord of table: task
    inputs['ah_comment'] ='Test Comment' ; // String

    // Call flow with known errors
    var contextId = sn_fd.FlowAPI.startSubflow('global.test_error_subflow', inputs);

    // Get flow error message
    var errormsg = sn_fd.FlowAPI.getErrorMessage(contextId);
    return errormsg;

  } catch (ex) {
    var message = ex.getMessage();
    gs.error(message);
  }
})();

    Sortie :

    Operation (test_error_flow.574033f6db6811102166e2291396199f.274073f6db6811102166e22913961908.0be0d916c31332002841b63b12d3ae13) failed with error: com.snc.process_flow.exception.OpException: Value of field record is not a GlideRecord
at com.snc.process_flow.operation.FieldValue.getGlideRecord(FieldValue.java:145)
at com.snc.process_flow.operation.CRUDOperation.getInputValidGlideRecord(CRUDOperation.java:54)
at com.snc.process_flow.operation.RecordDeleteOperation.run(RecordDeleteOperation.java:26)
at com.snc.process_flow.engine.Operation.execute(Operation.java:212)
at com.snc.process_flow.engine.restricted_caller_access.ExecuteWithCallerAccessTracking.executeWithMetaStack(ExecuteWithCallerAccessTracking.java:31)
at com.snc.process_flow.engine.ProcessEngine.executeOps(ProcessEngine.java:570)
at com.snc.process_flow.engine.ProcessEngine.runInternal(ProcessEngine.java:476)
at com.snc.process_flow.engine.ProcessEngine.run(ProcessEngine.java:462)
at com.snc.process_flow.engine.ProcessAutomation.run(ProcessAutomation.java:86)
at com.snc.process_flow.engine.GlideProcessAutomation.runSync(GlideProcessAutomation.java:155)
at com.snc.process_flow.engine.GlideProcessAutomation.runWithDomain(GlideProcessAutomation.java:270)
at com.snc.process_flow.engine.GlideProcessAutomation.lambda$runAsUserSync$1(GlideProcessAutomation.java:237)
at com.snc.process_flow.engine.PFSessionClone.run(PFSessionClone.java:70)
at com.snc.process_flow.engine.GlidePFSession.runPlanAsUserSession(GlidePFSession.java:42)
at com.snc.process_flow.engine.GlideProcessAutomation.runAsUserSync(GlideProcessAutomation.java:235)
at com.snc.process_flow.engine.GlideProcessAutomation.messageFlow(GlideProcessAutomation.java:330)
at com.snc.process_flow.engine.GlideProcessAutomation.messageFlow(GlideProcessAutomation.java:309)
at com.snc.process_flow.engine.ProcessHubEventHandler.doSendMessage(ProcessHubEventHandler.java:475)
at com.snc.process_flow.engine.ProcessHubEventHandler.process(ProcessHubEventHandler.java:119)
at com.snc.process_flow.engine.ProcessHubEventHandler.process(ProcessHubEventHandler.java:91)
at com.snc.process_flow.engine.FlowEventManager.processEvents(FlowEventManager.java:122)
at com.glide.job.EventHandlerJob.execute(EventHandlerJob.java:38)
at com.glide.schedule.JobExecutor.lambda$executeJob$0(JobExecutor.java:129)
at com.snc.db.data_replicate.replicator.DataReplicationAdvisors.runInOriginatorContext(DataReplicationAdvisors.java:73)
at com.glide.schedule.JobExecutor.lambda$inDataReplicationContext$2(JobExecutor.java:159)
at com.glide.schedule.JobExecutor.executeJob(JobExecutor.java:132)
at com.glide.schedule.JobExecutor.execute(JobExecutor.java:116)
at com.glide.schedule_v2.SchedulerWorkerThread.executeJob(SchedulerWorkerThread.java:338)
at com.glide.schedule_v2.SchedulerWorkerThread.lambda$process$0(SchedulerWorkerThread.java:220)
at com.glide.worker.TransactionalWorkerThread.executeInTransaction(TransactionalWorkerThread.java:35)
at com.glide.schedule_v2.SchedulerWorkerThread.process(SchedulerWorkerThread.java:220)
at com.glide.schedule_v2.SchedulerWorkerThread.run(SchedulerWorkerThread.java:101)

    FlowAPI : getFlowStages(String scopedFlowName)

    Renvoyer une chaîne JSON contenant la liste des étapes de flux.

    Tableau 19. Paramètres
    Nom Type Description
    scopedFlowName Chaîne Le périmètre de l’application et le nom du flux dont vous souhaitez obtenir les étapes.
    Tableau 20. Renvoie
    Type Description
    Chaîne Chaîne au format JSON qui répertorie les étapes du flux en fonction de leur valeur d’enregistrement d’étape.

    Cet exemple montre l’obtention des étapes pour le flux de demande d’élément de Catalogue de services.

    (function() {

  try {
    // Name of flow with stages
    var flowName = "service_catalog_item_request";

    // Get flow stages
    var flowStages = sn_fd.FlowAPI.getFlowStages(flowName);
    //Print JSON as info message  
    gs.info(flowStages);
    return flowStages;

  } catch (ex) {
    var message = ex.getMessage();
    gs.error(message);
  }
})();

    Sortie :

    La chaîne JSON contient des paires nom-valeur pour un champ d’étape. Consultez pour plus d'informations.

    [
  {
    "label": "Manager Approval",
    "value": "manager_approval",
    "type": "standard",
    "duration": "1970-01-03 00:00:00",
    "states": {
      "pending": "Pending - has not started",
      "inprogress": "In progress",
      "skipped": "Skipped",
      "complete": "Completed",
      "error": "Error"
    },
    "flow": "30f3d26187e92300e0ef0cf888cb0b91",
    "alwaysShow": true,
    "order": 0
  },
  {
    "label": "Set current stage state to:  [Error]",
    "value": "Set current stage state to:  [Error]",
    "type": "error",
    "duration": "1970-01-01 00:00:00",
    "states": {
      "pending": "Pending - has not started",
      "inprogress": "In progress",
      "skipped": "Skipped",
      "complete": "Completed",
      "error": "Error"
    },
    "flow": "30f3d26187e92300e0ef0cf888cb0b91",
    "alwaysShow": false,
    "order": 0
  },
  {
    "label": "Dept. Head Approval",
    "value": "Dept. Head Approval",
    "type": "standard",
    "duration": "1970-01-03 00:00:00",
    "states": {
      "pending": "Pending - has not started",
      "inprogress": "In progress",
      "skipped": "Skipped",
      "complete": "Completed",
      "error": "Error"
    },
    "flow": "30f3d26187e92300e0ef0cf888cb0b91",
    "alwaysShow": true,
    "order": 1
  },
  {
    "label": "CIO Approval",
    "value": "CIO Approval",
    "type": "standard",
    "duration": "1970-01-03 00:00:00",
    "states": {
      "pending": "Pending - has not started",
      "inprogress": "In progress",
      "skipped": "Skipped",
      "complete": "Completed",
      "error": "Error"
    },
    "flow": "30f3d26187e92300e0ef0cf888cb0b91",
    "alwaysShow": true,
    "order": 2
  },
  {
    "label": "Order Fulfillment",
    "value": "Order Fulfillment",
    "type": "standard",
    "duration": "1970-01-05 00:00:00",
    "states": {
      "pending": "Pending - has not started",
      "inprogress": "In progress",
      "skipped": "Skipped",
      "complete": "Completed",
      "error": "Error"
    },
    "flow": "30f3d26187e92300e0ef0cf888cb0b91",
    "alwaysShow": true,
    "order": 3
  },
  {
    "label": "Backordered",
    "value": "Backordered",
    "type": "standard",
    "duration": "1970-01-15 00:00:00",
    "states": {
      "pending": "Pending - has not started",
      "inprogress": "In progress",
      "skipped": "Skipped",
      "complete": "Completed",
      "error": "Error"
    },
    "flow": "30f3d26187e92300e0ef0cf888cb0b91",
    "alwaysShow": true,
    "order": 4
  },
  {
    "label": "Deployment",
    "value": "Deployment",
    "type": "standard",
    "duration": "1970-01-02 00:00:00",
    "states": {
      "pending": "Pending - has not started",
      "inprogress": "In progress",
      "skipped": "Skipped",
      "complete": "Completed",
      "error": "Error"
    },
    "flow": "30f3d26187e92300e0ef0cf888cb0b91",
    "alwaysShow": true,
    "order": 5
  },
  {
    "label": "Request Cancelled",
    "value": "Request Cancelled",
    "type": "standard",
    "duration": "1970-01-01 00:00:00",
    "states": {
      "pending": "Pending - has not started",
      "inprogress": "In progress",
      "skipped": "Skipped",
      "complete": "Completed",
      "error": "Error"
    },
    "flow": "30f3d26187e92300e0ef0cf888cb0b91",
    "alwaysShow": true,
    "order": 6
  },
  {
    "label": "Completed",
    "value": "complete",
    "type": "standard",
    "duration": "1970-01-01 00:00:00",
    "states": {
      "pending": "Pending - has not started",
      "inprogress": "In progress",
      "skipped": "Skipped",
      "complete": "Completed",
      "error": "Error"
    },
    "flow": "30f3d26187e92300e0ef0cf888cb0b91",
    "alwaysShow": true,
    "order": 7
  }
]

    FlowAPI : getOutputs(String contextId)

    Renvoie les résultats d’une action ou d’un flux secondaire terminé.

    Vous pouvez utiliser les valeurs de retour des méthodes startAction() oustartSubflow() comme paramètre contextId.
    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : dans le champ d’application, qui déconseille les méthodes existantes utilisées pour créer des objets et exécuter Studio de workflow des flux et des actions. Utilisez la méthode getRunner() dans la classe FlowAPI pour retourner un objet ScriptableFlowRunner et utiliser les méthodes associées. Utilisez les méthodes ScriptableFlowRunner si vous devez prendre en charge Séparation de domaine.
    Tableau 21. Paramètres
    Nom Type Description
    contextId Chaîne Le sys_id de l’action ou du flux secondaire dont vous souhaitez obtenir les sorties.
    Tableau 22. Renvoie
    Type Description
    Objet Objet contenant les sorties d’action ou de flux secondaire.

    Cet exemple démarre un flux secondaire global appelé test_subflow, attend la fin du flux, puis obtient ses valeurs de sortie. Normalement, un script unique n’exécute pas un flux et n’obtient pas ses valeurs de sortie. Étant donné qu’un flux peut ne pas se terminer avant l’appel getOutputs(), cet exemple utilise un délai d’attente. En règle générale, un autre script ou Studio de workflow aurait déjà exécuté le flux. Le code est encapsulé dans une instruction try/catch pour capturer toute erreur pouvant se produire lors de l’exécution du flux.

    (function() {

  try {
    // Gather inputs to call flow
    var inputs = {};
    inputs['ah_task'] = myTaskRecord; // GlideRecord of table: task
    inputs['ah_comment'] ='Test Comment' ; // String

    // Call flow
    var contextId = sn_fd.FlowAPI.startSubflow('global.test_subflow', inputs);

    // Wait for the flow to finish running

    // Get flow outputs
    var outputs = sn_fd.FlowAPI.getOutputs(contextId);
    var output1 = outputs['output1'];
    return output1;

  } catch (ex) {
    var message = ex.getMessage();
    gs.error(message);
  }
})();

    FlowAPI : getRunner()

    Renvoie un objet de générateur ScriptableFlowRunner pour un flux ou une action que vous souhaitez exécuter.

    Tableau 23. Paramètres
    Nom Type Description
    Aucun
    Tableau 24. Renvoie
    Type Description
    ScriptableFlowRunner Objet générateur utilisé pour exécuter une action, un flux ou un Studio de workflow flux secondaire.

    Cet exemple exécute un flux de manière synchrone.

    
(function() {
  try {

    var inputs = {}; 

    inputs['sys_id'] = '57af7aec73d423002728660c4cf6a71c';  // Pass the record's sys_id in as input.  

    var result = sn_fd.FlowAPI.getRunner()  // Create a ScriptableFlowRunner builder object.
      .action('global.markapproved')        // Run the global scope action named markapproved.
      .inForeground()
      .inDomain('TOP/ACME')                 // Run the action from the TOP/ACME domain.                               
      .withInputs(inputs)
      .run();                               // Run the action and return a FlowRunnerResult object.

    var contextId = result.getContextId();  // Retrieve the context ID from the result
    var dateRun = result.getDate();
    var domainUsed = result.getDomainId();  // Retrieve the Domain ID from the result.
    var flowName = result.getFlowObjectName();
    var flowObjectType = result.getFlowObjectType();

    var outputs = result.getOutputs();            // Retrieve any outputs from the action execution.
    var newApprovalStatus = outputs['approval'];  // Echo back the approval status for verification.
		
  } catch (ex) {
    var message = ex.getMessage();
    gs.error(message);
  }
	
})();

    FlowAPI : getStatus(String contextId)

    Renvoie l’état d’un flux, d’un flux secondaire ou d’une action.

    Tableau 25. Paramètres
    Nom Type Description
    contextId Chaîne Le sys_id du flux, du flux secondaire ou de l’action dont vous souhaitez obtenir l’état.
    Tableau 26. Renvoie
    Paramètre Type Description
    <Object> Objet Objet contenant l’état actuel du flux, du flux secondaire ou de l’action sous forme de paires nom-valeur. 
    {
    "hasLookupError": Boolean,
    "errorMessage": "String",
    "contextStatus": {Object}
  }
    <Object>.hasLookupError Booléen Marqueur indiquant si un problème s’est produit lors de la recherche de l’état du contexte du flux, du flux secondaire ou de l’action.
    {
    "hasLookupError": false,
    "errorMessage": "",
    "contextStatus": {Object}
  }
    <Object>.errorMessage Chaîne Message d’erreur renvoyé par l’opération de recherche de contexte. Ce paramètre est nul lorsque hasLookupError la valeur est faux.
    {
    "hasLookupError": false,
    "errorMessage": "",
    "contextStatus": {Object}
  }
    <Object>.contextStatus Objet Objet contenant les détails de l’état du flux, du flux secondaire ou de l’action interrogée.
    {
    "hasLookupError": false,
    "errorMessage": "",
    "contextStatus": {
      "state": "COMPLETE",
      "errorState": "NONE"
    }
  }
    <Object>.contextStatus.state Chaîne État du contexte du flux, du flux secondaire ou de l’action. Certaines valeurs d’état fournissent des informations supplémentaires dans les paramètres connexes.
    • COMPLETE fournit des informations supplémentaires dans le errorState paramètre
    • ERROR fournit des informations supplémentaires dans le message paramètre
    • CANCELLED fournit des informations supplémentaires dans le canceledReason paramètre
    • IN_PROGRESS fournit des informations supplémentaires dans le isRunOnMid paramètre
    • WAITING fournit des informations supplémentaires dans le waitingOn paramètre
    {
    "hasLookupError": false,
    "errorMessage": "",
    "contextStatus": {
      "state": "COMPLETE",
      "errorState": "NONE"
    }
  }
    <Object>.contextStatus.errorState Chaîne État d’achèvement du flux produit par la gestion des erreurs de flux. L’API ne génère ce paramètre que lorsque le flux, le flux secondaire ou l’action est à l’état TERMINÉ.
    • ERROR_CAUGHT
    • ERROR_SKIPPED
    {
    "hasLookupError": false,
    "errorMessage": "",
    "contextStatus": {
      "state": "COMPLETE",
      "errorState": "ERROR_CAUGHT"
    }
  }
    <Object>.contextStatus.message Chaîne Message d’erreur renvoyé par le flux, le flux secondaire ou l’action. L’API ne génère ce paramètre que lorsque le flux, le flux secondaire ou l’action est à l’état ERREUR.
    {
    "hasLookupError": false,
    "errorMessage": "",
    "contextStatus": {
      "state": "ERROR",
      "message": "Error:  Error Message! (Process Automation.LOG; line 1)"
    }
  }
    <Object>.contextStatus.canceledReason Chaîne Message d’annulation renvoyé par le flux, le flux secondaire ou l’action. L’API génère uniquement ce paramètre lorsque le flux, le flux secondaire ou l’action est à l’état ANNULÉ.
    {
    "hasLookupError": false,
    "errorMessage": "",
    "contextStatus": {
      "state": "CANCELLED",
      "canceledReason": "User has requested to stop executing the flow"
    }
  }
    <Object>.contextStatus.isRunOnMid Booléen Marqueur indiquant si le flux, le flux secondaire ou l’action est exécuté sur un environnement de Serveur MID. L’API génère uniquement ce paramètre lorsque le flux, le flux secondaire ou l’action est à l’état IN_PROGRESS.
    {
    "hasLookupError": false,
    "errorMessage": "",
    "contextStatus": {
      "state": "IN_PROGRESS",
      "isRunOnMid": true
    }
  }
  }
    <Object>.contextStatus.waitingOn Tableau Liste des éléments en attente par le flux, le flux secondaire ou l’action en cours. L’API ne génère ce paramètre que lorsque le flux, le flux secondaire ou l’action est à l’état ATTENTE.
    {
    "hasLookupError": false,
    "errorMessage": "",
    "contextStatus": {
      "state": "WAITING",
      "waitingOn": [
        {
          "order":"1",
          "stepType": "TIMER",
          "endTime": 1713627497643
        },
        {
          "order":"5",
          "stepType": "WAIT_FOR_CONDITION_WITH_TIMEOUT",
          "table": "incident",
          "condition": "sys_id=10e8b43243200210338774d6ebb8f22d^short_description=112",
          "endTime": 1713645497800
        }
      ]
    }
  }
    <Object>.contextStatus.waitingOn.order Chaîne Numéro d’étape de flux de l’élément à l’origine de l’attente du flux. Si l’action en attente est une action personnalisée dans un flux, la commande inclut également une période et le numéro d’étape d’action personnalisée pour laquelle le flux est en attente.
    {
    "hasLookupError": false,
    "errorMessage": "",
    "contextStatus": {
      "state": "WAITING",
      "waitingOn": [
        {
          "order":"1",
          "stepType": "TIMER",
          "endTime": 1713627497643
        },
        {
          "order":"5",
          "stepType": "WAIT_FOR_CONDITION_WITH_TIMEOUT",
          "table": "incident",
          "condition": "sys_id=10e8b43243200210338774d6ebb8f22d^short_description=112",
          "endTime": 1713645497800
        }
      ]
    }
  }
    <Object>.contextStatus.waitingOn.stepType Chaîne Type d’action ou d’étape de flux qui entraîne l’attente du flux, du flux secondaire ou de l’action. L’API ne génère ce paramètre que lorsque le flux, le flux secondaire ou l’action est à l’état ATTENTE. Voici quelques exemples courants.
    • WAIT_FOR_CONDITION
    • WAIT_FOR_CONDITION_WITH_TIMEOUT
    • ASK_FOR_APPROVAL
    • CREATE_TASK_WITH_WAIT
    • MINUTEUR
    • SLA_TIMER
    • FLUX SECONDAIRE
    <Object>.contextStatus.waitingOn.table Chaîne Nom de table contenant l’enregistrement en attente du flux, du flux secondaire ou de l’action. L’API génère uniquement ce paramètre lorsque le flux, le flux secondaire ou l’action est à l’état WAITING et que stepType est WAIT_FOR_CONDITION, WAIT_FOR_CONDITION_WITH_TIMEOUT, ASK_FOR_APPROVAL ou CREATE_TASK_WITH_WAIT.
    {
    "hasLookupError": false,
    "errorMessage": "",
    "contextStatus": {
      "state": "WAITING",
      "waitingOn": [
          {
          "order":"1",
          "stepType": "WAIT_FOR_CONDITION",
          "table": "incident",
          "condition": "sys_id=1347723243200210338774d6ebb8f285^short_description=1238"
          }
        ]
    }
  }
    <Object>.contextStatus.waitingOn.condition Chaîne Condition de requête de l’enregistrement sur lequel le flux, le flux secondaire ou l’action est en attente. L’API génère uniquement ce paramètre lorsque le flux, le flux secondaire ou l’action est à l’état EN ATTENTE et qu’une condition doit être remplie pour continuer à s’exécuter.
    {
    "hasLookupError": false,
    "errorMessage": "",
    "contextStatus": {
      "state": "WAITING",
      "waitingOn": [
          {
          "order":"1",
          "stepType": "WAIT_FOR_CONDITION",
          "table": "incident",
          "condition": "sys_id=1347723243200210338774d6ebb8f285^short_description=1238"
          }
        ]
    }
  }
    <Object>.contextStatus.waitingOn.endTime Entier Heure de fin en attente du flux, du flux secondaire ou de l’action. L’API génère uniquement ce paramètre lorsque le flux, le flux secondaire ou l’action est à l’état WAITING et que le stepType est WAIT_FOR_CONDITION_WITH_TIMEOUT, TIMER ou SLA_TIMER.
    {
    "hasLookupError": false,
    "errorMessage": "",
    "contextStatus": {
    "state": "WAITING",
    "waitingOn": [
        {
          "order":"3",
          "stepType": "SLA_TIMER",
          "endTime": 1713574610000
        }
    ]
    }
  }
    <Object>.contextStatus.waitingOn.approvalRule Chaîne Règle d’approbation en attente du flux, du flux secondaire ou de l’action. L’API génère uniquement ce paramètre lorsque le flux, le flux secondaire ou l’action est à l’état WAITING et que stepType est ASK_FOR_APPROVAL.
    {
    "hasLookupError": false,
    "errorMessage": "",
    "contextStatus": {
      "state": "WAITING",
      "waitingOn": [
        {
          "order":"3",
          "stepType": "ASK_FOR_APPROVAL",
          "table": "incident",
          "condition": "sys_id=3bd89703372002103387963174924b20^approvalINapproved,rejected,cancelled",
          "approvalRule": "ApprovesAnyU[a8f98bb0eb32010045e1a5115206fe3a,71826bf03710200044e0bfc8bcbe5d3b]"
        }
      ]
    }
  }
    <Object>.contextStatus.waitingOn.contextId Chaîne Le sys_id du flux secondaire sur lequel le flux ou le flux secondaire est en attente. L’API génère uniquement ce paramètre lorsque le flux ou le flux secondaire est à l’état WAITING et que le stepType est SUBFLOW.
    {
    "hasLookupError": false,
    "errorMessage": "",
    "contextStatus": {
    "state": "WAITING",
    "waitingOn": [
        {
          "order":"1",
          "stepType": "SUBFLOW",
          "contextId": "0f724aabd921021020291a665e07e44a"
        }
      ]
    }
  }

    Cet exemple exécute un flux contenant Effectuer ce qui suit dans une logique de flux parallèle. Normalement, un script unique n’exécute pas un flux et n’obtient pas ses messages d’erreur. En règle générale, un autre script ou Studio de workflow aurait déjà exécuté le flux.

    (function() {
  try {
    var result = sn_fd.FlowAPI.getRunner()  // Create a ScriptableFlowRunner builder object.
      .flow('global.test_do_in_parallel')   // Run the global scope flow named do_in_parallel.
      .run();                               // Run the flow and return a FlowRunnerResult object.

    var contextId = result.getContextId();  // Retrieve the context ID from the result

    var flowStatus = sn_fd.FlowAPI
      .getStatus(contextId);                // Retrieve any outputs from the flow execution.

    JSON.stringfy(flowStatus);              // Convert object to string
    return flowStatus;
		
  } catch (ex) {
    var message = ex.getMessage();
    gs.error(message);
  }
	
})();
    Sortie :
    {
    "hasLookupError": false,
    "errorMessage": "",
    "contextStatus": {
      "state": "WAITING",
      "waitingOn": [
        {
          "order":"1",
          "stepType": "TIMER",
          "endTime": 1713627497643
        },
        {
          "order":"5",
          "stepType": "WAIT_FOR_CONDITION_WITH_TIMEOUT",
          "table": "incident",
          "condition": "sys_id=10e8b43243200210338774d6ebb8f22d^short_description=112",
          "endTime": 1713645497800
        }
      ]
    }
  }

    FlowAPI : hasApprovals(String scopedFlowName)

    Vérifie si un flux dans un périmètre donné contient des actions de demande d’approbation.

    La méthode hasApprovals() détermine si un flux dans une portée donnée contient des actions de demande d’approbation. Cette méthode vérifie également si des actions de demande d’approbation dans le flux sont imbriquées sous les blocs de logique de flux Si. Pour plus d’informations, consultez Demander des actions d’approbation.

    Tableau 27. Paramètres
    Nom Type Description
    scopedFlowName Chaîne Périmètre et nom interne du flux à exécuter. Par exemple, global.flow_name. Localisez le champ Nom interne dans la liste des Studio de workflow flux.
    Tableau 28. Renvoie
    Type Description
    Chaîne Renvoie l’une des valeurs de chaîne suivantes :
    • TOUJOURS : le flux contient une action de demande d’approbation qui n’est pas imbriquée dans un bloc de logique de flux If conditionnel.
    • CONDITIONNELLEMENT : le flux contient une action Demander l’approbation imbriquée dans un bloc de logique de flux If conditionnel.
    • NON : le flux ne contient aucune action de demande d’approbation.
    • INCONNU : une erreur de compilateur s’est produite et le système ne peut pas déterminer si le flux contient des actions de demande d’approbation.

    L’exemple suivant vérifie si le flux de example_flow dans le champ d’application global contient des actions de demande d’approbation et consigne le résultat.

    (function() {
	
  try {
    var result = sn_fd.FlowAPI.hasApprovals('global.example_flow');
    gs.log('Result: ' + result);
  }

  catch (ex) {
    var message = ex.getMessage();
    gs.error(message);
  }
})();

    FlowAPI : restartFlowFromContext(String ContextId, mapper providedInputs)

    Redémarre un flux, un flux secondaire ou une action qui a été exécuté en arrière-plan. Vous pouvez fournir de nouvelles entrées ou les omettre pour réutiliser celles fournies précédemment.

    Tableau 29. Paramètres
    Nom Type Description
    contextId Chaîne Le sys_id du flux, du flux secondaire ou de l’action que vous souhaitez redémarrer. Ce flux, ce flux secondaire ou cette action doit avoir été exécuté en arrière-plan et avoir un enregistrement sysevent associé.
    Entrées fournies Objet Facultatif. Objet de carte contenant les paires nom-valeur qui définissent les entrées de remplacement pour le flux, le flux secondaire ou l’action. Si vous omettez ou fournissez une valeur Null pour ce paramètre, le flux, le flux secondaire ou l’action s’exécute à l’aide des entrées fournies précédemment.
    Tableau 30. Renvoie
    Type Description
    ScriptableFlowRunnerResultsScoped Objet contenant les détails d’exécution d’une action, d’un flux ou d’un Studio de workflow flux secondaire.

    Redémarre un échantillon de flux qui a un déclencheur basé sur les enregistrements sur la table Incident. Le flux d’origine utilisait un exemple de INC0008112 d’incident comme entrée. Lorsque le flux redémarre, il utilise à la place un exemple de INC0008111 d’incident comme entrée.

    (function() {
  try {

    var flowContextID = '4216396ffd7d11107edcf07204c30fd5';     // sys_id of sys_flow_context record
    var oldIncidentRecord = '552c48888c033300964f4932b03eb092'; // sys_id of INC0008112
    var newIncidentRecord = 'a83820b58f723300e7e16c7827bdeed2'; // sys_id of INC0008111
    var inputs = {};
    var gr = new GlideRecord('incident'); // Create new incident object

    gr.get(newIncidentRecord);            // Get GlideRecord object for INC0008111

    inputs['current'] = gr;               // Set new Incident record as input
    inputs['table_name'] = 'incident';    // Set table name to Incident

    var result = sn_fd.FlowAPI.getRunner()            // Create a ScriptableFlowRunner builder object.
      .restartFlowFromContext(flowContextID, inputs); // Restart flow with new inputs.

    var contextId = result.getContextId();  // Retrieve the context ID from the result
    var dateRun = result.getDate();

    gs.info(contextId + ' ' + dateRun);

  } catch (ex) {
    var message = ex.getMessage();
    gs.error(message);
  }

})();

    FlowAPI : scheduleCancel(String contextId, String reason, Integer delaySeconds)

    Planifiez un événement système dans la file d’attente du moteur de flux pour annuler un flux à l’état En cours, Supposé interrompu ou En attente après un délai.

    Tableau 31. Paramètres
    Nom Type Description
    contextId Chaîne Sys_id de l’enregistrement des détails d’exécution du flux, du flux secondaire ou de l’action. Le flux, le flux secondaire ou l’action cible doit être à l’état En cours, Présumé interrompu ou En attente. Accédez aux détails de l’exécution en naviguant jusqu’à l’onglet Exécutions de flux dans Studio de workflowou transmettez les sys_id de l’enregistrement de contexte renvoyé par la méthode.
    Remarque :
    Il peut y avoir un léger délai d’annulation si le contexte cible s’exécute sur un autre nœud de l’instance. Les contextes s’exécutant sur le même nœud sont annulés immédiatement. Les contextes s’exécutant sur un autre nœud doivent d’abord attendre que l’annulation soit transférée au nœud approprié.
    motif Chaîne Motif d’annulation du flux, du flux secondaire ou de l’action. Apparaît dans le champ Message de la table Entrées de journal du moteur de flux [sys_flow_log].
    delaySeconds Entier Facultatif. Nombre de secondes à attendre avant le traitement d’un événement d’annulation dans la file d’attente du moteur de flux. Si vous omettez ce paramètre, la méthode utilise la valeur par défaut de 1 seconde.

    Vous pouvez utiliser ce paramètre pour éviter l’impact sur les performances de la planification de l’annulation de milliers de contextes de flux en même temps. Plutôt que d’exécuter toutes les annulations simultanément, planifiez un lot d’annulations de flux avec un délai. Vous pouvez également utiliser le délai comme valeur de délai d’expiration pour un flux asynchrone.
    Tableau 32. Renvoie
    Type Description
    Néant

    Cet exemple utilise la valeur de retour de la méthode startFlow() pour planifier l’annulation de tout flux de longue durée.

    (function() { 

var now_GR = new GlideRecord('incident'); 
now_GR.addQuery('number', 'INC0000050'); 
now_GR.query(); 
now_GR.next(); 

      try { 
          var inputs = {}; 
          inputs['current'] = now_GR; // GlideRecord of table: 
          inputs['table_name'] = 'incident'; 

          // Starts the flow asynchronously.
          var contextId = sn_fd.FlowAPI.startFlow('global.myFlow', inputs); 

      } catch (ex) { 
          var message = ex.getMessage(); 
          gs.error(message); 
      } 
})();

 
// Call the scheduleCancel() method using the context Id returned from the startFlow() method
sn_fd.FlowAPI.scheduleCancel(contextId, 'Flow took too long to execute.', 60);

    Cet exemple planifie l’annulation de tous les flux nommés Test Flow.

    var now_GR = new GlideRecord("sys_flow_context");
now_GR.addQuery("name", "Test Flow");
now_GR.query();

while (now_GR.next()) {
sn_fd.FlowAPI.scheduleCancel(now_GR.getUniqueValue(), 'Canceling Test Flows', 60);
}

    Cet exemple utilise le paramètre delaySeconds pour exécuter des tâches d’annulation de flux par lots. Utilisez des lots pour annuler des milliers de contextes de flux.

    var delaySeconds = 1;

for (var i; i < sys_flow_context.length; ++i) {
  if (i % 100 === 0) {
    delaySeconds = delaySeconds + 60;
  }
  var contextId = sys_flow_context[i];
  var reason = "Example reason";
  sn_fd.FlowAPI.scheduleCancel(contextId, reason, delaySeconds);
}

    FlowAPI : sendMessage(String contextSysID, String message, String payload)

    Envoyer un message spécifique et une réponse de charge utile à un flux en pause et en attente d’un message.

    Tableau 33. Paramètres
    Nom Type Description
    contextSysID Chaîne Valeur sys_id du flux ou du flux secondaire qui est en pause et en attente de la reprise d’un message spécifique. Le flux ou le flux secondaire doit inclure une action Attendre un message. Consultez Wait For Message action.
    message Chaîne La chaîne de texte à envoyer au flux ou au flux secondaire en attente. Si cette valeur de message correspond à la valeur de message répertoriée dans l’action Attendre un message, le flux ou le flux secondaire reprend son exécution. Consultez Wait For Message action.
    charge utile Chaîne Valeur de sortie de la chaîne de texte à envoyer au flux en attente. Le flux ou le flux secondaire peut utiliser la charge utile comme entrée lorsqu’il reprend son exécution. Par exemple, vous pouvez spécifier un motif pour lequel un enregistrement a été rouvert ou qu’une nouvelle approbation est requise.
    Tableau 34. Renvoie
    Type Description
    Néant

    Cet exemple envoie le message Reprendre le flux pour redémarrer un flux en pause. Le flux en pause peut alors utiliser la valeur de charge utile comme données ailleurs dans le flux.

    (function() {
    try {
      // var change = '154a6320db9b12102166e229139619fc';    // Example sys_id of change record
      var pausedFlowId = '6e9bab60949b1210dda11cd237cd955d'; // Example sys_id of a paused flow
      var resumeMessage = 'Resume Flow';                     // Message that paused flow is waiting for
      var payload = 'Resubmitted for approval';              // Data to send back to flow
      var result = sn_fd.FlowAPI
      .sendMessage(pausedFlowId, resumeMessage, payload);    // Send a message to the paused flow
    } catch (ex) {
      var message = ex.getMessage();
      gs.error(message);
    }
  })();

    Sortie :

    Ce script ne produit aucune sortie propre. Lorsque vous l’exécutez à partir du module Scripts-Arrière-plan , le système répertorie les opérations et les tables modifiées par le script. Vous pouvez également voir les résultats de la sortie de script dans les détails d’exécution du flux d’une action Attendre un message.
    [0:00:00.074] Script completed in scope global: script
Script execution history and recovery available here
Operation	Table	                       Row Count
delete	   sys_flow_runtime_state_chunk	1
insert	   sys_flow_runtime_state_chunk	1
update	   sys_flow_context	            1
record-watcher asynchronous tracking complete - time: 3 ms. Executed responders: 1 
record-watcher asynchronous tracking complete - time: 3 ms. Executed responders: 1 
record-watcher asynchronous tracking complete - time: 3 ms. Executed responders: 1

    FlowAPI : setEncryptedOutput(Mot de passe de chaîne)

    Génère des valeurs password2 à l’intérieur d’une étape de script.

    Identifiez une valeur password2 chiffrée renvoyée par un GlideRecord, ce qui permet au système d’afficher la valeur sous forme de mot de passe masqué plutôt que sous forme de chaîne chiffrée.

    Tableau 35. Paramètres
    Nom Type Description
    mot de passe Chaîne Valeur password2 chiffrée.
    Tableau 36. Renvoie
    Type Description
    Chaîne Valeur password2 chiffrée, reconnue par le moteur comme valeur de mot de passe.

    Cet exemple renvoie la valeur d’un champ password2 à partir d’un enregistrement utilisateur et la stocke dans une variable. Cette variable est transmise dans la méthode setEncryptedOutput, qui est appelée à l’aide de sn_fd. GlideActionUtil.setEncryptedOutput. L’instance reconnaît la valeur renvoyée comme un mot de passe.

    (function execute(inputs, outputs) {
  // ...code...
  var now_GR = new GlideRecord('sys_user');
  now_GR.addQuery('first_name' , 'Abel');
  now_GR.query();
  now_GR.next();
  var pwVal = now_GR.getValue('pw2');
  outputs['usedSetEncrypted'] = sn_fd.GlideActionUtil.setEncryptedOutput(pwVal);
  outputs['justSetDirectly'] = pwVal;
})(inputs, outputs);

    FlowAPI : startAction (nom de chaîne, entrées de carte)

    Exécute une action à partir d’un script côté serveur de manière asynchrone.

    Exécutez une action à partir d’une règle métier, d’un include de script ou de tout autre script côté serveur. Les actions exécutées à l’aide de cette méthode sont exécutées de façon asynchrone. Les scripts qui utilisent cette méthode n’ont donc pas accès aux sorties créées par l’action. Utilisez executeAction pour exécuter une action de manière synchrone et accéder aux sorties qu’elle génère.
    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : dans le champ d’application, qui déconseille les méthodes existantes utilisées pour créer des objets et exécuter Studio de workflow des flux et des actions. Utilisez la méthode getRunner() dans la classe FlowAPI pour retourner un objet ScriptableFlowRunner et utiliser les méthodes associées. Utilisez les méthodes ScriptableFlowRunner si vous devez prendre en charge Séparation de domaine.
    Remarque :
    Cette méthode exécute l’action en tant qu’utilisateur qui initie la session.
    Tableau 37. Paramètres
    Nom Type Description
    nom Chaîne Le périmètre et le nom de l’action à exécuter, par exemple global.action_name.
    entrées Carte Paires nom-valeur qui définissent les entrées d’action. Utilisez le nom de l’entrée, pas l’étiquette d’entrée.
    Tableau 38. Renvoie
    Type Description
    Chaîne ID système de l’enregistrement du contexte de l’action. Accédez à l’enregistrement de contexte en naviguant jusqu’à l’onglet Exécutions de flux dans , en sélectionnant une exécution de flux, puis en Studio de workflowcliquant sur Ouvrir l’enregistrement de contexte.

    Cet exemple utilise sn_fd. FlowAPI.startAction pour exécuter une action appelée add_comment dans le périmètre sn_itsm_spoke. L’objet Entrées contient un enregistrement cible et un commentaire à ajouter à cet enregistrement. Le code est encapsulé dans une instruction try/catch pour capturer toute erreur pouvant se produire lors de l’exécution du flux.

    (function() {
  try {
    var inputs = {};
    inputs['ah_task'] = myTaskRecord; // GlideRecord of table: task 
    inputs['ah_comment'] ='Test Comment' ; // String 

    var contextId = sn_fd.FlowAPI.startAction('sn_itsm_spoke.add_comment', inputs);	
			
  } catch (ex) {
    var message = ex.getMessage();
    gs.error(message);
  }
})();

    FlowAPI : startActionQuick(nom de chaîne, entrées de carte)

    Exécute une action à partir d’un script côté serveur de manière asynchrone sans créer de détails d’exécution ou d’autres enregistrements connexes. Améliorez les performances en éliminant les frais généraux de tenue d’enregistrement. Utilisez cette API pour augmenter la vitesse de traitement de gros volumes, par exemple plusieurs exécutions par seconde, dans un environnement de production.

    Reporting et enregistrements générés
    Cette méthode ne crée pas de détails d’exécution ni d’enregistrements de contexte, quels que soient les Studio de workflow paramètres.
    Assistance en attente
    Cette méthode ne prend pas en charge la mise en pause de l’action pour attendre les conditions. Les étapes qui mettent en pause pour des conditions d’attente telles que Demander l’approbation ou Attendre une condition ne sont pas prises en charge.
    Prise en charge de Serveur MID
    Cette méthode ne prend pas en charge la pause d’une action à exécuter à partir d’un Serveur MID.
    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : dans le champ d’application, qui déconseille les méthodes existantes utilisées pour créer des objets et exécuter Studio de workflow des flux et des actions. Utilisez la méthode getRunner() dans la classe FlowAPI pour retourner un objet ScriptableFlowRunner et utiliser les méthodes associées. Utilisez les méthodes ScriptableFlowRunner si vous devez prendre en charge Séparation de domaine.
    Tableau 39. Paramètres
    Nom Type Description
    nom Chaîne Périmètre et nom interne de l’action à exécuter. Par exemple, global.action_name. Localisez le champ Nom interne dans la liste d’actions Studio de workflow .
    entrées Carte Paires nom-valeur qui définissent les entrées d’action. Vous trouverez les entrées d’action disponibles et les types de données requis sous Entrées dans le plan d’action. Utilisez le nom de l’entrée, pas l’étiquette d’entrée. Par exemple, {'table' :'incident','sys_id' :'a39d8e3cf0212300964feeefe80ff0ed'}.
    Tableau 40. Renvoie
    Type Description
    nul 
    (function() {
	
  try {
    var grIncident = new GlideRecord('incident');
    grIncident.get('57af7aec73d423002728660c4cf6a71c');

    var inputs = {};
    inputs['variable'] = grIncident;

    sn_fd.FlowAPI.startActionQuick('global.update_record_test', inputs);

  } catch (ex) {
    var message = ex.getMessage();
    gs.error(message);
    }
	
})();

    FlowAPI : startFlow(nom de chaîne, entrées de carte)

    Exécute un flux à partir d’un script côté serveur.

    Exécutez un flux à partir d’une règle métier, d’un include de script ou de tout autre script côté serveur. Les flux exécutés avec cette méthode s’exécutent de façon asynchrone.
    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : dans le champ d’application, qui déconseille les méthodes existantes utilisées pour créer des objets et exécuter Studio de workflow des flux et des actions. Utilisez la méthode getRunner() dans la classe FlowAPI pour retourner un objet ScriptableFlowRunner et utiliser les méthodes associées. Utilisez les méthodes ScriptableFlowRunner si vous devez prendre en charge Séparation de domaine.
    Remarque :
    Cette méthode exécute le flux en tant qu’utilisateur spécifié dans les propriétés du flux.
    Tableau 41. Paramètres
    Nom Type Description
    nom Chaîne Le périmètre et le nom du flux à exécuter, par exemple global.flow_name.
    entrées Carte Paires nom-valeur qui définissent les entrées de déclenchement. Utilisez le nom de l’entrée, pas l’étiquette d’entrée.
    Tableau 42. Renvoie
    Type Description
    Chaîne ID système de l’enregistrement du contexte pour le flux. Accédez à l’enregistrement de contexte en naviguant jusqu’à l’onglet Exécutions de flux dans , en sélectionnant une exécution de flux, puis en Studio de workflowcliquant sur Ouvrir l’enregistrement de contexte.

    Cet exemple utilise sn_fd. FlowAPI.startFlow pour exécuter un flux global appelé test_flow. Le code crée une variable d’entrées qui contient les entrées requises par le flux. Dans ce cas, l’enregistrement actuel et la table de l’enregistrement. Le code est encapsulé dans une instruction try/catch pour capturer toute erreur pouvant se produire lors de l’exécution du flux.

    (function() {
 
  var now_GR = new GlideRecord('incident'); 
  now_GR.addQuery('number', 'INC0009009'); 
  now_GR.query(); 
  now_GR.next();

  try {
    var inputs = {};
    inputs['current'] = now_GR; // GlideRecord of table: Incident
    inputs['table_name'] = 'incident';

    var contextId = sn_fd.FlowAPI.startFlow('global.test_flow', inputs);	
	
  } catch (ex) {
    var message = ex.getMessage();
    gs.error(message);  
  }
})();

    FlowAPI : startFlowQuick(nom de chaîne, entrées de carte)

    Exécute un flux à partir d’un script côté serveur de manière asynchrone sans créer les détails de l’exécution ou d’autres enregistrements connexes. Améliorez les performances en éliminant les frais généraux de tenue d’enregistrement. Utilisez cette API pour augmenter la vitesse de traitement de gros volumes, par exemple plusieurs exécutions par seconde, dans un environnement de production.

    Reporting et enregistrements générés
    Cette méthode ne crée pas de détails d’exécution ni d’enregistrements de contexte, quels que soient les Studio de workflow paramètres.
    Exécuter en tant qu’utilisateur système
    Cette méthode exécute le flux en tant qu’utilisateur système. Définir le flux pour qu’il s’exécute en tant qu’utilisateur qui initie la session ou emprunter l’identité d’un utilisateur n’est pas pris en charge.
    Assistance en attente
    Cette méthode ne prend pas en charge la mise en pause du flux pour attendre les conditions. Les actions ou la logique de flux qui mettent en pause pour des conditions d’attente telles que Demander l’approbation, Attendre une condition ou Attendre pendant une durée ne sont pas prises en charge.
    Prise en charge de Serveur MID
    Cette méthode ne prend pas en charge la mise en pause d’un flux à exécuter à partir d’un serveur MID.
    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : dans le champ d’application, qui déconseille les méthodes existantes utilisées pour créer des objets et exécuter Studio de workflow des flux et des actions. Utilisez la méthode getRunner() dans la classe FlowAPI pour retourner un objet ScriptableFlowRunner et utiliser les méthodes associées. Utilisez les méthodes ScriptableFlowRunner si vous devez prendre en charge Séparation de domaine.
    Tableau 43. Paramètres
    Nom Type Description
    nom Chaîne Périmètre et nom interne du flux à exécuter. Par exemple, global.flow_name. Localisez le champ Nom interne dans la liste des Studio de workflow flux.
    entrées Carte Paires nom-valeur qui définissent les entrées de déclenchement. Vous trouverez les entrées de déclencheur disponibles et les types de données requis dans la section Déclencheur du flux. Utilisez le nom de l’entrée, pas l’étiquette d’entrée. Par exemple, {'table' :'incident','sys_id' :'a39d8e3cf0212300964feeefe80ff0ed'}.
    Tableau 44. Renvoie
    Type Description
    nul 
    (function() {
	
  try {
    var grIncident = new GlideRecord('incident');
    grIncident.get('ed92e8d173d023002728660c4cf6a7bc');

    var inputs = {};
    inputs['current'] = grIncident;
    inputs['table_name'] = 'incident';
		
    sn_fd.FlowAPI.startFlowQuick('global.test_quick_flow', inputs);
		
  } catch (ex) {
    var message = ex.getMessage();
    gs.error(message);
	}
	
})();

    FlowAPI : startSubflow(nom de chaîne, entrée de carte)

    Exécute un flux secondaire à partir d’un script côté serveur.

    Exécutez un flux secondaire à partir d’une règle métier, d’un include de script ou de tout autre script côté serveur. Les flux secondaires exécutés à l’aide de cette méthode sont exécutés de façon asynchrone Les scripts qui incluent cette méthode n’ont pas accès aux sorties créées par le flux. Utilisez executeSubflow pour exécuter un flux secondaire de manière synchrone et accéder aux sorties qu’il génère.
    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : dans le champ d’application, qui déconseille les méthodes existantes utilisées pour créer des objets et exécuter Studio de workflow des flux et des actions. Utilisez la méthode getRunner() dans la classe FlowAPI pour retourner un objet ScriptableFlowRunner et utiliser les méthodes associées. Utilisez les méthodes ScriptableFlowRunner si vous devez prendre en charge Séparation de domaine.
    Remarque :
    Cette méthode exécute le flux en tant qu’utilisateur spécifié dans les propriétés du flux.
    Tableau 45. Paramètres
    Nom Type Description
    nom Chaîne Périmètre et nom du flux secondaire à exécuter, par exemple global.subflow_name.
    entrées Carte Paires nom-valeur qui définissent les entrées de flux secondaire. Utilisez le nom de l’entrée, pas l’étiquette d’entrée.
    Tableau 46. Renvoie
    Type Description
    Chaîne ID système de l’enregistrement de contexte pour le flux secondaire. Accédez à l’enregistrement de contexte en naviguant jusqu’à l’onglet Exécutions de flux dans , en sélectionnant une exécution de flux, puis en Studio de workflowcliquant sur Ouvrir l’enregistrement de contexte.

    Cet exemple utilise sn_fd. FlowAPI.startSubflow pour exécuter un flux global appelé test_subflow. Le code est encapsulé dans une instruction try/catch pour capturer toute erreur pouvant se produire lors de l’exécution du flux.

    (function() {
  try {
    var inputs = {};
    inputs['ah_task'] = myTaskRecord; // GlideRecord of table: task 
    inputs['ah_comment'] ='Test Comment' ; // String 

    var contextId = sn_fd.FlowAPI.startSubflow('global.test_subflow', inputs);

  } catch (ex) {
    var message = ex.getMessage();
    gs.error(message);
  }
	
})();

    FlowAPI : startSubflowQuick(nom de chaîne, entrées de carte)

    Exécute un flux secondaire à partir d’un script côté serveur de façon asynchrone sans créer les détails de l’exécution ou d’autres enregistrements connexes. Améliorez les performances en éliminant les frais généraux de tenue d’enregistrement. Utilisez cette API pour augmenter la vitesse de traitement de gros volumes, par exemple plusieurs exécutions par seconde, dans un environnement de production.

    Reporting et enregistrements générés
    Cette méthode ne crée pas de détails d’exécution ni d’enregistrements de contexte, quels que soient les Studio de workflow paramètres.
    Exécuter en tant qu’utilisateur système
    Cette méthode exécute le flux en tant qu’utilisateur système. Définir le flux pour qu’il s’exécute en tant qu’utilisateur qui initie la session ou emprunter l’identité d’un utilisateur n’est pas pris en charge.
    Assistance en attente
    Cette méthode ne prend pas en charge la mise en pause du flux pour attendre les conditions. Les actions ou la logique de flux qui mettent en pause pour des conditions d’attente telles que Demander l’approbation, Attendre une condition ou Attendre pendant une durée ne sont pas prises en charge.
    Prise en charge de Serveur MID
    Cette méthode ne prend pas en charge la mise en pause d’un flux à exécuter à partir d’un serveur MID.
    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : dans le champ d’application, qui déconseille les méthodes existantes utilisées pour créer des objets et exécuter Studio de workflow des flux et des actions. Utilisez la méthode getRunner() dans la classe FlowAPI pour retourner un objet ScriptableFlowRunner et utiliser les méthodes associées. Utilisez les méthodes ScriptableFlowRunner si vous devez prendre en charge Séparation de domaine.
    Tableau 47. Paramètres
    Nom Type Description
    nom Chaîne Périmètre et nom interne du flux secondaire à exécuter. Par exemple, global.subflow_name. Localisez le champ Nom interne dans la liste des Studio de workflow flux secondaires.
    entrées Carte Paires nom-valeur qui définissent les entrées de flux secondaire. Vous trouverez les entrées de flux secondaire disponibles et les types de données requis sous Entrées dans le flux secondaire. Utilisez le nom de l’entrée, pas l’étiquette d’entrée. Par exemple, {'table' :'incident','sys_id' :'a39d8e3cf0212300964feeefe80ff0ed'}.
    Tableau 48. Renvoie
    Type Description
    nul 
    (function() {

  try {
    var grIncident = new GlideRecord('incident');
    grIncident.get('57af7aec73d423002728660c4cf6a71c');

    var inputs = {};
    inputs['variable'] = grIncident;

    sn_fd.FlowAPI.startSubflowQuick('global.test_quick_run_subflow', inputs);

  } catch (ex) {
    var message = ex.getMessage();  
    gs.error(message);
    }
	
})();