We have put together expressions for the following common situations when you may want the system to automatically fill in a field’s value. If you see an expression that is applicable for your situation, copy the expression text from this article and paste it into the “expression” field in Case IQ. Your application will likely have different names for fields, so make sure to replace the field names in the expression per your application. We have created these example expressions following ISEL conventions outlined in the “Expression Language and Syntax”, “ ISEL Functions”, and “Context Objects” tabs of this article. 

All example expressions are created for the case form, except “Calculate a Party's Age”. If you want to add a computed field to another form, change the object to the form name.

Today's Date

Populate a field with the current date when the case is saved.

Set Field

Expression for Today field:

if(isEmpty(this.value)) then now else this.value

Calculate a Party's Age

Calculate a person's age based on their date of birth on the party form. In this example, the “Age" field has been added to the party form, so party is used as the object in the expression.

Input Fields

Set Field

Expression for Age field:

yearsBetween(now, party.dateOfBirth)

Percent

Find the percentage between two case fields' values.

Input Fields

Set Field

Expression for Percent field:

divide(case.field1, case.field2)*100

Categorization

Categorize a case based on the answers to several radio or checkbox questions posed to the user submitting the case. Subsequently, you can use the computed category as display criteria for workflows, workflow steps, or other form fields.

Input Fields

Set Field

Expression for Category field:

(
	(case.question1 == true ? 5 : 0) + 
	(case.question2 == "Answer 3" ? 2 : (case.question2 == "Answer 2" ? 1 : 0)) + 
	(case.question3 == "Yes" ? 1 : 0 ) + 
	case.question4
) > 6 ? "Category A" : "Category B"

Priority By Cost

Calculate priority for a case based on its total cost. The “Priority” will be set to “High” when the “Total Cost” is greater than or equal to $1000, “Medium” when “Total Cost” is greater than or equal to $500 and less than or equal to $1000, and “Low” when “Total Cost” is less than or equal to $500. This may be combined with rules and actions to set specific flags based on the computed field.

Input Fields

Set Field

Expression for Priority field:

case.totalCost >= 1000.00 ? 
	'High' : 
	(case.totalCost >= 500 ? 'Medium' : 
	(case.totalCost <= 499.00 ? 'Low' : '')
	)

Priority By Case Type

Calculate priority based on case properties, such as “case type”. In this example, the “Priority” will be set to “High” when case type is “Case Type 1”, “Medium” when case type is “Case Type 2”, and “Low” when case type is “Case Type 3”. This may be combined with rules and actions to set specific flags based on the computed field.

Input Field

Set Field

Expression for Priority field:

case.caseType == 'Case Type 1' ? 
	'High' : 
	(case.caseType == 'Case Type 2' ? 'Medium' : 
	(case.caseType == 'Case Type 3' ? 'Low' : '')
	)

Risk Assessment

Assess risk based on Case Type, Likelihood (1-5), Consequence (1-5) and setting the Risk rating. This expression is based on Case IQ's Risk Assessment Matrix.

Input Fields

Set Fields

Expression for Risk Rating field:

sum(case.likelihood, case.consequence)

Expression for Risk Assessment field: 

sum(case.likelihood, case.consequence) <= 6 ? 
	((case.likelihood + case.consequence) < 5 ? "Low" : "Medium") : 
	((case.consequence + case.likelihood) > 7 ? "Extreme" : "High")

Due Date

Calculating the date a case is due by adding either 15 or 30 business days to the created date based on “case type”.

Input Fields

Set Field

Expression for Due Date field:

case.caseType == 'Case Type 1' ? 
	addBusinessDays(case.dateRecorded, 15) : 
	addBusinessDays(case.dateRecorded, 30)

Summary

Calculating the content of a text area field that includes string concatenation and formatting of various other fields such as Case Type, Date Created, Priority, Categories, etc.

Input Fields

Set Field

Expression for Summary field:

concat('The Case Type is ' 
	+ case.caseType 
	+ '. The Created Date is ' 
	+ case.dateRecorded 
	+ '. The Case Priority is ' 
	+ case.priority 
	+ '. The Case Category is ' 
	+ case.category 
	+ '.'
)

Totals

Calculate a money field whose value is a sum of other money fields (ie. total amount charged or owed).

Input Fields

Set Field

Expression for Total field:

sum(case.payment1, case.payment2, case.payment3)

Write Up

Joining case information into a text area field to include the content in email or file templates and distribution. May include properties such as the Name and Email address of the case submitter or the last acting user and global system context properties such as "System Name" and "Support Address".

This example only uses system fields as the inputs, meaning that you will not need to add fields to a form for the input fields. You only need to add the field you want Case IQ to set.

