Criar um gatilho personalizado (Exemplo 2)

O exemplo mostra como criar um gatilho em Automation 360 que permite criar as tarefas que serão executadas nos intervalos especificados.

Um gatilho lança um bot quando certas condições são atendidas e espera até que as condições tenham mudado ou parado. Quando as condições do gatilho são combinadas, o método de execução é chamado para sinalizar o gatilho.

Anotações necessárias

Para criar um gatilho, são necessárias as seguintes anotações:

Anotação Utilização
BotCommand Use a anotação BotCommand com o gatilho como commandType. Isso garante que o objeto Java simples antigo (POJO) seja adequado para criar o gatilho com Automation 360.
CommandPkg Esses valores são utilizados na criação de um pacote. Forneça um nome, rótulo e descrição para a anotação.
TriggerId Uma identificação do gatilho, que é necessária para parar o gatilho.

TriggerConsumer

 Especifica a função do consumidor a ser invocada quando a condição do gatilho for atendida.
StartListen Inicia o ouvinte do gatilho.
StopAllTriggers Identifica o método usado para cancelar todos os gatilhos.
StopListen Identifica o método responsável pelo cancelamento de um gatilho específico.

Caso de uso — Gatilho do temporizador

O seguinte caso de uso mostra como criar um gatilho temporizador que aciona um bot em intervalos regulares. A amostra de comando Demo Trigger explicada aqui é um comando de gatilho que permite criar e gerenciar gatilhos com base em intervalos especificados pelo usuário. Esse gatilho pode ser usado para executar tarefas em intervalos regulares.

Informação 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: Gatilho
  • Rótulo: Gatilho de demonstração
  • Descrição: Gatilho de demonstração
  • Ícone: email.svg
  • Nome: demoTrigger
  • Tipo de retorno: GRAVAR
  • Nome do retorno: TriggerData
  • Descrição do retorno: Chaves disponíveis: triggerType
Estrutura de classe

A classe TriggerDemo é uma classe singleton que gerencia as tarefas de gatilho. Ela armazena as tarefas em um mapa usando o triggerId como chave. Uma vez atendida a condição do gatilho, o método run do Runnable associado é chamado para sinalizar o gatilho.

Variáveis de classe
  • taskMap: Um ConcurrentHashMap estático que armazena múltiplas tarefas de gatilho.
  • TIMER: Um Timer estático usado para agendar as tarefas de gatilho.
  • triggerUid: Anotado com @TriggerId, representa o identificador exclusivo do gatilho.
  • consumer: Anotado com @TriggerConsumer, é o consumidor que aceitará os dados do gatilho.
Métodos
  • startTrigger: Anotado com @StartListen, esse método inicia o gatilho. Um parâmetro de intervalo (em segundos) é necessário para especificar o intervalo de ativação do gatilho. Ele cria um novo TimerTask> que chama o método run do Runnable associado quando executado. O TimerTask é adicionado ao taskMap com o triggerUid como chave e é agendado para ser executado no intervalo especificado.
  • getRecordValue: Um método privado que cria e retorna um RecordValue contendo os dados do gatilho. Os dados do gatilho incluem um esquema com uma única chave "triggerType" e o valor correspondente "Interval Trigger".
  • stopAllTriggers: Anotado com @StopAllTriggers, esse método cancela todas as tarefas de gatilho e limpa o taskMap.
  • stopListen: Anotado com @StopListen, esse método cancela uma tarefa de gatilho específica identificada pelo parâmetro triggerUid e o remove do taskMap.
  • Métodos setter: setTriggerUid e setConsumer são métodos setter para as variáveis triggerUid e 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;
	}

}
Exemplo
Aqui está um exemplo de uso do Demo Trigger
demoTrigger.startTrigger(60.0);

Ele inicia um gatilho que é executado a cada 60 segundos e chama o consumidor associado aos dados do gatilho.

Para interromper o gatilho, você pode usar os seguintes métodos:

  • demoTrigger.stopAllTriggers(): Esse método interrompe todos os gatilhos ativos.
  • demoTrigger.stopListen(triggerUid): Esse método interrompe um gatilho específico identificado pelo triggerUid.
    Nota: O triggerUid é um identificador exclusivo para cada gatilho e é atribuído automaticamente quando um gatilho é criado.