Exécuteur de règle multiligne

Pour les règles de syntaxe sur une seule ligne, voir « Fonctions d'attribut ».

Eléments d'une règle multiligne

La règle multiligne est écrite au format YAML. Elle est soumise aux exigences de formatage d'un document YAML. L'analyseur YAML utilisé prend en charge la plupart des formats YAML 1.1 et 1.2.

Types d'instruction pris en charge

Instruction context

Instruction return

L'instruction return est utilisée pour demander au moteur de règles de mettre fin à l'exécution et de renvoyer immédiatement la valeur calculée.

Le format est return: {{expression}}.

Instruction if

L'instruction if est utilisée pour générer des blocs conditionnels. Elle se compose de plusieurs propriétés à la différences des deux instructions précédentes.

Consignation de trace

Il est possible d'ajouter la journalisation des traces à une règle multiligne afin d'envoyer des journaux de débogage. Les propriétés de journalisation des traces sont appliquées si une règle est exécutée avec le mode de trace activé. La journalisation des traces est prise en charge via les debug propriétés et debugx .

debug STATEMENT

Cette debug instruction sert à exécuter l'expression fournie et à enregistrer la valeur renvoyée. L'expression doit toujours donner une chaîne de caractères.

Format - debug: {{expression}}

debugx bloc

Le debugx bloc comprend deux propriétés : log et fields.

Nom	Descriptif	Format
journal	L'expression fournie est évaluée et la valeur renvoyée est enregistrée. L'expression doit toujours donner une chaîne de caractères.	log: {{expression}}
Zones	Champs de métadonnées personnalisés envoyés avec le journal. Fournie sous forme de table de paires clé-valeur. La valeur de chaque paire est une expression qui doit donner une chaîne de caractères.	{{field_key}}: {{expression}}

Consultez cette section pour découvrir un exemple de fonction illustrant la journalisation des traces.

Fragments

Cette liste de fragments n'est pas exhaustive et ne couvre pas toutes les utilisations possibles des règles. Elle fournit toutefois des exemples qui peuvent être utilisés en l'état ou développés.

Obtention du nom d'affichage du gestionnaire

statements:
  - context: manager := user.getManager()
  - context: userExists := has(context.manager.name)
  - context: >
      givenNameExists := context.userExists
      && has(context.manager.name.givenName) 
      && context.manager.name.givenName != ""
  - context: familyNameExists := context.userExists && has(context.manager.name.familyName) && context.manager.name.familyName != ""
  - context: formattedExists := context.userExists && has(context.manager.name.formatted) && context.manager.name.formatted != ""
  - if:
      match: context.formattedExists
      block:
        - return: context.manager.name.formatted
      elseifs:
        - match: context.givenNameExists
          block:
            - if:
                match: context.familyNameExists
                block:
                  - context: managerName := context.manager.name.familyName + ", " + context.manager.name.givenName
                  - return: context.managerName
                else:
                  - return: context.manager.name.givenName
        - match: context.familyNameExists
          block:
            - return: context.manager.name.familyName
- return: string("Not Available")

Transformation du domaine d'e-mail

statements:
  - context: "workEmails := has(user.emails) ? user.emails.filter(e, e.type == 'work') : []"
  - context: "workEmail := size(context.workEmails) > 0 ? context.workEmails[0].value : ''"
  - if:
      match: context.workEmail != ""
      block:
        - context: cn := context.workEmail.substring(0, context.workEmail.lastIndexOf('@'))
        - if:
            match: context.cn != ""
            block:
              - return: context.cn + "@github.com"
  - return: ""

Portée des variables

statements:
    - context: ret := 3 + 4
    - if:
        match: 2 > 1block:
          - context: ret := 5
          - if:
              match: 3 > 2block:
                - context: ret = 0
    - return: context.ret

Le résultat est 7. Ce résultat est dû au fait que la ligne 6 réinitialise ret dans if.block. Les instructions imbriquées suivantes voient cette variable. Cependant, une fois que le moteur de règles a quitté if.block, il peut accéder à la variable initialisée sur la ligne 2.

Exemple de journalisation des traces

Cet exemple montre comment utiliser les instructions de journalisation de trace.

statements:
  - context: uid := user.id
  - context: userEmail := "user@test.com"
  - debug: '"This is an example of a trace log at time " + string(now)'
  - debugx: 
      log: '"The user id obtained: " + context.uid'
      fields:
          flow: '"login"'
          time: 'string(now)'
          userEmail: context.userEmail
  - return: context.uid  + ", " + context.userEmail

Dans cette debug instruction, l'expression fournie sera évaluée et enregistrée sous la forme "This is an example of a trace log at time <timestamp>".

Restrictions importantes

• Les variables initialisées par le cadre context ne peuvent se trouver que dans ce cadre ou ses sous-cadres. Dans l'exemple de règle précédent, la variable managerName n'est pas accessible en dehors du cadre if dans lequel elle a été initialisée.
• Les cadres elseifs et else ne peuvent être utilisés que si un cadre if se trouve au même niveau.
• Tous les cadres if et elseifs doivent comporter une expression match qui renvoie toujours une valeur booléenne.
• Si le flux d'évaluation de règles ne rencontre pas d'instruction return, une valeur NULL est renvoyée. Aucune erreur n'est renvoyée et aucune vérification de syntaxe n'est effectuée pour s'assurer que tous les flux possibles comportent une instruction return. L'auteur de la règle doit s'assurer que tous les flux de la règle renvoient une valeur acceptable.