automatic import of python-robotframework-processcubeopeneuler20.03

3 files changed, 1339 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
index e69de29..3108f73 100644
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1 @@
+/robotframework-processcube-2.1.0.tar.gz
diff --git a/python-robotframework-processcube.spec b/python-robotframework-processcube.spec
new file mode 100644
index 0000000..f8973d7
--- /dev/null
+++ b/python-robotframework-processcube.spec
@@ -0,0 +1,1337 @@
+%global _empty_manifest_terminate_build 0
+Name:		python-robotframework-processcube
+Version:	2.1.0
+Release:	1
+Summary:	Robot Framework Keywords for processcube workflow engine.
+License:	MIT Licence
+URL:		https://github.com/atlas-engine-contrib/robotframework-processcube
+Source0:	https://mirrors.nju.edu.cn/pypi/web/packages/f4/59/21fa460ffbb7e9f162c3cc13d5efa8db867cfc69b2cbc8c787963a478e30/robotframework-processcube-2.1.0.tar.gz
+BuildArch:	noarch
+
+Requires:	python3-atlas-engine-client
+Requires:	python3-docker
+Requires:	python3-requests
+Requires:	python3-robotframework
+Requires:	python3-six
+
+%description
+# Verwendung des Robot Framework mit der 5Minds-Engine
+
+- [Voraussetzung](#voraussetzung)
+- [Verwendung](#verwendung)
+  * [Allgmeine Informatione](#allgemeine-informationen)
+  * [Info von der 5Minds-Engine abrufen](#info-von-der-5minds-engine-abrufen)
+  * [BPMN-Datei in 5Minds-Engine laden](#bpmn-datei-in-5minds-engine-laden)
+  * [Prozessmodell starten](#prozessmodell-starten)
+  * [Ergebnisse von beendeten Prozessen abfragen](#ergebnisse-von-beendeten-prozessen-abfragen)
+  * [Verarbeiten von Aktivitäten](#verarbeiten-von-aktivitaten)
+    + [Umgang mit External-Tasks](#umgang-mit-external-tasks)
+    + [Umgang mit Benutzer-Tasks (User-Tasks)](#umgang-mit-benutzer-tasks-user-tasks)
+    + [Umgang mit manuellen Tasks (Manual-Tasks)](#umgang-mit-manuellen-tasks-manual-tasks)
+    + [Umgang mit untypisierten Tasks (Empty-Tasks)](#umgang-mit-untypisierten-tasks-empty-tasks)
+  * [Umgang mit Ereignissen (Events)](#umgang-mit-ereignissen-events)
+    + [Signale](#signale)
+    + [Nachrichten (Messages)](#nachrichten-messages)
+    
+## Voraussetzung
+
+Um Tests auf Basis der [Robot Framework](https://robotframework.org/) für die BPMN-basierte-Workflowengine
+[5Minds-Engine](https://www.5minds.de/processcube/) zu erstellen, sind folgende Voraussetzung erforderlich:
+- 5Minds-Studio in der stabilen Version ist installiert
+- 5Minds-Studio ist gestartet
+- 5Minds-Engine ist durch das Studio auf dem Port `56000`gestartet
+
+Alternative kann Docker für die 5Minds-Engine verwendet werden, dann sind folgende Vorausetzungen notwendig:
+- Docker-Desktop ist installiert und gestartet
+- Zugang zum Internet für den Download des Image [5minds/atlas_engine_fullstack_server](https://hub.docker.com/r/5minds/atlas_engine_fullstack_server)
+
+Für die Ausführung von Tests ist dann noch folgende Voraussetzung notwendig:
+- Python in der Version `>=3.7.x` ist installiert und im Pfad konfiguriert
+- Robot-Framework für die 5Minds-Engine ist installiert `pip install robotframework-processcube`
+
+Für die Bearbeitung ist [VS Code](https://code.visualstudio.com/) und der [Robot Framework Language Server](https://marketplace.visualstudio.com/items?itemName=robocorp.robotframework-lsp) hilfreich.
+
+## Verwendung
+
+Um die *Keywords* für die Interaktion mit der 5Minds-Engine verwenden zu können, ist die 
+Library ProcessCubeLibrary einzubinden.
+Für die Verwendung mit dem 5Minds-Studio (ohne Docker) ist die URL für die Engine mit
+dem Paramter `engine_url` zu konfiguieren, dies ist für die stabile Version der
+Studio-Engine `http://localhost:56000`.
+
+Mit dem 5Minds-Studio ist folgende Verwendung zu verwenden.
+```robotframework
+*** Settings ***
+Library         ProcessCubeLibrary     engine_url=http://localhost:56000
+
+```
+
+Für die weiteren Beispiele wird Docker verwendet und dann ist folgende Einstellung zu ändern:
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+```
+
+Die Engine im Docker-Container wird standardmäßig mit dem Port `55000` gestartet. Die URL zum
+Einbinden ins Studio ist also `http://localhost:55000`.
+
+
+### Allgmeine Informationen
+
+Um den Aufruf der nachfolgenden Keywords gegenüber Fehlern etwas robuster zu gestalten, kann global oder bei jeden Keyword
+gesteuert werden:
+- max_retries: Anzahl der Wiederholungen, bevor ein Keyword abgebrochen wird.
+- delay: Verzögerung in Sekunden, die zwischen den Wiederholungen gewartet wird.
+- backoff_factor: Faktor, mit dem die Wiederholungszeit vergrößert wird.
+
+### Info von der 5Minds-Engine abrufen
+
+Um zwei verschiedene Engines gleichzeitig verwenden zu können, kann die Verwendung der Library mit `WITH NAME <ein Name>`
+benannt werden. Danach ist die Verwendung der Keywords mit einem entsprechenenden Namen zu konkretisieren.
+
+Im folgenden Beispiel wird `Get Engine Info` einmal für die `Engine01` und einmal für die `Engine02` abgerufen.
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+
+*** Settings ***
+Library         ProcessCubeLibrary    self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}    WITH NAME    Engine01
+Library         ProcessCubeLibrary    self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}    WITH NAME    Engine02
+
+*** Tasks ***
+Engine info from Engine01
+    ${INFO}=    Engine01.Get Engine Info
+    Log    ${INFO}
+
+
+Engine info from Engine02
+    ${INFO}=    Engine02.Get Engine Info
+    Log    ${INFO}
+```
+
+
+### BPMN-Datei in 5Minds-Engine laden
+
+Zuerst ist ein BPMN-Diagram (z.B. [`processes/hello_minimal.bpmn`](processes/hello_minimal.bpmn) zu erstellen.
+
+Mit dem Keyword `Deploy Processmodel` und der Angabe des Dateipfades wird das BPMN-Diagram in die 5Minds-Engine geladen.
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_minimal.bpmn
+```
+
+### Prozessmodell starten
+
+Wie unter [BPMN-Datei in 5Minds-Engine laden](#bpmn-datei-in-5minds-engine-laden) beschrieben, muss die BPMN-Datei
+vorhanden sein.
+
+Mit dem Keyword `Start Processmodel` und der Angabe der Process ID `hello_minimal` wird eine Prozessinstanz gestartet.
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library    Process
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_minimal.bpmn
+
+Start process model
+    Start Processmodel     hello_minimal
+```
+
+### Ergebnisse von beendeten Prozessen abfragen
+
+Nachdem der Prozess gestartet wurde, kann mit dem Keyword `Get Processinstance Result` das Ergebnis
+der Prozessinstanz abgefragt werden.
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+${CORRELATION}               -1
+
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library         Collections
+
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_minimal.bpmn
+
+Start process model
+    &{PAYLOAD}=              Create Dictionary     foo=bar    hello=world
+    ${PROCESS_INSTANCE}=     Start Processmodel    hello_minimal    ${PAYLOAD}
+    Set Suite Variable       ${CORRELATION}        ${PROCESS_INSTANCE.correlation_id}
+    Log                      ${CORRELATION}
+
+Get the process instance
+    ${RESULT}                Get Processinstance Result            correlation_id=${CORRELATION}
+    Log                      ${RESULT}
+```
+
+### Verarbeiten von Aktivitäten
+
+#### Umgang mit untypisierten Tasks (Empty-Tasks)
+
+Um bei der Entwicklung von Aktivitäten mit noch untypisierten Tasks 
+zu beginnen, stehen die Keywords `Get Empty Task By` fürs Laden und 
+`Finish Empty Task` zum Abschließen zur Verfügung.
+
+Für diesen Test wird eine andere BPMN-Datei verwendet `hello_empty_task.bpmn`.
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+${CORRELATION}               -1
+
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library         Collections
+
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_empty_task.bpmn
+
+Start process model
+    &{PAYLOAD}=              Create Dictionary     foo=bar    hello=world
+    ${PROCESS_INSTANCE}=     Start Processmodel    hello_empty_task    ${PAYLOAD}
+    Set Suite Variable       ${CORRELATION}        ${PROCESS_INSTANCE.correlation_id}
+    Log                      ${CORRELATION}
+
+Handle empty task by correlation_id
+    Log                      ${CORRELATION}
+    ${EMPTY_TASK}            Get Empty Task By                     correlation_id=${CORRELATION}
+    Log                      ${EMPTY_TASK.empty_task_instance_id}
+    Finish Empty Task        ${EMPTY_TASK.empty_task_instance_id}
+
+
+Get the process instance
+    ${RESULT}                Get Processinstance Result            correlation_id=${CORRELATION}
+    Log                      ${RESULT}
+```
+
+#### Umgang mit manuellen Tasks (Manual-Tasks)
+
+Als Basis für den Umgang mit manuellen Task wird die BPMN-Datei 
+`hello_manual_task.bpmn` benötigt.
+
+Für das Laden vom manuellen Taak dient das Keyword `Get Manual Task By` und 
+für das Beenden `Finish Manual Task`.
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+${CORRELATION}               -1
+
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library         Collections
+
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_manual_task.bpmn
+
+Start process model
+    &{PAYLOAD}=              Create Dictionary     foo=bar    hello=world
+    ${PROCESS_INSTANCE}=     Start Processmodel    hello_manual_task    ${PAYLOAD}
+    Set Suite Variable       ${CORRELATION}        ${PROCESS_INSTANCE.correlation_id}
+    Log                      ${CORRELATION}
+
+Handle manual task by correlation_id
+    Log                      ${CORRELATION}
+    ${MANUAL_TASK}           Get Manual Task By                     correlation_id=${CORRELATION}
+    Log                      ${MANUAL_TASK.manual_task_instance_id}
+    Finish Manual Task       ${MANUAL_TASK.manual_task_instance_id}
+
+
+Get the process instance
+    ${RESULT}                Get Processinstance Result            correlation_id=${CORRELATION}
+    Log                      ${RESULT}
+```
+
+#### Umgang mit Benutzer-Tasks (User-Tasks)
+
+Um den Umgang mit Benutzer-Task zu testen ist die BPMN-Datei `hello_user_task.bpmn` notwendig.
+
+Mit dem Keyword `Get User Task By` können User-Tasks geladen und 
+mit dem Keyword `Finish User Task` beendet werden.
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+${CORRELATION}               -1
+
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library         Collections
+
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_user_task.bpmn
+
+Start process model
+    &{PAYLOAD}=              Create Dictionary     foo=bar    hello=world
+    ${PROCESS_INSTANCE}=     Start Processmodel    hello_user_task    ${PAYLOAD}
+    Set Suite Variable       ${CORRELATION}        ${PROCESS_INSTANCE.correlation_id}
+    Log                      ${CORRELATION}
+
+Handle User Task by correlation_id
+    Log                      ${CORRELATION}
+    ${USER_TASK}             Get User Task By                      correlation_id=${CORRELATION}
+    Log                      ${USER_TASK}
+    Should Not Be Empty      ${USER_TASK.user_task_instance_id}
+    Should Be Equal          ${USER_TASK.process_model_id}         hello_user_task
+
+    &{ANSWER}=               Create Dictionary                     field_01=from user task    
+    Finish User Task         ${USER_TASK.user_task_instance_id}    ${ANSWER}
+
+
+Get the process instance
+    ${RESULT}                Get Processinstance Result            correlation_id=${CORRELATION}
+    Log                      ${RESULT}
+```
+
+#### Umgang mit External-Tasks
+
+Um den Umgang mit External-Task zu testen ist die BPMN-Datei `hello_external_task.bpmn` notwendig.
+
+Mit dem Keyword `Get External Task` können User-Tasks geladen und 
+mit dem Keyword `Finish External Task` beendet werden.
+
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+${CORRELATION}               -1
+
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library         Collections
+
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_external_task.bpmn
+
+Start process model
+    &{PAYLOAD}=              Create Dictionary     foo=bar    hello=world
+    ${PROCESS_INSTANCE}=     Start Processmodel    hello_external_task    ${PAYLOAD}
+    Set Suite Variable       ${CORRELATION}        ${PROCESS_INSTANCE.correlation_id}
+    Log                      ${CORRELATION}
+
+Handle External Task
+    ${TASK}                  Get External Task                     topic=doExternal
+    &{ANSWER}=               Create Dictionary                     external_field_01=The Value of field 1
+    Log                      ${TASK.id}
+    Finish External Task     ${TASK.id}                            ${ANSWER}
+
+
+Get the process instance
+    ${RESULT}                Get Processinstance Result            correlation_id=${CORRELATION}
+    Log                      ${RESULT}
+```
+
+### Umgang mit Ereignissen (Events)
+
+Beim Umgang mit Ereignissen, muss zwischen Signalen und Nachrichten unterschieden werden.
+
+#### Signale
+
+Um mit Ereignissen der BPMN-Module zu interagieren, muss die BPMN-Datei 
+`hello_signal.bpmn` verwendet werden.
+
+Das Keyword für das Auslösen von Signale ist `Send Signal`.
+
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+${CORRELATION}               -1
+
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library         Collections
+
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_signal.bpmn
+
+Start process model
+    &{PAYLOAD}=              Create Dictionary     foo=bar    hello=world
+    ${PROCESS_INSTANCE}=     Start Processmodel    hello_signal    ${PAYLOAD}
+    Set Suite Variable       ${CORRELATION}        ${PROCESS_INSTANCE.correlation_id}
+    Log                      ${CORRELATION}
+
+Send Signal
+    Send Signal              catch_signal                           delay=0.2     
+
+
+Get the process instance
+    ${RESULT}                Get Processinstance Result            correlation_id=${CORRELATION}
+    Log                      ${RESULT}
+```
+
+#### Nachrichten (Messages)
+
+Um mit Ereignissen der BPMN-Module zu interagieren, muss die BPMN-Datei 
+`hello_message.bpmn` verwendet werden.
+
+Das Keyword für das Auslösen von Signale ist `Send Message`.
+
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+${CORRELATION}               -1
+
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library         Collections
+
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_message.bpmn
+
+Start process model
+    &{PAYLOAD}=              Create Dictionary     foo=bar    hello=world
+    ${PROCESS_INSTANCE}=     Start Processmodel    hello_message    ${PAYLOAD}
+    Set Suite Variable       ${CORRELATION}        ${PROCESS_INSTANCE.correlation_id}
+    Log                      ${CORRELATION}
+
+Send Message
+    &{PAYLOAD}=              Create Dictionary        message_field1=Value field 1    message_field2=Value field 2
+    Send Message             catch_message            ${PAYLOAD}                      delay=0.5
+
+
+Get the process instance
+    ${RESULT}                Get Processinstance Result            correlation_id=${CORRELATION}
+    Log                      ${RESULT}
+```
+
+
+%package -n python3-robotframework-processcube
+Summary:	Robot Framework Keywords for processcube workflow engine.
+Provides:	python-robotframework-processcube
+BuildRequires:	python3-devel
+BuildRequires:	python3-setuptools
+BuildRequires:	python3-pip
+%description -n python3-robotframework-processcube
+# Verwendung des Robot Framework mit der 5Minds-Engine
+
+- [Voraussetzung](#voraussetzung)
+- [Verwendung](#verwendung)
+  * [Allgmeine Informatione](#allgemeine-informationen)
+  * [Info von der 5Minds-Engine abrufen](#info-von-der-5minds-engine-abrufen)
+  * [BPMN-Datei in 5Minds-Engine laden](#bpmn-datei-in-5minds-engine-laden)
+  * [Prozessmodell starten](#prozessmodell-starten)
+  * [Ergebnisse von beendeten Prozessen abfragen](#ergebnisse-von-beendeten-prozessen-abfragen)
+  * [Verarbeiten von Aktivitäten](#verarbeiten-von-aktivitaten)
+    + [Umgang mit External-Tasks](#umgang-mit-external-tasks)
+    + [Umgang mit Benutzer-Tasks (User-Tasks)](#umgang-mit-benutzer-tasks-user-tasks)
+    + [Umgang mit manuellen Tasks (Manual-Tasks)](#umgang-mit-manuellen-tasks-manual-tasks)
+    + [Umgang mit untypisierten Tasks (Empty-Tasks)](#umgang-mit-untypisierten-tasks-empty-tasks)
+  * [Umgang mit Ereignissen (Events)](#umgang-mit-ereignissen-events)
+    + [Signale](#signale)
+    + [Nachrichten (Messages)](#nachrichten-messages)
+    
+## Voraussetzung
+
+Um Tests auf Basis der [Robot Framework](https://robotframework.org/) für die BPMN-basierte-Workflowengine
+[5Minds-Engine](https://www.5minds.de/processcube/) zu erstellen, sind folgende Voraussetzung erforderlich:
+- 5Minds-Studio in der stabilen Version ist installiert
+- 5Minds-Studio ist gestartet
+- 5Minds-Engine ist durch das Studio auf dem Port `56000`gestartet
+
+Alternative kann Docker für die 5Minds-Engine verwendet werden, dann sind folgende Vorausetzungen notwendig:
+- Docker-Desktop ist installiert und gestartet
+- Zugang zum Internet für den Download des Image [5minds/atlas_engine_fullstack_server](https://hub.docker.com/r/5minds/atlas_engine_fullstack_server)
+
+Für die Ausführung von Tests ist dann noch folgende Voraussetzung notwendig:
+- Python in der Version `>=3.7.x` ist installiert und im Pfad konfiguriert
+- Robot-Framework für die 5Minds-Engine ist installiert `pip install robotframework-processcube`
+
+Für die Bearbeitung ist [VS Code](https://code.visualstudio.com/) und der [Robot Framework Language Server](https://marketplace.visualstudio.com/items?itemName=robocorp.robotframework-lsp) hilfreich.
+
+## Verwendung
+
+Um die *Keywords* für die Interaktion mit der 5Minds-Engine verwenden zu können, ist die 
+Library ProcessCubeLibrary einzubinden.
+Für die Verwendung mit dem 5Minds-Studio (ohne Docker) ist die URL für die Engine mit
+dem Paramter `engine_url` zu konfiguieren, dies ist für die stabile Version der
+Studio-Engine `http://localhost:56000`.
+
+Mit dem 5Minds-Studio ist folgende Verwendung zu verwenden.
+```robotframework
+*** Settings ***
+Library         ProcessCubeLibrary     engine_url=http://localhost:56000
+
+```
+
+Für die weiteren Beispiele wird Docker verwendet und dann ist folgende Einstellung zu ändern:
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+```
+
+Die Engine im Docker-Container wird standardmäßig mit dem Port `55000` gestartet. Die URL zum
+Einbinden ins Studio ist also `http://localhost:55000`.
+
+
+### Allgmeine Informationen
+
+Um den Aufruf der nachfolgenden Keywords gegenüber Fehlern etwas robuster zu gestalten, kann global oder bei jeden Keyword
+gesteuert werden:
+- max_retries: Anzahl der Wiederholungen, bevor ein Keyword abgebrochen wird.
+- delay: Verzögerung in Sekunden, die zwischen den Wiederholungen gewartet wird.
+- backoff_factor: Faktor, mit dem die Wiederholungszeit vergrößert wird.
+
+### Info von der 5Minds-Engine abrufen
+
+Um zwei verschiedene Engines gleichzeitig verwenden zu können, kann die Verwendung der Library mit `WITH NAME <ein Name>`
+benannt werden. Danach ist die Verwendung der Keywords mit einem entsprechenenden Namen zu konkretisieren.
+
+Im folgenden Beispiel wird `Get Engine Info` einmal für die `Engine01` und einmal für die `Engine02` abgerufen.
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+
+*** Settings ***
+Library         ProcessCubeLibrary    self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}    WITH NAME    Engine01
+Library         ProcessCubeLibrary    self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}    WITH NAME    Engine02
+
+*** Tasks ***
+Engine info from Engine01
+    ${INFO}=    Engine01.Get Engine Info
+    Log    ${INFO}
+
+
+Engine info from Engine02
+    ${INFO}=    Engine02.Get Engine Info
+    Log    ${INFO}
+```
+
+
+### BPMN-Datei in 5Minds-Engine laden
+
+Zuerst ist ein BPMN-Diagram (z.B. [`processes/hello_minimal.bpmn`](processes/hello_minimal.bpmn) zu erstellen.
+
+Mit dem Keyword `Deploy Processmodel` und der Angabe des Dateipfades wird das BPMN-Diagram in die 5Minds-Engine geladen.
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_minimal.bpmn
+```
+
+### Prozessmodell starten
+
+Wie unter [BPMN-Datei in 5Minds-Engine laden](#bpmn-datei-in-5minds-engine-laden) beschrieben, muss die BPMN-Datei
+vorhanden sein.
+
+Mit dem Keyword `Start Processmodel` und der Angabe der Process ID `hello_minimal` wird eine Prozessinstanz gestartet.
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library    Process
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_minimal.bpmn
+
+Start process model
+    Start Processmodel     hello_minimal
+```
+
+### Ergebnisse von beendeten Prozessen abfragen
+
+Nachdem der Prozess gestartet wurde, kann mit dem Keyword `Get Processinstance Result` das Ergebnis
+der Prozessinstanz abgefragt werden.
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+${CORRELATION}               -1
+
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library         Collections
+
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_minimal.bpmn
+
+Start process model
+    &{PAYLOAD}=              Create Dictionary     foo=bar    hello=world
+    ${PROCESS_INSTANCE}=     Start Processmodel    hello_minimal    ${PAYLOAD}
+    Set Suite Variable       ${CORRELATION}        ${PROCESS_INSTANCE.correlation_id}
+    Log                      ${CORRELATION}
+
+Get the process instance
+    ${RESULT}                Get Processinstance Result            correlation_id=${CORRELATION}
+    Log                      ${RESULT}
+```
+
+### Verarbeiten von Aktivitäten
+
+#### Umgang mit untypisierten Tasks (Empty-Tasks)
+
+Um bei der Entwicklung von Aktivitäten mit noch untypisierten Tasks 
+zu beginnen, stehen die Keywords `Get Empty Task By` fürs Laden und 
+`Finish Empty Task` zum Abschließen zur Verfügung.
+
+Für diesen Test wird eine andere BPMN-Datei verwendet `hello_empty_task.bpmn`.
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+${CORRELATION}               -1
+
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library         Collections
+
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_empty_task.bpmn
+
+Start process model
+    &{PAYLOAD}=              Create Dictionary     foo=bar    hello=world
+    ${PROCESS_INSTANCE}=     Start Processmodel    hello_empty_task    ${PAYLOAD}
+    Set Suite Variable       ${CORRELATION}        ${PROCESS_INSTANCE.correlation_id}
+    Log                      ${CORRELATION}
+
+Handle empty task by correlation_id
+    Log                      ${CORRELATION}
+    ${EMPTY_TASK}            Get Empty Task By                     correlation_id=${CORRELATION}
+    Log                      ${EMPTY_TASK.empty_task_instance_id}
+    Finish Empty Task        ${EMPTY_TASK.empty_task_instance_id}
+
+
+Get the process instance
+    ${RESULT}                Get Processinstance Result            correlation_id=${CORRELATION}
+    Log                      ${RESULT}
+```
+
+#### Umgang mit manuellen Tasks (Manual-Tasks)
+
+Als Basis für den Umgang mit manuellen Task wird die BPMN-Datei 
+`hello_manual_task.bpmn` benötigt.
+
+Für das Laden vom manuellen Taak dient das Keyword `Get Manual Task By` und 
+für das Beenden `Finish Manual Task`.
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+${CORRELATION}               -1
+
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library         Collections
+
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_manual_task.bpmn
+
+Start process model
+    &{PAYLOAD}=              Create Dictionary     foo=bar    hello=world
+    ${PROCESS_INSTANCE}=     Start Processmodel    hello_manual_task    ${PAYLOAD}
+    Set Suite Variable       ${CORRELATION}        ${PROCESS_INSTANCE.correlation_id}
+    Log                      ${CORRELATION}
+
+Handle manual task by correlation_id
+    Log                      ${CORRELATION}
+    ${MANUAL_TASK}           Get Manual Task By                     correlation_id=${CORRELATION}
+    Log                      ${MANUAL_TASK.manual_task_instance_id}
+    Finish Manual Task       ${MANUAL_TASK.manual_task_instance_id}
+
+
+Get the process instance
+    ${RESULT}                Get Processinstance Result            correlation_id=${CORRELATION}
+    Log                      ${RESULT}
+```
+
+#### Umgang mit Benutzer-Tasks (User-Tasks)
+
+Um den Umgang mit Benutzer-Task zu testen ist die BPMN-Datei `hello_user_task.bpmn` notwendig.
+
+Mit dem Keyword `Get User Task By` können User-Tasks geladen und 
+mit dem Keyword `Finish User Task` beendet werden.
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+${CORRELATION}               -1
+
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library         Collections
+
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_user_task.bpmn
+
+Start process model
+    &{PAYLOAD}=              Create Dictionary     foo=bar    hello=world
+    ${PROCESS_INSTANCE}=     Start Processmodel    hello_user_task    ${PAYLOAD}
+    Set Suite Variable       ${CORRELATION}        ${PROCESS_INSTANCE.correlation_id}
+    Log                      ${CORRELATION}
+
+Handle User Task by correlation_id
+    Log                      ${CORRELATION}
+    ${USER_TASK}             Get User Task By                      correlation_id=${CORRELATION}
+    Log                      ${USER_TASK}
+    Should Not Be Empty      ${USER_TASK.user_task_instance_id}
+    Should Be Equal          ${USER_TASK.process_model_id}         hello_user_task
+
+    &{ANSWER}=               Create Dictionary                     field_01=from user task    
+    Finish User Task         ${USER_TASK.user_task_instance_id}    ${ANSWER}
+
+
+Get the process instance
+    ${RESULT}                Get Processinstance Result            correlation_id=${CORRELATION}
+    Log                      ${RESULT}
+```
+
+#### Umgang mit External-Tasks
+
+Um den Umgang mit External-Task zu testen ist die BPMN-Datei `hello_external_task.bpmn` notwendig.
+
+Mit dem Keyword `Get External Task` können User-Tasks geladen und 
+mit dem Keyword `Finish External Task` beendet werden.
+
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+${CORRELATION}               -1
+
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library         Collections
+
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_external_task.bpmn
+
+Start process model
+    &{PAYLOAD}=              Create Dictionary     foo=bar    hello=world
+    ${PROCESS_INSTANCE}=     Start Processmodel    hello_external_task    ${PAYLOAD}
+    Set Suite Variable       ${CORRELATION}        ${PROCESS_INSTANCE.correlation_id}
+    Log                      ${CORRELATION}
+
+Handle External Task
+    ${TASK}                  Get External Task                     topic=doExternal
+    &{ANSWER}=               Create Dictionary                     external_field_01=The Value of field 1
+    Log                      ${TASK.id}
+    Finish External Task     ${TASK.id}                            ${ANSWER}
+
+
+Get the process instance
+    ${RESULT}                Get Processinstance Result            correlation_id=${CORRELATION}
+    Log                      ${RESULT}
+```
+
+### Umgang mit Ereignissen (Events)
+
+Beim Umgang mit Ereignissen, muss zwischen Signalen und Nachrichten unterschieden werden.
+
+#### Signale
+
+Um mit Ereignissen der BPMN-Module zu interagieren, muss die BPMN-Datei 
+`hello_signal.bpmn` verwendet werden.
+
+Das Keyword für das Auslösen von Signale ist `Send Signal`.
+
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+${CORRELATION}               -1
+
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library         Collections
+
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_signal.bpmn
+
+Start process model
+    &{PAYLOAD}=              Create Dictionary     foo=bar    hello=world
+    ${PROCESS_INSTANCE}=     Start Processmodel    hello_signal    ${PAYLOAD}
+    Set Suite Variable       ${CORRELATION}        ${PROCESS_INSTANCE.correlation_id}
+    Log                      ${CORRELATION}
+
+Send Signal
+    Send Signal              catch_signal                           delay=0.2     
+
+
+Get the process instance
+    ${RESULT}                Get Processinstance Result            correlation_id=${CORRELATION}
+    Log                      ${RESULT}
+```
+
+#### Nachrichten (Messages)
+
+Um mit Ereignissen der BPMN-Module zu interagieren, muss die BPMN-Datei 
+`hello_message.bpmn` verwendet werden.
+
+Das Keyword für das Auslösen von Signale ist `Send Message`.
+
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+${CORRELATION}               -1
+
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library         Collections
+
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_message.bpmn
+
+Start process model
+    &{PAYLOAD}=              Create Dictionary     foo=bar    hello=world
+    ${PROCESS_INSTANCE}=     Start Processmodel    hello_message    ${PAYLOAD}
+    Set Suite Variable       ${CORRELATION}        ${PROCESS_INSTANCE.correlation_id}
+    Log                      ${CORRELATION}
+
+Send Message
+    &{PAYLOAD}=              Create Dictionary        message_field1=Value field 1    message_field2=Value field 2
+    Send Message             catch_message            ${PAYLOAD}                      delay=0.5
+
+
+Get the process instance
+    ${RESULT}                Get Processinstance Result            correlation_id=${CORRELATION}
+    Log                      ${RESULT}
+```
+
+
+%package help
+Summary:	Development documents and examples for robotframework-processcube
+Provides:	python3-robotframework-processcube-doc
+%description help
+# Verwendung des Robot Framework mit der 5Minds-Engine
+
+- [Voraussetzung](#voraussetzung)
+- [Verwendung](#verwendung)
+  * [Allgmeine Informatione](#allgemeine-informationen)
+  * [Info von der 5Minds-Engine abrufen](#info-von-der-5minds-engine-abrufen)
+  * [BPMN-Datei in 5Minds-Engine laden](#bpmn-datei-in-5minds-engine-laden)
+  * [Prozessmodell starten](#prozessmodell-starten)
+  * [Ergebnisse von beendeten Prozessen abfragen](#ergebnisse-von-beendeten-prozessen-abfragen)
+  * [Verarbeiten von Aktivitäten](#verarbeiten-von-aktivitaten)
+    + [Umgang mit External-Tasks](#umgang-mit-external-tasks)
+    + [Umgang mit Benutzer-Tasks (User-Tasks)](#umgang-mit-benutzer-tasks-user-tasks)
+    + [Umgang mit manuellen Tasks (Manual-Tasks)](#umgang-mit-manuellen-tasks-manual-tasks)
+    + [Umgang mit untypisierten Tasks (Empty-Tasks)](#umgang-mit-untypisierten-tasks-empty-tasks)
+  * [Umgang mit Ereignissen (Events)](#umgang-mit-ereignissen-events)
+    + [Signale](#signale)
+    + [Nachrichten (Messages)](#nachrichten-messages)
+    
+## Voraussetzung
+
+Um Tests auf Basis der [Robot Framework](https://robotframework.org/) für die BPMN-basierte-Workflowengine
+[5Minds-Engine](https://www.5minds.de/processcube/) zu erstellen, sind folgende Voraussetzung erforderlich:
+- 5Minds-Studio in der stabilen Version ist installiert
+- 5Minds-Studio ist gestartet
+- 5Minds-Engine ist durch das Studio auf dem Port `56000`gestartet
+
+Alternative kann Docker für die 5Minds-Engine verwendet werden, dann sind folgende Vorausetzungen notwendig:
+- Docker-Desktop ist installiert und gestartet
+- Zugang zum Internet für den Download des Image [5minds/atlas_engine_fullstack_server](https://hub.docker.com/r/5minds/atlas_engine_fullstack_server)
+
+Für die Ausführung von Tests ist dann noch folgende Voraussetzung notwendig:
+- Python in der Version `>=3.7.x` ist installiert und im Pfad konfiguriert
+- Robot-Framework für die 5Minds-Engine ist installiert `pip install robotframework-processcube`
+
+Für die Bearbeitung ist [VS Code](https://code.visualstudio.com/) und der [Robot Framework Language Server](https://marketplace.visualstudio.com/items?itemName=robocorp.robotframework-lsp) hilfreich.
+
+## Verwendung
+
+Um die *Keywords* für die Interaktion mit der 5Minds-Engine verwenden zu können, ist die 
+Library ProcessCubeLibrary einzubinden.
+Für die Verwendung mit dem 5Minds-Studio (ohne Docker) ist die URL für die Engine mit
+dem Paramter `engine_url` zu konfiguieren, dies ist für die stabile Version der
+Studio-Engine `http://localhost:56000`.
+
+Mit dem 5Minds-Studio ist folgende Verwendung zu verwenden.
+```robotframework
+*** Settings ***
+Library         ProcessCubeLibrary     engine_url=http://localhost:56000
+
+```
+
+Für die weiteren Beispiele wird Docker verwendet und dann ist folgende Einstellung zu ändern:
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+```
+
+Die Engine im Docker-Container wird standardmäßig mit dem Port `55000` gestartet. Die URL zum
+Einbinden ins Studio ist also `http://localhost:55000`.
+
+
+### Allgmeine Informationen
+
+Um den Aufruf der nachfolgenden Keywords gegenüber Fehlern etwas robuster zu gestalten, kann global oder bei jeden Keyword
+gesteuert werden:
+- max_retries: Anzahl der Wiederholungen, bevor ein Keyword abgebrochen wird.
+- delay: Verzögerung in Sekunden, die zwischen den Wiederholungen gewartet wird.
+- backoff_factor: Faktor, mit dem die Wiederholungszeit vergrößert wird.
+
+### Info von der 5Minds-Engine abrufen
+
+Um zwei verschiedene Engines gleichzeitig verwenden zu können, kann die Verwendung der Library mit `WITH NAME <ein Name>`
+benannt werden. Danach ist die Verwendung der Keywords mit einem entsprechenenden Namen zu konkretisieren.
+
+Im folgenden Beispiel wird `Get Engine Info` einmal für die `Engine01` und einmal für die `Engine02` abgerufen.
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+
+*** Settings ***
+Library         ProcessCubeLibrary    self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}    WITH NAME    Engine01
+Library         ProcessCubeLibrary    self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}    WITH NAME    Engine02
+
+*** Tasks ***
+Engine info from Engine01
+    ${INFO}=    Engine01.Get Engine Info
+    Log    ${INFO}
+
+
+Engine info from Engine02
+    ${INFO}=    Engine02.Get Engine Info
+    Log    ${INFO}
+```
+
+
+### BPMN-Datei in 5Minds-Engine laden
+
+Zuerst ist ein BPMN-Diagram (z.B. [`processes/hello_minimal.bpmn`](processes/hello_minimal.bpmn) zu erstellen.
+
+Mit dem Keyword `Deploy Processmodel` und der Angabe des Dateipfades wird das BPMN-Diagram in die 5Minds-Engine geladen.
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_minimal.bpmn
+```
+
+### Prozessmodell starten
+
+Wie unter [BPMN-Datei in 5Minds-Engine laden](#bpmn-datei-in-5minds-engine-laden) beschrieben, muss die BPMN-Datei
+vorhanden sein.
+
+Mit dem Keyword `Start Processmodel` und der Angabe der Process ID `hello_minimal` wird eine Prozessinstanz gestartet.
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library    Process
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_minimal.bpmn
+
+Start process model
+    Start Processmodel     hello_minimal
+```
+
+### Ergebnisse von beendeten Prozessen abfragen
+
+Nachdem der Prozess gestartet wurde, kann mit dem Keyword `Get Processinstance Result` das Ergebnis
+der Prozessinstanz abgefragt werden.
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+${CORRELATION}               -1
+
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library         Collections
+
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_minimal.bpmn
+
+Start process model
+    &{PAYLOAD}=              Create Dictionary     foo=bar    hello=world
+    ${PROCESS_INSTANCE}=     Start Processmodel    hello_minimal    ${PAYLOAD}
+    Set Suite Variable       ${CORRELATION}        ${PROCESS_INSTANCE.correlation_id}
+    Log                      ${CORRELATION}
+
+Get the process instance
+    ${RESULT}                Get Processinstance Result            correlation_id=${CORRELATION}
+    Log                      ${RESULT}
+```
+
+### Verarbeiten von Aktivitäten
+
+#### Umgang mit untypisierten Tasks (Empty-Tasks)
+
+Um bei der Entwicklung von Aktivitäten mit noch untypisierten Tasks 
+zu beginnen, stehen die Keywords `Get Empty Task By` fürs Laden und 
+`Finish Empty Task` zum Abschließen zur Verfügung.
+
+Für diesen Test wird eine andere BPMN-Datei verwendet `hello_empty_task.bpmn`.
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+${CORRELATION}               -1
+
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library         Collections
+
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_empty_task.bpmn
+
+Start process model
+    &{PAYLOAD}=              Create Dictionary     foo=bar    hello=world
+    ${PROCESS_INSTANCE}=     Start Processmodel    hello_empty_task    ${PAYLOAD}
+    Set Suite Variable       ${CORRELATION}        ${PROCESS_INSTANCE.correlation_id}
+    Log                      ${CORRELATION}
+
+Handle empty task by correlation_id
+    Log                      ${CORRELATION}
+    ${EMPTY_TASK}            Get Empty Task By                     correlation_id=${CORRELATION}
+    Log                      ${EMPTY_TASK.empty_task_instance_id}
+    Finish Empty Task        ${EMPTY_TASK.empty_task_instance_id}
+
+
+Get the process instance
+    ${RESULT}                Get Processinstance Result            correlation_id=${CORRELATION}
+    Log                      ${RESULT}
+```
+
+#### Umgang mit manuellen Tasks (Manual-Tasks)
+
+Als Basis für den Umgang mit manuellen Task wird die BPMN-Datei 
+`hello_manual_task.bpmn` benötigt.
+
+Für das Laden vom manuellen Taak dient das Keyword `Get Manual Task By` und 
+für das Beenden `Finish Manual Task`.
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+${CORRELATION}               -1
+
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library         Collections
+
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_manual_task.bpmn
+
+Start process model
+    &{PAYLOAD}=              Create Dictionary     foo=bar    hello=world
+    ${PROCESS_INSTANCE}=     Start Processmodel    hello_manual_task    ${PAYLOAD}
+    Set Suite Variable       ${CORRELATION}        ${PROCESS_INSTANCE.correlation_id}
+    Log                      ${CORRELATION}
+
+Handle manual task by correlation_id
+    Log                      ${CORRELATION}
+    ${MANUAL_TASK}           Get Manual Task By                     correlation_id=${CORRELATION}
+    Log                      ${MANUAL_TASK.manual_task_instance_id}
+    Finish Manual Task       ${MANUAL_TASK.manual_task_instance_id}
+
+
+Get the process instance
+    ${RESULT}                Get Processinstance Result            correlation_id=${CORRELATION}
+    Log                      ${RESULT}
+```
+
+#### Umgang mit Benutzer-Tasks (User-Tasks)
+
+Um den Umgang mit Benutzer-Task zu testen ist die BPMN-Datei `hello_user_task.bpmn` notwendig.
+
+Mit dem Keyword `Get User Task By` können User-Tasks geladen und 
+mit dem Keyword `Finish User Task` beendet werden.
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+${CORRELATION}               -1
+
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library         Collections
+
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_user_task.bpmn
+
+Start process model
+    &{PAYLOAD}=              Create Dictionary     foo=bar    hello=world
+    ${PROCESS_INSTANCE}=     Start Processmodel    hello_user_task    ${PAYLOAD}
+    Set Suite Variable       ${CORRELATION}        ${PROCESS_INSTANCE.correlation_id}
+    Log                      ${CORRELATION}
+
+Handle User Task by correlation_id
+    Log                      ${CORRELATION}
+    ${USER_TASK}             Get User Task By                      correlation_id=${CORRELATION}
+    Log                      ${USER_TASK}
+    Should Not Be Empty      ${USER_TASK.user_task_instance_id}
+    Should Be Equal          ${USER_TASK.process_model_id}         hello_user_task
+
+    &{ANSWER}=               Create Dictionary                     field_01=from user task    
+    Finish User Task         ${USER_TASK.user_task_instance_id}    ${ANSWER}
+
+
+Get the process instance
+    ${RESULT}                Get Processinstance Result            correlation_id=${CORRELATION}
+    Log                      ${RESULT}
+```
+
+#### Umgang mit External-Tasks
+
+Um den Umgang mit External-Task zu testen ist die BPMN-Datei `hello_external_task.bpmn` notwendig.
+
+Mit dem Keyword `Get External Task` können User-Tasks geladen und 
+mit dem Keyword `Finish External Task` beendet werden.
+
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+${CORRELATION}               -1
+
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library         Collections
+
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_external_task.bpmn
+
+Start process model
+    &{PAYLOAD}=              Create Dictionary     foo=bar    hello=world
+    ${PROCESS_INSTANCE}=     Start Processmodel    hello_external_task    ${PAYLOAD}
+    Set Suite Variable       ${CORRELATION}        ${PROCESS_INSTANCE.correlation_id}
+    Log                      ${CORRELATION}
+
+Handle External Task
+    ${TASK}                  Get External Task                     topic=doExternal
+    &{ANSWER}=               Create Dictionary                     external_field_01=The Value of field 1
+    Log                      ${TASK.id}
+    Finish External Task     ${TASK.id}                            ${ANSWER}
+
+
+Get the process instance
+    ${RESULT}                Get Processinstance Result            correlation_id=${CORRELATION}
+    Log                      ${RESULT}
+```
+
+### Umgang mit Ereignissen (Events)
+
+Beim Umgang mit Ereignissen, muss zwischen Signalen und Nachrichten unterschieden werden.
+
+#### Signale
+
+Um mit Ereignissen der BPMN-Module zu interagieren, muss die BPMN-Datei 
+`hello_signal.bpmn` verwendet werden.
+
+Das Keyword für das Auslösen von Signale ist `Send Signal`.
+
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+${CORRELATION}               -1
+
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library         Collections
+
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_signal.bpmn
+
+Start process model
+    &{PAYLOAD}=              Create Dictionary     foo=bar    hello=world
+    ${PROCESS_INSTANCE}=     Start Processmodel    hello_signal    ${PAYLOAD}
+    Set Suite Variable       ${CORRELATION}        ${PROCESS_INSTANCE.correlation_id}
+    Log                      ${CORRELATION}
+
+Send Signal
+    Send Signal              catch_signal                           delay=0.2     
+
+
+Get the process instance
+    ${RESULT}                Get Processinstance Result            correlation_id=${CORRELATION}
+    Log                      ${RESULT}
+```
+
+#### Nachrichten (Messages)
+
+Um mit Ereignissen der BPMN-Module zu interagieren, muss die BPMN-Datei 
+`hello_message.bpmn` verwendet werden.
+
+Das Keyword für das Auslösen von Signale ist `Send Message`.
+
+
+```robotframework
+*** Variables ***
+&{DOCKER_OPTIONS}            auto_remove=False
+${CORRELATION}               -1
+
+
+*** Settings ***
+Library         ProcessCubeLibrary     self_hosted_engine=docker    docker_options=${DOCKER_OPTIONS}
+Library         Collections
+
+
+*** Tasks ***
+Successfully deploy
+    Deploy Processmodel    processes/hello_message.bpmn
+
+Start process model
+    &{PAYLOAD}=              Create Dictionary     foo=bar    hello=world
+    ${PROCESS_INSTANCE}=     Start Processmodel    hello_message    ${PAYLOAD}
+    Set Suite Variable       ${CORRELATION}        ${PROCESS_INSTANCE.correlation_id}
+    Log                      ${CORRELATION}
+
+Send Message
+    &{PAYLOAD}=              Create Dictionary        message_field1=Value field 1    message_field2=Value field 2
+    Send Message             catch_message            ${PAYLOAD}                      delay=0.5
+
+
+Get the process instance
+    ${RESULT}                Get Processinstance Result            correlation_id=${CORRELATION}
+    Log                      ${RESULT}
+```
+
+
+%prep
+%autosetup -n robotframework-processcube-2.1.0
+
+%build
+%py3_build
+
+%install
+%py3_install
+install -d -m755 %{buildroot}/%{_pkgdocdir}
+if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi
+if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi
+if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi
+if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi
+pushd %{buildroot}
+if [ -d usr/lib ]; then
+	find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/lib64 ]; then
+	find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/bin ]; then
+	find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/sbin ]; then
+	find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+touch doclist.lst
+if [ -d usr/share/man ]; then
+	find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst
+fi
+popd
+mv %{buildroot}/filelist.lst .
+mv %{buildroot}/doclist.lst .
+
+%files -n python3-robotframework-processcube -f filelist.lst
+%dir %{python3_sitelib}/*
+
+%files help -f doclist.lst
+%{_docdir}/*
+
+%changelog
+* Fri May 05 2023 Python_Bot <Python_Bot@openeuler.org> - 2.1.0-1
+- Package Spec generated
diff --git a/sources b/sources
new file mode 100644
index 0000000..cef0582
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+7770c325584011e0963ea4ac8cedd3f8  robotframework-processcube-2.1.0.tar.gz