Administrationshandbuch d.ecs process

Administrationshandbuch d.ecs process

Basisinformationen zur Anwendung und zum Handbuch

In diesem Kapitel finden Sie Produkthinweise und allgemeine Informationen.

Über d.ecs process

d.ecs process ist eine Anwendung, mit der Sie Prozesse ausführen, überwachen und administrieren können.

Mit d.ecs process sind Sie in der Lage, Geschäftsprozesse zu automatisieren. Sie können Anwender in Form von Aufgaben an Prozessen teilnehmen lassen oder automatisierte Serviceaktivitäten ausführen. d.ecs process unterstützt den BPMN-Standard. Dadurch haben Sie vielfältige Möglichkeiten bei der Gestaltung von Prozessen.

In der Prozessüberwachung haben Sie die Möglichkeit, den Status aktiver Prozesse zu kontrollieren. Im Falle eines Fehlers haben Sie direkt die Möglichkeit, Korrekturen vorzunehmen. Damit stellen Sie auf einfache Weise den erfolgreichen Betrieb Ihrer Geschäftsprozesse sicher.

Die Prozessadministration unterstützt Sie dabei, Aktionen über mehrere Prozessinstanzen durchzuführen. Sie können beispielsweise mehrere Prozessinstanzen abbrechen, diese bei Prozessänderungen in eine neue Version migrieren, fehlerhafte Prozessinstanzen erneut ausführen oder eine Prozessversion löschen.

Wenn Sie einen eigenen Prozess modelliert haben, können Sie diesen in der Prozessadministration bereitstellen. Der Prozess steht Ihnen dann in der d.3ecm-Welt zur Verfügung.

Konfigurieren von d.ecs process

In diesem Thema finden Sie Informationen zur Konfiguration und weiteren Einstellungen.

Konfigurieren eines Systembenutzers

Konfigurieren Sie einen Systembenutzer, damit die Anwendung mit anderen Anwendungen kommunizieren kann, die eine Authentifizierung benötigen.

Um einen Systembenutzer zu konfigurieren, gehen Sie wie folgt vor:

  1. Wählen Sie das Feature Konfiguration aus.
  2. Wählen Sie im Bereich Prozesse die Option Systembenutzer aus.
  3. Wählen Sie die Kontextaktion Konfigurieren aus.
  4. Geben Sie den API-Schlüssel des gewünschten Benutzers ein. Verwenden Sie die Kontextaktion API-Schlüsselerzeugung öffnen, um mithilfe von d.ecs identity provider einen API-Schlüssel zu ermitteln oder zu erzeugen.
  5. Klicken Sie auf Speichern.

Einrichten von Benutzerrollen (optional)

Mit dem Eintrag Benutzerrollen im Feature Konfiguration können Sie Benutzern eine Benutzerrolle zuweisen. Jeder authentifizierte Benutzer ist nach der Einrichtung von d.ecs process automatisch der Rolle Prozessbenutzer zugewiesen. 

Sie können Benutzern folgende Rollen zuweisen:

  • Prozessadministrator: Besitzt alle Berechtigungen für die Arbeit mit d.ecs process.
  • Prozessbenutzer: Darf Einmalprozesse starten und Prozesse bereitstellen.

Möchten Sie einem Benutzer beispielsweise die Rolle Prozessadministrator zuweisen, tragen Sie einfach den Benutzernamen in das entsprechende Feld ein und wählen ihn aus.

Administrieren von Prozessen

In diesem Thema erfahren Sie, wie Sie Ihre Prozesse verwalten können. Informieren Sie sich über die Möglichkeiten, einen Überblick über Ihre Prozesse zu erhalten und fehlerhafte Prozesse zu korrigieren.

Wissenswertes zum Feature "Prozessadministration"

Mit dem Feature Prozessadministration können Sie Aktionen starten, die ganze Prozessversionen betreffen. In der Regel umfassen die Aktionen mehrere Prozessinstanzen. Die Prozessadministration erlaubt es Ihnen, Aktionen zu verschiedenen Prozessen und Versionen nacheinander durchzuführen, ohne die Ansicht wechseln zu müssen.

Sie können folgende Aktionen für ganze Prozessversionen durchführen:

  • Prozessversionen erneut ausführen: Wenn innerhalb eines Prozesses mehrere Fehler auftreten, können Sie zur Fehlerbehebung die Prozessversion erneut ausführen. Verwenden Sie zum erneuten Ausführen einer Prozessversion die Aktion Erneut ausführen.
  • Prozessinstanzen in die nächste Prozessversion migrieren: Bei der Aktualisierung von Prozessen wird automatisch eine neue Version des Prozesses angelegt. Sie können mit der Aktion Migrieren alle Instanzen einer Prozessversion in die neuste Version migrieren.
  • Prozessversionen löschen: Wenn keine laufenden Prozessinstanzen zu einer Version mehr vorliegen, können Sie die Prozessversion löschen. Verwenden Sie zum Löschen einer Prozessversion die Aktion Prozessversion löschen.
  • Prozessinstanzen abbrechen: Sie können alle offenen Instanzen einer Prozessversion abbrechen. Durch das Abbrechen werden alle offenen Aktivitäten zu dieser Prozessversion entfernt und die Prozessinstanz kann nicht wieder fortgesetzt werden. Verwenden Sie zum Abbrechen einer Prozessinstanz die Aktion Instanzen abbrechen.

Darüber hinaus stehen noch folgende Aktionen zur Verfügung:

  • Neuen Prozess bereitstellen: Sie können einen neuen Prozess (oder eine neue Version eines bereits bestehenden Prozesses) aus einer .bpmn-Datei ins System importieren.

Anzeigen aller Prozessinstanzen

Mit dem Feature Prozessüberwachung erhalten Sie einen Überblick über alle Prozessinstanzen. Sie können mit dem Business-Key gezielt nach einzelnen Prozessen suchen oder die Ergebnisliste mit den Filtern Prozesse, Versionen, Aktivitäten und Status eingrenzen. Ein Prozess befindet sich in einem der folgenden vier Status:

: Die Instanz wurde abgebrochen

: Die Instanz ist in einem Fehlerzustand

: Die Instanz wurde erfolgreich beendet

: Die Instanz läuft aktuell noch

Um nähere Informationen zu einer Prozessinstanz zu erhalten, wählen Sie den Prozess aus. In der Detailansicht stehen Ihnen Kontextaktionen zur Verfügung, die sich je nach Prozesstyp unterscheiden können. Mit den Kontextaktionen können Sie die Prozessinstanz abbrechen, in die nächste Version migrieren, in einem Instanzdiagramm darstellen oder in der Quelle anzeigen.

Anzeigen eines Instanzdiagramms

In der Detailansicht einer Instanz können Sie die Prozessinstanz mit der Kontextaktion Instanzdiagramm in einem Diagramm anzeigen.

Um bei sehr komplexen Instanzdiagrammen den Überblick zu bewahren, können Sie die Ansicht des Diagramms ändern. Mit dem Mausrad können Sie die Größe des Diagramms ändern. Wenn Sie die Ansicht mit dem Mausrad vergrößert haben, können Sie das Diagramm mit gedrückter linker Maustaste verschieben. Mit Ansicht zurücksetzen kehren Sie zur ursprünglichen Ansicht zurück.

Ändern der Variablen eines Tokens

Wenn Sie im Feature Prozessüberwachung in die Detailansicht eines Tokens navigieren, können Sie die Variablen der Prozessinstanz ändern. Ändern Sie Variablen beispielsweise, um die mögliche Fehlerursache eines Prozesses zu beheben.

Wählen Sie Variablen bearbeiten aus, um den Bearbeitungsmodus zu aktivieren und die Werte in den Eingabefeldern zu ändern. Sie haben zwei Möglichkeiten, den Bearbeitungsmodus zu verlassen:

  • Wählen Sie Änderungen speichern aus, um die neuen Werte in die Datenbank zu schreiben und den Bearbeitungsmodus zu verlassen. Alle Änderungen haben eine direkte Auswirkung auf den gesamten Prozess.
  • Wählen Sie Änderungen verwerfen aus, um die alten Ausgangswerte wiederherzustellen und den Bearbeitungsmodus zu verlassen. Dieser Vorgang hat keine Auswirkungen auf den Prozess. 

Erneutes Ausführen eines fehlgeschlagenen Tokens

Wenn Sie im Feature Prozessüberwachung einen Prozess im Status Fehler sehen, können Sie den fehlerhaften Token zur Fehlerbehebung erneut ausführen. Beachten Sie die Fehlerursache in der Detailansicht eines Tokens, da Sie für die Fehlerbehebung möglicherweise die Variablen der Prozessinstanz ändern müssen.

Zum erneuten Ausführen eines Tokens navigieren Sie in die Detailansicht des Tokens. Wählen Sie Erneut versuchen aus und bestätigen Sie den Hinweis.

Modellieren von Prozessen

In diesem Thema erfahren Sie, wie Sie Ihre eigenen Prozesse modellieren. Sie lernen die unterstützten BPMN-Elemente kennen und erfahren, wie Sie diese zu Ihren Prozessen hinzufügen.

Wissenswertes zur Prozessmodellierung

Bei der Erstellung von Prozessmodellen unterstützt die Anwendung den BPMN-Standard. Dabei handelt es sich um ein XML-basiertes Format. Das Modellieren von Prozessen im d.velop-Kontext orientiert sich am Standard der Object Management Group (OMG). Der Wert http://www.omg.org/spec/BPMN/20100524/MODEL ist der standardmäßige Namensraum.

Für die Modellierung von Prozessmodellen benötigen Sie einen Text-Editor oder einen BPMN-Editor mit einer XML-Ansicht.

Sie müssen beim Modellieren Ihrer eigenen Prozesse jeder XML-Datei folgenden Namensraum hinzufügen:

   xmlns:camunda="http://camunda.org/schema/1.0/bpmn"

Verwenden von BPMN-Elementen

Bei der Erstellung eigener Prozessmodelle können Sie folgende BPMN-Elemente des BPMN-Standards 2.0 verwenden:


BPMN-ElementRestriktionen

Start event (Startereignis)

Keine Ereignistypen möglich.

End event (Endereignis)

Erlaubte Ereignistypen: Keine, Terminierung.

Intermediate boundary event (angeheftetes Zwischenereignis)

Erlaubte Ereignistypen: Timer.

Intermediate event (Zwischenereignis)

Erlaubte Ereignistypen: Timer.

User Task (Benutzeraktivität)


 

Send Task (Sendenaktivität)Nur zur Anbindung von Services.

 

