Crear un activador personalizado (ejemplo 2)
- Última actualización2023/07/21
Crear un activador personalizado (ejemplo 2)
El ejemplo muestra cómo crear un activador en Automation 360 que le permita crear tareas que se ejecutarán a intervalos específicos.
Un activador inicia un bot cuando se cumplen ciertas condiciones y espera hasta que las condiciones hayan cambiado o se hayan detenido. Cuando se cumplen las condiciones del activador, se llama al método de ejecución para señalar el activador.
Anotaciones obligatorias
Para crear un activador, se requieren las siguientes anotaciones:
Anotación | Uso |
---|---|
BotCommand |
Use la anotación BotCommand con el activador como commandType . Esto asegura que el objeto Java antiguo sin formato (POJO) sea adecuado para crear el activador de Automation 360. |
CommandPkg |
Estos valores se utilizan cuando se crea un paquete. Proporcione un nombre, una etiqueta y una descripción para la anotación. |
TriggerId |
Un ID de activación, necesario para detener el activador. |
|
Especifica la función consumidora que se invocará cuando se cumpla la condición de activación. |
StartListen |
Inicia la escucha de activadores. |
StopAllTriggers |
Identifica el método utilizado para cancelar todos los activadores. |
StopListen |
Identifica el método responsable de cancelar un activador específico. |
Caso de uso: activador de temporizador
El siguiente caso de uso muestra cómo crear un activador de temporizador que activa un bot a un intervalo regular. El ejemplo de comando Demo Trigger
que se explica aquí es un comando de activación que le permite crear y administrar activaciones en función de los intervalos especificados por el usuario. Este activador se puede utilizar para ejecutar tareas a intervalos regulares.
@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")
- Tipo de comando: Activador
- Etiqueta: Activador de demostración
- Descripción: Activador de demostración
- Icono: email.svg
- Nombre: demoTrigger
- Tipo de devolución: REGISTRO
- Nombre de retorno: TriggerData
- Descripción de devolución: Teclas disponibles: triggerType
La clase TriggerDemo
es una clase singleton que administra las tareas del activador. Almacena las tareas en un mapa usando triggerId
como la clave. Una vez que se cumple la condición del activador, el método run
del Runnable
asociado se solicita para dar una señal al activador.
taskMap
: UnConcurrentHashMap
estático que almacena múltiples tareas del activador.TIMER
: UnTimer
estático que se utiliza para programar las tareas del activador.triggerUid
: Anotado con@TriggerId
, representa el identificador único del activador.consumer
: Anotado con@TriggerConsumer
, es el consumidor el que aceptará los datos del activador.
startTrigger
: Anotado con@StartListen
, este método inicia el activador. Se necesita un parámetro de intervalo (en segundos) para especificar el intervalo de activación del activador. Crea un nuevoTimerTask>
que solicita el métodorun
delRunnable
asociado cuando se ejecuta.TimerTask
se agrega ataskMap
con triggerUid como clave y está programado para ejecutarse en el intervalo especificado.getRecordValue
: Un método privado que crea y devuelve unRecordValue
que contiene los datos del activador. Los datos del activador incluyen un esquema con una sola clave "triggerType" y su valor correspondiente "Interval Trigger".stopAllTriggers
: Anotado con@StopAllTriggers
, este método cancela todas las tareas del activador y borrataskMap
.stopListen
: Anotado con@StopListen
, este método cancela una tarea del activador específica identificada por el parámetrotriggerUid
y lo elimina detaskMap
.- Métodos de establecimiento:
setTriggerUid
ysetConsumer
son métodos de establecimiento para las variablestriggerUid
yconsumer
respectivamente.
/*
* 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;
}
}
EjemploDemo Trigger
demoTrigger.startTrigger(60.0);
Esto iniciará un disparador que se ejecuta cada 60 segundos y llama al consumidor asociado con los datos del activador.
Para detener el activador, puede usar los siguientes métodos:
demoTrigger.stopAllTriggers()
: Este método detendrá todos los activadores activos.demoTrigger.stopListen(triggerUid)
: Este método detendrá un activador específico identificado portriggerUid
.Nota:triggerUid
es un identificador único para cada activador y se asigna automáticamente cuando se crea uno.