Form Editor - Client Command über die AESB Schnittstelle an einen Client senden

Last modified by Sabrina V. on 2024/10/14 06:26

  

Ausgangslage

In diesem Anwendungsfall wird Ihnen anhand einer Schritt-für-Schritt Anleitung aufgezeigt, wie Sie mithilfe eines Client Commands den Form Editor über die AESB Schnittstelle an einen Client senden können. Dabei werden die verfügbaren Clients aus der Datenbank geladen und in einer Liste angezeigt. Über ein Suchfeld kann der Benutzer nach bestimmten Client Commands filtern. Die Treffer werden aus der Datenbank geholt und ebenfalls in einer Liste angezeigt. Um das versehentliche Absenden des Client Commands zu verhindern, muss der Benutzer noch eine Checkbox anhaken. Diese dient dazu zu bestätigen, dass der ausgewählte Client und das ausgewählte Client Command korrekt sind.

Zur besseren Verständlichkeit wird der Inhalt des Form Editors größtenteils in der Code-Ansicht erläutert.

66_Use Case Client Commands_AESB Code Ausschnitt_906.png

Code-Ansicht für den nachfolgenden Client Commands Use Case

Hinweis  Note:  

Lesen Sie hier nach, wie Sie AESB installieren können und wie die Komponenten ACMP und AESB miteinander verbunden werden.

Skript auswählen

  1. Navigieren Sie ins Modul Client Commands > Erstellen.
  2. Klicken Sie in der Ribbonleiste auf Hinzufügen. Es öffnet sich der Client Command Editor, in dem Sie entscheiden müssen, ob es sich um ein Console- oder Clientskript handelt. In diesem Fall wählen Sie das Console Skript aus.

Command Set project variable auswählen und bearbeiten

  1. Wählen Sie aus der Commandliste das Command Variables > Set project variable aus.
  2. Öffnen Sie den Befehl per Doppelklick und öffnen Sie nun den Tab Allgemein.
  3. Tragen Sie unter Beschreibung der Aktion einen Namen ein. In diesem Beispiel wird „Hier den AESB Benutzernamen setzen“ eingefügt. Alle weiteren Konfigurationsmöglichkeiten in diesem Tab müssen nicht angepasst werden.
  4. Wechseln Sie in den Tab Details.
  5. Klicken Sie unter der Variableneinstellung auf das Icon neben dem Variablennamen.
  6. Optional: Legen Sie eine neue Variable unter den Aktionen an. Benennen Sie diese „USERNAME“ und klicken Sie auf das Plus-Icon. Klicken Sie anschließend auf den OK Button, um den Schritt abzuschließen und damit der Eintrag als Variablenname gelistet wird.

Hinweis  Note:  

Dieser Schritt ist optional, sollte sich diese Variable bisher nicht bei Ihnen im System befinden und angelegt worden sein.

      7. Fügen Sie unter dem Feld Einzeiliger Text den Begriff „Operator“ ein. Dieser wird hier als Erkennungsmerkmal für den Benutzernamen benötigt.
      8. Klicken Sie im Anschluss auf OK.

66_Use Case Client Commands_AESB Form Editor Set project variable Username_570.png

Variableneinstellungen vornehmen

Command Set project variable auswählen und editieren

  1. Wählen Sie erneut das Command Set project variable aus.
  2. Öffnen Sie den Befehl mit einem Doppelklick und öffnen Sie den Tab Allgemein.
  3. Geben Sie unter der Beschreibung den Namen der Aktion ein, z.B. Hier das AESB Benutzerkennwort setzen. Nehmen Sie keine weiteren Änderungen an den anderen Einstellungen vor, diese sind nicht nötig.
  4. Wechseln Sie in den Tab Details.
  5. Optional: Legen Sie eine neue Variable unter den Variableneinstellungen an. Klicken Sie dafür auf das Icon neben den Listeneinträgen und es öffnet sich ein neues Fenster. Benennen Sie die neue Variable „PASSWORD“ und klicken Sie auf das Plus-Icon. Schließen Sie diesen Schritt mit dem OK ab.

Hinweis  Note:  