Receive Task (Empfangenaktivität)


Nur zur Anbindung von Services.

Gateway (Verzweigung)

Erlaubte Verzweigungstypen: Exclusiv, Parallel, Inclusiv.

Sequence flow (Sequenzfluss)


Sub process (Subprozesse)

Allgemeine Einschränkungen

Für alle Elemente gelten folgende Restriktionen:

  • Ausdrücke bei In- und Output-Parametern unterliegen den Restriktionen für Ausdrücke.
  • Es sind ausschließlich die folgenden camunda-Erweiterungen erlaubt:
    • camunda:inputOutput
    • camunda:properties
    • camunda:property
    • camunda:failedJobRetryTimeCycle
    • camunda:asyncBefore
    • camunda:asyncAfter
    • camunda:formKey

Erstellen eines exemplarischen Prozesses in einer BPMN-Datei

Für den Einstieg in das Modellieren eigener Prozesse ist es hilfreich, wenn Sie zunächst einen einfachen Prozess beispielhaft erstellen. Voraussetzung für das Modellieren eigener Prozesse sind ein konfigurierter Systembenutzer und eingerichtete Benutzerrollen. Außerdem benötigen Sie einen Text- oder BPMN-Editor mit XML-Ansicht und ein Tool zum Aufrufen einer REST-API.

Ein einfacher Prozess sieht beispielsweise so aus:

Erstellen Sie zum Modellieren Ihres eigenen Prozesses zunächst folgendes Grundgerüst in Ihrer BPMN-Datei:

   <?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" targetNamespace="">
  <process>
    <startEvent/>
    <sequenceFlow/>
    <userTask/>
    <sequenceFlow/>
    <endEvent/>
  </process>
</definitions>

Diesem Grundgerüst fügen Sie die einzelnen Prozesselemente hinzu.

Hinzufügen des Prozesselements

Das BPMN-Element process ist eine Kapsel um den gesamten Prozess. Fügen Sie dem BPMN-Element die Eigenschaften id, name und isExcecutable hinzu.

   <process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">

Erläuterung der Eigenschaften

  • id: Die Eigenschaft wird als eindeutiger Bezeichner für den Prozess verwendet.
  • name: Die Eigenschaft wird als Anzeigename in den Benutzeroberflächen verwendet.
  • isExecutable: Die Eigenschaft muss den Wert true enthalten, damit der Prozess gestartet werden kann.

Hinzufügen eines Start- und Endereignisses

Die BPMN-Elemente startEvent und endEvent werden als Markierungen verwendet, die anzeigen, wo der Prozess beginnt und wo er endet. Fügen Sie den BPMN-Elementen jeweils die Eigenschaft id hinzu.

   <startEvent id="start"/>
<endEvent id="end"/>

Hinzufügen einer Benutzeraktivität

Das BPMN-Element userTask stellt eine Benutzeraktivität im Prozess dar. Bei Eingang in diese Aktivität wird einem oder mehreren Benutzern eine Aufgabe zugestellt. Fügen Sie dem BPMN-Element die Eigenschaften idname sowie humanPerformer hinzu.

   <userTask id='task_hello_world' name='Hello World' >
    <humanPerformer>
        <resourceAssignmentExpression>
            <formalExpression>${variables.get("dv_initiator")}</formalExpression>
        </resourceAssignmentExpression>
    </humanPerformer>
</userTask>

Erläuterung der Eigenschaften

  • id: Die Eigenschaft dient als Bezeichner der Aktivität im BPMN-Modell und wird bei der Verbindung durch Sequenzflüsse verwendet.
  • name: Die Eigenschaft wird der Aufgabe als Betreff hinzugefügt.
  • humanPerformer: Die Eigenschaft bezieht sich auf die Person, die die Aufgabe bearbeiten soll. In der BPMN-Datei wird mit dem Ausdruck ${variables.get("dv_initiator")} eine Variable verwendet. Die Variable dv_initiator verweist immer auf die Person, die den Prozess gestartet hat. Diese Aufgabe wird also immer der Person zugestellt, die den Prozess startet.

Hinzufügen von Sequenzflüssen

Verbinden Sie die einzelnen Prozesselemente, um einen Ablauf zu erstellen. Zum verbinden der Prozesselemente verwenden Sie das BPMN-Element sequenceFlow. Fügen Sie dem BPMN-Element die Eigenschaften idsourceRef und targetRef hinzu.

Die beispielhafte Konfiguration in der BPMN-Datei zeigt, wie Sie das Startereignis mit der Benutzeraktivität verbinden und die Benutzeraktivität mit dem Endereignis verknüpfen:

   <sequenceFlow id="s1" sourceRef="start" targetRef="task_hello_world" />
<sequenceFlow id="s2" sourceRef="task_hello_world" targetRef="end" />

Erläuterung der Eigenschaften

  • id: Die Eigenschaft ist ein eindeutiger Bezeichner für den Sequenzfluss innerhalb des BPMN-Modells.
  • sourceRef: Die Eigenschaft verweist auf den Ausgangspunkt des Sequenzflusses.
  • targetRef: Die Eigenschaft verweist auf das Ziel des Sequenzflusses. In dieser Eigenschaft tragen Sie die Bezeichner der zu verbindenden Elemente ein.

Nachdem Sie die einzelnen Prozesselemente hinzugefügt haben, sieht die BPMN-Datei folgendermaßen aus:

   <?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" targetNamespace="">
    <process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
        <startEvent id="start"/>
        <endEvent id="end"/>
        <userTask id='task_hello_world' name='Hello World' >
            <humanPerformer>
                <resourceAssignmentExpression>
                    <formalExpression>${variables.get("dv_initiator")}</formalExpression>
                </resourceAssignmentExpression>
            </humanPerformer>
        </userTask>
        <sequenceFlow id="s1" sourceRef="start" targetRef="task_hello_world" />
        <sequenceFlow id="s2" sourceRef="task_hello_world" targetRef="end" />
    </process>
</definitions>

Hinzufügen von grafischen Informationen

Wenn Sie Ihren erstellten Prozess in einem Diagramm anzeigen möchten, können Sie der BPMN-Datei grafische Informationen hinzufügen. Diese grafischen Informationen legen die Größe des Diagramms und die Position der einzelnen Elemente fest. Die grafischen Informationen fügen Sie mithilfe des BPMN-Elements bmpndi:BPMNDiagram hinzu.

   <?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:di="http://www.omg.org/spec/DD/20100524/DI" xmlns:dc="http://www.omg.org/spec/DD/20100524/DC" targetNamespace="">
    <process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
        <startEvent id="start"/>
        <endEvent id="end"/>
        <userTask id='task_hello_world' name='Hello World' >
            <humanPerformer>
                <resourceAssignmentExpression>
                    <formalExpression>${variables.get("dv_initiator")}</formalExpression>
                </resourceAssignmentExpression>
            </humanPerformer>
        </userTask>
        <sequenceFlow id="s1" sourceRef="start" targetRef="task_hello_world" />
        <sequenceFlow id="s2" sourceRef="task_hello_world" targetRef="end" />
    </process>
    <bpmndi:BPMNDiagram id="BPMNDiagram_1">
        <bpmndi:BPMNPlane id="BPMNPlane" bpmnElement="GettingStarted">
            <bpmndi:BPMNShape id="start_di" bpmnElement="start">
                <dc:Bounds x="173" y="102" width="36" height="36" />
            </bpmndi:BPMNShape>
            <bpmndi:BPMNEdge id="s1_di" bpmnElement="s1">
                <di:waypoint x="209" y="120" />
                <di:waypoint x="259" y="120" />
            </bpmndi:BPMNEdge>
            <bpmndi:BPMNShape id="end_di" bpmnElement="end">
                <dc:Bounds x="409" y="102" width="36" height="36" />
            </bpmndi:BPMNShape>
            <bpmndi:BPMNEdge id="s2_di" bpmnElement="s2">
                <di:waypoint x="359" y="120" />
                <di:waypoint x="409" y="120" />
            </bpmndi:BPMNEdge>
            <bpmndi:BPMNShape id="task" bpmnElement="task_hello_world">
                <dc:Bounds x="259" y="80" width="100" height="80" />
            </bpmndi:BPMNShape>
        </bpmndi:BPMNPlane>
    </bpmndi:BPMNDiagram>
</definitions>

Verwenden von Ausdrücken

Sie können beim Modellieren von Prozessen variable Ausdrücke verwenden. Die Ausdrücke verwenden die Syntax der Java Expression Language.

Ausdrücke dürfen lediglich folgende Elemente verwenden:

ElementRestriktion

Lesender Zugriff auf die Variablen mittels variables

  • variables.get
  • variables.getObject
  • variables.getDisplayValue

Erzeugen von Mehrfachwerten

  • collections.from

Operatoren und Zeichen

Erlaubte Operatoren und Zeichen: +, -, *, /, %, =, !, <, >, &, |, ?, (, ), [, ].

KeywordErlaubte Keywords: div, mod, eq, ne, lt, gt, le, ge, and, or, not, empty.
Numerische Werte
ZeichenkettenZeichenketten müssen in " " oder ' ' eingeschlossen sein.

Beispiele

   ${"Hello World"}                            // Hello World
${3}                                        // 3
${3 > 4}                                    // false
${variables.get("myVariable")}              // Value of myVariable
${variables.get("myVariable") == "Hello"}   // true, if myVariable equals Hello, false otherwise
${collections.from("a", "b", "c")}          // creates a collection with "a", "b" and "c"

Es sind auch Mischformen möglich, sodass Sie Texte und variable Inhalte direkt miteinander kombinieren können.

Beispiele

   This is an expression with ${variables.get("myVariable")}
3 is ${(3 > 4) ? "greater" : "lesser"} than 4

Arbeiten mit Prozessvariablen

In diesem Thema erfahren Sie, wie Sie Ihre Prozesse mithilfe von Variablen dynamisch erstellen.

Wissenswertes zu Prozessvariablen

Prozessvariablen sind Daten, die Informationen zu einer Prozessinstanz enthalten. Folgende Prozessvariablen sind in jeder Prozessinstanz vorhanden:

  • dv_initiator: Eine Prozessvariable vom Datentyp Identity. Die Prozessvariable verweist auf die Identität des Benutzers, der die Prozessinstanz gestartet hat.
  • dv_start_time: Eine Prozessvariable vom Datentyp String. Die Prozessvariable enthält den UTC-String des Zeitpunktes, in dem die Prozessinstanz aus Sicht der Anwendung gestartet wurde. Es gilt der Zeitpunkt, in dem die Anwendung beauftragt wurde, die Prozessinstanz zu starten. Da der eigentliche (technische) Start der Instanz asynchron durchgeführt wird, kann der in der Variable enthaltene Zeitpunkt möglicherweise abweichen.

