FlowAPI : dans le champ d’application, global
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.
| 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 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]. |
| 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.
| 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. |
| 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.
| 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. |
| 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.| 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 |
| 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.
| 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. |
| Type | Description |
|---|---|
| Aucun | 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 liés à la tenue des dossiers. 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.
| 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. |
| 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.
| 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. |
| 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.
| 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. |
| 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().
| 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. |
| 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)
Renvoie une chaîne JSON contenant la liste des étapes de flux.
| Nom | Type | Description |
|---|---|---|
| scopedFlowName | Chaîne | Le périmètre de l’application et le nom du flux dont vous souhaitez obtenir les étapes. |
| 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.
| Nom | Type | Description |
|---|---|---|
| contextId | Chaîne | Le sys_id de l’action ou du flux secondaire dont vous souhaitez obtenir les sorties. |
| 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.
| Nom | Type | Description |
|---|---|---|
| Aucun |
| 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.
| Nom | Type | Description |
|---|---|---|
| contextId | Chaîne | Le sys_id du flux, du flux secondaire ou de l’action dont vous souhaitez obtenir l’état. |
| 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. |
| <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. |
| <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. |
| <Object>.contextStatus | Objet | Objet contenant les détails de l’état du flux, du flux secondaire ou de l’action interrogée. |
| <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.
|
| <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É.
|
| <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. |
| <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É. |
| <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. |
| <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. |
| <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. |
| <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.
|
| <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. |
| <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. |
| <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. |
| <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. |
| <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. |
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.
| 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. |
| Type | Description |
|---|---|
| Chaîne | Renvoie l’une des valeurs de chaîne suivantes :
|
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 les entrées fournies précédemment.
| 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. |
| 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 en cours, présumé interrompu ou en attente après un certain retard.
| 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 workflow ou 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. |
| Type | Description |
|---|---|
| Aucun |
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)
Envoyez un message spécifique et une réponse de charge utile à un flux en pause et en attente d’un message.
| 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. |
| Type | Description |
|---|---|
| Aucun |
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.
| Nom | Type | Description |
|---|---|---|
| mot de passe | Chaîne | Valeur password2 chiffrée. |
| 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.
| 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. |
| 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 workflow 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 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.
| 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'}. |
| 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.
| 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. |
| 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 workflow 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 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.
| 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'}. |
| 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.
| 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. |
| 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 workflow 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 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.
| 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'}. |
| 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);
}
})();