Dieser Schritt ist optional, sollten Sie im Vorfeld diese Variable noch nicht angelegt haben.

      6. Wählen Sie die Option Einzeiliger Text aus, sollte dies noch nicht erfolgt sein. In dieser Zeile muss der Klartext später eingefügt werden, also das Passwort.
      7. Beenden Sie Ihre Arbeiten an diesem Command und klicken Sie auf OK.

66_Use Case Client Commands_AESB Form Editor Set project variable Password_476.png

Variableneinstellungen festlegen

Command Form Editor öffnen und bearbeiten

Warning  Warning:  

Das Client Command Form Editor ist äußerst komplex und sollte nur verwendet werden, wenn Sie über ausreichendes Wissen mit der Programmierung unter Delphi Skripten verfügen und auch wissen, wie die Nutzung einer IDE (Integrierte Entwicklungsumgebung) funktioniert. 

Die Elemente des Form Editors können Sie entweder über die Code- oder Design-Ansicht bearbeiten. Der besseren Verständlichkeit wird im nachfolgenden Abschnitt nur vereinzelt auf die optische Design-Ansicht eingegangen, sondern mehr auf den Code. Hierdurch entfallen die Erklärungen zu den Eigenschaften und Events des Object Inspectors, die Sie hier nachlesen können.

Mithilfe dieses Client Commands bauen Sie ein interaktives Formular, wo Sie einem Client ein ausgewähltes Client Command zuweisen können. Gehen Sie dafür wie folgt weiter vor:

  1. Wählen Sie das Client Command Form Editor (Dialogs > Form Editor) aus.
  2. Öffnen Sie den Befehl mit einem Doppelklick und öffnen Sie den Tab Allgemein und passen Sie optional die Beschreibung der Aktion an. In diesem Beispiel bleibt der Titel hier Form Editor.
  3. Wechseln Sie in den Tab Form bearbeiten.
  4. Klicken Sie unterhalb der Form Vorschau auf den Button Form bearbeiten. Es öffnet sich ein neues Fenster für die Arbeiten mit dem Form Editor in der Standardansicht, mit einigen benutzerdefinierten Feldern.

Hinweis  Note:  

Hinweis: Lesen Sie hier weitere Informationen zum Einsatz des Form Editors bzw. der IDE (Integrierte Entwicklerumgebung) nach.

      5. Wechseln Sie aus der Design- in die Code-Ansicht, indem Sie den unteren Tab klicken (siehe Abbildung). Die Ansicht verändert sich.

66_Use Case Client Commands_AESB Form Editor Standard_1191.png

Ansicht des Form Editors

      6. Wechseln Sie hier in den Tab FormUnit, sollten Sie sich noch nicht darin befinden. Sie sehen hier den Code vom oberen Custom Windows-Fenster aus der Design-Ansicht. Dieser Code muss nun für Ihre Zwecke angepasst werden.

66_Use Case Client Commands_AESB Form Editor Code Ansicht_592.png

Ansicht des Codes zum Custom Windows-Fenster

Code anpassen

Nachfolgend wird der Code in Sinnabschnitten unterteilt und jeweils erklärt. Fügen Sie die Zeilen immer in der hier dargestellten Reihenfolge ein, damit das Client Command richtig funktioniert. Hierbei wird die Form so ausgeführt, wie sie später angezeigt wird.

Hinweis  Note:  

Sämtliche Angaben im Code, die nach einem doppelten Schrägstrich stehen, sind auskommentiert und dienen lediglich als spezifische Erklärung der nachfolgenden Zeilen. Sie sind nicht Teil der Ausführung. 

ZeilenabschnittBeschreibung
Zeile 1 - 13 
{$FORM TCustomACMPWindow, FormUnit.sfm}  

uses
  Classes, Graphics, Controls, Forms, Dialogs, ExtCtrls,
  StdCtrls, SysUtils, Buttons, AagonSQLQuery, AagonAESBV1,
  ComCtrls;
var   
  LClients, LClientCommands, ResultMessages: TStringlist;
  IResult, Protocol, ExchangeType, AErrorCode, ConnectionTimeout: Integer;
  Server, Port, SClientID, SClientCommandID, MessageID, AAckMessages, AResult, Username,
  Passwort, ConnectionString, VirtualRouter, RoutingKey, Tag, CallbackVirtualRouter, CallbackRoutingKey,
  TargetConnectionVariable : string;
  

