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.

TriggerConsumer

 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.

Información de comando
@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
Estructura de clase

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.

Variables de clase
  • taskMap: Un ConcurrentHashMap estático que almacena múltiples tareas del activador.
  • TIMER: Un Timer 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.
Métodos
  • 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 nuevo TimerTask> que solicita el método run del Runnable asociado cuando se ejecuta. TimerTask se agrega a taskMap con triggerUid como clave y está programado para ejecutarse en el intervalo especificado.
  • getRecordValue: Un método privado que crea y devuelve un RecordValue 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 borra taskMap.
  • stopListen: Anotado con @StopListen, este método cancela una tarea del activador específica identificada por el parámetro triggerUid y lo elimina de taskMap.
  • Métodos de establecimiento: setTriggerUid y setConsumer son métodos de establecimiento para las variables triggerUid y consumer 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;
	}

}
Ejemplo
He aquí un ejemplo del uso de Demo 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 por triggerUid.
    Nota: triggerUid es un identificador único para cada activador y se asigna automáticamente cuando se crea uno.