368 lines
8.4 KiB
Markdown
368 lines
8.4 KiB
Markdown
---
|
|
gitea: none
|
|
include_toc: true
|
|
---
|
|
|
|
# Les valeurs par défault calculées
|
|
|
|
## Synopsis
|
|
|
|
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 :
|
|
|
|
```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: suffix
|
|
all_dyn_var:
|
|
default:
|
|
type: variable
|
|
variable: rougail.my_dyn_family_val1.my_dyn_var_val1
|
|
```
|
|
|
|
Dans ce cas, on récupère la valeur `val1`.
|
|
|
|
Deuxième exemple en utilisant la variable pour tous les suffixes :
|
|
|
|
```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: suffix
|
|
all_dyn_var:
|
|
multi: true
|
|
default:
|
|
type: variable
|
|
variable: rougail.my_dyn_family_.my_dyn_var_
|
|
```
|
|
|
|
Dans ce cas, on récupère la liste `val1` et `val2`.
|
|
|
|
|
|
### Calcul via un 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: suffix
|
|
```
|
|
|
|
### Calcul via un index
|
|
|
|
```yml
|
|
---
|
|
version: '1.0'
|
|
family:
|
|
type: leadership
|
|
leader:
|
|
multi: true
|
|
default:
|
|
- val1
|
|
- val2
|
|
follower1:
|
|
type: number
|
|
default:
|
|
type: index
|
|
```
|
|
|
|
### Rédéfinition
|
|
|
|
Dans un premier dictionnaire déclarons notre variable et notre calcule :
|
|
|
|
```yml
|
|
---
|
|
version: '1.0'
|
|
my_calculated_variable:
|
|
default:
|
|
type: jinja
|
|
jinja: 'the value is calculated'
|
|
```
|
|
|
|
Dans un second dictionnaire il est possible de redéfinir le calcul :
|
|
|
|
```yml
|
|
---
|
|
version: '1.0'
|
|
my_calculated_variable:
|
|
redefine: true
|
|
default:
|
|
type: jinja
|
|
jinja: 'the value is redefined'
|
|
```
|
|
|
|
Dans un troisième on peut même supprimer le calcul :
|
|
|
|
```yml
|
|
---
|
|
version: '1.0'
|
|
my_calculated_variable:
|
|
redefine: true
|
|
default: null
|
|
```
|