> 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/fr/guide/account/iot-logic/nodes/logic-node/logic-node-expressions-and-syntax.md).

# Expressions et syntaxe de Logique

Rédigez des expressions de Logique à l'aide du langage d'expression Navixy basé sur JEXL. Les expressions orientent les données en évaluant vrai ou faux, mais une valeur manquante peut se comporter différemment.

## Principes fondamentaux des expressions

Le nœud Logique utilise le [langage d'expressions Navixy IoT Logic](https://navixy.com/docs/iot-logic-api/technologies/navixy-iot-logic-expression-language.md), basé sur Java Expression Language (JEXL). Les expressions sont censées renvoyer `true` ou `false`, mais une valeur manquante ne suit pas toujours cette règle. Certains opérateurs orientent une valeur manquante vers THEN au lieu de ELSE, et certains laissent l'attribut stocké `null` plutôt que `false`. Voir [Valeurs manquantes et routage de null](#missing-values-and-null-routing) avant de vous fier à une comparaison pour échouer en toute sécurité.

**Évaluation des expressions**: Les expressions sont évaluées de gauche à droite, et vous pouvez utiliser des parenthèses pour contrôler l'ordre des opérations.

**Exemple de syntaxe de base**:

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

## Opérateurs disponibles

### Opérateurs de comparaison

<table><thead><tr><th width="138.54547119140625">Opérateur</th><th>Description</th></tr></thead><tbody><tr><td><code>==</code></td><td>Vérifie si deux opérandes sont égaux. Si les opérandes sont de types différents, JEXL les convertit en un seul si possible</td></tr><tr><td><code>!=</code></td><td>Vérifie l'inégalité de deux opérandes. Retourne true si les opérandes ne sont pas égaux</td></tr><tr><td><code>&#x3C;</code></td><td>Vérifie que l'opérande de gauche est inférieur à l'opérande de droite</td></tr><tr><td><code>&#x3C;=</code></td><td>Vérifie que l'opérande de gauche est inférieur ou égal à l'opérande de droite</td></tr><tr><td><code>></code></td><td>Vérifie que l'opérande de gauche est supérieur à l'opérande de droite</td></tr><tr><td><code>>=</code></td><td>Vérifie que l'opérande de gauche est supérieur ou égal à l'opérande de droite</td></tr></tbody></table>

Pour savoir comment les valeurs manquantes affectent le routage, voir [Valeurs manquantes et routage de null](#missing-values-and-null-routing).

### Opérateurs logiques

<table><thead><tr><th width="139.45458984375">Opérateur</th><th>Description</th></tr></thead><tbody><tr><td><code>&#x26;&#x26;</code> ou <code>et</code></td><td>ET logique - vérifie si deux conditions sont vraies. Retourne true si les deux conditions sont vraies</td></tr><tr><td><code>||</code> ou <code>ou</code></td><td>OU logique - vérifie qu'au moins une des deux conditions est vraie</td></tr><tr><td><code>!</code> ou <code>non</code></td><td>NON logique - convertit le résultat de la condition en la valeur opposée</td></tr></tbody></table>

### Opérateurs de correspondance de motifs

<table><thead><tr><th width="138.54547119140625">Opérateur</th><th>Description</th></tr></thead><tbody><tr><td><code>=~</code></td><td>Vérifie si la valeur de l'opérande de gauche appartient à l'ensemble de l'opérande de droite. Pour les chaînes, vérifie la correspondance avec une expression régulière</td></tr><tr><td><code>!~</code></td><td>Vérifie si la valeur de l'opérande de gauche n'appartient pas à l'ensemble de l'opérande de droite. Pour les chaînes, vérifie l'absence de correspondance avec une expression régulière</td></tr><tr><td><code>=^</code></td><td>Vérifie que l'opérande de chaîne de gauche commence par l'opérande de chaîne de droite</td></tr><tr><td><code>!^</code></td><td>Vérifie que l'opérande de chaîne de gauche ne commence pas par l'opérande de chaîne de droite</td></tr><tr><td><code>=$</code></td><td>Vérifie que l'opérande de chaîne de gauche se termine par l'opérande de chaîne de droite</td></tr><tr><td><code>!$</code></td><td>Vérifie que l'opérande de chaîne de gauche ne se termine pas par l'opérande de chaîne de droite</td></tr></tbody></table>

### Fonctions de zone géographique

Trois fonctions évaluent la position d'un appareil par rapport à une Zone géographique Navixy nommée, et une quatrième renvoie le nom de la Zone géographique dans laquelle se trouve l'appareil. Pour des instructions d'utilisation et des exemples, voir [Fonctions de zone géographique](https://navixy.com/docs/user/fr/guide/account/iot-logic/nodes/geofence-functions.md).

<table><thead><tr><th width="194">Fonction</th><th width="137">Paramètre</th><th>Renvoie true lorsque</th></tr></thead><tbody><tr><td><code>inGeofence(id)</code></td><td>ID de la Zone géographique</td><td>L'appareil se trouve actuellement dans la Zone géographique</td></tr><tr><td><code>enterGeofence(id)</code></td><td>ID de la Zone géographique</td><td>L’appareil vient d’entrer dans la zone géographique</td></tr><tr><td><code>leaveGeofence(id)</code></td><td>ID de la Zone géographique</td><td>L’appareil vient de sortir de la zone géographique</td></tr></tbody></table>

**Position actuelle :**

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

Le nom de la Zone géographique apparaît comme un commentaire pour la lisibilité et n'a aucun effet sur l'évaluation. Le sélecteur de Zone géographique insère automatiquement ce format.

**Position historique :**

```jexl
inGeofence(35229 /* zone de livraison n° 4 */, 1, 'valid')
```

Le deuxième paramètre est l'index du paquet de données (0 pour le paquet actuel, 1 pour le précédent, jusqu'à 11), et le troisième est le filtre de validité, selon la même convention que `value()`. Les deux sont facultatifs, et s'appliquent tous deux à `inGeofence()` uniquement. `enterGeofence()` et `leaveGeofence()` prenez l'ID de la Zone géographique et rien d'autre. N'imbriquez pas une fonction de Zone géographique dans `value()`: le premier paramètre de `value()` est un nom d'attribut, pas une expression.

## Exemples d'expressions

<details>

<summary>Exemples de conditions de base</summary>

**Vérifications d'égalité**:

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

**Vérifications d'inégalité**:

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

**Mise en garde contre les valeurs manquantes**: `!=` face à un littéral non nul, les valeurs manquantes sont acheminées vers THEN, et non vers ELSE.

Sûr : un test de présence limite la vérification aux paquets qui portent l'attribut.

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

Dangereux : cela se déclenche sur `temperature`les premiers paquets de 's avant qu'il n'ait le moindre historique, puisque `!=` considère une valeur manquante comme différente de tout littéral.

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

**Comparaisons numériques**:

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

**Surveillance de la température**:

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

Cette expression se déclenche lorsque la température dépasse 75 degrés, utile pour les alertes de surchauffe.

**Détection des Excès de vitesse**:

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

Cette expression identifie lorsque les Véhicules dépassent la limite de vitesse de 80 km/h.

**Surveillance de l’état de l’appareil**:

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

Cette expression détecte les conditions de Batterie faible nécessitant une attention d'Entretien.

**Règles d’alertes du niveau de Carburant**:

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

Cette expression identifie lorsque les niveaux de carburant descendent sous 20 %, ce qui permet un ravitaillement proactif.

</details>

<details>

<summary>Exemples d’opérateurs logiques</summary>

**Opérations ET**:

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

**Opérations OR**:

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

**Opérations NOT**:

```
!condition
not condition
```

</details>

<details>

<summary>Exemples de correspondance de motifs</summary>

**Appartenance à un ensemble**:

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

**Correspondance de motifs de chaînes**:

```
driver_id =^ 'cc6f8216'
identifiant du conducteur !^ 'cc6f8216'
value('engine_hours', 0, 'valid') =$ '1000'
value('driver_id', 0, 'valid') !$ '8b38851c3c68'
```

</details>

<details>

<summary>Exemples complexes à conditions multiples</summary>

**Alerte d'excès de vitesse en dehors des heures de service**:

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

Cela combine la surveillance de la vitesse avec des conditions basées sur le temps pour une supervision renforcée de la Sécurité pendant les équipes de nuit.

**Diagnostics complets de l'appareil**:

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

Cela valide simultanément plusieurs paramètres d’état de l’appareil afin de garantir un fonctionnement fiable.

**Surveillance de la sécurité du conducteur**:

```
value('harsh_braking', 0, 'valid') == true && value('driver_identified', 0, 'valid') == false
```

Cela identifie un comportement d’Eco conduite dangereux lorsque le Conducteur n’est pas correctement identifié dans le système.

**Ordonnancement de l’Entretien des équipements**:

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

Cela déclenche des Règles d’alertes d’Entretien lorsque les Heures moteur dépassent les seuils et que l’Entretien est en retard.

**Conformité à la plage de température**:

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

Cela détecte lorsque les températures du chargement réfrigéré sortent de la plage acceptable.

</details>

<details>

<summary>Complexité des expressions et parenthèses</summary>

Vous pouvez créer des expressions complexes en combinant plusieurs conditions avec des parenthèses pour contrôler l'ordre d'évaluation :

**Validation de sécurité complexe**:

```
driver_identified == false && (vibration_active == true || speed > 3)
```

**Vérification de l'équipement à paramètres multiples**:

{% code overflow="wrap" %}

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

{% endcode %}

</details>

## Valeurs manquantes et routage de null

**Symptôme courant :** Une condition se déclenche sur les tout premiers paquets d’un appareil, avant que l’attribut référencé ne soit jamais arrivé. Cela signifie généralement que la condition utilise `!=` (ou un opérateur de motif négatif) sur une valeur manquante. Voir [Opérateurs de comparaison avec des opérandes nuls](#comparison-operators-with-null-operands) et [Opérateurs logiques avec des opérandes nuls](#logical-operators-with-null-operands) pour savoir quels opérateurs sont sûrs par défaut et lesquels nécessitent une condition de garde.

Un attribut référencé se résout à `null` dans quatre cas :

* Il n’a jamais été envoyé pour cet appareil.
* Il est absent du paquet actuel, mais un paquet précédent contient encore une valeur.
* L’index d’historique demandé n’existe pas encore.
* L'appareil n'a rien envoyé pendant plus de 30 jours, donc Navixy a supprimé son historique stocké.

JEXL les traite tous les quatre de la même manière, comme `null`ainsi, le comportement d’un opérateur face à une valeur manquante ne dépend pas de laquelle des quatre en est à l’origine. Un attribut jamais envoyé ne provoque pas d’erreur dans le flux. Pour la conservation des valeurs stockées pendant 30 jours, voir [Syntaxe complète](https://navixy.com/docs/user/fr/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#full-syntax).

Pour savoir pourquoi une valeur manquante interrompt une expression, et pour les modèles de comparaison qui l’empêchent dans les deux types de nœud, voir [Valeurs manquantes dans les expressions](https://navixy.com/docs/user/fr/guide/account/iot-logic/nodes/missing-values-in-expressions.md).

Chaque message entrant quitte le nœud Logic par exactement une branche, THEN ou ELSE, même lorsque la condition fait référence à des données manquantes. Si le résultat global de la condition est autre chose que `true` (y compris `null`ou une valeur que le nœud ne peut pas évaluer), le message est acheminé vers ELSE. Le chemin ELSE véhicule donc à la fois « la condition est fausse » et « la condition n’a pas pu être satisfaite à partir des données disponibles ».

### Modèles de conditions tolérants aux valeurs nulles

**Garde de présence** (recommandé lorsqu’une condition doit s’appliquer uniquement aux paquets qui contiennent l’attribut). L’attribut stocké est une valeur réelle `true`/`false` ici, pas `null`:

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

**Vérification explicite des données manquantes**: `null` Les littéraux sont acceptés dans les conditions.

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

**`||` ordre de chaînage**: Placez en dernier le terme qui peut être nul. L’ordre n’aide que sur les paquets où l’opérande de gauche est vrai, considérez donc cela comme une amélioration et non comme une correction.

Non sûr : l’opérande de gauche nul est dirigé vers ELSE même si `speed > 50` est vrai sur le même paquet.

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

Mieux : un véritable opérande de gauche court-circuite avant que l’opérande de droite nul ne soit évalué. Sur un paquet où la vitesse est de 20, l’opérande de droite nul est quand même évalué, et la condition redirige toujours vers ELSE.

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

Pour un formulaire qui fonctionne sur chaque paquet, comparez chaque terme explicitement. Voir [Comparez une valeur explicitement](https://navixy.com/docs/user/fr/guide/account/iot-logic/nodes/missing-values-in-expressions.md#compare-a-value-explicitly).

**Ne comptez pas sur `!()` pour détecter les données manquantes**: Lorsque `x` est nul, les deux `x > 5` et `!(x > 5)` redirigent vers ELSE.

**`'tous'` contre `'valide'`**: `value(attr, 0, 'valid')` peut renvoyer la dernière lecture non nulle d’un paquet antérieur. La condition peut encore s’évaluer par rapport à une valeur réelle même lorsque le paquet actuel ne la contient pas. Utilisez `'tous'` lorsque la condition doit refléter uniquement le paquet actuel.

### Opérateurs de comparaison avec des opérandes nuls

| Situation                                                                                                   | Dirige vers | Valeur d’attribut stockée |
| ----------------------------------------------------------------------------------------------------------- | ----------- | ------------------------- |
| `<`, `<=`, `>`, ou `>=` par rapport à une valeur manquante                                                  | ELSE        | `null`                    |
| `!=` par rapport à une valeur manquante et à un littéral non nul (par exemple, `value('a', 0, 'all') != 1`) | THEN        | `true`                    |
| `==` par rapport à une valeur manquante et à un littéral non nul                                            | ELSE        | `false`                   |
| `== null` par rapport à une valeur manquante                                                                | THEN        | `true`                    |
| `!= null` lorsque l’attribut est absent                                                                     | ELSE        | `false`                   |
| `!= null` lorsque l’attribut est présent                                                                    | THEN        | `true`                    |
| `=~` par rapport à une valeur manquante et à une chaîne littérale ou à une liste                            | ELSE        | `false`                   |
| `!~` par rapport à une valeur manquante et à une chaîne littérale ou à une liste                            | THEN        | `true`                    |
| `=^` ou `=$` par rapport à une valeur manquante `value()` résultat                                          | ELSE        | `false`                   |
| `!^` ou `!$` par rapport à une valeur manquante `value()` résultat                                          | THEN        | `true`                    |
| `=^`, `!^`, `=$`, ou `!$` par rapport à un attribut manquant référencé par son nom                          | ELSE        | `null`                    |

{% hint style="warning" %}
`!=` par rapport à une valeur manquante et à un littéral non nul s’évalue à `true` et redirige vers THEN. Une condition comme `value('attribute', 1, 'all') != 1` peut se déclencher sur les premiers paquets d’un appareil, avant que cet attribut n’ait le moindre historique. Cela peut se produire même lorsque l’intention est d’acheminer les valeurs inconnues vers ELSE.

Pour échouer de façon sûre lorsqu’une valeur peut ne pas encore exister, utilisez un garde de présence ou une `== null` vérification :

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

`null == null` est `true`, et `null != null` est `false`. Le garde vérifie si l’attribut a une valeur sur ce paquet, et non s’il diffère d’un littéral.
{% endhint %}

{% hint style="warning" %}
`=~` et `!~` se résolvent en une valeur réelle `true` ou `false` sur une valeur manquante, quelle que soit la syntaxe utilisée. Sur une valeur manquante, `=~` false compte comme « pas de correspondance » et aboutit à ELSE, et `!~` aboutit à THEN.

Les opérateurs « commence par » et « se termine par » (`=^`, `!^`, `=$`, `!$`) sont le seul cas où les deux options de syntaxe diffèrent. Avec `value()`, elles se comportent comme `=~` et `!~`: `value('a', 0, 'all') =^ 'AB'` se résout en `false` et aboutit sur ELSE, et `!^` se résout en `true` et aboutit sur THEN. Avec l'attribut référencé par son nom, `a =^ 'AB'` se résout en `null` à la place, et les formes positive et négative aboutissent toutes deux sur ELSE.

La forme abrégée est ce que [le remplissage automatique](https://navixy.com/docs/user/fr/guide/account/iot-logic/nodes/initiate-attribute-node/managing-attributes.md#autofill-attribute-names) insère, donc une condition construite avec le sélecteur d'attribut emprunte le second chemin. Écrivez la comparaison avec `value()` quand vous devez `!^` ou `!$` se déclencher sur un paquet qui ne contient pas l'attribut.

`!~` atteindre THEN repose sur un mécanisme différent de `!=` atteindre THEN. `!~` aboutit là parce qu'une valeur manquante est considérée comme « ne correspond pas », et `!=` aboutit là parce qu'une valeur manquante est « inégale » au littéral. Ne présumez pas que l'un explique l'autre.
{% endhint %}

### Opérateurs logiques avec des opérandes nuls

| Situation                                                                | Dirige vers | Valeur d’attribut stockée                           |
| ------------------------------------------------------------------------ | ----------- | --------------------------------------------------- |
| `!(x > 5)` lorsque `x` est absent                                        | ELSE        | `null`                                              |
| Opérande nul dans \`                                                     |             | \` évalué avant un opérande vrai sur le même paquet |
| Opérande vrai dans \`                                                    |             | \` évalué avant un opérande nul (court-circuite)    |
| Opérande nul dans `&&` avec un opérande vrai, quel que soit l'ordre      | ELSE        | `null`                                              |
| `false` Opérande dans `&&` évalué avant un opérande nul (court-circuite) | ELSE        | `false`                                             |
| `false` Opérande dans \`                                                 |             | \` évalué avant un opérande nul                     |

L'ordre compte pour les deux opérateurs. Chacun évalue d'abord l'opérande de gauche et s'arrête là lorsque l'opérande de gauche fixe déjà le résultat. Un `false` l'opérande de gauche fixe `&&`, et un `true` l'opérande de gauche fixe `||`. Dans toutes les autres combinaisons, l'opérande nul est évalué, la condition se résout en `null`, et le message est routé vers ELSE.

Un opérande vrai ne peut pas court-circuiter un opérande nul dans `&&`, car AND doit encore savoir si le côté nul ferait échouer la condition. Un `false` opérande peut, et le nœud stocke alors un véritable `false` plutôt que `null`. Pour la même règle appliquée aux formules d'attribut, et pour les modèles de comparaison qui l'évitent, voir [Valeurs manquantes dans les expressions](https://navixy.com/docs/user/fr/guide/account/iot-logic/nodes/missing-values-in-expressions.md).

## Scénarios de gestion des erreurs

| Scénario                                                                       | Résultat            | Chemin du flux | Valeur de l'attribut |
| ------------------------------------------------------------------------------ | ------------------- | -------------- | -------------------- |
| L'expression s'évalue en `true`                                                | Succès              | Connexion THEN | `true`               |
| L'expression s'évalue en `false`                                               | Succès              | Connexion ELSE | `false`              |
| L'attribut référencé est `null` et utilisé seul, sans opérateur de comparaison | Se résout en `null` | Connexion ELSE | `null`               |
| Valeur manquante comparée à `<`, `<=`, `>`, ou `>=`                            | Se résout en `null` | Connexion ELSE | `null`               |
| Valeur manquante comparée à `==` et un littéral non nul                        | S'évalue en `false` | Connexion ELSE | `false`              |
| Valeur manquante comparée à `== null`                                          | S'évalue en `true`  | Connexion THEN | `true`               |
| Valeur manquante comparée à `!=` et un littéral non nul                        | S'évalue en `true`  | Connexion THEN | `true`               |
| Erreur de syntaxe dans l'expression                                            | Se résout en `null` | Connexion ELSE | `null`               |

{% hint style="warning" %}
Une ligne acheminée vers ELSE ne signifie pas toujours que l'attribut est stocké comme `false`. Une référence nulle seule et les opérateurs relationnels (`<`, `<=`, `>`, `>=`) acheminent vers ELSE mais stockent l'attribut comme `null`. Une expression en aval qui vérifie directement l'attribut (`my_flag == false` ou `my_flag == 0`) nécessite une vérification tolérante aux valeurs nulles pour couvrir ce cas, car cela ne correspondra pas à une `null` valeur.

Dans un **Initialiser un Attribut** nœud, les mêmes échecs laissent plutôt l'attribut hors du paquet de données sortant. Voir [Valeurs manquantes dans les expressions](https://navixy.com/docs/user/fr/guide/account/iot-logic/nodes/missing-values-in-expressions.md).
{% endhint %}

## Exemples pratiques d'implémentation

<details>

<summary>Surveillance de la température de la flotte</summary>

**Exigence métier**: Surveillez les véhicules frigorifiques afin de garantir la conformité de la température du chargement

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

* **Chemin THEN**: Envoyez immédiatement des règles d'alertes au dispatch, consignez les violations de conformité et déclenchez des mesures correctives
* **Chemin ELSE**: Poursuivez le traitement normal pour les températures conformes, mettez à jour les tableaux de bord de conformité

</details>

<details>

<summary>Application de la Sécurité du Conducteur</summary>

**Exigence métier**: Identifiez les schémas d'Eco conduite dangereuse pendant les heures de service actives

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

* **Chemin THEN**: Générez des Rapports de coaching du Conducteur, envoyez des notifications de Sécurité, consignez les incidents
* **Chemin ELSE**: Traitez les données de comportement normal d'Eco conduite, mettez à jour les indicateurs de performance

</details>

<details>

<summary>Règles d'alertes d'Entretien prédictif</summary>

**Exigence métier**: Détectez les pannes potentielles des équipements avant qu'elles ne surviennent

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

* **Chemin THEN**: Planifiez des rendez-vous d'Entretien, envoyez des règles d'alertes au technicien, consignez les données de diagnostic
* **Chemin ELSE**: Poursuivez la surveillance de routine, mettez à jour les tableaux de bord d'état des équipements

</details>

<details>

<summary>Surveillance de conformité des zones géographiques</summary>

**Exigence métier**: Veillez à ce que les Véhicules circulent dans les zones autorisées pendant les heures ouvrées

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

Cette expression utilise la `inGeofence()` fonction pour vérifier si un appareil se trouve dans une zone géographique nommée, combinée à un attribut des heures ouvrées. Les limites des zones géographiques sont gérées dans l'interface des zones géographiques Navixy, donc aucune valeur de coordonnées n'a besoin d'être maintenue dans l'expression.

Le bloc `== true` La comparaison permet à la condition de fonctionner sur les paquets pour lesquels la fonction de zone géographique ne peut pas trancher, par exemple un paquet qui ne contient aucune position. Sans elle, une seule valeur vide interrompt toute la condition et le message est routé vers ELSE.

* **Chemin THEN**: Poursuivez les opérations normales ; l'appareil se trouve dans la zone autorisée pendant les heures de travail.
* **Chemin ELSE**: Générez une alerte de localisation non autorisée, avisez la Sécurité et consignez la violation.

Pour détecter le moment où un véhicule quitte la zone autorisée plutôt que de vérifier en continu, utilisez `leaveGeofence()` à la place :

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

Pour la référence complète sur les fonctions de zones géographiques, y compris `enterGeofence()`, `geofenceName()`, et la vérification d'une position antérieure avec `inGeofence()`, consultez [Fonctions de zone géographique](https://navixy.com/docs/user/fr/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/fr/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.
