MoniteScript

Payables

The payables connector has methods that allow you to modify the status of the payable. The params must be declared in raw expression.

Here are the available methods and their parameters for the Payables connector:

• mark_as_paid(payable_id: uuid, comment: str)
• approve(payable_id: uuid)
• reject(payable_id: uuid)

Examples:

"script": [
  {
    "call": "Payables.mark_as_paid",
    "params": {
       "payable_id": "{invoice.id}",
       "comment": "Marked from approval.",
    },
  },
]

"script": [
  {
    "call": "Payables.approve",
    "params": {
       "payable_id": "{invoice.id}"
    },
  },
]

"script": [
  {
    "call": "Payables.reject",
    "params": {
       "payable_id": "{invoice.id}"
    },
  },
]

Approval requests

The approval requests connector is used to require approvals from users or roles. Here are the available methods for the approval requests connector:

• request_approval_by_users(object_id: uuid, user_ids: list[uuid], required_approval_count: int)
• request_approval_by_roles(object_id: uuid, role_ids: list[uuid], required_approval_count: int)

Examples:

"script": [
  {
    "call": "ApprovalRequests.request_approval_by_users",
    "params": {
       "user_ids": ["ae6e88a8-c088-428c-ace2-d657bf407805"],
       "required_approval_count": 1,
    },
  }
]

"script": [
  {
    "call": "ApprovalRequests.request_approval_by_roles",
    "params": {
       "object_id": "{invoice.id}",
       "role_ids": ["ae6e88a8-c088-428c-ace2-d657bf407805"],
       "required_approval_count": 1,
    },
  }
]

Primitives

Primitives expressions include all JSON primitive types:

• null
• boolean
• number
• string

Array

Evaluates to a JSON array of values, each one of which is also an expression. It is used inside any and all expressions.

[<Expression>, <Expression>, ...]

Any

Returns true if at least one of the values in its array expression is true. So{"any": [true, false, false]} evaluates to true.

{
  "any": <Array expression>
}

All

Returns true only if all of the values in its array expression are true.
So {"all": [true, false, false]} evaluates to false.

{
  "all": <Array expression>
}

Not

Evaluates to a boolean that is the complement of its inner expression.

{
  "not": <Expression>
}

Binary operation

Compares two operands and evaluates the result of the operation. The following operators are supported:

• ==
• !=
• =
• < or >
• <= or >=

{
  "left_operand": <Expression>,
  "operator": "==",
  "right_operand": <Expression>
}

Name

Retrieves the values of the variable Event, which has all the information about the event that triggered the MoniteScript execution.

Name expression supports the basic operations of access on the object: square bracket indexing (object_list[0]) and dot access (object.attribute).

{
  "name": "Event.invoice.counterparts[0].id"
}

Connector name

Evaluates to specific methods from the connector classes. It uses the same syntax as the name expression with the only difference being that it evaluates to a non-JSON object.

As a result, connector name expression can only be used within call expressions.

"Payables.get"

Raw

Evaluates to a JSON object. It is only necessary because many other expressions are also JSON objects. The raw expression exists to distinguish expressions from regular JSON objects.

{
    <Any String>: <Expression>,
    <Any String>: <Expression>,
    ...
}

Evaluated string

The evaluated string expression can evaluate to other expressions in the MoniteScript language. It allows writing simple scripts without delving into the complexities of binary operations and calls.

They are regular JSON strings wrapped in {}, to distinguish them from non-evaluated strings.

The different types of evaluated string are:

Primitive string

Evaluates to a simple string.

Evaluated string:

"{'hello world'}"

Evaluates to:

"hello world"

Name expression string

Evaluates to a name expression.

Evaluated string:

"{Event.invoice.amount}"

Evaluates to:

{
    "name": "Event.invoice.amount"
}

Binary expression string

A one-line syntax that evaluates to a binary operation expression.

Binary expression string:

"{83 > 11}"

Evaluates to false, which is the result of:

{
    "left_operand": 83,
    "operator": ">",
    "right_operand": 11
}

However, evaluated strings are recursive, so the following is supported:

Evaluated string:

"{Event.invoice.amount <= 100000}"

Evaluates to:

{
    "left_operand": {
        "name": "Event.invoice.amount"
    },
    "operator": "{=",
    "right_operand": 100000
}

Call string

A one-line syntax that evaluates to a call expression.

Evaluated string:

"{Payables.pay('payable_uuid')}"

Evaluates to:

{
  "call": "Payables.pay",
  "params": {
      "payable_id": "payable_uuid"
  },
}

Also, this evaluated string:

"{Payables.pay(Event.invoice.id)}"

Evaluates to:

{
  "call": "Payables.pay",
  "params": {
    "payable_id": {
      "name": "Event.invoice.id"
    }
  },
}

Straight chain

On a straight chain, the first action must be executed before the script continues to the next. In the example below, the first approval must be performed before the second one, so the payable approval can be concluded:

[
  {
      "call": "ApprovalRequests.request_approval_by_users",
      "params": {
          "user_ids": [random_user_and_role_uuid],
          "required_approval_count": 1,
      },
  },        
  {
      "call": "ApprovalRequests.request_approval_by_users",
      "params": {
          "user_ids": [random_user_and_role_uuid],
          "required_approval_count": 1,
      },
  },
  "{Payables.approve(invoice.id)}"
]

“And” logic

A chain with an "And" condition refers to a situation where multiple conditions or actions are combined together using the all operator, and all of those conditions must be true or actions must be successfully executed for the overall chain to be considered successful.

In the example below, all approval requests are sent and their approval is required to conclude the payable approval:

[
  {
      "all": [
          {
              "call": "ApprovalRequests.request_approval_by_users",
              "params": {
                  "user_ids": [random_user_and_role_uuid],
                  "required_approval_count": 1,
              },
          },
          {
              "call": "ApprovalRequests.request_approval_by_roles",
              "params": {
                  "role_ids": [random_user_and_role_uuid],
                  "required_approval_count": 2,
              },
          },
      ]
  },
  "{Payables.approve(invoice.id)}"
]

“Or” logic

A chain with an "Or" condition refers to a situation where multiple conditions or actions are combined together using the any operator, and at least one of those conditions must be true or actions must be successfully executed for the overall chain to be considered successful. Once one of the conditions returns true, the next ones will be canceled.

In the example below, only one type of approval is required to conclude the payable approval:

[
  {
      "any": [
          {
              "call": "ApprovalRequests.request_approval_by_users",
              "params": {
                  "user_ids": [random_user_and_role_uuid],
                  "required_approval_count": 1,
              },
          },
          {
              "call": "ApprovalRequests.request_approval_by_roles",
              "params": {
                  "role_ids": [random_user_and_role_uuid],
                  "required_approval_count": 2,
              },
          },
      ]
  },
  "{Payables.approve(invoice.id)}"
]