Créer un déclencheur personnalisé (exemple 2)

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.
`TriggerConsumer`	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.

Informations sur la commande

@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

Structure de classe

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.

Variables de classe

taskMap : Un ConcurrentHashMap statique qui stocke plusieurs tâches de déclenchement.
TIMER : Un Timer 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.

Méthodes

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 nouveau TimerTask> qui appelle la méthode run du Runnable associé lorsqu'elle est exécutée. Le TimerTask est ajouté au taskMap 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 un RecordValue 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 le taskMap.
stopListen : Annotée par @StopListen, cette méthode annule une tâche de déclenchement spécifique identifiée par le paramètre triggerUid et la supprime du taskMap.
Méthodes de définition : setTriggerUid et setConsumer sont des méthodes de définition pour les variables triggerUid et consumer, 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;
	}

}

Exemple

Voici un exemple d'utilisation de Demo 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 le triggerUid.
Remarque : Le triggerUid est un identifiant unique pour chaque déclencheur et est attribué automatiquement lors de la création d'un déclencheur.