Conditions

A condition in Alumio is an object that tests a single value. Conditions can be used in transformers to filter values or to conditionally transform values.

Example use of a condition in a filter

In the following example a condition is used in an entity filter to remove products that are not enabled.

{
  "prototype": "data",
  "parameters": {
    "filters": [
      {
        "prototype": "value-condition",
        "parameters": {
          "accessor": {
            "prototype": "key",
            "parameters": {
              "keys": [
                "enabled"
              ]
            }
          },
          "conditions": [
            {
              "prototype": "equals",
              "parameters": {
                "value": true
              }
            }
          ]
        }
      }
    ]
  }
}

Input:

[
  {
    "sku": "tnt",
    "enabled": true
  },
  {
    "sku": "dynamite",
    "enabled": false
  }
]

Output:

[
  {
    "sku": "tnt",
    "enabled": true
  }
]

Combining conditions

Conditions can be combined using logical conditions. They can also be combined with a mapper using a mapped condition.

Logic: not

Code: logic-not

{
  "prototype": "logic-not",
  "parameters": {
    "conditions": [
      {
        "prototype": "type-array"
      }
    ]
  }
}

> ["foo"] => false
> "foo"   => true

Logic: and

Code: logic-and

{
  "prototype": "logic-and",
  "parameters": {
    "conditions": [
      {
        "prototype": "format-email"
      },
      {
        "prototype": "string-length-between",
        "parameters": {
          "min": 6
        }
      }
    ]
  }
}

> "example@example.com" => true
> "x@x.com"             => false

Logic: or

Code: logic-or

{
  "prototype": "logic-or",
  "parameters": {
    "conditions": [
      {
        "prototype": "format-email"
      },
      {
        "prototype": "format-url"
      }
    ]
  }
}

> "example@example.com" => true
> "https://example.com" => true
> "foo"                 => false

Mapped condition

Code: mapped-condition

A mapped condition applies a mapper on the value before the value is tested.

{
  "prototype": "mapped-condition",
  "parameters": {
    "mappers": [
      {
        "prototype": "string-upper"
      }
    ],
    "conditions": [
      {
        "prototype": "equals",
        "parameters": {
          "value": "POST"
        }
      }
    ]
  }
}

> "POST" => true
> "post" => true
> "get"  => false

Available conditions

The following are available conditions.

For custom conditions, !! a new condition !! can be created.

Equals

Code: equals

Compare a value against a configured value. Both the type and the value have must match.

{
  "prototype": "equals",
  "parameters": {
    "value": 10
  }
}

> 10   => true
> 9    => false
> "10" => false

Not equals

Code: not-equals

Inverse of "Equals".

Equals adaptive

Code: equals-adaptive

Compare a value adaptively to a configured value. The type may differ.

{
  "prototype": "equals-adaptive",
  "parameters": {
    "value": 10
  }
}

> 10   => true
> 9    => false
> "10" => true

Not equals adaptive

Code: not-equals-adaptive

Inverse of "Equals adaptive".

One of list

Code: one-of

Compare a value to a list of values.

{
  "prototype": "one-of",
  "parameters": {
    "value": [
      10,
      20
    ]
  }
}

> 10 => true
> 20 => true
> 9  => false

Not one of list

Code: not-one-of

Inverse of "One of list"

Empty

Code: empty

Checks whether a value is empty.

> 0    => true
> 10   => false
> null => true
> []   => true
> [10] => false

Note that this condition usually does not check whether a value has been set. To be able to check the value it has to be retrieved from the entity.

Not empty

Code: not-empty

Inverse of "Empty".

Number: greater than

Code: number-greater-than

{
  "prototype": "number-greater-than",
  "parameters": {
    "value": 10
  }
}

> 11 => true
> 10 => false

Number: greater than or equals

Code: number-greater-than-or-equals

{
  "prototype": "number-greater-than-or-equals",
  "parameters": {
    "value": 10
  }
}

> 11 => true
> 10 => true
> 9  => false

Number: less than

Code: number-less-than

{
  "prototype": "number-less-than",
  "parameters": {
    "value": 10
  }
}

> 9  => true
> 10 => false

Number: less than or equals

Code: number-less-than-or-equals

{
  "prototype": "number-less-than-or-equals",
  "parameters": {
    "value": 10
  }
}

> 9  => true
> 10 => true
> 11 => false

List: contains

Code: list-contains

{
  "prototype": "list-contains",
  "parameters": {
    "value": 10
  }
}

> [8, 9, 10] => true
> [1, 2, 3]  => false
> 2          => false

List: Does not contain

Code: list-not-contains

Inverse of "List: contains".

String: Matches fnmatch pattern

Code: string-match

Compares a string to an fnmatch pattern.

{
  "prototype": "string-match",
  "parameters": {
    "value": "foo-*"
  }
}

> "foo-bar" => true
> "bar"     => false

String: Does not match fnmatch pattern

Code: string-not-match

Inverse of "String: Matches fnmatch pattern".

String: Matches PCRE expression

Code: string-regex

Compares a string to PCRE regular expression

{
  "prototype": "string-regex",
  "parameters": {
    "value": "/foo-.*/"
  }
}

> "foo-bar" => true
> "bar"     => false

String: Does not match PCRE expression

Code: string-not-regex

Inverse of "String: Matches PCRE expression".

String: Contains only alphanumeric characters

Code: string-alnum

Checks whether a string only contains alphanumeric characters.

> "foo123" => true
> "foo@#$" => false

String: Contains only alphabetic characters

Code: string-alpha

Checks whether a string only contains alphabetic characters.

> "foo"    => true
> "foo123" => false

String: Contains only numbers

Code: string-number

Checks whether a string contains only numbers.

> "123"    => true
> "foo123" => false

String: Length equals

Code: string-length

Checks whether the length of a string equals a number.

{
  "prototype": "string-length",
  "parameters": {
      "length": 3
    }
}

> "foo"    => true
> "foobar" => false

String: Length between

Code: string-length-between

Checks whether the length of a string is between two values.

{
  "prototype": "string-length-between",
  "parameters": {
    "max": 6,
    "min": 3
  }
}

> "f"         => false
> "foo"       => true
> "foobar"    => true
> "foobarbaz" => false

Format: Valid date time

Code: format-datetime

> "2019-01-01 00:00:00" => true
> "now"                 => true
> "foo"                 => false

Format: Valid credit card

Code: format-credit-card

> "4111111111111111" => true
> "foo"              => false

Format: Valid email address

Code: format-email

> "example@example.com" => true
> "foo"                 => false

Format: Valid URL

Code: format-url

> "https://example.com/index.html" => true
> "foo"                            => false

Format: Valid unique identifier (UUID)

Code: format-uuid

> "6fc23076-8d38-4563-9cb2-1e91f6621666" => true
> "foo"                                  => false

Format: Valid JSON

Code: format-json

> "{\"foo\": [\"bar\"]}" => true
> "\"foo\""              => true
> "false"                => true
> "No JSON"              => false

Type: boolean

Code: type-boolean

> true => true
> 10   => false

Type: string

Code: type-string

> "foo" => true
> 10    => false

Type: integer

Code: type-integer

> 10    => true
> "foo" => false

Type: float

Code: type-float

> 10.5  => true
> "foo" => false

Type: numeric

Code: type-numeric

> 10.5  => true
> 10    => true
> "10"  => true
> "foo" => false

Type: array

Code: type-array

> ["foo"] => true
> "foo"   => false