Understanding the pluggable RPA bot generator script

dataModel

The dataModel argument is the first argument to the generator function and is injected as a JSON object by Process mining.

Example 1: The following example demonstrates the structure of a dataModel object.

{
  "startNodes": [
    "BTN1"
  ],
  "endNodes": [
    "BTN3",
    "BTN6"
  ],
  "transitions": [
    {
      "source": "BTN1",
      "destination": null,
      "rules": {
        "BTNPLUS": {
          "OR": [
            {
              "AND": [
                {
                  "attribute": "productName",
                  "operator": "IN",
                  "value": "['A', 'B']"
                }
              ]
            },
            {
              "AND": [
                {
                  "attribute": "amount",
                  "operator": "<=",
                  "value": "10749.0"
                }
              ]
            }
          ]
        },
        "BTNMINUS": {
          "OR": [
            {
              "AND": [
                {
                  "attribute": "amount",
                  "operator": ">",
                  "value": "10749.0"
                }
              ]
            }
          ]
        }
      }
    },
    {
      "source": "BTNMINUS",
      "destination": "BTN6",
      "rules": null
    },
    {
      "source": "BTNPLUS",
      "destination": "BTN3",
      "rules": null
    }
  ],
  "aliasToTasksMap": {
    "ButtonOne": [
      "BTN1"
    ]
  },
  "humanMandatoryInfo": [
    {
      "taskName": "BTN1",
      "humanMandatory": false
    },
    {
      "taskName": "BTN3",
      "humanMandatory": false
    },
    {
      "taskName": "BTN6",
      "humanMandatory": false
    },
    {
      "taskName": "BTNPLUS",
      "humanMandatory": false
    },
    {
      "taskName": "BTNMINUS",
      "humanMandatory": false
    }
  ]
}

This sample JSON object includes the following five main components, such as startNodes, endNodes, transitions, aliasToTasksMap, and humanMandatoryInfo.

• startNodes
  

  This component lists the task names from which the execution must start. In a normal BPMN model, there is only one startNode, though there can be more.

  If there are more than one startNodes, then the system considers it as an invalid scenario and ends the script execution with an error message. Similarly, if no nodes are listed in startNodes, then the system ends the bot generation process and displays an error message.

• endNodes
  

  This component lists one or more tasks that mark the end of a flow. When the execution reaches a task that is listed as endNodes, the system considers the bot execution as completed.

  The sample RPA generator script that is provided in this document, marks all such nodes with the isFinal=true attribute in the UiPath script generated.

• transitions

  This object represents the transition of flow from the start to the end based on the BPMN. You can have direct transitions from one node to another and rule-based transitions.

  Example 2: The following example demonstrates a direct transition from BTNMINUS to BTN6. In other words, after running the code snippet of BTNMINUS, the automation provider selects the snippet of BTN6 for execution.

  {
    "source": "BTNMINUS",
    "destination": "BTN6",
    "rules": null
  }
  

  Rule-based transitions do not include a direct transition from one node to another. Hence, the destination is always null. Instead, it includes one or more rules that define a condition to transition to the next node in the execution flow.

  Example 3: In the following example, after running BTN1, the automation provider selects BTNPLUS only if the defined condition (productName IN ‘A’ or ‘B’ AND amount <= 10749.0) is satisfied.

  {
  "BTNPLUS": {
    "OR": [
      {
        "AND": [
          {
            "attribute": "productName",
            "operator": "IN",
            "value": "['A', 'B']"
          }
        ]
      },
      {
        "AND": [
          {
            "attribute": "amount",
            "operator": "<=",
            "value": "10749.0"
          }
        ]
      }
    ]
  }
  }
  

  The rules are structured in a special format to easily traverse them. Every rule in a transition is a group of one or more OR expressions. Each OR expression includes one or more AND expressions. The generator script must iterate over this structure to build the vendor-specific conditional expression equivalent to this expression.

  Logical operators

  Table 1 describes the logical operators that you can use in the rules that are passed to the generator script from Process Mining.

  Table 1. Logical Operators

  Logical operator	Description	Usage Example
  IS	Equal to the value	productAmt IS 123.45
  IS NOT	Not equal to the value	productAmt IS NOT 123.45
  <	Less than the value	productAmt < 123.45
  >	Greater than the value	productAmt > 123.45
  <=	Less than or equal to the value	productAmt <= 123.45
  >=	Greater than or equal to the value	productAmt <= 123.45
  IN	Contains a value	productAmt IN (123.45, 234.56, 345.67)
  NOT IN	Does not contain a Value	productAmt NOT IN (123.45, 234.56, 345.67)
  INSIDE	Value in a range	You can use the INSIDE operator to define various logical expressions. The expression, productAmt INSIDE (100, 200) indicates productAmt > 100 && productAmt < 200. The expression, productAmt INSIDE [100, 200) indicates productAmt >= 100 && productAmt < 200. The expression, productAmt INSIDE [100, 200] indicates productAmt >= 100 && productAmt <= 200.

  Conditional Expressions

  Conditional expressions are generated based on the data type information that is derived from the contextual data details that are loaded to the script.

  Contextual data from Process Mining can be of the following data types:

  • string
  • numeric
  • integer
  • long
  • double
  • date (according to Epoch timestamp)

  Example 4: The Visual Basic expression for the rule generated in the UiPath Bot generator script (demonstrated in Example 3) is as follows:

  <Transition.Condition>[({'A','B'}.Contains(productName)) Or (amount &lt;= 10749.0)]</Transition.Condition>
  

