From 32c4435c38d15cd6154b792b3c62e1b00ced48ec Mon Sep 17 00:00:00 2001
From: TCHERNIATINSKY <philippe.tcherniatinsky@inrae.fr>
Date: Tue, 8 Feb 2022 11:53:31 +0100
Subject: [PATCH] Modification du yaml pour la section groovy
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- regroupement des paramètres groovy dans une section groovy
- utilisation de listes pour references et dataypes
- modification des yaml et de la documentation
---
 Documentation_fichier_Yaml.md                 | 128 ++-
 Documentation_fichier_Yaml.md.backup          | 768 +++++++++++++++++
 .../inra/oresing/checker/CheckerFactory.java  |   5 +-
 .../oresing/checker/GroovyConfiguration.java  |  18 +
 .../oresing/checker/GroovyLineChecker.java    |  69 +-
 .../GroovyLineCheckerConfiguration.java       |  16 +-
 .../decorators/DecoratorConfiguration.java    |  12 +-
 .../checker/decorators/GroovyDecorator.java   |   5 +-
 .../fr/inra/oresing/model/Configuration.java  |  18 +-
 .../IGroovyDataInjectionConfiguration.java    |   8 +
 .../rest/ApplicationConfigurationService.java |  13 +-
 .../checker/GroovyLineCheckerTest.java        |  34 +-
 .../oresing/model/LocalDateTimeRangeTest.java |  10 +-
 src/test/resources/data/acbb/acbb.yaml        |   3 +-
 .../resources/data/foret/foret_essai.yaml     | 792 ++++++++++--------
 .../data/monsore/monsore-with-repository.yaml |  64 +-
 src/test/resources/data/monsore/monsore.yaml  |  76 +-
 .../resources/data/validation/fake-app.yaml   |   3 +-
 18 files changed, 1479 insertions(+), 563 deletions(-)
 create mode 100644 Documentation_fichier_Yaml.md.backup
 create mode 100644 src/main/java/fr/inra/oresing/checker/GroovyConfiguration.java
 create mode 100644 src/main/java/fr/inra/oresing/model/IGroovyDataInjectionConfiguration.java

diff --git a/Documentation_fichier_Yaml.md b/Documentation_fichier_Yaml.md
index d5fd3b58b..78b694123 100644
--- a/Documentation_fichier_Yaml.md
+++ b/Documentation_fichier_Yaml.md
@@ -13,18 +13,29 @@ Il y a 5 parties (<span style="color: orange">sans indentation</span>) attendues
 
 <span style="color: orange">l'indentation du fichier yaml est très importante.</span>
 
-### on commence par mettre la version du parser de yaml. 
+
+### Description du fichier
+
+Informations sur le fichier lui même
+
+#### on renseigne la version du parser de yaml.
 Soit version actuelle du site qui est 0 actuellement.
 
+
 ``` yaml
 version: 0
 ```
 
+```
+  D'une version à l'autre le format du yaml peut changer
+```
+
 <span style="color: orange">*version* n'est pas indenté.</span>
-### on présente l'application avec son nom et sa la version du fichier yaml : 
+#### on présente l'application avec son nom et sa la version du fichier yaml :
 (on commence par la version 1) 
 
-S'il y a déjà une application du même nom mais que l'on a fait des modifications dans le fichier on change de version.
+S'il y a déjà une application du même nom mais que l'on a fait des modifications dans le fichier on incrémente la  version.
+
 ``` yaml
 application:
   name: Aplication_Nom
@@ -32,8 +43,18 @@ application:
 ```
 
 <span style="color: orange">*application* n'est pas indenté. *nom* et *version* sont indentés de 1.</span>
-### on décrit les donnés de référence dans la partie *references*, on y liste les noms des colonnes souhaitées (dans *columns*); on précisant la liste de colonnes qui forment la clef naturelle (dans *keyColumn*): 
-par exemple pour les fichiers :
+
+### Description référentiels
+on décrit les référentiels dans la partie *references*, on y liste les noms des colonnes souhaitées (dans *columns*); on précisant la liste de colonnes qui forment la clef naturelle (dans *keyColumn*):
+
+pour le modèle de référentiels
+
+```mermaid
+  classDiagram
+    sites *-- parcelles:site
+```
+
+et pour les fichiers :
 
 
 - sites
@@ -73,20 +94,33 @@ references:
       nom de la parcelle:
 ```
 
-Le nom des colonnes des references doivent être courte pour ne pas être tronqué lors de la création de l'application.
+```
+Le nom du référentiel est libre. Cependant pour ceux réutilisés  ailleurs dans l'application, préférer utiliser minuscules et underscores sous peine de générer des erreurss: 
+
+exampl : mon_nom_de_referentiel
+```
+
+Le nom des colonnes des references doivent être courte pour ne pas être tronqué lors de la création des vues de l'application.
+
+
+```
+  les noms des colonnes dans la base de données est limité à 63 caractères. Dans les vues, ce nom est une concaténation du nom du référentiel et du nom de la colonne
+```
+
 Penser à mettre le même nom de colonnes dans le fichier *.csv* que dans la partie *columns* du fichier yaml.
 
 <span style="color: orange">*references* n'est pas indenté. *sites* et *parcelles* sont indentés de 1. *keyColumns* et 
 *columns* sont indentés de 2. Le contenue de *columns* seront indenté de 3.</span>
 
 
-#### On rajoute contraintes sur les données de référence
+#### On peut poser des contraintes sur les données de référence
 
 Les contraintes se définissent pour chacune des données de référence dans la section validations.
 Chaque règle de validation peut porter sur plusieurs colonnes de la donnée de référence.
 Elle comporte une description et un checker (Reference, Integer, Float, RegularExpression, Date).
 
 
+
 ``` yaml
 
   types_de_donnees_par_themes_de_sites_et_projet:
@@ -118,12 +152,30 @@ Elle comporte une description et un checker (Reference, Integer, Float, RegularE
         checker:
           name: GroovyExpression # utilisation d'un script groovy de validation
           params:
-            expression: >
-              String datatype = Arrays.stream(datum.get("nom du type de données").split("_")).collect{it.substring(0, 1)}.join();
-              return application.getDataType().contains(datatype);
+            groovy:
+              expression: >
+                String datatype = Arrays.stream(datum.get("nom du type de données").split("_")).collect{it.substring(0, 1)}.join();
+                return application.getDataType().contains(datatype);
 
 ```
 
+|  name| References | Integer | Float | GroovyExpression | RegularExpression | *
+| --- | :-:  | :-:  | :-:  | :-:  | :-:  | --- | 
+| columns | X | X | X |  | X | La colonne dans laquelle on prend la valeur | 
+| refTypes | X | |  |  |  | Le référentiels de jointure | 
+| pattern |  | |  |  | X | Le pattern pour une expression régulière | 
+| codify | X | X | X |  | X | Le contenu de la colonne est codifié | 
+| required | X | X | X |  | X | Le contenu de la colonne ne peut être vide | 
+| groovy |  | |  | X |  | une section pour le traitement d'une expression groovy | 
+| replace |  | |  | X |  | l'expression groovy renvoie un résultat au lieu d'un booléen | 
+
+
+La section groovy accepte trois paramètres
+expression : une expression groovy (pour le checker GroovyExpression doit renvoyer true. Ou remplace la valeur actuelle pour les autres checkers)
+references : une liste de référentiels pour lesquels on veut disposer des valeurs dans l'expression
+datatypes : une liste de datatypes pour lesquels on veut disposer des valeurs dans l'expression
+
+
 Pour les checkers GroovyExpression, on récupère dans le script des informations :
 
     datum : les valeurs de la ligne courante. 
@@ -138,7 +190,8 @@ Pour les checkers GroovyExpression, on récupère dans le script des information
       -> datatypes.get("nom du datatype").getValues().get("nom de la colonne")
     datatypesValues : idem que datatypes
       -> datatypesValues.get("nom du datatype").get("nom de la colonne")
-    params : la section params dans laquelle on peut rajouter des information que l'on souhaite utiliser dans le script..
+    params : la section params
+
 ### il est possible de définir des clefs composite entre différentes références
 
   Une clef composite permet de définir une hiérarchie entre différentes données de référence.
@@ -157,17 +210,6 @@ Pour les checkers GroovyExpression, on récupère dans le script des information
   seront supprimés.
 
 Pour créer une clef à partir d'une chaîne, on peut utiliser un checker et enrenseignant la section codify de params.
-rajouter le params required si cette clef est obligatoire
-```yaml
-
-  checker:
-    name: RegularExpression
-    params:
-      pattern: .*
-      required: true
-      codify: true
-      columns: nom du taxon déterminé
-```
 
 ```mermaid
   classDiagram
@@ -196,17 +238,19 @@ compositeReferences:
       - parentRecursiveKey: nom du taxon superieur
         reference: taxon
 ```
-### on met les infos des *dataTypes* 
+### on renseigne la description des *dataTypes*
+ 
  Pour enregistrer un type de données, il faut déclarer 
  - le data : ce qui sera enregistré en base de données (*section data*)
  - le format du fichier (*section format*)
  - les authorisations (*section authorisations*)
  - les validations de chaque ligne
-#### Nous regrouperons les données par nom du fichier csv qu'on souhaite importer (*nomDonnéeCSV*).</h4>
+ 
+#### Nous regrouperons les données par nom du fichier csv qu'on souhaite importer (*nomDonnéeCSV*.csv)</h4>
 
 ``` yaml
 dataTypes:
-  nomDonnéeCSV:
+  nom_donnees_csv:
 ```
 
 <span style="color : orange">*dataTypes* n'est pas indenté. *nomDonnée* est indenté de 1.</span>
@@ -321,10 +365,15 @@ Les *variables/components* sont passés dans la map *datum*. On récupère la va
         checker:
           name: GroovyExpression
           params:
-            expression: >
-              Set.of("", "0", "1", "2").contains(datum.get("SWC").get("qualité"))
+          	groovy:
+	            expression: >
+	              Set.of("", "0", "1", "2").contains(datum.get("SWC").get("qualité"))
 ```
 
+Cette formulation vérifie que la valeur du component qualité de la variable SWC est vide ou égale à 0,1 ou 2
+L'expression doit renvoyer true
+
+
 Pour les checkers GroovyExpression, on récupère dans le script des informations :
 
     datum : les valeurs de la ligne courante. 
@@ -347,15 +396,20 @@ Pour les checkers GroovyExpression, on récupère dans le script des information
         checker:
           name: GroovyExpression
           params:
+          groovy:
             expression: >
-              return referencesValues.get("variables_et_unites_par_types_de_donnees")
-              .findAll{it.get("nom du type de données").equals(params.get("datatype"))}
-              .find{it.get("nom de la variable").equals(params.get("codeVariable"))}
-              .get("nom de l'unité").equals(datum.get(params.get("variable")).get(params.get("component")));
-            references: variables_et_unites_par_types_de_donnees
+	            String datatype= "piegeage_en_montee"
+	            String variable= "Nombre d'individus"
+	            String codeVariable= "nombre_d_individus"
+	            String component= "unit"
+	              return referencesValues.get("variables_et_unites_par_types_de_donnees")
+	              .findAll{it.get("nom du type de données").equals(datatype)}
+	              .find{it.get("nom de la variable").equals(codeVariable)}
+	              .get("nom de l'unité").equals(datum.variable.component);
+            references: 
+            	- variables_et_unites_par_types_de_donnees
 ``` 
-Cette formulation vérifie que la valeur du component qualité de la variable SWC est vide ou égale à 0,1 ou 2
-L'expression doit renvoyer true
+Des valeurs peuvent être définies dans l'expression.
 
 La partie validation peut être utilisée pour vérifier le contenu d'une colonne d'un fichier de référence
 
@@ -678,8 +732,8 @@ multiyaml.zip
 ├── compositeReferences.yaml
 ├── configuration.yaml
 ├── dataTypes
-│   ├── smp_infraj.yaml
-│   └── ts_infraj.yaml
+│   ├── smp_infraj.yaml
+│   └── ts_infraj.yaml
 └── references
     ├── types_de_zones_etudes.yaml
 
@@ -712,4 +766,4 @@ multiyaml.zip
 
 ## lors de l'importation de fichier csv dans l'application:
 
-* ouvrer la console avec F12 dans votre navigateur pour voir l'erreur de téléversement (erreur serveur) plus en détail.
\ No newline at end of file
+* ouvrer la console avec F12 dans votre navigateur pour voir l'erreur de téléversement (erreur serveur) plus en détail.
diff --git a/Documentation_fichier_Yaml.md.backup b/Documentation_fichier_Yaml.md.backup
new file mode 100644
index 000000000..bb4a92346
--- /dev/null
+++ b/Documentation_fichier_Yaml.md.backup
@@ -0,0 +1,768 @@
+# Aide fichier Yaml
+## La création :
+Vous trouverez ci-dessous un exemple de fichier Yaml fictif qui décrit les parties attendues dans celui-ci pour qu'il 
+soit valide. **Attention le format Yaml est sensible** il faut donc respecter l'indentation. 
+
+Il y a 5 parties (<span style="color: orange">sans indentation</span>) attendues dans le fichier : 
+
+  * version, 
+  * application, 
+  * references,
+  * compositeReferences, 
+  * dataTypes
+
+<span style="color: orange">l'indentation du fichier yaml est très importante.</span>
+
+
+### Description du fichier
+
+Informations sur le fichier lui même
+
+#### on renseigne la version du parser de yaml.
+Soit version actuelle du site qui est 0 actuellement.
+
+
+``` yaml
+version: 0
+```
+
+```
+  D'une version à l'autre le format du yaml peut changer
+```
+
+<span style="color: orange">*version* n'est pas indenté.</span>
+#### on présente l'application avec son nom et sa la version du fichier yaml :
+(on commence par la version 1) 
+
+S'il y a déjà une application du même nom mais que l'on a fait des modifications dans le fichier on incrémente la  version.
+
+``` yaml
+application:
+  name: Aplication_Nom
+  version: 1
+```
+
+<span style="color: orange">*application* n'est pas indenté. *nom* et *version* sont indentés de 1.</span>
+
+### Description référentiels
+on décrit les référentiels dans la partie *references*, on y liste les noms des colonnes souhaitées (dans *columns*); on précisant la liste de colonnes qui forment la clef naturelle (dans *keyColumn*):
+
+pour le modèle de référentiels
+
+```mermaid
+  classDiagram
+    sites *-- parcelles:site
+```
+
+et pour les fichiers :
+
+
+- sites
+
+| nom du site |
+| ------ |
+| site1 |
+| site2 |
+
+- parcelles
+
+| site | nom de la parcelle |
+| ------ | ------ |
+| site1 | 1 |
+| site2 | 1 |
+
+on aura le yaml suivant
+
+``` yaml
+references:
+  agroécosystème: 
+    keyColumns: [nom]
+    columns:
+      nom:
+    nom
+  sites:
+  #donnée de référence avec une clef sur une colonne
+    keyColumns: [nom du site]
+    columns:
+      Agroécosystème:
+      nom du site:
+  parcelles:
+  #donnée de référence avec une clef sur deux colonnes
+    keyColumns: [site,nom de la parcelle]
+    columns:
+      site:
+      nom de la parcelle:
+```
+
+```
+Le nom du référentiel est libre. Cependant pour ceux réutilisés  ailleurs dans l'application, préférer utiliser minuscules et underscores sous peine de générer des erreurss: 
+
+exampl : mon_nom_de_referentiel
+```
+
+Le nom des colonnes des references doivent être courte pour ne pas être tronqué lors de la création des vues de l'application.
+
+
+```
+  les noms des colonnes dans la base de données est limité à 63 caractères. Dans les vues, ce nom est une concaténation du nom du référentiel et du nom de la colonne
+```
+
+Penser à mettre le même nom de colonnes dans le fichier *.csv* que dans la partie *columns* du fichier yaml.
+
+<span style="color: orange">*references* n'est pas indenté. *sites* et *parcelles* sont indentés de 1. *keyColumns* et 
+*columns* sont indentés de 2. Le contenue de *columns* seront indenté de 3.</span>
+
+
+#### On peut poser des contraintes sur les données de référence
+
+Les contraintes se définissent pour chacune des données de référence dans la section validations.
+Chaque règle de validation peut porter sur plusieurs colonnes de la donnée de référence.
+Elle comporte une description et un checker (Reference, Integer, Float, RegularExpression, Date).
+
+
+
+``` yaml
+
+  types_de_donnees_par_themes_de_sites_et_projet:
+    validations:
+      projetRef: # la clef d'une validation
+        description: "référence au projet" # la description
+        checker: # le checker de validation
+          name: Reference #Le checker à utiliser
+          params: #liste de paramètres (dépend du checker choisi)
+            refType: projet #pour le checker référence la donnée référencée
+            columns: nom du projet #liste des colonnes sur lequel s'applique le checker
+      sitesRef:
+        description: "référence au site"
+        checker:
+          name: Reference
+          params:
+            refType: sites
+            columns: nom du site
+      themesRef:
+        description: "référence au theme"
+        checker:
+          name: Reference
+          params:
+            refType: themes
+            columns: nom du thème
+
+      checkDatatype:
+        description: "test"
+        checker:
+          name: GroovyExpression # utilisation d'un script groovy de validation
+          params:
+            groovy:
+              expression: >
+                String datatype = Arrays.stream(datum.get("nom du type de données").split("_")).collect{it.substring(0, 1)}.join();
+                return application.getDataType().contains(datatype);
+
+```
+
+|  name| References | Integer | Float | GroovyExpression | RegularExpression | *
+| --- | :-:  | :-:  | :-:  | :-:  | :-:  | --- | 
+| columns | X | X | X |  | X | La colonne dans laquelle on prend la valeur | 
+| refTypes | X | |  |  |  | Le référentiels de jointure | 
+| pattern |  | |  |  | X | Le pattern pour une expression régulière | 
+| codify | X | X | X |  | X | Le contenu de la colonne est codifié | 
+| required | X | X | X |  | X | Le contenu de la colonne ne peut être vide | 
+| groovy |  | |  | X |  | une section pour le traitement d'une expression groovy | 
+| replace |  | |  | X |  | l'expression groovy renvoie un résultat au lieu d'un booléen | 
+
+
+La section groovy accepte trois paramètres
+expression : une expression groovy (pour le checker GroovyExpression doit renvoyer true. Ou remplace la valeur actuelle pour les autres checkers)
+references : une liste de référentiels pour lesquels on veut disposer des valeurs dans l'expression
+datatypes : une liste de datatypes pour lesquels on veut disposer des valeurs dans l'expression
+
+
+Pour les checkers GroovyExpression, on récupère dans le script des informations :
+
+    datum : les valeurs de la ligne courante. 
+      On récupère la valeur d'un variable-component -> datum.get("nom de la variable").get("nom du composant")
+    application : le yaml de l'application
+    references: les valeurs d'une donnée de référence spécifique;
+      Il faut renseigner dans params la clef "references" qui définit les données de références accessibles dans references.
+      -> references.get("nom de la reference").getRefValues().get("nom de la colonne")
+    referencesValues : idem que references; 
+      -> referencesValues.get("nom de la reference").get("nom de la colonne")
+    datatypes : idem que references pour les datatypes. Il faut renseigner le param datatypes
+      -> datatypes.get("nom du datatype").getValues().get("nom de la colonne")
+    datatypesValues : idem que datatypes
+      -> datatypesValues.get("nom du datatype").get("nom de la colonne")
+    params : la section params
+
+### il est possible de définir des clefs composite entre différentes références
+
+  Une clef composite permet de définir une hiérarchie entre différentes données de référence.
+  Dans l'example ci-dessous il y a une relation oneToMany entre les deux données de référence nomDeLaReferences et 
+  nomDeLaReferences2. 
+
+  La clef naturelle permet de distinguer deux lignes distinctes
+  La clef composite rajoute une hiérarchie entre les données de référence. Dans l'exemple ci-dessous pour référencer 
+  une ligne nomDeLaReferences2, il faudra utiliser comme valeur la clef technique crée : site1.site1__1
+
+  La clef crée sera en minuscule, ne comportera pas d'accents; les espaces sont remplacés par des underscores; les 
+  traits d'union sont supprimés.
+  "Ma clé qui-sert-de-référence" -> "ma_cle_quisertdereference"
+
+  Elle ne doit alors comporter que des lettres minuscules de chiffres et des underscores tous les autres caractères 
+  seront supprimés.
+
+Pour créer une clef à partir d'une chaîne, on peut utiliser un checker et enrenseignant la section codify de params.
+
+```mermaid
+  classDiagram
+    sites *-- parcelles:site
+```
+
+``` yaml
+compositeReferences:
+  localizations:
+    components:
+      - reference: sites
+      - reference: parcelles
+        parentKeyColumn: "site"
+```
+
+<span style="color: orange">*compositeReferences* n'est pas indenté. *localizations* est indenté de 1. *components* est 
+indenté de 2. *- reference* et *- parentKeyColumn* sont indentés de 3. Le *reference* qui est sous parentKeyColumn est 
+indenté de 4.</span>
+
+Il est possible de définir une composite référence récursive dans le cas de données de références dui font référence à elle même. En ce cas on utilisera la clef `parentRecursiveKey` pour faire référence à la colonne parent du même fichier. 
+``` yaml
+
+compositeReferences:
+  taxon:
+    components:
+      - parentRecursiveKey: nom du taxon superieur
+        reference: taxon
+```
+### on renseigne la description des *dataTypes*
+ 
+ Pour enregistrer un type de données, il faut déclarer 
+ - le data : ce qui sera enregistré en base de données (*section data*)
+ - le format du fichier (*section format*)
+ - les authorisations (*section authorisations*)
+ - les validations de chaque ligne
+ 
+#### Nous regrouperons les données par nom du fichier csv qu'on souhaite importer (*nomDonnéeCSV*.csv)</h4>
+
+``` yaml
+dataTypes:
+  nom_donnees_csv:
+```
+
+<span style="color : orange">*dataTypes* n'est pas indenté. *nomDonnée* est indenté de 1.</span>
+
+##### *data* 
+La section data permet de décrire le schéma des données enregistrées en base. Les données sont enregistrées comme une 
+liste de *variables* pouvant avoir plusieurs *components*.
+Les *variables/components* peuvent être des constantes ou des valeurs calculées, provenir d'un en-tête, ou provenir des 
+colonnes.
+
+*date*, *localization* et *prélèvement* sont des exemples de nom de variable qui regrouperont plusieurs components.
+ On fait la liste de *components* pour chaque variable. 
+
+Par exemple *day* et *time* sont les *components* de la variable *date*. 
+
+On vérifie leurs formats grace aux *checker* -> *name* est le nom du checker et *params* permet de définir les 
+paramètres du format via le *pattern*.
+Voici quelque possibilité de *pattern* possible pour les dates et heures : 
+
+|pattern   | exemple 1    | exemple 2   |
+| -------- |   ---------  | ---------   |
+|dd/MM/yy  |31/01/21      | 31/12/21    |
+|dd/MM/yyyy|31/01/2021    |31/12/2021   |
+|MM/yyyy   |01/2021       |12/2021      |
+|M/yyyy    |1/2021        |12/2021      |
+|HH:mm     |13:00         |01:00        |
+|hh:mm:ss  |13:00:00      |01:00:00     |
+|dd/MM/yy hh:mm:ss|31/01/21 13:00:00|31/12/21 01:00:00|
+
+<span style="color : orange">Pour les dates anglaises inverser le "dd" avec le "MM" (exemple : MM/dd/yy -> 01/31/21) et 
+pour l'heure anglaise il suffit d'ajouter am/pm (exemple "hh:mm am/pm"-> "01:00 am" ou "hh:mm:ss AM/PM" -> "01:00:00 AM"). 
+Le *pattern* doit correspondre avec le format de la date dans le fichier CSV.</span>
+
+pour les données :
+
+| date | heure | nom de la parcelle | point | volume | qualité |
+| ------ | ------ | ------ | ------ | ------ | ------ |
+| 12/01/2010 | 10:00:00 | site1.site1__1 | 2 | 240.7 | 2 |
+| 12/01/2010 | 15:30:00 | site2.site2__1 | 1 | 105.25 | 1 |
+
+On décrit un format pour stocker les données sous la forment
+
+``` json
+  {
+    date:{
+      datetime: "12/01/2010 10:00:00",
+      day: "12/01/2010",
+      time: "10:00:00"
+    },
+    localization:{
+      parcelle:"site1.site1__1",
+      point:"2"
+    },
+    prélèvement:{
+      volume:240.7,
+      qualité:2
+    }
+  }
+```
+
+``` yaml
+    data:
+      date:
+        components:
+          datetime:
+            #calcul d'une valeur par défaut date+time avec une expression groovy
+            defaultValue: >
+              return datumByVariableAndComponent.get("date").get("day") +" " +datumByVariableAndComponent.get("date").get("time")+ ":00"
+          day:
+            checker:
+              name: Date
+              params:
+                pattern: dd/MM/yyyy
+          time:
+            checker:
+              name: Date
+              params:
+                pattern: hh:mm:ss
+      localization:
+        components:
+          parcelle:
+            checker:
+              name: Reference
+              params:
+                refType: parcelles
+          point:
+            checker:
+              name: Integer
+      prélèvement:
+        components:
+          volume:
+            checker:
+              name: Float
+          qualité:
+            checker:
+              name: Integer
+```
+
+<span style="color: red">*/!\ *refType* doit forcément être identique aux noms des références déclarées dans la partie 
+*references* /!\ </span>
+
+<span style="color: orange">*data* est indenté de 2. Les variables sont indentés de 3 et les components le sont de 4.</span>
+
+##### la validation est utilisé pour valider une ligne.
+
+Les *variables/components* sont passés dans la map *datum*. On récupère la valeur du component qualité de la variable SWC
+
+``` yaml
+    validations:
+      swcQualityEnumeration:
+        description: "Si renseignée, la qualité du taux d'humidité vaut 1, 2 ou 3"
+        checker:
+          name: GroovyExpression
+          params:
+          	groovy:
+	            expression: >
+	              Set.of("", "0", "1", "2").contains(datum.get("SWC").get("qualité"))
+```
+
+Cette formulation vérifie que la valeur du component qualité de la variable SWC est vide ou égale à 0,1 ou 2
+L'expression doit renvoyer true
+
+
+Pour les checkers GroovyExpression, on récupère dans le script des informations :
+
+    datum : les valeurs de la ligne courante. 
+      On récupère la valeur d'un variable-component -> datum.get("nom de la variable").get("nom du composant")
+    application : le yaml de l'application
+    references: les valeurs d'une donnée de référence spécifique;
+      Il faut renseigner dans params la clef "references" qui définit les données de références accessibles dans references.
+      -> references.get("nom de la reference").getRefValues().get("nom de la variable").get("nom du composant")
+    referencesValues : idem que references; 
+      -> referencesValues.get("nom de la reference").get("nom de la variable").get("nom du composant")
+    datatypes : idem que references pour les datatypes. Il faut renseigner le param datatypes
+      -> datatypes.get("nom du datatype").getValues().get("nom de la variable").get("nom du composant")
+    datatypesValues : idem que datatypes
+      -> datatypesValues.get("nom du datatype").get("nom de la variable").get("nom du composant")
+
+
+``` yaml
+  unitOfIndividus:
+        description: "vérifie l'unité du nombre d'individus"
+        checker:
+          name: GroovyExpression
+          params:
+          groovy:
+            expression: >
+            String datatype= "piegeage_en_montee"
+            String variable= "Nombre d'individus"
+            String codeVariable= "nombre_d_individus"
+            String component= "unit"
+              return referencesValues.get("variables_et_unites_par_types_de_donnees")
+              .findAll{it.get("nom du type de données").equals(datatype)}
+              .find{it.get("nom de la variable").equals(codeVariable)}
+              .get("nom de l'unité").equals(datum.variable.component);
+            references: variables_et_unites_par_types_de_donnees
+``` 
+Des valeurs peuvent être définies dans l'expression.
+
+La partie validation peut être utilisée pour vérifier le contenu d'une colonne d'un fichier de référence
+
+<span style="color: orange">*validations* est indenté de 2. </span>
+
+##### *authorization* porte bien son nom c'est là qu'on définira les autorisations d'accès aux données :
+Authorization permet de définir des groupes de valeurs. Une ligne du fichier est découpée en autant de ligne que de 
+*dataGroups* et contient un *authorizationScope* et un *timeScope*.
+Les droits sont portés par la ligne. (un dataGroup + un authorizationScope + un timeScope)
+
+Dans *dataGroups* nous regrouperont les données par type de données.
+
+-> *authorizationScope* clef naturelle d' une ligne de fichier en combinaison avec.
+
+-> *timeScope* est la partie qui permet de mettre une autorisation sur une durée.
+
+``` yaml
+    authorization:
+      dataGroups:
+        typeDonnée1:
+          label: "Référentiel"
+          data:
+            - date
+            - localization
+        typeDonnée2:
+          label: "Données qualitatives"
+          data:
+            - prélèvement
+      authorizationScopes:
+        localization_ref1:
+          variable: localization
+          component: parcelle
+        localization_ref2:
+          variable: localization
+          component: point
+      timeScope:
+        variable: date
+        component: datetime
+```
+
+Les patterns de timescope valides sont :
+- dd/MM/yyyy HH:mm:ss
+- dd/MM/yyyy
+- MM/yyyy
+- yyyy
+Vous pouvez préciser la durée du timescope dans le params "duration" au format:
+- ([0-9]*) (NANOS|MICROS|MILLIS|SECONDS|MINUTES|HOURS|HALF_DAYS|DAYS|WEEKS|MONTHS|YEARS
+
+
+``` yaml
+    authorization:
+      ...
+      timeScope:
+        variable: date
+        component: datetime
+        
+    data:
+      date:
+        components:
+          datetime:
+            checker:
+              name: Date
+              params:
+                pattern: dd/MM/yyyy HH:mm:ss
+                duration: 30 MINUTES
+```
+
+<span style="color: orange">*authorization* est indenté de 2. *dataGroups*, *authorizationScopes* et *timeScope* sont 
+indenté de 3.</span>
+
+##### ensuite on va décrire le format des données attendues (dans *format*) décrite dans la partie *dataTypes* : 
+
+Si votre fichier à des données mise dans un cartouche vous devrez les décrire dans la partie *constants*.
+On précisera le nombre de lignes dans la cartouche dans *rowNumber* et le nombre de colonnes utiliser dans la cartouche 
+dans *columnNumber*.
+
+ici le contenu de la première ligne deuxième colonne est lié au varaible/component localization/nomDonnée et apparaîtra 
+à l'export dans une colonne "type de données"
+``` yaml
+    format:
+      constants:
+        - rowNumber: 1
+          columnNumber: 2
+          boundTo:
+            variable: localization
+            component: nomDonnée
+          exportHeader: "type de données"
+```
+
+<span style="color: orange">*format* est indenté de 2. </span>
+
+*headerLine* permet de mettre le nombre de la lignes qui contient le nom des colonnes décrite plus bas dans *columns*.
+
+``` yaml
+      headerLine: 1
+```
+
+*firstRowLine* sera égale au numéro de la première ligne dans la quelle se trouvera les premières données.
+``` yaml
+      firstRowLine: 2
+```
+
+*columns* est la partie dans laquelle nous décrirons toutes les colonnes et leurs types de données que nous attendons 
+dans chaque colonne du fichier CSV (pour l'exemple utilisé ici c'est pour les données du fichier nomDonnées.csv):
+
+*header* doit avoir exactement le même nom que le nom de la colonne dans le fichier csv.
+
+``` yaml
+      columns:
+        - header: "nom de la parcelle"
+          boundTo:
+            variable: localization
+            component: parcelle
+        - header: "point"
+          boundTo:
+            variable: localization
+            component: point
+        - header: "date"
+          boundTo:
+            variable: date
+            component: day
+        - header: "heure"
+          boundTo:
+            variable: date
+            component: time
+        - header: "volume"
+          boundTo:
+            variable: prélèvement
+            component: volume
+        - header: "qualité"
+          boundTo:
+            variable: prélèvement
+            component: qualité
+```
+## lors de l'importation du fichier yaml :
+	
+* mettre le nom de l'application en minuscule,
+* sans espace,
+* sans accent,
+* sans chiffre et 
+* sans caractères speciaux
+## Internationalisation du fichier yaml:
+Il est possible de faire un fichier international en ajoutant plusieurs parties Internationalisation en précisant la langue.
+
+### Internationalisation de l'application:
+Dans la partie application ajouter *defaultLanguage* pour préciser la langue par default de l'application.
+Ainsi que *internationalization* qui contient les abbreviations des langues de traduction (ex: *fr* ou *en*)
+Ce qui premettra de traduire le nom de l'application.
+
+``` yaml
+  defaultLanguage: fr
+  internationalization:
+    fr: Application_nom_fr
+    en: Application_nom_en
+```
+### Internationalisation des *references*:
+Nous pouvons faire en sorte que le nom de la référence s'affiche dans la langue de l'application en y ajoutant
+*internationalizationName* ainsi que les langues dans lequel on veux traduire le nom de la référence.
+*internationalizedColumns* ....
+
+``` yaml
+references:
+  especes:
+    internationalizationName:
+      fr: Espèces
+      en: Species
+    internationalizedColumns:
+      esp_definition_fr:
+        fr: esp_definition_fr
+        en: esp_definition_en
+```
+
+- Définition d'un affichage d'un référentiel'
+
+Il est possible de créer un affichage internationalisé d'un référentiel (dans les menus, les types de données).
+Pour cela on va rajouter une section internationalizationDisplay.
+
+``` Yaml
+    internationalizationDisplay:
+      pattern:
+        fr: '{nom_key} ({code_key})'
+        en: '{nom_key} ({code_key})'
+
+```
+On définit un pattern pour chaque langue en mettant entre accolades les nom des colonnes. C'est nom de colonnes seront remplacés par la valeur de la colonne ou bien, si la colonne est internationalisée, par la valeur de la colonne internationalisée correspondant à cette colonne.
+
+Par défaut, c'est le code du référentiel qui est affiché.
+### Internationalisation des *dataTypes*:
+Nous pouvons aussi faire en sorte que *nomDonnéeCSV* soit traduit. Même chose pour les noms des *dataGroup*.
+
+``` yaml
+dataTypes:
+  nomDonnéeCSV:
+    internationalizationName:
+      fr: Nom Donnée CSV
+      en: Name Data CSV
+    authorization:
+      dataGroups:
+        referentiel:
+          internationalizationName:
+            fr: Référentiel
+            en: Referential
+          label: "Référentiel"
+          data:
+            - date
+            - projet
+            - site
+            - commentaire
+```
+
+On peut surcharger l'affichage d'une colonne faisant référence à un référentiel en rajoutant une section internationalizationDisplay dans le dataType.
+```Yaml
+  pem:
+    internationalizationDisplay:
+      especes:
+          pattern:
+            fr: 'espèce :{esp_nom}'
+            en: 'espèce :{esp_nom}'
+```
+## templating
+IL est possible d'utiliser un template lorsque certaines colonnes de datatype on un format commun.
+par example avec des colonnes dont le nom répond au pattern variable_profondeur_répétition : SWC_([0-9]*)_([0-9]*)
+
+``` csv
+Date	      Time	SWC_1_10	SWC_2_10	SWC_3_10	SWC_4_10
+01/01/2001	01:00	45	      35	      37	      49
+01/01/2001	02:00	45	      35	      37	      49
+
+
+```
+Il est possible d'enregistrer toutes les colonnes SWC_([0-9]*)_([0-9]*) dans une variable unique swc. 
+
+On declare cette variable dans la section data 
+
+```yaml
+      SWC:
+        components:
+          variable:
+            checker:
+              name: Reference
+              params:
+                refType: variables
+                required: true
+                codify: true
+          value:
+            checker:
+              name: Float
+              params:
+                required: false
+          unit:
+            defaultValue: return "percentage"
+            checker:
+              name: Reference
+              params:
+                refType: unites
+                required: true
+                codify: true
+          profondeur:
+            checker:
+              name: Float
+              params:
+                required: true
+          repetition:
+            checker:
+              name: Integer
+              params:
+                required: true
+
+```
+Dans la section format on rajoute une section _repeatedColumns_ pour indiquer comment remplir le data à partir du pattern
+```yaml
+    format:
+      ... 
+      repeatedColumns:
+        - headerPattern: "(SWC)_([0-9]+)_([0-9]+)"
+          tokens:
+            - boundTo:
+                variable: SWC
+                component: variable
+              exportHeader: "variable"
+            - boundTo:
+                variable: SWC
+                component: repetition
+              exportHeader: "Répétition"
+            - boundTo:
+                variable: SWC
+                component: profondeur
+              exportHeader: "Profondeur"
+          boundTo:
+            variable: SWC
+            component: valeur
+          exportHeader: "SWC"
+
+```
+On note la présence de la section token contenant un tableau de boundTo dans lequel le résultat des capture de l'expression régulière seront utilisés comme une colonne.
+token d'indice 0 -> $1
+token d'indice 1 -> $2
+
+ etc...
+
+Dans l'exemple le variable-component SWC-variable aura pour valeur SWC résultat de la première parenthèse.
+
+
+## Zip de YAML
+Il est possible au lieu de fournir un yaml, de fournir un fichier zip. Cela permet de découper les YAML long en plusieurs fichiers.
+
+Dans le zip le contenu de la section  <section><sous_section><sous_sous_section> sera placé dans un fichier sous_sous_section.yaml que l'on placera dans le dossier sous_section du dossier section.
+
+Au premier niveau il est possible de placer un fichier configuration.yaml qui servira de base à la génération du yaml.
+A défaut de se fichier on utilisera comme base 
+```yaml
+version: 0
+```
+
+voici un example du contenu du zip :
+
+``` html
+multiyaml.zip
+├── application.yaml
+├── compositeReferences.yaml
+├── configuration.yaml
+├── dataTypes
+│   ├── smp_infraj.yaml
+│   └── ts_infraj.yaml
+└── references
+    ├── types_de_zones_etudes.yaml
+
+```
+## lors de l'importation du fichier yaml :
+	
+* mettre le nom de l'application en minuscule,
+* sans espace,
+* sans accent,
+* sans chiffre et 
+* sans caractères speciaux
+# Aide fichier .csv 
+
+## lors de l'ouverture du fichier csv via libre office:
+
+<span style="color: red">* sélectionner le séparateur en ";"</span> 
+	
+## lors de la création du fichier csv de Référence et de donnée : 
+	
+* cocher lors de l'enregistrement du fichier 
+  * Éditer les paramètre du filtre
+  * Sélectionner le point virgule
+* dans les données qui se trouvent dans les colonnes contenant des clés naturelles on attend :
+    * pas d'accents
+    * pas de majuscules
+    * pas de caratères spéciaux () , - : 
+    * autorisé les _ et les .
+* le nom des colonnes doive être le plus court possible
+* le fichier doit être en UTF8 pour que les colonnes soient lisible (les caractères spéciaux ne passe pas sinon. ex : é, è, ç)
+
+## lors de l'importation de fichier csv dans l'application:
+
+* ouvrer la console avec F12 dans votre navigateur pour voir l'erreur de téléversement (erreur serveur) plus en détail.
diff --git a/src/main/java/fr/inra/oresing/checker/CheckerFactory.java b/src/main/java/fr/inra/oresing/checker/CheckerFactory.java
index cce2221f5..627d5b92d 100644
--- a/src/main/java/fr/inra/oresing/checker/CheckerFactory.java
+++ b/src/main/java/fr/inra/oresing/checker/CheckerFactory.java
@@ -159,7 +159,10 @@ public class CheckerFactory {
             LineChecker lineChecker;
             Configuration.CheckerConfigurationDescription configurationDescription = checkerDescription.getParams();
             if (GroovyLineChecker.NAME.equals(checkerDescription.getName())) {
-                String expression = configurationDescription.getExpression();
+                String expression = Optional.of(configurationDescription)
+                        .map(Configuration.CheckerConfigurationDescription::getGroovy)
+                        .map(GroovyConfiguration::getExpression)
+                        .orElse(null);
                 lineChecker = GroovyLineChecker.forExpression(expression, app, repository.getRepository(app), configurationDescription);
                 checkersBuilder.add(lineChecker);
             } else {
diff --git a/src/main/java/fr/inra/oresing/checker/GroovyConfiguration.java b/src/main/java/fr/inra/oresing/checker/GroovyConfiguration.java
new file mode 100644
index 000000000..5fefa209c
--- /dev/null
+++ b/src/main/java/fr/inra/oresing/checker/GroovyConfiguration.java
@@ -0,0 +1,18 @@
+package fr.inra.oresing.checker;
+
+import fr.inra.oresing.model.IGroovyDataInjectionConfiguration;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+import java.util.LinkedList;
+import java.util.List;
+
+@Getter
+@Setter
+@ToString
+public class GroovyConfiguration implements IGroovyDataInjectionConfiguration {
+    String expression;
+    List<String> references = new LinkedList<>();
+    List<String> datatypes = new LinkedList<>();
+}
\ No newline at end of file
diff --git a/src/main/java/fr/inra/oresing/checker/GroovyLineChecker.java b/src/main/java/fr/inra/oresing/checker/GroovyLineChecker.java
index 8bdb02b76..901beb9de 100644
--- a/src/main/java/fr/inra/oresing/checker/GroovyLineChecker.java
+++ b/src/main/java/fr/inra/oresing/checker/GroovyLineChecker.java
@@ -42,57 +42,68 @@ public class GroovyLineChecker implements LineChecker<GroovyLineCheckerConfigura
     }
 
     public static ImmutableMap<String, Object> buildContext(Object datum, Application application, DecoratorConfiguration params, OreSiRepository.RepositoryForApplication repository) {
-        Optional<String> configurationReferences = Optional.of(params)
-                .map(DecoratorConfiguration::getReferences);
-        Optional<String> configurationDataTypes = Optional.empty();
+        List<String> configurationReferences = Optional.of(params)
+                .map(DecoratorConfiguration::getGroovy)
+                .map(GroovyConfiguration::getReferences)
+                .orElseGet(List::of);
+        List<String> configurationDataTypes = Optional.of(params)
+                .map(DecoratorConfiguration::getGroovy)
+                .map(GroovyConfiguration::getDatatypes)
+                .orElseGet(List::of);
         ImmutableMap<String, Object> context = buildContext(datum, application, repository, configurationReferences, configurationDataTypes);
         return context;
     }
 
     public static ImmutableMap<String, Object> buildContext(Object datum, Application application, Configuration.VariableComponentDescriptionConfiguration params, OreSiRepository.RepositoryForApplication repository) {
-        Optional<String> configurationReferences = Optional.of(params)
-                .map(Configuration.VariableComponentDescriptionConfiguration::getReferences);
-        Optional<String> configurationDataTypes = Optional.empty();
+        List<String> configurationReferences = Optional.of(params)
+                .map(Configuration.VariableComponentDescriptionConfiguration::getReferences)
+                .orElseGet(List::of);
+        ;
+        List<String> configurationDataTypes = Optional.of(params)
+                .map(Configuration.VariableComponentDescriptionConfiguration::getDatatypes)
+                .orElseGet(List::of);
+        ;
         ImmutableMap<String, Object> context = buildContext(datum, application, repository, configurationReferences, configurationDataTypes);
         return context;
     }
 
     public static ImmutableMap<String, Object> buildContext(Object datum, Application application, GroovyLineCheckerConfiguration params, OreSiRepository.RepositoryForApplication repository) {
-        Optional<String> configurationReferences = Optional.of(params)
-                .map(GroovyLineCheckerConfiguration::getReferences);
-        Optional<String> configurationDataTypes = Optional.of(params)
-                .map(GroovyLineCheckerConfiguration::getDatatypes);
+        List<String> configurationReferences = Optional.of(params)
+                .map(GroovyLineCheckerConfiguration::getGroovy)
+                .map(GroovyConfiguration::getReferences)
+                .orElseGet(List::of);
+        ;
+        List<String> configurationDataTypes = Optional.of(params)
+                .map(GroovyLineCheckerConfiguration::getGroovy)
+                .map(GroovyConfiguration::getDatatypes)
+                .orElseGet(List::of);
+        ;
+        ;
         ImmutableMap<String, Object> context = buildContext(datum, application, repository, configurationReferences, configurationDataTypes);
         return context;
     }
 
-    private static ImmutableMap<String, Object> buildContext(Object datum, Application application, OreSiRepository.RepositoryForApplication repository, Optional<String> configurationReferences, Optional<String> configurationDataTypes) {
+    private static ImmutableMap<String, Object> buildContext(Object datum, Application application, OreSiRepository.RepositoryForApplication repository, List<String> configurationReferences, List<String> configurationDataTypes) {
         Map<String, List<ReferenceValue>> references = new HashMap<>();
         Map<String, List<DataRow>> datatypes = new HashMap<>();
         Map<String, List<Map<String, String>>> referencesValues = new HashMap<>();
         Map<String, List<Map<String, Map<String, String>>>> datatypesValues = new HashMap<>();
         configurationReferences
-                .ifPresent(refs -> {
-                    Arrays.stream(refs.split(","))
-                            .forEach(ref -> {
-                                List<ReferenceValue> allByReferenceType = repository.referenceValue().findAllByReferenceType(ref);
-                                references.put(ref, allByReferenceType);
-                                allByReferenceType.stream()
-                                        .map(referenceValue -> referenceValue.getRefValues())
-                                        .forEach(values -> referencesValues.computeIfAbsent(ref, k->new LinkedList<>()).add(values));
-                            });
+                .forEach(ref -> {
+                    List<ReferenceValue> allByReferenceType = repository.referenceValue().findAllByReferenceType(ref);
+                    references.put(ref, allByReferenceType);
+                    allByReferenceType.stream()
+                            .map(referenceValue -> referenceValue.getRefValues())
+                            .forEach(values -> referencesValues.computeIfAbsent(ref, k -> new LinkedList<>()).add(values));
                 });
 
         configurationDataTypes
-                .ifPresent(datas -> {
-                    Arrays.stream(datas.split(","))
-                            .forEach(dataType -> {
-                                List<DataRow> allByDataType = repository.data().findAllByDataType(DownloadDatasetQuery.buildDownloadDatasetQuery(null, null, dataType, application));
-                                datatypes.put(dataType, allByDataType);
-                                allByDataType.stream()
-                                        .map(datatValues -> datatValues.getValues())
-                                        .forEach(dv -> datatypesValues.computeIfAbsent(dataType, k -> new LinkedList<>()).add(dv));
-                            });
+                .forEach(dataType -> {
+                    List<DataRow> allByDataType = repository.data().findAllByDataType(DownloadDatasetQuery.buildDownloadDatasetQuery(null, null, dataType, application));
+                    datatypes.put(dataType, allByDataType);
+                    allByDataType.stream()
+                            .map(datatValues -> datatValues.getValues())
+                            .forEach(dv -> datatypesValues.computeIfAbsent(dataType, k -> new LinkedList<>()).add(dv));
                 });
         ImmutableMap.Builder<String, Object> builder = ImmutableMap.builder();
         builder.put("datum", datum);
diff --git a/src/main/java/fr/inra/oresing/checker/GroovyLineCheckerConfiguration.java b/src/main/java/fr/inra/oresing/checker/GroovyLineCheckerConfiguration.java
index 6e6449feb..80637b920 100644
--- a/src/main/java/fr/inra/oresing/checker/GroovyLineCheckerConfiguration.java
+++ b/src/main/java/fr/inra/oresing/checker/GroovyLineCheckerConfiguration.java
@@ -8,17 +8,5 @@ public interface GroovyLineCheckerConfiguration extends LineCheckerConfiguration
     /**
      * L'expression groovy elle-même. Elle doit retourner un booléen.
      */
-    String getExpression();
-
-    /**
-     * Les référentiels qui devront être chargés puis injectés dans le contexte au moment de
-     * l'évaluation de l'expression {@link #getExpression()}
-     */
-    String getReferences();
-
-    /**
-     * Les types de données qui devront être chargées puis injectés dans le contexte au moment de
-     * l'évaluation de l'expression {@link #getExpression()}
-     */
-    String getDatatypes();
-}
+    GroovyConfiguration getGroovy();
+}
\ No newline at end of file
diff --git a/src/main/java/fr/inra/oresing/checker/decorators/DecoratorConfiguration.java b/src/main/java/fr/inra/oresing/checker/decorators/DecoratorConfiguration.java
index f725b6ecb..c7e3dc5f3 100644
--- a/src/main/java/fr/inra/oresing/checker/decorators/DecoratorConfiguration.java
+++ b/src/main/java/fr/inra/oresing/checker/decorators/DecoratorConfiguration.java
@@ -1,5 +1,7 @@
 package fr.inra.oresing.checker.decorators;
 
+import fr.inra.oresing.checker.GroovyConfiguration;
+
 /**
  * Configuration de la décoration d'une donnée.
  */
@@ -18,11 +20,5 @@ public interface DecoratorConfiguration {
     /**
      * Avant d'être vérifiée, la donnée doit être transformée en appliquant cette expression.
      */
-    String getGroovy();
-
-    /**
-     * Les référentiels qui devront être chargés puis injectés dans le contexte au moment de
-     * l'évaluation de l'expression {@link #getGroovy()}
-     */
-    String getReferences();
-}
+    GroovyConfiguration getGroovy();
+}
\ No newline at end of file
diff --git a/src/main/java/fr/inra/oresing/checker/decorators/GroovyDecorator.java b/src/main/java/fr/inra/oresing/checker/decorators/GroovyDecorator.java
index d32607aff..ee83cb47c 100644
--- a/src/main/java/fr/inra/oresing/checker/decorators/GroovyDecorator.java
+++ b/src/main/java/fr/inra/oresing/checker/decorators/GroovyDecorator.java
@@ -2,6 +2,7 @@ package fr.inra.oresing.checker.decorators;
 
 import com.google.common.collect.ImmutableMap;
 import fr.inra.oresing.checker.CheckerTarget;
+import fr.inra.oresing.checker.GroovyConfiguration;
 import fr.inra.oresing.checker.GroovyLineChecker;
 import fr.inra.oresing.groovy.StringGroovyExpression;
 import fr.inra.oresing.rest.DefaultValidationCheckResult;
@@ -12,13 +13,13 @@ import java.util.Map;
 public class GroovyDecorator implements ICheckerDecorator {
 
     public ValidationCheckResult check(Map<? extends Object, String> values, String value, DecoratorConfiguration params, CheckerTarget target) throws DecoratorException {
-        String groovy = params.getGroovy();
+        GroovyConfiguration groovy = params.getGroovy();
         String valueAfterDecoration;
         if (groovy == null) {
             valueAfterDecoration = value;
         } else {
             ImmutableMap<String, Object> context = GroovyLineChecker.buildContext(values, target.getApplication(), params, target.getRepository());
-            StringGroovyExpression groovyExpression = StringGroovyExpression.forExpression(groovy);
+            StringGroovyExpression groovyExpression = StringGroovyExpression.forExpression(groovy.getExpression());
             valueAfterDecoration = groovyExpression.evaluate(context);
         }
         return DefaultValidationCheckResult.warn(valueAfterDecoration, null);
diff --git a/src/main/java/fr/inra/oresing/model/Configuration.java b/src/main/java/fr/inra/oresing/model/Configuration.java
index e10a26621..110ccb158 100644
--- a/src/main/java/fr/inra/oresing/model/Configuration.java
+++ b/src/main/java/fr/inra/oresing/model/Configuration.java
@@ -1,12 +1,7 @@
 package fr.inra.oresing.model;
 
 import com.google.common.collect.MoreCollectors;
-import fr.inra.oresing.checker.DateLineCheckerConfiguration;
-import fr.inra.oresing.checker.FloatCheckerConfiguration;
-import fr.inra.oresing.checker.GroovyLineCheckerConfiguration;
-import fr.inra.oresing.checker.IntegerCheckerConfiguration;
-import fr.inra.oresing.checker.ReferenceLineCheckerConfiguration;
-import fr.inra.oresing.checker.RegularExpressionCheckerConfiguration;
+import fr.inra.oresing.checker.*;
 import fr.inra.oresing.model.internationalization.Internationalization;
 import fr.inra.oresing.model.internationalization.InternationalizationMap;
 import lombok.Getter;
@@ -222,9 +217,11 @@ public class Configuration {
     @Getter
     @Setter
     @ToString
-    public static class VariableComponentDescriptionConfiguration {
-        String references; // à remplacer par une collection car split(',')
+    public static class VariableComponentDescriptionConfiguration implements IGroovyDataInjectionConfiguration {
+        List<String> references;
+        List<String> datatypes;
         boolean replace;
+
     }
 
     @Getter
@@ -247,13 +244,10 @@ public class Configuration {
             GroovyLineCheckerConfiguration {
         String pattern;
         String refType;
-        String expression;
+        GroovyConfiguration groovy;
         String columns;
         String variableComponentKey;
-        String references; // à remplacer par une collection car split(',')
-        String datatypes;
         String duration;
-        String groovy;
         boolean codify;
         boolean required;
     }
diff --git a/src/main/java/fr/inra/oresing/model/IGroovyDataInjectionConfiguration.java b/src/main/java/fr/inra/oresing/model/IGroovyDataInjectionConfiguration.java
new file mode 100644
index 000000000..feefd5c32
--- /dev/null
+++ b/src/main/java/fr/inra/oresing/model/IGroovyDataInjectionConfiguration.java
@@ -0,0 +1,8 @@
+package fr.inra.oresing.model;
+
+import java.util.List;
+
+public interface IGroovyDataInjectionConfiguration {
+    List<String> getReferences();
+    List<String> getDatatypes();
+}
\ No newline at end of file
diff --git a/src/main/java/fr/inra/oresing/rest/ApplicationConfigurationService.java b/src/main/java/fr/inra/oresing/rest/ApplicationConfigurationService.java
index 6d54d0018..6d02b79f0 100644
--- a/src/main/java/fr/inra/oresing/rest/ApplicationConfigurationService.java
+++ b/src/main/java/fr/inra/oresing/rest/ApplicationConfigurationService.java
@@ -12,6 +12,7 @@ import com.google.common.collect.Multiset;
 import com.google.common.collect.Sets;
 import com.google.common.collect.TreeMultiset;
 import fr.inra.oresing.OreSiTechnicalException;
+import fr.inra.oresing.checker.GroovyConfiguration;
 import fr.inra.oresing.checker.GroovyLineChecker;
 import fr.inra.oresing.groovy.GroovyExpression;
 import fr.inra.oresing.model.Configuration;
@@ -428,7 +429,11 @@ public class ApplicationConfigurationService {
             String lineValidationRuleKey = validationEntry.getKey();
             Configuration.CheckerDescription checker = lineValidationRuleDescription.getChecker();
             if (GroovyLineChecker.NAME.equals(checker.getName())) {
-                String expression = checker.getParams().getExpression();
+                String expression = Optional.of(checker)
+                        .map(Configuration.CheckerDescription::getParams)
+                        .map(Configuration.CheckerConfigurationDescription::getGroovy)
+                        .map(GroovyConfiguration::getExpression)
+                        .orElse(null);
                 if (StringUtils.isBlank(expression)) {
                     builder.recordMissingRequiredExpression(lineValidationRuleKey);
                 } else {
@@ -618,7 +623,11 @@ public class ApplicationConfigurationService {
                     .orElse(Set.of());
 
             if (GroovyLineChecker.NAME.equals(checker.getName())) {
-                String expression = checker.getParams().getExpression();
+                String expression =Optional.of(checker)
+                        .map(Configuration.CheckerDescription::getParams)
+                        .map(Configuration.CheckerConfigurationDescription::getGroovy)
+                        .map(GroovyConfiguration::getExpression)
+                        .orElse(null);
                 if (StringUtils.isBlank(expression)) {
                     builder.recordMissingRequiredExpression(validationRuleDescriptionEntryKey);
                 } else {
diff --git a/src/test/java/fr/inra/oresing/checker/GroovyLineCheckerTest.java b/src/test/java/fr/inra/oresing/checker/GroovyLineCheckerTest.java
index 3d0939d7f..9d976f8ea 100644
--- a/src/test/java/fr/inra/oresing/checker/GroovyLineCheckerTest.java
+++ b/src/test/java/fr/inra/oresing/checker/GroovyLineCheckerTest.java
@@ -12,6 +12,7 @@ import org.junit.Assert;
 import org.junit.Test;
 import org.mockito.Mockito;
 
+import java.util.List;
 import java.util.Optional;
 
 @Slf4j
@@ -101,20 +102,6 @@ public class GroovyLineCheckerTest {
 
     private GroovyLineCheckerConfiguration getConfiguration(String expression) {
         return new GroovyLineCheckerConfiguration() {
-            @Override
-            public String getExpression() {
-                return expression;
-            }
-
-            @Override
-            public String getReferences() {
-                return null;
-            }
-
-            @Override
-            public String getDatatypes() {
-                return null;
-            }
 
             @Override
             public boolean isCodify() {
@@ -127,8 +114,23 @@ public class GroovyLineCheckerTest {
             }
 
             @Override
-            public String getGroovy() {
-                throw new UnsupportedOperationException("doublure de test");
+            public GroovyConfiguration getGroovy() {
+                return new GroovyConfiguration() {
+                    @Override
+                    public String getExpression() {
+                        return expression;
+                    }
+
+                    @Override
+                    public List<String> getReferences() {
+                        return null;
+                    }
+
+                    @Override
+                    public List<String> getDatatypes() {
+                        return null;
+                    }
+                };
             }
         };
     }
diff --git a/src/test/java/fr/inra/oresing/model/LocalDateTimeRangeTest.java b/src/test/java/fr/inra/oresing/model/LocalDateTimeRangeTest.java
index 59dcc4f80..9811413a8 100644
--- a/src/test/java/fr/inra/oresing/model/LocalDateTimeRangeTest.java
+++ b/src/test/java/fr/inra/oresing/model/LocalDateTimeRangeTest.java
@@ -2,6 +2,7 @@ package fr.inra.oresing.model;
 
 import fr.inra.oresing.checker.DateLineChecker;
 import fr.inra.oresing.checker.DateLineCheckerConfiguration;
+import fr.inra.oresing.checker.GroovyConfiguration;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -71,14 +72,9 @@ public class LocalDateTimeRangeTest {
             }
 
             @Override
-            public String getGroovy() {
+            public GroovyConfiguration getGroovy() {
                 throw new UnsupportedOperationException("doublure de test");
             }
-
-            @Override
-            public String getReferences() {
-                throw new UnsupportedOperationException("doublure de test");
-            }
-        };
+};
     }
 }
\ No newline at end of file
diff --git a/src/test/resources/data/acbb/acbb.yaml b/src/test/resources/data/acbb/acbb.yaml
index 50552a244..7b6cd1195 100644
--- a/src/test/resources/data/acbb/acbb.yaml
+++ b/src/test/resources/data/acbb/acbb.yaml
@@ -1482,7 +1482,8 @@ dataTypes:
         checker:
           name: GroovyExpression
           params:
-            expression: "Set.of(\"\", \"0\", \"1\", \"2\").contains(datum.get(\"SWC\").get(\"qualité\"))"
+            groovy:
+              expression: "Set.of(\"\", \"0\", \"1\", \"2\").contains(datum.get(\"SWC\").get(\"qualité\"))"
     format:
       headerLine: 7
       firstRowLine: 10
diff --git a/src/test/resources/data/foret/foret_essai.yaml b/src/test/resources/data/foret/foret_essai.yaml
index 6036939a2..63a6a183c 100644
--- a/src/test/resources/data/foret/foret_essai.yaml
+++ b/src/test/resources/data/foret/foret_essai.yaml
@@ -364,16 +364,18 @@ references:
           params:
             refType: theme_types_de_donnees_par_zone_etudes
             columns: theme_types_de_donnees_par_zone_etudes
-            groovy: >
-              String[] tab = datum.get("Nom du Thème-Type de
-              données-Variable").split("-"); String site = tab[0].strip();
-              String theme = tab[1].strip(); String datatype = tab[2].strip();
-              return references["theme_types_de_donnees_par_zone_etudes"]
-              .findAll {it.refValues["nom du site"].equals(site)} .findAll
-              {it.refValues["nom du thème"].equals(theme)} .find
-              {it.refValues["nom du type de données"].equals(datatype)}
-              .naturalKey
-            references: theme_types_de_donnees_par_zone_etudes
+            groovy:
+              expression: >
+                String[] tab = datum.get("Nom du Thème-Type de
+                données-Variable").split("-"); String site = tab[0].strip();
+                String theme = tab[1].strip(); String datatype = tab[2].strip();
+                return references["theme_types_de_donnees_par_zone_etudes"]
+                .findAll {it.refValues["nom du site"].equals(site)} .findAll
+                {it.refValues["nom du thème"].equals(theme)} .find
+                {it.refValues["nom du type de données"].equals(datatype)}
+                .naturalKey
+              references:
+                - theme_types_de_donnees_par_zone_etudes
       checkDataypeVariableUnite:
         description: référence au DataypeVariableUnite
         checker:
@@ -382,18 +384,20 @@ references:
             refType: variables_par_types_de_donnees
             columns: variables_par_types_de_donnees
             required: true
-            groovy: >
-              String[] tab = datum.get("Nom du Thème-Type de
-              données-Variable").split("-"); String datatype =
-              fr.inra.oresing.rest.OreSiService.escapeKeyComponent(
-              tab[2].strip()); String variable =
-              fr.inra.oresing.rest.OreSiService.escapeKeyComponent(
-              tab[3].strip()); return
-              references.find{it.key.equals("variables_par_types_de_donnees")}.value
-                      .findAll {it.refValues["nom de la variable"].equals(variable)}
-                      .find {it.refValues["nom du type de données"].equals(datatype)}
-                .naturalKey
-            references: variables_par_types_de_donnees
+            groovy:
+              expression: >
+                String[] tab = datum.get("Nom du Thème-Type de
+                données-Variable").split("-"); String datatype =
+                fr.inra.oresing.rest.OreSiService.escapeKeyComponent(
+                tab[2].strip()); String variable =
+                fr.inra.oresing.rest.OreSiService.escapeKeyComponent(
+                tab[3].strip()); return
+                references.find{it.key.equals("variables_par_types_de_donnees")}.value
+                        .findAll {it.refValues["nom de la variable"].equals(variable)}
+                        .find {it.refValues["nom du type de données"].equals(datatype)}
+                  .naturalKey
+              references:
+                - variables_par_types_de_donnees
             codify: true
       date début:
         description: date de début
@@ -497,16 +501,18 @@ references:
           params:
             refType: theme_types_de_donnees_par_zone_etudes
             columns: theme_types_de_donnees_par_zone_etudes
-            groovy: >
-              String[] tab = datum.get("Nom du Thème-Type de
-              données-Variable").split("-"); String site = tab[0].strip();
-              String theme = tab[1].strip(); String datatype = tab[2].strip();
-              return references["theme_types_de_donnees_par_zone_etudes"]
-              .findAll {it.refValues["nom du site"].equals(site)} .findAll
-              {it.refValues["nom du thème"].equals(theme)} .find
-              {it.refValues["nom du type de données"].equals(datatype)}
-              .naturalKey
-            references: theme_types_de_donnees_par_zone_etudes
+            groovy:
+              expression: >
+                String[] tab = datum.get("Nom du Thème-Type de
+                données-Variable").split("-"); String site = tab[0].strip();
+                String theme = tab[1].strip(); String datatype = tab[2].strip();
+                return references["theme_types_de_donnees_par_zone_etudes"]
+                .findAll {it.refValues["nom du site"].equals(site)} .findAll
+                {it.refValues["nom du thème"].equals(theme)} .find
+                {it.refValues["nom du type de données"].equals(datatype)}
+                .naturalKey
+              references:
+                - theme_types_de_donnees_par_zone_etudes
       checkDataypeVariableUnite:
         description: référence au DataypeVariableUnite
         checker:
@@ -515,18 +521,20 @@ references:
             refType: variables_par_types_de_donnees
             columns: variables_par_types_de_donnees
             required: true
-            groovy: >
-              String[] tab = datum.get("Nom du Thème-Type de
-              données-Variable").split("-"); String datatype =
-              fr.inra.oresing.rest.OreSiService.escapeKeyComponent(
-              tab[2].strip()); String variable =
-              fr.inra.oresing.rest.OreSiService.escapeKeyComponent(
-              tab[3].strip()); return
-              references.find{it.key.equals("variables_par_types_de_donnees")}.value
-                      .findAll {it.refValues["nom de la variable"].equals(variable)}
-                      .find {it.refValues["nom du type de données"].equals(datatype)}
-                .naturalKey
-            references: variables_par_types_de_donnees
+            groovy:
+              expression: >
+                String[] tab = datum.get("Nom du Thème-Type de
+                données-Variable").split("-"); String datatype =
+                fr.inra.oresing.rest.OreSiService.escapeKeyComponent(
+                tab[2].strip()); String variable =
+                fr.inra.oresing.rest.OreSiService.escapeKeyComponent(
+                tab[3].strip()); return
+                references.find{it.key.equals("variables_par_types_de_donnees")}.value
+                        .findAll {it.refValues["nom de la variable"].equals(variable)}
+                        .find {it.refValues["nom du type de données"].equals(datatype)}
+                  .naturalKey
+              references:
+                - variables_par_types_de_donnees
             codify: true
       date début:
         description: date de début
@@ -621,16 +629,18 @@ references:
           params:
             refType: theme_types_de_donnees_par_zone_etudes
             columns: theme_types_de_donnees_par_zone_etudes
-            groovy: >
-              String[] tab = datum.get("Nom du Thème-Type de
-              données-Variable").split("-"); String site = tab[0].strip();
-              String theme = tab[1].strip(); String datatype = tab[2].strip();
-              return references["theme_types_de_donnees_par_zone_etudes"]
-              .findAll {it.refValues["nom du site"].equals(site)} .findAll
-              {it.refValues["nom du thème"].equals(theme)} .find
-              {it.refValues["nom du type de données"].equals(datatype)}
-              .naturalKey
-            references: theme_types_de_donnees_par_zone_etudes
+            groovy:
+              expression: >
+                String[] tab = datum.get("Nom du Thème-Type de
+                données-Variable").split("-"); String site = tab[0].strip();
+                String theme = tab[1].strip(); String datatype = tab[2].strip();
+                return references["theme_types_de_donnees_par_zone_etudes"]
+                .findAll {it.refValues["nom du site"].equals(site)} .findAll
+                {it.refValues["nom du thème"].equals(theme)} .find
+                {it.refValues["nom du type de données"].equals(datatype)}
+                .naturalKey
+              references:
+                - theme_types_de_donnees_par_zone_etudes
       checkDataypeVariableUnite:
         description: référence au DataypeVariableUnite
         checker:
@@ -639,18 +649,20 @@ references:
             refType: variables_par_types_de_donnees
             columns: variables_par_types_de_donnees
             required: true
-            groovy: >
-              String[] tab = datum.get("Nom du Thème-Type de
-              données-Variable").split("-"); String datatype =
-              fr.inra.oresing.rest.OreSiService.escapeKeyComponent(
-              tab[2].strip()); String variable =
-              fr.inra.oresing.rest.OreSiService.escapeKeyComponent(
-              tab[3].strip()); return
-              references.find{it.key.equals("variables_par_types_de_donnees")}.value
-                      .findAll {it.refValues["nom de la variable"].equals(variable)}
-                      .find {it.refValues["nom du type de données"].equals(datatype)}
-                .naturalKey
-            references: variables_par_types_de_donnees
+            groovy:
+              expression: >
+                String[] tab = datum.get("Nom du Thème-Type de
+                données-Variable").split("-"); String datatype =
+                fr.inra.oresing.rest.OreSiService.escapeKeyComponent(
+                tab[2].strip()); String variable =
+                fr.inra.oresing.rest.OreSiService.escapeKeyComponent(
+                tab[3].strip()); return
+                references.find{it.key.equals("variables_par_types_de_donnees")}.value
+                        .findAll {it.refValues["nom de la variable"].equals(variable)}
+                        .find {it.refValues["nom du type de données"].equals(datatype)}
+                  .naturalKey
+              references:
+                - variables_par_types_de_donnees
             codify: true
     internationalizationName:
       fr: >-
@@ -730,22 +742,24 @@ dataTypes:
             checker:
               name: Reference
               params:
-                groovy: >
-                  String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
-                  String nom = datumByVariableAndComponent.localization.zones_etudes;
-                  String hierarchicalKey = ""; 
-                  if ("".equals(nom)){
-                    hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
-                  }else{
-                    parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
-                    nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
-                    hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
-                  }
-                  
-                  return references
-                  .find{it.key.equals("zones_etudes")}.value
-                  .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
-                references: zones_etudes
+                groovy:
+                  expression: >
+                    String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
+                    String nom = datumByVariableAndComponent.localization.zones_etudes;
+                    String hierarchicalKey = ""; 
+                    if ("".equals(nom)){
+                      hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
+                    }else{
+                      parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
+                      nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
+                      hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
+                    }
+                    
+                    return references
+                    .find{it.key.equals("zones_etudes")}.value
+                    .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
+                  references:
+                    - zones_etudes
                 codify: true
                 refType: zones_etudes
                 required: true
@@ -963,22 +977,24 @@ dataTypes:
             checker:
               name: Reference
               params:
-                groovy: >
-                  String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
-                  String nom = datumByVariableAndComponent.localization.zones_etudes;
-                  String hierarchicalKey = ""; 
-                  if ("".equals(nom)){
-                    hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
-                  }else{
-                    parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
-                    nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
-                    hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
-                  }
-                  
-                  return references
-                  .find{it.key.equals("zones_etudes")}.value
-                  .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
-                references: zones_etudes
+                groovy:
+                  expression: >
+                    String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
+                    String nom = datumByVariableAndComponent.localization.zones_etudes;
+                    String hierarchicalKey = ""; 
+                    if ("".equals(nom)){
+                      hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
+                    }else{
+                      parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
+                      nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
+                      hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
+                    }
+                    
+                    return references
+                    .find{it.key.equals("zones_etudes")}.value
+                    .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
+                  references:
+                    - zones_etudes
                 codify: true
                 refType: zones_etudes
                 required: true
@@ -1196,22 +1212,24 @@ dataTypes:
             checker:
               name: Reference
               params:
-                groovy: >
-                  String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
-                  String nom = datumByVariableAndComponent.localization.zones_etudes;
-                  String hierarchicalKey = ""; 
-                  if ("".equals(nom)){
-                    hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
-                  }else{
-                    parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
-                    nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
-                    hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
-                  }
-                  
-                  return references
-                  .find{it.key.equals("zones_etudes")}.value
-                  .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
-                references: zones_etudes
+                groovy:
+                  expression: >
+                    String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
+                    String nom = datumByVariableAndComponent.localization.zones_etudes;
+                    String hierarchicalKey = ""; 
+                    if ("".equals(nom)){
+                      hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
+                    }else{
+                      parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
+                      nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
+                      hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
+                    }
+                    
+                    return references
+                    .find{it.key.equals("zones_etudes")}.value
+                    .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
+                  references:
+                    - zones_etudes
                 codify: true
                 refType: zones_etudes
                 required: true
@@ -1429,22 +1447,24 @@ dataTypes:
             checker:
               name: Reference
               params:
-                groovy: >
-                  String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
-                  String nom = datumByVariableAndComponent.localization.zones_etudes;
-                  String hierarchicalKey = ""; 
-                  if ("".equals(nom)){
-                    hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
-                  }else{
-                    parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
-                    nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
-                    hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
-                  }
-                  
-                  return references
-                  .find{it.key.equals("zones_etudes")}.value
-                  .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
-                references: zones_etudes
+                groovy:
+                  expression: >
+                    String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
+                    String nom = datumByVariableAndComponent.localization.zones_etudes;
+                    String hierarchicalKey = ""; 
+                    if ("".equals(nom)){
+                      hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
+                    }else{
+                      parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
+                      nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
+                      hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
+                    }
+                    
+                    return references
+                    .find{it.key.equals("zones_etudes")}.value
+                    .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
+                  references:
+                    - zones_etudes
                 codify: true
                 refType: zones_etudes
                 required: true
@@ -1662,22 +1682,24 @@ dataTypes:
             checker:
               name: Reference
               params:
-                groovy: >
-                  String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
-                  String nom = datumByVariableAndComponent.localization.zones_etudes;
-                  String hierarchicalKey = ""; 
-                  if ("".equals(nom)){
-                    hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
-                  }else{
-                    parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
-                    nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
-                    hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
-                  }
-                  
-                  return references
-                  .find{it.key.equals("zones_etudes")}.value
-                  .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
-                references: zones_etudes
+                groovy:
+                  expression: >
+                    String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
+                    String nom = datumByVariableAndComponent.localization.zones_etudes;
+                    String hierarchicalKey = ""; 
+                    if ("".equals(nom)){
+                      hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
+                    }else{
+                      parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
+                      nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
+                      hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
+                    }
+                    
+                    return references
+                    .find{it.key.equals("zones_etudes")}.value
+                    .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
+                  references:
+                    - zones_etudes
                 codify: true
                 refType: zones_etudes
                 required: true
@@ -1895,22 +1917,24 @@ dataTypes:
             checker:
               name: Reference
               params:
-                groovy: >
-                  String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
-                  String nom = datumByVariableAndComponent.localization.zones_etudes;
-                  String hierarchicalKey = ""; 
-                  if ("".equals(nom)){
-                    hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
-                  }else{
-                    parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
-                    nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
-                    hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
-                  }
-                  
-                  return references
-                  .find{it.key.equals("zones_etudes")}.value
-                  .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
-                references: zones_etudes
+                groovy:
+                  expression: >
+                    String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
+                    String nom = datumByVariableAndComponent.localization.zones_etudes;
+                    String hierarchicalKey = ""; 
+                    if ("".equals(nom)){
+                      hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
+                    }else{
+                      parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
+                      nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
+                      hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
+                    }
+                    
+                    return references
+                    .find{it.key.equals("zones_etudes")}.value
+                    .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
+                  references:
+                    - zones_etudes
                 codify: true
                 refType: zones_etudes
                 required: true
@@ -2111,22 +2135,24 @@ dataTypes:
             checker:
               name: Reference
               params:
-                groovy: >
-                  String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
-                  String nom = datumByVariableAndComponent.localization.zones_etudes;
-                  String hierarchicalKey = ""; 
-                  if ("".equals(nom)){
-                    hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
-                  }else{
-                    parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
-                    nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
-                    hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
-                  }
-                  
-                  return references
-                  .find{it.key.equals("zones_etudes")}.value
-                  .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
-                references: zones_etudes
+                groovy:
+                  expression: >
+                    String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
+                    String nom = datumByVariableAndComponent.localization.zones_etudes;
+                    String hierarchicalKey = ""; 
+                    if ("".equals(nom)){
+                      hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
+                    }else{
+                      parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
+                      nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
+                      hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
+                    }
+                    
+                    return references
+                    .find{it.key.equals("zones_etudes")}.value
+                    .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
+                  references:
+                    - zones_etudes
                 codify: true
                 refType: zones_etudes
                 required: true
@@ -2327,22 +2353,24 @@ dataTypes:
             checker:
               name: Reference
               params:
-                groovy: >
-                  String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
-                  String nom = datumByVariableAndComponent.localization.zones_etudes;
-                  String hierarchicalKey = ""; 
-                  if ("".equals(nom)){
-                    hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
-                  }else{
-                    parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
-                    nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
-                    hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
-                  }
-                  
-                  return references
-                  .find{it.key.equals("zones_etudes")}.value
-                  .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
-                references: zones_etudes
+                groovy:
+                  expression: >
+                    String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
+                    String nom = datumByVariableAndComponent.localization.zones_etudes;
+                    String hierarchicalKey = ""; 
+                    if ("".equals(nom)){
+                      hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
+                    }else{
+                      parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
+                      nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
+                      hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
+                    }
+                    
+                    return references
+                    .find{it.key.equals("zones_etudes")}.value
+                    .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
+                  references:
+                    - zones_etudes
                 codify: true
                 refType: zones_etudes
                 required: true
@@ -2543,22 +2571,24 @@ dataTypes:
             checker:
               name: Reference
               params:
-                groovy: >
-                  String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
-                  String nom = datumByVariableAndComponent.localization.zones_etudes;
-                  String hierarchicalKey = ""; 
-                  if ("".equals(nom)){
-                    hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
-                  }else{
-                    parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
-                    nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
-                    hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
-                  }
-                  
-                  return references
-                  .find{it.key.equals("zones_etudes")}.value
-                  .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
-                references: zones_etudes
+                groovy:
+                  expression: >
+                    String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
+                    String nom = datumByVariableAndComponent.localization.zones_etudes;
+                    String hierarchicalKey = ""; 
+                    if ("".equals(nom)){
+                      hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
+                    }else{
+                      parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
+                      nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
+                      hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
+                    }
+                    
+                    return references
+                    .find{it.key.equals("zones_etudes")}.value
+                    .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
+                  references:
+                    - zones_etudes
                 codify: true
                 refType: zones_etudes
                 required: true
@@ -2759,22 +2789,24 @@ dataTypes:
             checker:
               name: Reference
               params:
-                groovy: >
-                  String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
-                  String nom = datumByVariableAndComponent.localization.zones_etudes;
-                  String hierarchicalKey = ""; 
-                  if ("".equals(nom)){
-                    hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
-                  }else{
-                    parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
-                    nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
-                    hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
-                  }
-                  
-                  return references
-                  .find{it.key.equals("zones_etudes")}.value
-                  .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
-                references: zones_etudes
+                groovy:
+                  expression: >
+                    String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
+                    String nom = datumByVariableAndComponent.localization.zones_etudes;
+                    String hierarchicalKey = ""; 
+                    if ("".equals(nom)){
+                      hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
+                    }else{
+                      parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
+                      nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
+                      hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
+                    }
+                    
+                    return references
+                    .find{it.key.equals("zones_etudes")}.value
+                    .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
+                  references:
+                    - zones_etudes
                 codify: true
                 refType: zones_etudes
                 required: true
@@ -2976,22 +3008,24 @@ dataTypes:
             checker:
               name: Reference
               params:
-                groovy: >
-                  String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
-                  String nom = datumByVariableAndComponent.localization.zones_etudes;
-                  String hierarchicalKey = ""; 
-                  if ("".equals(nom)){
-                    hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
-                  }else{
-                    parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
-                    nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
-                    hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
-                  }
-                  
-                  return references
-                  .find{it.key.equals("zones_etudes")}.value
-                  .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
-                references: zones_etudes
+                groovy:
+                  expression: >
+                    String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
+                    String nom = datumByVariableAndComponent.localization.zones_etudes;
+                    String hierarchicalKey = ""; 
+                    if ("".equals(nom)){
+                      hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
+                    }else{
+                      parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
+                      nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
+                      hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
+                    }
+                    
+                    return references
+                    .find{it.key.equals("zones_etudes")}.value
+                    .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
+                  references:
+                    - zones_etudes
                 codify: true
                 refType: zones_etudes
                 required: true
@@ -3220,22 +3254,24 @@ dataTypes:
             checker:
               name: Reference
               params:
-                groovy: >
-                  String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
-                  String nom = datumByVariableAndComponent.localization.zones_etudes;
-                  String hierarchicalKey = ""; 
-                  if ("".equals(nom)){
-                    hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
-                  }else{
-                    parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
-                    nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
-                    hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
-                  }
-                  
-                  return references
-                  .find{it.key.equals("zones_etudes")}.value
-                  .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
-                references: zones_etudes
+                groovy:
+                  expression: >
+                    String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
+                    String nom = datumByVariableAndComponent.localization.zones_etudes;
+                    String hierarchicalKey = ""; 
+                    if ("".equals(nom)){
+                      hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
+                    }else{
+                      parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
+                      nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
+                      hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
+                    }
+                    
+                    return references
+                    .find{it.key.equals("zones_etudes")}.value
+                    .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
+                  references:
+                    - zones_etudes
                 codify: true
                 refType: zones_etudes
                 required: true
@@ -3466,22 +3502,24 @@ dataTypes:
             checker:
               name: Reference
               params:
-                groovy: >
-                  String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
-                  String nom = datumByVariableAndComponent.localization.zones_etudes;
-                  String hierarchicalKey = ""; 
-                  if ("".equals(nom)){
-                    hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
-                  }else{
-                    parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
-                    nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
-                    hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
-                  }
-                  
-                  return references
-                  .find{it.key.equals("zones_etudes")}.value
-                  .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
-                references: zones_etudes
+                groovy:
+                  expression: >
+                    String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
+                    String nom = datumByVariableAndComponent.localization.zones_etudes;
+                    String hierarchicalKey = ""; 
+                    if ("".equals(nom)){
+                      hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
+                    }else{
+                      parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
+                      nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
+                      hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
+                    }
+                    
+                    return references
+                    .find{it.key.equals("zones_etudes")}.value
+                    .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
+                  references:
+                    - zones_etudes
                 codify: true
                 refType: zones_etudes
                 required: true
@@ -3679,22 +3717,24 @@ dataTypes:
             checker:
               name: Reference
               params:
-                groovy: >
-                  String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
-                  String nom = datumByVariableAndComponent.localization.zones_etudes;
-                  String hierarchicalKey = ""; 
-                  if ("".equals(nom)){
-                    hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
-                  }else{
-                    parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
-                    nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
-                    hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
-                  }
-                  
-                  return references
-                  .find{it.key.equals("zones_etudes")}.value
-                  .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
-                references: zones_etudes
+                groovy:
+                  expression: >
+                    String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
+                    String nom = datumByVariableAndComponent.localization.zones_etudes;
+                    String hierarchicalKey = ""; 
+                    if ("".equals(nom)){
+                      hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
+                    }else{
+                      parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
+                      nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
+                      hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
+                    }
+                    
+                    return references
+                    .find{it.key.equals("zones_etudes")}.value
+                    .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
+                  references:
+                    -  zones_etudes
                 codify: true
                 refType: zones_etudes
                 required: true
@@ -4166,22 +4206,24 @@ dataTypes:
             checker:
               name: Reference
               params:
-                groovy: >
-                  String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
-                  String nom = datumByVariableAndComponent.localization.zones_etudes;
-                  String hierarchicalKey = ""; 
-                  if ("".equals(nom)){
-                    hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
-                  }else{
-                    parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
-                    nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
-                    hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
-                  }
-                  
-                  return references
-                  .find{it.key.equals("zones_etudes")}.value
-                  .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
-                references: zones_etudes
+                groovy:
+                  expression: >
+                    String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
+                    String nom = datumByVariableAndComponent.localization.zones_etudes;
+                    String hierarchicalKey = ""; 
+                    if ("".equals(nom)){
+                      hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
+                    }else{
+                      parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
+                      nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
+                      hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
+                    }
+                    
+                    return references
+                    .find{it.key.equals("zones_etudes")}.value
+                    .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
+                  references:
+                    - zones_etudes
                 codify: true
                 refType: zones_etudes
                 required: true
@@ -4592,22 +4634,24 @@ dataTypes:
             checker:
               name: Reference
               params:
-                groovy: >
-                  String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
-                  String nom = datumByVariableAndComponent.localization.zones_etudes;
-                  String hierarchicalKey = ""; 
-                  if ("".equals(nom)){
-                    hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
-                  }else{
-                    parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
-                    nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
-                    hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
-                  }
-                  
-                  return references
-                  .find{it.key.equals("zones_etudes")}.value
-                  .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
-                references: zones_etudes
+                groovy:
+                  expression: >
+                    String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
+                    String nom = datumByVariableAndComponent.localization.zones_etudes;
+                    String hierarchicalKey = ""; 
+                    if ("".equals(nom)){
+                      hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
+                    }else{
+                      parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
+                      nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
+                      hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
+                    }
+                    
+                    return references
+                    .find{it.key.equals("zones_etudes")}.value
+                    .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
+                  references:
+                    - zones_etudes
                 codify: true
                 refType: zones_etudes
                 required: true
@@ -5024,22 +5068,24 @@ dataTypes:
             checker:
               name: Reference
               params:
-                groovy: >
-                  String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
-                  String nom = datumByVariableAndComponent.localization.zones_etudes;
-                  String hierarchicalKey = ""; 
-                  if ("".equals(nom)){
-                    hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
-                  }else{
-                    parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
-                    nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
-                    hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
-                  }
-                  
-                  return references
-                  .find{it.key.equals("zones_etudes")}.value
-                  .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
-                references: zones_etudes
+                groovy:
+                  expression: >
+                    String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
+                    String nom = datumByVariableAndComponent.localization.zones_etudes;
+                    String hierarchicalKey = ""; 
+                    if ("".equals(nom)){
+                      hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
+                    }else{
+                      parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
+                      nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
+                      hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
+                    }
+                    
+                    return references
+                    .find{it.key.equals("zones_etudes")}.value
+                    .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
+                  references:
+                    - zones_etudes
                 codify: true
                 refType: zones_etudes
                 required: true
@@ -5587,22 +5633,24 @@ dataTypes:
             checker:
               name: Reference
               params:
-                groovy: >
-                  String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
-                  String nom = datumByVariableAndComponent.localization.zones_etudes;
-                  String hierarchicalKey = ""; 
-                  if ("".equals(nom)){
-                    hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
-                  }else{
-                    parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
-                    nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
-                    hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
-                  }
-                  
-                  return references
-                  .find{it.key.equals("zones_etudes")}.value
-                  .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
-                references: zones_etudes
+                groovy:
+                  expression: >
+                    String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
+                    String nom = datumByVariableAndComponent.localization.zones_etudes;
+                    String hierarchicalKey = ""; 
+                    if ("".equals(nom)){
+                      hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
+                    }else{
+                      parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
+                      nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
+                      hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
+                    }
+                    
+                    return references
+                    .find{it.key.equals("zones_etudes")}.value
+                    .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
+                  references:
+                    - zones_etudes
                 codify: true
                 refType: zones_etudes
                 required: true
@@ -6133,22 +6181,24 @@ dataTypes:
             checker:
               name: Reference
               params:
-                groovy: >
-                  String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
-                  String nom = datumByVariableAndComponent.localization.zones_etudes;
-                  String hierarchicalKey = ""; 
-                  if ("".equals(nom)){
-                    hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
-                  }else{
-                    parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
-                    nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
-                    hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
-                  }
-                  
-                  return references
-                  .find{it.key.equals("zones_etudes")}.value
-                  .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
-                references: zones_etudes
+                groovy:
+                  expression: >
+                    String parent = datumByVariableAndComponent.localization.zones_etudes_parent;
+                    String nom = datumByVariableAndComponent.localization.zones_etudes;
+                    String hierarchicalKey = ""; 
+                    if ("".equals(nom)){
+                      hierarchicalKey = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent);
+                    }else{
+                      parent = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(parent)
+                      nom = fr.inra.oresing.rest.OreSiService.escapeKeyComponent(nom)
+                      hierarchicalKey = String.format("%s.%s__%s", parent, parent, nom)
+                    }
+                    
+                    return references
+                    .find{it.key.equals("zones_etudes")}.value
+                    .find {it.hierarchicalKey.equals(hierarchicalKey)} .hierarchicalKey
+                  references:
+                    - zones_etudes
                 codify: true
                 refType: zones_etudes
                 required: true
@@ -6614,4 +6664,4 @@ dataTypes:
         - header: WS
           boundTo:
             variable: WS
-            component: value
+            component: value
\ No newline at end of file
diff --git a/src/test/resources/data/monsore/monsore-with-repository.yaml b/src/test/resources/data/monsore/monsore-with-repository.yaml
index 892ffbb53..20e911205 100644
--- a/src/test/resources/data/monsore/monsore-with-repository.yaml
+++ b/src/test/resources/data/monsore/monsore-with-repository.yaml
@@ -205,9 +205,10 @@ references:
         checker:
           name: GroovyExpression
           params:
-            expression: >
-              String datatype = Arrays.stream(datum.get("nom du type de données").split("_")).collect{it.substring(0, 1)}.join();
-              return application.getDataType().contains(datatype);
+            groovy:
+              expression: >
+                String datatype = Arrays.stream(datum.get("nom du type de données").split("_")).collect{it.substring(0, 1)}.join();
+                return application.getDataType().contains(datatype);
     keyColumns: ["nom du projet","nom du site","nom du thème","nom du type de données" ]
     columns:
       nom du projet:
@@ -308,9 +309,10 @@ references:
         checker:
           name: GroovyExpression
           params:
-            expression: >
-              String datatype = Arrays.stream(datum.get("nom du type de données").split("_")).collect{it.substring(0, 1)}.join();
-              return application.getDataType().contains(datatype);
+            groovy:
+              expression: >
+                String datatype = Arrays.stream(datum.get("nom du type de données").split("_")).collect{it.substring(0, 1)}.join();
+                return application.getDataType().contains(datatype);
     keyColumns: [nom du type de données,nom de la variable]
     internationalizationName:
       fr: Variables et unités par type de données
@@ -348,7 +350,8 @@ dataTypes:
         components:
           bassin:
             params:
-              references: sites
+              references:
+                - sites
               replace: true
             defaultValue: >
               return references.get("sites")
@@ -361,7 +364,8 @@ dataTypes:
           plateforme:
           chemin:
             params:
-              references: sites
+              references:
+                -  sites
             defaultValue: >
               return references.get("sites")
               .find{it.getRefValues().get("zet_chemin_parent").equals(datumByVariableAndComponent.get("site").get("bassin")) && it.getRefValues().get("zet_nom_key").equals(datumByVariableAndComponent.get("site").get("plateforme"))}
@@ -420,31 +424,35 @@ dataTypes:
         checker:
           name: GroovyExpression
           params:
-            expression: >
-              String datatype = "piegeage_en_montee";
-              String variable = "Couleur des individus";
-              String codeVariable = "couleur_des_individus";
-              String component = "unit";
-              return referencesValues.get("variables_et_unites_par_types_de_donnees")
-              .findAll{it.get("nom du type de données").equals(datatype)}
-              .find{it.get("nom de la variable").equals(codeVariable)}
-              .get("nom de l'unité").equals(datum.get(variable).get(component));
-            references: variables_et_unites_par_types_de_donnees
+            groovy:
+              expression: >
+                String datatype = "piegeage_en_montee";
+                String variable = "Couleur des individus";
+                String codeVariable = "couleur_des_individus";
+                String component = "unit";
+                return referencesValues.get("variables_et_unites_par_types_de_donnees")
+                .findAll{it.get("nom du type de données").equals(datatype)}
+                .find{it.get("nom de la variable").equals(codeVariable)}
+                .get("nom de l'unité").equals(datum.get(variable).get(component));
+              references:
+                - variables_et_unites_par_types_de_donnees
       unitOfIndividus:
         description: "vérifie l'unité du nombre d'individus"
         checker:
           name: GroovyExpression
           params:
-            expression: >
-              String datatype = "piegeage_en_montee";
-              String variable = "Nombre d'individus";
-              String codeVariable = "nombre_d_individus";
-              String component = "unit";
-              return referencesValues.get("variables_et_unites_par_types_de_donnees")
-              .findAll{it.get("nom du type de données").equals(datatype)}
-              .find{it.get("nom de la variable").equals(codeVariable)}
-              .get("nom de l'unité").equals(datum.get(variable).get(component));
-            references: variables_et_unites_par_types_de_donnees
+            groovy:
+              expression: >
+                String datatype = "piegeage_en_montee";
+                String variable = "Nombre d'individus";
+                String codeVariable = "nombre_d_individus";
+                String component = "unit";
+                return referencesValues.get("variables_et_unites_par_types_de_donnees")
+                .findAll{it.get("nom du type de données").equals(datatype)}
+                .find{it.get("nom de la variable").equals(codeVariable)}
+                .get("nom de l'unité").equals(datum.get(variable).get(component));
+              references:
+                - variables_et_unites_par_types_de_donnees
     format:
       headerLine: 4
       firstRowLine: 5
diff --git a/src/test/resources/data/monsore/monsore.yaml b/src/test/resources/data/monsore/monsore.yaml
index bba2c8793..e82a39925 100644
--- a/src/test/resources/data/monsore/monsore.yaml
+++ b/src/test/resources/data/monsore/monsore.yaml
@@ -2,8 +2,8 @@ version: 0
 application:
   defaultLanguage: fr
   internationalization:
-    fr: SOERE mon SOERE
-    en: SOERE my SOERE
+    fr: SOERE mon SOERE avec dépôt
+    en: SOERE my SOERE with repository
   name: MONSORE
   version: 1
 compositeReferences:
@@ -176,7 +176,7 @@ references:
     internationalizationDisplay:
       pattern:
         fr: 'nom du projet: {nom du projet}, nom du site : {nom du site}, nom du thème : {nom du thème}, nom du type de données : {nom du type de données} '
-        en: 'project name: {nom du projet}, site name : {nom du site}, thematic : {nom du thème}, datatype : {nom du type de données} '
+        en: 'projet name: {nom du projet}, site name : {nom du site}, theme name : {nom du thème}, data type name : {nom du type de données} '
     validations:
       projetRef:
         description: "référence au projet"
@@ -205,9 +205,10 @@ references:
         checker:
           name: GroovyExpression
           params:
-            expression: >
-              String datatype = Arrays.stream(datum.get("nom du type de données").split("_")).collect{it.substring(0, 1)}.join();
-              return application.getDataType().contains(datatype);
+            groovy:
+              expression: >
+                String datatype = Arrays.stream(datum.get("nom du type de données").split("_")).collect{it.substring(0, 1)}.join();
+                return application.getDataType().contains(datatype);
     keyColumns: ["nom du projet","nom du site","nom du thème","nom du type de données" ]
     columns:
       nom du projet:
@@ -308,9 +309,10 @@ references:
         checker:
           name: GroovyExpression
           params:
-            expression: >
-              String datatype = Arrays.stream(datum.get("nom du type de données").split("_")).collect{it.substring(0, 1)}.join();
-              return application.getDataType().contains(datatype);
+            groovy:
+              expression: >
+                String datatype = Arrays.stream(datum.get("nom du type de données").split("_")).collect{it.substring(0, 1)}.join();
+                return application.getDataType().contains(datatype);
     keyColumns: [nom du type de données,nom de la variable]
     internationalizationName:
       fr: Variables et unités par type de données
@@ -331,9 +333,9 @@ dataTypes:
       en: Trap in ascent
     internationalizationDisplay:
       especes:
-          pattern:
-            fr: 'espèce :{esp_nom}'
-            en: 'espèce :{esp_nom}'
+        pattern:
+          fr: 'espèce :{esp_nom}'
+          en: 'espèce :{esp_nom}'
     data:
       projet:
         components:
@@ -346,7 +348,8 @@ dataTypes:
         components:
           bassin:
             params:
-              references: sites
+              references:
+                - sites
               replace: true
             defaultValue: >
               return references.get("sites")
@@ -359,7 +362,8 @@ dataTypes:
           plateforme:
           chemin:
             params:
-              references: sites
+              references:
+                -  sites
             defaultValue: >
               return references.get("sites")
               .find{it.getRefValues().get("zet_chemin_parent").equals(datumByVariableAndComponent.get("site").get("bassin")) && it.getRefValues().get("zet_nom_key").equals(datumByVariableAndComponent.get("site").get("plateforme"))}
@@ -418,31 +422,35 @@ dataTypes:
         checker:
           name: GroovyExpression
           params:
-            expression: >
-              String datatype = "piegeage_en_montee";
-              String variable = "Couleur des individus";
-              String codeVariable = "couleur_des_individus";
-              String component = "unit";
-              return referencesValues.get("variables_et_unites_par_types_de_donnees")
-              .findAll{it.get("nom du type de données").equals(datatype)}
-              .find{it.get("nom de la variable").equals(codeVariable)}
-              .get("nom de l'unité").equals(datum.get(variable).get(component));
-            references: variables_et_unites_par_types_de_donnees
+            groovy:
+              expression: >
+                String datatype = "piegeage_en_montee";
+                String variable = "Couleur des individus";
+                String codeVariable = "couleur_des_individus";
+                String component = "unit";
+                return referencesValues.get("variables_et_unites_par_types_de_donnees")
+                .findAll{it.get("nom du type de données").equals(datatype)}
+                .find{it.get("nom de la variable").equals(codeVariable)}
+                .get("nom de l'unité").equals(datum.get(variable).get(component));
+              references:
+                - variables_et_unites_par_types_de_donnees
       unitOfIndividus:
         description: "vérifie l'unité du nombre d'individus"
         checker:
           name: GroovyExpression
           params:
-            expression: >
-              String datatype = "piegeage_en_montee";
-              String variable = "Nombre d'individus";
-              String codeVariable = "nombre_d_individus";
-              String component = "unit";
-              return referencesValues.get("variables_et_unites_par_types_de_donnees")
-              .findAll{it.get("nom du type de données").equals(datatype)}
-              .find{it.get("nom de la variable").equals(codeVariable)}
-              .get("nom de l'unité").equals(datum.get(variable).get(component));
-            references: variables_et_unites_par_types_de_donnees
+            groovy:
+              expression: >
+                String datatype = "piegeage_en_montee";
+                String variable = "Nombre d'individus";
+                String codeVariable = "nombre_d_individus";
+                String component = "unit";
+                return referencesValues.get("variables_et_unites_par_types_de_donnees")
+                .findAll{it.get("nom du type de données").equals(datatype)}
+                .find{it.get("nom de la variable").equals(codeVariable)}
+                .get("nom de l'unité").equals(datum.get(variable).get(component));
+              references:
+                - variables_et_unites_par_types_de_donnees
     format:
       headerLine: 4
       firstRowLine: 5
diff --git a/src/test/resources/data/validation/fake-app.yaml b/src/test/resources/data/validation/fake-app.yaml
index b9c3ccfa3..208988dd0 100644
--- a/src/test/resources/data/validation/fake-app.yaml
+++ b/src/test/resources/data/validation/fake-app.yaml
@@ -142,7 +142,8 @@ dataTypes:
         checker:
           name: GroovyExpression
           params:
-            expression: "true"
+            groovy:
+              expression: "true"
     format:
       constants:
         - rowNumber: 1
-- 
GitLab