In diesen Zeilen wird die Anzeige des Form Editors für den Benutzer festgelegt und beschrieben, womit die Anzeige befüllt wird und nach welchem Typ die Inhalte generiert werden (Datentyp: String, Zeile 12).

In den Zeilen werden Units hinzugefügt (uses, Zeilen 3 – 6) und Variablen (var, Zeilen 7 – 12) deklariert, die zu einem späteren Zeitpunkt befüllt werden können. Der jeweilige Variablentyp (z.B. TStringlist, Integer oder String) steht hinter den Variablennamen.

 

Zeile 14 - 21 
//  
function EscapeValues(Value: String) : String;
begin
  Value := '"'+StringReplace(Value,',','","')+'"';
  Result := StringReplace(Value, '","","', ',');
end;
  
//
Diese Funktion wird benötigt, um bestimmte Sonderzeichen in Strings zu verwenden. Einige Sonderzeichen im String haben eine besondere Bedeutung für das Programm: Wenn Sie diese Sonderzeichen anzeigen möchten, müssen Sie diese „escapen“. Beim Escapen wird dem anzuzeigenden Sonderzeichen dasselbe Zeichen vorangestellt oder aber ein bestimmtes anderes Zeichen, wie z.B. ein „\“.
Zeile 22 - 45 
function SetAESBConfig;  
begin
  Protocol := 1; // HTTP (0) / HTTPS (1)    
  ConnectionTimeout:= 30; // Timeout in Sekunden
  ExchangeType:= 1; // Direct (0) / Routing (1)  
  ResultMessages.Clear();
  AAckMessages:= '';  
  AResult:= '';
  AErrorCode:= 0;
  IResult:= 0;   
  Server:= '127.0.0.1';
  Port:= '3900';
  Username:= GetVarContent('USERNAME');
  Passwort:= GetVarContent('PASSWORD');  
  TargetConnectionVariable:= 'CONNECTION';  
  ConnectionString:= '';
  MessageID:= '{43584358-4358-4358-4358-435843584358}'; //hier kann eine beliebige GUID verwendet werden  
  VirtualRouter:= 'VCMN';
  RoutingKey:= '?.Aagon.Components.ACMPServer.*';
  Tag:= 'ICQL';
  CallbackVirtualRouter := '';  
  CallbackRoutingKey := '';    
end;
   

In diesem Abschnitt werden die Variablen für die AESB Service Funktion (function SetAESBConfig, Zeile 22) definiert und mit Werten befüllt. Die Funktion wird im späteren Verlauf benötigt (ab Zeile 142), die Sie aber bereits an dieser Stelle konfigurieren müssen.

Befüllen Sie die Zeilen der Funktion wie folgt:

Zeile 24: Tragen Sie hier den Typen des Protokolls ein. Der Wert 0 steht für eine HTTP Seite, die 1 für eine HTTPS Seite. Fügen Sie hier eine 1 ein, da es sich um eine verschlüsselte Anfrage handelt.

Zeile 25: Legen Sie eine Sekundenanzahl fest, wann die Anfrage an das AESB in ein Timeout läuft. Hier wurde der Standardwert „30 Sekunden“ angegeben.

Zeile 26: Der ExchangeType kann entweder über den Typen „Direct (0)“ oder „Routing (1)“ befüllt werden. Hier wird die letztere Option gewählt.

Zeile 27: ResultMessages.Clear() löscht die Stringliste.

Zeilen 28 – 29: Die beiden Variablen AAckMessages und AResult können leer bleiben. Tragen Sie dafür hinter dem Gleichheitszeichen '' ein.

Zeilen 30 – 31: Der AErrorCode und IResult werden jeweils mit dem Wert 0 befüllt.

Zeile 32: Tragen Sie hier den Namen oder die IP des AESB Servers ein, mit dem Sie sich verbinden wollen. In diesem Beispiel ist es '127.0.0.1'.

