Skip to main content
Skip table of contents

Créer un arbre dynamique


Dans un arbre dynamique, les nœuds sont déterminés par requêtes ! Alors que pour un arbre statique, ils sont rentrés en “dur” dans le paramétrage de l’arbre et seront toujours les mêmes ( cas d’un arbre associé à un couplage permettant de présenter un menu statique )

Ici, on souhaite créer un arbre paramétré pour afficher la liste des devis et des commandes rattachés à un client :

image-20241126-092059.png

Et on souhaite pouvoir ouvrir ces devis/commandes en lançant une action depuis l’arbre:

image-20241126-092402.png

Cet arbre sera donc dynamique, car selon le client on aura des branches avec des commandes ou devis différents !

Comment faire ? 🧐 Déjà, ayez bien en tête le schéma de votre arbre, et les actions à lancer sur chaque branche ! 🙂

ETAPE 1: Créer la définition de l’arbre

On commence par créer la définition de l’arbre. Pour cela, on va ici:

image-20241126-071719.png

Et on vient créer un nouvel arbre ! On va ensuite pouvoir le remplir comme ceci:

Ici, vous trouverez uniquement les champs principaux. Pour aller dans le détail de tous les champs, c’est par ici !

image-20241126-071840.png

  • Mode démarrage :

    • [0] l’arbre est en visualisation uniquement !

    • [1] l’arbre est en écriture, et quand on le lance ça ne bloque pas l’application depuis laquelle on l’a ouvert

    • [2] l’arbre est en écriture, et quand on le lance ça bloque l’application depuis laquelle on l’a ouvert

Ces champs permettent de transmettre le contexte entre le père de l’arbre et l’arbre. Si ce n’est pas renseigné l’arbre est “aveugle” il n’aura pas le contexte d’entrée. Dans cet exemple par exemple, on ne saura pas quel est le client en cours…

image-20241126-074557.png

  • Type de chargement : l’arbre est chargé complétement au démarrage ou niveau par niveau ?

En général, on charge complètement !

Sinon ça veut dire que les branches de l’arbre se chargent au fur à mesure, quand on clique sur une branche. Il faut donc écrire la requête en conséquence, en décrivant ce qu’il se passe dès qu’on clique sur une branche ! On doit donc prévoir tous les cas unitaires et la requête peut être très complexe.

  • Réf. Origine Arbre: Il s’agit du nom de notre arbre de plus haut niveau ! Dans notre cas, c’est “CLIENT”. On ajoutera le nom du client dynamiquement dans la requête !

image-20241126-140542.png

Dans un arbre, le “vrai” nœud de plus haut niveau s’appelle *ORI, et il n’est pas visible dans l’arbre. Ici, on indique à DIAPASON quel nœud doit être rattaché au nœud père *ORI, celui de plus haut niveau.

  • Règ.Const: On vient rentrer ici la règle de constitution de notre tableur, qu’on a créé à l’étape précédente !

image-20241126-071923.png

  • Icône défaut. : les nœuds de notre arbre auront tous cet icône par défaut ( modifiable dans la requête de construction de l’arbre) !

image-20241126-080224.png

On créé les actions qu’on souhaite lancer depuis les branches de notre arbre

  • Actions : on peut créer ici les actions qu’on lancera depuis une ou plusieurs branches de notre arbre paramétré. Le principe est celui du moteur RCT

  • Règle : si on a une ou plusieurs actions gérées par requête, on va utiliser une requête RCT qu’on définira ici. Pour plus de détail, rdv au Chapitre “Lancer des actions depuis les branches de l’arbre” à la fin de ce tuto !

ETAPE 2: Créer la requête REB de constitution de l’arbre

On va ensuite pouvoir la requête REB de constitution de notre arbre.

Pour cela, il faut bien avoir en tête ce à quoi notre arbre doit ressembler: quels sont les nœuds pères et fils !

Quelles sont les listes utilisées ?

Les arbres peuvent être gérés par requête REB à l’aide de 3 listes standards :

  • WfArbEnt : cette liste contient le contenu de l’arbre existant, dans le cas d’un réaffichage ! Elle n’est accessible qu’en lecture.

  • WfArbSor : cette liste permet de construire l’arbre, et mettre à jour les nœuds construits par l’application. Chaque enregistrement alimenté dans cette liste correspond à un nœud à afficher dans l’arbre. Cette liste est accessible en écriture ! On y retrouve les champs de la https://diapason-documentation.atlassian.net/wiki/spaces/T0/pages/147592897 😉

La structure des listes WfArbEnt et WfArbSor est la suivante

Champs

Description

NodIdeEnc

Identifiant du nœud courant. UNIQUE. A initialiser seulement dans le cas du mode complet.

NodIdePer

Identifiant du nœud père. UNIQUE . A initialiser.

NodRef

Référence du noeud

NodRefPere

