Einen benutzerdefinierten Auslöser erstellen (Beispiel 2)

Das Beispiel zeigt, wie Sie einen Auslöser in Automation 360 erstellen, mit dem Sie Aufgaben erstellen können, die in bestimmten Intervallen ausgeführt werden.

Ein Auslöser startet einen Bot, wenn bestimmte Bedingungen erfüllt sind, und wartet, bis sich die Bedingungen geändert haben oder nicht mehr bestehen. Wenn die Bedingungen des Auslösers erfüllt sind, wird die Ausführungsmethode aufgerufen, um einen Signal an den Auslöser zu senden.

Erforderliche Anmerkungen

Zum Erstellen eines Auslösers sind die folgenden Anmerkungen erforderlich:

Anmerkung Verwendung
BotCommand Verwenden Sie die Anmerkung BotCommand mit dem Auslöser commandType. Dadurch wird gewährleistet, dass das Plain Old Java Object (POJO) für die Erstellung des Auslösers mit Automation 360 geeignet ist.
CommandPkg Diese Werte werden bei der Erstellung eines Pakets verwendet. Geben Sie einen Namen, eine Bezeichnung und eine Beschreibung für die Anmerkung an.
TriggerId Eine Auslöser-ID, die zum Anhalten des Auslösers erforderlich ist.

TriggerConsumer

 Gibt die Verbraucherfunktion an, die aufgerufen werden soll, wenn die Auslösebedingung erfüllt ist.
StartListen Startet den Auslöser-Listener.
StopAllTriggers Gibt die Methode an, mit der alle Auslöser abgebrochen werden.
StopListen Gibt die Methode an, die für das Abbrechen eines bestimmten Auslösers verantwortlich ist.

Anwendungsfall – Timer-Auslöser

Der folgende Anwendungsfall zeigt, wie Sie einen Timer-Auslöser erstellen, der in regelmäßigen Abständen einen Bot auslöst. Der hier erläuterte Demo Trigger-Befehl ist ein Auslöserbefehl, mit dem Sie Auslöser auf der Grundlage von benutzerdefinierten Intervallen erstellen und verwalten können. Dieser Auslöser kann verwendet werden, um Aufgaben in regelmäßigen Abständen auszuführen.

Informationen zum Befehl
@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")
  • Befehlstyp: Auslöser
  • Bezeichnung: Demo-Auslöser
  • Beschreibung Demo-Auslöser
  • Symbol: email.svg
  • Name: demoTrigger
  • Rückgabetyp: RECORD
  • Name der Rückgabe: TriggerData
  • Beschreibung der Rückgabe: Verfügbare Schlüssel: triggerType
Struktur der Klasse

Die TriggerDemo-Klasse ist eine Singleton-Klasse, die die Auslöseraufgaben verwaltet. Sie speichert die Aufgaben in einer Zuordnung mit triggerId als Schlüssel. Sobald die Auslösebedingung erfüllt ist, wird die run-Methode des zugehörigen Runnable-Elements aufgerufen, um ein Signal an den Auslöser zu senden.

Klassenvariablen
  • taskMap: Eine statische ConcurrentHashMap, die mehrere Auslöseraufgaben speichert.
  • TIMER: Ein statisches Timer-Element, das für die Planung der Auslöseraufgaben verwendet wird.
  • triggerUid: Mit der Anmerkung @TriggerId gekennzeichnet, stellt sie den eindeutigen Bezeichner für den Auslöser dar.
  • consumer: Mit der Anmerkung @TriggerConsumer gekennzeichnet, stellt sie den Verbraucher dar, der die Auslösedaten akzeptiert.
Methoden
  • startTrigger: Mit der Anmerkung @StartListen startet diese Methode den Auslöser. Mit einem Intervallparameter (in Sekunden) wird das Aktivierungsintervall des Auslösers festgelegt. Sie erstellt eine neue TimerTask>, die bei ihrer Ausführung die run-Methode des zugehörigen Runnable aufruft. Die TimerTask wird dem taskMap-Element mit der triggerUid als Schlüssel hinzugefügt und für die Ausführung im angegebenen Intervall geplant.
  • getRecordValue: Eine private Methode, die ein RecordValue-Element mit den Auslöserdaten erstellt und zurückgibt. Die Auslöserdaten umfassen ein Schema mit einem einzigen Schlüssel „triggerType“ und dem entsprechenden Wert „Interval Trigger“.
  • stopAllTriggers: Mit der Anmerkung @StopAllTriggers versehen, bricht diese Methode alle Auslöseaufgaben ab und löscht die taskMap.
  • stopListen: Mit der Anmerkung @StopListen versehen, bricht diese Methode eine bestimmte, durch den triggerUid-Parameter identifizierte Auslöseaufgabe ab und entfernt sie aus der taskMap.
  • Setter-Methoden: setTriggerUid und setConsumer sind Setter-Methoden für die Variablen triggerUid bzw. consumer.
/*
 * 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;
	}

}
Beispiel
Hier ist ein Beispiel für die Verwendung des Demo Triggers
demoTrigger.startTrigger(60.0);

Dadurch wird ein Auslöser gestartet, der alle 60 Sekunden ausgeführt wird und den zugehörigen Verbraucher mit den Auslöserdaten aufruft.

Um den Auslöser zu stoppen, können Sie die folgenden Methoden verwenden:

  • demoTrigger.stopAllTriggers(): Mit dieser Methode werden alle aktiven Auslöser gestoppt.
  • demoTrigger.stopListen(triggerUid): Mit dieser Methode wird ein bestimmter Auslöser gestoppt, der durch die triggerUid identifiziert wird.
    Anmerkung: Die triggerUid ist ein eindeutiger Bezeichner für den jeweiligen Auslöser, der bei der Erstellung des Auslösers automatisch zugewiesen wird.