Die System-Skriptsprache wird u. a. im Workflow-Management verwendet, um beispielsweise eine Vorbedingung oder Übergangsbedingung zu formulieren oder um Bearbeiter zu ermitteln, die nicht in einer Workflowrolle zusammengefasst sind.

Die Workflow-Engine unterstützt sowohl die eigene System-Skriptsprache als auch JavaScript, um komplexe Zusammenhänge auszudrücken. Dieses Dokument behandelt nur die System-Skriptsprache. Es ist in folgende Kapitel aufgeteilt:

• Aufbau und Syntax
• Deklarationen
• Informationsauswertung
• Fehlerbehandlung
• Erweiterung der System-Skriptsprache

Die Einführung in die System-Skriptsprache ist auf mehrere Dokumente aufgeteilt. In diesem Dokument erhalten Sie ausführliche Informationen zum Aufbau und der Syntax der System-Skriptsprache. Für weitere Informationen zu den einzelnen Funktionen und Befehlen lesen Sie folgende Dokumentationen:

• System-Skriptsprache: Allgemeine Funktionen
• System-Skriptsprache: OLTP-Funktionen
• System-Skriptsprache: Workflow-Funktionen

Informationen zu der Workflow-Engine erhalten Sie in der gleichnamigen Dokumentation Workflow-Engine. Informationen zur Verwendung der System-Skriptsprache in Workflow-Definitionen erhalten Sie in den Dokumentationen Aktivitätsdefinitionen und Prozessdefinitionen.

Darüber hinaus kann die System-Skriptsprache u. a. in den folgenden Anwendungen verwendet werden:

• Individuelle Prüfungen
• Individuelle Hook-Implementierungen

Weitere Informationen entnehmen Sie den jeweiligen Dokumentationen.

Zielgruppe

Die Zielgruppe dieses Dokuments besteht aus Entwicklern und technischen Beratern, die Workflows bei Kunden erstellen oder anpassen, sowie Kunden, die eigene Workflows verwalten.

Für dieses Dokument wird das Verständnis des für den Benutzer sichtbaren Funktionsumfangs des Workflow-Managements vorausgesetzt. Weiterhin sollte der Leser zum Verständnis der System-Skriptsprache grundlegende Kenntnisse in SQL oder einer beliebigen Programmiersprache haben.

Begriffsbestimmung

• Aktivitätsdefinition – Aktivitätsdefinitionen legen fest, ob beim Auftreten eines bestimmten Ereignisses eine Aktivität erzeugt werden soll und welche Merkmale diese Aktivität haben soll. Eine Aktivitätsdefinition muss aktiviert sein. Wenn das der Fall ist, dann erzeugt die Workflow-Engine beim Auftreten des dort angegebenen Ereignisses eine neue Aktivität, sofern die Übergangs- und Vorbedingung erfüllt sind. Alle für die Aktivität notwendigen Daten werden aus der Aktivitätsdefinition berechnet. Die Aktivitätsdefinition stellt somit die Vorlage für die aus ihr erzeugten Aktivitäten dar. Aktivitätsdefinitionen sind unabhängig von der OLTP-Datenbank und dem System, in dem sie erfasst wurden, da sie weder System- noch OLTP-spezifische Daten enthalten. Aktivitätsdefinitionen werden in der Repository-Datenbank abgelegt.
• Deklarationen – Deklarationen sind Skripte in den Prozessdefinitionen und Aktivitätsdefinitionen, die Methoden zur Verfügung stellen, welche beim Erzeugen von Aktivitäten, bei Statuswechseln und bei der Eingabe von bestimmten Parameterwerten aufgerufen werden. Durch Anpassung der Deklarationen lassen sich die Eigenschaften von Prozessen und Aktivitäten flexibel festlegen. Deklarationen werden in einer Skriptsprache erfasst.
• GUID – GUID ist die Abkürzung für Globally Unique Identifier und entspricht einem Global eindeutigen Bezeichner. Eine GUID ist eine 128-Bit Zahl, die nach dem Schema der Open Software Foundation (OSF) für verteilte Berechnungen (Distributed Computing Environment, DCE) berechnet wurde. Sie enthält u. a. die IP-Adresse der erzeugenden Rechner, eine Zeit-Komponente und eine Zufalls-Komponente. So können zwei unabhängige Rechner ohne Synchonisation immer unterschiedliche GUIDs berechnen. In Comarch ERP Enterprise werden GUIDs als Java-Byte-Arrays der Länge 16 repräsentiert und vor allem als kompakte Primär- und Fremdschlüssel in Business Objects verwendet.
• Hook Contract – Ein Hook ist eine Schnittstelle, mit der vorhandener Programmcode unabhängig von einem Release und damit konfliktfrei erweitert werden kann. Hooks werden beispielsweise verwendet, wenn in einer Adaptierung oder einer App für eine Business-Object-Erweiterung zusätzliche Prüfungen durchgeführt werden müssen, die die vorhandenen Prüfungen ergänzen.
• Hook-Contract-Implementierung – In der Hook-Contract-Implementierung werden die zu implementierenden Hooks und die jeweilige Implementierungsklasse angegeben. Die Hook-Contract-Implementierung bezieht sich immer auf eine Hook-Contract-Definition, in der die implementierbaren Hooks enthalten sind.
• Individuelle Prüfung – Bestimmte Business Entitys bieten Hook-Contracts für die Prüfung an, die mithilfe der System-Skriptsprache und ohne Zugang zu einem Entwicklungssystem implementiert werden können. Diese erweiterten Prüfungen werden in allen Ein- und Ausgabekanälen verwendet, also sowohl in den Dialog-Anwendungen als auch beim Import oder Export.
• System-Skriptsprache – Terme, Bedingungen, Befehle und Deklarationen werden verwendet, um komplexe Zusammenhänge auszudrücken. Alle diese Ausdrücke sind Teil einer gemeinsamen Skriptsprache, die System-Skriptsprache genannt wird. Die Syntax der System-Skriptsprache lehnt sich an SQL, Pascal und Java an. Die System-Skriptsprache wird im Workflow-Management verwendet, um z. B. eine Vorbedingung oder Übergangsbedingung zu formulieren oder um Bearbeiter zu ermitteln, die nicht in einer Workflowrolle zusammengefasst sind.
• Workflow-Engine –  Zusammen mit dem Ereignisdienst koordiniert und überwacht die Workflow-Engine die Ausführung von Workflows. Die Workflow-Engine wird in jedem System auf dem Message-Server ausgeführt.

Aufbau und Syntax

Terme, Bedingungen, Befehle, Funktionen und Deklarationen werden verwendet, um komplexe Zusammenhänge auszudrücken. Alle diese Ausdrücke sind Teil einer gemeinsamen Skriptsprache, die System-Skriptsprache genannt wird. Die Syntax der System-Skriptsprache lehnt sich an SQL, Pascal und Java an.

Da im Allgemeinen keine komplexen Algo­rith­men mit dieser Sprache ausgedrückt werden müssen, sollten Vorkenntnisse in SQL zum Erlernen der Sprache ausreichend sein.