Verwenden weiterer Prozessvariablen

Diese Variablen können Sie für spezielle Zwecke verwenden:

  • dv_sender: Eine Prozessvariable vom Datentyp Identity. Die Prozessvariable verweist auf die Identität des Benutzers, der als Absender von Benutzeraktivitäten verwendet wird.
  • dv_attachment: Eine Prozessvariable vom Datentyp DmsObject oder abweichend. Die Prozessvariable enthält eine Verknüpfung, die allen Benutzeraktivitäten als Anhang hinzugefügt wird.

Wichtig

Die Prozessvariable dv_attachment ist mit dem Datentyp DmsObject vordefiniert. Möchten Sie eine andere URI als die zu einem Objekt der DMS-App verwenden, müssen Sie den Wert des Datentyps auf String ändern.

Definieren von Prozessvariablen

Definieren Sie in der Prozessdefinition Variablen, die innerhalb eines Prozesses genutzt werden. Definierte Variablen können an den entsprechenden Schnittstellen der Anwendung automatisch validiert und ggf. konvertiert werden. 

Innerhalb eines Prozesses können Sie folgende Variablen definieren:

  • Allgemeine Prozessvariable: Eine Variable, die im gesamten Prozess Gültigkeit hat. Sie können festlegen, ob es sich um eine Startvariable handelt.
  • Lokale Prozessvariable: Eine Variable, deren Gültigkeitsbereich auf eine einzelne Prozessaktivität beschränkt ist. 
  • Servicevariablen: Ein- oder Ausgabevariablen eines Prozessservices. 

Eine Variablendefinition beinhaltet folgende Informationen:

EigenschaftMögliche WerteBeispiel
Name[A-Za-z][A-Za-z0-9_]*myVariable (name-Eigenschaft)
StartvariablemyStartVariable* (name-Eigenschaft)
Datentyp
  • String
  • Number
  • Identity
  • DmsObject
String (value-Eigenschaft)
Einzel- oder Mehrfachwert

Einzelwert: String (value-Eigenschaft)

Mehrfachwert: [String] (value-Eigenschaft)

Pflichtvariable

Einzelwert: String! (value-Eigenschaft)

Mehrfachwert: [String]! (value-Eigenschaft)

Hinweis

Eine Variable, die als Pflichtvariable definiert ist, kann nicht über die Schnittstelle zum Ändern von Variablen gelöscht werden. Handelt es sich bei der Pflichtvariable zusätzlich um eine Startvariable, so muss ein Benutzer beim Start einer Prozessinstanz immer einen gültigen Wert für die Variable übergeben. Geschieht dies nicht, wird die Anfrage mit dem Fehlercode 400 abgelehnt.

Für den Datentypen Number gelten diese Einschränkungen:

MinimumMaximumNachkommastellenGenauigkeit
-1e16

1e16

515 Stellen

Die nicht-primitiven Datentypen verwenden die folgende Notation:

DatentypNotation
Identity

Für Benutzer:
identity:///identityprovider/scim/users/<someUserId>

Für Gruppen:
identity:///identityprovider/scim/groups/<someGroupId>

DmsObjectdmsObject:///dms/r/<repositoryId>/o2/<dmsObjectId>

Variablen werden als BPMN-Erweiterung in Form von Camunda-Properties definiert. Allgemeine Prozess- und Servicevariablen definieren Sie innerhalb des BPMN-Modells direkt im Prozessknoten. Lokale Prozessvariablen definieren Sie im Knoten der Aktivität, in der sie gültig sein sollen.

Allgemeine Prozess- und Servicevariablen

    <process id="myProcess" name="Process with variable declaration" isExecutable="true">
    <extensionElements>
        <camunda:properties>
            <camunda:property name="variable:myVariable" value="[String]!" /> <!-- Name: "myVariable", Type: "String", Multiple: true, Mandatory: true, Startvariable: false -->
            <camunda:property name="variable:myStartVariable*" value="String" /> <!-- Name: "myStartVariable", Type: "String", Multiple: false, Mandatory: false, Startvariable: true-->
            <camunda:property name="variable:someUserTaskOutput" value="String" /> <!-- Name: "someUserTaskOutput", Type: "String", Multiple: false, Mandatory: false, Startvariable: false -->
            <camunda:property name="service:/myservice:in:input" value="String!" /> <!-- Name: "input", Type: "String", Multiple: false, Mandatory: true -->
            <camunda:property name="service:/myservice:out:output" value="Number!" /> <!-- Name: "output", Type: "Number", Multiple: false, Mandatory: true -->
        </camunda:properties>
    </extensionElements>
</userTask>

Lokale Prozessvariable

   <userTask id="userTask" name="User Task">
    <extensionElements>
        <camunda:inputOutput>
            <camunda:inputParameter name="someInput">user task input which is only available within this user task scope</camunda:outputParameter>
            <camunda:outputParameter name="someUserTaskOutput">user task output which will be written to process scope</camunda:outputParameter>
        </camunda:inputOutput>
        <camunda:properties>
            <camunda:property name="variable:someInput" value="String" />
        </camunda:properties>
    </extensionElements>
</userTask>

Verwenden von Prozessvariablen

Beim Modellieren eigener Prozesse können Sie Prozessvariablen verwenden, um dynamische Prozesse zu erstellen. Zum Einstieg in das Arbeiten mit Prozessvariablen ist es hilfreich, wenn Sie zunächst einen einfachen Prozess mit einer Benutzeraktivität erstellen. Dieser Prozess sieht beispielsweise so aus:


Das BPMN-Modell dieses beispielhaften Prozesses ist folgendermaßen aufgebaut. Zur Vereinfachung sind die grafischen Informationen zum BPMN-Diagramm in dieser BPMN-Beispieldatei nicht enthalten.

   <?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:di="http://www.omg.org/spec/DD/20100524/DI" xmlns:dc="http://www.omg.org/spec/DD/20100524/DC" targetNamespace="">
  <process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
    <startEvent id="start"/>
    <userTask id='task_hello_world' name='Hello World' >
      <humanPerformer>
          <resourceAssignmentExpression>
              <formalExpression>${variables.get("dv_initiator")}</formalExpression>
          </resourceAssignmentExpression>
      </humanPerformer>
	</userTask>
    <sequenceFlow id="s1" sourceRef="start" targetRef="task_hello_world" />
	<sequenceFlow id="s2" sourceRef="task_hello_world" targetRef="end" />
    <endEvent id="end"/>        
  </process>  
</definitions>

Dieser Prozessdefinition fügen Sie nun eine neue Variablendefinition hinzu.

Hinzufügen einer Variablendefinition

Um eine Prozessvariable verwenden zu können, müssen Sie diese der Prozessdefinition hinzufügen. In der Prozessdefinition fügen Sie die BPMN-Elemente extensionElements und camunda:properties zum BPMN-Element process hinzu. Zum Definieren der Prozessvariable fügen Sie dem BPMN-Element camunda:properties noch das Element camunda:property hinzu.

Dieses Beispiel zeigt, wie Sie die Variable message vom Datentyp String hinzufügen:

   <process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
	<extensionElements>
      <camunda:properties>
        <camunda:property name="variable:message" value="String" />
      </camunda:properties>
    </extensionElements>
	...
</process>

Erläuterung der Eigenschaften

  • name: Die Eigenschaft definiert den Namen der Prozessvariable. Vor dem Wert steht immer das Präfix variable:.
  • value: Die Eigenschaft definiert den Datentypen der Prozessvariable.

Verwenden der Prozessvariable

Sie können die Variable message nun für den Namen der Benutzeraktivität verwenden, damit dieser Name dem Anwender in der Aufgabenliste angezeigt wird. Hierzu ersetzen Sie den vorhandenen Text in der Eigenschaft name der Benutzeraktivität durch die Methode für den Zugriff auf die Variable message:

   <process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
	...
	<userTask id="task_hello_world" name="${variables.get('message')}">
		...
	</userTask>
	...

Sie können den Wert der Variablen nun zum Beispiel beim Start des Prozesses belegen.


Ermitteln von Prozessvariablen

Mit dem Objekt variables können Sie auf die Prozessvariablen zugreifen. Der Aufruf erfolgt jeweils in der Notation variables.<methodName>( <Parameter>).

get( String variableName)

Die Methode ermittelt den Wert für die Variable mit dem eingegebenen Variablennamen. Bei Variablen mit einem Mehrfachwert werden die Werte in einer Liste (collection) zurückgegeben.

getDisplayValue( String variableName)

Die Methode ermittelt den Wert für die Variable mit dem eingegebenen Variablennamen. Je nach Datentyp findet hierbei automatisch eine entsprechende Konvertierung statt.

Bei Variablen mit einem Mehrfachwert werden die konvertierten Werte in einem String mit Kommas getrennt zurückgegeben. Sind die Variablen vom Datentyp Number, werden die konvertierten Werte in einem String mit Semikolons getrennt zurückgegeben.

DatentypTatsächlicher WertRückgabewert
String"some value""some value"
Number1.23"1.23"
Identityidentity:///identityprovider/scim/users/userIdOfMaxMustermann

"Max Mustermann" (displayName-Eigenschaft des Benutzers,

name-Eigenschaft bei Gruppen im d.ecs identity provider)

DmsObjectdmsObject:///dms/r/someRepo/o2/T000000001"/dms/r/someRepo/o2/T000000001"

Erzeugen von Mehrfachwerten

Mit dem Objekt collections können Sie aus Einzelwerten eine Liste (collection) erzeugen, z.B. um einer Variablen einen Mehrfachwert zuzuweisen. Das Erzeugen einer Liste aus Einzelwerten ist beispielsweise hilfreich, wenn Sie in einer Benutzeraktivität mehrere Empfänger als Konstante hinterlegen wollen.

Beispiel

   ${collections.from( "identity:///identityprovider/scim/users/user1", "identity:///identityprovider/scim/users/user")}


from( Object...objects)

Die Methode erzeugt eine Liste (collection) mit den übergebenen Einzelwerten.

Wissenswertes zum Geltungsbereich von Prozessvariablen

Prozessvariablen haben innerhalb einer Prozessinstanz immer einen bestimmten Geltungsbereich. Je nach Geltungsbereich sind lesende und schreibende Zugriffe möglich.

