Fonction de vérification

Synopsis

Une fonction de vérification est une fonction complémentaire au type qui permet de valider plus précisement le contenu d'une variable.

Un validateur est forcement un calcul de type Jinja.

Paramètres

Suivant les types de calcul les paramètres vont être différents :

Type de calcul	Paramètre	Commentaires	Exemple
	type `string` `mandatory`	Type du calcul, la seule valeur possible est : jinja	jinja
jinja `string` `mandatory`	Template Jinja.	{% if rougail.variable == 'not_allowed' %}not allowed!{% endif %}
params `list`	Paramètres complémentaire passé au template Jinja

Il existe deux types de paramètre :

les paramètres standards (string, boolean, integer, null), dans ce il suffit de faire : "key: value"
les paramètres avancés :
- paramètre via une variable
- paramètre via une information
- paramètre via un suffix : dans le cas d'une variable dans une famille dynamique
- paramètre via un index : dans le cas d'une variable suiveuse

Type du paramètre	Paramètre	Commentaires	Exemple
	name `string` `mandatory`	Le nom du paramètre	my_param
	type `string` `mandatory`	Type du paramètre, les valeurs possible sont : variable, information, suffix ou index	suffix
Variable	variable `string` `mandatory`	Nom de la variable	rougail.variable
Variable (`mandatory`) Information	propertyerror `boolean`	Si l'accès à la variable n'est pas possible à cause d'une propriété (par exemple `disabled`) par défaut une erreur est retournée. Si l'attribut est à False, le paramètre n'est pas passé au template Jinja. Valeur par défaut : True	False
Variable	optional `boolean`	La variable peut ne pas exister suivant les importations de fichier YAML. Si le paramètre optional est à True, le paramètre sera tout simplement supprimer si la variable n'existe pas. Valeur par défaut : False	True
Information	information `string` `mandatory`	Nom de l'information dont on veut récupérer la valeur.	doc

Exemples

Vérification stricte des valeurs

Voici un exemple simple de validation des valeurs :

---
version: '1.0'
my_variable:
  validators:
    - type: jinja
      jinja: |
        {% if rougail.my_variable and not rougail.my_variable.islower() %}
        {{ rougail.my_variable }} is not lowercase string
        {% endif %}

Une fonction de vérification doit prendre en compte 2 aspects important :

la valeur peut ne pas être renseigné (même si la variable est obligatoire), la valeur None doit être prise en compte
si la valeur est invalide, il faut renvoyer une phrase avec un message explicite.

À partir de maintenant seule None et des valeurs en minuscule seront autorisés.

Vérification des valeurs avec avertissement

Dans la contrainte, il est possible de spécifier le niveau d'erreur et le mettre en avertissement :

---
version: '1.0'
my_variable:
  validators:
    - type: jinja
      jinja: |+
        {% if rougail.my_variable and not rougail.my_variable.islower() %}
        {{ rougail.my_variable }} is not lowercase string
        {% endif %}        
      params:
        warnings_only: true

Dans ce cas une valeur avec une majuscule sera accepté, mais un message d'avertissement apparaitra.

Vérification avec paramètres :

---
version: '1.0'
my_hidden_variable:
  disabled: true
my_variable:
  validators:
    - type: jinja
      jinja: |
        {% if param1 is defined and rougail.my_variable == param1 %}
        has same value as rougail.unknown_variable
        {% endif %}
        {% if param2 is defined and rougail.my_variable == param2 %}
        has same value as rougail.my_hidden_variable
        {% endif %}        
      params:
        param1:
          type: variable
          variable: rougail.unknown_variable
          optional: true
        param2:
          type: variable
          variable: rougail.my_hidden_variable
          propertyerror: false

Un exemple avec un paramètre de type suffix :

##FIXME##

---
version: '1.0'
varname:
  multi: true
  default:
    - val1
    - val2
my_dyn_family_:
  type: dynamic
  variable: rougail.varname
  description: 'Describe '
  my_dyn_var_:
    type: string
    validators:
      - type: jinja
        jinja: |
          {% if rougail.my_dyn_family_.my_dyn_var_ == param1 %}
          forbidden!
          {% endif %}          
        params:
          param1:
            type: suffix

Un exemple avec un paramètre de type index :

---
version: '1.0'
family:
  type: leadership
  leader:
    multi: true
    default:
      - val1
      - val2
  follower1:
    type: number
    validators:
      - type: jinja
        jinja: |
          {% if rougail.family.follower1 == param1 %}
          forbidden!
          {% endif %}          
        params:
          param1:
            type: index

Rédéfinition

Dans un premier dictionnaire déclarons notre variable et sa fonction de vérification :

---
version: '1.0'
my_variable:
  validators:
    - type: jinja
      jinja: |
        {% if rougail.my_variable and not rougail.my_variable.islower() %}
        {{ rougail.my_variable }} is not lowercase string
        {% endif %}

Dans un second dictionnaire il est possible de redéfinir le calcul :

---
version: '1.0'
my_variable:
  redefine: true
  validators:  
    - type: jinja
      jinja: |
        {% if rougail.my_variable and ' ' in rougail.my_variable %}
        {{ rougail.my_variable }} has a space
        {% endif %}

Dans ce cas seule ce validateur sera exécuté.

Voici un troisième dictionnaire dans lequel on supprime la validation :

---
version: '1.0'
my_variable:
  redefine: true
  validators:

5.9 KiB Raw Blame History