Zeile 33: Tragen Sie hier die Portnummer ein, die Sie für die Verbindung benötigen (hier: '3900').

Zeile 34: Hier wird die Funktion GetVarContent verwendet, die auf die Projektvariable ('USERNAME') verweist. Die Projektvariable muss außerhalb des Form Editors im Client Command selber angelegt und befüllt werden.

Zeile 35: Hier wird die Funktion GetVarContent verwendet, die auf die Projektvariable ('PASSWORD') verweist. Auch diese Projektvariable muss außerhalb des Form Editors im Client Command selber angelegt und befüllt werden.

Zeile 36: Die Variable TargetConnectionVariable muss mit dem Wert 'CONNECTION' befüllt werden. Das Protokoll setzt diesen Typen für diese Art der Verbindung voraus (Typ: Connection).

Zeile 37: Der Wert des ConnectionStrings bleibt leer (' ') und wird im späteren Verlauf mit Werten befüllt.

Zeile 38: Die MessageID ist eine GUID, die beliebig ausgetauscht und verwendet werden kann. Bei der Eingabe ist es jedoch wichtig, dass diese dem gleichen Eingabeschema folgt: Die Anzahl der Stellen muss gleichbleiben (jeweils 8-4-4-4-8 Ziffern).

Zeile 39: Für den VirtualRouter muss der Wert 'VCMN' eingegeben werden. Es handelt sich hierbei um einen virtuellen Abschnitt innerhalb des AESB, in dem sich der ACMP Server befindet. Da in diesem Beispiel mit dem ACMP kommuniziert wird, muss dieser Router angegeben werden.

Zeile 40: Der RoutingKey gibt an, wohin die eingegebenen Werte geschickt werden sollen. Demnach muss hier der ACMP Server eingetragen werden, der die Eingaben erhalten soll. In diesem Beispiel heißt er '?.Aagon.Components.ACMPServer.*'. Das Fragezeichen und das Sternchen stehen beide für eine Wildcard. Das Sternchen repräsentiert hierbei die ACMP Server-ID. Sollten Sie mehrere ACMP Server mit dem AESB verbunden haben, können Sie auch die ID eines Servers eintragen, um die Daten nur dorthin zu leiten.

Zeile 41: Die Eingabezeile Tag beschreibt die Art der Nachricht. Da hier das ICQL Protokoll verwendet wird, muss der einzutragende Wert 'ICQL' lauten.

Zeilen 42 – 43: Hier werden der Virtual Router (CallbackVirtualRouter, Zeile 42) und Routing Key (CallbackRoutingKey, Zeile 43) angezeigt. Es wird keine Rückantwort benötigt, daher reicht hinter dem Gleichheitszeichen in beiden Zeilen ein '' als leerer Wert.

Zeile 46 - 55 
function GetClientID : String;
var
  Ltemp : TStringList;
begin
  LTemp := TStringList.Create();
  LTemp.CommaText := LClients.Strings[LBClients.ItemIndex];
  Result := LTemp.Values['CLIENTID'];
  LTemp.Free();
end
  

In den Zeilen 46 – 50 wird die Funktion GetClientID, mit einem Rückgabewert des Typen String, beschrieben. Die Funktion ermittelt die Client-ID des in der Oberfläche ausgewählten Clients aus der Liste LBClients.

Zeile 46: Beginn der Funktion GetClientID mit einem String als Rückgabewert.

Zeilen 47 – 54: Der Wert LClients.Strings beinhaltet den Index des Clients, den Sie ausgewählt haben. Mit diesem Index wird in der Liste LClients.Strings der entsprechende Client ausgesucht und in eine temporäre Variable zwischengespeichert. Der Rückgabewert der Funktion (Zeile 52) wird auf den Wert „Client-ID“ aus der temporären Variable gesetzt und entspricht damit der Client-ID, die Sie als selektierten Agenten aus der Liste gewählt haben. Über die Zeile 53 wird der Arbeitsspeicher wieder freigegeben.

Zeile 56 - 65 
function GetClientCommandID : String;
var
  Ltemp : TStringList;
begin
  LTemp := TStringList.Create();  
  LTemp.CommaText := LClientCommands.Strings[LBClientCommands.ItemIndex];
  Result := LTemp.Values['SCRIPTID'];
  LTemp.Free();