• aliasToTasksMap

  The aliasToTasksMap component indicates a map that contains the alias names to tasks mapping (if any) represented in the process mining project. Currently, the generator does not use this component as the alias names used by the BPMN are converted to the original task names in the data model injected to the generator. Additionally, these names are maintained in the data model for any future references.

  The application restricts you from mapping multiple tasks with the same alias name for a Task mining project, as it prevents the application from fetching and assigning the correct RPA snippets to tasks while generating RPA Bots.

  Example 5: You can define the aliasToTasksMap component as follows:

  "aliasToTasksMap": {
  "ButtonOne": [
    "BTN1"
  ]
  }
  

• humanMandatoryInfo

  The humanMandatoryInfo component indicates a map that contains the list of tasks that are used by the activity and the corresponding human mandatory status. You can mark a task as Human Mandatory on the Task Classification page of IBM Task Mining. This indicates that the task requires a human input and hence, it cannot be automated. If a task is marked as Human Mandatory in the application, then it is marked as true in the humanMandatoryInfo JSON object. The generator can use this object to produce appropriate actions within the generated bot.

  Example 6: You can define the humanMandatoryInfo component as follows:

  "humanMandatoryInfo": [
  {
    "taskName": "BTN1",
    "humanMandatory": false
  },
  {
    "taskName": "BTN3",
    "humanMandatory": false
  }
  

Snippets

The snippets JSON object holds the snippets for each of the tasks that are associated with the selected activity that is retrieved from IBM Task Mining. The generator script uses this object to build the RPA bot with the respective snippet script for each task.

Example 7: The contents of a snippets JSON object are as follows:

{
  "preExecutionSnippet": "<pre-execution script>",
  "postExecutionSnippet": "<post-execution script>",
  "activity": "Calculator Operations",
  "tasks": [
    {
      "taskName": "BTN1",
      "snippets": [
        {
          "snippetName": "Button One",
          "snippet": "<button one code>"
        }
      ]
    },
    {
      "taskName": "BTN3",
      "snippets": [
        {
          "snippetName": "Button Three",
          "snippet": "<button three code>"
        }
      ]
    },
    {
      "taskName": "BTN6",
      "snippets": [
        {
          "snippetName": "Button Six",
          "snippet": "<button six code>"
        }
      ]
    },
    {
      "taskName": "BTNPLUS",
      "snippets": [
        {
          "snippetName": "Button Plus",
          "snippet": "<button plus code>"
        }
      ]
    },
    {
      "taskName": "BTNMINUS",
      "snippets": [
        {
          "snippetName": "Button Minus",
          "snippet": "<button minus code>"
        }
      ]
    }
  ]
}

Table 2 lists the contents of the snippets JSON object.

Table 2. Contents in the snippets JSON object

contextualData

The rule expression in a transition from one task to another depends on the evaluation of expressions that contain the variables. In IBM Task Mining, every such variable is considered as a contextual data item. You can define the contextual data on the Task Classification page of IBM Task Mining. In the pluggable RPA bot generator script, you must ensure that the contextual data elements are declared as global variables so that the automation provider successfully runs these expressions.

This JSON object holds all the necessary information that is associated with contextual data. It also contains some additional variables that are not created by a user but by the system based on the CSV data. Table 3 lists some of the additional variables that are identified in the contextualData JSON object.

Table 3. Additional variables in the contextualData JSON object

These additional variables are added to the JSON object as part of the rule expressions in the BPMN, and thus in the generated bots.

You can exclude such resource variables from being updated as part of the BPMN. To do so, you can use the Edit Rule Configurations feature in the BPMN tab of the selected process in IBM Process Mining. For more information on BPMN tab, see Business Process Modeling Notation.

After excluding the system resources, use the Discover decision rules feature in the BPMN tab so that the BPMN reflects the latest changes. This process also removes such variables from BPMN, and from the decision rules in the generated bot.

Example 8: The contents of a contextualData JSON object are as follows:

[
  {
    "name": "PRODUCT_NAME",
    "rpaVariableName": "productName",
    "rpaVariableType": "string",
    "id": "Win32[@ClassName=RichEdit20WPT][@Type=edit][@Name=PName]",
    "application": "saplogon",
    "pageTitle": "Purchase Order Creation",
    "fullUrl": ""
  },
  {
    "name": "amount",
    "rpaVariableName": "amount",
    "rpaVariableType": "numeric",
    "id": "Win32[@ClassName=AfxWndA][@Type=pane][@Name=amount]",
    "application": "saplogon",
    "pageTitle": "Purchase Order Creation",
    "fullUrl": ""
  },
  {
    "name": "BUSINESSACTIVITY",
    "rpaVariableName": "businessactivity",
    "rpaVariableType": "string",
    "id": "attr-custom",
    "application": "",
    "pageTitle": "",
    "fullUrl": ""
  },
  {
    "name": "CASEPRODUCTIVE",
    "rpaVariableName": "caseproductive",
    "rpaVariableType": "integer",
    "id": "attr-custom",
    "application": "",
    "pageTitle": "",
    "fullUrl": ""
  }
]

Each entry in the JSON represents a contextual data item and these items are represented as a global variable in the generated bot script.

Table 4 lists the contents of the contextualData JSON object.

Table 4. Contents of the contextualData JSON object