In jeder Prozessinstanz gibt es einen universellen Geltungsbereich, der den gesamten Prozess umfasst. Alle weiteren Geltungsbereiche, wie zum Beispiel Benutzer- oder Serviceaktivitäten, können lesend auf die Variablen im universellen Geltungsbereich zugreifen.

Zusätzliche Geltungsbereiche werden an folgenden Stellen erzeugt:

  • Verzweigungen mit parallelen Pfaden
  • Multi-Instanz-Konstrukte
  • Subprozesse
  • Input-/Output-Mapping bei Benutzeraktivitäten
  • Serviceaktivitäten
  • Timer-Ereignis

Lesende Zugriffe

Lesende Zugriffe auf Prozessvariablen (z.B. die Verwendung in einem Ausdruck) sind unabhängig vom Geltungsbereich möglich. Wird im aktuellen Geltungsbereich kein Wert gefunden, so wird der darüber liegende Bereich durchsucht, bis ein Wert gefunden wurde.

Schreibende Zugriffe

Wenn Sie Werte ändern möchten (z.B. in einer Benutzeraktivität mit Output-Mapping), so wird der Wert immer zunächst in den aktuellen Geltungsbereich der Aktivität übernommen. Andere Geltungsbereiche, z.B. entlang anderer Zweige im Prozess, werden dadurch bis zum Ende dieses Geltungsbereiches nicht beeinflusst. Erst am Ende des aktuellen Wertebereichs werden die Änderungen auch in alle anderen Geltungsbereiche übernommen.

Ende von Geltungsbereichen

Am Ende eines Geltungsbereichs (z.B. bei der Zusammenführung paralleler Zweige oder am Ende eines Subprozesses) werden die Variablen dieses Geltungsbereichs verworfen. Um Variablen in den darüber liegenden Geltungsbereich zu übernehmen, müssen Sie ein Output-Mapping konfigurieren.

Auswirkungen in der Prozessüberwachung

Bei der Ansicht eines Tokens werden immer die Variablen des aktuellen Geltungsbereichs angezeigt. Änderungen an den Variablen werden nur in diesen Geltungsbereich übernommen.

Die meisten Tokens besitzen einen eigenen Geltungsbereich. Die einzige Ausnahme bilden Benutzeraktivitäten, für die kein Input-/Output-Mapping konfiguriert wurde und die nicht parallel zu anderen Aktivitäten ausgeführt werden. Diese Tokens besitzen denselben Geltungsbereich wie das direkt darüber liegende Token.

In der Ansicht des Tokens ohne eigenen Geltungsbereich finden Sie eine Verknüpfung zum Token aus dem darüber liegenden Bereich. Wenn Sie diese Verknüpfung auswählen, können Sie die Variablen des verknüpften Geltungsbereichs anzeigen.

Verwenden von Timer-Ereignissen

Bei der Prozessmodellierung können Sie das BPMN-Element intermediate boundary event (angeheftetes Zwischenereignis) vom Typ Timer verwenden. Diese Zwischenereignisse können Sie an Benutzeraktivitäten oder Services heften. Zum Einstieg in das Arbeiten mit angehefteten Zwischenereignissen ist es hilfreich, wenn Sie zunächst einen einfachen Prozess mit einer Benutzeraktivität erstellen.

Das BPMN-Modell dieses beispielhaften Prozesses ist folgendermaßen aufgebaut:

   <?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:camunda="http://camunda.org/schema/1.0/bpmn" targetNamespace="">
  <process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
    <startEvent id="start"/>
    <userTask id="task_hello_world" name="Hello World" >
      <humanPerformer>
          <resourceAssignmentExpression>
              <formalExpression>${variables.get("dv_initiator")}</formalExpression>
          </resourceAssignmentExpression>
      </humanPerformer>
    </userTask>
    <sequenceFlow id="s1" sourceRef="start" targetRef="task_hello_world" />
    <sequenceFlow id="s2" sourceRef="task_hello_world" targetRef="end" />
    <endEvent id="end"/>       
  </process> 
</definitions>

Zur Vereinfachung sind die grafischen Informationen zum BPMN-Diagramm in dieser BPMN-Beispieldatei nicht enthalten.

Hinzufügen eines Zwischenereignisses

Fügen Sie dem Prozess das BPMN-Element boundaryEvent hinzu. 

   ...
<process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
...
	<boundaryEvent id="timer" attachedToRef="task_hello_world">
	    <timerEventDefinition>
        	<timeDuration>PT1M</timeDuration>
    	</timerEventDefinition>
	</boundaryEvent>

Erläuterung der Eigenschaften

  • id: Die Eigenschaft wird als eindeutiger Bezeichner für die Sendenaktivität verwendet.
  • attachedToRef: Die Eigenschaft definiert, an welches BPMN-Element dieses Zwischenereignis angeheftet werden soll.

Erläuterung der Ereignisdefinition:

  • timerEventDefinition: Dieses BPMN-Element definiert, dass es sich bei dem Zwischenereignis um ein Zeitereignis handelt
  • timeDuration: Dieses BPMN-Element definiert, dass es sich um eine relative Zeitspanne handelt. In diesem Fall ist eine Spanne von 10 Minuten definiert. Möchten Sie einen absoluten Zeitpunkt definieren, können Sie das BPMN-Element timeDate verwenden. In beiden Fällen müssen Sie die Werte im ISO-8601-Format angeben. Sie können die Werte auch aus Variablen ermitteln.

Hinzufügen eines Ereignispfades

Tritt im Prozess ein Zwischenereignis ein, folgt der Prozess einem separaten Prozesspfad. Sie können einen Prozess beispielsweise so konfigurieren, dass der Prozess von einem Zwischenereignis direkt zum Endereignis führt. Diese Konfiguration fügen Sie folgendermaßen in den Prozess ein:

   ...
<process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
...
	<sequenceFlow id="s3" sourceRef="timer" targetRef="end" />
	...

Die finale BPMN-Definition sieht folgendermaßen aus:

   <?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:camunda="http://camunda.org/schema/1.0/bpmn" targetNamespace="">
  <process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
    <startEvent id="start"/>
    <userTask id="task_hello_world" name="Hello World" >
      <humanPerformer>
          <resourceAssignmentExpression>
              <formalExpression>${variables.get("dv_initiator")}</formalExpression>
          </resourceAssignmentExpression>
      </humanPerformer>
    </userTask>
    <boundaryEvent id="timer" attachedToRef="task_hello_world">
        <timerEventDefinition>
            <timeDuration>PT5S</timeDuration>
        </timerEventDefinition>
    </boundaryEvent>
    <sequenceFlow id="s1" sourceRef="start" targetRef="task_hello_world" />
    <sequenceFlow id="s2" sourceRef="task_hello_world" targetRef="end" />
    <sequenceFlow id="s3" sourceRef="timer" targetRef="end" />
    <endEvent id="end"/>      
  </process>
</definitions>

Verwenden von Verzweigungen

Beim Modellieren eigener Prozesse können Sie das BPMN-Element Gateway vom Typ exclusive (Verzweigung vom Typ exklusiv) verwenden, um dynamische Prozesse mit einer Entscheidungslogik zu erstellen. Zum Einstieg in das Arbeiten mit exklusiven Verzweigungen ist es hilfreich, wenn Sie zunächst einen einfachen Prozess mit einer Benutzeraktivität erstellen. Dieser Prozess sieht beispielsweise so aus:



Das BPMN-Modell dieses beispielhaften Prozesses ist folgendermaßen aufgebaut:

   <?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:camunda="http://camunda.org/schema/1.0/bpmn" targetNamespace="">
  <process id="GettingStarted" name="Example: Getting started" isExecutable="true">
    <startEvent id="start"/>
    <userTask id='task_hello_world' name='Hello World' >
      <humanPerformer>
          <resourceAssignmentExpression>
              <formalExpression>${variables.get("dv_initiator")}</formalExpression>
          </resourceAssignmentExpression>
      </humanPerformer>
    </userTask>
    <endEvent id="end"/>       
    <sequenceFlow id="s1" sourceRef="start" targetRef="task_hello_world" />
    <sequenceFlow id="s2" sourceRef="task_hello_world" targetRef="end" />
  </process> 
</definitions>

Zur Vereinfachung sind die grafischen Informationen zum BPMN-Diagramm in dieser BPMN-Beispieldatei nicht enthalten.

Diesen Beispielprozess erweitern Sie nun mit einer Verzweigung. Anhand des Wertes einer Prozessvariablen führt dieser Prozess entweder zu der Benutzeraktivität oder wird direkt beendet.

Hinzufügen einer Verzweigung

Fügen Sie dem Prozess zunächst das BPMN-Element exclusiveGateway hinzu. Das exclusiveGateway-Element repräsentiert eine Verzweigung mit nur einem einzigen möglichen Ausgangspfad. Ersetzen Sie die vorhandenen Sequenzflüsse anschließend mit den folgenden Sequenzflüssen:

   ...
<process id="GettingStarted" name="Example: Getting started" isExecutable="true">
	<startEvent id="start"/>
	<exclusiveGateway id="gateway" default="gw-option-b"/>
    ...
	<exclusiveGateway id="join"/>
    <endEvent id="end"/>       
	<sequenceFlow id="s1" sourceRef="start" targetRef="gateway" />
	<sequenceFlow id="gw-option-a" sourceRef="gateway" targetRef="task_hello_world" />
    <sequenceFlow id="gw-option-b" sourceRef="gateway" targetRef="join" />
    <sequenceFlow id="s2" sourceRef="task_hello_world" targetRef="join" />
    <sequenceFlow id="s3" sourceRef="join" targetRef="end" />
</process> 
...

Erläuterung der Eigenschaften:

  • id: Die Eigenschaft wird als eindeutiger Bezeichner für die Verzweigung verwendet.
  • default: Die Eigenschaft definiert die ID des Sequenzflusses, der als Standard-Ausgangspfad der Verzweigung gewählt werden soll.

Der Prozess sieht dann beispielsweise so aus:

Hinzufügen einer Bedingung

Alle Ausgangspfade einer exklusiven Verzweigung müssen eine Bedingung enthalten. Mithilfe dieser Bedingung ermittelt die Anwendung, welchem Pfad der Prozess folgen soll. Für den Beispielprozess fügen Sie dem Sequenzfluss gw-option-a die Bedingung hinzu, dass dieser Pfad abhängig von der Variable amount gewählt wird. Entspricht diese Variable einem Wert größer 1000, soll der Sequenzfluss gw-option-a gewählt werden.

   ...
<sequenceFlow id="gw-option-a" sourceRef="gateway" targetRef="task_hello_world" > 
	<conditionExpression xsi:type="tFormalExpression">${variables.get("amount") > 1000}</conditionExpression>