Die System-Skriptsprache umfasst folgende Elemente:

• Datentypen
• Feste Konstanten
• Kommentare
• Terme und Bedingungen
• Befehle
• Funktionen

Datentypen

Der Datentyp definiert gültige Wertebereiche und erlaubte Operationen. Die System-Skriptsprache kennt sowohl einfache als auch komplexe Datentypen. Beispiele von einfachen Datentypen sind Zeichenketten und Zahlen. Zu den komplexen Datentypen gehören z. B. Listen, Business Objects und Objektsichten.

Alle Datentypen in der System-Skriptsprache besitzen einen Standardwert (Default). Der Standardwert wird immer dann verwendet, wenn ein neuer, noch undefi­nier­ter Wert dieses Datentyps benötigt wird. Beim Parsen (Auswerten) eines Ausdrucks in der System-Skriptsprache werden die Verwendungen der Datentypen als Argumente von Funktionen, Befehlen und Operatoren über­prüft. Stimmt ein übergebener Wert nicht mit dem erwarteten Datentyp überein, wird eine Fehlermeldung ausgegeben.

Die System-Skriptsprache kennt die fol­genden Datentypen:

• Boolean – Wahrheitswerte (
  Boolean
  Boolean) können nur die Werte
  true
  truefür wahr und
  false
  falsefür falsch annehmen. Der Standardwert des Datentyps Boolean ist
  false
  false.
• Bytes – Der Datentyp
  Bytes
  Bytessind binäre Daten mit beliebigem Inhalt. Dieser Daten­typ kann insbesondere bei programmierten Ereig­nissen und Dateien als Parameter verwendet werden. Der Stan­dardwert des Datentyps Bytes ist
  null
  null.
• Class – Eine Klasse (
  Class
  Class) ist ein strukturierter Datentyp mit einer Menge von Attributen. Jedes Attribut hat einen Namen und einen Datentyp. Der Standard­wert einer Klasse ist
  null
  null.
• CisDate – Ein
  CisDate
  CisDateist die Kombination eines Zeitpunkts mit einer Zeitzone. Der Stan­dardwert des Datentyps
  CisDate
  CisDateist
  null
  null.
• CisObjectReference – Business Objects werden mit den Datentypen
  CisObject
  CisObjectoder
  CisObjectReference
  CisObjectReferenceverwaltet, Parts mit dem Datentyp
  CisObject
  CisObject. Referenzen auf Business Objects enthalten den Schlüssel des Business Objects. Der Standardwert des Datentyps
  CisObjectReference
  CisObjectReferenceist
  null
  null. Um eine typisierte
  CisObjectReference
  CisObjectReferencezu erhalten, geben Sie den Namen eines Business Objects in Klammern an. Wenn Sie keinen Namen angeben, erhalten Sie eine untypisierte
  CisObjectReference
  CisObjectReference.
  Hinweis

  Um Skripte performant auszuwerten und unnötige Datenbankzugriffe zu vermeiden, sind auch als

  CisObjectReference

  CisObjectReferencedeklarierte Variablen nur als Werte verfügbar, wie beim Datentyp

  CisObject

  CisObject. Möchten Sie den aktuellen Wert eines Business Object auswerten, dann sollten Sie es erneut öffnen, z. B. mithilfe der Funktionen

  getByPrimaryKey

  getByPrimaryKeyoder

  getByBusinessKey

  getByBusinessKey.
• CisObject – Business Objects werden mit den Datentypen
  CisObject
  CisObjectoder
  CisObjectReference
  CisObjectReferenceverwaltet, Parts mit dem Datentyp
  CisObject
  CisObject. Business Objects und ihre Parts sind auch als Werte ver­fügbar. Der Standardwert des Datentyps
  CisObject
  CisObjectist null. Um ein typisiertes
  CisObject
  CisObjectzu erhalten, geben Sie den Namen eines Business Objects in Klammern an. Wenn Sie keinen Namen angeben, erhalten Sie ein untypisiertes
  CisObject
  CisObject.
• DataView – Objektsichten (
  DataView
  DataView) sind eine Sicht auf den Zustand eines komplexen Business Entitys. Objektsichten werden insbesondere in individuellen Prüfungen verwendet. Der Standardwert des Datentyps
  DataView
  DataViewist
  null
  null. Um eine typisierte
  DataView
  DataViewzu erhalten, geben Sie den Namen einer Objektsicht in Klammern an. Wenn Sie keinen Namen angeben, erhalten Sie eine untypisierte
  DataView
  DataView.
• Guid – GUIDs werden häufig benötigt, um Business Objects über dessen Primärschlüssel zu identifizieren. Der Standardwert des Datentyps
  Guid
  Guidist
  null
  null.
• HashMap – Eine Hash-Tabelle (
  HashMap
  HashMap) speichert Schlüssel-Wert-Paare. Jedem Schlüssel kann genau ein Wert zugeordnet werden. Mithilfe des Schlüssels kann der Wert immer wieder gefunden werden. Als Schlüs­sel sind nur Zeichenketten erlaubt. Der Stan­dardwert des Datentyps
  HashMap
  HashMapist eine leere Hash-Tabelle.
• Number – Zahlen (
  Number
  Number) enthalten immer ein Vorzeichen. Sie können Nachkommastellen haben, die mit ei­nem Punkt zu trennen sind. Der Standardwert des Datentyps
  Number
  Numberist
  0
  0.
• String – Zeichenketten (
  String
  String) können eine beliebige Län­ge haben. Der Standardwert des Datentyps
  String
  Stringist eine leere Zeichenkette.
• Timestamp – Ein Zeitpunkt (
  Timestamp
  Timestamp) ist ein auf Millisekun­den genauer Punkt in der Zeit. Alle Zeitangaben werden in Zeitpunkten abgebildet. Der Standardwert des Datentyps
  Timestamp
  Timestampist die Konstante
  UNDEFINED_DATE
  UNDEFINED_DATE.
• Unknown – Dem Datentyp
  Unknown
  Unknownkann jeder beliebige andere Datentyp zugeordnet werden. Der Standardwert des Daten­typs
  Unknown
  Unknownist
  null
  null.

Automatische Umwandlung von einfachen Datentypen

Einige einfache Datentypen wie

Beachten Sie bitte, dass der Datentyp vom ersten Term eines Ausdrucks bestimmt wird.

Weitere Datentypen können mithilfe der Funktion

Prüfungen bei typisierten CisObject und CisObjectReference

Wenn Ihnen der Typ des Business Objects oder Parts bekannt ist, sollten Sie immer ein typisiertes

Bei einem untypisierten

Listen

Eine Liste ist eine geordnete Folge von Werten. Eine Liste besitzt einen Ele­ment­datentyp und optional eine Länge. Alle Listenelemente müssen in diesen Elementdatentyp umwandelbar sein. Wenn der Datentyp einer Liste eine Länge besitzt, so ist diese Länge festgelegt und kann nicht nachträglich verändert werden.

