Skip to content


Java scripts and Groovy scripts are embedded in the process through scripting activity and executed by the automatic client. The associated component>executeScript->executeScript is integrated into the process like all other activities from the Activity Repository using the drag and drop principle. BSH scripts have been deprecated and are no longer supported. We recommend using Groovy scripts, and we'll take a closer look at that activity here.

Scripting Wizard

After embedding the activity, the wizard pages open immediately, where you should enter the script to be executed. We use groovy scripts in our examples because Groovy is a powerful and dynamic language with which you can easily edit the process data. The data to be processed in the activity are entered as input parameters where the optional parameters may be null. The output parameters must be set in the script, only the optional ones can remain null. The parameters should be named in a Java-compliant way.

All parameters are available in the script and can be added to the script by double-clicking. The input parameters are marked in green, the output parameters in red. After entering the script, you can use Execute Script to check for syntax errors or do a test execution on the test execution page by clicking Set test input values. The errors that have occurred are then displayed on the left above the wizard page.

In the test execution, enter the values ​​for the input parameters by clicking the cell editor. Run the script using the Execute Script button and check the result in the Output Values ​​area below.

Example Parsing and Producing JSON

In this example we will see how to encapsulate parameter values ​​of simple primitive data types in a JsonObject. As Json builder we use the class JsonOutput which is responsible for String serializing the Json structures. In this case we serialise Groovy objects (String and Integer variables) into Json String. But we need the method toJson that take the various parameter types and returns a string representing the Json Array. First of all you have to import the JsonOutput with a import statement.

import groovy.json.JsonOutput
$json = JsonOutput.toJson([name: $name, age: $age])

To access this JSON text (parameter $json) like a JSON object, we parse it into a groovy object using Jsonslurper. This class parses Json text into Groovy data structure such as maps or lists etc. For that there are some parse methods with appropiate data types. We use parseText to convert this Json string to a list or map of object. Then we can access the individual elements of this object.

import groovy.json.JsonSlurper
def jsonSlurper = new JsonSlurper()
def person = jsonSlurper.parseText($json)
$name =
$age = person.age

For more information about Json in Groovy see Apache Groovy. You can download an example template here with the above Groovy scripts that will parse and produce Json.

Example Udt Lists

The udt lists are marked with the udt name List, whereby all data types such as INTEGER, STRING, BOOLEAN ... or a user defined data type can occur as type. A Udt list can also contain elements of different types. In the following example we show how easy it is to handle Udt lists in Groovy.

By default, when defining a list without specifying a type, groovy creates a list of java.util.ArrayList. The list elements are assigned to a variable in square brackets separated by commas. Groovy offers certain shortcuts when working with lists e.g. >> is used to add an item to the list. For more information about list handling see Groovy Documentation.

In the following process we calculate the age from date of birth of a user form. We generate a list from the user inputs for $name and $dateOfBirth and add it later the calculated age. At the end process step we display this age from the last element of the list in a new user form.

For the output $age, the period between today and birthday is calculated with the help of the LocalDate class. The value of the variable age is added to the list and written from the list to the output parameter $age. The associated script looks like this.

import java.time.*
LocalDate today =;
LocalDate birthday = new java.sql.Date($dateOfBirth.getTime()).toLocalDate();
def age = Period.between(birthday, today).years; 
def list = [$name, $dateOfBirth]
list << age
// same as: list.add(age)
$age = list.getAt(list.size()-1);