<sequenceFlow>
...

Um eine Prozessvariable verwenden zu können, müssen Sie diese der Prozessdefinition hinzufügen. In der Prozessdefinition fügen Sie die BPMN-Elemente extensionElements und camunda:properties zum BPMN-Element process hinzu. Zum Definieren der Prozessvariable fügen Sie dem BPMN-Element camunda:properties noch das Element camunda:property hinzu. In diesem Beispiel fügen Sie die Variable amount vom Typ Number ein.

   ...
<process id="GettingStarted" name="Example: Getting started" isExecutable="true">
	<extensionElements>
      <camunda:properties>
        <camunda:property name="variable:amount" value="Number" />
      </camunda:properties>
    </extensionElements>
...

Die finale BPMN-Definition sieht folgendermaßen aus:

   <?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:camunda="http://camunda.org/schema/1.0/bpmn" targetNamespace="">
  <process id="GettingStarted" name="Example: Getting started" isExecutable="true">
    <extensionElements>
      <camunda:properties>
        <camunda:property name="variable:amount" value="Number" />
      </camunda:properties>
    </extensionElements>
    <startEvent id="start"/>
    <exclusiveGateway id="gateway" default="gw-option-b"/>
    <userTask id='task_hello_world' name='Hello World' >
      <humanPerformer>
          <resourceAssignmentExpression>
              <formalExpression>${variables.get("dv_initiator")}</formalExpression>
          </resourceAssignmentExpression>
      </humanPerformer>
    </userTask>
    <exclusiveGateway id="join"/>
    <endEvent id="end"/>       
    <sequenceFlow id="s1" sourceRef="start" targetRef="gateway" />
    <sequenceFlow id="gw-option-a" sourceRef="gateway" targetRef="task_hello_world" >
      <conditionExpression xsi:type="tFormalExpression">${variables.get("amount") > 1000}</conditionExpression>
    </sequenceFlow>    	
    <sequenceFlow id="gw-option-b" sourceRef="gateway" targetRef="join" />      
    <sequenceFlow id="s2" sourceRef="task_hello_world" targetRef="join" />
    <sequenceFlow id="s3" sourceRef="join" targetRef="end" />
  </process> 
</definitions>

Sie können den Wert der Variablen amount nun zum Beispiel beim Start des Prozesses belegen, und so den Prozessverlauf beeinflussen.

Einfügen von Benutzeraktivitäten

In diesem Thema erhalten Sie grundlegende Informationen über die Verwendung und Anpassung des BPMN-Elements User Task (Benutzeraktivität).

Wissenswertes zu Benutzeraktivitäten

Im BPMN-Standard gibt es zwei unterschiedliche Konstrukte für die Verwendung des BPMN-Elements User Task (Benutzeraktivität). Die Konstrukte unterscheiden sich darin, ob es einen einzigen oder potentiell mehrere Empfänger für eine Aktivität gibt.

Einen einzelnen Empfänger geben Sie als Human Performer an. Wenn Sie mehrere Empfänger für eine Aktivität einplanen, verwenden Sie das Potential Owner-Konstrukt. Mehrere Empfänger geben Sie als Array von Identities (Variable) an.

Beispiel für einen einzelnen Empfänger

Human Performer
   <userTask id='theTask' name='important task' >
    <humanPerformer>
      <resourceAssignmentExpression>
        <formalExpression>${variables.get("myPerformer")}</formalExpression>
      </resourceAssignmentExpression>
    </humanPerformer>
  </userTask>

Beispiel für mehrere Empfänger

Potential Owner
   <userTask id='theTask' name='important task' >
    <potentialOwner>
      <resourceAssignmentExpression>
        <formalExpression>${variables.get("myPotentialOwners")}</formalExpression>
      </resourceAssignmentExpression>
    </potentialOwner>
  </userTask>

Hinweis

In camunda modeler wird das Potential Owner-Konstrukt durch die Felder Candidate Users und Candidate Groups abgebildet. Sie können das Human Performer-Konstrukt durch das Feld Assignee verwenden. Bei diesem Feld können Sie nur einen Benutzer angeben.

Verwenden von Konstanten für Empfänger

Wenn Sie die Empfänger einer Aktivität als Konstante angeben möchten, verwenden Sie folgende Syntax:

   identity:///identityprovider/scim/users/someUserId
// or
${collections.from("identity:///identityprovider/scim/users/someUserId", "identity:///identityprovider/scim/users/someOtherUserId")} 

Verwenden von Variablen für Empfänger

Wenn die Empfänger einer Aktivität aus Variablen ermittelt werden sollen, verwenden Sie folgende Syntax für die Referenzierung der Variablen:

   ${variables.get("variableName")}

Verlinken von Zusatzinformationen zu Benutzeraktivitäten

Um Benutzeraktivitäten Zusatzinformationen für die Bearbeitung hinzuzufügen, können Sie die dafür reservierte Prozessvariable dv_attachment verwenden.

In dieser Variable können Sie eine URL speichern. Die URL wird bei Erstellung einer Aktivität hinzugefügt, wenn Sie sie zuvor eingetragen haben.

Wichtig

Die Prozessvariable dv_attachment ist mit dem Datentyp DmsObject vordefiniert. Möchten Sie eine andere URI als die zu einem Objekt der DMS-App verwenden, müssen Sie den Wert des Datentyps auf String ändern.

Hinzufügen von Benutzeroberflächen zu einer Benutzeraktivität

Wenn Sie bei der Erstellung eines Prozessmodells das BPMN-Element User Task (Benutzeraktivität) verwenden, können Sie der Aktivität eine Benutzeroberfläche hinzufügen. Dem Benutzer wird dann beispielsweise eine Schaltfläche angezeigt, mit der er eine Aufgabe beginnen kann.

Um eine Benutzeroberfläche hinzuzufügen, verwenden sie die Eigenschaft formKey.

Beispiel

Form Key
   <userTask id="someTask" camunda:formKey="uri:/myapp/myform">
  ...
</userTask>

Der Schlüssel besteht aus einem Präfix und einem Wert. Diese werden durch einen Doppelpunkt voneinander getrennt. Folgende Präfixe können verwendet werden:

Präfix

Bedeutung

Beispiel

uriDie Benutzeroberfläche wird über eine URI angegeben.uri:https://example.com/

Verwenden von Prozessvariablen

Der Schlüssel kann auch Prozessvariablen beinhalten. Diese können in Form von Expression Language angegeben werden.

Beispiel

   uri:${variables.get("formUri")}

uri:https://example.com/?queryParam=${variables.get("formParam")}

Externer Zugriff auf Prozessvariablen

Mit dem Ausdruck ${process.task.variablesUri} kann ein URI erzeugt werden, um einer externen Applikation den Zugriff auf die aktuellen Variablen dieser Benutzeroberfläche zu ermöglichen. Mittels der HTTP-Methoden GET und PUT können diese Variablen gelesen und verändert werden. In dieser Bearbeitungsoberfläche muss zu den verwendenden Variablen ein Input- und Output-Mapping definiert sein.

Beispiel

   uri:/myApp?variablesUri=${process.task.variablesUri}


Verwenden von Prozessvariablen in einer Benutzeroberfläche

Enthält eine Benutzeraktivität ein Formular, können Sie mit HTTP lesend und schreibend auf die verwendeten Prozessvariablen zugreifen.

Zum Einstieg in das Arbeiten mit Prozessvariablen in einem Formular ist es hilfreich, wenn Sie zunächst einen einfachen Prozess mit einer Benutzeraktivität erstellen. Dieser Prozess sieht beispielsweise so aus:

   <?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:camunda="http://camunda.org/schema/1.0/bpmn" targetNamespace="">
  <process id="GettingStarted" name="Example: Getting started" isExecutable="true">
    <startEvent id="start"/>
    <userTask id='task_hello_world' name='Hello World' >
      <humanPerformer>
          <resourceAssignmentExpression>
              <formalExpression>${variables.get("dv_initiator")}</formalExpression>
          </resourceAssignmentExpression>
      </humanPerformer>
    </userTask>
    <endEvent id="end"/>       
    <sequenceFlow id="s1" sourceRef="start" targetRef="task_hello_world" />
    <sequenceFlow id="s2" sourceRef="task_hello_world" targetRef="end" />
  </process> 
</definitions>

Zur Vereinfachung sind die grafischen Informationen zum BPMN-Diagramm in dieser BPMN-Beispieldatei nicht enthalten.

Erstellen eines Formulars

Erstellen Sie zunächst eine HTML-Datei. Diese kann wie folgt aussehen. Die Code-Beispiele sind auf die Funktionsweise in Google Chrome ausgerichtet. Andere Browser können möglicherweise eine andere Syntax erfordern.

   <!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Getting started</title>
</head>
<body/>    
</html>

Legen Sie die HTML-Datei so ab, dass sie mit einem Http-Gateway erreichbar ist. Fügen Sie den URI des HTML-Dokuments zum HTML-Element userTask hinzu.

   ...
<process id="GettingStarted" name="Example: Getting started" isExecutable="true">
	...
    <userTask id='task_hello_world' name='Hello World' camunda:formKey="uri:/res/process/process-form.html?variables=${process.task.variablesUri}" >
	...

Erläuterung der Eigenschaft

  • camunda:formKey: In dieser Eigenschaft wird der URI definiert, der die Oberfläche für die Benutzeraktivität bereitstellt. Das Präfix uri: ist dabei verpflichtend. Die Variable ${process.task.variablesUri} wird als Query-Parameter zum URI ergänzt. Die Variable wird von der Anwendung zur Laufzeit in einen URI aufgelöst, der einen HTTP-Endpunkt zum Lesen und Schreiben der Variablen bereitstellt.

Erstellen der Benutzeroberfläche

Erstellen Sie zunächst das Grundgerüst für eine HTML-Tabelle in Ihrem HTML-Dokument. Im späteren Verlauf werden die Variablen dann in dieser Tabelle angezeigt.

   ...
<body>
    <table id="variables">
		<thead>
			<tr>
				<th>Name</th>
				<th>Value</th>
			</tr>
		</thead>
		<tbody id="variableValues">
		</tbody>
	</table>
</body>
...

Abfragen der Prozessvariablen

Im Head des HTML-Dokuments erstellen Sie eine Funktion zum Auslesen der Prozessvariablen. Die Prozessvariablen werden mit einer HTTP-GET-Anforderung entsprechend der Rest-API von der Anwendung abgefragt. Das Laden der Variablen wird durch das onLoad-Event des body-Elements ausgelöst.

   ...