Input Fields

Set Field

Expression for Write Up field:

join([case.caseNumber, "was recorded on", case.recordedDate, "and has status of", case.status], " ") + "."

Dynamic Case Number Format with Case Type

Set up a dynamic case number format based on the case's type on intake. See details on configuring the case number format and an explanation of each case number component in the Case Number Format article. In this example, the case number prefix will change depending on the “Case Type” field. This expression will generate case numbers in the following format:

CASETYPE-MM-YY-000

• “CASETYPE”: the system will populate this element with one of the following prefixes, based on the case type selection:
  • COMP
  • INV
  • QUERY
  • OTHER
• “-”: the character you enter in the "Separator" field will be used to separate each case number component.
• “MM": the month the case is created using the format you select in the “Month Format” field.
• “YY”: the year the case is created using the format you select in the “Year Format” field.
• "000": the sequential case number count that the system generates based on the number of cases added to the application, counting up from 1. The length of the sequence will be determined by your selection in the “Minimum sequence size” field.

Input Fields

Set Field

Expression to enter in the “Expression” field on the Case Number Configuration page:

case.caseType == "Complaint" 
	? "COMP" 
	: (case.caseType == "Investigation" 
		? "INV" 
		: (case.caseType == "Query" 
			? "QUERY" 
			: "OTHER"
		)
	)) 
	+ this.separator 
	+ format(now, this.monthFormat) 
	+ this.separator 
	+ format(now, this.yearFormat) 
	+ this.separator 
	+ padStart(this.sequence, 3, "0")

Dynamic Case Number Format Using Additional Date Field

Set up a dynamic case number format that includes an additional date field set on intake. See details on configuring the case number format and an explanation of each case number component in the Case Number Format article. In this example, the case number month and year will be set by a date field available on the intake form, called “Claim Date”. This expression will generate case numbers in the following format:

YYYY-MM-000

• “YYYY”: the year set in the “Claim Date” field on intake using the format you select in the “Year Format” field.
• “-”: the character you enter in the "Separator" field that will be used to separate each case number component.
• “MM": the month set in the “Claim Date” field on intake using the format you select in the “Month Format” field.
• "000": the sequential case number count that the system generates based on the number of cases added to the application, counting up from 1. The length of the sequence will be determined by your selection in the “Minimum sequence size” field.

Input Fields

Set Field

Expression to enter in the “Expression” field on the Case Number Configuration page:

format(case.claimDate, this.yearFormat) 
+ this.separator 
+ format(case.claimDate, this.monthFormat) 
+ this.separator 
+ padStart(this.sequence, 3, "0")

Set Value of a Static Field

If you want to set up a field whose value can be set by the system evaluating an expression, while remaining editable by a user, you can use a “Set Field Value” rule action. See the “Set Field Value” section under the “Actions” tab of the Add a Rule article for details on creating “Set Field Value” actions. This expression will set the case type field value based on the record source.

Input Fields

Set Field

Expression for Case Type field:

case.recordSource == "web" ? "Case Type 1" : 
	(case.recordSource == "external" ? "Case Type 2" : 
		(case.recordSource == "email" ? "Case Type 3" : "")
	)

Retain Data Submitted on Portal in Read Only Fields

You can create case fields that will be read-only in the internal application to retain the original data submitted by the reporter via the portal. Set up a duplicate field where internal users can edit the answer entered in the field. In this example, portal users can enter text in the “Portal Incident Details” field, but the field will be uneditable on the case's page in the internal application. Internal users can instead enter information in the “Incident Details” field. However, if a portal user does not enter information in the “Portal Incident Details” field, it will be populated with the “Incident Details” text.

Input Fields

Set Field

Expression for Portal Incident Details field:

case.portalIncidentDetails ? 
	case.portalIncidentDetails : case.incidentDetails

Retain Case Type Submitted on Intake in Read Only Fields

Similar to the previous example, you can create a field to retain the case type selected when the case was initially submitted. The system will copy the “Case Type” option selected by the reporter to the “Intake Case Type” field. Internal users will be able to update the “Case Type” field as needed but the “Intake Case Type” cannot be edited.

Input Fields

Set Field

Expression for Intake Case Type field:

if(isEmpty(this.value)) then case.caseType else this.value

JEXL is a context-based expression parser and evaluator that uses similar syntax to JavaScript. As ISEL is a simplified version of JEXL, this document only covers the relevant JEXL conventions to ISEL. 

If you are interested in learning more about JEXL, see the JEXL resources on Apache Commons.

Introduction to Expression Format