end
   

Die Zeilen 56 – 65 beschreiben die Funktion GetClientCommandID. Die Funktion ermittelt die Client Command-ID des in der Oberfläche ausgewählten Client Commands aus der Liste LBClientCommands.

Zeile 56: Beginn der Funktion GetClientCommandID mit einem String als Rückgabewert.

Zeilen 57 – 65: LBClientCommands.ItemIndex beinhaltet den Index des Client Commands, den Sie ausgewählt haben. Mit diesem Index wird in der Liste LClientCommands.Strings das entsprechende Client Command ausgesucht und in eine temporäre Variable zwischengespeichert. Der Rückgabewert der Funktion (Zeile 52) wird auf den Wert „Script-ID“ aus der temporären Variable gesetzt und entspricht damit der Client Command-ID, die Sie als selektiertes Client Command aus der Liste gewählt haben.

Der Arbeitsspeicher wird über die Zeile 63 freigegeben (LTemp.Free()).

Zeile 66 - 80 
function CreateMessageBody : String;
var
  MessageBody : TStringList;
begin
 
  MessageBody := TStringList.Create();
  MessageBody.Add('<ICQL><ACMP><EnqueueClientCommand version="1">');
  MessageBody.Add('<TEnqueueClientCommandRequest_V1 xmlns:xsi="http:~/~/www.w3.org/2001/XMLSchema-instance">');
  MessageBody.Add('<ClientId>'+GetClientID+'</ClientId>');
  MessageBody.Add('<ClientCommandId>'+GetClientCommandID+'</ClientCommandId>');
  MessageBody.Add('</TEnqueueClientCommandRequest_V1></EnqueueClientCommand></ACMP></ICQL>');
  Result := MessageBody.Text;
  MessageBody.Free();
end  

Die Zeilen 66 – 80 beschreiben die Funktion für das Erstellen der Nachricht, die an den SICS / AESB gesendet wird. In dem Abschnitt, wo der MessageBody festgelegt und befüllt wird, muss zunächst der Datentyp definiert werden. In Zeile 72 werden verschiedene Werte hinterlegt, die zwingend eingehalten werden müssen. ICQL steht für das Format, in dem das SICS die Anfrage erwartet, ebenso wie den Wert ACMP. EnqueueClientCommand legt fest, dass eine Funktion zum Einreihen eines Client Commands aufgerufen werden soll und zwar in der Version 1.

Zeilen 74 und 75 legen fest, dass die Anfrage die Client ID und die GetClientCommandID als Tag beinhalten müssen, damit der Empfänger (in diesem Fall der ACMP Server) weiß, welches Client Command er zu welchem Client schicken muss.

Der Rückgabewert (Zeile 77) enthält dann die komplette Nachricht. Danach folgt eine Freigabe des Arbeitsspeichers über die Zeile 78.

Zeile 81 - 109 
procedure GetClients;
var
  LSQL, LTemp : TStringList;
  I : Integer;
begin
  LSQL := TStringList.Create();
  LTemp := TStringList.Create();
  
// SQLStatement zum Ermitteln der Clients
  LSQL.Add('SELECT COMPUTERNAME, CLIENTID');
  LSQL.Add('FROM CLT_CLIENTS');
  LSQL.Add('WHERE ismanaged = 1');
  LSQL.Add('ORDER BY COMPUTERNAME');
  
// Leeren der Listbox der Clients
  LBClients.Clear();
  LClients.Clear;
// Ausführen des Statements zum Beziehen der Clients aus der DB
  SQLQuery(LSQL.Text,'','',LClients,true,30);
  
  for i := 0 to (LClients.Count-1) do
    begin
      LTemp.Commatext := EscapeValues(LClients.Strings[i]);
      LBClients.Items.Add(LTemp.Values['COMPUTERNAME']);
    end
  LSQL.Free();
  LTemp.Free();
end;
  