<head>
	...
	<script type="text/javascript">
	
		var urlParams = new URLSearchParams(window.location.search);
		var variablesUri = urlParams.get('variables');
			
		function loadVariables() {
			fetch(variablesUri)
				.then(response => response.json());
		}		
		
	</script>
</head>
<body onload="loadVariables()">
...

Nachdem die Variablen geladen wurden, können Sie diese nun in der vorbereiteten Tabelle anzeigen. Im folgenden Beispiel wird die JavaScript-Bibliothek jQuery verwendet. Fügen Sie im Head des HTML-Dokuments die jQuery-Bibliothek hinzu und implementieren Sie entsprechende Methoden zum Anzeigen der Variablen.

   ...
<head>
	<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.4.0/jquery.min.js"></script>
	<script type="text/javascript">
	
		var urlParams = new URLSearchParams(window.location.search);
		var variablesUri = urlParams.get('variables');
			
		function loadVariables() {
			fetch(variablesUri)
				.then(response => response.json())
				.then(json => createTableFromVariables(json.variables || {}));
		}	
	
		function createTableFromVariables(variables) {
			Object.keys(variables).forEach(variable => {
				var value = variables[variable];
				$('#variableValues').append( `<tr class="variable">${createKeyColumn(variable)}${createValueColumn(value)}</tr>`);
			});
		}
		
		function createKeyColumn(variable) {
			return `<td><span class="key">${variable}</span></td>`;
		}
		
		function createValueColumn(value) {
			return `<td><input class="value" type="text" value="${value}"></td>`;
		}

	</script>
</head>
<body onload="loadVariables()">
...
	

Die Variablen werden nun nach dem Laden des HTML-Dokuments abgefragt und angezeigt.

Schreiben der Prozessvariablen

Fügen Sie in den Skript-Bereich Methoden ein, die das Zurückschreiben der Variablen in die Anwendung ermöglichen. Anschließend fügen Sie einen button unterhalb der Tabelle hinzu, der die Methode saveVariables aufruft.

   ...
<head>
	<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.4.0/jquery.min.js"></script>
	<script type="text/javascript">
	
		var urlParams = new URLSearchParams(window.location.search);
		var variablesUri = urlParams.get('variables');
			
		...
		
		function saveVariables() {
			var variables = createVariablesFromTable();
			
			const headers = new Headers();
			headers.append('Cache-Control', 'no-cache');
			headers.append('Content-Type', 'application/json');

			let promise = fetch(variablesUri, {
				method: 'PUT',
				headers: headers,
				credentials: 'same-origin',
				body: JSON.stringify({variables})
			});

			promise.then(function(response) {
				let status = response.status;
				if (status !== 200 ) {
					window.alert("Saving variables failed: " + status);
				} else {
					window.alert("Variables saved");
				}
				
			});
		}

		function createVariablesFromTable() {
			var variables = {};
			$("tr.variable").each(function() {
				$this = $(this);
				var key = $this.find("span.key").html();
				var value = $this.find("input.value").val();
				variables[key] = value;
			});
			return variables;
		}

	</script>
</head>
<body onload="loadVariables()">
	...
	<br/>
	<button onClick="saveVariables()">Save</button>
</body>

Mithilfe des Formulars, das bei der Ausführung des Prozesses angezeigt wird, können Sie die aktuellen Prozessvariablen anzeigen und ändern.

Das finale HTML-Dokument sieht wie folgt aus. Das HTML-Dokument enthält einige ergänzende CSS-Definitionen zur optimierten Darstellung der Oberflächenelemente.

   <!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Process Form</title>
	<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.4.0/jquery.min.js"></script>
	<style>
		table {
		  border-collapse: collapse;
		  width: 100%;
		}
		
		table, th, td {
		  border: 1px solid black;
		}
		
		td {
		  padding: 3px;
		}
		
		.key {
			color: gray;
		}
		
		th {
		  text-align: left;
		}
		
		input {
			width: 100%;
			border: 0;
		}
	</style>
    <script type="text/javascript">
	
		var urlParams = new URLSearchParams(window.location.search);
		var variablesUri = urlParams.get('variables');
			
		function loadVariables() {
			fetch(variablesUri)
				.then(response => response.json())
				.then(json => createTableFromVariables(json.variables || {}));
		}
		
		function saveVariables() {
			var variables = createVariablesFromTable();
			
			const headers = new Headers();
			headers.append('Cache-Control', 'no-cache');
			headers.append('Content-Type', 'application/json');

			let promise = fetch(variablesUri, {
				method: 'PUT',
				headers: headers,
				credentials: 'same-origin',
				body: JSON.stringify({variables})
			});

			promise.then(function(response) {
				let status = response.status;
				if (status !== 200 ) {
					window.alert("Saving variables failed: " + status);
				} else {
					window.alert("Variables saved");
				}
				
			});
		}
		
		function createTableFromVariables(variables) {
			Object.keys(variables).forEach(variable => {
				var value = variables[variable];
				$('#variableValues').append( `<tr class="variable">${createKeyColumn(variable)}${createValueColumn(value)}</tr>`);
			});
		}
		
		function createKeyColumn(variable) {
			return `<td><span class="key">${variable}</span></td>`;
		}
		
		function createValueColumn(value) {
			return `<td><input class="value" type="text" value="${value}"></td>`;
		}
		
		function createVariablesFromTable() {
			var variables = {};
			$("tr.variable").each(function() {
				$this = $(this);
				var key = $this.find("span.key").html();
				var value = $this.find("input.value").val();
				variables[key] = value;
			});
			return variables;
		}
		
	</script>
</head>
<body onload="loadVariables()">
    <table id="variables">
		<thead>
			<tr>
				<th>Name</th>
				<th>Value</th>
			</tr>
		</thead>
		<tbody id="variableValues">
		</tbody>
	</table>
	<br/>
	<button onClick="saveVariables()">Save</button>
</body>
</html>

Verwenden einer Multi-Instanz

Sie können Mehrfachausführungen zu Benutzeraktivitäten und Subprozessen hinzufügen. Voraussetzung dafür ist, dass die Aktivität oder der Prozess auf einer Variable mit Mehrfachwert basiert. Für jeden Wert der Variable wird eine Ausführung der Aktivität vorgenommen. 

Zum Einstieg in das Arbeiten mit Multi-Instanzen ist es hilfreich, wenn Sie zunächst einen einfachen Prozess mit einer Benutzeraktivität erstellen. Dieser Prozess sieht beispielsweise so aus:

   <?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:camunda="http://camunda.org/schema/1.0/bpmn" targetNamespace="">
  <process id="GettingStarted" name="Example: Getting started" isExecutable="true">
    <startEvent id="start"/>
    <userTask id='task_hello_world' name='Hello World' >
      <humanPerformer>
          <resourceAssignmentExpression>
              <formalExpression>${variables.get("dv_initiator")}</formalExpression>
          </resourceAssignmentExpression>
      </humanPerformer>
    </userTask>
    <endEvent id="end"/>       
    <sequenceFlow id="s1" sourceRef="start" targetRef="task_hello_world" />
    <sequenceFlow id="s2" sourceRef="task_hello_world" targetRef="end" />
  </process> 
</definitions>

Zur Vereinfachung sind die grafischen Informationen zum BPMN-Diagramm in dieser BPMN-Beispieldatei nicht enthalten.

Hinzufügen einer Multi-Instanz

Fügen Sie der Benutzeraktivität das BPMN-Element multiInstanceLoopCharacteristics hinzu. Ändern Sie anschließend die Variable, die den Empfänger der Benutzeraktivität bestimmt, in myPerformer.

   ...
<process id="GettingStarted" name="Example: Getting started" isExecutable="true">
...
	<userTask id='task_hello_world' name='Hello World' >
		<humanPerformer>
        	<resourceAssignmentExpression>
            	<formalExpression>${variables.get("myPerformer")}</formalExpression>
        	</resourceAssignmentExpression>
		</humanPerformer>
	    <multiInstanceLoopCharacteristics
    	    isSequential="false"
        	camunda:collection="${variables.get('performers')}"
	        camunda:elementVariable="myPerformer" >
    	</multiInstanceLoopCharacteristics>
	</userTask>
	...

Erläuterung der Eigenschaften

  • isSequential: Verwenden Sie den Wert true, um die Aktivitäten nacheinander auszuführen und false, um sie gleichzeitig auszuführen.
  • camunda:collection: Ausdruck, der eine Mehrfachvariable zurückgibt.
  • camunda:elementVariable: Variablenname, der lokal für den jeweiligen Wert verwendet wird. Für die Variable muss eine Definition vorhanden sein.

Im Beispielprozess wird für jeden Wert der Variable performers eine Aktivität zugestellt. Mit der lokalen Variable myPerformer kann jedes einzelne Element als Empfänger angegeben werden.

Damit die Variablen performers und myPerformer verwendet werden können, müssen Sie diese definieren. Fügen Sie die BPMN-Elemente extensionElements und camunda:properties zu den BPMN-Elementen process und userTask hinzu. Zum Definieren der Prozessvariablen fügen Sie den BPMN-Elementen camunda:properties noch jeweils das Element camunda:property hinzu.

   ...
<process id="GettingStarted" name="Example: Getting started" isExecutable="true">
	<extensionElements>
    	<camunda:properties>
        	<camunda:property name="variable:performers" value="[Identity]" />
      	</camunda:properties>
    </extensionElements>
	...
	<userTask id='task_hello_world' name='Hello World' >
		<extensionElements>
    		<camunda:properties>
        		<camunda:property name="variable:myPerformer" value="Identity" />
      		</camunda:properties>
    	</extensionElements>
		...

Die finale BPMN-Definition sieht folgendermaßen aus:

   <?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:camunda="http://camunda.org/schema/1.0/bpmn" targetNamespace="">
  <process id="GettingStarted" name="Example: Getting started" isExecutable="true">
    <extensionElements>
        <camunda:properties>
            <camunda:property name="variable:performers" value="[Identity]" />
        </camunda:properties>
    </extensionElements>
    <startEvent id="start"/>
    <userTask id='task_hello_world' name='Hello World' >
      	<extensionElements>
            <camunda:properties>
                <camunda:property name="variable:myPerformer" value="Identity" />
            </camunda:properties>
        </extensionElements>
        <humanPerformer>
            <resourceAssignmentExpression>
                <formalExpression>${variables.get("myPerformer")}</formalExpression>
            </resourceAssignmentExpression>
        </humanPerformer>
        <multiInstanceLoopCharacteristics
            isSequential="false"
            camunda:collection="${variables.get('performers')}"
            camunda:elementVariable="myPerformer" >
        </multiInstanceLoopCharacteristics>
    </userTask>
    <endEvent id="end"/>       
    <sequenceFlow id="s1" sourceRef="start" targetRef="task_hello_world" />
    <sequenceFlow id="s2" sourceRef="task_hello_world" targetRef="end" />
  </process> 
