class Generate(pycamunda.base.CamundaRequest): source_process_definition_id = BodyParameter('sourceProcessDefinitionId') target_process_definition_id = BodyParameter('targetProcessDefinitionId') update_event_triggers = BodyParameter('updateEventTriggers') def __init__( self, url: str, source_process_definition_id: str, target_process_definition_id: str, update_event_triggers: bool = False ): """Generates a migration plan for 2 process definitions. The generated plan contains instructions that map equal activities between the process definitions. :param url: Camunda Rest engine URL. :param source_process_definition_id: Id of the source process definition for the migration. :param target_process_definition_id: Id of the target process definition for the migration. :param update_event_triggers: Whether instructions between events should be configured to update the event triggers. """ super().__init__(url=url + URL_SUFFIX + '/generate') self.source_process_definition_id = source_process_definition_id self.target_process_definition_id = target_process_definition_id self.update_event_triggers = update_event_triggers def __call__(self, *args, **kwargs) -> MigrationPlan: """Send the request.""" response = super().__call__(pycamunda.base.RequestMethod.POST, *args, **kwargs) return MigrationPlan.load(data=response.json())
class Terminate(_VariableDeletionMixin, pycamunda.base.CamundaRequest): id_ = PathParameter('id') variables = BodyParameter('variables') deletions = BodyParameter('deletions') def __init__(self, url: str, id_: str, deletions: typing.Iterable[str] = None): """Performs a transition from ACTIVE state to TERMINATED state. In addition to that, case instance variables can be updated and deleted. :param url: Camunda Rest engine URL. :param id_: Id of the case instance. :param deletions: Variables to delete. Is executed for creating or updating variables. """ super().__init__(url=url + URL_SUFFIX + '/{id}/terminate') self.id_ = id_ self.deletions = deletions self.variables = {} def __call__(self, *args, **kwargs) -> None: """Send the request.""" super().__call__(pycamunda.base.RequestMethod.POST, *args, **kwargs)
class Update(_Criteria): id_ = PathParameter('id') resource_type = BodyParameter('resourceType') name = BodyParameter('name') owner = BodyParameter('owner') def __init__(self, url: str, id_: str, name: str = None, owner: str = None): """Update a filter. :param url: Camunda Rest engine URL. :param id_: Id of the filter. :param name: Name of the filter. :param owner: User id of the owner of the filter. """ super().__init__(url=url + URL_SUFFIX + '/{id}') self.id_ = id_ self.resource_type = 'Task' self.name = name self.owner = owner def __call__(self, *args, **kwargs) -> None: """Send the request""" super().__call__(pycamunda.base.RequestMethod.PUT, *args, **kwargs)
class UpdateProfile(pycamunda.base.CamundaRequest): id_ = PathParameter('id') new_user_id = BodyParameter('id') first_name = BodyParameter('firstName') last_name = BodyParameter('lastName') email = BodyParameter('email') def __init__(self, url: str, id_: str, new_user_id: str = None, first_name: str = None, last_name: str = None, email: str = None): """Update the profile information of an already existing user. :param url: Camunda Rest engine URL. :param id_: Id of the user. :param new_user_id: New user id of the user. :param first_name: New first name of the user. :param last_name: New last name of the user. :param email: New email of the user. """ super().__init__(url=url + URL_SUFFIX + '/{id}/profile') self.id_ = id_ self.new_user_id = new_user_id self.first_name = first_name self.last_name = last_name self.email = email def __call__(self, *args, **kwargs) -> None: """Send the request""" super().__call__(pycamunda.base.RequestMethod.PUT, *args, **kwargs)
class Update(pycamunda.base.CamundaRequest): id_ = PathParameter('id') name = BodyParameter('name') type_ = BodyParameter('type') def __init__(self, url: str, id_: str, name: str, type_: str): """Update a group. :param url: Camunda Rest engine URL. :param id_: Id of the group. :param name: New name of the group. :param type_: New zype of the group. """ super().__init__(url=url + URL_SUFFIX + '/{id}') self.id_ = id_ self.name = name self.type_ = type_ def body_parameters(self, apply: typing.Callable = ...): params = super().body_parameters(apply=apply) params['id'] = self.id_ return params def __call__(self, *args, **kwargs) -> None: """Send the request.""" super().__call__(pycamunda.base.RequestMethod.PUT, *args, **kwargs)
class IdentityLinksDelete(pycamunda.base.CamundaRequest): task_id = PathParameter('id') user_id = BodyParameter('userId') group_id = BodyParameter('groupId') type_ = BodyParameter('type') def __init__( self, url: str, task_id: str, type_: str, user_id: str = None, group_id: str = None ): """Delete an identity link of an user task. An identity link is a relationship between an user task and an user or a group. E.g. when the user is the assignee / owner or one of the candidate users of the task. :param url: Camunda Rest engine URL. :param task_id: Id of the task. :param user_id: Id of the user. Can not be provided if group_id is provided. :param group_id: Id of the groupt. Can not be provided if user_id is provided. :param type_: Type of the identity link. Can be any custom string. Pre-defined types are 'assignee' (user), 'owner' (user) and 'candidate' (user / group). """ assert (user_id is None) != (group_id is None), ( 'Either \'user_id\' or \'group_id\' has to be provided, not both.' ) super().__init__(url=url + URL_SUFFIX + '/{id}/identity-links/delete') self.task_id = task_id self.user_id = user_id self.group_id = group_id self.type_ = type_ def __call__(self, *args, **kwargs) -> None: """Send the request.""" super().__call__(pycamunda.base.RequestMethod.POST, *args, **kwargs)
class Evaluate(pycamunda.base.CamundaRequest): variables = BodyParameter('variables') business_key = BodyParameter('businessKey') tenant_id = BodyParameter('tenantId') without_tenant_id = BodyParameter('withoutTenantId', provide=pycamunda.base.value_is_true) process_definition_id = BodyParameter('processDefinitionId') def __init__(self, url: str, business_key: str = None, tenant_id: str = None, without_tenant_id: bool = False, process_definition_id: str = None): """Trigger the evaluation of conditional start events. :param url: Camunda Rest engine URL. :param business_key: Business key for the process instances that might be started. :param tenant_id: Tenant id of the conditions to evaluate. :param without_tenant_id: Whether evaluate only conditions that have no tenant. :param process_definition_id: Process definition id of the conditions to evaluate. """ super().__init__(url=url + URL_SUFFIX) self.business_key = business_key self.tenant_id = tenant_id self.without_tenant_id = without_tenant_id self.process_definition_id = process_definition_id self.variables = {} def add_variable(self, name: str, value: typing.Any, type_: str = None, value_info: typing.Mapping = None) -> None: """Add a variable for the evaluation of the conditions. :param name: Name of the variable. :param value: Value of the variable. :param type_: Value type of the variable. :param value_info: Additional information regarding the value type. """ self.variables[name] = { 'value': value, 'type': type_, 'valueInfo': value_info } def __call__( self, *args, **kwargs) -> typing.Tuple[pycamunda.processinst.ProcessInstance]: """Send the request.""" response = super().__call__(pycamunda.base.RequestMethod.POST, *args, **kwargs) return tuple( pycamunda.processinst.ProcessInstance.load(data=result_json) for result_json in response.json())
class _Event(pycamunda.base.CamundaRequest): name = BodyParameter('name') execution_id = BodyParameter('executionId') variables = BodyParameter('variables') tenant_id = BodyParameter('tenantId') without_tenant_id = BodyParameter('withoutTenantId', provide=pycamunda.base.value_is_true) def __init__(self, url: str, name: str, execution_id: str = None, tenant_id: str = None, without_tenant_id: bool = False): """Deliver a signal to all process definitions and executions with the specific signal handler. :param url: Camunda Rest engine URL. :param name: Name of the signal. :param execution_id: Id of the execution to deliver the signal to. :param tenant_id: Id of the tenant. Signal will only be delivered to process definitions or executions that belong to this tenant. :param without_tenant_id: Whether to deliver the signal only to process definitions or executions without tenant. """ super().__init__(url=url + URL_SUFFIX) self.name = name self.execution_id = execution_id self.tenant_id = tenant_id self.without_tenant_id = without_tenant_id self.variables = {} def add_variable(self, name: str, value: typing.Any, type_: str = None, value_info: typing.Mapping = None): """Add variables to the process after correlating the message. :param name: Name of the variable. :param value: Value of the variable. :param type_: Value type of the variable. :param value_info: Additional information regarding the value type. """ self.variables[name] = { 'value': value, 'type': type_, 'valueInfo': value_info } return self def __call__(self, *args, **kwargs) -> None: """Send the request.""" super().__call__(pycamunda.base.RequestMethod.POST, *args, **kwargs)
class VariablesModify(pycamunda.base.CamundaRequest): process_instance_id = PathParameter('id') modifications = BodyParameter('modifications') deletions = BodyParameter('deletions') def __init__(self, url: str, process_instance_id: str, deletions: typing.Iterable[str] = None): """Modify variables of a process instance. This can be either updating or deleting variables. :param url: Camunda Rest engine URL. :param process_instance_id: Id of the process instance. :param deletions: Variables to delete. """ super().__init__(url=url + URL_SUFFIX + '/{id}/variables') self.process_instance_id = process_instance_id self.deletions = deletions self.modifications = {} def add_variable(self, name: str, value: typing.Any, type_: str = None, value_info: typing.Any = None) -> None: """Add a variable to modify. :param name: Name of the variable. :param value: Value of the variable. :param type_: Value type of the variable. :param value_info: Additional information regarding the value type. """ self.modifications[name] = { 'value': value, 'type': type_, 'valueInfo': value_info } def body_parameters( self, apply: typing.Callable = ...) -> typing.Dict[str, typing.Any]: params = super().body_parameters(apply=apply) deletions = params.get('deletions', []) if isinstance(deletions, str): params['deletions'] = [deletions] else: params['deletions'] = list(deletions) return params def __call__(self, *args, **kwargs) -> None: """Send the request.""" super().__call__(pycamunda.base.RequestMethod.POST, *args, **kwargs)
class CreateInstance(pycamunda.base._PathMixin, pycamunda.base.CamundaRequest): id_ = PathParameter('id') key = PathParameter('key') tenant_id = PathParameter('tenant-id') variables = BodyParameter('variables') business_key = BodyParameter('businessKey') def __init__(self, url: str, id_: str = None, key: str = None, tenant_id: str = None, business_key: str = None): """Create a case instance. :param url: Camunda Rest engine URL. :param id_: Id of the case definition. :param key: Key of the case definition. :param tenant_id: Id of the tenant the case definition belongs to. :param business_key: The business key to initialize the case instance with. """ super().__init__(url=url + URL_SUFFIX + '/{path}/create') self.id_ = id_ self.key = key self.tenant_id = tenant_id self.business_key = business_key self.variables = {} def add_variable(self, name: str, value: typing.Any, type_: str = None, value_info: str = None) -> None: """Add a variable to initialize the case instance with. :param name: Name of the variable. :param value: Value of the variable. :param type_: Value type of the variable. :param value_info: Additional information regarding the value type. """ self.variables[name] = { 'value': value, 'type': type_, 'valueInfo': value_info } def __call__(self, *args, **kwargs) -> pycamunda.caseinst.CaseInstance: """Send the request.""" response = super().__call__(pycamunda.base.RequestMethod.POST, *args, **kwargs) return pycamunda.caseinst.CaseInstance.load(response.json())
class Create(pycamunda.base.CamundaRequest): name = BodyParameter('deployment-name') enable_duplicate_filtering = BodyParameter('enable-duplicate-filtering') deploy_changed_only = BodyParameter('deploy-changed-only') source = BodyParameter('deployment-source') tenant_id = BodyParameter('tenant-id') def __init__(self, url: str, name: str, source: str = None, enable_duplicate_filtering: bool = False, deploy_changed_only: bool = False, tenant_id: str = None): """Create a deployment with one or multiple resources (e.g. bpmn diagrams). :param url: Camunda Rest engine url :param name: Name of the deployment. :param source: Source of the deployment. :param enable_duplicate_filtering: Whether to check if a deployment with the same name already exists. If one does, no new deployment is done. :param deploy_changed_only: Whether to check if already deployed resources that are also contained in this deployment have changed. The ones that do not will not created again. :param tenant_id: Id of the tenant to create the deployment for. """ super().__init__(url=url + URL_SUFFIX + '/create') self.name = name self.source = source self.enable_duplicate_filtering = enable_duplicate_filtering self.deploy_changed_only = deploy_changed_only self.tenant_id = tenant_id self._files = [] def add_resource(self, file) -> None: """Add a resource to the deployment. :param file: Binary data of the resource. """ self._files.append(file) @property def files(self): return { f'resource-{i}': resource for i, resource in enumerate(self._files) } def __call__(self, *args, **kwargs) -> None: """Send the request.""" assert bool(self.files), 'Cannot create deployment without resources.' super().__call__(pycamunda.base.RequestMethod.POST, *args, **kwargs)
class _ActivateSuspend(pycamunda.base.CamundaRequest): id_ = PathParameter('id') key = PathParameter('key') tenant_id = PathParameter('tenant-id') suspended = BodyParameter('suspended') include_process_instances = BodyParameter('includeProcessInstances') execution_datetime = BodyParameter('executionDate') def __init__( self, url: str, suspended: bool, id_: str = None, key: str = None, tenant_id: str = None, include_process_instances: bool = None, execution_datetime: dt.datetime = None ): """Activate or Suspend a process definition. :param url: Camunda Rest engine URL. :param suspended: Whether to suspend or activate the process definition. :param id_: Id of the process definition. :param key: Key of the process definition. :param tenant_id: Id of the tenant the process definition belongs to. :param include_process_instances: Whether to cascade the action to process instances. :param execution_datetime: When to execute the action. If 'None' the action is immediately. """ super().__init__(url=url + URL_SUFFIX + '/{path}/suspended') self.suspended = suspended self.id_ = id_ self.key = key self.tenant_id = tenant_id self.include_process_instances = include_process_instances self.execution_datetime = execution_datetime @property def url(self): if self.id_ is not None: return self._url.format(path=self.id_) if self.tenant_id is not None: return self._url.format(path=f'key/{self.key}/tenant-id/{self.tenant_id}') return self._url.format(path=f'key/{self.key}') def __call__(self, *args, **kwargs) -> None: """Send the request.""" super().__call__(pycamunda.base.RequestMethod.PUT, *args, **kwargs)
class Complete(pycamunda.base.CamundaRequest): id_ = PathParameter('id') worker_id = BodyParameter('workerId') variables = BodyParameter('variables') local_variables = BodyParameter('localVariables') def __init__(self, url: str, id_: str, worker_id: str): """Complete an external task that is locked for a worker. :param url: Camunda Rest engine URL. :param id_: Id of the external task. :param worker_id: Id of the worker the external tasks was locked for. """ super().__init__(url=url + URL_SUFFIX + '/{id}/complete') self.id_ = id_ self.worker_id = worker_id self.variables = {} self.local_variables = {} def add_variable( self, name: str, value: str, type_: str = None, value_info: typing.Mapping = None ) -> None: """Add a variable to send to the Camunda process instance. :param name: Name of the variable. :param value: Value of the variable. :param type_: Value type of the variable. :param value_info: Additional information regarding the value type. """ self.variables[name] = {'value': value, 'type': type_, 'valueInfo': value_info} def add_local_variable( self, name: str, value: str, type_: str = None, value_info: typing.Mapping = None ) -> None: """Add a local variable to send to Camunda. Local variables are set only in the scope of an external task. :param name: Name of the variable. :param value: Value of the variable. :param type_: Value type of the variable. :param value_info: Additional information regarding the value type. """ self.local_variables[name] = {'value': value, 'type': type_, 'valueInfo': value_info} def __call__(self, *args, **kwargs) -> None: """Send the request""" super().__call__(pycamunda.base.RequestMethod.POST, *args, **kwargs)
class Resolve(pycamunda.base.CamundaRequest): id_ = PathParameter('id') variables = BodyParameter('variables') def __init__(self, url: str, id_: str): """Resolve an user task that was delegated to the current assignee and send it back to the original owner. It is necessary that the task was delegated. The assignee of the user task will be set back to the owner of the task. :param url: Camunda Rest engine URL. :param id_: Id of the user task. """ super().__init__(url=url + URL_SUFFIX + '/{id}/resolve') self.id_ = id_ self.variables = {} def add_variable( self, name: str, value: typing.Any, type_: str = None, value_info: typing.Any = None ) -> None: """Add a variable to send to the Camunda process instance. :param name: Name of the variable. :param value: Value of the variable. :param type_: Value type of the variable. :param value_info: Additional information regarding the value type. """ self.variables[name] = {'value': value, 'type': type_, 'valueInfo': value_info} def __call__(self, *args, **kwargs) -> None: """Send the request.""" super().__call__(pycamunda.base.RequestMethod.POST, *args, **kwargs)
class UpdateHistoryTimeToLive(pycamunda.base._PathMixin, pycamunda.base.CamundaRequest): id_ = PathParameter('id') key = PathParameter('key') tenant_id = PathParameter('tenant-id') history_time_to_live = BodyParameter( 'historyTimeToLive', validate=lambda val: val is None or val >= 0) def __init__(self, url: str, history_time_to_live: int, id_: str = None, key: str = None, tenant_id: str = None): """Update the history time to live of a case definition. :param url: Camunda Rest engine URL. :param history_time_to_live: New history time to live. Can be set to 'None'. :param id_: Id of the case definition. :param key: Key of the case definition. :param tenant_id: Id of the tenant the case definition belongs to. """ super().__init__(url=url + URL_SUFFIX + '/{path}/history-time-to-live') self.history_time_to_live = history_time_to_live self.id_ = id_ self.key = key self.tenant_id = tenant_id def __call__(self, *args, **kwargs) -> None: """Send the request.""" super().__call__(pycamunda.base.RequestMethod.PUT, *args, **kwargs)
class HandleBPMNError(pycamunda.base.CamundaRequest): id_ = PathParameter('id') worker_id = BodyParameter('workerId') error_code = BodyParameter('errorCode') error_message = BodyParameter('errorMessage') variables = BodyParameter('variables') def __init__( self, url: str, id_: str, worker_id: str, error_code: str, error_message: str = None ): """Report a business error for a running external task. :param url: Camunda Rest engine URL. :param id_: Id of the external task. :param worker_id: Id of the worker that locked the external task. :param error_code: Error code that identifies the predefined error. :param error_message: Error message that describes the error. """ super().__init__(url=url + URL_SUFFIX + '/{id}/bpmnError') self.id_ = id_ self.worker_id = worker_id self.error_code = error_code self.error_message = error_message self.variables = {} def add_variable( self, name: str, value: str, type_: str = None, value_info: typing.Mapping = None ) -> None: """Add a variable to send to the Camunda process instance. :param name: Name of the variable. :param value: Value of the variable. :param type_: Value type of the variable. :param value_info: Additional information regarding the value type. """ self.variables[name] = {'value': value, 'type': type_, 'valueInfo': value_info} def __call__(self, *args, **kwargs) -> None: """Send the request""" super().__call__(pycamunda.base.RequestMethod.POST, *args, **kwargs)
class HandleFailure(pycamunda.base.CamundaRequest): id_ = PathParameter('id') worker_id = BodyParameter('workerId') error_message = BodyParameter('errorMessage') error_details = BodyParameter('errorDetails') retries = BodyParameter('retries', validate=lambda val: val >= 0) retry_timeout = BodyParameter('retryTimeout', validate=lambda val: val >= 0) def __init__( self, url: str, id_: str, worker_id: str, error_message: str, error_details: str, retries: int, retry_timeout: int ): """Report a failure to execute a running external task. A number of retries and a timeout until the external task can be tried can be specified. If retries are set to 0, the external task cannot be fetched anymore and an incident is created. The message of the incident is set to the value of `error_message`. :param url: Camunda Rest engine URL. :param id_: Id of the external task. :param worker_id: Id of the worker that locked the external task. :param error_message: Error message that describes the reason of the failure. :param error_details: Error description. :param retries: How often the external task can be retried. :param retry_timeout: Timeout in milliseconds until the external task becomes available again for fetching. """ super().__init__(url=url + URL_SUFFIX + '/{id}/failure') self.id_ = id_ self.worker_id = worker_id self.error_message = error_message self.error_details = error_details self.retries = retries self.retry_timeout = retry_timeout def __call__(self, *args, **kwargs) -> None: """Send the request""" super().__call__(pycamunda.base.RequestMethod.POST, *args, **kwargs)
class Create(pycamunda.base.CamundaRequest): id_ = BodyParameter('id') name = BodyParameter('name') def __init__(self, url: str, id_: str, name: str): """Create a new tenant. :param url: Camunda Rest engine URL. :param id_: Id of the tenant. :param name: Name of the tenant. """ super().__init__(url=url + URL_SUFFIX + '/create') self.id_ = id_ self.name = name def __call__(self, *args, **kwargs) -> None: """Send the request""" super().__call__(pycamunda.base.RequestMethod.POST, *args, **kwargs)
class Update(pycamunda.base.CamundaRequest): id_ = PathParameter('id') permissions = BodyParameter('permissions') user_id = BodyParameter('userId') group_id = BodyParameter('groupId') resource_type = BodyParameter('resourceType') resource_id = BodyParameter('resourceId') def __init__(self, url: str, id_: str, permissions: typing.Iterable[str], resource_type: typing.Union[str, pycamunda.resource.ResourceType], resource_id: str, user_id: str = None, group_id: str = None): """Update an auth. :param url: Camunda Rest engine URL. :param id_: Id of the authorization. :param permissions: Permissions provided by this authorization. A permission be 'READ' or 'CREATE' for example. :param user_id: Id of the user this authorization is for. The value '*' means all users. :param group_id: Id of the group this authorization is for. :param resource_type: Resource type this authorization is for. :param resource_id: Id of the resource. The value '*' means all instances of a resource. """ super().__init__(url=url + URL_SUFFIX + '/{id}') self.id_ = id_ self.permissions = permissions self.user_id = user_id self.group_id = group_id self.resource_type = resource_type self.resource_id = resource_id def __call__(self, *args, **kwargs) -> None: """Send the request.""" assert (self.user_id is not None) != (self.group_id is not None), ( 'Either \'user_id\' or \'group_id\' has to be provided, not both.') super().__call__(pycamunda.base.RequestMethod.PUT, *args, **kwargs)
class Complete(pycamunda.base.CamundaRequest): id_ = PathParameter('id') variables = BodyParameter('variables') with_variables_in_return = BodyParameter('withVariablesInReturn') def __init__(self, url: str, id_: str, with_variables_in_return: bool = False): """Complete an user task. :param url: Camunda Rest engine URL. :param id_: Id of the user task. """ super().__init__(url=url + URL_SUFFIX + '/{id}/complete') self.id_ = id_ self.with_variables_in_return = with_variables_in_return self.variables = {} def add_variable( self, name: str, value: typing.Any, type_: str = None, value_info: typing.Any = None ) -> None: """Add a variable to send to the Camunda process instance. :param name: Name of the variable. :param value: Value of the variable. :param type_: Value type of the variable. :param value_info: Additional information regarding the value type. """ self.variables[name] = {'value': value, 'type': type_, 'valueInfo': value_info} def __call__( self, *args, **kwargs ) -> typing.Optional[typing.Dict[str, pycamunda.variable.Variable]]: """Send the request.""" response = super().__call__(pycamunda.base.RequestMethod.POST, *args, **kwargs) if self.with_variables_in_return: return { name: pycamunda.variable.Variable.load(var_json) for name, var_json in response.json().items() }
class SetRetriesSync(pycamunda.base.CamundaRequest): retries = BodyParameter('retries', validate=lambda val: val >= 0) external_task_ids = BodyParameter('externalTaskIds') process_instance_ids = BodyParameter('processInstanceIds') external_task_query = BodyParameter('externalTaskQuery') process_instance_query = BodyParameter('processInstanceQuery') historic_process_instance_query = BodyParameter('historicProcessInstanceQuery') def __init__(self, url: str, retries: int, external_task_ids: typing.Iterable[str]): """Sets the number of retries of external tasks synchronously. :param url: Camunda Rest engine URL. :param retries: New number of retries of the external tasks. :param external_task_ids: Ids of the external tasks. """ super().__init__(url=url + URL_SUFFIX + '/retries') self.retries = retries self.external_task_ids = external_task_ids self.process_instance_ids = None # TODO self.external_task_query = None # TODO self.process_instance_query = None # TODO self.historic_process_instance_query = None # TODO def __call__(self, *args, **kwargs) -> None: """Send the request""" super().__call__(pycamunda.base.RequestMethod.PUT, *args, **kwargs)
class Update(pycamunda.base.CamundaRequest): id_ = PathParameter('id') new_id = BodyParameter('id') new_name = BodyParameter('name') def __init__(self, url: str, id_: str, new_id: str, new_name: str): """Update a tenant. :param url: Camunda Rest engine URL. :param id_: Id of the tenant. :param new_id: New id of the tenant. :param new_name: New name of the tenant. """ super().__init__(url=url + URL_SUFFIX + '/{id}') self.id_ = id_ self.new_id = new_id self.new_name = new_name def __call__(self, *args, **kwargs) -> None: """Send the request""" super().__call__(pycamunda.base.RequestMethod.PUT, *args, **kwargs)
class Create(pycamunda.base.CamundaRequest): id_ = BodyParameter('id') first_name = BodyParameter('firstName') last_name = BodyParameter('lastName') email = BodyParameter('email') profile = BodyParameterContainer('profile', id_, first_name, last_name, email) password = BodyParameter('password') credentials = BodyParameterContainer('credentials', password) def __init__(self, url: str, id_: str = None, first_name: str = None, last_name: str = None, email: str = None, password: str = None): """Create a new user. :param url: Camunda Rest engine URL. :param id_: Id of the user. :param first_name: First name of the user. :param last_name: Last name of the user. :param email: Email of the user. :param password: Password of the user. """ super().__init__(url=url + URL_SUFFIX + '/create') self.id_ = id_ self.first_name = first_name self.last_name = last_name self.email = email self.password = password def __call__(self, *args, **kwargs) -> None: """Send the request""" super().__call__(pycamunda.base.RequestMethod.POST, *args, **kwargs)
class Create(_Criteria): resource_type = BodyParameter('resourceType') name = BodyParameter('name') owner = BodyParameter('owner') def __init__(self, url: str, name: str, owner: str = None): """Create a new filter. :param url: Camunda Rest engine URL. :param name: Name of the filter. :param owner: User id of the owner of the filter. """ super().__init__(url=url + URL_SUFFIX + '/create') self.resource_type = 'Task' self.name = name self.owner = owner def __call__(self, *args, **kwargs) -> Filter: """Send the request""" response = super().__call__(pycamunda.base.RequestMethod.POST, *args, **kwargs) return Filter.load(response.json())
class ExtendLock(pycamunda.base.CamundaRequest): id_ = PathParameter('id') new_duration = BodyParameter('newDuration') worker_id = BodyParameter('workerId') def __init__(self, url: str, id_: str, new_duration: int, worker_id: str): """Unlock an external task. :param url: Camunda Rest engine URL. :param id_: Id of the external task. :param new_duration: New duration in milliseconds how long the external task wants to be locked. :param worker_id: Id of the worker that locked this external task. """ super().__init__(url=url + URL_SUFFIX + '/{id}/extendLock') self.id_ = id_ self.new_duration = new_duration self.worker_id = worker_id def __call__(self, *args, **kwargs) -> None: """Send the request""" super().__call__(pycamunda.base.RequestMethod.POST, *args, **kwargs)
class UpdateCredentials(pycamunda.base.CamundaRequest): id_ = PathParameter('id') password = BodyParameter('password') authenticated_user_password = BodyParameter('authenticatedUserPassword') def __init__(self, url: str, id_: str, password: str, authenticated_user_password: str): """Update a user's credentials (password). :param url: Camunda Rest engine URL. :param id_: Id of the user. :param password: New password of the user. :param authenticated_user_password: Password of the authenticated user who changes the password. """ super().__init__(url=url + URL_SUFFIX + '/{id}/credentials') self.id_ = id_ self.password = password self.authenticated_user_password = authenticated_user_password def __call__(self, *args, **kwargs) -> None: """Send the request""" super().__call__(pycamunda.base.RequestMethod.PUT, *args, **kwargs)
class Configure(pycamunda.base.CamundaRequest): enable_telemetry = BodyParameter('enableTelemetry') def __init__(self, url: str, enable_telemetry: bool): """Modify the telemetry configuration. :param url: Camunda Rest engine URL. :param enable_telemetry: Whether to enable telemetry configuration. """ super().__init__(url=url + URL_SUFFIX) self.enable_telemetry = enable_telemetry def __call__(self, *args, **kwargs) -> None: """Send the request.""" super().__call__(pycamunda.base.RequestMethod.POST, *args, **kwargs)
class Evaluate(pycamunda.base._PathMixin, pycamunda.base.CamundaRequest): id_ = PathParameter('id') key = PathParameter('key') tenant_id = PathParameter('tenant-id') variables = BodyParameter('variables') def __init__(self, url: str, id_: str = None, key: str = None, tenant_id: str = None): """Evaluate the result of a decision definition. :param url: Camunda Rest engine URL. :param id_: Id of the decision definition. :param key: Key of the decision definition. :param tenant_id: Id of the tenant the decision definition belongs to. """ super().__init__(url=url + URL_SUFFIX + '/{path}/evaluate') self.id_ = id_ self.key = key self.tenant_id = tenant_id self.variables = {} def add_variable( self, name: str, value: typing.Any, type_: str = None, value_info: str = None ) -> None: """Add a variable for the evaluation of the decision definition. :param name: Name of the variable. :param value: Value of the variable. :param type_: Value type of the variable. :param value_info: Additional information regarding the value type. """ self.variables[name] = {'value': value, 'type': type_, 'valueInfo': value_info} def __call__(self, *args, **kwargs) -> typing.Tuple[typing.Dict]: """Send the request.""" response = super().__call__(pycamunda.base.RequestMethod.POST, *args, **kwargs) return tuple( { name: pycamunda.variable.Variable.load(var_json) for name, var_json in rule.items() } for rule in response.json() )
class UpdateHistoryTimeToLive(pycamunda.base.CamundaRequest): id_ = PathParameter('id') key = PathParameter('key') tenant_id = PathParameter('tenant-id') history_time_to_live = BodyParameter( 'historyTimeToLive', validate=lambda val: val is None or val >= 0 ) def __init__( self, url: str, history_time_to_live: int, id_: str = None, key: str = None, tenant_id: str = None ): """Update the history time to live of a process definition. :param url: Camunda Rest engine URL. :param history_time_to_live: New history time to live. Can be set to 'None'. :param id_: Id of the process definition. :param key: Key of the process definition. :param tenant_id: Id of the tenant the process definition belongs to. """ super().__init__(url=url + URL_SUFFIX + '/{path}/history-time-to-live') self.history_time_to_live = history_time_to_live self.id_ = id_ self.key = key self.tenant_id = tenant_id @property def url(self): if self.id_ is not None: return self._url.format(path=self.id_) if self.tenant_id is not None: return self._url.format(path=f'key/{self.key}/tenant-id/{self.tenant_id}') return self._url.format(path=f'key/{self.key}') def __call__(self, *args, **kwargs) -> None: """Send the request.""" response = super().__call__(pycamunda.base.RequestMethod.PUT, *args, **kwargs)
class _ActivateSuspend(pycamunda.base.CamundaRequest): id_ = PathParameter('id') suspended = BodyParameter('suspended') def __init__(self, url: str, id_: str, suspended: bool): """Activate or Suspend a process definition. :param url: Camunda Rest engine URL. :param id_: Id of the process instance. :param suspended: Whether to suspend or activate the process instance. """ super().__init__(url=url + URL_SUFFIX + '/{id}/suspended') self.id_ = id_ self.suspended = suspended def __call__(self, *args, **kwargs) -> None: """Send the request.""" super().__call__(pycamunda.base.RequestMethod.PUT, *args, **kwargs)