Die Zeilen 81 – 109 (procedure GetClients) holen die Agenten aus der Datenbank und speichern diese in die linke Box, die direkt beim Start des Fensters mit den Einträgen befüllt wird. Hierfür werden zunächst zwei Listen definiert und anschließend erzeugt (86 und 87). Anschließend wird die SQL Abfrage/ das SQL Statement zusammengebaut und mit Werten befüllt, womit die Ermittlung der Clients ermöglicht wird. Es wird nur der Computername und die Client-ID aus der Tabelle CLT_Clients geholt. Mit der Bedingung ismanaged=1 wird sichergestellt, dass es sich nur um gemangte Agenten handelt. Die Liste, die vom SQL Server zurückgeliefert wird, wird nach dem Computernamen sortiert (89 – 94). Die Listbox wird vor dem Befüllen einmal geleert, um zu verhindern, dass noch Einträge vorhanden sind (96 und 97).

Die Funktion SQL Query wendet das SQL Statement an und schreibt alle Clients in die globale Stringlist (LClients) (Zeile 99). Die Zeilen 101 – 107 befüllen die Oberfläche der Listbox, die Sie als Benutzer angezeigt bekommen. Die Listbox wird mit den Computernamen befüllt, die zuvor aus der SQL Abfrage geholt wurden. Die letzten beiden Zeilen (106 und 107) geben die zuvor erstellten Listen jeweils wieder frei.

Zeile 110 - 141 
procedure GetClientCommands;
var
  LSQL, LTemp : TStringList;
  I : Integer;
begin

  LSQL := TStringList.Create();
  LTemp := TStringList.Create();
  LSQL.Add('DECLARE @Search nvarchar(200) = ' + QuotedStr(EDCCSearch.Text) + ';')
  LSQL.Add('SELECT DESCRIPTION, SCRIPTID');
  LSQL.Add('FROM SYS_SCRIPTS');
  LSQL.Add('WHERE HASCLIENTSCRIPT = 1');
  LSQL.Add('AND State = 7');
  LSQL.Add('AND DESCRIPTION LIKE @Search');  
  LSQL.Add('ORDER BY DESCRIPTION');
 
// Leeren der Listbox der ClientCommands
  LBClientCommands.Clear();
  LClientCommands.Clear();
// Ausführen des Statements zum Beziehen der ClientCommands aus der DB
  SQLQueryEx(LSQL.Text,'','',LClientCommands,true,emOpen,30);

  for I := 0 to (LClientCommands.Count-1) do
    begin
      LTemp.Commatext := EscapeValues(LClientCommands.Strings[i]);
      LBClientCommands.Items.Add(LTemp.Values['DESCRIPTION']);
    end  

  LSQL.Free();
  LTemp.Free();
end;
   

Mit diesen Zeilen (110 – 141) wird die rechte Box mit den Client Command Einträgen befüllt, indem sie aus der SQL Datenbank geladen und dort eingefügt werden. Es werden zunächst zwei Listen definiert (116 und 117). Zum Ermitteln der Client Commands wird eine SQL-Abfrage in den Zeilen 119 – 124 erstellt. Zeile 118 verwendet das Suchfeld der Oberfläche, um nur Client Commands mit diesem Namen aus der Datenbank zu holen. Die Eingabe der Wildcard „%“ holt alle Client Commands aus der Datenbank, die Eingabe „Test_%“ holt lediglich alle Client Commands die mit „Test_“ im Namen beginnen.  (LSQL.Add('DECLARE @Search nvarchar(200) = ' + QuotedStr(EDCCSearch.Text) + ';')).

Über die Zeilen 127 und 128 wird die Listbox und die globale Liste der Client Commands geleert. Es folgt die Ausführung des Statements über die SQL Query, wobei die geholten Client Commands in die globale Stringlist (LClientCommands) geschrieben werden. Die Zeilen 132 – 136 befüllen die Oberfläche der Listbox mit der Description (Name) des Client Commands, die aus der SQL Abfrage zuvor geholt wurden. Die Zeilen 138 und 139 geben die Funktionen wieder jeweils frei.

Zeile 142 - 151 
procedure FormActivate;
begin
  LClients := TStringList.Create();
  LClientCommands := TStringList.Create();
  
  ResultMessages := TStringList.Create();
  GetClients;
  SetAESBConfig;
