Weitere Clients & API

ProcessDefinitionClient

Prozesse starten und Definitionen verwalten.


from processcube_client import ClientFactory
 
factory = ClientFactory()
client = factory.create_process_definition_client("http://localhost:56100")
 
result = client.start_process_instance_and_await_end_event(
    "MeinProzess",
    start_event_id="StartEvent_1",
    initial_token={"eingabe": "wert"}
)

Methode	Beschreibung
`start_process_instance(process_model_id, **options)`	Startet Prozess, gibt sofort zurück
`start_process_instance_and_await_end_event(process_model_id, **options)`	Startet Prozess und wartet auf Ende
`start_process_instance_and_await_specific_end_event(process_model_id, end_event_id=..., **options)`	Wartet auf bestimmtes End-Event
`get_process_definition(process_model_id)`	Gibt die Prozessdefinition zurück

ProcessInstanceClient


client = factory.create_process_instance_client("http://localhost:56100")
 
client.terminate(process_instance_id)
client.retry(process_instance_id)

Methode	Beschreibung
`terminate(process_instance_id)`	Bricht eine Prozessinstanz ab
`retry(process_instance_id)`	Wiederholt eine fehlgeschlagene Instanz

EventClient


client = factory.create_event_client("http://localhost:56100")
 
client.trigger_message("BestellungEingegangen", payload={"order_id": "123"})
client.trigger_signal("NotfallStop")

Methode	Beschreibung
`trigger_message(event_name, payload={}, process_instance_id=None)`	Message-Event senden
`trigger_signal(signal_name)`	Signal-Event broadcasten

NotificationClient

Echtzeit-Benachrichtigungen über Prozess-Events per Long Polling.


client = factory.create_notification_client("http://localhost:56100")
 
client.on_process_started(lambda event: print(f"Prozess gestartet: {event}"))
client.on_process_ended(lambda event: print(f"Prozess beendet: {event}"))
client.on_user_task_waiting(lambda event: print(f"User Task wartet: {event}"))
 
client.start()

Methode	Beschreibung
`on_process_started(callback)`	Prozess gestartet
`on_process_ended(callback)`	Prozess beendet
`on_process_error(callback)`	Prozess-Fehler
`on_activity_reached(callback)`	Aktivität erreicht
`on_activity_finished(callback)`	Aktivität abgeschlossen
`on_user_task_waiting(callback)`	User Task wartet
`on_user_task_finished(callback)`	User Task abgeschlossen
`on_user_task_reserved(callback)`	User Task reserviert
`on_user_task_reservation_canceled(callback)`	Reservierung aufgehoben
`on_manual_task_waiting(callback)`	Manual Task wartet
`on_manual_task_finished(callback)`	Manual Task abgeschlossen
`on_boundary_event_triggered(callback)`	Boundary Event ausgelöst
`on_intermediate_throw_event_triggered(callback)`	Intermediate Throw Event
`on_intermediate_catch_event_reached(callback)`	Intermediate Catch Event erreicht
`on_intermediate_catch_event_finished(callback)`	Intermediate Catch Event abgeschlossen

FlowNodeInstanceClient


client = factory.create_flow_node_instance_client("http://localhost:56100")
 
client.trigger_message_event("MeineNachricht", process_instance_id="...")
client.trigger_signal_event("MeinSignal")

AppInfoClient


client = factory.create_app_info_client("http://localhost:56100")
 
info = client.get_info()
authority = client.get_authority()

Synchroner Client (core/api)

Für synchrone Kontexte (z.B. Robot Framework):


from processcube_client.core.api.client import Client
 
client = Client("http://localhost:56100")
 
# Engine-Info
info = client.info()
 
# Prozess starten
from processcube_client.core.api.helpers.process_models import ProcessStartRequest
result = client.process_model_start("MeinProzess", ProcessStartRequest(
    start_event_id="StartEvent_1"
))
 
# BPMN-Dateien deployen
result = client.deploy_bpmn_from_path("prozesse/")

API-Endpunkte

Alle Endpunkte liegen unter {engine_url}/atlas_engine/api/v1/.

Methode	Endpunkt	Beschreibung
`GET`	`/info`	Engine-Informationen
`GET`	`/authority`	Authority-URL
`POST`	`/process_definitions`	Prozessdefinition hochladen
`DELETE`	`/process_definitions/{id}`	Prozessdefinition löschen
`POST`	`/process_models/{id}/start`	Prozessinstanz starten
`GET`	`/process_instances/query`	Prozessinstanzen abfragen
`PUT`	`/process_instances/{id}/terminate`	Prozessinstanz abbrechen
`POST`	`/external_tasks/fetch_and_lock`	ExternalTasks abholen und locken
`PUT`	`/external_tasks/{id}/extend_lock`	Lock verlängern
`PUT`	`/external_tasks/{id}/finish`	ExternalTask abschließen
`PUT`	`/external_tasks/{id}/error`	Fehler melden
`GET`	`/user_tasks`	User Tasks abfragen
`PUT`	`/user_tasks/{id}/finish`	User Task abschließen
`PUT`	`/user_tasks/{id}/reserve`	User Task reservieren
`DELETE`	`/user_tasks/{id}/cancel-reservation`	Reservierung aufheben
`PUT`	`/manual_tasks/{id}/finish`	Manual Task abschließen
`POST`	`/messages/{name}/trigger`	Message-Event auslösen
`POST`	`/signals/{name}/trigger`	Signal-Event auslösen
`GET`	`/flow_node_instances`	Flow-Node-Instanzen abfragen
`GET`	`/data_object_instances/query`	Datenobjekt-Instanzen abfragen