Der Datentyp Liste wird durch die Angabe eines Elementdatentyps, gefolgt von eckigen Klammern, ausgedrückt. In den eckigen Klammern steht optional die feste Länge der Liste.

Der Standardwert einer Liste mit vorgegebener Länge ist eine Liste dieser Länge. Wenn die Liste keine Länge hat, so ist der Standardwert eine leere Liste. Eine leere Liste kann mithilfe der Skript-Funktion

Die Skript-Funktion

Ein Element kann nur dann einer vorhandenen Liste hinzugefügt werden, wenn der Datentyp des Elements mit dem Datentyp der Liste übereinstimmt oder in diesen umgewandelt werden kann.

var list1 := Number[];
add(list1, "500");

Wenn Sie einer Liste Elemente unterschiedlicher Datentypen zuweisen (z. B. als Parameterliste für den Aufruf einer Hintergrundanwendung), dann sollten Sie das erste Element so wählen, dass die weiteren Elemente in den Datentyp des ersten Elements umgewandelt werden können. Beispielweise können Zahlen in Zeichenketten umgewandelt werden, aber nicht umgekehrt. Ist das nicht möglich, dann können Sie eine Liste vom Datentyp

Somit lässt sich z. B. eine Parameterliste auch dann für die Funktionen

const PartnerType as valueSet(com.cisag.app.general.PartnerType);
function create()
{
var params as Unknown[];
var OQL :=
"SELECT FROM com.cisag.app.general.obj.Partner p" +
" WHERE p:type = ? AND p:human = ?" +
" ORDER BY p:number";

add(params, PartnerType.INTERNAL);
add(params, true);

var pList := getCisObjectList(OQL, params, BlockSize);

for (p as CisObject(com.cisag.app.general.obj.Partner) : pList)
echo(p:number);
}

Besitzt eine Liste Elemente unterschiedlicher Datentypen, dann müssen die Elemente mithilfe der Funktion

var myList as Unknown[];
add(myList, 800);
add(myList, "°");
var song := cast(String, myList[0]) + cast(String, myList[1]);

Die System-Skriptsprache umfasst viele Funktionen, um Listen zu erzeugen und zu bearbeiten. Weitere Informationen und Beispiele finden Sie im Kapitel Listenfunktionen der Dokumentation System-Skriptsprache: Allgemeine Funktionen.

Der Wert null

Zusätzlich zu den Werten der Datentypen existiert der Wert

Eine Übergangsbedingung in einer Aktivitätsdefinition gilt beim Wert

Auch ein Ausdruck, der eine Beziehung über ein Attribut mit dem Wert

Die System-Skriptsprache umfasst zwei Funktionen

Feste Konstanten

Eine Konstante kann nur einen einzigen vorbestimmten Wert annehmen. Konstanten werden u. a. dazu verwendet, um die Verwendung der System-Skriptsprache verständlicher und kompakter zu machen. Folgende Konstanten sind fest definiert und immer verfügbar:

• INVALID_GUID – Die
  INVALID_GUID
  INVALID_GUIDstellt einen ungültigen Wert für den Datentyp
  Guid
  Guiddar.
• MAX_DATE – Der größte darstellbare Zeitpunkt (
  Timestamp
  Timestamp). Das
  MAX_DATE
  MAX_DATEkann z. B. für Gültigkeitsbereiche verwendet werden, die nach oben offen sind.
  MAX_DATE
  MAX_DATE entspricht dem konstanten
  MAX_TIME_STAMP
  MAX_TIME_STAMPeiner OQL-Abfrage.
• MIN_DATE – Der kleinste darstellbare Zeitpunkt (
  Timestamp
  Timestamp). Das
  MIN_DATE
  MIN_DATEkann z. B. für Gültigkeitsbereiche verwendet werden, die nach unten offen sind.
  MIN_DATE
  MIN_DATEentspricht dem konstanten
  MIN_TIME_STAMP
  MIN_TIME_STAMPeiner OQL-Abfrage.
• UNDEFINED_DATE – Ein undefinierter Zeitpunkt (
  Timestamp
  Timestamp). Das
  UNDEFINED_DATE
  UNDEFINED_DATEwird z. B. für Zeitpunkte verwendet, bevor ein konkreter Wert zugewiesen wurde. Zum Beispiel der Zeitpunkt der letzten Änderung eines Business Objects (im Attribut
  updateInfo.updateTime
  updateInfo.updateTime), welches seit dem Erfassen nicht mehr geändert wurde.
  UNDEFINED_DATE
  UNDEFINED_DATEentspricht dem konstanten
  UNDEFINED_TIME_STAMP
  UNDEFINED_TIME_STAMPeiner OQL-Abfrage.
• ZERO_GUID – Die
  ZERO-GUID
  ZERO-GUIDwird immer dann verwendet, wenn eine GUID nicht null sein darf, aber dennoch undefiniert ist. Dies ist in z. B. dann der Fall, wenn die GUID Bestandteil eines Primärschlüssels ist.
  ZERO_GUID
  ZERO_GUIDentspricht dem Konstanten
  ZEROGUID
  ZEROGUIDeiner OQL-Abfrage.

Kommentare

Kommentare werden mit

Bei komplexeren Workflow-Prozessen ist es ratsam, ausreichend Kommentare in den Aktivitätsdefinitionen zu erfassen, um die Anpassung und Pflege zu erleichtern. Folgender beispielhafter Kommentar aus einer Prozessdefinition beschreibt den Prozess.

/**
* This process exports changes to the Partner object every 15
* minutes. The process ends automaticallly when the processing
* duration has been exceeded.
*
* Start: Manual process without event definition
*
* Owner: If the process owner is not defined in the process
* definition then the start node automatically sets the owner to
* the initiator (user who triggered the event) so that he or she
* can display the process and be notified in case of errors.
* Number1: Total number of export runs
* Number2: Total number of Partners exported
* Timestamp1: Begin time of Partner query of the last export run
* Timestamp2: End time of Partner query of the last export run
*/

Es ist auch ratsam, globale Konstanten in Prozessdefinitionen zu deklarieren und zu kommentieren, um die Konfiguration von Workflow-Prozessen zu vereinfachen.

/**
* JOB_QUEUE is the name of the job queue for the batch job.
* If no job queue is specified in this constant then the default
* job queue from the Customizing function 'Workflow Management'
* is used.
*/
const JOB_QUEUE := "";