Expressions must follow a specific format for the system to understand the actions you want it to execute and to what fields. They can include a combination of the following elements:   

You can combine the functions and operators listed in this guide with objects and variables from your application to create ISEL expressions. For example, you could set up a field to be automatically filled in with any money amount entered in a field on the case form, say the “Total Expense” field, plus 15% tax. For the field you want the system to fill in with this sum, you would enter the following in the “Expression” text box:

This expression would tell the system to multiply the amount in the “Total Expense” field by 1.15 and fill in the computed field with the amount it calculated.

You do not have to include static values in your expressions and can opt to only use variables as your inputs. For example, you could calculate the total expenses of a case by adding two case fields, called “Cash Expenses” and “Credit Card Expenses”, then fill in a field with the sum of those amounts. You would enter the following in the “Expression” text box for the field you wanted the system to fill in.

As ISEL is based on JEXL, use the same syntax and operators as you would writing JEXL expressions, which are covered in this section of the guide. However, ISEL contains unique functions, which are covered in the next section of this guide, ISEL API. For all ISEL functions, you can either use the format outlined in the String Functions, Math Functions, and Date Functions sections of this guide or transform your expressions, so you have the option to include multiple functions in the same row, as detailed in Transform Expressions.

Operators

Use an operator symbol in expressions to tell the system what action to perform with or how to compare any variables or values in the expression. For example, you can perform arithmetic with operators:

You can also combine a “string”, or an object storing a text, with a variable using the + operator, as in the example below: 

The following table lists all operators you can use to create expressions with ISEL. For most operators, you can use either the symbol or the English word or phrase in expressions.

You can use the in operator to check for text in a string (e.g. "Green" in "Derek Greene") or an “array” element, or a group of values, (e.g. "Investigation" in ['Complaint', 'Investigation', 'Query'] or 'Investigation' in case.arrayField). However, use the == operator when you search an array of objects, called a collection (see the Collections section of this guide for more).

Conditional Expressions and Ternary Operators

You can use conditional expressions to define two different results when the system evaluates the expression based on the situation. Conditional expressions contain three segments in either of the following formats: 

condition ? if_true : if_false

or

if(condition) then if_true else if_false

In the condition segment, you enter a statement that can be found true or false. The system will check if the condition expression evaluates as true. If it is true, the second segment of your expression will be evaluated. If it is false, the system will skip over the second segment and evaluate the third segment instead. If you leave out the if_true section from your expression, the result of the condition segment will be returned instead.

For example, you could automatically set a case field as “High” priority if the case is set as confidential and “Low” priority when the case is not confidential. Supposing you had a radio, picklist, or text box field called “Priority” on the case form, you could create a “Set Field Value” rule action for the “Priority” field and enter the following into the “Expression” text box to accomplish this:

With this expression, the system will check if the case has been set as confidential, per the expression’s first segment. If so, it will refer to the second segment of the expression, which tells the system to set “Priority” as “High”. When the case is not confidential, the system will make sure “Priority” is “Low”.

You can create expressions with multiple conditions by either nesting multiple conditions in one conditional expression or using the ifeach function. Nested conditional expressions can return more than two different values. To nest a condition, enter it in the if_false segment of an expression. See the following nested conditional expression written out in two different formats as an example:

if(case.caseType equals "Case Type 1") then "High" else 
                                                                                        	if(case.caseType equals "Case Type 2") then "Medium" else 
                                                                                        		if(case.caseType equals "Case Type 3") then "Low" else ""

or

case.caseType == "Case Type 1" ? "High" : 
                                                                                        	(case.caseType == "Case Type 2" ? "Medium" : 
                                                                                        		(case.caseType == "Case Type 3" ? "Low" : "")
                                                                                        	)

This nested expression returns “High”, “Medium”, or “Low” based on one of three possible values of the “Case Type” field, which could be used to set a priority field by “Case Type” for example. 

You can use the ifeach function to create expressions where multiple conditions must be true to return a value (see the “String Functions” section in the ISEL Functions tab of this article for an explanation of each function argument). The example ifeach function below evaluates two conditions before returning a value: 

ifeach([case.confidential == true, case.caseType == 'Investigation'], 'High Priority', 'Low Priority')

This expression will return “High Priority” only when the case is both set to confidential and its “Case Type” is “Investigation”. “Low Priority” will be returned when the case is confidential or its “Case Type” is not “Investigation”.

Native Types

The following data types are built into ISEL. 

Groups

Use parentheses, (), to denote groups and control the order of operations for calculations. 

Identifiers

Refer to variables of the object (i.e. fields on the form) by entering the object name, a period, and then the variable name. For example, case.caseType.

