processcube-client 4.0.0a1__tar.gz

processcube_client-4.0.0a1/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.1
+Name: processcube_client
+Version: 4.0.0a1
+Summary: A Client for the workflow engine of the ProcessCube platform.
+Home-page: https://github.com/5minds/processcube_client.py
+Author: 5Minds IT-Solutions GmbH & Co. KG
+Author-email: ProcessCube@5Minds.de
+Keywords: workflow-engine atlas-engine client bpmn
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp==3.8.3
+Requires-Dist: nest-asyncio==1.5.6
+Requires-Dist: dataclasses-json>=0.5.7
+Requires-Dist: requests>=2.28.1
+
+# Client zur Anbindung des ProcessCube®
+
+Der [ProcessCube®](https://www.5minds.de/processcube/) ist ein BPMN-Engine
+der mittels [Python](http://processcube.io/docs/engine/clients/python/) 
+angebunden werden kann. Die Beispiel sind unter [Developer-Seite](http://processcube.io/) 
+zu finden.
+

processcube_client-4.0.0a1/README.md

@@ -0,0 +1,7 @@
+# Client zur Anbindung des ProcessCube®
+
+Der [ProcessCube®](https://www.5minds.de/processcube/) ist ein BPMN-Engine
+der mittels [Python](http://processcube.io/docs/engine/clients/python/) 
+angebunden werden kann. Die Beispiel sind unter [Developer-Seite](http://processcube.io/) 
+zu finden.
+

processcube_client-4.0.0a1/processcube_client/__init__.py

@@ -0,0 +1,22 @@
+from .client_factory import ClientFactory
+from .app_info import AppInfoClient
+from .event import EventClient
+from .external_task import ClientWrapper, ExternalTaskClient
+from .flow_node_instance import FlowNodeInstanceClient
+from .notification import NotificationClient
+from .process_instance import ProcessInstanceClient
+from .process_definition import ProcessDefinitionClient
+from .user_task import UserTaskClient
+
+__all__ = ['ClientFactory',
+    'AppInfoClient',
+    'EventClient',
+    'ClientWrapper',
+    'ExternalTaskClient',
+    'FlowNodeInstanceClient',
+    'NotificationClient',
+    'ProcessInstanceClient',
+    'ProcessDefinitionClient',
+    'UserTaskClient',
+]
+

processcube_client-4.0.0a1/processcube_client/app_info/__init__.py

@@ -0,0 +1 @@
+from .app_info_client import AppInfoClient

processcube_client-4.0.0a1/processcube_client/app_info/app_info_client.py

@@ -0,0 +1,66 @@
+import asyncio
+import logging 
+
+from ..core.base_client import BaseClient
+
+logger = logging.getLogger(__name__)
+
+class AppInfoClient(BaseClient):
+
+    def __init__(self, url, session=None, identity=None):
+        super(AppInfoClient, self).__init__(url, session, identity)
+
+    async def __get_info(self):
+        
+        url = f"/atlas_engine/api/v1/info"
+
+        result = await self.do_get(url)
+
+        return result
+
+    def get_info(self):
+
+        async def run_loop():
+
+            result = await self.__get_info()
+
+            return result
+
+        logger.info(f"Connection to atlas engine at url '{self._url}'.")
+        logger.info(f"Get info of the atlas engine.")
+
+        loop = asyncio.new_event_loop()
+
+        task = run_loop()
+        result = loop.run_until_complete(task)
+
+        loop.close()
+
+        return result
+
+    async def __get_authority(self):
+
+        url = f"/atlas_engine/api/v1/authority"
+
+        result = await self.do_get(url)
+
+        return result
+
+    def get_authority(self):
+
+        async def run_loop():
+            result = await self.__get_authority()
+
+            return result
+
+        logger.info(f"Connection to atlas engine at url '{self._url}'.")
+        logger.info(f"Get info of the authority of the atlas engine.")
+
+        loop = asyncio.new_event_loop()
+
+        task = run_loop()
+        result = loop.run_until_complete(task)
+
+        loop.close()
+
+        return result

processcube_client-4.0.0a1/processcube_client/client_factory.py

@@ -0,0 +1,40 @@
+from processcube_client.app_info import AppInfoClient
+from processcube_client.event import EventClient
+from processcube_client.external_task import ClientWrapper
+from processcube_client.flow_node_instance import FlowNodeInstanceClient
+from processcube_client.notification import NotificationClient
+from processcube_client.process_instance import ProcessInstanceClient
+from processcube_client.process_definition import ProcessDefinitionClient
+from processcube_client.user_task import UserTaskClient
+
+
+class ClientFactory:
+
+    def __init__(self):
+        pass
+
+    def create_app_info_client(self, engine_url):
+        return AppInfoClient(engine_url)
+
+    def create_event_client(self, engine_url):
+        return EventClient(engine_url)
+
+    def create_external_task_client(self, engine_url):
+        return ClientWrapper(engine_url)
+
+    def create_flow_node_instance_client(self, engine_url):
+        return FlowNodeInstanceClient(engine_url)
+
+    def create_notification_client(self, engine_url):
+        return NotificationClient(engine_url)
+
+    def create_process_instance_client(self, engine_url):
+        return ProcessInstanceClient(engine_url)
+
+    def create_process_definition_client(self, engine_url):
+        return ProcessDefinitionClient(engine_url)
+
+    def create_user_task_client(self, engine_url):
+        return UserTaskClient(engine_url)
+
+    

processcube_client-4.0.0a1/processcube_client/core/__init__.py

@@ -0,0 +1,2 @@
+from .base_client import BaseClient
+from .loop_helper import LoopHelper, get_or_create_loop, ensure_has_loop

processcube_client-4.0.0a1/processcube_client/core/api/__init__.py

@@ -0,0 +1,13 @@
+from .client import Client
+
+from .helpers.application_info import ApplicationInfo
+from .helpers.data_object_instances import DataObjectInstanceHandler, DataObjectInstancesQuery, DataObjectInstanceResponse
+from .helpers.empty_tasks import EmptyTaskHandler, EmptyTaskQuery, EmptyTaskResponse
+from .helpers.events import EventsHandler, MessageTriggerRequest
+from .helpers.process_definitions import ProcessDefinitionUploadPayload, ProcessDefinitionHandler
+from .helpers.process_instances import ProcessInstanceHandler, ProcessInstanceQueryRequest, ProcessInstanceQueryResponse
+from .helpers.process_models import ProcessStartResponse, ProcessStartRequest, StartCallbackType
+from .helpers.external_tasks import FetchAndLockRequestPayload, ExternalTask, FinishExternalTaskRequestPayload
+from .helpers.flow_node_instances import FlowNodeInstanceHandler, FlowNodeInstanceResponse, FlowNodeInstancesQuery
+from .helpers.manual_tasks import ManualTaskHandler, ManualTaskQuery, ManualTaskResponse
+from .helpers.user_tasks import UserTaskHandler, UserTaskQuery, UserTaskResponse, ReserveUserTaskRequest

processcube_client-4.0.0a1/processcube_client/core/api/base_client.py

@@ -0,0 +1,103 @@
+from dataclasses import dataclass
+from typing import Callable, Dict, Type
+from requests.api import request
+from typing_extensions import Protocol
+import json
+
+import requests
+
+class IsDataclass(Protocol):
+    __dataclass_fields__: Dict
+
+class BaseClient(object):
+
+    def __init__(self, url: str, identity: Callable=None):
+        self._url = url
+
+        if identity is not None:
+            self._identity = identity
+        else:
+            self._identity = lambda: {"token": "ZHVtbXlfdG9rZW4="}
+
+
+    def do_get(self, path: str, options: Dict={}):
+        headers = self.__get_default_headers()
+        headers.update(options.get('headers', {}))
+        headers.update(self.__get_auth_headers())
+
+        request_url = f"{self._url}{path}"
+
+        response = requests.get(request_url, headers=headers)
+
+        response.raise_for_status()
+
+        json_body = response.json()
+
+        return json_body
+
+    def do_delete(self, path: str, options: Dict={}):
+        headers = self.__get_default_headers()
+        headers.update(options.get('headers', {}))
+        headers.update(self.__get_auth_headers())
+
+        request_url = f"{self._url}{path}"
+
+        response = requests.delete(request_url, headers=headers)
+
+        response.raise_for_status()
+
+    def do_post(self, path: str, payload: IsDataclass, options: Dict={}):
+        headers = self.__get_default_headers()
+        headers.update(options.get('headers', {}))
+        headers.update(self.__get_auth_headers())
+
+        request_url = f"{self._url}{path}"
+
+        json_payload = json.dumps(payload)
+
+        response = requests.post(request_url, json_payload, headers=headers)
+
+        response.raise_for_status()
+
+        if response.status_code == 200:
+            json_body = response.json()
+        else:
+            json_body = {}
+
+        return json_body
+
+    def do_put(self, path: str, payload: IsDataclass, options: Dict={}):
+        headers = self.__get_default_headers()
+        headers.update(options.get('headers', {}))
+        headers.update(self.__get_auth_headers())
+
+        request_url = f"{self._url}{path}"
+
+        json_payload = json.dumps(payload)
+
+        response = requests.put(request_url, json_payload, headers=headers)
+        
+        response.raise_for_status()
+
+        if response.status_code == 200:
+            json_body = response.json()
+        else:
+            json_body = {}
+
+        return json_body
+
+    def __get_auth_headers(self):
+        identity = self.__get_identity()
+        token = identity['token']
+        return {'Authorization': 'Bearer {}'.format(token)}
+
+    def __get_default_headers(self):
+        return {'Content-Type': 'application/json'}
+
+    def __get_identity(self):
+        identity = self._identity
+
+        if callable(self._identity):
+            identity = self._identity()
+
+        return identity

processcube_client-4.0.0a1/processcube_client/core/api/client.py

@@ -0,0 +1,256 @@
+from pathlib import Path
+import os
+
+from typing import Any, Callable, Dict, List
+
+from dataclasses import dataclass, field
+from dataclasses_json import dataclass_json, LetterCase
+
+from .helpers.application_info import ApplicationInfo, ApplicationInfoHandler
+from .helpers.data_object_instances import DataObjectInstanceHandler, DataObjectInstancesQuery, DataObjectInstanceResponse
+from .helpers.empty_tasks import EmptyTaskHandler, EmptyTaskQuery, EmptyTaskResponse
+from .helpers.events import EventsHandler, MessageTriggerRequest
+from .helpers.external_tasks import ExtendLockRequest, FetchAndLockRequestPayload, ExternalTask
+from .helpers.external_tasks import ExternalTaskHandler, FinishExternalTaskRequestPayload
+from .helpers.flow_node_instances import FlowNodeInstanceHandler, FlowNodeInstanceResponse, FlowNodeInstancesQuery
+from .helpers.manual_tasks import ManualTaskHandler, ManualTaskQuery, ManualTaskResponse
+from .helpers.external_tasks import BpmnErrorRequest, ServiceErrorRequest
+from .helpers.process_definitions import ProcessDefinitionUploadPayload, ProcessDefinitionHandler
+from .helpers.process_instances import ProcessInstanceHandler, ProcessInstanceQueryRequest, ProcessInstanceQueryResponse
+from .helpers.process_models import ProcessStartRequest, ProcessStartResponse, ProcessModelHandler
+from .helpers.user_tasks import UserTaskHandler, UserTaskQuery, UserTaskResponse, ReserveUserTaskRequest
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL)
+@dataclass
+class DeployResult:
+    filename: str
+    deployed: bool = True
+
+
+@dataclass_json(letter_case=LetterCase.CAMEL)
+@dataclass
+class DeployResults:
+    deployed_files: List[DeployResult] = field(default_factory=list)
+
+
+class Client(object):
+
+    def __init__(self, url: str, identity: Callable = None):
+        self._url = url
+        self._identity = identity
+
+    def info(self) -> ApplicationInfo:
+        handler = ApplicationInfoHandler(self._url, self._identity)
+
+        application_info = handler.info()
+
+        return application_info
+
+    def authority(self) -> str:
+        handler = ApplicationInfoHandler(self._url, self._identity)
+
+        authority = handler.authority()
+
+        return authority
+
+    def data_object_instance_get(self, query: DataObjectInstancesQuery, options: dict = {}) -> DataObjectInstanceResponse:
+        handler = DataObjectInstanceHandler(self._url, self._identity)
+
+        response = handler.get_data_object_instances(query, options)
+
+        return response
+
+    def empty_task_get(self, empty_task_query: EmptyTaskQuery, options: dict = {}) -> EmptyTaskResponse:
+        handler = EmptyTaskHandler(self._url, self._identity)
+
+        response = handler.get_empty_tasks(empty_task_query, options)
+
+        return response
+
+    def empty_task_finish(self, empty_task_instance_id: str, options: dict = {}):
+        handler = EmptyTaskHandler(self._url, self._identity)
+
+        _ = handler.finish_empty_task(empty_task_instance_id, options)
+
+        return True
+
+    def events_trigger_message(self, event_name: str, request: MessageTriggerRequest, options: dict = {}):
+        handler = EventsHandler(self._url, self._identity)
+
+        handler.trigger_message(event_name, request, options)
+
+    def events_trigger_signal(self, signal_name: str, options: dict = {}):
+        handler = EventsHandler(self._url, self._identity)
+
+        handler.trigger_signal(signal_name, options)
+
+    def external_task_fetch_and_lock(self, request: FetchAndLockRequestPayload, options: dict = {}) -> List[ExternalTask]:
+        handler = ExternalTaskHandler(self._url, self._identity)
+
+        reponse = handler.fetch_and_lock(request, options)
+
+        return reponse
+
+    def external_task_extend_lock(self, request: ExtendLockRequest, options: dict = {}) -> List[ExternalTask]:
+        handler = ExternalTaskHandler(self._url, self._identity)
+
+        reponse = handler.extend_lock(request, options)
+
+        return reponse
+
+    def external_task_finish(self, external_task_id: str, request: FinishExternalTaskRequestPayload, options: dict = {}):
+        handler = ExternalTaskHandler(self._url, self._identity)
+
+        response = handler.finish(external_task_id, request, options)
+
+        return response
+
+    def external_task_handle_bpmn_error(self, external_task_id: str, request: BpmnErrorRequest, options: dict = {}):
+        handler = ExternalTaskHandler(self._url, self._identity)
+
+        response = handler.handle_bpmn_error(
+            external_task_id, request, options)
+
+        return response
+
+    def external_task_handle_service_error(self, external_task_id: str, request: ServiceErrorRequest, options: dict = {}):
+        handler = ExternalTaskHandler(self._url, self._identity)
+
+        response = handler.handle_service_error(
+            external_task_id, request, options)
+
+        return response
+
+    def flow_node_instance_get(self, query: FlowNodeInstancesQuery, options: dict = {}) -> FlowNodeInstanceResponse:
+        handler = FlowNodeInstanceHandler(self._url, self._identity)
+
+        response = handler.get_flow_node_instances(query, options)
+
+        return response
+
+    def manual_task_get(self, manual_task_query: ManualTaskQuery, options: dict = {}) -> ManualTaskResponse:
+        handler = ManualTaskHandler(self._url, self._identity)
+
+        response = handler.get_manual_tasks(manual_task_query, options)
+
+        return response
+
+    def manual_task_finish(self, manual_task_instance_id: str, options: dict = {}):
+        handler = ManualTaskHandler(self._url, self._identity)
+
+        _ = handler.finish_manual_task(manual_task_instance_id, options)
+
+        return True
+
+    def process_defintion_deploy(self, request: ProcessDefinitionUploadPayload, options: dict = {}):
+        handler = ProcessDefinitionHandler(self._url, self._identity)
+
+        handler.deploy(request, options)
+
+    def process_defintion_deploy_by_pathname(self, pathname: str, exit_on_fail: bool = False, overwrite_existing: bool = True, options: dict = {}) -> DeployResults:
+
+        handler = ProcessDefinitionHandler(self._url, self._identity)
+
+        deploy_results = DeployResults()
+
+        filenames = []
+
+        if Path(pathname).is_file():
+            filenames.append(pathname)
+        else:
+            found_paths = Path(os.getcwd()).rglob(pathname)
+            filenames = [str(path) for path in found_paths]
+
+        if len(filenames) == 0 and exit_on_fail:
+            raise Exception(f"No files found for pathname {pathname}")
+
+        has_failed_deployments = False
+
+        for filename in filenames:
+
+            deployed_file = DeployResult(filename=filename)
+            deploy_results.deployed_files.append(deployed_file)
+
+            with open(filename) as file:
+                xml = file.read()
+
+            request = ProcessDefinitionUploadPayload(
+                xml=xml, overwrite_existing=overwrite_existing)
+
+            try:
+                handler.deploy(request, options=options)
+                deployed_file.deployed = True
+            except Exception as e:
+                if exit_on_fail:
+                    raise e
+                else:
+                    deployed_file.deployed = False
+                    has_failed_deployments = True
+
+        if has_failed_deployments and exit_on_fail:
+            failed_filenames = [
+                deploy_result.filename for deploy_result in deploy_results if deploy_result.deployed == False]
+            msg = f'Failed to deploy {",".join(failed_filenames)}'
+            raise Exception(msg)
+
+        if len(filenames) != len(deploy_results.deployed_files) or len(deploy_results.deployed_files) == 0:
+            if exit_on_fail:
+                msg = f"Nothing to deploy with '{pathname}' in current working dir '{os.getcwd()}'"
+                raise Exception(msg)
+
+        return deploy_results
+
+    def process_instanceq_query(self, request: ProcessInstanceQueryRequest, options: dict = {}) -> ProcessInstanceQueryResponse:
+        return self.process_instance_query(request, options)
+
+    def process_instance_query(self, request: ProcessInstanceQueryRequest, options: dict = {}) -> ProcessInstanceQueryResponse:
+        handler = ProcessInstanceHandler(self._url, self._identity)
+
+        response = handler.query(request, options)
+
+        return response
+
+    def process_instance_terminate(self, process_instance_id: str, options: dict = {}):
+        handler = ProcessInstanceHandler(self._url, self._identity)
+
+        response = handler.terminate(process_instance_id, options)
+
+        return response
+
+    def process_model_start(self, process_model_id: str, request: ProcessStartRequest, options: dict = {}) -> ProcessStartResponse:
+        handler = ProcessModelHandler(self._url, self._identity)
+
+        response = handler.start(process_model_id, request, options)
+
+        return response
+
+    def user_task_get(self, query: UserTaskQuery = UserTaskQuery(), options: dict = {}) -> UserTaskResponse:
+        handler = UserTaskHandler(self._url, self._identity)
+
+        response = handler.get_user_tasks(query, options)
+
+        return response
+
+    def user_task_reserve(self, user_task_instance_id: str, request: ReserveUserTaskRequest, options: dict = {}):
+        handler = UserTaskHandler(self._url, self._identity)
+
+        response = handler.reserve_user_task(
+            user_task_instance_id, request, options)
+
+        return response
+
+    def user_task_cancel_reservation(self, user_task_instance_id: str, options: dict = {}):
+        handler = UserTaskHandler(self._url, self._identity)
+
+        response = handler.cancel_reservation(user_task_instance_id, options)
+
+        return response
+
+    def user_task_finish(self, user_task_instance_id: str, request: Dict[str, Any], options: dict = {}):
+        handler = UserTaskHandler(self._url, self._identity)
+
+        response = handler.finish_user_task(
+            user_task_instance_id, request, options)
+
+        return response

processcube_client-4.0.0a1/processcube_client/core/api/helpers/application_info.py

@@ -0,0 +1,36 @@
+
+
+from dataclasses import dataclass
+from dataclasses_json import dataclass_json, LetterCase
+from typing import Callable
+
+from ..base_client import BaseClient
+
+@dataclass_json(letter_case=LetterCase.CAMEL)
+@dataclass
+class ApplicationInfo:
+    id: str
+    name: str
+    package_name: str
+    version: str
+    authority_url: str
+    allow_anonymous_root_access: str
+    extra_info: dict
+
+
+class ApplicationInfoHandler(BaseClient):
+
+    def __init__(self, url: str, identity: Callable=None):
+        super(ApplicationInfoHandler, self).__init__(url, identity)
+
+    def info(self) -> ApplicationInfo:
+        json_data = self.do_get('/atlas_engine/api/v1/info')
+
+        info = ApplicationInfo.from_dict(json_data)
+
+        return info
+
+    def authority(self) -> str:
+        json_data = self.do_get('/atlas_engine/api/v1/authority')
+
+        return json_data

processcube_client-4.0.0a1/processcube_client/core/api/helpers/data_object_instances.py

@@ -0,0 +1,56 @@
+from dataclasses import dataclass, field
+from dataclasses_json import dataclass_json, LetterCase, Undefined
+from dataclasses_json import CatchAll
+from typing import Any, Callable, Dict, Optional
+from urllib import parse
+
+from ..base_client import BaseClient
+
+@dataclass_json(letter_case=LetterCase.CAMEL)
+@dataclass
+class DataObjectInstancesQuery:
+    limit: int = None
+    offset: int = None
+    data_object_id: str = None
+    process_definition_id: str = None
+    process_model_id: str = None
+    process_instance_id: str = None
+    flow_node_instance_id: str = None
+
+@dataclass_json(letter_case=LetterCase.CAMEL, undefined=Undefined.INCLUDE)
+@dataclass
+class DataObjectInstanceResponse:
+    data_object_id: Optional[str] = None
+    flow_node_instance_id: Optional[str] = None
+    process_definition_id: Optional[str] = None
+    process_model_id: Optional[str] = None
+    process_instance_id: Optional[str] = None
+    value: Dict[str, Any] = field(default_factory=dict)
+    created_at: Optional[str] = None
+    updated_at: Optional[str] = None
+    place_holder: CatchAll = None
+    
+class DataObjectInstanceHandler(BaseClient):
+
+    def __init__(self, url: str, identity: Callable=None):
+        super(DataObjectInstanceHandler, self).__init__(url, identity)
+
+    def get_data_object_instances(self, query: DataObjectInstancesQuery, options: dict={}) -> DataObjectInstanceResponse:
+
+        query_dict = query.to_dict() 
+
+        filtered_query = list(filter(lambda dict_entry: dict_entry[1] is not None, query_dict.items()))
+
+        query_str = parse.urlencode(filtered_query, doseq=False)
+
+        path = f"/atlas_engine/api/v1/data_object_instances/query?{query_str}"
+
+        response_list_of_dict = self.do_get(path, options)
+
+        if response_list_of_dict.get('totalCount', 0) > 0:
+            json_data = response_list_of_dict['dataObjectInstances']
+            response = DataObjectInstanceResponse.schema().load(json_data, many=True)
+        else:
+            response = []
+
+        return response