</definitions>

Sie können den Wert der Variablen performers nun zum Beispiel beim Start des Prozesses belegen.

Verwenden von Services

In diesem Thema erfahren Sie, wie Sie Services in Ihre Prozesse einbinden können. Beim Einfügen von Services können Sie sich entscheiden, ob der Service synchron oder asynchron durchgeführt wird.

Verwenden eines synchronen Service

Automatisierte Aktivitäten werden in einem Prozess mithilfe von Services ausgeführt. Für die Verwendung von synchronen Services in BPMN können Sie das BPMN-Element Send Task (Sendenaktiviät) verwenden. Erreicht der Prozess die Sendenaktivität, so werden die im Prozess definierten Daten an den HTTP-Endpunkt des Serviceanbieters geschickt und unmittelbar auf das Ergebnis gewartet. Anschließend wird die Prozessausführung direkt fortgesetzt. Dieser Artikel zeigt Ihnen anhand eines einfachen Beispielservice, wie Sie einen synchronen Service verwenden können. Der Beispielservice "Hello World" wandelt einen beliebigen Text in "Hello <yourname>" um, wobei <yourname> der Text ist, der zuvor an den Service gesendet wurde.

Um dieses Beispiel durchzuführen, ist es hilfreich, wenn Sie zunächst einen einfachen Prozess mit einer Benutzeraktivität erstellen. Das BPMN-Modell dieses beispielhaften Prozesses ist folgendermaßen aufgebaut:

   <?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:camunda="http://camunda.org/schema/1.0/bpmn" targetNamespace="">
  <process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
    <startEvent id="start"/>
    <userTask id="task_hello_world" name="Hello World" >
      <humanPerformer>
          <resourceAssignmentExpression>
              <formalExpression>${variables.get("dv_initiator")}</formalExpression>
          </resourceAssignmentExpression>
      </humanPerformer>
    </userTask>
    <sequenceFlow id="s1" sourceRef="start" targetRef="task_hello_world" />
    <sequenceFlow id="s2" sourceRef="task_hello_world" targetRef="end" />
    <endEvent id="end"/>       
  </process> 
</definitions>

Zur Vereinfachung sind die grafischen Informationen zum BPMN-Diagramm in dieser BPMN-Beispieldatei nicht enthalten.

Hinzufügen einer Sendenaktivität

Fügen Sie zunächst eine Sendenaktivität nach dem Startereignis hinzu. 

   ...
<process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
    <startEvent id="start"/>
	<sendTask id="call_service" 
          name="Call 'Hello world'" 
          camunda:delegateExpression="${syncService}"
		  camunda:asyncBefore="true" 
		  camunda:asyncAfter="true" 
		  camunda:exclusive="false">
	</sendTask>
	...

Erläuterung der Eigenschaften:

  • id: Die Eigenschaft wird als eindeutiger Bezeichner für die Sendenaktivität verwendet.
  • name: Die Eigenschaft wird als Anzeigename in den Benutzeroberflächen verwendet.
  • camunda:*: Diese Eigenschaften beinhalten technische Informationen, die zur Ausführung benötigt werden.

    Hinweis

    Bei synchronen Services müssen Sie für die camunda-Eigenschaften immer die Werte des Beispiels eintragen. Wenn Sie abweichende Werte eintragen, kann der Prozess nicht bereitgestellt werden.

Fügen Sie nun der Sendenaktivität die BPMN-Elemente extensionElements und camunda:inputOutput hinzu. Sie müssen alle Daten definieren, die an den HTTP-Endpunkt des Services gesendet werden sollen. Zur Definition der Daten fügen Sie für jeden Wert das BPMN-Element camunda:inputParameter in die Prozessdefinition ein. Anschließend müssen Sie auch die erwarteten Ausgabewerte definieren. Fügen Sie hierzu für jeden Wert das BPMN-Element camunda:outputParameter in die Prozessdefinition ein.

   ...
<process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
    <startEvent id="start"/>
	<sendTask id="call_service" 
		...>
		<extensionElements>
		    <camunda:inputOutput>
	        	<camunda:inputParameter name="service.uri">/process/services/helloworld/sync</camunda:inputParameter>
      			<camunda:inputParameter name="yourName">${variables.getDisplayValue("dv_initiator")}</camunda:inputParameter>
	        	<camunda:outputParameter name="greeting">${variables.get("greeting")}</camunda:outputParameter>
    		</camunda:inputOutput>
  		</extensionElements>
	</sendTask>
	...

Erläuterung der Parameter:

  • service.uri: Dieser Parameter muss immer eingefügt werden. Er definiert den URI, unter dem der HTTP-Endpunkt des Services erreichbar ist. Das Beispiel zeigt den URI des "Hello World"-Services. Der Wert dieser Variablen muss eine Konstante sein, das heißt er darf keine Ausdrücke enthalten.
  • yourName: Dieser Parameter wurde vom konkreten Service als Eingabewert definiert. In diesem Beispiel wird der Anzeigename des Benutzers verwendet, der den Prozess gestartet hat. 
  • greeting: Der Service hat als einzigen Ausgabewert den Parameter greeting definiert. Dieser Parameter wird bei der Antwort des Services automatisch in eine gleichnamige Variable im Geltungsbereich der Sendenaktivität geschrieben. Der Parameter definiert, dass der Inhalt dieses Ergebniswertes bei Fortführung des Prozesses in die Variable greeting im Geltungsbereich des gesamten Prozesses geschrieben wird. 

Um die Kommunikation zwischen der Anwendung und dem Service zu ermöglichen, müssen Sie die Schnittstelle des Services zum Prozess hinzufügen. Zum Hinzufügen der Schnittstelle tragen Sie die BPMN-Elemente extensionElements und camunda:properties in die Prozessdefinition ein. Anschließend fügen Sie je ein BPMN-Element camunda:property für den Service-Eingabewert yourName, den Service-Ausgabewert greeting, sowie die resultierende Prozessvariable greeting ein. Alle Werte sind vom Datentyp String.

   <process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
    <extensionElements>
      <camunda:properties>
        <camunda:property name="service:/process/services/helloworld/sync:in:yourName" value="String" />
        <camunda:property name="service:/process/services/helloworld/sync:out:greeting" value="String" />

        <camunda:property name="variable:greeting" value="String" />
      </camunda:properties>
    </extensionElements>
    ...
</process>

Die Variable greeting enthält nun den Text "Hello <display name of process start user>". Verwenden Sie diese Variable nun als Namen für die Benutzeraktivität, damit der Anwender den freundlichen Gruß als Betreff der zu erledigenden Aufgabe erhält. 

   <process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
    ...
    <userTask id="task_hello_world" name="${variables.get('greeting')}">
        ...
    </userTask>
    ...

Damit die Prozessaktivitäten in der richtigen Reihenfolge ausgeführt werden, müssen Sie die Sequenzflusselemente noch an die neuen Aktivitäten anpassen. 

   <process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
    ...
    </userTask>
	<sequenceFlow id="s1" sourceRef="start" targetRef="call_service" />
    <sequenceFlow id="s2" sourceRef="call_service" targetRef="task_hello_worldr" />
    <sequenceFlow id="s3" sourceRef="task_hello_world" targetRef="end" />
    ...

Die finale BPMN-Definition sieht folgendermaßen aus:

   <?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:camunda="http://camunda.org/schema/1.0/bpmn" targetNamespace="">
  <process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
    <extensionElements>
      <camunda:properties>
        <camunda:property name="service:/process/services/helloworld/sync:in:yourName" value="String" />
        <camunda:property name="service:/process/services/helloworld/sync:out:greeting" value="String" />
        <camunda:property name="variable:greeting" value="String" />
      </camunda:properties>
    </extensionElements>   
    <startEvent id="start"/>
    <sendTask id="call_service" 
      name="Call 'Hello world'" 
      camunda:delegateExpression="${syncService}"
		  camunda:asyncBefore="true" 
		  camunda:asyncAfter="true" 
		  camunda:exclusive="false">
      <extensionElements>
		    <camunda:inputOutput>
	        	<camunda:inputParameter name="service.uri">/process/services/helloworld/sync</camunda:inputParameter>
      			<camunda:inputParameter name="yourName">${variables.getDisplayValue("dv_initiator")}</camunda:inputParameter>
	        	<camunda:outputParameter name="greeting">${variables.get("greeting")}</camunda:outputParameter>
    		</camunda:inputOutput>
  		</extensionElements>
		</sendTask>
    <userTask id="task_hello_world" name="${variables.get('greeting')}" >
      <humanPerformer>
          <resourceAssignmentExpression>
              <formalExpression>${variables.get("dv_initiator")}</formalExpression>
          </resourceAssignmentExpression>
      </humanPerformer>
    </userTask>
    <sequenceFlow id="s1" sourceRef="start" targetRef="call_service" />
    <sequenceFlow id="s2" sourceRef="call_service" targetRef="task_hello_world" />
    <sequenceFlow id="s3" sourceRef="task_hello_world" targetRef="end" />
    <endEvent id="end"/>       
  </process> 
</definitions>

Verwenden eines asynchronen Service

Automatisierte Aktivitäten werden in einem Prozess mithilfe von Services ausgeführt. Für die Verwendung von asynchronen Services in BPMN können Sie die BPMN-Elemente Send Task (Sendenaktivität) und Receive Task (Empfangenaktiviät) verwenden. Erreicht der Prozess die Sendenaktivität, so werden die im Prozess definierten Daten an den HTTP-Endpunkt des Serviceanbieters geschickt. Anschließend wird die Prozessausführung so lange pausiert, bis der Serviceanbieter das Ergebnis der Verarbeitung zurückmeldet. Dieser Artikel zeigt Ihnen anhand eines einfachen Beispielservice, wie Sie einen asynchronen Service verwenden können. Der Beispielservice "Hello World" wandelt einen beliebigen Text in "Hello <yourname>" um, wobei <yourname> der Text ist, der zuvor an den Service gesendet wurde.

