> For the complete documentation index, see [llms.txt](https://documentation.efalia.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://documentation.efalia.com/produit/efalia-egov/administration/administration-du-portail/annexe-conditions-formulaire.md).

# Annexe : gérer les conditions dans un formulaire

Lorsque le formulaire / la démarche comprend des informations à n'afficher que sous certaines conditions, deux méthodes complémentaires sont disponibles dans le générateur :

**Conditions entre étapes** : Afficher / masquer une étape en fonction de la valeur des champs d'une autre étape

Cas d'utilisation : toutes les démarches qui doivent adapter le nombre de questions à afficher en fonction des informations données par l'usager

**Conditions entre champs au sein d'une étape** : Afficher / masquer des champs en fonction de la valeur des autres champs au sein d'une même étape

Cas d'utilisation : Au-delà d'un certain nombre de conditions, le nombre d'étapes peut considérablement augmenter et rendre la démarche complexe. Il est alors possible de gérer les conditions entre champs à l'intérieur d'une étape.

## 1ère méthode : Contrôles de champs avec des expressions SPEL

**Principes des expressions SPEL**

Les expressions SPEL servent à contrôler la valeur d'un champ ou plusieurs champs de l'étape en cours en fonction de valeurs d'autres champs.

Le contrôle est réalisé à la validation de l'étape et donne lieu à l'affichage d'un message d'erreur le cas échéant. Le message d'erreur est positionné sur un champ qui doit être obligatoire et valorisé pour que le contrôle s'applique. Il n'est pas possible de positionner le contrôle sur un champ tableau, ressource, séparateur, fichier.

**Intégration des expressions SPEL**

Ces expressions doivent être intégrées dans les champs avancés des étapes.

**Champ à tester** : champ de l'étape sur lequel apparaîtra le message en cas de non-respect de l'expression SPEL à tester. Le test ne sera effectué que si le champ en question est obligatoire et valorisé dans le formulaire.

**Message** : message d'erreur à afficher au niveau du champ précité en cas de non-respect de l'expression SPEL à tester.

**Expression SPEL** : expression exploitant le langage SPEL et les valeurs traduisibles (voir [Annexe : valeurs traduisibles](https://documentation.efalia.com/produit/efalia-egov/administration/administration-du-portail/annexe-valeurs-traduisibles.md)) devant renvoyer la valeur *true* ou *false*, selon que l'expression est vérifiée ou pas (voir éléments de syntaxe ci-dessous).

**Syntaxe utilisable dans les expressions SPEL**

*Opérateurs arithmétiques* :

| Signe | Signification  |
| ----- | -------------- |
| +     | Addition       |
| -     | Soustraction   |
| \*    | Multiplication |
| /     | Division       |
| %     | Modulo         |

Dans le cas de champs de type Date, les opérations d'addition et de soustraction renvoient des nombres de jours.

*Opérateurs logiques* : and (et), or (ou)

Il est possible d'utiliser OR ou ||, qui sont remplacés automatiquement par « or », de même que AND ou &&, qui sont remplacés automatiquement par « and ».

L'utilisation de parenthèses () permet de définir le regroupement en cas de tests multiples.

*Comparateurs* :

| Signe    | Signification                                                | Remarques                                                                             |
| -------- | ------------------------------------------------------------ | ------------------------------------------------------------------------------------- |
| <        | Strictement inférieur                                        |                                                                                       |
| >        | Strictement supérieur                                        |                                                                                       |
| <=       | Inférieur ou égal                                            |                                                                                       |
| >=       | Supérieur ou égal                                            |                                                                                       |
| ==       | Egal                                                         | Ex : `${field:S1:F2}=='1'` pour vérifier que la clé 1 est choisie.                    |
| !        | Différent de                                                 |                                                                                       |
| contains | Contient, pour le cas de champs contenant plusieurs valeurs. | Ex : `${field:S1:F2}.contains('1')` pour vérifier que la clé 1 fait partie des choix. |

*Règles de gestion à connaître* :

* Au-delà des valeurs de champs du formulaire, il est possible de faire référence à la date du jour avec `${date:now}`, ou à une date spécifique avec `${date:DD/MM/YYYY}`.
* Il est possible de définir des listes de valeurs en les encadrant par des accolades { }
* Les chaînes de caractères doivent être encadrés par des apostrophes ' ', l'apostrophe devant être doublée dans la chaîne de caractères pour être prise en compte.
* Pour écrire des chiffres décimaux, le séparateur de décimales doit être le point « . » et non la virgule « , ».

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-4c37ab287d708edc212b4069a22cb991f10bd7b5%2Fegov-portail-annexe-conditions-formulaire-01.webp?alt=media" alt=""><figcaption></figcaption></figure>

**Exemple 1 :**

Dans une étape S1, il faut faire en sorte que si l'usager choisit « Autres » à la question F1 « de quel mode de garde bénéficie votre enfant ? » « 1. Crèche ; 2. Nourrice ; 3. Autre », le champ F2 suivant « Précisions » soit obligatoire pour passer à l'étape suivante.

Mettre la condition de validité sur le champ F1 de l'étape S1 : `${field:S1:F1} != '3' or ${field:S1:F2} != ''`

**Exemple 2 :**

Dans une étape S2, il faut faire en sorte que l'usager choisisse dans le champ F3 « Date de délivrance du passeport » une date de moins de 10 ans.

Mettre la condition de validité sur le champ F3 de l'étape S2 : `${date:now} - ${field:S2:F3} < 3650`

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-9846ca3208fb869170897e6c6d95ac8d2b90967c%2Fegov-portail-annexe-conditions-formulaire-02.webp?alt=media" alt=""><figcaption></figcaption></figure>

## 2ème méthode : Conditions entre champs au sein d'une même étape avec un code JavaScript

**Principes du code JavaScript**

L'intégration de code JavaScript permet de contrôler l'affichage de champs de la démarche (masquer/afficher des champs ou rendre des valeurs de champs inaccessibles).

Le champ à contrôler doit obligatoirement être **facultatif**.

La fonction JavaScript qui se compose ainsi :

```
Portal.Utils.Request.showDisplayFieldsOnTextFieldContent(fieldCode,fieldValues,fieldsToManage)
```

* `fieldCode` : Code du champ à tester
* `fieldValues` : Valeur du champ à tester
* `fieldsToManage` : Code du ou des champs à afficher / masquer
* Effet attendu de la fonction : afficher / masquer

**Intégration du code Javascript**

Le code doit être intégré dans les champs avancés de l'étape.

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-dc8ddbc24129c3d2b77eb5ae7bb7daea84677958%2Fegov-portail-annexe-conditions-formulaire-03.webp?alt=media" alt=""><figcaption></figcaption></figure>

En fonction du type de champ à tester pour valider la condition, plusieurs cas sont disponibles. A l'intégration les expressions doivent être modifiées / adaptées à la démarche en cours.

Les éléments à modifier sont indiqués en gris dans chaque code. **Eviter de « copier coller »** cette partie de code, mieux vaut saisir directement ces éléments dans le générateur de démarche.

Si plusieurs valeurs doivent déclencher la condition dans le code à tester, elles doivent être indiquées les unes à la suite des autres séparées par une virgule. Idem si plusieurs étapes doivent être affichées ou masquées.

Il est possible d'intégrer plusieurs codes dans la même étape : il suffit de les séparer par un point-virgule.

Exemple : `Portal.Utils.Request.hideDisplayFieldsOnCheckboxValue('F10',['V4','V6','V7','V8'],['F11','F12'])`

Il est possible de rendre une cellule d'un tableau non modifiable (exemple : dans le cas d'un tableau où une cellule affiche la somme d'une colonne, celle-ci doit être de préférence non modifiable par l'utilisateur). L'ajout de l'élément suivant `true` dans le code Javascript indique que la cellule de destination sera non modifiable.

Exemple : `Portal.Utils.Request.tableSum('F1','C1','F1_L26_C1',true).`

**Exemples**

| Action                                                                         | Champ testé   | Code                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| ------------------------------------------------------------------------------ | ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Montrer un champ                                                               | Champ radio   | `Portal.Utils.Request.showDisplayFieldsOnRadioChecked('fieldCode',['fieldValues'],['fieldsToManage'])`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Cacher un champ (affiché)                                                      | Champ radio   | `Portal.Utils.Request.hideDisplayFieldsOnRadioChecked('fieldCode',['fieldValues'],['fieldsToManage'])`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Montrer un champ                                                               | Menu          | `Portal.Utils.Request.showDisplayFieldsOnSelectValue('fieldCode',['fieldValues'],['fieldsToManage'])`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Cacher un champ                                                                | Menu          | `Portal.Utils.Request.hideDisplayFieldsOnSelectValue('fieldCode',['fieldValues'],['fieldsToManage'])`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Montrer un champ                                                               | Case à cocher | `Portal.Utils.Request.showDisplayFieldsOnCheckboxValue('fieldCode',['fieldValues'],['fieldsToManage'])`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| Cacher un champ                                                                | Case à cocher | `Portal.Utils.Request.hideDisplayFieldsOnCheckboxValue('fieldCode',['fieldValues'],['fieldsToManage'])`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| Montrer un champ                                                               | Texte libre   | `Portal.Utils.Request.showDisplayFieldsOnEmptyTextField('fieldCode',['fieldsToManage'])` — Montre le champ si le champ testé est vide.                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Cacher un champ                                                                | Texte libre   | `Portal.Utils.Request.hideDisplayFieldsOnEmptyTextField('fieldCode',['fieldsToManage'])` — Montre le champ si le champ testé est vide.                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Masquer un choix                                                               | Texte libre   | `Portal.Utils.Request.hideDisplayFieldOptionsOnTextFieldContent('fieldCode',['fieldValue'], 'fieldToManage,['fieldValue'])`                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| Afficher la plus petite valeur d'une colonne                                   | Tableau       | `Portal.Utils.Request.tableMin('fieldCode',['fieldColumn'],['outputCode'])` — La valeur sera affichée dans le champ outputCode.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Afficher la plus grande valeur d'une colonne                                   | Tableau       | `Portal.Utils.Request.tableMax('fieldCode',['fieldColumn'],['outputCode'])` — La valeur sera affichée dans le champ outputCode.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Afficher la somme d'une colonne                                                | Tableau       | `Portal.Utils.Request.tableSum('fieldCode',['fieldColumn'],['outputCode'])` — La valeur sera affichée dans le champ outputCode.                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Afficher le résultat d'un calcul / Faire des calculs                           | —             | `Portal.Utils.Request.calcul('<code_resultat>', '<formule>', true);` — Dans l'élément `<code_resultat>`, indiquer le code du champ dans lequel le résultat doit s'afficher et dans l'élément `<formule>` l'opération qui doit être réalisée. Dans la formule les champs à évaluer sont à citer entre accolades, ex `Portal.Utils.Request.calcul('F4','({F1}+{F2}+{F3})*(19.6/100)',true)`. Pour le calcul des décimales, utiliser `Portal.Utils.Request.calcul('F5','{F3}+{F4}',false,{decimals:2})` — le `false` est un attribut qui permet de dire si le champ cible doit être modifiable ou pas. |
| Forcer le formatage en "euros"                                                 | —             | `Portal.Utils.Request.isCurrency([...]);`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Forcer la mise en forme en majuscule sur un champ texte                        | —             | `Portal.Utils.Request.upperCase([...]);`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| Forcer la mise en forme sur la première lettre en majuscule sur un champ texte | —             | `Portal.Utils.Request.camelCase([...])`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |

<figure><img src="https://3557286639-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FcnnXLnfB61CBUw4H9Fho%2Fuploads%2Fgit-blob-ae5eaa5d73cfba6d40007edc693bdf4e6e63e728%2Fegov-portail-annexe-conditions-formulaire-04.webp?alt=media" alt=""><figcaption></figcaption></figure>


---

# 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://documentation.efalia.com/produit/efalia-egov/administration/administration-du-portail/annexe-conditions-formulaire.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.
