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