You can also refer to specific values of a variable using square brackets ([]) around the value in the expression. Enter the object name, a period, the variable name, an open square bracket, the variable’s value, and then a closed square bracket. For example, case.confidential[true]. 

You can use this syntax to identify specific values in an array, such as a picklist and its options. Suppose your application contained a picklist called “Location” with the following options: “Toronto”, “Montreal”, and “Vancouver”. The values in an array are ordered by number, starting at 0. The table below shows how you would identify each “Location” picklist option in an expression.  

Collections

You can filter any collections in your application by entering a filter expression in square brackets and referencing the properties of the collection using a period, i.e. object.collection[.variable in filter expression], which will result in an array of the objects for which the filter expression is true. If you want the result to be a single object variable, enter the variable following the filter expression: object.collection[.filter expression].variable. 

For example, attachment records in Case IQ contain a collection called “Files”. The “Files” collection includes the following objects:

name
                                                                                                        sizeBytes
                                                                                                        nameWithoutExtension
                                                                                                        encoding
                                                                                                        mimeType
                                                                                                        objectId
                                                                                                        description

If you wanted to pull a list of attached files that are over a certain file size, say 30 KB (or 30720 bytes), you would enter the following expression:

attachment.files[.sizeBytes > 30720]

This expression would return an array of all attached files that are over 30720 bytes, meaning that the name, bytes, etc. for each file that met the criteria would be pulled. If you just wanted a list of their file names, you would enter the following expression instead:

attachment.files[.sizeBytes > 30720].name

Most ISEL functions are “type agnostic”, meaning that they will work with numbers, arrays, strings, or Boolean types, so you do not have to check if the function type matches the value type you input. 

String Functions

Math Functions

ISEL’s math functions are also type agnostic. However, the types of inputted values will be coerced into numbers for math following these rules:

• The system will attempt to turn a string into a number. If it cannot, its value will default to 0. 
• For Booleans, a true value will be converted to 1 and false to 0. 
• The system will process each value of an array in an expression and return a new array. The new values will be outputted in the same order, except if the sum, subtract, multiply, and divide functions were used in the expression. For these functions, a single number will be calculated by performing the operation on each value of the array.

Date Functions

ISEL has many unique functions for date type values. The functions that add to or subtract time from a date value will return a date value. For example, you can write the following expression to fill in a field with the date the case was created plus 2 days:

addDays(case.dateRecorded, 2)

Transform Expressions

You can transform expressions to write it in a different format, allowing you to use multiple functions in a single row. Use the transform pipe character, |, to transform an expression following this order of elements: 

object.variable | function(value)

Instead of the function formats outlined in the String Functions, Math Functions, and Date Functions sections, you can use the transformed format to write the same expression. For example, to add days to the date the case was created (dateRecorded), you can either write: 

or

You can also combine multiple functions in a single expression using the transform syntax, i.e. object.variable | function1(value) | function2(value) | function3(value). Functions will be evaluated in the order entered in the expression. For example, in the expression case.number | sum(4) | multiply(5), the system would add 4 to the number variable, then multiply it by 5.

ISEL has implicit context, meaning that the objects you can refer to in expressions are already identified by the system and you do not need to create a context for your expression. When writing your expression, the object available is the form on which the field you are creating the expression is located. 

Now Object

now is a simple object that does not have variables. Enter now in an expression to refer to the current date and time a form was saved or the Set Field Value rule was triggered.

System Object

The system object contains basic information about the Case IQ application in which you are working. You can use system and its variables, which are listed below, just like the form objects used in this guide’s examples so far. 

User Object

The user object allows you to contextually refer to the last user account that updated a record. For example, you could enter user.email in an expression to fill in a field with the email address of the last person who updated a case. The table below contains all variables of user.

Math Object

In addition to the form objects, you will also be able to use the math object. You can use the math object to perform arithmetic using mathematical constants, such as pi. Just like form objects in ISEL, you do not need to construct or set up the math object, meaning that you can get started using it in expressions right away. For example, to refer to pi, enter the following in your expression:

The following properties are available for the math object in ISEL:

This and Field Objects

The this and field objects allow you to contextually refer to the entity for which you are creating the expression. For example, when creating a “set field value” rule action, you can use the field object to refer to the properties of the field that will be set by the rule, including its caption, name, type, and value. Entering field.caption will return the field's caption text.

The field object will only be available when you are creating an expression for a field, such as  “set field value” rule actions, computed fields, and aggregate fields. You can use the this object instead to pull the same information, for example, when writing an expression for the case number format. When typing in the “Expression” field on the Case Number page in Settings, entering this.prefix will return the prefix set as the case number format.