Page History

The JWT expression parser accepts the most common comparison operators as well as logical operators . 

The main purpose of these operators is to construct complex logical comparisons by linking individual expressions. 

A comparison always returns a

All operators respect the case of the characters.

1=1
true = true
[1, 2, 3] = [1, 2, 3]
["blue", "red", "green"] = ["blue", "red", "green"]

When working with Lists, each elements' existence and its order are being evaluated.

0 != 1
"HELLO" != "Hello"
%{issue.description} != "Hello"
true != false
[1, 2, 3] != [1, 3, 2]
["blue", "red", "green"] != ["blue", "green", "red"]

When working with Lists, each elements' existence and its order are being evaluated.

1 < 2
"abc" < "bbc"
"abc" < "abcd"

2 > 1
"bbc" > "abc"
"abcd" > "abc"

3 <= 3

"Hello world! Hello *" >= "Hello world"

"Hello world!" ~ "world" #true. The text "world" is contained in the first text.
%{issue.components.leads} ~ %{system.currentUser} #checks whether "Component leads" contains the "Current user".
[1, 2, 3, 2, 2, 4] ~ [2, 1, 2] #true
["blue", "red", "green", "red", "white", "red"] ~ ["red", "green", "red"] #true
["green", "red"] ~ ["red", "green", "red"] #false

"world" !~ "Hello world!" #false. The text "world" is contained in the first text.
%{issue.fixVersions} !~ %{issue.versions} #false if all "Affects version/s" are also selected as "Fix version/s".
[1, 2, 3, 2, 2, 4] !~ [2, 1, 1, 4] #true
["blue", "red", "green", "red", "red"] !~ ["red", "green", "green", "red"] #true

"world" in "Hello world!" #true. The text "world" is contained in the first text.
%{system.currentUser} in %{issue.components.leads} #true if current user is a component lead of any of the issue's components 
[1, 1, 2] in [2, 1, 1, 1, 4] #true
["blue", "red", "red"] in ["red", "green", "blue", "red", "red"] #true
2 in [1, 2, 3] #true
"blue" in ["red, "blue", "white"] #true

"Hello world!" not in "world" #true
%{issue.versions} not in %{issue.fixVersions} #false if all "Affects version/s" are also selected as "Fix version/s".
[1, 1, 2, 2] not in [2, 1, 1, 1, 4] #true
["blue", "red", "red", "blue"] not in ["red", "blue", "red", "red"] #true 
5 not in [1, 2, 3, 3, 4] #true
"orange" not in ["blue", "red", "white"] #true

%{issue.versions} any in %{issue.fixVersions} # true if any selected "Affects version/s" has also been selected as "Fix version/s". 
[1, 3] any in [3, 4, 5] #true
["blue", "white"] any in ["black", "white", "green"] #true

%{issue.versions} none in %{issue.fixVersions} #true if no selected "Affects version/s" has also been selected as "Fix version/s". 
[1, 2] none in [3, 4, 5] #true
["blue", "red"] none in ["black", "white", "green"] #true

["blue", "red", "green", "red", "white", "red"] ~ ["red", "green", "red"]

["green", "red"] ~ ["red", "green", "red"]

"HELLO" =~ "Hello" #true
"up" =~ "UP" #true
["blue", "red", "green"] =~ ["Blue", "RED", "Green"] #true

" HELLO" !=~ "Hello" #false, since there is a whitespace in the first text
"up" !=~ "down" #true
("up" !=~ "UP") #false 
["blue", "red"] !=~ ["Blue", "green"] #true
["blue", "red"] !=~ ["Red", "BLUE"] #true
["blue", "red", "green"] !=~ ["Blue", "RED", "Green"] #false

"Hello World!" ~~ "world" #true, checks whether a text contains a substring. 
"A small step for a man" ~~ "STEP" #true
["one", "two", "three"] ~~ ["TWO", "One"] #true, checks whether a text list contains all the elements of another text list.

"Hello World!" !~~ "bye" #true, checks whether a text does not contain a substring. 
"A small step for a man" !~~ "big" #true
["one", "two", "three"] !~~ ["Four"] #true, checks whether a text list does not contain a single element of another text list. 
(["one", "two", "three"] !~~ ["TWO"]) = false

"world" in~ "Hello World!" #true, checks whether a substring is contained in another text. 
"STEP" in~ "A small step for a man" #true 
["TWO", "One"] in~ ["one", "two", "three"] #true, checks whether all the elements of a text list are contained in another text list.

"bye" not in~ "Hello World!" #true, checks whether a substring is not contained in another text. 
"big" not in~ "A small step for a man" #true
["Four"] not in~ ["one", "two", "three"] #true, checks whether any of the elements of a text list are not contained in another text list. 
["TWO"] not in~ ["one", "two", "three"] #false

["blue", "violet"] any in~ ["Blue", "Red", "Green"] #true
["Five", "One"] any in~ ["FOUR", "FIVE", "SIX"]"bye" #true

["Orange"] none in~ ["red", "blue", "green"] #true, checks whether none of the elements of a text list are not contained in another text list. 
["orange"] none in~ ["Red", "Orange"] #false

1 in [1, 2, 3] 
["blue", "red"] ~ "blue"

"I love coding" ~ "love"
"I don't like Mondays" !~ "Fridays"
"love" in "I love coding"
"Fridays" not in "I don't like Mondays"

[1, 1] in [1, 1, 1]
[1, 1] not in [1, 2, 3]

[1, 2, 3] = [1, 2, 3]
[4, 5, 6] != [4, 6, 5]

1 < 2
"abc" < "bbc"
"abcd" > "abc"

Logical operators can only be used in logical expressions in the Logical mode or in combination with the conditional operator.

A single logical term can be enclosed by brackets () in order to increase the readability of the expressions or to define a precedence which differs from the given one. 

Logical operators can also be written in lower case (e.g. and , or )

<logical_expression> ? <term_1> : <term_2> 

The conditional operator is extremely helpful when being used in calculated fields.

%{issue.priority} = "Highest" ? "Please have a look at this issue immediately" : "No stress, come back later" 

{issue.duedate} != null ? ({...duedate} - {...currentDateTime}) / {HOUR} : 0

%{issue.somefield} = "Red" ? "Color" : "No color" 

timePart({...currentDateTime}, LOCAL) > 21:00 AND timePart({...currentDateTime}, LOCAL) < 7:00 ? "Night" : "Day"

• When using the list operators, you have to make sure that both lists that you compare are of the same type.
• All operators are case insensitive, i.e., they can also be written in lower case: append, union, intersect and except .
• There are four equivalent functions available for each type of list, and their behavior is exactly equivalent to that of its corresponding operator.
  • append()
  • except()
  • intersect()
  • union()
• This way, you can choose to use operators or functions according to your preference. Although operators yield shorter expressions and with fewer parentheses, the usage of functions produces a more functional consistent syntax.