end;     
    

Procdure FormActivate (Zeilen 142 – 151) wird aufgerufen, wenn das Fenster erstellt wird. Die globalen Listen LClients und LClientCommands werden als erstes erzeugt (144 und 145). Die Methode GetClients holt alle Clients aus der Datenbank und zeigt sie in der Oberfläche an (siehe obere Funktion) (148). Die Funktion SetAESBConfig wird in Zeile 149 aufgerufen und setzt alle Variablen, die zuvor von Ihnen eingestellt wurden und die notwendig sind, um mit dem AESB zu kommunizieren (siehe Funktion oben).

Zeile 152 - 160 
procedure OkButtonClick(Sender: TObject);
begin
  LClients.Free();
  LClientCommands.Free();
  
  ResultMessages.Free();
  CloseForm(0);
end;
  

Die Funktion in den Zeilen 152 – 160 wird aufgerufen, wenn der OK Button gedrückt wird. Dabei werden alle Listen geleert, damit keine Einträge mehr in LClients oder LClientCommands stehen. Zeile 158 CloseForm(0) schließt die Form mit dem Parameter 0.

Hinweis  Note:  

Als Parameter in der Klammer können Sie jede beliebige Ganzzahl reinschreiben. Standardmäßig bedeutet eine -1, dass dieser Baustein fehlgeschlagen ist. Diese Zahl (-1) lässt sich beim Start des Form Editors einstellen. Wird die Funktion CloseForm(-1) dann aufgerufen, wird dieser Baustein das Client Command fehlschlagen lassen und es werden nach diesem Baustein keine weiteren Commands mehr ausgeführt.   

Zeile 161 - 169 
procedure CancelButtonClick(Sender: TObject);
begin
  LClients.Free();
  LClientCommands.Free();
     
  ResultMessages.Free();
  CloseForm(1);
end;  
  

Die Zeilen 161 – 169 werden aufgerufen, wenn der Abbrechen Button gedrückt wird. Hierbei werden wie bereits im vorherigen Abschnitt alle Listen geleert und die Closeform (Zeile 167) mit dem Parameter 1 befüllt, um eine bessere Unterscheidung zwischen dem OK und Abbrechen Button aufzuzeigen, wobei dieser Wert keinen Fehler darstellt. Dieser Parameter kann im Client Command als Rückgabewert der Form genutzt werden, um zu unterscheiden, ob der OK oder der Abbrechen Button gedrückt wurde.

Zeile 170 - 176 
procedure CBSureClick(Sender: TObject);
begin
  if ((CBSure.Checked) AND (LBClients.ItemIndex > -1 ) AND (LBClientCommands.ItemIndex > -1 ))
  then BtnSend.Enabled := True;
  Else BtnSend.Enabled := False;
end;
    

Dieser Zeilenabschnitt wird aufgerufen, wenn die Checkbox CBSure angeklickt wird („Ich bin sicher“), die der Benutzer vor dem Abschicken eines Commands aktivieren muss. Der Prozess procedure CBSureClick(Sender:TOBject) (ab Zeile 170) stellt sicher, dass die nachfolgenden Bedingungen erfüllt sind (171 – 175) und dadurch der Button Command Senden aktiviert wird. Die Bedingung lautet:

Wenn CBSure (true) (Checkbox angehakt) ist, ein Client aus der linken und ein Client Command aus der rechten Box ausgewählt wurden (ItemIndex muss größer als -1 sein; es muss also ein ausgewähltes Element selektiert sein), dann wird der Button Command Senden aktiviert (BtnSend.Enabled :=True). Andernfalls wird der Button beim Else deaktiviert.

Zeile 177 - 194 
procedure BtnSendClick(Sender: TObject);
var
  AESBMessage : String;
begin
  AESBMessage := CreateMessageBody;   AddSICSConnectionV1(Protocol,Server,Port,Username,
Passwort,ConnectionTimeout,TargetConnectionVariable,false);   
  ConnectionString := GetVarContent('CONNECTION');
  IResult := SICSPublishV1(ConnectionString, MessageID, VirtualRouter, RoutingKey, ExchangeType, Tag,
  AESBMessage, CallbackVirtualRouter, CallbackRoutingKey, ResultMessages, AAckMessages, AResult, AErrorCode);
  if (IResult = 0) then
  begin
    ShowMessage('Command has been send');
    CBSure.Checked := false;
    BtnSend.Enabled := false;
  end;
  Else Showmessage('An Error has occured: '+InttoStr(IResult));
