Skip to main content
There are cases when extra configuration is needed on certain nodes to enhance process management and execution.

Subprocess

 The Call Activity node contains a default action for starting a subprocess, which can be started in two modes:
  • Async mode: The parent process will continue without waiting for the subprocess to finish.
Select if this task should be invoked asynchronously. Make tasks asynchronous if they cannot be executed instantaneously, for example, a task performed by an outside service.
  • Sync mode: The parent process must wait for the subprocess to finish before advancing.
The start mode can be chosen when configuring the call activity. If the parent process needs to wait for the subprocess to finish and retrieve results, the parent process key that will hold the results must be defined using the output key node configuration value.

​
Starting multiple subprocesses

​
Parallel multi-instance

The Call Activity node can also be used for starting a set of subprocesses that will be started and run at the same time. This is useful when there is an array of values in the parent process parameters, and a subprocess needs to be started for each element in that array.

​
Configuration options

When configuring parallel multi-instance on a Call Activity node, you have access to the following configuration options:
  • Input Array: Declare the array used for subprocess input. Map the array of objects or the keys inside the array of objects to the destination object or its keys from the subprocess.
  • Output Array: Declare the array used for subprocess output. Map from the subprocess object back to an array of objects in the parent process.
  • Correlation attribute: The attribute that will be used to correlate subprocess results with parent process data.

​
Data mapping

In the Data Mapping section, when Parallel Multi-instance is enabled, you can configure:
New data mapping
  1. Declare arrays: Define the arrays used for subprocess input and subprocess output
  2. Input mapping: In the mapping modal, map the array of objects or the keys inside the array of objects to the destination object or its keys from the subprocess
  3. Output mapping: Map from the subprocess object back to an array of objects in the parent process
Legacy mapping
Legacy mapping works using current mechanics in both configuration and runtime, with no changes to existing features.
When you change the arrays in the node configuration and save, any existing mappings for input and output will be automatically deleted.

​
Correlation attribute behavior

When results from parallel subprocesses are returned, the correlation attribute determines how the subprocess payload is handled:
  • Update existing element: When the correlation attribute value from the subprocess payload matches one or more elements in the parent process array, those elements are updated with the subprocess payload
  • Insert new element: When the correlation attribute value from the subprocess payload doesn’t match any records in the parent process array, the payload is inserted as a new element in the array
This allows for flexible data handling where subprocesses can either update existing records or add new ones based on the correlation logic.

​
Dismissing unfinished subprocesses

When subprocesses are started in Sync mode:
  • If the token is advanced due to another action being performed in the process
  • Then the subprocesses that haven’t finished are automatically dismissed
This ensures that the parent process can continue without waiting indefinitely for subprocesses that may not complete.

​
Business rule example

Below is an example of an MVEL business rule used to generate a list of shipping codes: 
import java.util.*;

def mapValues(shippingCode) {
    return {
        "shippingCode": shippingCode
    }
}

shippingCodeList = [];

shippingCodeList.add(mapValues("12456"));
shippingCodeList.add(mapValues("146e3"));
shippingCodeList.add(mapValues("24356"));
shippingCodeList.add(mapValues("54356"));
output.put("shippingCodeList", shippingCodeList);
In this example, the shippingCodeList array contains multiple shipping code maps. Each of these maps could represent parameters for individual subprocesses. The ability to generate and handle such arrays allows the system to dynamically start and manage multiple subprocesses based on the elements in the array, enabling parallel processing of tasks or operations. To achieve this, select the parallel multi-instance option. The input array name from the parent process also needs to be specified.
When designing such a subprocess that will be started in a loop, remember that the input value for the subprocess (one of the values from the array in the parent process) will be stored in the subprocess parameter values under the key named item. This key should be used inside the subprocess. If this subprocess produces any results, they should be stored under a key named result to be sent back to the parent process.

​
Subprocess business rule example

Here’s an MVEL business rule for a subprocess that processes shipping codes: 
import java.util.*;

map = new HashMap();

if (input.item.shippingCode.startsWith("1")) {
    map.package = "Fragile";
} else {
    map.package = "Non-fragile";
}

map.shippingCode = input.item.shippingCode;

output.put("result", map);

​
Result (one of the subprocess instances)

The result shows the output of a process that has handled multiple shipping codes. The structure is: 
{
    "package": "Non-fragile",
    "shippingCode": "54356"
}
This contains the result of processing the specific shipping code, indicating additional attributes related to the shipping code (for example, package type) determined during the subprocess execution.