"Boucler à travers une collection"

1. Le principe de l'itération sur une collection

L'idée d'une boucle est simple : répéter un ensemble d'actions un certain nombre de fois. Pour parcourir une collection, nous devons dire à la boucle de se répéter autant de fois qu'il y a d'éléments dans notre collection.

Imaginez que vous ayez une liste de courses. Parcourir cette liste avec une boucle reviendrait à prendre le premier article, faire ce que vous avez à faire avec (le mettre dans le caddie), puis passer au deuxième, et ainsi de suite jusqu'à la fin de la liste.

Dans Architect, ce processus se décompose en trois concepts clés :

1. L'action Loop : Le conteneur qui définit la zone de répétition.
2. Le nombre d'itérations : Nous devons indiquer dynamiquement à la boucle combien de fois elle doit s'exécuter. Pour cela, nous utiliserons la fonction Count() que vous connaissez déjà pour connaître la taille de la collection.
3. L'accès à l'élément courant : À chaque passage dans la boucle, nous devons pouvoir récupérer l'élément correspondant à cette itération (le premier, puis le deuxième, etc.). Nous ferons cela grâce à une variable spéciale appelée index.

Pour une première vue d'ensemble, la documentation de Genesys Cloud décrit bien ce cas d'usage.

2. Configurer une boucle pour une collection

Maintenant, voyons comment configurer cela concrètement dans Architect. La communauté Genesys a documenté une excellente méthode pour cela, que nous allons adopter comme bonne pratique.

Pour résumer cette excellente explication, voici les étapes à suivre :

1. Ajouter l'action Loop : Faites-la glisser depuis la boîte à outils dans votre flux.
2. Configurer le nombre d'itérations (Loop Count) : C'est le paramètre le plus important. Au lieu de mettre un nombre fixe, nous allons utiliser une expression. Si votre collection s'appelle Flow.MaCollection, l'expression sera : Count(Flow.MaCollection). Ainsi, la boucle s'exécutera exactement le bon nombre de fois.
3. Définir la variable d'index (Current Index Data Name) : L'action Loop met à votre disposition une variable qui s'incrémente automatiquement à chaque passage (0, 1, 2...). Vous pouvez lui donner un nom, par exemple Flow.currentIndex. Si vous ne lui donnez pas de nom, Architect utilisera un nom par défaut.

Une fois la boucle configurée, il faut travailler à l'intérieur de celle-ci.

3. Accéder à l'élément courant dans la boucle

À chaque passage, la variable d'index (par ex. Flow.currentIndex) contient la position de l'élément que nous voulons traiter. Dans la leçon précédente, nous avons utilisé GetAt(collection, index) pour cela. C'est une méthode qui fonctionne parfaitement.

Cependant, Architect offre une syntaxe plus moderne et plus lisible, que vous avez vue dans la lecture précédente : la notation avec des crochets [].

Flow.MaCollection[Flow.currentIndex]

Cette expression est strictement équivalente à GetAt(Flow.MaCollection, Flow.currentIndex), mais elle est plus concise. Elle signifie : "Dans Flow.MaCollection, donne-moi l'élément qui se trouve à la position indiquée par Flow.currentIndex".

L'image suivante, tirée de la discussion de la communauté, illustre parfaitement ce concept. On y voit une boucle qui parcourt une collection et utilise l'élément courant comme paramètre d'entrée pour une autre action (Call Data Action).

4. Mise en pratique : Énoncer tous les services d'un client

Reprenons notre exercice de la leçon précédente et améliorons-le. Au lieu de n'annoncer que le premier service souscrit, nous allons maintenant tous les annoncer, un par un.

Objectif : Modifier le flux pour qu'il parcoure la collection de services et énonce chaque service à l'appelant.

1. Repartez du flux "Manipulation de Collections" que vous avez créé précédemment. Si vous ne l'avez plus, recréez rapidement les deux premières actions Update Data :

   • La première qui crée la collection de chaînes vide Flow.SubscribedServices.
   • La seconde qui y ajoute "Assurance Vie" et "Epargne Logement" avec la fonction AddItem.

2. Supprimez les anciennes actions : Effacez l'action Update Data qui récupérait le premier service (Flow.FirstService) et l'action Play Audio qui l'énonçait.

3. Ajoutez et configurez l'action Loop :

   • Faites glisser une action Loop depuis la catégorie Data de la boîte à outils, juste après l'action qui peuple la collection.
   • Dans le panneau de configuration de la boucle :
     • Name : Donnez-lui un nom clair, par exemple Boucle sur les services.
     • Loop Count : Cliquez sur le bouton "Expression" et entrez Count(Flow.SubscribedServices).
     • Current Index Data Name : Nommez votre variable d'index, par exemple Flow.serviceIndex.

4. Agir à l'intérieur de la boucle :

   • Toutes les actions que vous ajoutez maintenant sous le chemin de sortie "Loop" (le chemin principal qui continue sous la boucle) seront répétées.
   • Faites glisser une action Play Audio à l'intérieur de la boucle (sur la flèche qui sort de l'action Loop).
   • Configurez cette action Play Audio :
     • Choisissez Text to Speech Expression.
     • Entrez l'expression suivante pour construire le message :
       Append("Vous avez souscrit au service : ", Flow.SubscribedServices[Flow.serviceIndex])
   • Cette action va maintenant s'exécuter pour chaque service. Au premier passage, Flow.serviceIndex vaudra 0 et l'expression lira Flow.SubscribedServices[0] ("Assurance Vie"). Au second passage, Flow.serviceIndex vaudra 1 et l'expression lira Flow.SubscribedServices[1] ("Epargne Logement").

5. Finalisez le flux :

   • Après la boucle (sur le chemin de sortie "Exit"), ajoutez une dernière action Play Audio avec le message "Fin de la liste de vos services.".
   • Ajoutez une action Disconnect à la toute fin.

6. Publiez et testez votre flux. Vous devriez maintenant entendre, l'un après l'autre :

   • "Vous avez souscrit au service : Assurance Vie"
   • "Vous avez souscrit au service : Epargne Logement"
   • "Fin de la liste de vos services."

Félicitations, vous venez de créer votre première boucle dynamique !

Conclusion

Vous maîtrisez maintenant l'une des techniques les plus fondamentales de la programmation de flux : l'itération. Savoir parcourir une collection d'éléments pour les traiter un par un est une compétence qui vous servira constamment pour construire des flux robustes et évolutifs.

Points clés à retenir :

• L'action Loop permet d'exécuter un bloc d'actions de manière répétée.
• Pour itérer sur une collection, le Loop Count doit être défini dynamiquement avec l'expression Count(nom_de_la_collection).
• À l'intérieur de la boucle, on accède à l'élément de l'itération en cours via la notation nom_de_la_collection[variable_index].
• Cette méthode permet d'écrire un code propre et efficace qui s'adapte à n'importe quelle taille de collection.

Prochaine leçon :

Nous avons terminé notre exploration de la logique de flux avancée. Vous savez maintenant créer des branchements conditionnels, manipuler des listes et les parcourir. Mais d'où viennent ces données ? Très souvent, d'un système externe (un CRM, une base de données...).

Dans le prochain module, nous aborderons un sujet passionnant et crucial : les API REST et les Data Actions. Vous découvrirez comment, depuis un flux Architect, interroger un service externe pour récupérer des informations (comme la liste des services d'un client !) et les utiliser pour personnaliser l'expérience de l'appelant. C'est l'équivalent dans Genesys Cloud des mécanismes de recherche de données externes que vous avez pu utiliser avec UCCE, mais avec une approche beaucoup plus moderne et standardisée.