223 lines
5.8 KiB
Markdown
223 lines
5.8 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
|
|
|
|
## Paramètres
|
|
|
|
| Type de calcul | Paramètre | Commentaires | Exemple |
|
|
|----------------|-----------|--------------|---------|
|
|
| | **type**<br/>`string`<br/>`mandatory` | Nom du calcul, les valeurs possible sont : jinja, variable, information, suffix | jinja |
|
|
| Jinja | **jinja**<br/>`string`<br/>`mandatory` | Template Jinja | {% 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` | Nom de l'information dont on veut récupérer la valeur. | doc |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
# Les variables à valeur par défaut calculées
|
|
|
|
## Variable avec une valeur par défaut calculée
|
|
|
|
### 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 second exemple avec une variable de type nombre
|
|
|
|
|
|
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'
|
|
```
|
|
|
|
## Variable avec une valeur calculée
|
|
|
|
En ajoutant le paramètre "hidden" à "True" dans la variable précédente, l'utilisateur n'aura plus la possibilité de modifié la valeur. La valeur de la variable sera donc systématiquement calculée :
|
|
|
|
```yml
|
|
---
|
|
version: '1.0'
|
|
my_calculated_variable:
|
|
hidden: true
|
|
default:
|
|
type: jinja
|
|
jinja: '{{ return_no() }}'
|
|
```
|
|
|
|
C'est également vrai également si hidden est un calcul et que le résultat du calcul est `true`.
|
|
|
|
## Variable meneuse ou suiveuse avec valeur calculé
|
|
|
|
Une [variable suiveuse](../family/leadership.md) ne peut pas être calculé automatiquement.
|
|
Une [variable meneuse](../family/leadership.md) peut être calculé automatiquement.
|
|
Si la variable n'est pas multiple, il ne faut pas que le calcule retourne une liste.
|
|
|
|
## Variable dynamique avec une valeur calculée
|
|
|
|
Il est également possible de calculer [une variable d'une famille dynamique](../family/auto.md) à partir d'une variable standard :
|
|
|
|
```yml
|
|
---
|
|
version: '1.0'
|
|
suffixes:
|
|
type: string
|
|
description: Suffixes of dynamic family
|
|
multi: true
|
|
default:
|
|
- val1
|
|
- val2
|
|
my_variable:
|
|
type: string
|
|
description: My variable
|
|
default: val
|
|
dyn_:
|
|
type: dynamic
|
|
variable: rougail.suffixes
|
|
my_calculated_variable_dyn_:
|
|
type: string
|
|
description: My calculated variable
|
|
default:
|
|
type: variable
|
|
variable: rougail.my_variable
|
|
```
|
|
|
|
Dans ce cas, les variables dynamiques "rougail.dyn_.my_calculated_variable_dyn_" seront calculés à partir de la valeur de la variable "my_variable".
|
|
Que cela soit pour la variable "rougail.dynval1.my_calculated_variable_dyn_val1" ou "rougail.dynval2.my_calculated_variable_dyn_val2".
|
|
|
|
Par contre, il n'est pas possible de faire un calcul pour une seule des deux variables issues de la variable dynamique.
|
|
Si c'est ce que vous cherchez à faire, il faudra prévoir un traitement particulier dans votre fonction.
|
|
|
|
Dans ce cas, il faut explicitement demander le suffix et faire un traitement :
|
|
|
|
|
|
```yml
|
|
---
|
|
version: '1.0'
|
|
suffixes:
|
|
type: string
|
|
description: Suffixes of dynamic family
|
|
multi: true
|
|
default:
|
|
- val1
|
|
- val2
|
|
my_variable:
|
|
type: string
|
|
description: My variable
|
|
default: val
|
|
dyn_:
|
|
type: dynamic
|
|
variable: rougail.suffixes
|
|
my_calculated_variable_dyn_:
|
|
type: string
|
|
description: My calculated variable
|
|
default:
|
|
type: jinja
|
|
jinja: "{% if suffix == 'val1' %}value{% endif %}"
|
|
params:
|
|
suffix:
|
|
type: suffix
|
|
```
|
|
|
|
## Variable avec valeur calculée obligatoire
|
|
|
|
Par défaut les variables calculées ne sont pas des variables obligatoires.
|
|
Dans ce cas un calcul peut retourner "None" ou "", mais surtout un utilisateur peut spécifier une valeur nulle à cette variable. Dans ce cas le calcul ne sera plus réalisé.
|
|
|
|
Une variable calculée est une variable donc sa valeur est le résultat d'une fonction Python.
|
|
|
|
# Rédéfinition
|
|
|
|
## Redéfinition des calcules
|
|
|
|
Dans un premier dictionnaire déclarons notre variable et notre calcule :
|
|
|
|
```yml
|
|
---
|
|
version: '1.0'
|
|
my_calculated_variable:
|
|
default:
|
|
type: jinja
|
|
jinja: '{{ return_no() }}'
|
|
```
|
|
|
|
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: '{{ return_yes() }}'
|
|
```
|
|
|
|
Dans ce cas, à aucun moment la fonction "return_no" ne sera exécuté. Seul la fonction "return_yes" le sera.
|
|
|
|
## Redéfinition avec suppression d'un calcul
|
|
|
|
Il se peut que dans un dictionnaire on décide de définir une valeur par défaut à une variable via un calcul.
|
|
|
|
Dans un second dictionnaire il est possible de supprimer ce calcul.
|
|
|
|
Dans un premier dictionnaire déclarons notre variable et notre calcule :
|
|
|
|
```yml
|
|
---
|
|
version: '1.0'
|
|
my_calculated_variable:
|
|
default:
|
|
type: jinja
|
|
jinja: '{{ return_no() }}'
|
|
```
|
|
|
|
Dans un second dictionnaire supprimer ce calcul :
|
|
|
|
```yml
|
|
---
|
|
version: '1.0'
|
|
my_calculated_variable:
|
|
redefine: true
|
|
default: null
|
|
```
|