Aloe.EnterpriseOne.Model.Systems.Bpm.ExpressionCompiler.Operators Namespace |
Classes| Class | Description | |
|---|---|---|
 | AddDaysOperator |
Represents ADDDAYS operator, which adds the specified number of days to a date.
Format: ADDDAYS(date, num_days)
Result: date.AddDays(num_days)
|
| AddOperator |
Represents ADD operator, which adds its arguments.
Format: ADD(param1, param2)
Result: param1 + param2
|
| AndOperator |
Represents AND operator, which performs boolean AND over its parameters.
Format: AND(condition1[, condition2[, condition3]]) Result: condition1 [&& condition2 [&& condition3]] |
| CastOperator |
Represents CAST operator, which casts a parameter to a type.
Format: CAST(param, type) Result: (type)param |
| CeilingOperator |
Represents CEILING operator, which
returns the smallest integral value that is greater than or equal to the specified decimal number
Format: CEILING(d) Result: Math.Ceiling(d) |
| ConcatOperator |
Represents CONCAT operator, which concatenates strings.
Format: CONCAT(str1, str2)
Result: string.Concat(str1, str2)
|
| ConvertOperator |
Represents CONVERT operator, which converts its input to the specified type.
Format: CONVERT(param, new_type) Result: Convert.ChangeType(param, new_type) |
| CountOperator |
Represents the COUNT operator, which returns the number of items in a list
Format: COUNT(LIST) Result: integral number of items |
| DivideOperator |
Represents the DIVIDE operator, which divides a its parameters.
Format: DIVIDE(param1, param2) Result: param1 / param2 |
| EqualOperator |
Represents the EQUAL operator, which is equality comparison.
Format: EQUAL(param1, param2) Result: param1 == param2 |
| FilterOperator |
Represents FILTER operator, which filters a list according to a condition.
Format: FILTER(list, condition) Result: list.Where(x => condition(x)) |
| FirstOperator |
Represents the FIRST operator, which returns the first element from a list.
Format: FIRST(list) Result: list.FirstOrDefault() |
| FloorOperator |
Represents FLOOR operator, which
returns the smallest integer less than or equal to the specified decimal number.
Format: FLOOR(num) Result: Math.Floor(num) |
| FormatStringOperator |
Represents the FORMATSTRING operator, which formats the supplied input variable with the specified format.
Format: FORMATSTRING(input_var, format_string) Result: string.Format($"\{0:{format_string}\}", input_var) |
| GetObjValueOperator |
Represents the GETOBJVALUE operator, which returns the value of a data attribute of an object.
Format: GETOBJVALUE(obj, attrib) Result: obj[attrib] |
| GetValueOperator |
Represents the GETVALUE operator, which returns the value of its first parameter.
Format: GETVALUE(param) Result: param |
| GteOperator |
Represents the GTE operator, which is greater than or equal comparison.
Format: GTE(param1, param2) Result: param1 >= param2 |
| GtOperator |
Represents the GT operator, which is greater than comparison.
Format: GT(param1, param2) Result: param1 > param2 |
| IifOperator |
Represents IIF operator, which performs functional if-then-else.
Format: IIF(condition, if_true, if_false) Result: condition ? if_true : if_false |
| IncnumOperator |
Represents the INCNUM operator, which increments is first parameter, a string
Format: INCNUM('AA01') Result: 'AA02' |
| InOperator |
Represents the IN operator, which returns whether an object is in a list.
Format: IN(list, obj) Result: list.In(obj) |
| LeftOperator |
Represents the LEFT operator, which returns the specified number of left-most characters from the supplied string.
Format: LEFT(str, num_chars) Result: str.Substring(0, Math.Min(num_chars, str.Length)) |
| LenOperator |
Represents the LEN operator, which returns the length of a string.
Format: LEN(str) Result: str.Length |
| LikeOperator |
Represents the LIKE operator, which matches an input against a pattern, using LIKE semantics.
Format: LIKE(input, pattern) Result: input.LIKE(pattern) |
| ListOperator | Represents the LIST operator, Returns a list with the string values of the specified attribute of the list of objects. The values in the created list are separated by a separator.If there is no indicated separator, then the list is separated with ", " (comma + space) by default. Format: LIST(list, attribute, separator (optional)) (attributeValue1, attributeValue2, ...) |
| LteOperator |
Represents the LTE operator, which is less than or equal comparison.
Format: LTE(param1, param2) Result: param1 <= param2 |
| LtOperator |
Represents the LT operator, which is less than comparison.
Format: LT(param1, param2) Result: param1 < param2 |
| MultiplyOperator |
Represents the MULTIPLY operator, which multiplies a its parameters.
Format: MULTIPLY(param1, param2) Result: param1 * param2 |
| NotOperator |
Represents the NOT operator, which performs a boolean negation.
Format: NOT(param1) Result: !param1 |
| OrOperator |
Represents OR operator, which performs boolean OR over its parameters.
Format: OR(condition1, condition2) Result: condition1 || condition2 |
| PosOperator |
Represents the POS operator, which returns the position of a term within a string.
Format: POS(str, term) Result: str.IndexOf(term) |
| RegexOperator |
Represents the REGEX operator, which matches an input against a pattern, using REGEX semantics.
Format: REGEX(input, pattern) Result: Regex.IsMatch(input, pattern) |
| ReplaceOperator |
Represents the REPLACE operator, which replaces all occurrences of a term within a string with another term.
Format: REPLACE(str, term, new_term) Result: str.Replace(term, new_term) |
| RightOperator |
Represents the RIGHT operator, which returns the specified number of right-most characters from the supplied string.
Format: RIGHT(str, num_chars) Result: str.Substring(str.Length - Math.Min(num_chars, str.Length)) |
| RoundOperator |
Represents ROUND operator, which rounds a decimal value to the nearest integral value.
Format: ROUND(number, precision = 0) Result: Math.Round(number, precision) |
| SelectOperator |
Represents the SELECT operator, which retrieves data from the database.
Format: SELECT(repository, clauses) Result: Transaction.Query<repository>().clauses.Take(MaxQueryRows) |
| SortOperator |
Represents the SORT operator, which sorts its input sequence.
Format: SORT(list, attribute, sort_order: ASC|DESC) Result: list.OrderBy[Descending](x => x[attribute]) |
| SubstringOperator |
Represents the SUBSTRING operator, which returns a sub-string of a string.
Format: SUBSTRING(str, start, length) Result: str.Substring(start, length) |
| SumOperator |
Represents the SUM operator, which computes the sum of values in a sequence.
Format: SUM(list, attribute) Result: list.Sum(e => e[attribute]) |
| TodayOperator |
Represents the TODAY operator, which returns the current date.
Format: TODAY Result: DateTime.Today |
| ToLowerOperator |
Represents the TOLOWER operator, which returns a lowercase version of the input string.
Format: TOLOWER(str) Result: str.ToLowerInvariant() |
| TopOperator |
Represents the TOP operator, which returns the specified number of elements from the start of a sequence.
Format: TOP(count, list) Result: list.Take(count) |
| ToUpperOperator |
Represents the TOUPPER operator, which returns an upper-case version of the input string.
Format: TOUPPER(str) Result: str.ToUpperInvariant() |
| WhereOperator |
Represents the WHERE operator, which is a clause, filtering a sequence.
Format: WHERE(condition1[, condition2[, condition3]]) Result: context.Where(e => conditon1(e))[.Where(f => conditon2(f))[.Where(g => condition3(g))]] |