Um dieses Beispiel durchzuführen, ist es hilfreich, wenn Sie zunächst einen einfachen Prozess mit einer Benutzeraktivität erstellen. Das BPMN-Modell dieses beispielhaften Prozesses ist folgendermaßen aufgebaut:

   <?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:camunda="http://camunda.org/schema/1.0/bpmn" targetNamespace="">
  <process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
    <startEvent id="start"/>
    <userTask id="task_hello_world" name="Hello World" >
      <humanPerformer>
          <resourceAssignmentExpression>
              <formalExpression>${variables.get("dv_initiator")}</formalExpression>
          </resourceAssignmentExpression>
      </humanPerformer>
    </userTask>
    <sequenceFlow id="s1" sourceRef="start" targetRef="task_hello_world" />
    <sequenceFlow id="s2" sourceRef="task_hello_world" targetRef="end" />
    <endEvent id="end"/>       
  </process> 
</definitions>

Zur Vereinfachung sind die grafischen Informationen zum BPMN-Diagramm in dieser BPMN-Beispieldatei nicht enthalten.

Hinzufügen einer Sendenaktivität

Fügen Sie zunächst eine Sendenaktivität nach dem Startereignis hinzu. 

   ...
<process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
    <startEvent id="start"/>
	<sendTask id="call_service" 
          name="Call 'Hello world'" 
          camunda:delegateExpression="${asyncService}"
		  camunda:asyncBefore="true" 
		  camunda:exclusive="false">
	</sendTask>
	...

Erläuterung der Eigenschaften:

  • id: Die Eigenschaft wird als eindeutiger Bezeichner für die Sendenaktivität verwendet.
  • name: Die Eigenschaft wird als Anzeigename in den Benutzeroberflächen verwendet.
  • camunda:*: Diese Eigenschaften beinhalten technische Informationen, die zur Ausführung benötigt werden.

    Hinweis

    Bei asynchronen Services müssen Sie für die camunda-Eigenschaften immer die Werte des Beispiels eintragen. Wenn Sie abweichende Werte eintragen, kann der Prozess nicht bereitgestellt werden.

Fügen Sie nun der Sendenaktivität die BPMN-Elemente extensionElements und camunda:inputOutput hinzu. Sie müssen alle Daten definieren, die an den HTTP-Endpunkt des Services gesendet werden sollen. Zur Definition der Daten fügen Sie für jeden Wert das BPMN-Element camunda:inputParameter in die Prozessdefinition ein.

   ...
<process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
    <startEvent id="start"/>
	<sendTask id="call_service" 
		...>
		<extensionElements>
		    <camunda:inputOutput>
	        	<camunda:inputParameter name="service.uri">/process/services/helloworld/async</camunda:inputParameter>
      			<camunda:inputParameter name="yourName">${variables.getDisplayValue("dv_initiator")}</camunda:inputParameter>
    		</camunda:inputOutput>
  		</extensionElements>
	</sendTask>
	...

Erläuterung der Parameter:

  • service.uri: Dieser Parameter muss immer eingefügt werden. Er definiert den URI, unter dem der HTTP-Endpunkt des Services erreichbar ist. Das Beispiel zeigt den URI des "Hello World"-Services. Der Wert dieser Variablen muss eine Konstante sein, das heißt er darf keine Ausdrücke enthalten.
  • yourName: Dieser Parameter wurde vom konkreten Service als Eingabewert definiert. In diesem Beispiel wird der Anzeigename des Benutzers verwendet, der den Prozess gestartet hat. 

Hinzufügen einer Empfangenaktivität

Fügen Sie der Prozessdefinition nun die Empfangenaktivität hinzu. Mithilfe der Empfangenaktivität können die verarbeiteten Daten vom Service an den Prozess übermittelt werden.

   ...
<process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
	...
	</sendTask>
	<receiveTask id="receive_service_answer"
			 name="Wait for 'Hello world'"
	         camunda:asyncAfter="true">
	</receiveTask>
	...

Erläuterung der Eigenschaften:

  • id: Die Eigenschaft wird als eindeutiger Bezeichner für die Sendenaktivität verwendet.
  • name: Die Eigenschaft wird als Anzeigename in den Benutzeroberflächen verwendet.
  • camunda:*: Diese Eigenschaften beinhalten technische Informationen, die zur Ausführung benötigt werden. Bei asynchronen Services müssen Sie für die Eigenschaft camunda:asyncAfter immer den Wert true eintragen.

Fügen Sie der Empfangenaktivität die BPMN-Elemente extensionElements und camunda:inputOutput hinzu. Sie müssen alle Daten definieren, die vom HTTP-Endpunkt des Services als Antwort erwartet werden. Zur Definition der Daten fügen Sie für jeden Wert das BPMN-Element camunda:outputParameter ein.

   ...
<process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
	...
	</sendTask>
	<receiveTask id="receive_service_answer"
			 name="Wait for 'Hello world'"
	         camunda:asyncAfter="true">
		<extensionElements>
		    <camunda:inputOutput>
	        	<camunda:outputParameter name="greeting">${variables.get("greeting")}</camunda:outputParameter>
    		</camunda:inputOutput>
  		</extensionElements>
	</receiveTask>
	...

Erläuterung der Parameter:

  • greeting: Der Service hat als einzigen Ausgabewert den Parameter greeting definiert. Dieser Parameter wird bei der Antwort des Services automatisch in eine gleichnamige Variable im Geltungsbereich der Empfangenaktivität geschrieben. Der Parameter definiert, dass der Inhalt dieses Ergebniswertes bei Fortführung des Prozesses in die Variable greeting im Geltungsbereich des gesamten Prozesses geschrieben wird. 

Um die Kommunikation zwischen der Anwendung und dem Service zu ermöglichen, müssen Sie die Schnittstelle des Services zum Prozess hinzufügen. Zum Hinzufügen der Schnittstelle tragen Sie die BPMN-Elemente extensionElements und camunda:properties in die Prozessdefinition ein. Anschließend fügen Sie je ein BPMN-Element camunda:property für den Service-Eingabewert yourName, den Service-Ausgabewert greeting, sowie die resultierende Prozessvariable greeting ein. Alle Werte sind vom Datentyp String.

   <process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
    <extensionElements>
      <camunda:properties>
        <camunda:property name="service:/process/services/helloworld/async:in:yourName" value="String" />
        <camunda:property name="service:/process/services/helloworld/async:out:greeting" value="String" />

        <camunda:property name="variable:greeting" value="String" />
      </camunda:properties>
    </extensionElements>
    ...
</process>

Die Variable greeting enthält nun den Text "Hello <display name of process start user>". Verwenden Sie diese Variable nun als Namen für die Benutzeraktivität, damit der Anwender den freundlichen Gruß als Betreff der zu erledigenden Aufgabe erhält. 

   <process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
    ...
    <userTask id="task_hello_world" name="${variables.get('greeting')}">
        ...
    </userTask>
    ...

Damit die Prozessaktivitäten in der richtigen Reihenfolge ausgeführt werden, müssen Sie die Sequenzflusselemente noch an die neuen Aktivitäten anpassen. 

   <process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
    ...
    </userTask>
	<sequenceFlow id="s1" sourceRef="start" targetRef="call_service" />
    <sequenceFlow id="s2" sourceRef="call_service" targetRef="receive_service_answer" />
    <sequenceFlow id="s3" sourceRef="receive_service_answer" targetRef="task_hello_world" />
    <sequenceFlow id="s4" sourceRef="task_hello_world" targetRef="end" />
    ...

Die finale BPMN-Definition sieht folgendermaßen aus:

   <?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:camunda="http://camunda.org/schema/1.0/bpmn" targetNamespace="">
  <process id="GettingStarted" name="Beispiel: Einstieg" isExecutable="true">
    <extensionElements>
      <camunda:properties>
        <camunda:property name="service:/process/services/helloworld/async:in:yourName" value="String" />
        <camunda:property name="service:/process/services/helloworld/async:out:greeting" value="String" />

        <camunda:property name="variable:greeting" value="String" />
      </camunda:properties>
    </extensionElements>
    
    <startEvent id="start"/>
    <sendTask id="call_service" 
          name="Call 'Hello world'" 
          camunda:delegateExpression="${asyncService}"
		  camunda:asyncBefore="true" 
		  camunda:exclusive="false">
      <extensionElements>
		    <camunda:inputOutput>
	        	<camunda:inputParameter name="service.uri">/process/services/helloworld/async</camunda:inputParameter>
      			<camunda:inputParameter name="yourName">${variables.getDisplayValue("dv_initiator")}</camunda:inputParameter>
    		</camunda:inputOutput>
  		</extensionElements>
		</sendTask>
    <receiveTask id="receive_service_answer"
			name="Wait for 'Hello world'"
	    camunda:asyncAfter="true">
      <extensionElements>
		    <camunda:inputOutput>
	        	<camunda:outputParameter name="greeting">${variables.get("greeting")}</camunda:outputParameter>
    		</camunda:inputOutput>
  		</extensionElements>
		</receiveTask>
    <userTask id="task_hello_world" name="${variables.get('greeting')}" >
      <humanPerformer>
          <resourceAssignmentExpression>
              <formalExpression>${variables.get("dv_initiator")}</formalExpression>
          </resourceAssignmentExpression>
      </humanPerformer>
    </userTask>
    <endEvent id="end"/>       
    <sequenceFlow id="s1" sourceRef="start" targetRef="call_service" />
    <sequenceFlow id="s2" sourceRef="call_service" targetRef="receive_service_answer" />
    <sequenceFlow id="s3" sourceRef="receive_service_answer" targetRef="task_hello_world" />
    <sequenceFlow id="s4" sourceRef="task_hello_world" targetRef="end" />
  </process> 
</definitions>

Häufig gestellte Fragen

Sie finden in diesem Thema Antworten zu häufig gestellten Fragen. 

Warum tritt beim Einfügen einer Variablen ein unbekannter Serverfehler auf?

Wenn Sie eine Prozessvariable einfügen wollen, die bereits in einer anderen Groß-/Kleinschreibung existiert, kann es zu einem Fehler kommen. Der Fehler tritt auf, wenn die Sortierung der Datenbank die Groß-/Kleinschreibung nicht beachtet und somit nicht zwischen den beiden Variablen unterscheiden kann.

Zur Vermeidung des Fehlers verwenden Sie beim Einfügen einer Variablen die bereits verwendete Groß-/Kleinschreibung.

Wo finde ich eine Übersicht über alle Aktionen?

Wenn Sie im Feature Prozessadministration in die Perspektive Aktionsübersicht wechseln, erhalten Sie einen Überblick über alle laufenden, gestarteten, abgeschlossenen und fehlgeschlagenen Aktionen. Mit dem Papierkorb-Symbol können Sie abgeschlossene und fehlerhafte Aktionen manuell aus dem Protokoll entfernen.