Advanced model settings
Last updated
Last updated
All type of nodes in the BPMN model has advanced settings. This document explains each.
This setting determines whether an activity should be executed asynchronously, meaning it runs independently in the background without blocking the process flow.
Before: If the "Before" checkbox is selected for an activity, it means that the process engine will first complete the asynchronous continuation of the activity before proceeding to the next activity. This allows for parallel execution and asynchronous processing.
After: If the "After" checkbox is selected for an activity, it means that the process engine will complete the asynchronous continuation of the next activity before completing the current activity. This enables deferred or delayed processing of subsequent activities.
By utilizing these checkboxes, you can control the order of execution for activities and determine whether they should be completed before or after the next activity. This flexibility allows for asynchronous behaviour in the process, where activities can be executed in parallel or with deferred processing, enhancing efficiency and scalability.
Example: By selecting the "before" checkbox, the activity will be executed asynchronously before the current activity completes, allowing for parallel processing.
The Business Key setting allows you to assign a unique identifier to each instance of a process. It helps you track and correlate specific instances of the process.
Key: Allows you to select a value from the form fields to define the business key for the process instance.
Example: If the form contains a field named "orderId," selecting "orderId" from the key select box will set the business key of the process instance to the value entered in the "orderId" field.
The Called Element setting is used to define the process or global task that is invoked when a Call Activity is executed. It specifies which process or task to execute when the Call Activity is reached. The configuration for the Called Element setting includes the following fields:
Called element: This field allows you to specify the identifier or key of the process or global task that should be executed when the Call Activity is reached. It can be the process definition key or ID.
Example: Called element: "myProcess" specifies that the process with the key or ID "myProcess" should be executed when the Call Activity is reached.
Binding: The Binding field determines the scope of the called element. It specifies how the called element should be treated and resolved.
Latest: Indicates that the latest version of the process or global task should be used.
Deployment: Specifies that a specific deployment version of the process or global task should be used.
Version: Allows you to specify a specific version of the process or global task.
Tenant ID: The Tenant ID field allows you to specify a tenant ID for the called element. It associates the called element with a specific tenant in a multi-tenant environment.
Example: Tenant ID: "myTenant" associates the called element with the tenant "myTenant".
Business key: The Business Key checkbox indicates whether a business key should be provided for the called element. A business key is an identifier associated with the process or global task and can be used for tracking or correlation purposes.
Example: Business key: Selected. This indicates that a business key should be provided for the called element.
Delegate Variable Mapping: The Delegate Variable Mapping field determines how variables should be mapped between the calling process and the called process or global task.
The Compensation setting is used to specify a compensating action for an activity. It defines how the process should be compensated or reversed in case of a cancellation or error.
Wait for completion: Indicates whether the process should wait for the compensation activity to complete before continuing.
Activity reference: Allows you to select the activity to be compensated.
Example: By selecting the "wait for completion" checkbox and choosing the activity reference "Cancel Order" from the select box, the process will pause until the "Cancel Order" activity completes its compensation.
The Condition setting for the Conditional Intermediate Catch Event allows you to specify a condition that triggers the event to occur. It enables you to create a waiting state within the process until a specific condition is met. The condition can be defined using expressions or scripting languages like JavaScript or Groovy.
When the process reaches the Conditional Intermediate Catch Event, it evaluates the condition. If the condition is true, the event is triggered, and the process flow continues. If the condition is false, the process remains in a waiting state until the condition becomes true.
Variable name: Specifies the name of the variable used in the condition expression.
Variable events: Specifies the events that trigger the evaluation of the condition.
Type: Specifies the type of condition:
Expression
Script
Condition expression: Specifies the expression or script used as the condition.
Example: Variable name to "quantity," variable events to "create" and "update," type to "expression," and condition expression to "quantity > 10" will evaluate the condition based on the value of the "quantity" variable during creation and update events.
This setting allows you to define input parameters for a connector in your BPMN model. Connectors are used to interact with external systems or services, and the input parameters specify the data that needs to be provided to the connector for its execution.
Local variable: Specifies the name of the local variable for the connector input.
Assignment type: Specifies the type of assignment for the connector input:
List: Specifies that the connector input is assigned a list of values.
Map: Specifies that the connector input is assigned a key-value mapping.
String: Specifies that the connector input is assigned a single string value.
Script: Specifies that the connector input is assigned a script, allowing for more complex logic or calculations to determine the input value.
Expression: Specifies that the connector input is assigned an expression, which can refer to variables or functions to dynamically determine the input value.
Value: Specifies the value assigned to the connector input.
Example: Local variable name to "customerId," assignment type to "string," and value to "12345" will assign the string value "12345" to the connector input variable "customerId."
The Connector Outputs setting enables you to define the output variables that are generated or returned by a connector. These variables hold the result or response received from the external system or service after the connector's execution.
Process variable: Specifies the name of the process variable for the connector output.
Assignment type: Specifies the type of assignment for the connector output
List: Specifies that the connector input is assigned a list of values.
Map: Specifies that the connector input is assigned a key-value mapping.
String: Specifies that the connector input is assigned a single string value.
Script: Specifies that the connector input is assigned a script, allowing for more complex logic or calculations to determine the input value.
Expression: Specifies that the connector input is assigned an expression, which can refer to variables or functions to dynamically determine the input value.
Value: Specifies the value assigned to the connector output.
Example: Process variable name to "orderStatus," assignment type to "expression," and value to "result.status" will assign the value of the expression "result.status" to the process variable "orderStatus."
The Candidate Starter setting specifies the users or groups who are potential candidates to start or initiate a process instance. It determines who has the permission or authorization to trigger the process.
Candidate starter groups field: Specifies the candidate groups who can start the process or task.
Candidate starter users field: Specifies the candidate users who can start the process or task.
Example: Candidate starter groups to "managers" and candidate starter users to "john.doe" will allow managers and user "john.doe" to start the process or task.
This setting provides a space for adding descriptive text or documentation to the BPMN model. It allows you to include additional information or explanations that help others understand the process.
Element documentation: Allows you to provide detailed documentation for the BPMN element.
Example: In the element documentation field, you can add detailed instructions, notes, or explanations about the purpose and behaviour of the BPMN element.
The Escalation setting is used to define and handle escalation events in a BPMN process. It specifies how the process should respond or escalate when certain conditions or events occur.
Global escalation reference: Allows you to select an existing global escalation or create a new one by providing a name.
Example: Selecting an existing global escalation reference named "OrderNotFound" will associate the escalation event with the "OrderNotFound" escalation.
The Error setting allows you to define and handle specific errors that may occur during the process execution. It helps you manage and handle errors in a structured manner.
Global error reference: Allows you to select an existing global error.
Example: Choosing the global error reference "InvalidInput" will associate the error event with the "InvalidInput" error and will drop the error "Code" and "Message" if needed.
Extension Properties allow you to define additional custom properties or metadata for BPMN elements. These properties can hold extra information or configuration settings specific to your process or implementation requirements.
The Execution Listeners setting defines listeners or event handlers that are triggered during specific execution events or states within the BPMN process. It allows you to add custom logic or actions at specific points during process execution.
Event type: Specifies the event type for the extension listener, either start or end.
Listener type: Specifies the type of listener
Java Class: Specifies that the listener is implemented as a Java class. It allows you to provide a fully qualified class name that implements the necessary listener interface.
Expression: Specifies that the listener is implemented as an expression. It allows you to provide an expression that will be evaluated at runtime to determine the listener's behaviour.
Delegate Expression: Specifies that the listener is implemented as a delegate expression. It allows you to provide an expression that resolves to an instance of a delegate object, which will handle the listener logic.
Script: Specifies that the listener is implemented as a script. It allows you to provide a script in a specific scripting language (e.g., JavaScript, Groovy, etc.) that will be executed as the listener logic.
Field injection opportunity: Provides fields for injecting additional values to the listener.
Name: Specifies the name of the field to be injected.
Type: Specifies the type of the field injection, either String or Expression.
Value: Specifies the value to be injected into the field.
Example: Adding a new extension listener with event type "start," listener type "Java Class," Java class "com.example.MyListener," and field injection with name "orderId," type "Expression," and value "execution.getVariable('orderId')" will invoke the "MyListener" Java class with the "orderId" value retrieved from the execution's variables.
The External Task setting represents a task that is performed outside of the BPMN engine. It allows you to delegate the execution of a task to an external worker or system, which can be monitored and managed through the BPMN process.
: Specifies the priority of the external task.
Example: Setting the priority to "50" will assign a priority of 50 to the external task.
The Inputs setting specifies input mappings for a BPMN element. It defines how data should be passed into the element from external sources or previous activities.
Local variable name: Specifies the name of the local variable for the input.
Assignment type: Specifies the type of assignment input
List: Specifies that the connector input is assigned a list of values.
Map: Specifies that the connector input is assigned a key-value mapping.
String: Specifies that the connector input is assigned a single string value.
Script: Specifies that the connector input is assigned a script, allowing for more complex logic or calculations to determine the input value.
Expression: Specifies that the connector input is assigned an expression, which can refer to variables or functions to dynamically determine the input value.
Value: Specifies the value assigned to the input.
Example: Adding an input with local variable name "customerId," assignment type "string," and value "12345" will assign the string value "12345" to the input variable "customerId."
This setting determines how input mappings should be propagated to nested BPMN elements. It specifies whether the input mappings defined for a parent element should be passed down to its child elements.
Propagate all variables: Indicates whether all variables should be propagated in mapping.
Example: By selecting the "propagate all variables" checkbox, all variables available in the current scope will be propagated in the in mapping.
The In Mappings setting defines input mappings that specify how data should be retrieved and assigned to BPMN elements. It determines how data is passed from one element to another within the process.
Type: Specifies the type of the in mapping, either Source or Source Target.
Source: Specifies the source of the mapping.
Target: Specifies the target of the mapping.
Local: Indicates whether the mapping should be local to the current scope.
Example: Adding an in mapping with type "Source," source "inputData," target "executionVariable," and selecting the "local" checkbox will map the value of the "inputData" to the local execution variable "executionVariable."
The Implementation setting specifies the implementation details for a BPMN element. It determines how a particular element should be executed, such as invoking a specific service or script.
Type: Specifies the implementation type
DMN (Decision Model and Notation):
Specifies a decision model based on DMN.
Allows separation of decision logic from the process flow.
External:
Implementation is handled externally to the BPMN process.
Can invoke external systems or services.
Java Class:
Specifies a custom Java class implementation.
Requires providing the fully qualified class name.
Enables custom logic and integration with Java libraries.
Expression:
Implementation is based on an expression.
Supports scripting languages or expression languages like Java EL or Groovy.
Delegate Expression:
Implementation is based on a delegate expression.
Enables dynamic resolution and invocation of a delegate object.
Provides flexibility in selecting the implementation at runtime.
Connector:
The implementation uses a connector to interact with external systems.
Provides a standardized way to configure and invoke external APIs.
Simplifies integration with various systems and services.
Example: Selecting the implementation type "DMN" will indicate that the BPMN element is implemented using a Decision Model and Notation.
The Field Injections setting allows you to inject values into fields of a BPMN element. It enables you to provide specific data or configurations to the element at runtime.
Name: Specifies the name of the field to be injected.
Type: Specifies the type of field injection:
Java Class: Specifies that the listener is implemented as a Java class. It allows you to provide a fully qualified class name that implements the necessary listener interface.
Expression: Specifies that the listener is implemented as an expression. It allows you to provide an expression that will be evaluated at runtime to determine the listener's behaviour.
Delegate Expression: Specifies that the listener is implemented as a delegate expression. It allows you to provide an expression that resolves to an instance of a delegate object, which will handle the listener logic.
Script: Specifies that the listener is implemented as a script. It allows you to provide a script in a specific scripting language (e.g., JavaScript, Groovy, etc.) that will be executed as the listener logic.
Value: Specifies the value to be injected into the field.
Example: Adding a field injection with name "orderId," type "Expression," and value "execution.getVariable('orderId')" will inject the value of the "orderId" variable into the specified field.
The Forms setting enables the design and integration of user forms within the BPMN process. It provides a way to create user-friendly interfaces for interacting with the process.
Type: Specifies the type of form:
Generated Task Form (Recommended):
This type of form is used by default for Stackflows environment.
This option refers to a form that is automatically generated based on the process definition or task configuration in Camunda.
The form fields and layout are generated dynamically, often based on the associated BPMN model.
It provides a quick way to generate forms without the need for manual form design.
Embedded or External Task Forms:
This option allows you to define forms externally using frameworks such as HTML, JavaScript, or other form-modelling tools.
The form can be embedded within the BPMN process or referenced externally through a URL.
You have more flexibility and control over the form design and behaviour using this option.
The form can be customized according to specific requirements and can leverage advanced UI capabilities.
Camunda Forms:
This option refers to forms created and managed using Camunda's native form modelling capabilities.
Camunda Forms provide a user-friendly interface within the Camunda Modeler to design and configure forms.
You can define form fields, layout, validation rules, and other form-related properties using this option.
Camunda Forms offer a convenient way to design forms directly within the BPMN modelling environment.
Generated Task Form is used by default for the Stackflows environment.
The Form Fields setting defines the fields or input elements within a user form for capturing data during process execution. It helps design user interfaces for user tasks and allows users to provide input to the process.
ID: Specifies a unique identifier for the form field.
Label: Provides a descriptive label for the form field.
Type: Specifies the type of the form field, which can be one of the following options:
Boolean: Represents a checkbox or toggle switch.
Date: Represents a date picker for selecting a date.
String: Represents a text input field.
Enum: Represents a dropdown select field with predefined options.
Long Custom: Represents a custom form field type with additional configuration.
Default Value: Allows you to set a default value for the form field.
Here's an example to illustrate the usage of the form fields:
Field 1:
ID: firstName
Label: First Name
Type: String
Default Value: John Doe
Field 2:
ID: email
Label: Email Address
Type: String
Field 3:
ID: department
Label: Department
Type: Enum
Default Value: Sales
Enum Options: Sales, Marketing, Finance
This configuration includes properties such as Name and ID that provide essential information about the BPMN model. Here's a closer look at these fields:
Name: The Name field represents the descriptive title or label assigned to the BPMN model. It serves as a human-readable identifier and helps stakeholders quickly understand the purpose or scope of the process.
ID: The ID field refers to a unique identifier assigned to the BPMN model. This identifier distinguishes the model from others and enables precise referencing and identification within the BPMN ecosystem. The ID is typically auto-generated by modelling tools or can be manually assigned.
These fields in the General configuration clearly identify and describe the BPMN model, allowing for effective communication, collaboration, and process management throughout its lifecycle.
The History Cleanup setting configures the cleanup or deletion of historical data related to process instances, tasks, or other BPMN entities. It helps manage the size and storage of historical data to optimize system performance and comply with data retention policies.
: Specifies the duration for which historical data should be retained.
Example: Setting the time to live to "30 days" will retain historical data for 30 days before cleanup.
Job Executions refer to the scheduling and execution of asynchronous jobs within the BPMN process. This setting allows you to configure and manage the execution of these jobs, which may include tasks, timers, or other types of background processes.
Priority: Specifies the priority of job executions.
Retry time cycle: Specifies the time cycle for job retries.
Example: Setting the priority to "50" and retry time cycle to "PT10M" will assign a priority of 50 and retry the job every 10 minutes.
Link Intermediate Catch Event allows you to define a link that triggers the event to occur. It provides a way to connect different parts of the process flow by establishing a link between a Link Intermediate Throw Event and a Link Intermediate Catch Event.
You can assign a unique identifier or name to the link, and when the process reaches the Link Intermediate Catch Event with the matching link name, the event is triggered, and the process flow continues.
Name: Specifies the name of the link.
Example: Adding a link with the name "Documentation" will create a link with the label "Documentation" associated with the BPMN element.
The Messages setting specifies the messages used for communication between different BPMN elements. It defines the content and structure of the messages exchanged during process execution.
Global message reference: Allows you to select an existing global message or create a new one by providing a name.
Example: Selecting an existing global message reference named "OrderReceived" will associate the message event with the "OrderReceived" message.
The Outputs setting specifies output mappings for a BPMN element. It determines how data should be passed from the element to subsequent elements or external systems.
Process variable name: Specifies the name of the process variable for the output.
Assignment type: Specifies the type of assignment for the output, such as list, map, string, script, or expression.
Value: Specifies the value assigned to the output.
Example: Adding an output with process variable name "result," assignment type "expression," and value "execution.getVariable('result')" will assign the value of the expression "execution.getVariable('result')" to the process variable "result."
This setting determines how output mappings should be propagated to nested BPMN elements. It specifies whether the output mappings defined for a parent element should be passed down to its child elements.
Propagate all variables: Indicates whether all variables should be propagated in the out mapping.
Example: By selecting the "propagate all variables" checkbox, all variables available in the current scope will be propagated in the out mapping.
The Out Mappings setting defines output mappings that specify how data should be assigned and passed to subsequent BPMN elements. It determines how data is transmitted from one element to another within the process.
Type: Specifies the type of the in mapping, either Source or Source Target.
Source: Specifies the source of the mapping.
Target: Specifies the target of the mapping.
Local: Indicates whether the mapping should be local to the current scope
Example: Setting the type as "Source," source as "orderAmount," target as "totalPrice," and checking the "Local" checkbox will create a local mapping from "orderAmount" to "totalPrice."
The Process Variables setting represents variables used within the BPMN process. They are used to store and manipulate data during process execution. This setting itself does nothing except collect all variables used in BPMN model.
The Script setting allows the execution of scripts (e.g., JavaScript, Groovy) within the BPMN process. It enables you to include custom code or logic to be executed at specific points during process execution.
Format: Field to specify the format of the script.
Type: Select box with values
External Resource: This type allows you to reference an external script resource. You can specify the location or path to the script file that contains the custom code or logic. The BPMN engine will load and execute the script from the specified external resource.
Inline: This type allows you to directly write the script code within the BPMN model itself. You can enter the script code directly into the field, without the need for an external file.
Example for External Resource: If you have a JavaScript file named "customScript.js" located in the "resources/scripts" directory of your BPMN project, you can provide the path as "resources/scripts/customScript.js" in the field.
The Signal setting defines and handles signals used for communication between different BPMN elements. It enables elements to send or receive signals, triggering specific actions or events.
Global signal reference: This setting enables you to create new signals by providing a signal name. Signals can be thought of as messages or notifications that can be sent and received within a BPMN process.
Example: A global signal reference named "OrderReceived" is created. Within a BPMN process, when an order is received, the process sends the "OrderReceived" signal. Other process elements, such as event subprocesses or message events, can catch this signal and initiate corresponding actions, such as sending notifications or updating data.
The Start Initiator setting determines the entity or event responsible for triggering the start of the process. It specifies what triggers the process to begin its execution.
Initiator: This field specifies the start initiator, which defines the user or identity initiating the process instance.
Example: Setting the start initiator as "John Doe" means that the process instance will be initiated by the user with the identity "John Doe."
The Tasklist setting pertains to the configuration of the user interface and functionalities available in the Camunda Tasklist application. It allows you to customize the appearance and behaviour of the user interface for managing and interacting with tasks within the BPMN process.
Startable: This checkbox indicates whether the task is startable, allowing users to manually initiate the associated task.
The Task Listener setting defines listeners or event handlers associated with user tasks. It allows you to execute custom logic or actions when specific events occur during the lifecycle of a user task.
Event type: This select box specifies the type of event to which the listener is attached, such as create, assign, complete, delete, update, or timeout.
Listener ID: This field specifies the listener ID.
Listener type: This select box defines the type of listener:
Java Class: Specifies that the listener is implemented as a Java class. It allows you to provide a fully qualified class name that implements the necessary listener interface.
Expression: Specifies that the listener is implemented as an expression. It allows you to provide an expression that will be evaluated at runtime to determine the listener's behaviour.
Delegate Expression: Specifies that the listener is implemented as a delegate expression. It allows you to provide an expression that resolves to an instance of a delegate object, which will handle the listener logic.
Script: Specifies that the listener is implemented as a script. It allows you to provide a script in a specific scripting language (e.g., JavaScript, Groovy, etc.) that will be executed as the listener logic.
Example: Adding a task listener with event type "complete," listener ID "taskCompletionListener," listener type "Java Class," and Java class "com.example.TaskCompletionListener" allows you to execute custom logic when the associated task is completed.
The Timer setting allows you to schedule time-based events within the BPMN process. A timer can be associated with a specific task or event, and it triggers the execution of that task or event at a specified time or after a certain duration.
Value: This field specifies the timer value, which determines when the timer event should be triggered.
Options: This select box allows you to choose the type of timer
Date: Selecting the "date" option allows you to specify an exact point in time when the timer event should be triggered. The timer value should be provided in a valid date and time format, following standard conventions.
Duration: Choosing the "duration" option enables you to specify a time duration after which the timer event should be triggered. The timer value should be provided in the ISO 8601 duration format, indicating the length of time.
Cycle: Selecting the "cycle" option allows you to define a repeating pattern for the timer event. The timer value should be provided in the ISO 8601 duration format, indicating the interval at which the timer event should be repeated.
Date example: Setting the timer value to "2023-06-30T09:00:00" triggers the timer event at 9:00 AM on June 30, 2023.
Duration example: Setting the timer value to "PT2H30M" triggers the timer event after 2 hours and 30 minutes from the point of execution.
Cycle example: Setting the timer value to "R/PT1M" triggers the timer event every minute, creating a recurring cycle.
The User Assignment setting specifies user assignments for user tasks, determining who should perform the tasks and their respective roles or groups. It assigns responsibilities to users or groups within the process.
Assignee: The Assignee field is used to assign a single user to the task or process element. You can specify the username, user ID, or any other identifier associated with the user. Only the assigned user will have the responsibility to complete the task.
Example: Assignee: "john.doe" assigns the task or process element to the user with the username "john.doe".
Candidate Users: The Candidate Users field allows you to specify a list of potential users who can claim and work on the task or process element. It provides flexibility in task assignment and enables multiple users to collaborate or work on the same task.
Example: Candidate Users: ["user1", "user2", "user3"] allows users "user1", "user2", and "user3" to claim and work on the task or process element.
Candidate Groups: The Candidate Groups field allows you to specify a group or groups to which the task or process element is assigned. Any member of the assigned group can claim and work on the task or process element. This is useful when you want to assign tasks based on user roles or organizational structure.
Example: Candidate Groups: ["managers"] assigns the task or process element to the group with the name "managers". Any member of the "managers" group can claim and work on the task or process element.
Due Date: The Due Date field allows you to specify a deadline for completing the task or process element. It helps in prioritizing and managing tasks based on their urgency and time sensitivity.
Example: Due Date: "2023-07-31" sets the deadline for completing the task or process element as July 31, 2023.
Follow-Up Date: The Follow-Up Date field is used to schedule a reminder or follow-up action for the task or process element. It helps in tracking and managing pending or upcoming tasks to ensure timely completion.
Example: Follow-Up Date: "2023-07-15" sets a follow-up action for the task or process element on July 15, 2023.
Priority: The Priority field allows you to assign a priority level to the task or process element. It helps in prioritizing tasks and managing workload based on their importance or criticality.
