The Expression Language

The Scripting Context

Any script that you develop has a context where variables may be stored. The following objects are available within the context of expression language scripts.

Context Description
asset Available in the context of plugins that access and manage assets.
actionType Available in the context of plugins that use action types.
action Available in the context of plugins  that use  Ooyala Flex action configs.
configs A list of relevant  Ooyala Flex action configs.
document Represents an arbitrary XML document that has been inserted into the context.
event Available in the context of events.
job Available in the context of plugins that are run inside jobs.
user Available in the context of plugins that access and manage users.
util Provides access to common utility methods such as time calculations.
workflowContext Available to plugins that run inside workflows.

Note: Other variables may be available in the workflow context. The are inserted by plugins as a result of their execution. A good example is the HTTP Request Message plugin that inserts an httpResponse variable into the workflow context once a message has been sent. These variable can then be referenced by other jobs in the same workflow context.

Below we provide some examples of what scripting looks like inside configuration fields:

Using Expressions

EL expressions can be used in static text fields or any field in Ooyala Flex that is marked as supporting scripting. At runtime the value of the expression is evaluated and set as the value of the field. 

There are three ways to set a value:

  1. With a single expression construct - ${expr}. The expression is evaluated and the result is coerced to the expected output type.

  2. With one or more expressions separated or surrounded by text - some${expr}${expr}text${expr}. The expressions are evaluated from left to right. Each expression is coerced to a string and then concatenated with any intervening text. The resulting string is then coerced to the expected output type.

  3. With text only - sometext. In this case, the string value is coerced to the expected output type.

Expressions used to set configuration values are evaluated in the context of an expected type. If the result of the expression evaluation does not match the expected type exactly, type conversion will be performed. For example, the expression ${1.2E4} provided as the value of a type float will result in the following conversion Float.valueOf("1.2E4").floatValue()

Implicit Objects

Ooyala Flex defines a set of implicit objects. These objects exist within the scope of the expression that is being evaluated. Please note that not all objects are available in all contexts. A table showing which objects are available in each script-enabled plugin is shown in the table below:

asset event job user actionType action configs workflowContext
Actions
Timed Actions
Event Handlers
Event Handler Expression Filter
Validation Profile
Transcode Profile
Task Assignment
Email Templates
Action Run Rules
Asset Run Rules
SMS URL Property

Using Variables

Ooyala Flex evaluates a variable that appears in an expression by looking up its value in the context. For example, when evaluating the expression ${asset}, Ooyala Flex will look for object of name “asset” in the context scope and return its value. If the object is not found, null is returned. A variable that matches one of the implicit objects described in implicit objects will return that implicit object instead of the variable’s value.

Properties of variables are accessed using the . operator and can be nested arbitrarily.

The expression language unifies the treatment of the . and [] operators:

object-a.property-b is equivalent to object-a["property-b"]

that is, the expression property-b is used to construct a literal whose value is the identifier, and the [] operator is used with that value.

To evaluate object-a["property-b"] evaluate object-a into value-a and evaluate property-b into value-b. If either value-a or value-b is null, return null otherwise return the value.

  • If value-a is a map, return value-a.get(value-b). If !value-a.containsKey(value-b), then return null.

  • If value-a is a list or array, coerce value-b to an integer and return value-a.get(value-b) or array.get(value-a, value-b), as appropriate. If the coercion couldn’t be performed, an error is returned.

  • If the get call returns an IndexOutOfBoundsException, null is returned. If the get call returns another exception, an error is returned.

  • If value-a is a JavaBean object, coerce value-b to string. If value-b is a readable property of value-a, then return the result of a get call. If the get method throws an exception, an error is returned.

Literals

EL defines the following literals.

Type Description
Boolean true and false
Integer as in Java
Float as in Java
String with single and double quotes; " is escaped as \", ' is escaped as \', and \ is escaped as \\.
Null a null value

Operators

In addition to the . and [] operators discussed in variables, EL provides the following operators.

Type Operator
Arithmetic +, -, *, / and div, % and mod, -
Logical and, &&, or, ||, not, !
Relational ==, eq, !=, ne, <, lt, >, gt, <=, ge, >=, le. Comparisons can be made against other values, or against boolean, string, integer, or floating point literals.
Empty The empty operator is a prefix operation that can be used to determine whether a value is null or empty.
Conditional A ? B : C. Evaluate B or C, depending on the result of the evaluation of A.

The precedence of operators highest to lowest, left to right is as follows:

[] . () - Used to change the precedence of operators - (unary) not ! empty * / div % mod + - (binary) < > <= >= lt gt le ge == != eq ne && and || or ? :

The following words are reserved for expression language and should not be used as identifiers:

and, eq, gt, true, instanceof, or, ne, le, false, empty, not, lt, ge, null, div, mod

Note: Many of these words are not in the language now, but they may be in the future, so you should avoid using them.

Examples

Expression Result
{1 > (4/2)} false
${4.0 >= 3} true
${100.0 == 100} true
${(10*10) ne 100} false
${'a' < 'b'} true
${'hip' gt 'hit'} false
${4 > 3} true
${1.2E4 + 1.4} 12001.4
${3 div 4} 0.75
${10 mod 4} 2

Advanced Scripting

As well as standard Expression Language, Ooyala Flex also offers some advanced features for the creation of more advanced runtime evaluations.

Metadata Expressions

Ooyala Flex supports some operators that assist with locating metadata field values within asset hierarchies.

Expression Explanation
@@fieldname@@ Expression starts with @@ and ends with @@. Using this expression we can access metadata variable values. e.g. @@film_id@@ - returns value of film_id variable from metadata associated with current asset.
%%assetContext%% Metadata Expressions also support embedded asset hierarchy expressions. These start with %% and ends with %%. If we want to retrieve values from parent or child metadata then we can also specify the asset hierarchy expressions e.g. @@%%./..%%artist[0]:first_name[0]@@ - evaluates metadata expression artist[0]:first_name[0] against metadata of the parent.

System Properties

Expression Explanation
@[propertyName] System properties are variables that are available in the Ooyala Flex system. Super users can create their own system properties, that can be accessed through scripting. System Properties support scoping.