Sent Fields Explained

Sent Fields are name-value pairs you define inside an Execute Action Batch to pass data into child logic — such as evaluations, nested batches, or dynamic widgets.

They act like “named variables” that you hand over to the next step of logic to inform decisions and branching.

Think of it like this: “I'm executing a batch, and I want to pass these values into it so it can make decisions based on them.”

Where They're Used

You can reference Sent Fields in multiple contexts:

• Inside Evaluations
  Use them as the Field Name to apply conditional checks.

• Inside Nested Batches
  Sub-actions or inner batches can use them as input from the parent.

• Dynamic Widget Updates
  Update widget state or content using values passed in.

• Call Function Scripts
  Custom scripts can access Sent Fields to compute a result.

Sent Field Types

Each Sent Field has a type, determining where its value comes from:

Sent Field Type	Description
Data Field	A specific value from a Datasource
Next Data Row	Steps through rows in a Datasource
Received Value	The primary value received from the trigger. Most of the time, this refers to the value property (e.g., the numeric value from a sensor ).
Static Value	A constant, hardcoded value
Random Number	A random value within a specified range
Filtered Data Source	A filtered set of rows from a Datasource
Property of Received Value	Extracts a specific property from the full object — for example, event, id, or value. Supports dot notation for nested objects.
Widget Value	Retrieves the current value from a widget
Pick File	Opens a file picker and returns the selected file path
Device Info	Device metadata such as device ID, base URL, bound row ID, content ID, page ID, and page URL
Call Function	Returns a computed value from a custom JavaScript-like script

note

Each data field type can be filtered using simple logic.
However, only the Filtered Data Source supports advanced filtering rules.

Examples

Property of Received Value #1

Suppose a sensor or script sends the following object as the received value:
{ batchedValues: { temperature: 22, humidity: 60, pressure: 1012 } }

To extract just the pressure:

• Value column: batchedValues.pressure
• Name column: currentPressure

This creates a Sent Field named currentPressure with the value 1012.

You can now:

• Use it in an evaluation (e.g., “If currentPressure > 1000”)
• Display it in a widget
• Pass it to another nested batch for further logic

Property of Received Value #2

You can also use dynamic placeholders to extract values based on either the original received value or data passed from a parent batch via Sent Fields.

This is particularly useful when dealing with complex objects or arrays.

Example: Extract nested data from a parent batch

Imagine you have a parent Execute Action Batch that passes a list of users to a child batch as a Sent Field named allUsers.

Here’s a simplified input:

{
    "allUsers": [
        {
            "name": "Alice",
            "email": "alice@example.com"
        },
        {
            "name": "Bob",
            "email": "bob@example.com"
        },
        ...
        {
            "name": "Jane",
            "email": "jane@example.com"
        }
        // index 9
    ]
}

In the child batch, let’s say you only want to extract the email of the user at index 9.

1. Define two static value Sent Fields:

• Name: index
  Value: 9

• Name: emailKey
  Value: email

2. Use a Property of Received Value field with the following:

• Name: searchedEmail
• Value: allUsers.{index}.{emailKey}

How it works:

• {index} resolves to 9
• {emailKey} resolves to email
• The final property path becomes: allUsers.9.email
• The system extracts the value: jane@example.com
• The Sent Field searchedEmail will now hold: jane@example.com

You can now use searchedEmail in:

• Evaluations (e.g., "If searchedEmail contains 'example'")
• Widget displays (e.g., show a specific user’s contact)
• Nested logic for conditional branching

Call Function

The Value column for this field type always uses a JavaScript-like syntax:
(receivedValue) => { return /* something */ }

The receivedValue object includes all variables accessible from the current batch context — like Sent Fields, trigger values, or external input.

For example, to return true only when motionValue > 5 and timeOfDay === "morning":

• Value column:
  (receivedValue) => { return receivedValue.motionValue > 5 && receivedValue.timeOfDay === 'morning'; }

• Name column: isValidCondition

Now isValidCondition will hold a boolean result (true or false) that can:

• Be used in an evaluation
• Trigger conditional actions
• Be passed forward to nested logic