FlowAPI : incluse dans le périmètre, globale

  • Rversion finale: Australia
  • Mis à jour 12 mars 2026
  • 45 minutes de lecture

    • FlowAPI fournit des méthodes permettant d’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élimités à l’aide de l’espace de noms sn_fd . Créez des appels vers 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 du 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. Au lieu de cela, créez 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 workflow, ou transmettez l’sys_id de l’enregistrement de contexte renvoyé par les méthodes startFlow(),startSubflow() ou startAction().
    Remarque :
    L’annulation peut tarder légèrement 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 immédiatement annulés. 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. S’affiche 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 tous 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 manière 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 s’exécutent de manière synchrone afin que la méthode ait 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 : délimité, 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 la séparation en domaines.
    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 Périmètre et 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 d’expiration 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 enveloppé dans une instruction try/catch pour capturer toutes les erreurs qui peuvent 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 les détails de l’exécution ou d’autres enregistrements connexes. Améliorez les performances en éliminant les frais généraux liés à la tenue des dossiers. Utilisez cette API pour augmenter la vitesse de traitement à haut volume, 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.
    En attente de support
    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.
    Support du serveur MID
    Cette méthode ne prend pas en charge la mise en pause d’une action à exécuter à partir d’un serveur MID.
    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : délimité, 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 la séparation en domaines.
    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 des Studio de workflow actions.
    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 d’expiration 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 manière 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, consultez Actions de flux de données et pagination.

    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : délimité, 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 la séparation en domaines.
    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 que l’action n’expire. 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 com.glide.hub.flow_api.default_execution_time propriété système

    Unité : millisecondes
    Tableau 8. Renvoie
    Type Description
    Flux de données scriptable 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 manière 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 manière synchrone. Utilisez startFlow pour exécuter un flux de manière asynchrone.
    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : délimité, 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 la séparation en domaines.
    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éclencheur. 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 d’expiration 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ées qui contient l’enregistrement actuel et la table de l’enregistrement. Le code est enveloppé dans une instruction try/catch pour capturer toutes les erreurs qui peuvent 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 liés à la tenue des dossiers. Utilisez cette API pour augmenter la vitesse de traitement à haut volume, 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. La définition du flux pour qu’il s’exécute en tant qu’utilisateur système ou l’emprunt d’identité d’un utilisateur n’est pas prise en charge.
    En attente de support
    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 des conditions d’attente telles que Demander l’approbation, Attendre une condition ou Attendre pendant un certain temps ne sont pas prises en charge.
    Support du serveur MID
    Cette méthode ne prend pas en charge la pause d’un flux pour s’exécuter à partir d’un serveur MID.
    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : délimité, 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 la séparation en domaines.
    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éclencheur. 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 d’expiration 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 manière 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 manière synchrone. Utilisez startSubflow pour exécuter un flux secondaire de manière asynchrone.
    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : délimité, 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 la séparation en domaines.
    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 d’expiration 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 périmètre global. Une variable appelée entrées contient les entrées du flux secondaire. Dans ce cas, un nom et un mot de passe. Le code est enveloppé dans une instruction try/catch pour capturer toutes les erreurs qui peuvent 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 manière 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 liés à la tenue des dossiers. Utilisez cette API pour augmenter la vitesse de traitement à haut volume, 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. La définition du flux pour qu’il s’exécute en tant qu’utilisateur système ou l’emprunt d’identité d’un utilisateur n’est pas prise en charge.
    En attente de support
    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 des conditions d’attente telles que Demander l’approbation, Attendre une condition ou Attendre pendant un certain temps ne sont pas prises en charge.
    Support du serveur MID
    Cette méthode ne prend pas en charge la pause d’un flux pour s’exécuter à partir d’un serveur MID.
    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : délimité, 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 la séparation en domaines.
    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 d’expiration 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 les sorties définies par le flux secondaire. Vous pouvez trouver les sorties pour le flux secondaire sous Entrées et sorties de flux secondaire dans le contour 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 L’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 seul script n’exécute pas un flux mais 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 enveloppé dans une instruction try/catch pour capturer toutes les erreurs qui peuvent 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(chaîne scopedFlowName)

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

    Tableau 19. Paramètres
    Nom Type Description
    scopedFlowName Chaîne Périmètre de l’application et 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 par leurs valeurs d’enregistrement d’étape.

    Cet exemple montre comment obtenir les étapes du 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 la section 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 sorties 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 : délimité, 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 la séparation en domaines.
    Tableau 21. Paramètres
    Nom Type Description
    contextId Chaîne L’sys_id de l’action ou du flux secondaire dont vous souhaitez obtenir les résultats.
    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 que le flux se termine, puis obtient ses valeurs de sortie. Normalement, un script unique n’exécute pas un flux mais n’obtient pas ensuite ses valeurs de sortie. Étant donné qu’un flux peut ne pas se terminer avant l’appel getOutputs(), cet exemple utilise un temps 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 enveloppé dans une instruction try/catch pour capturer toutes les erreurs qui peuvent 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
    Néant
    Tableau 24. Renvoie
    Type Description
    Exécuteur de flux scriptable 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 L’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 est survenu 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é.
    {
    "hasLookupError": false,
    "errorMessage": "",
    "contextStatus": {
      "state": "COMPLETE",
      "errorState": "NONE"
    }
  }
    <Object>.contextStatus.state Chaîne État du contexte de flux, de flux secondaire ou d’action. Certaines valeurs d’état fournissent des informations supplémentaires dans les paramètres associés.
    • 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 génère ce paramètre uniquement 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 génère uniquement ce paramètre 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 ce paramètre uniquement 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 que le flux, le flux secondaire ou l’action en cours attend. L’API génère uniquement ce paramètre lorsque le flux, le flux secondaire ou l’action est à l’état 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.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 au sein d’un flux, la commande inclut également une période et le numéro d’étape d’action de l’action personnalisée sur 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 à l’origine de l’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 EN 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 que le flux, le flux secondaire ou l’action attend. L’API génère ce paramètre uniquement lorsque le flux, le flux secondaire ou l’action est à l’état EN ATTENTE 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 attend. L’API génère ce paramètre uniquement 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 ce paramètre uniquement lorsque le flux, le flux secondaire ou l’action est à l’état EN ATTENTE et que stepType est WAIT_FOR_CONDITION_WITH_TIMEOUT, MINUTEUR 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 attendue par le flux, le flux secondaire ou l’action. L’API génère ce paramètre uniquement lorsque le flux, le flux secondaire ou l’action est à l’état EN ATTENTE 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 La sys_id du flux secondaire que le flux ou le flux secondaire attend. L’API génère uniquement ce paramètre lorsque le flux ou le flux secondaire est à l’état EN ATTENTE 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 la logique de flux Effectuer les opérations suivantes en parallèle. Normalement, un seul script n’exécute pas un flux mais 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(Chaîne 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 un périmètre donné contient des actions Demander une approbation. Cette méthode vérifie également si des actions Demander une approbation dans le flux sont imbriquées sous la 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 Demander une approbation qui n’est pas imbriquée dans un bloc de logique de flux Si conditionnelle.
    • CONDITIONNELLEMENT : le flux contient une action Demander une approbation imbriquée dans un bloc de logique de flux Si conditionnelle.
    • NON : le flux ne contient aucune action Demander une 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, Map 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 les entrées fournies précédemment.

    Tableau 29. Paramètres
    Nom Type Description
    contextId Chaîne L’sys_id du flux, du flux secondaire ou de l’action que vous souhaitez redémarrer. Ce flux, sous-flux ou action doit avoir été exécuté en arrière-plan et avoir un enregistrement sysevent associé.
    providedInputs 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 exemple 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 en cours, présumé interrompu ou en attente après un certain retard.

    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 accédant à l’onglet Exécutions de flux dans Studio de workflow, ou transmettez l’sys_id de l’enregistrement de contexte renvoyé par la méthode.
    Remarque :
    L’annulation peut tarder légèrement 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 immédiatement annulés. 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. S’affiche 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 lié à 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 tous 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 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 les 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)

    Envoyez 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 indiquée dans l’action Attendre un message, le flux ou le flux secondaire reprend l’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 l’exécution. Par exemple, vous pouvez spécifier un motif pour lequel un enregistrement a été rouvert ou pour lequel 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 liste 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)

    Crée 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 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 une 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 à 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, de sorte que les scripts utilisant cette méthode n’ont 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 : délimité, 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 la séparation en domaines.
    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 Périmètre et 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 de contexte de l’action. Accédez à l’enregistrement de contexte en accédant à l’onglet Exécutions de flux dans , en Studio de workflow sélectionnant une exécution de flux, puis en cliquant 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 enveloppé dans une instruction try/catch pour capturer toutes les erreurs qui peuvent 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 les détails de l’exécution ou d’autres enregistrements connexes. Améliorez les performances en éliminant les frais généraux liés à la tenue des dossiers. Utilisez cette API pour augmenter la vitesse de traitement à haut volume, 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.
    En attente de support
    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.
    Support du serveur MID
    Cette méthode ne prend pas en charge la mise en pause d’une action à exécuter à partir d’un serveur MID.
    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : délimité, 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 la séparation en domaines.
    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 des Studio de workflow actions.
    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 manière asynchrone.
    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : délimité, 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 la séparation en domaines.
    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éclencheur. 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 de contexte pour le flux. Accédez à l’enregistrement de contexte en accédant à l’onglet Exécutions de flux dans , en Studio de workflow sélectionnant une exécution de flux, puis en cliquant 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 enveloppé dans une instruction try/catch pour capturer toutes les erreurs qui peuvent 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 liés à la tenue des dossiers. Utilisez cette API pour augmenter la vitesse de traitement à haut volume, 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. La définition du flux pour qu’il s’exécute en tant qu’utilisateur qui initie la session, ou l’emprunt d’identité d’un utilisateur, n’est pas prise en charge.
    En attente de support
    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 des conditions d’attente telles que Demander l’approbation, Attendre une condition ou Attendre pendant un certain temps ne sont pas prises en charge.
    Support du serveur MID
    Cette méthode ne prend pas en charge la pause d’un flux pour s’exécuter à partir d’un serveur MID.
    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : délimité, 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 la séparation en domaines.
    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éclencheur. 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 s’exécutent à l’aide de cette méthode Exécuter 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 : délimité, 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 la séparation en domaines.
    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 accédant à l’onglet Exécutions de flux dans , en Studio de workflow sélectionnant une exécution de flux, puis en cliquant 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 enveloppé dans une instruction try/catch pour capturer toutes les erreurs qui peuvent 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 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 liés à la tenue des dossiers. Utilisez cette API pour augmenter la vitesse de traitement à haut volume, 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. La définition du flux pour qu’il s’exécute en tant qu’utilisateur qui initie la session, ou l’emprunt d’identité d’un utilisateur, n’est pas prise en charge.
    En attente de support
    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 des conditions d’attente telles que Demander l’approbation, Attendre une condition ou Attendre pendant un certain temps ne sont pas prises en charge.
    Support du serveur MID
    Cette méthode ne prend pas en charge la pause d’un flux pour s’exécuter à partir d’un serveur MID.
    Remarque :
    Cette API est remplacée par ScriptableFlowRunner : délimité, 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 la séparation en domaines.
    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);
    }
	
})();