Documentación: Nodo Condicional IF

Descripción General

El Nodo Condicional IF evalúa una o más condiciones y bifurca el flujo de la automatización según el resultado. Si la evaluación es verdadera, la ejecución continúa por la ruta true; de lo contrario, continúa por la ruta false.

¿Cuándo usar este nodo?

Utiliza este nodo cuando necesites:

• Tomar decisiones dentro de una automatización (si/entonces/sino)
• Validar datos antes de ejecutar una acción
• Aplicar filtros (por ejemplo, solo procesar eventos con un texto específico)
• Implementar reglas con múltiples condiciones combinadas

Rutas de salida

Este nodo tiene dos rutas:

• true: se ejecuta cuando el resultado final de la evaluación es verdadero.
• false: se ejecuta cuando el resultado final de la evaluación es falso.

Configuración del Nodo

Paso 1: Definir el combinador de condiciones

El campo combinator define cómo se combinan las condiciones del arreglo conditions:

• AND: todas las condiciones deben ser verdaderas.
• OR: basta con que una condición sea verdadera.

Paso 2: Agregar condiciones

El campo conditions es un arreglo requerido con la lista de condiciones a evaluar. Cada condición requiere:

• id (string, requerido): identificador único de la condición (usado por la UI).
• leftValue (string): valor izquierdo (texto a evaluar).
• operator (objeto, requerido):
• name (string): etiqueta/UI (no afecta la lógica).
• operation (string): operación (ver tabla abajo).
• type (string): string o number (otros tipos hoy retornan error).
• singleValue (bool): aplica solo para number (ver detalles abajo).
• rightValue (string): requerido para la mayoría de comparaciones (excepto operaciones “single value” en number).

Note

En operaciones tipo string, los valores se comparan como texto. Esto incluye comparaciones “greater/less”, que son lexicográficas (por ejemplo, "10" < "2" puede resultar true).

Paso 3: Opciones de comparación

En options puedes configurar:

• caseSensitive (bool): si es false, en condiciones de tipo string el nodo convierte leftValue y rightValue a minúsculas antes de comparar.

Operaciones soportadas

Operadores tipo string (operator.type = "string")

Single-value (no usan rightValue):

operation	Descripción
exists	leftValue existe (no es vacío)
does not exist	leftValue no existe (es vacío)
is empty	leftValue es vacío
is not empty	leftValue no es vacío

Comparación / búsqueda:

operation	Descripción
is equal to	Igualdad
is not equal to	Desigualdad
contains	Contiene
does not contain	No contiene
starts with	Comienza con
does not start with	No comienza con
ends with	Termina con
does not end with	No termina con
matches regex	rightValue se usa como patrón regex y leftValue como texto
does not match regex	Negación de matches regex

Comparaciones “greater/less” (lexicográficas):

operation	Descripción
is greater than	leftValue > rightValue (texto)
is less than	leftValue < rightValue (texto)
is greater than or equal to	leftValue ≥ rightValue (texto)
is less than or equal to	leftValue ≤ rightValue (texto)

Note

Si necesitas comparar números (por ejemplo 10 vs 2) usa operator.type = "number" con singleValue = false.

Operadores tipo number (operator.type = "number")

Si singleValue = true (no parsea a número; evalúa el string leftValue):

operation	Descripción
exists	leftValue existe (no es vacío)
does not exist	leftValue no existe (es vacío)
is empty	leftValue es vacío
is not empty	leftValue no es vacío

Si singleValue = false (parsea leftValue y rightValue como float64):

operation	Descripción
is equal to	Igualdad numérica
is not equal to	Desigualdad numérica
is greater than	Mayor que
is less than	Menor que
is greater than or equal to	Mayor o igual que
is less than or equal to	Menor o igual que

Warning

Si leftValue o rightValue no son numéricos en comparaciones numéricas (singleValue = false), el nodo retorna error.

Estructura JSON

La configuración del nodo genera un JSON con esta forma:

{
  "combinator": "AND",
  "conditions": [
    {
      "id": "a6e0e332d43",
      "leftValue": "",
      "rightValue": "",
      "operator": {
        "type": "string",
        "operation": "is equal to",
        "name": "is equal to",
        "singleValue": true
      }
    }
  ],
  "options": {
    "caseSensitive": true
  }
}

Campos requeridos

• conditions (array) con al menos una condición válida.
• conditions[].id (string).
• conditions[].operator (objeto) con type y operation.

Campos opcionales

• combinator (por defecto suele ser AND si no se especifica).
• conditions[].leftValue, conditions[].rightValue (según operación).
• options.caseSensitive (por defecto true).

Ejemplos de Uso

Ejemplo 1: Validar igualdad de texto (string)

Caso: si el evento contiene una etiqueta exacta.

{
  "combinator": "AND",
  "conditions": [
    {
      "id": "cond-1",
      "leftValue": "{{context.tag}}",
      "rightValue": "alarma",
      "operator": {
        "type": "string",
        "operation": "is equal to",
        "name": "is equal to",
        "singleValue": true
      }
    }
  ],
  "options": {
    "caseSensitive": false
  }
}

Resultado: si {{context.tag}} es "Alarma" o "alarma", se ejecuta la ruta true.

---

Ejemplo 2: Evaluar varias condiciones con AND

Caso: solo continuar si el mensaje contiene texto y no está vacío.

{
  "combinator": "AND",
  "conditions": [
    {
      "id": "cond-1",
      "leftValue": "{{context.message}}",
      "rightValue": "",
      "operator": {
        "type": "string",
        "operation": "is not empty",
        "name": "is not empty",
        "singleValue": true
      }
    },
    {
      "id": "cond-2",
      "leftValue": "{{context.message}}",
      "rightValue": "intrusion",
      "operator": {
        "type": "string",
        "operation": "contains",
        "name": "contains",
        "singleValue": true
      }
    }
  ],
  "options": { "caseSensitive": false }
}

---

Ejemplo 3: Comparación numérica (number)

Caso: disparar ruta true cuando la temperatura supera 28.5.

{
  "combinator": "AND",
  "conditions": [
    {
      "id": "cond-1",
      "leftValue": "{{context.temperature}}",
      "rightValue": "28.5",
      "operator": {
        "type": "number",
        "operation": "is greater than",
        "name": "is greater than",
        "singleValue": false
      }
    }
  ],
  "options": { "caseSensitive": true }
}

Note

Para number con singleValue = false, leftValue y rightValue deben ser strings numéricos (ej: "28.5"). Si no, el nodo retorna error.

Solución de Problemas

Error: tipo de operador no soportado

Causa: operator.type distinto de string o number.

Solución: usa únicamente string o number.

---

Error: comparación numérica inválida

Causa: singleValue = false y alguno de los valores no puede parsearse como float64.

Solución: valida que leftValue y rightValue sean numéricos (sin texto adicional).

---

Error: regex inválida

Causa: patrón rightValue inválido en matches regex / does not match regex.

Solución: corrige el patrón y prueba con un valor de ejemplo.

Mejores Prácticas

• Usa number (con singleValue = false) para comparaciones numéricas reales.
• Si recibes texto de usuarios/fuentes variables, considera caseSensitive: false para evitar falsos negativos.
• Mantén condiciones simples y explícitas; si la regla crece mucho, divide el flujo en varios nodos IF.

---