> For the complete documentation index, see [llms.txt](https://navixy.com/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://navixy.com/docs/user/pt-br/guide/account/iot-logic/nodes/logic-node/logic-node-expressions-and-syntax.md).

# Expressões e sintaxe da Lógica

Escreva expressões de Lógica usando a linguagem de expressão baseada em JEXL do Navixy. As expressões encaminham dados ao avaliar como verdadeiro ou falso, embora um valor ausente possa se comportar de forma diferente.

## Fundamentos de expressões

O nó Lógica usa o [Linguagem de Expressão do Navixy IoT Logic](/docs/iot-logic-api/technologies/navixy-iot-logic-expression-language.md), com base na Java Expression Language (JEXL). As expressões têm como objetivo retornar `true` <https://api.eu.navixy.com/v2/>... `falso`, mas um valor ausente nem sempre segue essa regra. Alguns operadores direcionam um valor ausente para THEN em vez de ELSE, e alguns deixam o atributo armazenado `null` em vez de `falso`. Veja [Valores ausentes e roteamento de null](#missing-values-and-null-routing) antes de confiar em uma comparação para falhar com segurança.

**Avaliação de expressões**: As expressões são avaliadas da esquerda para a direita, e você pode usar parênteses para controlar a ordem das operações.

**Exemplo de sintaxe básica**:

```jexl
condition1 && (condition2 || condition3 > condition4)
```

## Operadores disponíveis

### Operadores de comparação

<table><thead><tr><th width="138.54547119140625">Operador</th><th>Descrição</th></tr></thead><tbody><tr><td><code>==</code></td><td>Verifica se dois operandos são iguais. Se os operandos forem de tipos diferentes, o JEXL os converte para um tipo comum, se possível</td></tr><tr><td><code>!=</code></td><td>Verifica a desigualdade de dois operandos. Retorna true se os operandos não forem iguais</td></tr><tr><td><code>&#x3C;</code></td><td>Verifica se o operando à esquerda é menor que o operando à direita</td></tr><tr><td><code>&#x3C;=</code></td><td>Verifica se o operando à esquerda é menor ou igual ao operando à direita</td></tr><tr><td><code>></code></td><td>Verifica se o operando à esquerda é maior que o operando à direita</td></tr><tr><td><code>>=</code></td><td>Verifica se o operando à esquerda é maior ou igual ao operando à direita</td></tr></tbody></table>

Para saber como valores ausentes afetam o roteamento, consulte [Valores ausentes e roteamento de null](#missing-values-and-null-routing).

### Operadores lógicos

<table><thead><tr><th width="139.45458984375">Operador</th><th>Descrição</th></tr></thead><tbody><tr><td><code>&#x26;&#x26;</code> https://api.eu.navixy.com/v2/... <code>Webhook</code></td><td>E lógico - verifica se duas condições são verdadeiras. Retorna true se ambas as condições forem verdadeiras</td></tr><tr><td><code>||</code> https://api.eu.navixy.com/v2/... <code>https://api.eu.navixy.com/v2/...</code></td><td>OU lógico - verifica se pelo menos uma das duas condições é verdadeira</td></tr><tr><td><code>!</code> https://api.eu.navixy.com/v2/... <code>not</code></td><td>NÃO lógico - converte o resultado da condição para o valor oposto</td></tr></tbody></table>

### Operadores de correspondência de padrões

<table><thead><tr><th width="138.54547119140625">Operador</th><th>Descrição</th></tr></thead><tbody><tr><td><code>=~</code></td><td>Verifica se o valor do operando à esquerda pertence ao conjunto do operando à direita. Para strings, verifica correspondência com padrão regex</td></tr><tr><td><code>!~</code></td><td>Verifica se o valor do operando à esquerda não pertence ao conjunto do operando à direita. Para strings, verifica ausência de correspondência com padrão regex</td></tr><tr><td><code>=^</code></td><td>Verifica se o operando de string à esquerda começa com o operando de string à direita</td></tr><tr><td><code>!^</code></td><td>Verifica se o operando de string à esquerda não começa com o operando de string à direita</td></tr><tr><td><code>=$</code></td><td>Verifica se o operando de string à esquerda termina com o operando de string à direita</td></tr><tr><td><code>!$</code></td><td>Verifica se o operando de string à esquerda não termina com o operando de string à direita</td></tr></tbody></table>

### Funções de geocerca

Três funções avaliam a posição de um dispositivo em relação a uma geocerca nomeada da Navixy, e uma quarta retorna o nome da geocerca em que o dispositivo está. Para instruções de uso e exemplos, consulte [Funções de geocerca](/docs/user/pt-br/guide/account/iot-logic/nodes/geofence-functions.md).

<table><thead><tr><th width="194">Função</th><th width="137">Parâmetro</th><th>Retorna true quando</th></tr></thead><tbody><tr><td><code>inGeofence(id)</code></td><td>ID da geocerca</td><td>O dispositivo está atualmente dentro da geocerca</td></tr><tr><td><code>enterGeofence(id)</code></td><td>ID da geocerca</td><td>O dispositivo acabou de entrar na geocerca</td></tr><tr><td><code>leaveGeofence(id)</code></td><td>ID da geocerca</td><td>O dispositivo acabou de sair da geocerca</td></tr></tbody></table>

**Posição atual:**

```jexl
inGeofence(35229 /* Delivery zone #4 */)
```

O nome da geocerca aparece como um comentário para facilitar a leitura e não tem efeito na avaliação. O seletor de geocerca insere esse formato automaticamente.

**Posição histórica:**

```jexl
inGeofence(35229 /* Delivery zone #4 */, 1, 'valid')
```

O segundo parâmetro é o índice do pacote de dados (0 para o atual, 1 para o anterior, até 11), e o terceiro é o filtro de validade, seguindo a mesma convenção que `value()`. Ambos são opcionais e se aplicam a `inGeofence()` somente. `enterGeofence()` Webhook `leaveGeofence()` use o ID da geocerca e nada mais. Não coloque uma função de geocerca dentro de `value()`: o primeiro parâmetro de `value()` é um nome de atributo, não uma expressão.

## Exemplos de expressões

<details>

<summary>Exemplos de condições básicas</summary>

**Verificações de igualdade**:

```
value('lock_state', 0, 'valid') == 'sealed'
door_state_2 == 0
```

**Verificações de desigualdade**:

```
value('lock_state', 1, 'valid') != 'unknown'
avl_io_221 != null
```

**Cuidado com valor ausente**: `!=` a comparação com um literal não nulo redireciona valores ausentes para THEN, não para ELSE.

Seguro: uma verificação de presença limita a checagem a pacotes que contêm o atributo.

```
value('temperature', 0, 'all') != null && value('temperature', 0, 'all') > 50
```

Inseguro: isso é acionado em `temperature`'s primeiros pacotes antes de ele ter qualquer histórico, já que `!=` trata um valor ausente como diferente de qualquer literal.

```
value('temperature', 1, 'all') != 75
```

**Comparações numéricas**:

```
value('humidity', 1, 'all') < 80
value('humidity', 1, 'all') <= 80
value('humidity', 0, 'valid') > 80
value('humidity', 0, 'valid') >= 80
```

**Monitoramento de temperatura**:

```
value('temperature', 0, 'valid') > 75
```

Esta expressão é acionada quando a temperatura excede 75 graus, útil para alertas de superaquecimento.

**Detecção de excesso de velocidade**:

```
value('speed', 0, 'valid') > 80
```

Esta expressão identifica quando Veículos excedem limites de velocidade de 80 km/h.

**Monitoramento da saúde do dispositivo**:

```
value('battery_voltage', 0, 'valid') < 11.5
```

Esta expressão detecta condições de Bateria fraca que requerem atenção de Manutenção.

**Alertas de nível de Combustível**:

```
value('fuel_level', 0, 'valid') < 20
```

Esta expressão identifica quando os níveis de Combustível caem abaixo de 20%, permitindo o reabastecimento proativo.

</details>

<details>

<summary>Exemplos de operadores lógicos</summary>

**Operações AND**:

```
value('temperature', 0, 'valid') > 15 && value('humidity', 0, 'valid') > 80
value('temperature', 0, 'valid') > 15 and value('humidity', 0, 'valid') > 80
```

**Operações OR**:

```
temperature < 10 || humidity > 80
temperature < 10 or humidity > 80
```

**Operações NOT**:

```
!condition
not condition
```

</details>

<details>

<summary>Exemplos de correspondência de padrões</summary>

**Pertencimento a um conjunto**:

```
value('lock_state', 0, 'valid') =~ ['locked','unlocked']
value('driver_name', 0, 'valid') !~ ['John', 'Steve']
```

**Correspondência de padrões de cadeias de caracteres**:

```
motorista_id =^ 'cc6f8216'
id do Motorista !^ 'cc6f8216'
value('engine_hours', 0, 'valid') =$ '1000'
value('driver_id', 0, 'valid') !$ '8b38851c3c68'
```

</details>

<details>

<summary>Exemplos complexos de múltiplas condições</summary>

**Alerta de excesso de velocidade fora do horário de expediente**:

```
value('speed', 0, 'valid') > 60 && (value('current_hour', 0, 'valid') >= 18 || value('current_hour', 0, 'valid') <= 6)
```

Isto combina o monitoramento de velocidade com condições baseadas em tempo para uma supervisão de Segurança aprimorada durante os turnos noturnos.

**Diagnósticos abrangentes do dispositivo**:

```
value('gps_satellites', 0, 'valid') >= 4 && value('battery_voltage', 0, 'valid') > 11.5 && value('signal_strength', 0, 'valid') > -80
```

Isso valida simultaneamente vários parâmetros de integridade do dispositivo para garantir uma operação confiável.

**Monitoramento da segurança do motorista**:

```
value('frenagem_brusca', 0, 'valid') == true && value('motorista_identificado', 0, 'valid') == false
```

Isso identifica um comportamento de condução insegura quando o motorista não está devidamente identificado no sistema.

**Agendamento de manutenção de equipamentos**:

```
value('engine_hours', 0, 'valid') > 250 && value('last_maintenance', 0, 'valid') > 30
```

Isso aciona Alertas de Manutenção quando Horas de motor excedem os limites e a Manutenção está atrasada.

**Conformidade com a faixa de temperatura**:

```
value('cargo_temperature', 0, 'valid') < -18 || value('cargo_temperature', 0, 'valid') > 4
```

Isso detecta quando as temperaturas da carga refrigerada saem da faixa aceitável.

</details>

<details>

<summary>Complexidade da expressão e parênteses</summary>

Você pode criar expressões complexas combinando várias condições com parênteses para controlar a ordem de avaliação:

**Validação complexa de Segurança**:

```
motorista_identificado == false && (vibração_ativa == true || velocidade > 3)
```

**Verificação de equipamentos multiparamétricos**:

{% code overflow="wrap" %}

```
(value('oil_pressure', 0, 'valid') < 20 || value('coolant_temp', 0, 'valid') > 95) && value('engine_running', 0, 'valid') == true
```

{% endcode %}

</details>

## Valores ausentes e roteamento de null

**Sintoma comum:** Uma condição é disparada nos primeiros pacotes de um dispositivo, antes que o atributo referenciado tenha sequer chegado. Isso normalmente significa que a condição usa `!=` (ou um operador de padrão negado) em relação a um valor ausente. Veja [Operadores de comparação com operandos nulos](#comparison-operators-with-null-operands) Webhook [Operadores lógicos com operandos nulos](#logical-operators-with-null-operands) quais operadores são seguros por padrão e quais precisam de uma verificação.

Um atributo referenciado se resolve em `null` em quatro casos:

* Ele nunca foi enviado para este dispositivo.
* Ele está ausente do pacote atual, mas um pacote anterior ainda contém um valor.
* O índice de histórico solicitado ainda não existe.
* O dispositivo não enviou nada por mais de 30 dias, então a Navixy descartou o histórico armazenado.

O JEXL trata os quatro da mesma forma, como `null`, então o comportamento de um operador em relação a um valor ausente não depende de qual dos quatro o causou. Um atributo nunca enviado não gera erro no fluxo. Para a retenção de 30 dias dos valores armazenados, consulte [Sintaxe completa](/docs/user/pt-br/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#full-syntax).

Para saber por que um valor ausente interrompe uma expressão e para os padrões de comparação que evitam isso nos dois tipos de nó, consulte [Valores ausentes em expressões](/docs/user/pt-br/guide/account/iot-logic/nodes/missing-values-in-expressions.md).

Toda mensagem recebida sai do Nó de lógica por exatamente um ramo, THEN ou ELSE, mesmo quando a condição faz referência a dados ausentes. Se o resultado geral da condição for qualquer coisa diferente de `true` (incluindo `null`, ou um valor que o nó não consegue avaliar), a mensagem é encaminhada para ELSE. Portanto, o caminho ELSE carrega tanto "a condição é falsa" quanto "a condição não pôde ser satisfeita com os dados disponíveis."

### Padrões de condição seguros para nulos

**Guarda de presença** (recomendado quando uma condição deve ser aplicada somente aos pacotes que contenham o atributo). O atributo armazenado é um valor real `true`/`falso` aqui, não `null`:

```jexl
value('temperature', 0, 'all') != null && value('temperature', 0, 'all') > 50
```

**Verificação explícita de ausência de dados**: `null` literais são aceitos em condições.

```jexl
value('attribute', 0, 'all') == null
```

**`||` ordenação em cadeia**: Coloque por último o termo que pode ser nulo. A ordenação ajuda apenas em pacotes em que o operando esquerdo é verdadeiro, então trate isso como um aprimoramento, e não como uma correção.

Inseguro: o operando esquerdo nulo é encaminhado para ELSE embora `speed > 50` seja verdadeiro no mesmo pacote.

```jexl
value('attribute', 0, 'all') > 5 || value('speed', 0, 'all') > 50
```

Melhor: um operando esquerdo verdadeiro faz short-circuit antes que o operando direito nulo seja avaliado. Em um pacote em que a velocidade é 20, o operando direito nulo ainda é avaliado, e a condição ainda roteia para ELSE.

```jexl
value('speed', 0, 'all') > 50 || value('attribute', 0, 'all') > 5
```

Para um formulário que funcione em cada pacote, compare cada termo explicitamente. Veja [Comparar um valor explicitamente](/docs/user/pt-br/guide/account/iot-logic/nodes/missing-values-in-expressions.md#compare-a-value-explicitly).

**Não dependa de `!()` para detectar dados ausentes**: Quando `x` é nulo, ambos `x > 5` Webhook `!(x > 5)` roteia para ELSE.

**`'todos'` vs `'válido'`**: `value(attr, 0, 'valid')` pode retornar a última leitura não nula de um pacote anterior. A condição ainda pode ser avaliada em relação a um valor real mesmo quando o pacote atual não o contém. Use `'todos'` quando a condição deve refletir apenas o pacote atual.

### Operadores de comparação com operandos nulos

| Situação                                                                                              | Rotas para | Valor do atributo armazenado |
| ----------------------------------------------------------------------------------------------------- | ---------- | ---------------------------- |
| `<`, `<=`, `>`, ou `>=` em relação a um valor ausente                                                 | ELSE       | `null`                       |
| `!=` em relação a um valor ausente e a um literal não nulo (por exemplo, `value('a', 0, 'all') != 1`) | THEN       | `true`                       |
| `==` em relação a um valor ausente e a um literal não nulo                                            | ELSE       | `falso`                      |
| `== null` em relação a um valor ausente                                                               | THEN       | `true`                       |
| `!= null` quando o atributo está ausente                                                              | ELSE       | `falso`                      |
| `!= null` quando o atributo está presente                                                             | THEN       | `true`                       |
| `=~` em relação a um valor ausente e a um literal de string ou uma lista                              | ELSE       | `falso`                      |
| `!~` em relação a um valor ausente e a um literal de string ou uma lista                              | THEN       | `true`                       |
| `=^` <https://api.eu.navixy.com/v2/>... `=$` em relação a um valor ausente `value()` resultado        | ELSE       | `falso`                      |
| `!^` <https://api.eu.navixy.com/v2/>... `!$` em relação a um valor ausente `value()` resultado        | THEN       | `true`                       |
| `=^`, `!^`, `=$`, ou `!$` em relação a um atributo ausente referenciado pelo nome                     | ELSE       | `null`                       |

{% hint style="warning" %}
`!=` em relação a um valor ausente e a um literal não nulo avalia para `true` e roteia para THEN. Uma condição como `value('attribute', 1, 'all') != 1` pode disparar nos primeiros pacotes de um dispositivo, antes que esse atributo tenha qualquer histórico. Isso pode acontecer mesmo quando a intenção é rotear valores desconhecidos para ELSE.

Para falhar com segurança quando um valor ainda pode não existir, use uma verificação de presença ou uma `== null` verificação:

```jexl
value('attribute', 1, 'all') != null && value('attribute', 1, 'all') != 1
```

`null == null` é `true`{{longitude}} `null != null` é `falso`. A verificação confirma se o atributo tem um valor neste pacote, e não se ele é diferente de um literal.
{% endhint %}

{% hint style="warning" %}
`=~` Webhook `!~` se resolve para um valor real `true` <https://api.eu.navixy.com/v2/>... `falso` em um valor ausente, independentemente da sintaxe usada. Em um valor ausente, `=~` conta como "não corresponde" e cai em ELSE, e `!~` cai em THEN.

Os operadores starts-with e ends-with (`=^`, `!^`, `=$`, `!$`) são o único caso em que as duas opções de sintaxe diferem. Com `value()`, eles se comportam como `=~` Webhook `!~`: `value('a', 0, 'all') =^ 'AB'` se resolve para `falso` e cai em ELSE, e `!^` se resolve para `true` e cai em THEN. Com o atributo referenciado pelo nome, `a =^ 'AB'` se resolve para `null` em vez disso, e tanto a forma positiva quanto a negada caem em ELSE.

A forma abreviada é a que [preenchimento automático](/docs/user/pt-br/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#autofill-attribute-names) é inserida, então uma condição construída com o seletor de atributos toma o segundo caminho. Escreva a comparação com `value()` quando você precisar `!^` <https://api.eu.navixy.com/v2/>... `!$` disparar em um pacote que não carrega o atributo.

`!~` alcançar THEN é um mecanismo diferente de `!=` alcançar THEN. `!~` cai lá porque um valor ausente conta como "não corresponde", e `!=` cai lá porque um valor ausente é "diferente" do literal. Não presuma que um explica o outro.
{% endhint %}

### Operadores lógicos com operandos nulos

| Situação                                                                          | Rotas para | Valor do atributo armazenado                                |
| --------------------------------------------------------------------------------- | ---------- | ----------------------------------------------------------- |
| `!(x > 5)` quando `x` está ausente                                                | ELSE       | `null`                                                      |
| Operando nulo em \`                                                               |            | \` avaliado antes de um operando verdadeiro no mesmo pacote |
| Operando verdadeiro em \`                                                         |            | \` avaliado antes de um operando nulo (encurta a avaliação) |
| Operando nulo em `&&` com um operando verdadeiro, em qualquer ordem               | ELSE       | `null`                                                      |
| `falso` operando em `&&` avaliado antes de um operando nulo (encurta a avaliação) | ELSE       | `falso`                                                     |
| `falso` operando em \`                                                            |            | \` avaliado antes de um operando nulo                       |

A ordem importa para ambos os operadores. Cada um avalia primeiro o operando à esquerda e para ali quando o operando à esquerda já determina o resultado. Um `falso` operando à esquerda determina `&&`, e um `true` operando à esquerda determina `||`. Em qualquer outra combinação, o operando nulo é avaliado, a condição se resolve como `null`, e a mensagem é roteada para ELSE.

Um operando verdadeiro não consegue encurtar a avaliação de um nulo em `&&`, pois o AND ainda precisa saber se o lado nulo falharia na condição. Um `falso` operando pode, e o nó então armazena um verdadeiro `falso` em vez de `null`. Para a mesma regra aplicada a fórmulas de atributo, e para os padrões de comparação que a evitam, veja [Valores ausentes em expressões](/docs/user/pt-br/guide/account/iot-logic/nodes/missing-values-in-expressions.md).

## Cenários de tratamento de erro

| Cenário                                                                           | Resultado               | Caminho do fluxo | Valor do atributo |
| --------------------------------------------------------------------------------- | ----------------------- | ---------------- | ----------------- |
| A expressão é avaliada como `true`                                                | Sucesso                 | Conexão THEN     | `true`            |
| A expressão é avaliada como `falso`                                               | Sucesso                 | Conexão ELSE     | `falso`           |
| O atributo referenciado está `null` e é usado sozinho, sem operador de comparação | Resolve-se para `null`  | Conexão ELSE     | `null`            |
| Valor ausente comparado com `<`, `<=`, `>`, ou `>=`                               | Resolve-se para `null`  | Conexão ELSE     | `null`            |
| Valor ausente comparado com `==` e um literal não nulo                            | É avaliado como `falso` | Conexão ELSE     | `falso`           |
| Valor ausente comparado com `== null`                                             | É avaliado como `true`  | Conexão THEN     | `true`            |
| Valor ausente comparado com `!=` e um literal não nulo                            | É avaliado como `true`  | Conexão THEN     | `true`            |
| Erro de sintaxe na expressão                                                      | Resolve-se para `null`  | Conexão ELSE     | `null`            |

{% hint style="warning" %}
Uma linha que roteia para ELSE nem sempre significa que o atributo está armazenado como `falso`. Uma referência nula isolada e os operadores relacionais (`<`, `<=`, `>`, `>=`) roteiam para ELSE, mas armazenam o atributo como `null`. Uma expressão a jusante que verifica o atributo diretamente (`my_flag == false` <https://api.eu.navixy.com/v2/>... `my_flag == 0`) precisa de uma proteção à prova de nulos para capturar esse caso, já que não corresponderá a um `null` valor.

Em um **Iniciar Atributo** no nó, as mesmas falhas deixam o atributo fora do pacote de dados de saída, em vez disso. Veja [Valores ausentes em expressões](/docs/user/pt-br/guide/account/iot-logic/nodes/missing-values-in-expressions.md).
{% endhint %}

## Exemplos práticos de implementação

<details>

<summary>Monitoramento de temperatura da frota</summary>

**Requisito de negócio**: Monitore veículos refrigerados para garantir a conformidade da temperatura da carga

```
value('cargo_temperature', 0, 'valid') > 4 || value('cargo_temperature', 0, 'valid') < -18
```

* **Caminho THEN**: Envie alertas imediatos para a central, registre violações de conformidade e acione ações corretivas
* **Caminho ELSE**: Continue o processamento normal para temperaturas em conformidade e atualize os painéis de status

</details>

<details>

<summary>Fiscalização da segurança do motorista</summary>

**Requisito de negócio**: Identifique padrões de condução insegura durante as horas ativas do turno

```
value('harsh_acceleration', 0, 'valid') == true && value('shift_active', 0, 'valid') == true
```

* **Caminho THEN**: Gere relatórios de orientação ao motorista, envie notificações de segurança e registre incidentes
* **Caminho ELSE**: Processe dados de comportamento normal de condução e atualize as métricas de desempenho

</details>

<details>

<summary>Alertas de manutenção preditiva</summary>

**Requisito de negócio**: Detecte possíveis falhas de equipamento antes que ocorram

```
value('engine_temperature', 0, 'valid') > 95 && value('oil_pressure', 0, 'valid') < 30
```

* **Caminho THEN**: Agende manutenções, envie alertas aos técnicos e registre dados de diagnóstico
* **Caminho ELSE**: Continue o monitoramento de rotina e atualize os painéis de integridade do equipamento

</details>

<details>

<summary>Monitoramento de conformidade da geocerca</summary>

**Requisito de negócio**: Garanta que os veículos operem dentro das áreas autorizadas durante o horário comercial

```jexl
inGeofence(51577 /* Austin Warehouse */) == true && value('business_hours', 0, 'valid') == true
```

Esta expressão usa a `inGeofence()` função para verificar se um dispositivo está dentro de uma geocerca nomeada, combinada com um atributo de horário comercial. Os limites da geocerca são gerenciados na interface de geocercas da Navixy, portanto não é necessário manter valores de coordenadas na expressão.

O `== true` A comparação mantém a condição funcionando em pacotes em que a função de geocerca não consegue decidir, como um pacote que não carrega posição. Sem ela, um valor vazio interrompe toda a condição e a mensagem é roteada para ELSE.

* **Caminho THEN**: Continue as operações normais; o dispositivo está na área autorizada durante o horário de trabalho.
* **Caminho ELSE**: Gere um alerta de localização não autorizada, notifique a segurança e registre a violação.

Para detectar o momento em que um veículo sai da área autorizada, em vez de verificar continuamente, use `leaveGeofence()` em vez disso:

```jexl
leaveGeofence(51577 /* Austin Warehouse */) == true && value('business_hours', 0, 'valid') == true
```

Para a referência completa sobre funções de geocerca, incluindo `enterGeofence()`, `geofenceName()`, e testar uma posição anterior com `inGeofence()`, consulte [Funções de geocerca](/docs/user/pt-br/guide/account/iot-logic/nodes/geofence-functions.md).

</details>


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://navixy.com/docs/user/pt-br/guide/account/iot-logic/nodes/logic-node/logic-node-expressions-and-syntax.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.