Script Editor

Overview
Use Script Editor to develop and test your Scripts. Any Script can be used in any Process in your organization developed using programming languages that Script Editor supports.‌
Permissions Required
Your user account or group membership must have the following permissions to create or edit a Script:
Scripts: View Scripts
Scripts: Create Scripts
Scripts: Edit Scripts
See the Scripts permissions or ask your Administrator for assistance.
Scripts run securely and in isolation from within Docker containers called Script Executors. The Script Executor for each supported programming language contains the Software Development Kit (SDK) that supports extensibility to provide programmatic interaction with ProcessMaker. When the ProcessMaker instance calls a Script to run, the Script Executor for that programming language creates a Docker container corresponding with that programming language, runs the Script, and then destroys the Docker container. This ensures that any malicious script that anyone in your organization might inadvertently introduce to ProcessMaker does not affect the instance or its hosting environment: Docker containers cannot access them. Furthermore, Docker containers cannot listen for inbound connections; therefore, a Docker container cannot be accessed externally.
Scripts are developed and tested in the same environment.
Access the Script Editor in the following ways:
​Create a new Script.​
​Edit an existing Script.​
‌Below is the Script Editor displaying a Script written in PHP.‌
Could not load image
The Script Editor
Script Editor Usage Guidelines
‌Follow these guidelines to develop and test Scripts in the Script Editor.‌
Develop Your ProcessMaker Script
‌Develop the Script below the script's name and language description. Use the scroll panel to navigate your code not currently displayed. This is useful especially when you are editing a long Script.‌
Enter Mock Request Data Coming Into Your ProcessMaker Script
‌Use the Sample Input panel to mock Request data that comes into your Script to test how the Script runs using Request data you expect. 
Define the variables in a Screen when you configure its controls. See information about each control.‌
Follow these guidelines to mock Request data coming into your Script:‌
1.​​Open the Screen in which to view its JSON data model.
2.Enter Preview mode on the Screen page to view its JSON data model. Click the Preview button from Screen Builder's top menu to enter Preview mode.
3.Enter values into the control settings as if you were using the Screen in a Request. In the Data Preview panel, the JSON data model displays the key-value pairs in each object element. The keys' values are those you enter in the Screen preview. Understand what the key names are. Each key is derived from a Screen control's Variable Name setting value. Use these key names as variables in your Script. The Variable Name setting values become part of the Request data and contain the content that Request participants enter into that Screen during a Request. Mock these Variable Name setting values as input data to your Script.
4.After you have entered values into the Screen in Preview mode, the entire JSON data model displays in the Data Preview panel. Copy the JSON data model.
5.Paste the JSON data model into the Sample Input panel in Script Editor. If you use any variables as defined in the JSON data model in your Script, Script Editor uses those variable values during script testing.
6.Optionally, mock the Magic Variables that your Script would reference during an in-progress Request. ProcessMaker uses a set of Magic Variables that become part of the JSON data model for all Requests. ProcessMaker uses these Magic Variables to store user, Process, and Request related data for all Requests. During an in-progress Request, these Magic Variables are updated. All Magic Variables are preceded by an underscore (_) character in the JSON data model. Enter the Magic Variable into the Sample Input panel as part of the JSON data model, and then enter mock values for each. See Magic Variable Descriptions.
7.Click Run.
8.In the Output panel, view the mocked Request data.
‌Enter Other JSON Data as Input to Your ProcessMaker Script
‌Use the Configuration panel to include JSON configuration settings your Script uses when it runs. For example, include the Client ID and Client Secret values in JSON format for OAuth 2.0 verification to a third-party service's API your Script must access to access the API. By entering these values into the Configuration panel, you can verify during testing that these values are valid for the third-party service.‌
A Script may reference Screen control values during a Request by placing their Variable Name setting values within quotation marks ("). In the example below, FullName is the Variable Name setting value for a control to store a Request participant's full name:
1
{
2
    "Name": "FullName"
3
}
Copied!
‌Test Your ProcessMaker Script
‌Click the Run button to test your Script. Script Editor evaluates any JSON data entered into the Configuration and Sample Input panels.‌
If the Script evaluates successfully, its output displays in the Output panel. If the Script does not evaluate successfully, the language engine evaluating the script displays an error.‌
Pass Request Data Into Your ProcessMaker Script
‌Pass Request-related data into your Script in the following ways:‌
Request data: ProcessMaker uses a schema-less JSON data model from which to read, write, and store Request data. Since the JSON data model is schema-less, meaning that it does not require a specific schema or structure from which ProcessMaker assets must conform, the JSON data model is structured from the JSON objects in assets used in a Request, such as the Variable Name setting values in a Screen or variables a Script creates. When an in-progress Request routes through the Process, Request data aggregates into the JSON data model, thereby becoming Request data. Users or group members that have the Requests: Edit Request Data permission may view the JSON data model for a completed Request. This JSON data model displays from the Data tab in a completed Request's summary. Below is an example. Scripts can call Request data by referencing these JSON objects derived from Variable Name setting values in Screens.
​
​
Script Task element Configuration: Enter JSON data to pass to the Script when configuring the Script task element in Process Modeler. In the example below, the data from JSON Variable Email is being passed to the Script using the Script Configuration panel of a Script Task element.
​
​
Magic Variables: ProcessMaker uses a set of Magic Variables that become part of the JSON data model for all Requests. ProcessMaker uses these Magic Variables to store user, Process, and Request related data for all Requests. During an in-progress Request, these Magic Variables are updated. All Magic Variables are preceded by an underscore (_) character in the JSON data model. See Reference Magic Variables in ProcessMaker Assets.
Environment Variables: The sensitive information that an Environment Variable represents can pass to a Script when it runs. Usage depends on the programming language that the Script uses. In the usage examples below, ENV_VAR_NAME represents the name of the Environment Variable. See Variable Syntax, Usage, and Examples.
‌ProcessMaker and Environment Variable Syntax, Usage, SDK, and Examples
‌ProcessMaker uses two global variables that Scripts can call. Variable usage depends on the programming language that the Script uses. Below is a description of these global variables:‌
Data: The data variable is a JSON object that contains all Request data to the moment a Script runs.
Config: The config variable is a JSON object that contains any special configuration to be passed to the Script prior to it running. In Script Task elements of a Process model, special configurations are entered into the Script Configuration setting. See Reference a Request Variable from a Script Configuration Setting as to the best practice when configuring Scripts from Script Task elements in a Process model.
Every Script Executor from which a Script runs has the following default Environment Variables from which a Script may get its value. Refer to the tabs below how to get these Environment Variable values for each supported programming language. Below is a description of these default Environment Variables.
ProcessMaker Environment Variable
Description
HOST_URL
Domain for the ProcessMaker instance.
API_HOST
ProcessMaker instance API to which to make all RESTful API calls.
API_TOKEN
Token a Script uses to authenticate to our API host. Note that this API token is only valid for the lifetime of the Script: after the Script runs and the Script Executor's Docker container from which that Script ran, its API token is no longer valid.
‌Refer to the tabs below how to use variables in supported programming languages.
PHP
Lua
JavaScript
C#
Java
Python
R
Below is a sample Script that uses PHP. Refer to the comments denoted with // that describe how the sample functions:
How to get an Environment Variable.
How to get a value from the configuration object.
How to get a value from a data object.
Call the Software Development Kit (SDK).
1
<?php
2
$output = [];
3
// Get a ProcessMaker Environment Variable, in this case TEST_VAR.
4
$output['envVar'] = getenv('TEST_VAR');
5
// Get a value from the config object.
6
// In this example, 'test' in the JSON config: {"test":"test config value"}
7
$output['configTest'] = $config["test"];
8
// Get a value from the data object.
9
// In this example, the user_id for the _request.
10
$output['requestUserId'] = $data['_request']['user_id'];
11
// Get the email address for user id 1 using the API/SDK.
12
// Use the global `$api_config` to set credentials automatically.
13
$usersApi = new ProcessMaker\Client\Api\UsersApi(null, $api_config);
14
$user = $usersApi->getUserById("1");
15
$output['userEmail'] = $user->getEmail();
16
return $output;
Copied!
Below is a sample Script that uses Lua. Refer to the comments denoted with -- that describe how the sample functions:
How to get an Environment Variable.
How to get a value from the configuration object.
How to get a value from a data object.
Call the Software Development Kit (SDK).
1
-- Get a ProcessMaker Environment Variable, in this example TEST_VAR.
2
local envVar = os.getenv("TEST_VAR")
3
   
4
-- Get a value from the config object.
5
-- In this example, 'test' in the JSON config: {"test":"test config value"}
6
local configTest = config["test"]
7
​
8
-- Get a value from the data object.
9
-- In this example, the user_id for the _request.
10
local requestUserId = data["_request"]["user_id"]
11
​
12
-- Get the email address for user id 1 using the API/SDK.
13
-- Use client.make to get a pre-configured api client.
14
-- See https://github.com/ProcessMaker/sdk-lua/tree/master/pmsdk/api for available clients.
15
local users_api = client.make('users_api')
16
local user = users_api:get_user_by_id("1")
17
local userEmail = user.email
18
​
19
return {envVar=envVar, configTest=configTest, requestUserId=requestUserId, userEmail=userEmail}
Copied!
Below is a sample Script that uses JavaScript. Refer to the comments denoted with // that describe how the sample functions:
How to get an Environment Variable.
How to get a value from the configuration object.
How to get a value from a data object.
Call the Software Development Kit (SDK).
1
// A ProcessMaker Script written in JavaScript should return a Promise that
2
// resolves with the output data. You can also return a basic object.
3
// For example `return {"key":"value"}`
4
return new Promise((resolve, reject) => {
5
​
6
    // Get a ProcessMaker Environment Variable, in this example TEST_VAR.
7
    const envVar = process.env['TEST_VAR'];
8
    
9
    // Get a value from the config object.
10
    // In this example, 'test' in the JSON config: {"test":"test config value"}
11
    const configTest = config['test'];
12
    
13
    // Get a value from the data object.
14
    // In this case the user_id for the _request.
15
    const requestUserId = data["_request"]["user_id"];
16
    
17
    // Get the email address for user id 1 using the API/SDK.
18
    // Use the global `api` object to get a pre-configured client.
19
    let usersApi = new api.UsersApi();
20
    usersApi.getUserById("1", (error, user) => {
21
    
22
        const userEmail = user.email;
23
        
24
        resolve({
25
            'envVar' : envVar,
26
            'configTest' : configTest,
27
            'requestUserId' : requestUserId,
28
            'userEmail' : userEmail
29
        });
30
    });
31
});
Copied!
The C# package must be installed.
Below is a sample Script that uses C#. Refer to the comments denoted with // that describe how the sample functions:
How to get an Environment Variable.
How to get a value from the configuration object.
How to get a value from a data object.
Call the Software Development Kit (SDK).
1
using System;
2
using ProcessMakerSDK.Api;
3
using ProcessMakerSDK.Client;
4
using ProcessMakerSDK.Model;
5
​
6
// A ProcessMaker Script written in C# must have a 'Script' class that implements 'BaseScript'.
7
// It must include a method named 'Execute'. Results must be added to the 'output' map.
8
public class Script : BaseScript
9
{
10
    public override void Execute(
11
        dynamic data,
12
        dynamic config,
13
        dynamic output,
14
        Configuration apiConfig)
15
    {
16
        // Get a ProcessMaker Environment Variable, in this example TEST_VAR.
17
        output.envVar = Environment.GetEnvironmentVariable("TEST_VAR");
18
        
19
        // Get a value from the config object.
20
        // In this example, 'test' in the JSON config: {"test":"test config value"}
21
        output.configTest = config["test"];
22
        
23
        // Get a value from the data object.
24
        // In this example, the user_id for the _request.
25
        output.requestUserId = data["_request"]["user_id"];
26
        
27
        // Get the email address for user id 1 using the API/SDK.
28
        try {
29
            var apiInstance = new UsersApi(apiConfig);
30
            Users user = apiInstance.GetUserById("1");
31
            output.userEmail = user.Email;
32
        } catch (ApiException e) {
33
            Console.WriteLine(e.StackTrace);
34
        }
35
    }
36
}
Copied!
The Java package must be installed.
Below is a sample Script that uses Java. Refer to the comments denoted with // that describe how the sample functions:
How to get an Environment Variable.
How to get a value from the configuration object.
How to get a value from a data object.
Call the Software Development Kit (SDK).
1
import java.io.*;
2
import java.util.*;
3
import ProcessMaker_Client.ApiClient;
4
import ProcessMaker_Client.ApiException;
5
import ProcessMaker_Model.Users;
6
import ProcessMaker_Api.UsersApi;
7
​
8
// A ProcessMaker Script written in Java must have a 'Script' class that implements 'BaseScript'.
9
// It must include a method named 'execute'. Results must be pushed to the 'output' map.
10
public class Script implements BaseScript {
11
    public void execute(
12
        Map<String, Object> data,
13
        Map<String, Object> config,
14
        Map<String, Object> output,
15
        ApiClient api
16
    ) {
17
​
18
        // Get a ProcessMaker Environment Variable, in this example TEST_VAR.
19
        Map<String, String> env = System.getenv();
20
        output.put("env-var", env.get("TEST_VAR"));
21
        
22
        // Get a value from the config object.
23
        // In this example, 'test' in the JSON config: {"test":"test config value"}
24
        output.put("config-test", config.get("test"));
25
​
26
        // Get a value from the data object.
27
        // In this example, the user_id for the _request.
28
        Map requestData = ((Map)data.get("_request")); 
29
        output.put("data-request-user-id", requestData.get("user_id"));
30
        
31
        // Get the email address for user id 1 using the API/SDK.
32
        try {
33
            UsersApi apiInstance = new UsersApi(api);
34
            Users user = apiInstance.getUserById("1");
35
            output.put("user-1-email", user.getEmail());
36
        } catch (ApiException e) {
37
            e.printStackTrace();
38
        }
39
    }
40
}
Copied!
The Python package must be installed.
Below is a sample Script that uses Python. Refer to the comments denoted with # that describe how the sample functions:
How to get an Environment Variable.
How to get a value from the configuration object.
How to get a value from a data object.
Call the Software Development Kit (SDK).
1
# A PM4 script written in Python must set a dict
2
# named `output` with the data to return.
3
​
4
# Get an environment variable, in this case TEST_VAR
5
envVar = os.getenv('TEST_VAR')
6
​
7
# Get a value from the config object.
8
# In this case, 'test' in the json config: {"test":"test config value"}
9
configTest = config['test']
10
​
11
# Get a value from the data object.
12
# In this case the user_id for the _request
13
requestUserId = data['_request']['user_id']
14
​
15
# Get the email address for user id 1 using the API/SDK
16
# Use the global `configuration` object to set auth tokens
17
users_api_instance = pmsdk.UsersApi(pmsdk.ApiClient(configuration))
18
user = users_api_instance.get_user_by_id(1)
19
userEmail = user.email
20
​
21
output = {
22
    "envVar": envVar, 
23
    "configTest": configTest, 
24
    "requestUserId": requestUserId, 
25
    "userEmail": userEmail
26
}
Copied!
The R package must be installed.
Below is a sample Script that uses R. Refer to the comments denoted with # that describe how the sample functions:
How to get an Environment Variable.
How to get a value from the configuration object.
How to get a value from a data object.
Call the Software Development Kit (SDK).
1
# Get a ProcessMaker Environment Variable, in this example TEST_VAR.
2
envVar <- Sys.getenv("TEST_VAR")
3
​
4
# Get a value from the config object.
5
# In this example, 'test' in the JSON config: {"test":"test config value"}
6
configVar <- config[["test"]]
7
​
8
# Get a value from the data object.
9
# In this example, the user_id for the _request.
10
dataVar <- data[["_request"]][["user_id"]]
11
​
12
output
13
​
14
<- list(envVar = envVar, configVar = configVar, dataVar = dataVar)
Copied!
Save Your ProcessMaker Script
A Script can be saved in two ways depending if the Versioning package is installed. See the following sections regarding how a Script may be saved:
​Versioning package is not installed: Save a single version of your Script.
​Versioning package is installed: Save multiple versions of your Script.
Save a Single Version of a Script
​Permissions are required to do this. ​
Click the Save icon
from Script Editor's top menu to save the Script.‌ When the Versioning package is not installed, this action overwrites any previous changes made to this Script and a record of previous changes is not maintained. To save multiple versions of a Script, the Versioning package must be installed.
Save Multiple Versions of a Script
Permissions Required
​Permissions are required to do this.
Package Required
The Versioning package must be installed to save multiple versions of a Script.
When the Versioning package is installed, multiple versions of a Script can be saved. A version is a set of changes made to a Script at a particular time by a Process Designer. Versioning maintains a record of all named and unnamed changes to that Script. Any of these versions may be viewed or retrieved, if needed. See the Versioning package for more information. 
Follow these guidelines to save a new version of your Script:‌
1.Click the Save icon
from Script Editor's top menu.‌
2.If the Versioning package is installed, the Commit Changes screen displays to save a new version of this Script.
 
 
3.Do one of the following:
Save an unnamed version:
Follow these steps to save an unnamed version:
1.Click Save to save an unnamed version. Otherwise, click Cancel to return to the Script Editor without saving this version. As a best practice, save unnamed versions only to save work that is in active development and do not need a "milestone" set for this Script. Otherwise, Process Designers that manage versions of this Script do not view unnamed versions when the Only show named versions toggle key is enabled while viewing that Script's version history.
Save a named version:
Follow these steps to save a named version:
1.In the Version Name setting, enter a name for this version. The version name displays when viewing the version history of that Script and helps identify this version. Although this setting is not required, as a best practice name each version for easier maintenance, documentation, and auditing purposes. Name the version that describes the "milestone" set for this Script.
2.In the Additional Details (optional) setting, optionally enter details of the changes made in this version. The additional details display when viewing the version history of that Script and helps other Process Designers or Administrators understand the changes made in that version. Enter details which concisely summarize the changes made in this version.
3.Click Save to save this version. Otherwise, click Cancel to return to the Script Editor without saving this version. 
Related Topics
What is a Script?
What is a Screen?
Manage Script Categories
What is a Script Executor?
Reference Magic Variables in ProcessMaker Assets
View Scripts
Create a New Script
Search for a Script
Configure a Script
Edit a Script
Copy a Script
Delete a Script
C# Package
Java Package
R Package
Python Package
Versioning Package
What is a Package?