Une valeur peut être calculée. Dans ce cas on a quatre possibilités :
- calcul via Jinja
- calcul via une variable
- calcul via une information
- calcul via un suffix : dans le cas d'une variable dans une famille dynamique
- calcul via un index : dans le cas d'une variable suiveuse
Si l'utilisateur modifie la valeur de la variable, la valeur par défaut n'est plus utilisé, donc le calcul n'est plus réalisé.
C'est le cas également si la variable à l'attribut `auto_save`.
Par contre si la variable est caché (avec le paramètre `hidden`) c'est la valeur par défaut qui est utilisé et non la valeur personnalisée par l'utilisateur.
⚠️ Une variable suiveuse ne peut pas être calculé automatiquement.
## Paramètres
Suivant les types de calcul les paramètres vont être différents :
| Type de calcul | Paramètre | Commentaires | Exemple |
| | **type**<br/>`string`<br/>`mandatory` | Type du calcul, les valeurs possible sont : jinja, variable, information, suffix ou index | jinja |
| Jinja | **jinja**<br/>`string`<br/>`mandatory` | Template Jinja. Pour une variable multiple, chaque ligne représente une valeur. | {% if rougail.variable %}{{ rougail.variable }}{% endif %} |
| Jinja | **params**<br/>`list` | Paramètres complémentaire passé au template Jinja | |
| Variable (`mandatory`)<br/>Information | **variable**<br/>`string` | Nom de la variable associée | rougail.variable |
| Variable | **propertyerror**<br/>`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, la valeur calculée est vide.<br/>**Valeur par défaut :** True | False |
| Information | **information**<br/>`string`<br/>`mandatory` | Nom de l'information dont on veut récupérer la valeur. | doc |
Dans le cas d'un calcul de type Jinja, il est possible d'avoir des paramètres.
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**<br/>`string`<br/>`mandatory` | Le nom du paramètre | my\_param |
| | **type**<br/>`string`<br/>`mandatory` | Type du paramètre, les valeurs possible sont : variable, information, suffix ou index | suffix |
| Variable | **variable**<br/>`string`<br/>`mandatory` | Nom de la variable | rougail.variable |
| Variable (`mandatory`)<br/>Information | **propertyerror**<br/>`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.<br/>**Valeur par défaut :** True | False |
| Variable | **optional**<br/>`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.<br/>**Valeur par défaut :** False | True |
| Information | **information**<br/>`string`<br/>`mandatory` | Nom de l'information dont on veut récupérer la valeur. | doc |
## Exemples
### Calcul via un template Jinja
Commençons par exemple à partir d'un simple template Jinja :
```yml
---
version: '1.0'
my_calculated_variable:
default:
type: jinja
jinja: 'no'
```
Voici un deuxième exemple avec une variable de type booléen :
```yml
---
version: '1.0'
my_calculated_variable:
type: boolean
default:
type: jinja
jinja: 'false'
```
Et une valeur multiple de type nombre :
```yml
---
version: '1.0'
my_calculated_variable:
type: number
multi: true
default:
type: jinja
jinja: |
1
2
3
```
Créons une variable dont la valeur est retournée par une fonction Python :
```yml
---
version: '1.0'
my_calculated_variable:
default:
type: jinja
jinja: '{{ return_no() }}'
```
Puis créons la fonction "return\_no" :
```python
def return_no():
return 'no'
```
Un exemple avec des paramètres :
```yml
---
version: '1.0'
my_calculated_variable:
description: my description
default:
type: jinja
jinja: |
{{ param1 }}{% if param2 is defined %}_{{ param2 }}{% endif %}_{{ param3 }}
params:
param1: value
param2:
type: variable
variable: rougail.unknown_variable
optional: true
param3:
type: information
information: doc
variable: rougail.my_calculated_variable
```
Un exemple avec un paramètre de type suffix :
```yml
---
version: '1.0'
varname:
multi: true
default:
- val1
- val2
my_dyn_family_:
type: dynamic
variable: rougail.varname
description: 'Describe '
my_dyn_var_:
type: string
default:
type: jinja
jinja: 'the suffix is: {{ param1 }}'
params:
param1:
type: suffix
```
Un exemple avec un paramètre de type index :
```yml
---
version: '1.0'
family:
type: leadership
leader:
multi: true
default:
- val1
- val2
follower1:
default:
type: jinja
jinja: 'the index is: {{ param1 }}'
params:
param1:
type: index
```
### Calcul via une variable
Copier une variable dans une autre :
```yml
---
version: '1.0'
my_variable:
multi: true
default:
- val1
- val2
my_calculated_variable:
multi: true
default:
type: variable
variable: rougail.my_variable
```
Copier une variable dans une autre si la source n'a pas de problème de propriété :
```yml
---
version: '1.0'
my_variable:
default: val1
disabled: true
my_calculated_variable:
multi: true
default:
type: variable
variable: rougail.my_variable
propertyerror: false
```
Copier deux variables non multiple dans une variable multiple :
```yml
---
version: '1.0'
my_variable_1:
default: val1
my_variable_2:
default: val2
my_calculated_variable:
multi: true
default:
- type: variable
variable: rougail.my_variable_1
- type: variable
variable: rougail.my_variable_2
```
Une variable dans une famille dynamique peut également être utilisé dans un calcul.
Par exemple en utilisant la variable pour un suffixe particulier :
