About Operators

Role: Administrator.

Minimum Version: Neurons for ITSM 2022.4.

The following categories of operators are supported:

Relational operators are used to compare two expressions or values and return a Boolean result. Use the correct variable types, combinations of variables, and numbers to perform comparisons using relational operators.

Example 1: In this example, the Equal to Operator (represented as ‘==’) checks whether the two given operands are equal or not. If so, it returns true. Otherwise, it returns false. Here, values of the same type are compared and hence

6==6 will return true.

Example 2: In this example, both operands on either side of the operator are of a different type. The right hand side value is string and the left hand side is a number. Therefore, the number will be converted to string and the return value is false.

number(“6”)>=5

6>=number(“5”)

If the Relational and Equality operators both operands on either side of the operator are of a different type, then implicit conversion may yield unexpected results. It is recommended to use type conversion explicitly to ensure an accurate comparison.

The relational operators can be used with data types. For information about the supported data types, see About Type Conversions

The following table illustrates the order of precedence of the operators, from highest to lowest precedence.

Operators in the same row have the same precedence, which are evaluated from left to right, based on the appearance of the operators in the expression.

You can use parentheses to control precedence and associativity. When you save an expression, if you did not specify parentheses, the application automatically adds additional parentheses.

For example, if you enter the following expression:

$(3 + 4 * 5)

When you save it, the application displays the expression as:

$(3 + (4 * 5))

This is consistent with the order of precedence as shown in the previous table.

The Boolean operators (||, &&) are short circuiting:

For the Boolean AND (&&) and Boolean OR (||) operators, while defining the expression, you can opt to specify the operators as AND or OR, respectively. The application automatically converts them to && or || when you save the expression.

For example, if you define the if expressions as:

The application saves the respective expressions as:

Neurons for ITSM recognizes the following binary operators:

in, not in, before, not before, during, not during, after, not after, *, /, %, +, -, <<, >>, <, >, <=, >=, ==, !=, &, |, ^, &&, and ||

For example:

$(Status == "Closed" || Status == "Denied")

This conditional expression can be found as a read-only condition in the Layout Editor. If the value returned is true, then the status is closed and the form field becomes read-only. If the value returned is false, then the status is denied.

For example, when constructing an operator in the If block of the Workflow Designer, you can use binary operators:

Based on the outcome of this expression, the exit port of the If block can connect to a different block, creating a different path within the workflow.

The && (AND), || (OR), and ! (NOT) operators have Boolean operands and evaluate to a single Boolean value. && and || operators are short-circuiting, meaning that the right operand is not evaluated if the left operand determines the value result of the operator. This is only important if the right side expression has side effects, for example, in the case $(x && Prompt(...)).

The Prompt function is executed only when x is true. If x is false, the result of the && operator is always false regardless of the value of the Prompt function, and therefore the right operand is not executed in this case.

There are several new bitwise operators. Unlike the Boolean operators, these work on the individual bits of an integer value, treating a 0 it as false and 1 as true.

The bitwise operators are often useful in conjunction with hexadecimal literals, since the bit pattern of the resulting value is more apparent, for example, $(m & 0#f0f7).

DateTime interval operators consist of a pair of DateTime values that represent the start and end. They are often a calendar interval but do not have to be.

See Interval, Day, Week, Month, Quarter, and Year for information about built-in functions that use these DateTime interval operators.

The in and not in operators can function on the server, on the client, and in Microsoft SQL queries.

The syntax is as follows:

The right side of the operator is a comma-separated list of values surrounded by parentheses. Starting in Neurons for ITSM Release 2015.2, the values do not need to be constants. Therefore, the following example is valid: Status in ("Open","Log"+"ged",Status).

The right side of the in and not in operator expressions can also be any built-in function that computes a list. Currently, the only ways to compute a list are by using the built-in functions called CurrentUserTeamNames and CurrentUserTeamIds.

Therefore, expressions like $(OwnerTeam in CurrentUserTeamNames()) now work.

A conditional expression is a tool that lets you evaluate alternatives depending if a condition is true or false. You can enter conditional expressions using the if statement in the following syntax:

$(if condition then whenTrue else whenFalse)

This expression has three parameters:

Neurons for ITSM only evaluates either the whenTrue or whenFalse value, based on the outcome of the condition.

You can nest if expressions within one another, so that the return value of one if expression feeds into another expression. It is most common to nest an if expression in the else part of another if expression. It is also possible to nest in the then and if parts of the expression, but that is less common. In all cases, note that the Neurons for ITSM expression syntax $() applies to the outermost expression.  You do not need to use the $() syntax anywhere within the nested expression.

The following expression return false if the incident status has a value of logged; otherwise, it returns a value of true:

$(if Status == "Logged" then false else true)

The return value of this conditional expression can then be used, for example, to determine when the Owner field in the Incident business object is mandatory (that is, when the status has a value other than logged):

Owner is required when $(if Status == "Logged" then false else true)

The following is a more complex example of a conditional expression. It is in a default incident editing rule and specifies the priority change to make when the urgency and impact fields are changed:

In this case, each combination of urgency and impact field values specifies the priority level from 1 to 5.

There are two types of case expressions: Boolean and value.

The Boolean case expression is similar to an if-then-else statement.

For example, this statement:

case

when a > 0

then 44

when a < 0

then 22

else 11

is equivalent to this statement:

if a > 0 then 44 else if a < 0 then 22 else 11

The application executes the case statements in order. You can also nest case expressions, as in this example:

case

when a > 0 then case

when b > 0 then 11

when b < 0 then 22

else 33

when a < 0 then case

when b > 0 then 44

when b < 0 then 55

else 66

else case

when b > 0 then 44

when b < 0 then 55

else 66

The following is an example of a value case expression:

$(if ViewType == "frsHelpDesk" then helpdesk_Priority else case Urgency when "High", "Higher" then (case Impact when "High" then "1" when "Medium" then "2" when "Low" then "3" ) when "Medium" then (case Impact when "High" then "2" when "Medium" then "3" when "Low" then "4" ) when "Low" then (case Impact when "High" then "3" when "Medium" then "4" when "Low" then "5" ) else "5")

This case expression is a modified form of the expression in an editing rule for an incident, change, or problem that calculates the priority based on the impact and urgency.

The expression after the case clause computes a value and then the application matches the when expressions for equality. In this case, the when can also have a list of values as in the first when clause above.

If there is more than one when clause with the same value, the application only evaluates one of the then expressions; however, it is not necessarily done in order.

You can omit the else clause, but then the expression generates an error if there is no selected when clause. The when values do not have to have constant values, which means that you can use "when a/b then...". If a when value does not have the same type as the case value, the usual implicit conversions apply to the when value to make it have the same type.