All necessary steps are configured in the action block of an Execute with event action, which defines the candidates list variable with the list of eligible Users as a temporary reference object via the Object resolver parameter:

• A Set value event action uses the Calculate value resolver to determine a random value from the value range for the index of the given list, which is saved in the Variable randomIndex:
  
  

  • For the calculation, two input values are mapped to variables for the calculation: A Random long value (Variable name random) and the length (length) of the list (Variable name entries).
    
    

  • The calculation first determines the absolute value of the random number, as only positive values are desired, and then uses the modulo operator (%) to obtain the residual value of an integer division by the number of options (entries). This value is always between 0 and length-1, which corresponds exactly to the value range for the index in the user list.
    
    

• In the Dispatch action event event action, the List item value resolver is used, which uses the Mode ‘Get first’ and refers to the name of the variable (randomIndex) filled by the Set value resolver in the Offset.
  
  ►NOTE◄ The Offset cannot be calculated directly because the parameter does not provide a value configuration but only a static value that is interpreted either directly as an index value (number) or as a variable name (text).

The screenshot on the right shows the configuration for event handling that reacts to ‘Copy’ (see Common action event) as the Triggering event.

A Check type is executed as a Validating rule to ensure that a ‘Company account’ is copied.

As the only Action on passed rule, a Set value event action is used:

• The target for the assignment (left) is determined via a concatenation of two value resolvers:
  
  

  • The Object property value resolver accesses the ‘Parent companies’ (parentCompanies) list field.
    
    

  • The concatenated List item value resolver uses the Mode ‘Add first’ and the Offset of 0 to define that the value provided as an assignment is added as a new entry.
    
    

• The assigned value (right) is read via an Object property value resolver from the ‘owner’ (ownerId) field of the original company account provided via the source variable during the copy event.

In the context of an Execute with event action, the Object resolver parameter is used to provide the input list of parameters:

• The sample data is provided here as static Text (Statische Werte and split using the concatenated Split text resolver with the ‘comma’ (,) as a Delimiter. The result is a list of text values (String[]).
  
  

• A Set value event action is used in the action block, which defines the second parameter (with index 1) as the target for the assignment for the static ‘replacement text’ defined on the right via the List item resolver with the Mode ‘Get first’ and Offset 1.
  
  

• In the following Set value event action, a coherent string is formed again from the revised list of text values with the Join string list value resolver (right), which is assigned to the params Variable.

Result: (Text value of params Variable)

YEAR=2024&MONTH=10&AREA=7

►NOTE◄ Of course, the same result could also be achieved in other ways (e.g. Replace text), but the method presented here solves the task very clearly and reliably.

In the context of an Execute with event action, the Object resolver parameter is used to provide the input list of parameters:

• The data structure is provided in JSON format as static Text, from which a list of name/value tuples is generated using the concatenated object from JSON to object resolver.
  
  

• A Set value event action is used in the action block to assign a new value to the penultimate parameter entry in this list:
  
  

  • The List item resolver refers to the penultimate list entry using the ‘Get last’ Mode and -1.
    
    

  • The concatenated Object property value resolver addresses its value field as the target for assigning the statically defined text value on the right (48).

Result:
starting from the following input value:

[{"name":"YEAR","value":"2024"},
 {"name":"WEEK","value":"42"},
 {"name":"AREA","value":"7"}
]

{
	"class": "list",
	"data": [
		{
			"name": "YEAR",
			"value": "2024"
		},
		{
			"name": "WEEK",
			"value": "48"
		},
		{
			"name": "AREA",
			"value": "7"
		}
	]
}

In the configuration shown on the right, only the action block has been changed from the previous example:

• Instead of the Set value event action, a Set values event action is used in the given use case, as two fields of the completely newly added parameter must be set for the task at hand.
  
  

• The List item resolver was transferred to the value configuration for the Target host with unchanged parameterisation (for Mode and Offset), as it again concerns the penultimate list position.
  
  

• The two target hosts are each addressed via an instance of the Object property value resolver and are assigned static Text.

►IMPORTANT◄ This configuration only works in this form in the client context, where the 'add' Mode supports the creation of a new object for the additional parameter without any further precautions.

In the server context, on the other hand, it must be explicitly ensured that the object to be added is created as a ‘client object’, otherwise the value assignments via Set values will come to nothing.

In general, this could be achieved via a Create instance with values resolver, whose return value is assigned as a list entry to be added.

The alternative shown in the screenshot on the right shows how the above configuration can be made executable for the server context:

• When providing the list in the Object resolver, after parsing the list from the JSON text, an Input object (type safe) value resolver is concatenated, which declares the type of the list as an Is collection of (selected) ‘Client object’.
  
  

• Based on this declaration, the List item resolver now also ‘knows’ the object type (here: ‘Client object’) in the server context that it should use if an 'add' Mode is selected and the new list value is not assigned ‘ready-made’ as an object.

With this variant, the result is the same for server context and client context:

{
	"class": "list",
	"data": [
		{
			"name": "YEAR",
			"value": "2024"
		},
		{
			"name": "WEEK",
			"value": "42"
		},
		{
			"name": "COUNTRY",
			"value": "NL"
		},
		{
			"name": "AREA",
			"value": "7"
		}
	]
}

In contrast, in the server context with the original configuration, only an empty object entry without field values would be inserted at the penultimate position:

   { "class": "java.lang.Object" }

In the Object resolver of an Execute with event action, a list of static Long is generated with the Create list value resolver.

In the action block, a 'missing' value is added in the second position, which is queried by the user via the User prompt.

• As all the individual values provided in the Create list have the Long data type, the list is created with reference to this data type (see type hint Long[] for the action block).
  
  

• The List item resolver on the left-hand side of the Set value event action expects a Long value.
  
  

• By definition, only text (String) is expected from the User prompt resolver, as the entered character string is returned directly.

As the list provides the Long type for entries, the added input must also correspond to this type. If the character string entered can be converted into an integer, a Long value is inserted. Otherwise, no input is added.

►IMPORTANT◄ Specific rules or restrictions for the execution context (server/client) may be relevant for the type conversion:

• The input of ‘090’, for example, is converted into the value 90 regardless of the execution context.

• The input ‘90.0’ or ‘9e1’ only lead to the same result in the server context.

• The input ‘90°’ cannot be converted to Long, regardless of the execution context.