Configurer les entités composites

Les entités d'entité composite vous permettent d'écrire des définitions de flux de dialogue beaucoup plus courtes et plus compactes, car elles peuvent être résolues à l'aide d'un seul composant (soit les entités de résolution, soit une réponse commune).

Nous vous recommandons d'utiliser cette approche car vous n'avez pas besoin de composants tels que Switch ou Set Variable pour capturer toutes les entrées utilisateur nécessaires à une transaction d'affaires. À la place, un seul composant peut inviter les utilisateurs à fournir des valeurs pour chaque élément de l'entité. Les invites sont adaptées aux conditions car elles sont basées sur la configuration individuelle de chaque élément de l'entité. À l'aide de l'entité composite, d'un programme de traitement d'événements d'entité ou d'Apache FreeMarker, et des composants Réponse commune ou Résoudre des entités, votre compétence peut :
  • Saisir tout le texte libre, autoriser les chargements de fichiers et collecter l'emplacement courant de l'utilisateur grâce aux éléments STRING, ATTACHMENT et LOCATION.

  • Exécuter le comportement individuel de chaque entité membre de l'entité composite. Pour chaque entité, vous pouvez ajouter des invites spécifiques à la valeur et des messages d'erreur dans l'entité composite (qui inclut des entités personnalisées, des entités système et les éléments STRING, ATTACHMENT et LOCATION). Vous pouvez également contrôler les entités qui doivent (ou ne doivent pas) correspondre à l'entrée de l'utilisateur. Étant donné que vous pouvez créer une séquence d'invites, la compétence peut afficher des énoncés différent s à chaque tentative de l'utilisateur.

  • Présenter des listes à sélections multiples.

  • Valider les correspondances de valeurs en fonction règles.

  • Prendre en charge les cas dégradés–Les utilisateurs peuvent corriger des entrées précédentes.

  • Exécuter des transitions temporaires basées sur des correspondances–Le flux de dialogue peut sortir temporairement du composant lorsqu'une entité a été mise en correspondance. Un autre état peut ainsi effectuer une fonction complémentaire telle qu'un appel REST. Une fois la fonction terminée, le flux de dialogue retourne au composant et la mise en correspondance des valeurs peut continuer. Par exemple :
    • Lorsqu'un reçu est chargé par l'utilisateur, il doit être balayé afin que les valeurs comme la date, le montant et le type de frais puissent être extraites pour les autres membres de l'entité composite. Le composant peut ainsi compléter les valeurs à l'aide du reçu, et non à partir de l'entrée utilisateur.

    • La compétence présente un message, tel que "Presque terminé. Plus que quelques questions", entre les mises en correspondance pour les membres de l'entité composite.

    • L'entrée utilisateur doit être validée au moyen d'un appel REST dorsal. La validation peut être immédiatement nécessaire car elle détermine les éléments de l'entité composite qui doivent demander des données supplémentaires à l'utilisateur. L'appel peut également retourner des informations à partager avec l'utilisateur, comme un avertissement de non-couverture par la garantie.

  • Désambiguïser des valeurs–Vous pouvez isoler une valeur de l'entrée utilisateur au moyen d'invites propres à l'entité et de propriétés de composant. Ces actions incluent la prise en charge des corrections d'une entrée précédente (cas dégradé) et des demandes d'entrée utilisateur pour des propriétés d'entité intégrée spécifiques.