end;
   

Die Funktion procedure BtnSendClick(Sender: TObject) wird in den nachfolgenden Zeilen definiert und danach ausgeführt, sobald der Benutzer auf den Button klickt. Dabei wird die Variable (AESBMessage) deklariert (Zeile 179), dessen Datentyp ein String ist.

Anschließend wird die Funktion CreateMessageBody aufgerufen. In dieser Funktion wird der MessageBody einmal komplett zusammengebaut und als Rückgabewert zurückgeliefert. Dieser Rückgabewert wird wiederum in die AESBMessage Variable eingefügt (Zeile 181). Danach wird die SICS Connection hergestellt, die aus den verschiedenen Parametern und der Funktion AddSICSConnectionV1 besteht. In der Zeile 183 wird die Variable ConnectionString mit der Funktion GetVarContent befüllt. Die Funktion holt sich den Wert aus der Client Command Variable mit dem Namen (Parameter der Funktion) „Connection“. In Zeile 184 geht es mit der Variable IResult weiter, wo das Ergebnis der Funktion als SICSPublishV1 gespeichert wird. Die diversen Parameter werden an das AESB gesendet. Es folgt eine if.. then-Klausel: Das Ergebnis (IResult) der Funktion wird überprüft, ob das Ergebnis gleich 0 ist und es somit keine Fehler gab. Die Funktion ShowMessage wird aufgerufen, wodurch sich ein Dialogfenster mit dem Text „Command has been send“ öffnet (Zeile 188). In den beiden darauffolgenden Zeilen werden die Eigenschaften „Checked“ für die Checkbox und „Enabled“ für den Button auf False gesetzt. Somit haben die Objekte wieder den Ausgangszustand wiederhergestellt. Sollte ein Fehler aufgetreten sein, wird der Else-Teil ausgeführt (Zeile 192) und ein Dialog „An Error has occured“ angezeigt, sowie das Ergebnis von IResult (der Fehlercode).

      7. Wenn Sie alle relevanten Angaben in dem Code eingefügt oder angepasst haben, können Sie die Form über die Schnellwahlleiste mit dem Button Start image-20240205143129-1.png (F9) durchlaufen lassen. Beachten Sie hierzu, dass es sich hier nicht nur um einen Test handelt, mit dem Sie auf mögliche Syntax-, Rechtschreib- oder Logikfehler überprüfen können, sondern auch schon Client Commands zu einem Agenten absenden können. In der nachfolgenden Abbildung sehen Sie die fertige Form, so wie Sie bei Ihnen angezeigt werden kann.

66_Client Command_Use Case Form Editor Design Ansicht_832.png

Fertiges Client Command in dem Custom Window

      8. Schließen Sie die geöffneten Fenster (Custom Window und den Form Editor). Sie kommen wieder zur Benutzeroberfläche des Form Editors und dessen Vorschau zurück.

      9. Überprüfen Sie unter Skript Rückgabewert den eingetragenen Wert. Hier sollte die Ganzzahl "-1" stehen.

66_Use Case Client Commands_AESB Form Editor fertig_510.png

Form Editor Vorschau

     10. Klicken Sie anschließend auf OK.

     11. Speichern Sie das fertige Client Command ab und schließen Sie den Editor.

66_Use Case Client Commands_AESB fertiges Script_1487.png

Client Command-Editor: Client Command per Form Editor via AESB statisch an einen Client senden

Client Command-Phasen durchlaufen lassen

Ehe das Client Command verwendet werden kann, muss es noch abschließend die Phasen Testen, Synchronisieren, Freigeben und Ausführen durchlaufen. Danach ist es möglich die Client Commands mit Hilfe des Form Editors über das AESB statisch an einen Client zu senden.

© Aagon GmbH 2024
Besuchen Sie unsere neue Aagon-Community