---
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.

## 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` | Nom 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'
```

Enfin voici un exemple avec un paramètre :

```yml
---
version: '1.0'
my_calculated_variable:
  default:
    type: jinja
    jinja: |
      {{ param1 }}{% if param2 is defined %}_{{ param2 }}{% endif %}
    params:
      param1: value
      param2:
        type: variable
        variable: rougail.unknown_variable
        optional: 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
```