Référence du nœud père

NodNOrd

Numéro d’ordre

NodLib

Libellé du nœud

NodIco

Icône du nœud

NodIcoFer

Icône fermé du nœud

NodCl1

Clé information liée

NodCl2

Clé information liée

NodCl3

Clé information liée

NodVa1

Valeur alphanumérique

NodVa2

Valeur alphanumérique

NodVa3

Valeur alphanumérique

NodVa4

Valeur alphanumérique

NodVa5

Valeur alphanumérique

NodNu1

Valeur numérique

NodNu2

Valeur numérique

NodNu3

Valeur numérique

NodNu4

Valeur numérique

NodNu5

Valeur numérique

NodDa1

Valeur Date

NodDa2

Valeur Date

NodDa3

Valeur Date

NodDa4

Valeur Date

NodDa5

Valeur Date

NodLo1

Valeur Logique

NodLo2

Valeur Logique

NodLo3

Valeur Logique

NodLo4

Valeur Logique

NodLo5

Valeur Logique

NodTab

Table de l’enregistrement lié au nœud (DiaTab)

NodIde

Identifiant de l’enregistrement lié au nœud (DiaIde)

NodLstAct

Liste des actions disponibles sur le nœud

AppCouEnfTyp

Type d’enfant de couplage lié au nœud (dans le cas où l’arbre est père de couplage)

AppCouEnfRef

Référence de l’enfant de couplage lié au nœud (dans le cas où l’arbre est père de couplage)

  • WfArbCheEnt : En lecture, permet de donner le chemin d’un nœud à partir de l’origine de l’arbre (NodNiv = 1 pour l’origine) Cette liste est utilisée, lors d’une actualisation ou d’un rafraîchissement, ou pour le mode « par niveau » lors de l’ouverture d’un nœud, et servira à donner des informations permettant de retracer le chemin de l’origine de l’arbre jusqu’au nœud concerné par l’action.

La structure de la liste WfArbCheEnt est la suivante

Champs

Description

NodNiv

Niveau du nœud (en commençant par 1 pour l’origine).

NodRef

Toutes les variables : récupération de toutes les variables SCR, VCR, VBP de l’application père.

NodNOrd

Numéro d’ordre

Qu’avons nous, en entrée de la requête de création de la structure de l’arbre et que faut il définir en sortie ?

On a donc, en entrée de la requête :

Et il nous faut, en sortie de la requête :

  • SCR.ARB_ActCtxCons : dans quelle situation on se trouve ?

    • DEM : on est au démarrage de l’application ( premier affichage de l’arbre )

    • ACT : on actualise notre application suite au lancement d’une action

    • REA : on réaffiche notre application

  • la liste WfArbEnt : si on est en actualisation de notre arbre liste du contenu de l’arbre déjà existant, pour l’actualisation

  • la liste WfCheEnt disponible en lecture contient les nœuds menant au nœud courant

  • SCR.ARB_NodIdeEnc : Identifiant du nœud courant, qui doit être unique dans tout l’arbre

  • SCR.ARB_NodIdePer : Identifiant du nœud père du nœud courant

  • SCR.RCT_TypeAction : Code de l’action qui a déclenché le réaffichage, si on a SCR.ARB_ActCtxCons = REA

  • Liste WfArbSor : c’est dans cette liste qu’on construit l’arbre au démarrage ou après actualisation de l’application

    • S’il s’agit d’une actualisation, la liste WfArbSor doit être initialisée avec toute la structure de l’arbre, et la variable SCR.NodPosSor donnant l’identifiant du nœud de positionnement (par défaut le nœud courant).

    • S’il s’agit d’un rafraichissement, la liste WfArbSor doit être initialisée avec seulement les nœuds qui seront modifiés, ceux-ci ne changeant pas d’identifiant, ni de référence, et la variable SCR.NodPosSor donnant l’identifiant du nœud de positionnement (par défaut le nœud courant).

Voici comment on peut écrire notre requête

Il est possible, depuis la définition de notre arbre, de construire une partie de l'arbre de manière statique, comme on le fait ici. Ces noeuds seront automatiquement enregistrés dans la liste WfArbSor. ( les arbres statiques sont souvent utilisés comment des points d’entrée menu, lorsque l’arbre est utilisé comme père d’un couplage) !

image-20241126-144246.png

1- On récupère les critères d’entrée

Quels sont les critères dont on a besoin pour créer notre arbre ? On les récupère !

image-20241126-144327.png

Optionnel-On réactualise notre arbre en retour d’action

➡️ si vous comptez lancer des actions depuis une/plusieurs branches de votre requête, et que vous souhaitez actualiser votre arbre en conséquence, vous pouvez utiliser ce bout de requête, qui est complètement générique 😉