Ein leerer Ausdruck in einem Bedingungsfeld gilt als erfüllt (

Wenn Sie z. B. im Ramen einer Fehlersuche erreichen möchten, dass eine Aktivität unabhängig von der Übergangsbedingung immer erzeugt wird, aber die Übergangsbedingung nicht löschen möchten, dann können Sie stattdessen die Übergangsbedingung auskommentieren und durch den Wert

Terme und Bedingungen

Ein Term ist ein Ausdruck oder eine Formel, die einen Wert berechnet.

Beispiele von Termen:

a * a + b * b
max(a, b) * min(c, d)

Eine Bedingung ist ein Ausdruck, der einen Wahrheitswert zurückgibt und somit eine Ja/Nein-Entscheidung ermöglicht.

Beispiele von Bedingungen:

a * a + b * b = c * c
max(a, b) > 0
parameters.object:updateInfo.createUser <> parameters.userGuid

Die Syntax der Terme und Bedingungen ist ähnlich der in SQL. Wenn einer der Operanden nicht dem erwarteten Datentyp entspricht, so ist das Ergebnis der Operation

Arithmetische Operatoren

Für Zahlen sind die folgenden Operatoren definiert:

Arithmetische Operatoren, auch unterschiedlicher Art, können beliebig kombi­niert werden. Wie üblich haben dabei die Operatoren

Die System-Skriptsprache umfasst auch viele arithmetische Funktionen. Weitere Informationen und Beispiele finden Sie im Kapitel Arithmetische Funktionen der Dokumentation System-Skriptsprache: Allgemeine Funktionen.

Operatoren auf Zeichenketten

Für Zeichenketten sind die folgenden Operatoren definiert:

Beliebig viele Strings können zu einem Term verknüpft werden.

Die System-Skriptsprache umfasst auch viele Funktionen für Zeichenketten. Weitere Informationen und Beispiele finden Sie im Kapitel Funktionen für Zeichenketten der Dokumentation System-Skriptsprache: Allgemeine Funktionen.

Vergleichsoperatoren

Vergleichsoperatoren (Komparatoren) sind:

Alle Datentypen können mit den Operatoren

Die linke Seite einer Vergleichsoperation bestimmt den verglichenen Datentyp.

Werden zwei CisDates mit einander verglichen, dann wird die Zeitzone mit berücksichtigt.

Um ein CisDate mit einem Zeitpunkt zu vergleichen, können Sie mithilfe der Skript-Funktion

Bedingungen

Bedingungen können beliebig mit den logischen Operatoren

Die Operatoren

Klammerung

Terme und Bedingung können beliebig geklammert werden:

Ein geklammerter Term wird immer als Einheit ausgeführt, unabhängig von den Unterschieden der Bindungen der Operatoren.

Zugriff auf Listen und Hash-Tabellen

Für den Zugriff auf Listen und Hash-Tabellen existieren die folgenden Operato­ren:

Beide Arten des Zugriffs auf Hash-Tabellen sind äquivalent. Der Zugriff mit Punkt (

Zugriff auf Business Objects, Parts und Objektsichten

Für Business Objects und Parts sind die folgenden Operatoren verfügbar:

Der Zugriff auf Business Objects, Parts und Objektsichten wird häufig benötigt, da diese Objekte die wichtigsten Datencontainer im System sind.

Um Attribute, deren Namen mit einem Unterstrich beginnen, auszuwerten, können Sie die Funktion

Aktivitätsdefinitionen aufrufen

Sie können Aktivitätsdefinitionen mit der Kategorie Funktionsaufruf wie Funktionen aufrufen. Der Name der Aktivitätsdefinition darf für den Aufruf nur Buchstaben, Zahlen und die Sonderzeichen Punkt (

Um den Aufruf einer Aktivitätsdefinition von einem Funktionsaufruf zu unterscheiden, wird dem Namen der Aktivitätsdefinition das At-Zeichen (

Die maximale Rekursionstiefe ist beschränkt. Weitere Informationen finden Sie in dem Kapitel Komplexität von Ausdrücken beschränken.

Befehle

Ein Befehl ist ein Ausdruck, der eine Operation ausführt, die kein Ergebnis lie­fert. In der System-Skriptsprache werden Befehle durch ein Strichkomma (

echo(definition:code);
setMailRecipientsTo("somebody@localhost.local");

Abhängig vom Verwendungskontext können unterschiedliche Befehle definiert sein. In den folgenden Abschnitten werden die Befehle gruppiert nach den Verwendungskontexten beschrieben.

Kontrollfluss und Variablenzuweisung

Die Befehle zum Steuern des Kontrollflusses und die Variablenzuweisung sind in die System-Skriptsprache fest eingebaut.

type <TypeName> as class {
<AttributeName> as <Type>;
...
<AttributeName> as <Type>;
}

for (<VariableName> as <Type> : <List>)
<Command>

{
<Command>
...
<Command>
}

Die System-Skriptsprache umfasst auch die Funktion

Konstanten

Eine Konstante kann nur einen einzigen vorbestimmten Wert annehmen. Konstanten werden u. a. dazu verwendet, um die Verwendung der System-Skriptsprache verständlicher und kompakter zu machen.

Konstanten werden wie Variablen mit einem Term deklariert. Im Unterschied zu Variablen kann der Wert einer Konstante nach deren Deklaration nicht mehr verändert werden.

Bei komplexeren Workflow-Prozessen ist es ratsam, globale Konstanten in der Prozessdefinition zu deklarieren, mit denen der Workflow-Prozess zentral konfigurieren lässt, damit die Aktivitätsdefinitionen der einzelnen Prozessschritte möglichst nicht angepasst werden müssen.

/**
* JOB_QUEUE is the name of the job queue for the batch job.
* If no job queue is specified in this constant then the
* default job queue from the Customizing function 'Workflow
* Management' is used.
*/
const JOB_QUEUE := "";

Variablen

Alle verwendeten Variablen und Konstanten müssen deklariert werden. Varia­blen können mit einem Typ oder einem Initialwert deklariert werden. Wenn ein Typ angegeben wird, so besitzt die Variable den Standardwert des Typs als Ini­tialwert. Wenn eine Variable über einen Term deklariert wird, so hat diese den Ergebniswert des Terms als Wert und dessen Datentypen als Datentyp.

Um Konstanten von Variablen besser unterscheiden zu können, wird empfohlen, Konstanten, die in Prozessdefinitionen definiert sind, durchgehend mit Großbuchstaben zu deklarieren, Konstanten, die in Aktivitätsdefinitionen definiert sind, mit einem Großbuchstaben und Variablen mit einem Kleinbuchstaben anfangen zu lassen.

ValueSets

Um ein Valueset zu verwenden, müssen Sie dieses mit der Anweisung

const OrderStatus as valueSet(com.cisag.app.general.OrderStatus);
function create()
{
if (parameters.object:status = OrderStatus.RELEASED)
echo(valueSetName(OrderStatus, parameters.object:status);
}

Typdefinitionen

Zur Vereinfachung können Sie in der System-Skriptsprache eigene Datentypen deklarieren und verwenden. Die Ver­wendung von Typen erleichtert durch die besseren Abstraktionsmöglichkei­ten das Verständnis des Programms. Für jede Verwendung von Klassen muss ein Typ definiert werden. Das Schlüsselwort

type PartnerCode as String;
type PartnerCodeList as PartnerCode[];
type WeekdaySum as Number[7];

var code as PartnerCode;
code := "4711";

type Bike as class {
name   as String;
weight as Number;
chainset as String;
}

var myBike := new(Bike);
myBike.name := "Niner RLT";
myBike.weight := 9250;
myBike.chainset := "Shimano 105";

Zuweisungen

Bei der Zuweisung kann einer Variablen, einem Attribut einer Klasse, einem Eintrag in einer Liste oder einer Hash-Tabelle ein Wert zugewiesen werden. Das Element, wlechem etwas zugewiesen wird, steht auf der linken Seite der Zuwei­sung. Der zugewiesene Wert wird aus dem Term auf der rechten Seite der Zuweisung berechnet.

Jede verwendete Variable muss deklariert sein und besitzt somit einen festen Typ. Einer Variablen können nur Werte dieses Typs zugewiesen werden.

Nachfolgend einige Beispiele für die Zuweisung eines Wertes zu einer Variab­len.

var l as String[2];
l[0] := "Hallo";
l[1] := "Welt";

var c as HashMap;
c.a := "X";
c["a"] := "X";

Anweisungsblöcke

Mit geschweiften Klammern kann eine Folge von Befehlen zu einem Befehl in einem Anweisungsblock zusammengefasst werden. Alle Befehle in einem Anwei­sungsblock werden in der Reihenfolge ausgeführt, die in dem Block vorgegeben ist. Wenn ein Befehl bei der Ausführung einen Fehler meldet, so bricht der gesamte Anweisungsblock mit einem Fehler ab. Viele Befehle und Funktionen melden einen Fehler, wenn sie den Wert

{
x := 2;
x := x * x + 3;
}

Bedingter Befehl (if)

Der bedingte Befehl

x := -13;
if (x < 0)
x := 0;

Bedingter Befehl mit Alternative (if … else)

Der bedingte Befehl mit Alternative

x := 13;
if (x < 0) {
x := -1;
} else if (x > 0) {
x := 1;
}

Schleife mit Bedingung (while)

Die Schleife mit Bedingung

var i := 10;
var r := 0;
while (i > 0) {
r := r + i:
i := i - 1;
}

Die Anzahl der Durchläufe in einer while-Schleife ist beschränkt. Weitere Informationen finden Sie im Kapitel Komplexität von Ausdrücken beschränken.

Schleife über alle Elemente (for)

Die

var l := list(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
var r := 0;
for (e : l) {
r := r + e:
}

Schleife über alle Elemente (for … as)

Die

var objects := getCisObjectList(
"SELECT FROM com.cisag.app.general.obj.Item o", list(), 10);
for (item as CisObject(com.cisag.app.general.obj.Item) : objects)
{
echo(item:number);
}

Befehl beenden (return)

Der Befehl

function validate(state as Number)
{
if (state = State.CANCELED)
return;

if (results.COMMENT = "") {
sendMessage(results.COMMENT_id, "ERROR", "Comment is missing.");
return;
}

if (length(results.COMMENT) < 20) {
sendMessage(results.COMMENT_id, "WARNING", "Comment should be at least 20 characters.");
return;
}
}

Funktion beenden (return mit Rückgabewert)

Der Befehl

function join(p_textList as String[], p_separator as String) as String
{
var r_text as String;

for (word as String : p_textList)
r_text := r_text + p_separator + word;
if (r_text <> "")
r_text := substring(r_text, length(p_separator));

return r_text;
}

Funktionen

Funktionen der System-Skriptsprache

Die System-Skriptsprache stellt viele Funktionen zur Verfügung. Um korrekt zu funktionieren, benötigen Funktionen die geeignete Umgebung, d. h. bestimmte Rahmenbedingungen müssen erfüllt sein. Unterschieden wird zum einen die Datenbank und zum anderen, ob eine Aktivität benötigt wird oder nicht. Soll die Funktion z. B. in der Übergangsbedingung (Transition) der Aktivitätsdefinition genutzt werden, so kann die Funktion nicht auf die Aktivität zugreifen, da diese erst zu einem späteren Zeitpunkt erzeugt wird.

Die Festlegung des Gültigkeitsbereichs einer Funktion erfolgt im Konstruktor der Funktion. In der Klasse

Weitere Informationen und Beispiele zu den Funktionen und Befehlen finden Sie in folgenden Dokumentationen:

• System-Skriptsprache: Allgemeine Funktionen
  Funktionen des Verwendungskontexts
  ALL
  ALL.

• System-Skriptsprache: OLTP-Funktionen
  Funktionen des Verwendungskontexts
  OLTP
  OLTPoder
  SYS_SCRIPT_OLTP
  SYS_SCRIPT_OLTP.

• System-Skriptsprache: Workflow-Funktionen
  Funktionen des Verwendungskontexts
  WF_REPOSITORY
  WF_REPOSITORY,
  WF_OLTP
  WF_OLTP,
  WF_ACTIVITY_REPOSITORY
  WF_ACTIVITY_REPOSITORY,
  WF_ACTIVITY_OLTP
  WF_ACTIVITY_OLTP,
  WF_TRANSITION_REPOSITORY
  WF_TRANSITION_REPOSITORYoder
  WF_TRANSITION_OLTP
  WF_TRANSITION_OLTP.

Eigene Funktionsdeklarationen

Funktionen fassen unterschiedliche Elemente der System-Skriptsprache zusammen, um komplexe Zusammenhänge auszudrücken. Liefert eine Funktion keinen Wert zurück, dann ist der Wert der Funktion

function isPythagoreanTheorem(a as Number, b as Number, c as Number) as Boolean
{
return a * a + b * b = c * c;
}

function create()
{
var tryPythagoreanTheorem := isPythagoreanTheorem(3, 4, 5)
}

In den Termen können Funktionen aufgerufen werden. Funktionen berechnen aufgrund ihrer Eingangsparameter ein Ergebnis. Abhängig von der jeweiligen Funktion existieren Voraussetzungen an die Anzahl und den Typ der Eingangs­parameter. Diese Voraussetzungen werden wie folgt ausgedrückt:

Deklarationen

In diesem Kapitel wird beschrieben, wo Deklarationen erfasst und verwendet werden können, welche vorbelegten Funktionen dabei jeweils zur Verfügung stehen, sowie die Reihenfolge der Auswertung.

Deklarationen in Aktivitätsdefinitionen

Die Deklarationen einer Aktivitätsdefinition besitzen folgende vorbelegte Funktionen:

Deklarationen in Prozessdefinitionen

Die Deklarationen einer Prozessdefinition werden den globalen Deklarationen der Aktivitätsdefinitionen hinzugefügt, bevor sie ausgewertet werden. Aus diesem Grund dürfen die Deklarationen einer Prozessdefinition nur Deklarationen enthalten, die auch außerhalb der Deklarationen der Aktivitätsdefinition deklariert werden können.

const MaxAmount := "123";
function helloWorld () as String
{
return "Hello World!";
}

Beachten Sie bitte, dass je nach verwendeter Skript-Engine weitere Einschränkungen vorliegen können. Beispielsweise erlaubt die JavaScript-Engine Nashorn keine Deklaration von Konstanten.

Beachten Sie bitte auch, dass eine eigene Typdefinition (

Reihenfolge der Auswertung in Aktivitätsdefinitionen

Wenn eine neue Aktivität aufgrund eines Ereignisses erzeugt wird, dann wird die Umgebung, in der die Bedingungen, Befehle und Terme ausgeführt werden, mit den durch das Ereignis vorgegebenen Variablenwerten initialisiert. Wenn eine aktivierte Aktivitätsdefinition ein Ereignis empfängt, dann werden die Ausdrücke dieser Aktivitätsdefinition in der unten beschriebenen Reihenfolge ausgewertet.

In einem Startknoten

Beim Erzeugen einer Aktivität für einen Startknoten werden die Funktionen in der folgenden Reihenfolge aufgerufen:

1. Globale Deklarationen der Prozessdefinition
2. Globale Deklarationen der Aktivitätsdefinition (außerhalb der Funktionen)
3. applyDefaults
4. validate
5. create
6. validatePrecondition
7. close

Die Funktionen

Allgemein

Handelt es sich nicht um einen Startknoten, werden die Funktionen in der folgenden Reihenfolge aufgerufen:

1. Globale Deklarationen der Prozessdefinition
2. Globale Deklarationen der Aktivitätsdefinition (außerhalb der Funktionen)
3. Übergangsbedingung
4. create
5. Anwendungsparameter
6. Ausdruck für Bearbeiter
7. validatePrecondition
8. applyDefaults
9. validate
10. validatePostcondition
11. close

Die Funktion

Die Funktionen

Ist der Bearbeiter der Aktivität kein Benutzer, sondern das System oder ein Verarbeitungsauftrag, wird die Funktion

Befehle

Aktivitätsdefinitionen, die im Release 5.1 oder früher erfasst sind, können Befehle statt Deklarationen besitzen. Die Befehle werden beim Erzeugen der Aktivität ausgeführt und entsprechen in etwa der Funktion

Dazu kopieren Sie das Skript von dem Karteireiter Befehle in die Funktion

Da Konstanten und Variablen, die auf dem Karteireiter Befehle deklariert sind, in allen Feldern der Aktivitätsdefinition zur Verfügung stehen, müssen Sie zusätzlich alle Konstanten, Variablen und Typdefinitionen, die in anderen Feldern der Aktivitätsdefinition verwendet werden, z. B. in der Vorbedingung oder in einem Feld für die Anwendungsparameter, außerhalb der Funktion

var editors as Guid[];
var customer := parameters.object->CustomerData->CustomerPartner;
var responsible := loadTargetsOfPartnerRelations(customer:guid, parameters.object->DeliveryPartnerData->Organization:guid, "Responsible");
for (r : responsible) {
editors := union(editors, resolvePartner(r:guid));
}

const State as valueSet(com.cisag.sys.workflow.ActivityState);

var editors as Guid[];
var customer := parameters.object->CustomerData->CustomerPartner;

function create()
{
var responsible := loadTargetsOfPartnerRelations(customer:guid, parameters.object->DeliveryPartnerData->Organization:guid, "Responsible");
for (r : responsible) {
editors := union(editors, resolvePartner(r:guid));
}
}

Skript-Objekte und Bibliotheken

Eigene Deklarationen von Funktionen, Variablen und Konstanten können in Kundensystemen als Skript-Objekte erfasst werden. Verwenden Sie dazu die Anwendung Entwicklungsobjekte. Das Einbinden von Skript-Objekten hat den Vorteil, dass eigene Deklarationen zentral verwaltet werden können; Änderungen zu den Skript-Objekten wirken sich unmittelbar auf die Skripte aus, in denen sie eingebunden sind.

Als Entwicklungsobjekt unterliegen Skript-Objekte der Versionierung. Mithilfe der Anwendung Cockpit: Produktivsystem-Entwicklungsobjekte lassen sich die auf einem Testsystem erfassten Skript-Objekte (ähnlich wie die Workflow-Vorlagen) auf ein Produktivsystem übertragen.

Eigene Deklarationen können Sie auch in der Anwendung Bibliotheken erfassen und zu einer Bibliothek zusammenfassen. Wie die Workflow-Vorlagen werden auch Bibliotheken in der Repository-Datenbank gespeichert und stehen somit in allen OLTP-Datenbanken eines Systems zur Verfügung.

Um eingebunden werden zu können, muss das Skript-Objekt bzw. die Bibliothek die gleiche Skriptsprache wie das Skript verwenden. Ist das Skript in der System-Skriptsprache erfasst, dann verwenden Sie den Befehl

Individuelle Prüfungen

Eine individuelle Prüfung erweitert die Prüfung eines bestimmten Business Entitys. Diese erweiterte Prüfung wird in allen Ein- und Ausgabekanälen verwendet, also sowohl in den Dialog-Anwendungen als auch beim Import oder Export. Sie können das Ergebnis dieser individuellen Prüfungen als individuelle Meldung ausgeben. Diese individuelle Meldung wird gemeinsam mit den Meldungen, die in der Repository-Datenbank erfasst sind, im jeweiligen Kontext angezeigt.

Die Anwendung Individuelle Prüfungen zeigt die Funktionen des ausgewählten Hook-Contracts an. So besitzt z. B. das Hook-Contract für Vertriebsaufträge folgende Funktionen.

function validateHeader(
persistent as DataView(com.cisag.app.sales.order.model.SalesOrder),
current as DataView(com.cisag.app.sales.order.model.SalesOrder))
{ }

function validateDetail(
persistent as DataView(com.cisag.app.sales.order.model.SalesOrderDetail),
current as DataView(com.cisag.app.sales.order.model.SalesOrderDetail))
{ }

function validateDeleteHeader(
persistent as DataView(com.cisag.app.sales.order.model.SalesOrder))
{ }

function validateDeleteDetail(
persistent as DataView(com.cisag.app.sales.order.model.SalesOrderDetail))
{ }

Mithilfe der übergebenen Objektsichten

Besitzt ein Business Entity ein weiteres Feld, dann können Sie dessen Wert mithilfe einer weiteren Funktion mit dem gleichen Namen aber mit dem Suffix Extension_ gefolgt vom Schemanamen prüfen. Die Funktion umfasst einen zusätzlichen Parameter

Folgende Individuelle Prüfung gibt eine Fehlermeldung aus, wenn das weitere Feld EXTNUM leer ist:

function validate(
view as DataView(com.cisag.app.general.item.model.Item))
{ }

function validateExtension_EXTItem(
view as DataView(com.cisag.app.general.item.model.Item),
extension as Extension_EXTItem)
{
if (extension.EXTNUM_val = "")
sendMessage(extension.EXTNUM_id, "ERROR", list("No value."));
}

Wenn Sie das erste weitere Feld eines Business Entitys anlegen, nachdem Sie die individuelle Prüfung bereits erfasst haben, dann können Sie die individuelle Prüfung erneut erfassen, damit ein Muster für die zusätzliche Funktion mit dem Parameter

Informationsauswertung

Abhängig vom Initialisierungsstatus der neuen Aktivität werden die unterschiedlichen Variablen gefüllt. Beispielsweise ist zum Zeitpunkt der Auswertung der Übergangsbedingung und der Funktion

In den folgenden Kapiteln wird die Verwendung der zur Verfügung stehenden Variablen näher erläutert:

• Ereignis (event)
• Parameter (parameters)
• Prozess (process)
• Aktivität (activity)
• Aktivitätsdefinition (definition)
• Aktionsparameter (actionParameters)
• Aktivitätsergebnisse (results)
• Dialogsteuerung (dialog)
• Funktionsaufrufe (parameters und result)
• Hintergrundanwendungen (getJobResult)
• Webservices (getServiceResponse)
• Individuelle Prüfungen (environment)

Ereignis (event)

Besitzt die Aktivitätsdefinition einer Ereignisdefinition, dann enthält die Variable

var itemNumber := String;
if (event.subtype = 3)
itemNumber := parameters.oldObject:number;
else
itemNumber := parameters.newObject:number;
format("itemNumber", itemNumber);

Parameter (parameters)

In Abhängigkeit des Typs und Subtyps des Ereignisses enthält die Variable

Ereignistyp Programmiertes Ereignis

Programmierte Ereignisse besitzen genau diejenigen Parameter, die in der Anwendung Entwicklungsobjekte für das Ereignis eingetragen sind.

Ereignistyp Business Entity

Ein Ereignis des Typs Business Entity ist für Business Objects in der Repository-Datenbank oder der OLTP-Datenbank möglich. Welche Parameter das Ereignis besitzt, hängt vom Subtyp Einfü­gen, Ändern oder Löschen und vom Typ des überwachten Busi­ness Objects ab.

Ereignistyp Benutzeraktion

Ein Ereignis des Typs Benutzeraktion ist für Business Entitys in der Repository-Datenbank oder der OLTP-Datenbank möglich. Ereignisse für Dependents werden nicht unterstützt. Das Ereignis besitzt folgende Parameter.

Ohne Ereignisdefinition

Ein Prozess ohne Ereignisdefinition im Startknoten kann nur manuell gestartet werden. Um im Startknoten entscheiden zu können, ob der Benutzer berechtigt ist, den Prozess zu starten, stellt die Variable

Prozess (process)

Ist die Aktivitätsdefinition mit einer Prozessdefinition verknüpft dann enthält die Variable

process.ErrorCode := "USER_ERROR";
process.ErrorDescription := "Error raised by user in create() of activity " + activity:code + ".";
abortProcess();

var users as Guid[];
for (a : process.previousSteps)
users := union(users, list(a:completeUser));

Je nach Ausführungskontext und Aktivitätsstatus stehen unterschiedliche Attribute zur Verfügung. In den Funktionen

In der Funktion

In der Funktion

Aktivität (activity)

Wenn die Übergangsbedingung erfüllt ist und die Funktion

Um die Auswertung zu vereinfachen, stehen einige Attribute bereits in der Funktion

Aus dem gleichen Grund stehen einige Attribute in der Funktion

Nach der Ausführung der Funktion

Aktivitätsdefinition (definition)

Die Variable

Mithilfe der Übergangsbedingung

Über die Variable

Aktionsparameter (actionParameters)

Wenn die Funktion

Aktivitätsergebnisse (results)

Wenn die Funktion

function applyDefaults()
{
results.approvalStatus := "REJECTED";
}

function validate(state as Number)
{
if (results.approvalStatus <> "APPROVED" and results.comment = "")
sendMessage(results.comment_id, "COMMENT", list());
}

function close(state as Number)
{
if(results.approvalStatus = "APPROVED")
process.approvalStatus := "APPROVED";
else
process.approvalStatus := "REJECTED";
process.comment := results.comment;
}

In dem obigen Beispiel wäre auch die einfachere Zuweisung

Eine weitere Variante wäre, das Aktivitätseregbnis abhängig vom Status der Aktivität zuzuweisen: erledigt der Benutzer die Aktivität durch eine Cockpit-Anwendung, gilt dies als eine implizite Genehmigung. Wird die Aktivität unbearbeitet erledigt, dann gilt dies als eine implizite Ablehnung:

function close(state as Number)
{
if(results.approvalStatus = "APPROVED")
process.approvalStatus := "APPROVED";
else if(results.approvalStatus <> "")
process.approvalStatus := "REJECTED";
else if (state = State:DONE)
process.approvalStatus := "APPROVED";
else
process.approvalStatus := "REJECTED";
}

Es ist auch möglich, im Feld Erledigungsbestätigung auf dem Karteireiter Bearbeitung der Aktivitätsdefinition den Wert Erledigen durch Workflow-Symbolleiste auszuwählen, um das Erledigen durch eine Cockpit-Anwendung zu unterbinden.

Dialogsteuerung (dialog)

Besitzt die Aktivitätsdefinition ein Aktivitätsergebnis des Feldtyps Seite, dann besteht der Dialog Aktivitätsergebnisse eingeben aus mehreren Seiten. Um per Scripting zwischen den Seiten wechseln zu können, stellt die Variable

Im folgenden Beispiel besitzt eine Aktivitätsdefinition vier Dialogseiten mit den Namen page1, page2, page3 und page4. Jede Seite besitzt ein Textfeld mit den Namen text1, text2, text3 und text4. Ist das Textfeld auf einer Seite leer, dann soll nicht zur darauf folgenden Seite sondern direkt zur letzten Seite page4 gewechselt werden.

function validate(state as Number)
{
if (dialog.page = "page1" or dialog.page = "") {
if (results.text1 = "")
dialog.nextPage := "page4";
}
if (dialog.page = "page2") {
if (results.text2 = "")
dialog.nextPage := "page4";
}
}

Eine Prüfung auf der Seite page3 ist nicht erforderlich, da die Seite page4 ohnehin die nächste Seite ist.

Funktionsaufrufe (parameters und result)

Ein Funktionsaufruf ist eine Aktivitätsdefinition, die statt Aktivitäten zu erzeugen ein Ergebnis berechnet und zurückgibt. Funktionsaufrufe werden z. B. eingesetzt, um komplexe Berechnungen einmalig zu erfassen oder Ausdrücke in JavaScript auch in Aktivitätsdefinitionen verwenden zu können, die in der System-Skriptsprache erfasst sind.

Die Parameter und Rückgabewerte von Aktivitätsdefinitionen des Typs Funktionsaufruf werden mit der Aktivitätsdefinition erfasst. Jeder Parameter und jeder Rückgabewert hat in der Aktivitätsdefinition die folgenden Eigenschaften:

• Einen innerhalb der Aktivitätsdefinition eindeutigen technischen Namen
• Eine übersetzbare Bezeichnung
• Einen Datentyp

Für jeden Parameter P1,…,Pn und Rückgabewert R1,…,Rm gibt es eine Variable mit dem technischen Namen in den Variablen

parameters.P1,…,parameters.Pn
result.R1,…,result.Rm

Die Werte der Parameter werden beim Aufruf der Aktivitätsdefinition übergeben und gesetzt. Die Werte der Rückgabewerte sind beim Aufruf

parameters.ITEMNUMBER
result.PRICE

Beachten Sie bitte, dass in einer Aktivitätsdefinitionen des Typs Funktionsaufruf die üblichen Umgebungsvariablen für die Datenbank und den Benutzer nicht zur Verfügung stehen, da solche Aktivitätsdefinitionen in der Regel nicht interaktiv durch einen Benutzer beendet werden.

Hintergrundanwendungen (getJobResult)

Der Knotentyp Serviceknoten wird in Prozessdefinitionen verwendet, um eine Aktivität zu erzeugen, die eine Hintergrund-Anwendung aufruft. Ein Serviceknoten wird von einem Verarbeitungsauftrag bearbeitet. Auch in einer Aktivitätsdefinition des Typs Einzelaktivität kann Verarbeitungsauftrag als Bearbeiter ausgewählt werden.

In der Funktion

Die Funktion

CisParameterList:
{batchJobGuids:null}
{com.cisag.pgm.base.CisApplicationCallResult:true}
{nextAction:0}
{nextParameters:null}
{outQueueEntryGuids:null}
{result:1}
{resultParmeters:CisParameterList:
{ResultNumberOfSuccessfulResults:1}
{ResultPhysicalInventoryCountListGuids:[[B@22833e99]}}
{state:2}
{waitingResult:0}

{batchJobGuids=[103=null], com.cisag.pgm.base.CisApplicationCallResult=[B=true], nextAction=[N=0], nextParameters=[103=null], outQueueEntryGuids=[103=null], result=[N=1], resultParmeters=[H={ResultNumberOfSuccessfulResults=[N=1], ResultPhysicalInventoryCountListGuids=[L=[[G=0080EED3CBFB2E10B118AD1BAABC0000]]]}], state=[N=2], waitingResult=[N=0]}

function close(state as Number)
{
var rp as HashMap;
var cls as Number; /* number of count lists generated */
var clGuids as Guid[]; /* list of count list GUIDs */
var cl as CisObject(com.cisag.app.inventory.physical.obj.PhysicalInventoryCountList);

rp := cast(HashMap, getJobResult().resultParmeters);
cls := cast(Number, rp.ResultNumberOfSuccessfulResults);
clGuids := cast(Guid[], rp.ResultPhysicalInventoryCountListGuids);

echo(format(cls, "0") + " count list(s) generated:");
for (g : clGuids) {
cl := getByPrimaryKey(CisObject(com.cisag.app.inventory.physical.obj.PhysicalInventoryCountList), g);
echo(cl->PhysicalInventory->Type:code + "-" + cl->PhysicalInventory:number + " " + cl:number);
}
}

Webservices (getServiceResponse)

Der Knotentyp Webservice-Knoten wird in Prozessdefinitionen verwendet, um einen externen Webservice mit Hilfe der Hintergrundanwendung Service-Client aufzurufen. Die Hintergrundanwendung nutzt das HTTP-Protokoll und kann per JSON/REST und XML/SOAP externe Webservices aufrufen.

In der Funktion

Folgendes Beispiel gibt die vier Ergebnisvariablen data, errors, promise, und ready einer Aktivitätsdefinition des Typs Webservice-Knoten ins Protokoll aus:

function close(state as Number)
{
var response := parseJson(getServiceResponse());
echo((cast(HashMap, response.data));
echo((cast(String[],response.errors));
echo((cast(Guid, response.promise));
echo((cast(Boolean, response.ready));
}

Individuelle Prüfungen (environment)

Zusätzlich zu den übergebenen Parametern der Funktionen stellt eine individuelle Prüfung die Variable

function validateHeader(
persistent as DataView(com.cisag.app.purchasing.order.model.PurchaseOrder),
current as DataView(com.cisag.app.purchasing.order.model.PurchaseOrder))
{
const OrderStatus as valueSet(com.cisag.app.general.OrderStatus);
if ((persistent:status=OrderStatus.ORDER_ENTERED or persistent:status=OrderStatus.ORDER_HELD or persistent:status=OrderStatus.ORDER_CANCELED or (persistent:status=OrderStatus.ORDER_INVALID and persistent:statusBackup=OrderStatus.ORDER_RELEASED)) and current:status=OrderStatus.ORDER_RELEASED) {
var authorizedUsers := resolveRole("MANAGERS");
if (not isNull(persistent:responsible))
authorizedUsers := union(authorizedUsers, list(persistent:responsible));
if (not contains(authorizedUsers, environment.userGuid))
sendMessage(null, "ERROR", "No authorization to release.");
}
}

Beachten Sie bitte, dass das Attribut

Fehlerbehandlung

Komplexität von Ausdrücken beschränken

Die System-Skriptsprache ist für längere Berechnungen oder die Verarbeitung von größeren Datenmengen ungeeignet. Aus diesem Grund wird die Laufzeit von Bedingungen und Befehlen beschränkt.

Die Standardeinstellungen sind:

Mit der System-Property

Behandlung von Laufzeitfehlern

Einige Fehler in Ausdrücken können bei der Prüfung des Skripts nicht erkannt werden.

Laufzeitfehler in der Workflow-Engine haben die Meldungsklasse WFL. Fehler, die bei der Auswertung der Ausdrücke auftreten, werden abhängig von der Aktivitätsdefinition in das OLTP- oder Repository-Protokoll geschrieben. Das OLTP- bzw. Repository-Protokoll kann mit der Anwendung Meldungsprotokolle abgefragt werden. Wenn die Vorbedingung fehlerhaft ist, dann wird abhängig von der Aktivität eine Meldung in das OLTP- oder Repository-Protokoll geschrieben. Die Aktivität wird jedoch so behandelt, als ob die Vorbedingung erfüllt wäre.

Bei Fehlern in der Übergangsbedingung, der Berechnung der Bearbeiter oder im Befehlsblock wird keine neue Aktivität erzeugt. Eine Meldung wird in das Systemprotokoll geschrieben. Das Meldungsprotokoll sollte in regelmäßigen Abständen auf Fehler kontrolliert werden, insbesondere dann, wenn Aktivitäts­definitionen verändert oder neu erfasst wurden.

Erweiterung der System-Skriptsprache

Über eine vorgegebene Programmierschnittstelle kann die System-Skriptsprache um neue Befehle und Funktionen erweitert werden. Insbesondere wenn komplexe Bedingungen geprüft werden sollen, errei­chen Sie schnell die Grenzen der Skriptspra­che im Bezug auf die Ausdrucksfähigkeit oder Leistungsfähigkeit. In diesem Fall können Sie die Probleme über spezia­li­sierte Funk­tionen beheben.

Weitere Informationen finden Sie im Kapitel Erweitern der Skriptsprache der Dokumentation Schnittstellen zum Workflow-Management.