Créer une entité composite

  1. Cliquez sur Entities (Entités) Ceci est une image de l'icône Entities (Entités). dans la barre de navigation latérale.

  2. Cliquez sur Add Entities (Ajouter des entités).

  3. Choisissez le type d'entité Composite Bag (Entité composite).

  4. Entrez le nom et la description.
  5. Cliquez sur + + Event Handler (Programme de traitement d'événements) si vous souhaitez utiliser l'affichage d'invite et la logique de l'entité composite de manière programmatique à l'aide de programmes de traitement d'événements d'entité.
  6. Cliquez sur + Bag Item (Élément d'entité) pour ouvrir la boîte de dialogue Add Bag Item (Ajouter un élément d'entité composite). Si vous ajoutez une entité intégrée ou une entité personnalisée existante, vous pouvez créer un nom propre à l'entité composite et ajouter une description de son rôle dans le contexte de l'entité composite.

  7. Vous pouvez remplir l'entité composite avec des entités personnalisées et intégrées, ainsi que les éléments suivants :
    • STRING—Saisit le texte libre de l'utilisateur.

    • LOCATION—Saisit l'emplacement de l'utilisateur.

    • ATTACHMENT—Accepte des fichiers, des fichiers audio, vidéo ou d'image chargés par l'utilisateur. L'entité composite stocke l'URL où le fichier joint est hébergé.

    Note

    Vous êtes invité à entrer un sous-type lorsque vous ajoutez l'entité DATE_TIME.
    Les éléments sont résolus dans l'ordre de leur ajout. Toutefois, la séquence peut être affectée par la configuration des membres individuels de l'entité composite.
  8. Lorsque vous cliquez sur Close (Fermer), vous retournez à la page Entities (Entités), mais vous pouvez d'abord ajouter d'autres fonctions propres à l'entité composite à l'élément (ou le mettre à jour ultérieurement en cliquant sur Ceci est une image de l'icône Edit (Modifier). dans cette page).

  9. Étapes suivantes :
    • Ajoutez des messages d'erreur individuels, des invites de désambiguïsation ou des invites conditionnelles pour les éléments de l'entité composite.
      Note

      Ceux-ci seront remplacés si vous ajoutez l'entité à une entité composite.
    • Ajoutez l'entité à une intention. Voir Ajouter des entités à des intentions.

    • Configurez le flux de dialogue pour utiliser l'entité composite..

Remplissage amélioré de fente

Lorsque vous activez le remplissage amélioré des emplacements en activant Utiliser le remplissage amélioré des emplacements dans Paramètres > Configuration :
  • Seul l'élément en cours de résolution sera mis à jour. Lorsqu'une correspondance s'applique à plusieurs éléments d'entité, l'élément d'entité en cours de résolution a priorité sur les autres éléments. Si vous désactivez le remplissage amélioré des emplacements, tous les éléments sont mis à jour avec la même valeur.
  • Si l'élément de résolution courant est un élément d'entité de type STRING, aucun autre élément d'entité n'est mis à jour.
  • Si une correspondance d'entité s'applique à plusieurs éléments d'entité (non résolus), une boîte de dialogue de désambiguïsation s'affiche, ce qui permet à l'utilisateur de choisir l'élément à mettre à jour au lieu de mettre à jour tous les éléments d'entité.
  • Le commutateur Prompt for Disambiguation de l'entité est ignoré. Nous vous recommandons d'implémenter une désambiguïsation personnalisée avec un gestionnaire d'événements d'entité.
Note

L'activation de l'option Utiliser le remplissage d'emplacement amélioré est activée par défaut pour les compétences créées à l'aide de la version 22.08 de la plate-forme. Il est désactivé pour les compétences qui ont été mises à niveau vers cette version.

Ajouter des invites

Vous pouvez ajouter une invite unique, ou bien créer une séquence d'invites fournissant des informations de plus en plus spécifiques à chaque fois que l'utilisateur entre une valeur non valide. Par défaut, l'affichage d'invite est activé. Pour ajouter ces invites :
  1. Si vous souhaitez activer l'affichage d'invite, laissez le champ Prompt for Value (Invite de valeur) vide (son état par défaut). L'entrée de false dans le champ Prompt for Value empêche l'affichage d'invite. Pour demander une valeur conditionnelle, ajoutez une expression FreeMarker booléenne qui donne true (pour l'affichage d'invite) ou false.

    Conseil :

    Si vous réglez Prompt for Value à false, l'élément peut être résolu dans le cadre de l'invite d'un autre élément lorsque vous activez l'option Out of Order Extraction (Extraction dans le désordre).
  2. Cliquez sur Add Prompt (Ajouter une invite) pour générer la séquence d'invites. Vous pouvez la réorganiser en bougeant les champs par glisser-déposer ou en les renumérotant. Vous pouvez rendre aléatoire l'affichage des invites lorsque vous donnez le même numéro à plusieurs invites.
    Note

    Vous ne pouvez ajouter des invites pour les entités intégrées que lorsque vous les ajoutez à une entité composite.
    Vous pouvez stocker des invites dans des ensembles de ressources (par exemple, ${rb.askCheese}) ou les écrire en combinant du texte et des expressions FreeMarker.

Mise à jour des valeurs avec des expressions Apache FreeMarker

Dans le champ Modifiable, entrez une expression Apache FreeMarker qui donne la valeur true pour permettre la mise à jour de la valeur insérée pour un élément d'entité composite.

Activer l'extraction dans le désordre

L'extraction dans le désordre permet de définir et de mettre à jour la valeur d'un élément d'entité composite à n'importe quel moment de la conversation, que l'entité composite ait invité ou non l'utilisateur à indiquer la valeur. À l'aide des règles suivantes, vous pouvez définir comment, quand ou si une valeur peut être insérée ou modifiée à tout moment dans la conversation pour un élément ou un sous-type d'élément (par exemple, les sous-types DATE_TIME).
  • Toujours - Option par défaut. Lorsque vous choisissez cette option pour un élément, sa valeur peut être remplie sans invite. Par exemple, l'entité PizzaSize (Taille de pizza) peut être résolue lorsqu'un client entre I want a large pizza (Je veux une grande pizza). Cette option permet également de modifier la valeur de l'élément à tout moment, à condition que l'expression de la propriété Modifiable ne soit pas évaluée à false. Par exemple, lorsque l'entité composite affiche l'invite pour l'entité PizzaType, le client pourrait répondre Veggie s'il vous plaît, mais en faire un moyen. La compétence peut mettre à jour la valeur de l'entité PizzaSize avec la valeur moyenne sans redémarrer la conversation, car Toujours est activé pour les éléments PizzaSize et PizzaType de l'entité composite.
    Note

    Bien que cette option soit le comportement par défaut, elle peut ne pas toujours être appropriée pour les articles STRING. Si vous sélectionnez cette option pour un élément STRING par exemple, le premier message utilisateur sera stocké par l'élément STRING au lieu d'être mis en correspondance par l'entité prévue (qui pourrait être désignée comme le premier élément de l'entité composite à être résolu).
  • Jamais - Lorsque vous choisissez cette option, l'élément n'est inséré qu'après avoir été demandé, même si d'autres messages d'utilisateur contiennent des valeurs valides. Sélectionnez Jamais pour empêcher les correspondances par inadvertance.
  • Uniquement lors de la résolution de l'énoncé d'intention - Restreint l'insertion de valeurs dans le désordre au premier énoncé d'utilisateur qui a été résolu en intention associée à l'entité composite.
Voici des exemples de règles d'extraction dans le désordre appliquées à un élément d'entité composite PizzaToppings.
Règle d'extraction dans le désordre Énoncé initial de l'utilisateur Valeur avec intervalle Notes
Toujours Commander une pizza avec du thon Thon Le référencement des valeurs pour l'élément PizzaToppings peut être mis en correspondance chaque fois que le message de l'utilisateur contient la valeur correcte ("Champignons à la place!"). Il peut s'agir d'un slotting ou d'une mise à jour à tout moment de la conversation sans invite.
Jamais Commander une pizza avec du thon Aucune La valeur de l'article PizzaTopping ne peut pas être désordonnée ou mise à jour ad hoc. Il ne peut être mis en correspondance que lorsqu'il est demandé.
Seulement lors de la résolution de l'énoncé d'intention Commander une pizza avec du thon Thon. Toutefois, si l'utilisateur a entré "Commander une pizza volumineuse", l'entité composite doit demander la valeur PizzaTopping. L'élément PizzaTopping ne peut être inséré dans le désordre que lorsque le premier énoncé d'utilisateur qui se résout en intention a une valeur correspondante. Sinon, vous devez indiquer cette valeur. L'entité composite ne permet pas la mise à jour ou le référencement ad hoc de cet article.

Activer l'extraction avec

Utilisez l'option Extract With (Extraire avec) pour permettre à votre compétence de résoudre un élément d'entité composite à l'aide de la valeur entrée pour un deuxième élément. Cette option, qui permet à votre compétence de gérer des valeurs connexes, offre une plus grande souplesse pour l'entrée de l'utilisateur. Les utilisateurs peuvent entrer domicileau lieu d'une adresse complète, par exemple. Voici comment :
  • L'entité composite comporte deux entités liées à l'adresse : NamedAddress, une entité de type liste avec des valeurs telles que domicile et bureau, et DeliveryAddress, une entité ADDRESS.
  • L'invite de l'entité DeliveryAddress est Où voulez-vous être livré?
  • L'entité NamedAddress ne demande pas d'entrée ( false (faux) figure dans le champ Prompt for Value (Invite de valeur)).
  • L'entité NamedAddress peut être extraite avec DeliveryAddress (DeliveryAddress est sélectionné dans le menu Extract With (Extraire avec)).

Lorsque l'entité composite demande une valeur pour l'entité DeliveryAddress, elle peut résoudre cette dernière à l'aide d'une adresse physique ou de l'une des valeurs de la liste NamedAddress (domicile ou bureau).

Ajouter des règles de validation

Chaque élément de l'entité composite peut avoir ses propres règles de validation. Vous pouvez ajouter une règle de validation en cliquant sur +Validation Rule (Règle de validation), puis en ajoutant une expression FreeMarker et une invite de texte. L'expression utilise le modèle suivant pour référencer la valeur de l'élément, où varName est le nom de l'entité composite déclaré comme variable dans la définition de flux de dialogue :
${varName.value.itemName}
Si cette expression est évaluée à Faux, l'entrée de l'utilisateur n'est pas valide.
L'exemple suivant d'expression de validation concerne un élément appelé Amount. Il s'agit d'une entité intégrée, CURRENCY. Pour retourner un montant numérique pour la comparaison, l'expression ajoute la propriété amount de l'entité CURRENCY :
${expense.value.Amount.amount > 4}
Le message de validation correspondant peut également refléter l'entrée de l'utilisateur au moyen d'une expression FreeMarker. Par exemple, le message suivant utilise le type de devise extrait de l'entrée de l'utilisateur dans le message de validation :
Amounts below 5 ${expense.value.Amount.currency} cannot be expensed. Enter a higher amount or type 'cancel'.
Pour en savoir plus sur les autres propriétés CURRENCY (et sur les autres propriétés d'entité intégrée également), voir Entités intégrées et leurs propriétés.

Configurer un flux de dialogue YAML pour les entités composites

Si votre compétence est en cours de développement en mode de dialogue YAML, voici ce que vous devez faire pour configurer le flux de dialogue pour les entités composites :

  1. Dans le noeud context, déclarez l'entité composite comme variable :
    ...
    metadata:
      platformVersion: "1.1"
    main: true
    name: "ExpenseBot"
    context:
      variables:
        expense: "Expense"
        iResult: "nlpresult"
  2. Vous pouvez utiliser System.ResolveEntities ou System.CommonResponse. Ces deux composants vous permettent d'utiliser l'entité composite et chacun offre ses propres avantages. Le composant System.ResolveEntities est le plus simple des deux car son jeu de propriétés est réduit. Contrairement au composant System.ResolveEntities, System.CommonResponse vous permet de mieux maîtriser l'interface utilisateur utilisée pour résoudre les entités dans l'entité composite. Par exemple, vous pouvez ajouter une logique conditionnelle pour déterminer les invites et les actions globales liées aux valeurs.

    Conseil :

    Comme les métadonnées du composant System.CommonResponse peuvent devenir très complexes lorsque vous utilisez des entités composites, nous vous recommandons d'utiliser le composant System.ResolveEntities à la place et d'utiliser des programmes de traitement d'événements d'entité pour toutes les personnalisations d'interface utilisateur.
  3. Référencez la variable de contexte de l'entité composite dans la propriété variable du composant, puis définissez les autres propriétés au besoin. Les sections System.ResolveEntities et Propriétés de composant offrent une description et des exemples supplémentaires.

    Voici un exemple de composant System.ResolveEntities :
    createExpense:
        component: "System.ResolveEntities"
        properties:
          variable: "expense"
          useFullEntityMatches: true
          nlpResultVariable: "iResult"
          cancelPolicy: "immediate"
        transitions:
          actions:
            cancel: "cancelExpense"
          return: "done"          

La variable system.entityToResolve

La variable system.entityToResolve fournit des informations sur le statut courant du processus de résolution d'entité tel qu'exécuté par les composants Résoudre les entités et Réponse commune. Vous référencez généralement les propriétés de cette valeur de variable dans les métadonnées du composant de réponse commune lorsque vous souhaitez personnaliser des messages. Vous pouvez l'utiliser pour définir la logique d'un message d'erreur d'entité ou pour diverses propriétés appartenant aux groupes de pages Résoudre entités et Réponse commune. Ajoutez les propriétés suivantes pour retourner la valeur d'entité courante :
  • userInput
  • prompt
  • promptCount
  • updatedEntities
  • outOfOrderMatches
  • disambiguationValues
  • enumValues
  • needShowMoreButton
  • rangeStartVar
  • nextRangeStart
Vous pouvez également référencer les propriétés des expressions FreeMarker utilisées comme les propriétés prompt, errorMessage et les règles de validation.
Voici un exemple d'utilisation de cette variable pour retourner l'entrée utilisateur courante dans le message d'erreur d'une entité :
Sorry,'${system.entityToResolve.value.userInput!'this'}' is not a valid pizza size.
Voici un exemple d'utilisation de diverses définitions system.entityToResolve. Parmi celles-ci se trouve un message défini pour la propriété text, qui confirme la mise à jour d'une valeur d'entité précédemment définie à l'aide d'une directive Apache FreeMarker list et de la propriété updatedEntities.
    metadata:
      responseItems:        
      - type: "text" 
        text: "<#list system.entityToResolve.value.updatedEntities>I have updated <#items as ent>${ent.description}<#sep> and </#items>. </#list><#list system.entityToResolve.value.outOfOrderMatches>I got <#items as ent>${ent.description}<#sep> and </#items>. </#list>"
      - type: "text" 
        text: "${system.entityToResolve.value.prompt}"
        actions:
        - label: "${enumValue}"
          type: "postback"
          iteratorVariable: "system.entityToResolve.value.enumValues"
Pour les actions globales, cette variable contrôle l'action globale Show More (Afficher plus) avec les propriétés needShowMoreButton, rangeStartVar et nextRangeStart :
        globalActions: 
        - label: "Show More"
          type: "postback" 
          visible:
            expression: "${system.entityToResolve.value.needShowMoreButton}"
          payload:
            action: "system.showMore"
            variables: 
              ${system.entityToResolve.value.rangeStartVar}: ${system.entityToResolve.value.nextRangeStart} 
        - label: "Cancel"
          type: "postback" 
          visible:
            onInvalidUserInput: true
          payload:
            action: "cancel"
L'étiquette Show More doit comprendre system.showMore (action: "system.showMore"). Sinon, elle ne fonctionne pas.

Expressions entityToResolve

Expression Description
${system.entityToResolve.value.resolvingField} Retourne le nom de l'élément de l'entité composite.
${system.entityToResolve.value.allMatches[0].entityName} Retourne le nom d'entité référencé par l'élément d'entité composite. Le tableau allMatches contient toutes les entités dont les valeurs pourraient être mises à jour par le message de l'utilisateur.
${<variable>1.value[system.entityToResolve.value.resolvingField]} Retourne la valeur d'élément d'entité composite que les utilisateurs entrent ou sélectionnent.
${system.entityToResolve.value.userInput} Retourne le texte entré par l'utilisateur. Vous pouvez utiliser cette expression pour enregistrer l'entrée utilisateur ou l'afficher dans le clavardage, par exemple lorsqu'un utilisateur entre une valeur non valide.
${system.entityToResolve.value.outOfOrderMatches[n].entityName} Retourne le nom des entités extraites dans le désordre. Outre les valeurs que les composants Resolve Entities (Résoudre les entités) ou Common Response (Réponse commune) demandent, les utilisateurs peuvent fournir des valeurs supplémentaires qui déclenchent l'extraction de valeurs dans le désordre et des mises à jour dans d'autres entités de l'entité composite.
${system.entityToResolve.value.outOfOrderMatches[n].name} Retourne le nom de l'élément d'entité composite.
${system.entityToResolve.value.outOfOrderMatches? has_content?then(…,…)} Retourne la valeur d'une entité qui a été mise en correspondance dans le désordre. Comme il n'existe probablement aucune entité dans ce cas, cette expression utilise l'opérateur has_content.

Programmes de traitement d'événements d'entité

Vous pouvez exécuter la validation, l'invite et la désambiguïté des éléments d'entité composite par programmation à l'aide des programmes de traitement d'événements d'entité. Un programme de traitement d'événements d'entité (EEH) est une mise en oeuvre JavaScript (ou TypeScript) créée pour une entité composite et déployée en tant que service de code personnalisé.
Note

Vous pouvez gérer le service déployé pour EEH à partir de la page Components (Composants) Illustration de l'icône Composants dans la barre de navigation gauche..
Vous pouvez contrôler le comportement de résolution pour les éléments d'entité composite individuels et pour l'entité elle-même en définissant les fonctions du programme de traitement d'événements fournies par bots-node-sdk. Par exemple, l'extrait de code suivant illustre la définition d'un événement validate sur un élément d'entité appelé ExpenseDate qui empêche les utilisateurs d'entrer une date future lors du dépôt d'un rapport de frais.
ExpenseDate: {

        validate: async (event, context) => {
          if (new Date(event.newValue.date) > new Date()) {
            context.addValidationError("ExpenseDate",context.translate('ExpenseDate.text'));
            return false;
          }          
        }
La documentation Écriture des programmes de traitement d'événements d'entité de bots-node-sdk décrit la structure globale du code du programme de traitement d'événements, les événements au niveau de l'élément et de l'entité, ainsi que les méthodes EntityResolutionContext telles que addValidationError et translate dans l'extrait de code ci-dessus.

Comme les programmes de traitement d'événements d'entité sont écrits dans JavaScript, vous pouvez utiliser une logique avancée qui n'est pas facile à atteindre, voire réalisable, avec les expressions FreeMarker que vous pouvez utiliser pour définir la validation, les erreurs et les invites dans la page de modification d'élément d'entité composite et le flux de dialogue. Ils sont également plus faciles à déboguer. Cela dit, vous n'avez pas à choisir les expressions FreeMarker des programmes de traitement d'événements d'entité. Vous pouvez combiner les deux méthodes. Par exemple, vous pouvez utiliser des expressions FreeMarker pour des validations et des invites simples et réserver un EEH pour des fonctions plus complexes telles que l'appel d'une API REST lorsque tous les éléments de l'entité composite ont été résolus.

Créer des programmes de traitement d'événements avec l'éditeur de code de programme de traitement d'événements

Vous pouvez créer l'EEH à l'aide de l'éditeur de code du programme de traitement d'événements accessible à partir de la page des propriétés de l'entité composite ou de l'environnement IDE de votre choix. Bien que l'éditeur de code du gestionnaire d'événements présente certains avantages par rapport à un outil tiers, vous pouvez alterner avec un environnement IDE tiers en fonction de la taille de la tâche et des bibliothèques dont vous avez besoin. Pour peser le pour et le contre, voir Quel IDE dois-je utiliser?

Pour accéder à l'éditeur de code de programme de traitement d'événements :
  1. Cliquez sur + Gestionnaire d'événements.
  2. Complétez la boîte de dialogue Create Event Handler (Créer un gestionnaire d'événements) en ajoutant un nom de service et un nom de gestionnaire.

Après avoir créé le programme de traitement, vous pouvez ouvrir l'éditeur en cliquant sur Ceci est une image de l'icône Edit (Modifier)..

L'éditeur est alimenté avec un code de démarrage. Son objet handlers contient des objets entity, items et custom. Dans ces objets, vous définissez des événements au niveau de l'événement, qui sont déclenchés pour l'ensemble de l'entité composite, les événements au niveau de l'article, qui contrôlent la résolution des éléments d'entité individuels, et les événements personnalisés qui sont déclenchés lors des actions de republication. Par défaut, un objet entity est défini pour l'objet handler. Les objets items et custom sont alimentés lorsque vous ajoutez un modèle personnalisé ou au niveau de l'article.
Une description de eeh-default-template.png suit
Description de l'illustration eeh-default-template.png

Les événements eux-mêmes sont des fonctions JavaScript asynchrones qui prennent deux arguments :
  • event : Un objet JSON des propriétés propres à l'événement.
  • context : Référence à la classe EntityResolutionContext, dont les méthodes (telles que addValidationError dans l'extrait de code suivant) fournissent la logique du programme de traitement d'événements.
items: {
  Amount: { 
    validate: async (event, context) => {
      let amount = event.newValue.amount;
      if (amount < 5) {
        context.addValidationError("Amount",`Amounts below 5 ${event.newValue.currency} cannot be expensed. Enter a higher amount or type 'cancel'.`);
      }
    }
  }
Pour accéder aux modèles, cliquez sur + Add Event (Ajouter un événement).
Note

Reportez-vous à la documentation Écriture des programmes de traitement d'événements d'entité de bots-node-sdk pour plus d'informations sur le code de démarrage EEH, les événements au niveau de l'élément et de l'entité, EntityResolutionContext et les exemples de code.
Ajouter des événements
Cliquez sur + Ajouter un événement pour ajouter les modèles d'événement, d'article et d'événement personnalisé.

Par exemple, l'ajout d'un modèle d'événement validate alimente l'éditeur avec le code suivant :
validate: async (event, context) => {
        
      },
Vous pouvez ensuite mettre à jour ce modèle avec votre propre code :
validate: async (event, context) => {
     if (event.newValue.value === 'PEPPERONI')
       context.addValdiationError('Type', "Sorry, no pepperoni pizzas today!");     
      },
Le fait de cliquer sur Validate (Valider) lance la recherche d'éventuels problèmes de conception dans votre. Vous devez donc cliquer régulièrement sur cette option. Vous ne pouvez pas ajouter d'autres événements si le code n'est pas valide, ni enregistrer un code non valide. Comme l'enregistrement du code signifie également son déploiement, vous ne pouvez pas non plus déployer du code non valide.

Lorsque votre code est valide, cliquez sur Save (Enregistrer) pour le déployer automatiquement et créer un fichier TGZ. La page Components (Composants) sert à surveiller le statut du déploiement et à télécharger le fichier TGZ pour le réutiliser dans d'autres compétences.

Conseil :

Pour vérifier les erreurs d'exécution, activez Enable Component Logging (Activer la journalisation de composant), puis révisez les journaux (accessibles en cliquant sur Diagnostics > View Logs (Consulter les journaux)) pour en savoir plus sur les paramètres qui ont appelé les événements.
Dans la page d'entité composite, le statut Ready (Prêt) Ceci est une image de l'icône de statut Prêt. et l'icône Edit (Modifier) icône Modifier pour réviser votre code deviennent disponibles après le déploiement du service.

Ajouter des programmes de traitement d'événements au niveau de l'entité
Pour les événements de niveau entité, vous pouvez mettre à jour les modèles pour les événements de niveau entité validate, publishMessage, maxPromptsReached, resolved, attachmentReceived et locationReceived.

Événement Description
validate Programme de traitement pour les validations au niveau de l'entité qui est appelé lorsque la valeur d'au moins un des éléments de l'entité a été modifiée.
publishMessage Programme de traitement de secours générique appelé chaque fois qu'un élément d'entité composite n'a pas de message d'invite ou de traitement de désambiguïsation.
maxPromptsReached Programme de traitement de secours générique appelé lorsque le programme de traitement spécifique à l'élément relatif au nombre maximum d'invites atteint n'a pas été indiqué.
resolved Cette fonction est appelée lorsque l'entité composite a été résolue. En général, vous ajoutez un événement resolved pour appeler une API dorsale qui termine une transaction liée aux valeurs collectées par l'entité composite. Si l'appel d'API retourne des erreurs car certaines valeurs collectées par l'entité composite ne sont pas valides, vous pouvez effacer ces valeurs.
attachmentReceived Ce programme de traitement est appelé lorsque l'utilisateur envoie un fichier joint.
locationReceived Ce programme de traitement est appelé lorsque l'utilisateur envoie un emplacement.
Par défaut, le modèle est alimenté avec un événement au niveau de l'entité, publishMessage. Au moyen des fonctions updatedItemMessage et outOfOrderItemsMessage (qui sont également définies dans le modèle par défaut), cet événement permet à la compétence de sortir des messages confirmant qu'une valeur d'élément d'entité ayant déjà été résolue a été mise à jour ou qu'elle a accepté une entrée valide pour un élément d'entité autre que celui demandé par l'entité (entrée dans le désordre).

Cet événement est facultatif. Vous pouvez la supprimer, la laisser telle quelle ou y ajouter des fonctionnalités. Par exemple, vous pouvez ajouter un bouton d'annulation lorsque les tentatives d'entrée d'une valeur valide par l'utilisateur ont dépassé le nombre maximal d'invites.
publishMessage: async (event, context) => {
        updatedItemsMessage(context);
        outOfOrderItemsMessage(context);
        //Add Cancel button for invalid values entered by users
        let message = context.getCandidateMessageList()[0];
      }
…
message.addGlobalAction(context.getMessageFactory().createPostbackAction('Cancel', {action:'cancel'}));
        context.addMessage(message);      }
}
Ajouter des programmes de traitement au niveau de l'élément
Pour les éléments d'entité composite répertoriés dans la boîte de dialogue, vous pouvez ajouter des modèles pour les événements de niveau élément : shouldPrompt, validate, publishPromptMessage, publishDisambiguateMessage et MaxPromptsReached.

Événement Description
shouldPrompt Invites pour un élément en fonction des valeurs des autres éléments de l'entité. Ce programme de traitement a priorité sur l'invite configurée dans le champ Prompt for Value (Invite de valeur).
validate Ce programme de traitement n'est appelé que lorsqu'une valeur a été définie pour un élément d'entité composite. Si la validité de la valeur dépend d'autres éléments d'entité, vous devez mettre en oeuvre l'événement validate au niveau de l'entité.
publishPromptMessage Utilisez cette fonction pour remplacer ou étendre le message généré par les groupes de pages Réponse commune et Résoudre les entités pour demander l'élément.
publishDisambiguateMessage Utilisez cette fonction pour remplacer ou étendre le message d'invite de désambiguïsation généré par les groupes de pages Réponse commune et Résoudre les entités.
maxPromptsReached Cette fonction est appelée lorsque le nombre maximal d'invites pour cet élément, spécifié par Maximum User Input Attempts (Nombre maximum de tentatives d'entrée utilisateur) dans l'écran de l'élément d'entité composite, a été atteint.

L'ajout d'un événement de niveau élément génère l'objet items.
Description de eeh-items-block.png :
Description de l'illustration eeh-items-block.png

Ajouter des événements personnalisés
Vous pouvez créer des événements personnalisés appelés à partir d'actions de republication (boutons ou éléments de liste) à l'aide du modèle d'événement personnalisé.

L'ajout d'un modèle personnalisé ajoute un objet custom avec le code d'événement de base. Pour des exemples de mise en oeuvre d'un événement personnalisé, reportez-vous à la documentation Écriture des programmes de traitement d'événements d'entité de bots-node-sdk.
someCustomEvent: async (event, context) => {
  
}

Remplacer ou supprimer un programme de traitement d'événements d'entité

Si vous devez remplacer ou supprimer un EEH :
  1. Sélectionnez une ligne vide dans le menu Gestionnaire d'événements pour réactiver le bouton + Programme de traitement d'événements.

  2. Ouvrez la page Components (Composants) Illustration de l'icône Composants dans la barre de navigation gauche.. Désactivez Service Enabled (Service activé) ou supprimez le service.
    Note

    Vous ne pouvez pas supprimer ou désactiver un service si l'élément EEH est toujours associé à l'entité composite.
  3. Si nécessaire, ajoutez un nouvel EEH à l'entité composite ou, si vous n'optez pas pour un nouvel EEH, vous pouvez ajouter la logique de résolution avec des expressions FreeMarker.

Conseil :

La suppression de l'entité composite supprimera également le service déployé pour l'entité EEH.

Quel IDE dois-je utiliser?

Vous pouvez créer un EEH à l'aide de l'environnement IDE de votre choix, puis déployer le code à l'aide d'un fichier TGZ créé manuellement avec bots-node-sdk pack, ou utiliser l'éditeur de code de programme de traitement d'événements que nous fournissons. Lorsque vous utilisez notre éditeur, vous n'avez pas besoin de configurer votre environnement de développement, ni de créer un ensemble pour votre code et de le déployer. Le code est déployé automatiquement après son enregistrement. Vous pouvez également réviser le code directement sans avoir à le déployer, ce qui n'est pas possible lorsque vous créez et déployez un programme de traitement avec votre propre environnement IDE. Vous ne pouvez pas ajouter d'autres ensembles NPM à l'aide de l'éditeur de code de programme de traitement d'événements. Vous aurez besoin d'un autre IDE. Par exemple, si vous voulez utiliser Moment.js pour travailler avec des dates, vous devez télécharger le fichier TGZ, ajouter la bibliothèque à l'aide de l'environnement IDE de votre choix, puis recréer un ensemble et déployer le fichier TGZ. Après cela, vous pouvez continuer à utiliser l'éditeur Event Handler Code (Code de programme de traitement d'événements).

Conseil :

L'éditeur Event Handler Code (Code de programme de traitement d'événements) peut être préférable pour les petits changements. Si vous devez effectuer des modifications plus importantes ou ajouter des ensembles NPM, vous pouvez télécharger le fichier TGZ à partir de la page Components (Composants), le décompresser, puis utiliser votre éditeur préféré pour modifier le code avant de recréer l'ensemble et de le déployer.

Simplifier les flux de dialogue avec les programmes de traitement d'événements d'entité

Les programmes de traitement d'événements d'entité peuvent simplifier la définition de votre flux de dialogue, car ils sont utilisés avec la meilleure pratique de raccourcissement de dialogue qui est les entités composites. En ce qui concerne les services dorsaux, ils rendent votre définition de flux de dialogue moins compliquée parce que vous n'avez pas besoin d'écrire un état séparé pour le composant personnalisé qui les appelle.

Les programmes de traitement d'événements simplifient la définition du flux de dialogue d'une autre manière : ils vous permettent de modifier les messages générés par le groupe de pages Résoudre entités. Par exemple, vous pouvez créer un carrousel de messages de carte sans utiliser la structure complexe de la propriété metadata du composant de réponse commune. Vous pouvez ajouter le carousel à l'aide de code simple, ce qui signifie que vous pouvez également ajouter des réponses de carte au groupe de pages Résoudre entités. Par exemple, ce code permet au groupe de pages Résoudre entités de produire un carrousel de cartes défilant horizontalement pour le type de pizza, chaque carte ayant un bouton d'annulation :
Type: {

        publishPromptMessage: async (event, context) => {
          let candidateMessage = context.getCandidateMessageList()[0];
          const mf = context.getMessageFactory();
          const message = mf.createCardMessage()
            .setLayout(horizontal)
            .setCards(context.getEnumValues().map(p => {
                      mf.createCard(p.value)
                        .setDescription(pizzaInfo[p.value].description)
                        .setImageUrl(pizzaInfo[p.value].image)
                        .addAction(mf.createPostbackAction('Order',{variables: {pizza: p.value}}));
                      })
            .setGlobalActions(candidateMessage.getGlobalActions());
          context.addMessage(message);
        }

Tutoriels du programme de traitement d'événements d'entité

Suivez ce tutoriel pour vous familiariser avec les programmes de traitement d'événements d'entité et l'utilisation de l'éditeur. Consultez ensuite ce tutoriel avancé pour créer un programme de traitement d'événements d'entité avec un environnement IDE externe et bots-node-sdk.

Désambiguïser les articles et sous-types de sac imbriqués

L'entité composite demandera toujours des valeurs par ordre d'article dicté par la structure hiérarchique d'un article d'entité imbriquée. Il ne créera pas aveuglément de valeurs pour plusieurs éléments. Il tente plutôt de faire correspondre la valeur du message utilisateur uniquement à l'élément qu'il demande actuellement. Lorsque l'entrée utilisateur ne correspond pas à l'élément courant ou pourrait potentiellement correspondre à plusieurs éléments, comme c'est le cas pour startTime et endTime pour un sous-type INTERVAL, elle présente aux utilisateurs la valeur définie pour la propriété Étiquette pour clarifier l'entrée demandée.

Conseil :

Comme pour toutes les chaînes, nous vous recommandons de définir la valeur de l'étiquette en tant qu'ensemble de ressources.

Ajouter l'entité DATE_TIME à un sac composite

Pour permettre à votre compétence de gérer des scénarios complexes qui nécessitent plusieurs invites d'utilisateur telles que la programmation d'une réunion ou la définition d'un événement récurrent, vous devez créer un élément d'entité composite DATE_TIME, puis configurer les attributs des sous-types Interval, Récurrent, Date et Heure et leurs éléments d'entité imbriquée respectifs.
Note

Bien que vous puissiez utiliser la date, l'heure et la durée en tant qu'entités autonomes, nous vous recommandons de les utiliser dans des entités composites.
  1. Avant de créer un élément d'entité DATE_TIME, configurez les règles de résolution de l'ambiguïté de date et d'heure appropriées pour votre cas d'utilisation. Par exemple, si vous créez une compétence de production de rapports de frais, sélectionnez Précédent. Si la compétence est un programmateur de réunion, sélectionnez Futur.
  2. Dans l'entité composite, cliquez sur Ajouter un élément.
  3. Sélectionnez Entité dans le menu Type.
  4. Sélectionnez DATE_TIME dans le menu Nom de l'entité.
  5. Sélectionnez un sous-type DATE_TIME dans le menu Sous-type.

    Les options de configuration de la page Ajout articles sac changent en fonction du sous-type sélectionné. Par exemple, si vous sélectionnez le sous-type Récurrent, vous pouvez accéder aux options de configuration des éléments d'entité imbriquée spécifiques à la définition d'un événement répétitif, tels que l'objet Date et heure pour la date et l'heure de début initiales et l'objet Durée pour la définition de la fréquence de l'événement.

  6. Si vous avez sélectionné les sous-types Récurrent ou Intervalle :
    • Définissez les valeurs de sous-type que l'entité composite invite à partir du menu Invite pour.
    • Comme les réunions commencent et se terminent généralement le même jour, activez Date de fin par défaut à la date de début pour le sous-type startDate. Cela définit la date de fin comme étant égale à la date de début lorsque le message de l'utilisateur ne mentionne pas la date de fin (ou lorsque la date de fin n'est pas extraite dans le désordre).
      Ceci est une image du basculement entre la date de début et la date de fin par défaut.

  7. Facultativement, ajoutez une étiquette d'homonymie si l'entrée utilisateur peut correspondre à plusieurs sous-types.

    Conseil :

    Vous pouvez également configurer les propriétés qui ne sont pas propres à DATE_TIME, telles que le remplissage amélioré des emplacements, la mise à jour des valeurs de référencement avec Apache FreeMarker, les invites personnalisées et les messages d'erreur.
  8. Vous pouvez accéder à la configuration au niveau du sous-type en cliquant sur un sous-type. Utilisez le parcours pour revenir à la configuration au niveau de l'élément.
    Ceci est une image de la traversée Edit Bag Item.

  9. Étapes suivantes :
    • Associez l'entité composite à l'intention.
    • Déclarez une variable pour l'entité dans le flux de dialogue.
    • Dans le flux de dialogue, référencez l'entité composite avec l'élément DATE_TIME à l'aide de l'état Résoudre l'entité composite.
    • Les valeurs DATE_TIME sont représentées sous la forme ISO 8601. Pour une sortie conviviale, utilisez la version intégrée d'Apache FreeMarker .xs. Dans l'extrait de code suivant, la valeur du sous-type Heure est formatée à l'aide de .value?time.xs?string['hh:mm a'].
      Your pizza will be delivered at ${pizza.value.deliveryTime.value?time.xs?string['hh:mm a']}.
      
      Au lieu de référencer l'élément DATE_TIME en tant que chaîne, vous pouvez suivre l'approche de meilleure pratique consistant à le référencer dans un ensemble de ressources, par exemple DeliveryMessage dans l'exemple suivant.
      ${rb('DeliveryMessage','time',pizza.value.deliveryTime.value?time.xs?string['hh:mm a'])}
      
      Pour le message d'ensemble de ressources DeliveryMessage, la valeur est affichée au moyen du paramètre {time} :
      Your pizza will be delivered at {time}.
      

Tutoriel : Extraction d'entités réelles avec des entités composites

Vous pouvez procéder à la création d'une entité composite au moyen de ce tutoriel : Activer l'extraction d'entités réelles avec des entités composites.