Pourquoi ? on récupère les branches de l’arbre déjà définies, à partir de la liste WfTabEnt, et on s’en sert pour reconstruire le nouvel arbre à afficher, en remplissant la liste WfArbEnt. En bref, dans cette démarche on réactualise !

Que se passe-t-il ?

  • on vérifie qu’on en entrain d’actualiser, avec SCR.ARB_ActCtxCons=CLO.”ACT”

  • on va ensuite venir chercher le premier nœud de notre arbre ( celui dont le père est *ORI)

  • on va ensuite recréer la liste WFArbSor, la liste qui permet de construire notre arbre, à partir de la liste WfArbEnt, qui contient notre arbre existant !

  • on finit par un SINON, pour enchainer sur la construction de l’arbre quand on est au démarrage de l’application, et non pas en actualisation

image-20241126-145207.png

2-On peut modifier le nœud principal de notre arbre

On va maintenant passer sur la construction de notre arbre. On peut commencer par modifier dynamiquement le nœud principal. Mais comment DIAPASON va t’il reconnaitre quel est le premier nœud de notre arbre ? 🧐

  • le premier nœud de notre arbre est, par définition, celui qui est sous le nœud *ORI, qui n’est pas visible mais qui est le nœud de plus haut niveau pour DIAPASON. Rappelez-vous, on l’a déjà crée dans la définition de l’arbre, précédemment ! Et ce nœud principal est visible dans https://diapason-documentation.atlassian.net/wiki/spaces/T0/pages/147592897 sous le nœud *ORI :

image-20241129-141133.png
  • On va donc rechercher ce nœud qui est sous *ORI, et on peut venir modifier ses caractéristiques dans la liste WfArbSor.

Par exemple ici, on l’avait simplement nommé “CLIENT” dans la définition de l’arbre, et ici on le renomme dynamiquement avec le nom du client sur lequel on est !

image-20241126-153634.png

Exemple 1 de nœud fils

image-20241126-153759.png

Exemple 2 de nœud fils

On vient ensuite définir des nœuds fils

Pour chacun des nœuds fils , on va créer une liste WfArbSor, avec obligatoirement:

  • WfArbSor NodIdePer ➡️ le nom du nœud père

  • WfArbSor NodIdeEnc ➡️ le nom qu’on veut donner au nœud courant

  • WfArbSor NodRef ➡️idem, le nom qu’on veut donner au nœud courant

  • WfArbSor NodIdePer ➡️ idem, le nom du nœud père

Pourquoi on donne 2 fois le nom du nœud père et le nom du nœud courant ?

Dans WfArbSor NodIdePer et WfArbSor NodIdeEnc, on doit mettre des références de nœud père et fils qui doivent être uniques sur toutes l’arborescence de l’arbre. En revanche, dans WfArbSor NodRef et WfArbSor NodIdePer, dans le cas d’un type de chargement par niveau, on peut mettre des références non uniques.

  • WfArbSor NodNOrd ➡️ un numéro d’ordre, on utilisera un incrément pour le changer à chaque nœud

  • WfArbSor NodLib ➡️ le libellé du nœud

On peut également définir dans la liste WfArbSor:

  • WfArbSor NodIco ➡️ on peut définir ici dynamiquement l’icône de l’arbre

  • WfArbSor NodCl1,2 ou NodVa1, 2… ➡️ on peut mettre ici des données qui seront utilisables dans la requête RCT des actions

  • WfArbSor NodLstAct ➡️ on entre ici la référence des actions à lancer depuis ce nœud, séarées par une virgule. Toutes les actions seront visibles sur chaque nœud, mais seules elles déclarées ici seront lançables sur la branche.

Toutes les variables disponibles sont décrites plus haut dans le chapitre “Quelles sont les listes utilisées ? ”

Et voilà, notre requête est écrite et on peut tester ! 🙂 Ci-dessous, on peut voir le parallèle entre le requête et notre arbre:

ETAPE 3- Optionnel-Lancer des actions depuis les branches de l’arbre

Il est possible de créer des actions qu’on peut lancer depuis les branches de notre arbre. Comment faire ? 🤓

  • Dans la première étape de ce tuto, nous avons créée l’arbre. Il est possible de définir les actions à lancer dans l’onglet Actions ! C’est le même principe que dans le moteur RCT.

  • Si on veut définir ces actions par requête, il faut y entrer également une requête RCT. On pourra y récupérer des variables depuis l’arbre dans des SCR ! Par exemple:

  • On rentre la référence de l’action/des actions à lancer sur chaque nœud où elles peuvent être lancées ( s’il y a plusieurs références d’action, elles doivent être séparées par une virgule).

Ces références d’actions sont celles qu’on a entrée dans la définition de l’arbre dans l'étape 1, dans l’onglet Action ! 😉

image-20241126-164934.png

Et il n’y a plus qu’à tester !


JavaScript errors detected

Please note, these errors can depend on your browser setup.

If this problem persists, please contact our support.