Créer un déclencheur personnalisé (exemple 2)
- Dernière mise à jour2023/07/21
L'exemple montre comment créer un déclencheur dans Automation 360 qui vous permet de créer des tâches qui seront exécutées à des intervalles spécifiés.
Un déclencheur lance un robot lorsque certaines conditions sont remplies et attend que les conditions aient changé ou soient arrêtées. Lorsque les conditions du déclencheur correspondent, la méthode d'exécution est appelée pour signaler le déclencheur.
Annotations obligatoires
Pour créer un déclencheur, les annotations suivantes sont obligatoires :
Annotation | Utilisation |
---|---|
BotCommand |
Utilisez l'annotation BotCommand avec le déclencheur commandType . Cette opération garantit que l'ancien objet Java (POJO) est adapté à la création d' Le Automation 360. |
CommandPkg |
Ces valeurs sont utilisées lors de la création d'un package. Fournissez un nom, une étiquette et une description à l'annotation. |
TriggerId |
Un identifiant de déclencheur, qui est obligatoire pour arrêter le déclencheur. |
|
Spécifie la fonction consommateur à invoquer lorsque la condition de déclenchement est remplie. |
StartListen |
Démarre l'écouteur du déclencheur. |
StopAllTriggers |
Identifie la méthode utilisée pour annuler tous les déclencheurs. |
StopListen |
Identifie la méthode responsable de l'annulation d'un déclencheur spécifique. |
Cas d'utilisation - Déclenchement basé sur le temps
Le cas d'utilisation suivant montre comment créer un déclencheur basé sur le temps qui déclenche un robot à intervalles réguliers. L'exemple de commande Demo Trigger
expliqué ici est une commande de déclenchement qui vous permet de créer et de gérer des déclenchements basés sur des intervalles spécifiés par l'utilisateur. Ce déclencheur peut être utilisé pour exécuter des tâches à intervalles réguliers.
@BotCommand(commandType = BotCommand.CommandType.Trigger)
@CommandPkg(label = "Demo Trigger", description = "Demo Trigger", icon = "email.svg", name = "demoTrigger",
return_type = RECORD, return_name = "TriggerData", return_description = "Available keys: triggerType")
- Type de commande : Déclencheur
- Étiquette : Déclencheur de démonstration
- Description : Déclencheur de démonstration
- Icône : email.svg
- Nom : demoTrigger
- Type de retour : ENREGISTRER
- Nom de retour : TriggerData
- Description du retour : Clés disponibles : triggerType
La classe TriggerDemo
est une classe unique qui gère les tâches de déclenchement. Elle stocke les tâches dans une carte en utilisant triggerId
comme clé. Lorsque la condition de déclenchement est remplie, la méthode run
du Runnable
associé est appelée pour signaler le déclenchement.
taskMap
: UnConcurrentHashMap
statique qui stocke plusieurs tâches de déclenchement.TIMER
: UnTimer
statique utilisé pour planifier les tâches de déclenchement.triggerUid
: Annoté par@TriggerId
, il représente l'identifiant unique du déclencheur.consumer
: Annoté par@TriggerConsumer
, c'est le consommateur qui acceptera les données de déclenchement.
startTrigger
: Annotée par@StartListen
, cette méthode lance le déclencheur. Elle prend un paramètre d'intervalle (en secondes) pour spécifier l'intervalle d'activation du déclencheur. Elle crée un nouveauTimerTask>
qui appelle la méthoderun
duRunnable
associé lorsqu'elle est exécutée. LeTimerTask
est ajouté autaskMap
avec l'identifiant du déclencheur comme clé, et il est planifié pour s'exécuter à l'intervalle spécifié.getRecordValue
: Une méthode privée qui crée et renvoie unRecordValue
contenant les données du déclencheur. Les données de déclenchement comprennent un schéma avec une clé unique « triggerType » et sa valeur correspondante « Intervalle du déclencheur ».stopAllTriggers
: Annotée par@StopAllTriggers
, cette méthode annule toutes les tâches de déclenchement et efface letaskMap
.stopListen
: Annotée par@StopListen
, cette méthode annule une tâche de déclenchement spécifique identifiée par le paramètretriggerUid
et la supprime dutaskMap
.- Méthodes de définition :
setTriggerUid
etsetConsumer
sont des méthodes de définition pour les variablestriggerUid
etconsumer
, respectivement.
/*
* Copyright (c) 2023 Automation Anywhere.
* All rights reserved.
*
* This software is the proprietary information of Automation Anywhere.
* You shall use it only in accordance with the terms of the license agreement
* you entered into with Automation Anywhere.
*/
/**
*
*/
package com.automationanywhere.botcommand.samples.trigger;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Consumer;
import com.automationanywhere.botcommand.data.Value;
import com.automationanywhere.botcommand.data.impl.RecordValue;
import com.automationanywhere.botcommand.data.impl.StringValue;
import com.automationanywhere.botcommand.data.model.Schema;
import com.automationanywhere.botcommand.data.model.record.Record;
import com.automationanywhere.commandsdk.annotations.*;
import com.automationanywhere.commandsdk.annotations.rules.GreaterThan;
import com.automationanywhere.commandsdk.annotations.rules.NotEmpty;
import com.automationanywhere.commandsdk.annotations.rules.NumberInteger;
import com.automationanywhere.commandsdk.model.AttributeType;
import com.automationanywhere.commandsdk.model.DataType;
import static com.automationanywhere.commandsdk.model.DataType.RECORD;
/**
* There will be a singleton instance of this class. Whenever a new trigger is
* created it comes with a triggerId. In this sample we create multiple tasks
* and store them in a map with these triggerId as the key. Once the condition
* of trigger matches we call the run method of the runnable to signal the
* trigger.
* In the following example we will create a trigger which triggers are user
* specified intervals.
*
*/
@BotCommand(commandType = BotCommand.CommandType.Trigger)
@CommandPkg(label = "Demo Trigger", description = "Demo Trigger", icon = "email.svg", name = "demoTrigger",
return_type = RECORD, return_name = "TriggerData", return_description = "Available keys: triggerType")
public class TriggerDemo {
// Map storing multiple tasks
private static final Map<String, TimerTask> taskMap = new ConcurrentHashMap<>();
private static final Timer TIMER = new Timer(true);
@TriggerId
private String triggerUid;
@TriggerConsumer
private Consumer consumer;
/*
* Starts the trigger.
*/
@StartListen
public void startTrigger(@Idx(index = "1", type = AttributeType.NUMBER)
@Pkg(label = "Please provide the interval to trigger in seconds", default_value = "120", default_value_type = DataType.NUMBER)
@GreaterThan("0")
@NumberInteger
@NotEmpty
Double interval) {
TimerTask timerTask = new TimerTask() {
@Override
public void run() {
consumer.accept(getRecordValue());
}
};
taskMap.put(this.triggerUid, timerTask);
TIMER.schedule(timerTask, interval.longValue());
}
private RecordValue getRecordValue() {
List<Schema> schemas = new LinkedList<>();
List<Value> values = new LinkedList<>();
schemas.add(new Schema("triggerType"));
values.add(new StringValue("Interval Trigger"));
RecordValue recordValue = new RecordValue();
recordValue.set(new Record(schemas,values));
return recordValue;
}
/*
* Cancel all the task and clear the map.
*/
@StopAllTriggers
public void stopAllTriggers() {
taskMap.forEach((k, v) -> {
if (v.cancel()) {
taskMap.remove(k);
}
});
}
/*
* Cancel the task and remove from map
*
* @param triggerUid
*/
@StopListen
public void stopListen(String triggerUid) {
if (taskMap.get(triggerUid).cancel()) {
taskMap.remove(triggerUid);
}
}
public void setTriggerUid(String triggerUid) {
this.triggerUid = triggerUid;
}
public void setConsumer(Consumer consumer) {
this.consumer = consumer;
}
}
ExempleDemo Trigger
demoTrigger.startTrigger(60.0);
Ceci lancera un déclencheur qui s'exécutera toutes les 60 secondes et appellera le consommateur associé avec les données du déclencheur.
Pour arrêter le déclenchement, vous pouvez utiliser les méthodes suivantes :
demoTrigger.stopAllTriggers()
: Cette méthode arrête tous les déclencheurs actifs.demoTrigger.stopListen(triggerUid)
: Cette méthode permet d'arrêter un déclencheur spécifique identifié par letriggerUid
.Remarque : LetriggerUid
est un identifiant unique pour chaque déclencheur et est attribué automatiquement lors de la création d'un déclencheur.