Avis de fin de support : le 15 septembre 2025, le support pour Amazon Lex V1 AWS sera interrompu. Après le 15 septembre 2025, vous ne pourrez plus accéder à la console Amazon Lex V1 ni aux ressources Amazon Lex V1. Si vous utilisez Amazon Lex V2, consultez plutôt le [guide Amazon Lex V2](https://docs.aws.amazon.com/lexv2/latest/dg/what-is.html).
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Planifier un rendez-vous
L'exemple de bot de cet exercice planifie des rendez-vous pour un cabinet dentaire. L'exemple illustre également l'utilisation de cartes de réponse pour obtenir des entrées de l'utilisateur avec des boutons. Plus précisément, l'exemple illustre la génération dynamique de cartes de réponse lors de l'exécution.
Vous pouvez configurer des cartes de réponse au moment de la création (également appelées cartes de réponse statiques) ou les générer dynamiquement dans une AWS Lambda fonction. Dans cet exemple, le bot utilise les cartes de réponse suivantes :
+ Une carte de réponse qui affiche des boutons pour le type de rendez-vous. L’image suivante illustre un exemple :
![\[Carte-réponse indiquant le type de rendez-vous à fixer et trois options : nettoyage (30 minutes), canal radiculaire (60 minutes) et blanchiment (90 minutes).\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/respcard-10.png)
+ Une carte de réponse qui affiche des boutons pour la date de rendez-vous. L’image suivante illustre un exemple :
![\[Carte-réponse demandant la date pour fixer le rendez-vous et trois options : 2-15, 2-16 et 2-17.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/respcard-20.png)
+ Une carte de réponse qui affiche des boutons pour confirmer une heure de rendez-vous suggérée. L’image suivante illustre un exemple :
![\[Carte-réponse demandant la confirmation de l'heure et de la date du rendez-vous, avec deux options : oui et non.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/respcard-30.png)
Les dates et heures de rendez-vous disponibles varient, ce qui nécessite que vous génériez des cartes de réponse lors de l'exécution. Vous utilisez une AWS Lambda fonction pour générer ces cartes de réponse de manière dynamique. La fonction Lambda renvoie des cartes de réponse dans sa réponse à Amazon Lex. Amazon Lex inclut la carte-réponse dans sa réponse au client.
Si un client (par exemple, Facebook Messenger) prend en charge les cartes de réponse, l'utilisateur peut choisir dans la liste de boutons ou saisir la réponse. Sinon, l'utilisateur saisit simplement la réponse.
Outre le bouton affiché dans l'exemple précédent, vous pouvez également inclure des images, des pièces jointes et d'autres informations utiles à afficher sur les cartes de réponse. Pour plus d'informations sur les cartes de réponse, consultez [Cartes de réponse](howitworks-manage-prompts.md#msg-prompts-resp-card).
Dans cet exercice, vous effectuez les opérations suivantes :
+ Créez et testez un bot (à l'aide du ScheduleAppointment plan). Dans cet exercice, vous allez utiliser un modèle de présentation de bot pour configurer rapidement le bot et le tester. Pour obtenir une liste des modèles de présentation disponibles, consultez [Amazon Lex et AWS Lambda Blueprints](lex-lambda-blueprints.md).Cet bot est préconfiguré avec une intention (`MakeAppointment`).
+ Créez et testez une fonction Lambda (à l'aide du lex-make-appointment-python plan fourni par Lambda). Vous configurez l'`MakeAppointment`intention d'utiliser cette fonction Lambda comme crochet de code pour effectuer des tâches d'initialisation, de validation et d'exécution.
**Note**
L'exemple de fonction Lambda fourni présente une conversation dynamique basée sur la disponibilité simulée d'un rendez-vous chez le dentiste. Dans une application réelle, vous pouvez utiliser un calendrier réel pour définir un rendez-vous.
+ Mettez à jour la configuration d'`MakeAppointment`intention pour utiliser la fonction Lambda comme crochet de code. Ensuite, testez l' end-to-endexpérience.
+ Publiez le bot de prise de rendez-vous sur Facebook Messenger afin de voir les cartes-réponses en action (le client de la console Amazon Lex ne prend actuellement pas en charge les cartes-réponses).
Les sections suivantes fournissent des informations récapitulatives sur les modèles de présentation que vous utilisez dans le cadre de cet exercice.
**Topics**
+ [Présentation du plan du bot () ScheduleAppointment](#ex1-sch-appt-bp-summary-bot)
+ [Présentation du plan directeur de la fonction Lambda () lex-make-appointment-python](#ex1-sch-appt-summary-lambda)
+ [Étape 1 : créer un robot Amazon Lex](ex1-sch-appt-create-bot.md)
+ [Étape 2 : Création d'une fonction Lambda](ex1-sch-appt-create-lambda-function.md)
+ [Etape 3 : Mise à jour l'intention : configuration d'un hook de code](ex1-sch-appt-create-integrate.md)
+ [Etape 4 : Déploiement du bot sur la plateforme Facebook Messenger](ex-sch-appt-fb-integration.md)
+ [Détails du flux d'informations](ex1-sch-appt-info-flow-details.md)
## Présentation du plan du bot () ScheduleAppointment
Le ScheduleAppointment plan que vous utilisez pour créer un bot pour cet exercice est préconfiguré comme suit :
+ **Types d'option** – Un type d'option personnalisé appelé `AppointmentTypeValue` avec les valeurs d'énumération : `root canal`, `cleaning` et `whitening`.
+ **Intention** – Une intention (`MakeAppointment`) qui est préconfigurée comme suit :
+ **Options** – L'intention est configurée avec les options suivantes :
+ Option `AppointmentType`, du type d'option personnalisé `AppointmentTypes`.
+ Option `Date`, du type d'option prédéfini `AMAZON.DATE`.
+ Option `Time`, du type d'option prédéfini `AMAZON.TIME`.
+ **Enoncés** – L'intention est préconfigurée avec les énoncés suivants :
+ « I would like to book an appointment »
+ « Book an appointment »
+ « Réservez un \$1AppointmentType\$1 »
Si l'utilisateur prononce l'une de ces phrases, Amazon Lex détermine son intention, puis utilise les instructions pour obtenir les données des créneaux. `MakeAppointment`
+ **Invites** – L'intention est préconfigurée avec les invites suivantes :
+ Invite de l'option `AppointmentType` – « What type of appointment would you like to schedule? »
+ Demande de `Date` créneau — « Quand dois-je planifier votre \$1AppointmentType\$1 ? »
+ Demande de `Time` créneau — « À quelle heure souhaitez-vous planifier le \$1AppointmentType\$1 ? » and
« At what time on \$1Date\$1? »
+ Invite de confirmation – « \$1Time\$1 is available, should I go ahead and book your appointment? »
+ Message d'annulation – : « Okay, I will not schedule an appointment. »
## Présentation du plan directeur de la fonction Lambda () lex-make-appointment-python
La fonction Lambda blueprint (lex-make-appointment-python) est un crochet de code pour les robots que vous créez à l'aide du plan du ScheduleAppointment bot.
Ce code de modèle de fonction Lambda peut effectuer à la fois des tâches initialization/validation et des tâches d'exécution.
+ Le code de fonction Lambda présente une conversation dynamique basée sur un exemple de disponibilité pour un rendez-vous chez le dentiste (dans les applications réelles, vous pouvez utiliser un calendrier). Pour le jour ou la date que l'utilisateur spécifie, le code est configuré comme suit :
+ Si aucun rendez-vous n'est disponible, la fonction Lambda renvoie une réponse demandant à Amazon Lex de demander à l'utilisateur de fixer un autre jour ou une autre date (en définissant le `dialogAction` type sur). `ElicitSlot)` Pour de plus amples informations, veuillez consulter [Format de la réponse](lambda-input-response-format.md#using-lambda-response-format).
+ S'il n'y a qu'un seul rendez-vous disponible le jour ou la date spécifiés, la fonction Lambda suggère l'heure disponible dans la réponse et demande à Amazon Lex d'obtenir la confirmation de l'utilisateur en définissant le `dialogAction` dans la réponse sur. `ConfirmIntent` Ceci illustre la manière dont vous pouvez améliorer l'expérience utilisateur en suggérant de manière proactive l'horaire disponible pour un rendez-vous.
+ Si plusieurs rendez-vous sont disponibles, la fonction Lambda renvoie une liste des heures disponibles dans la réponse à Amazon Lex. Amazon Lex renvoie une réponse au client contenant le message de la fonction Lambda.
+ En tant que crochet du code d'expédition, la fonction Lambda renvoie un message récapitulatif indiquant qu'un rendez-vous est planifié (c'est-à-dire que l'intention est remplie).
**Note**
Dans cet exemple, nous montrons comment utiliser des cartes de réponse. La fonction Lambda crée et renvoie une carte de réponse à Amazon Lex. La carte de réponse répertorie les jours et heures disponibles sous forme de boutons à choisir. Lorsque vous testez le bot à l'aide du client fourni par la console Amazon Lex, vous ne pouvez pas voir la carte-réponse. Pour la voir, vous devez intégrer le bot avec une plateforme de messagerie, comme Facebook Messenger. Pour obtenir des instructions, veuillez consulter [Intégration d'un robot Amazon Lex à Facebook Messenger](fb-bot-association.md). Pour plus d'informations sur les cartes de réponse, consultez [Gestion des messages](howitworks-manage-prompts.md).
Lorsqu'Amazon Lex appelle la fonction Lambda, il transmet les données d'événement en entrée. L'un des champs d'événement est `invocationSource` celui que la fonction Lambda utilise pour choisir entre une activité de validation des entrées et une activité d'exécution. Pour de plus amples informations, veuillez consulter [Format d'un événement d'entrée](lambda-input-response-format.md#using-lambda-input-event-format).
**Étape suivante**
[Étape 1 : créer un robot Amazon Lex](ex1-sch-appt-create-bot.md)
# Étape 1 : créer un robot Amazon Lex
Dans cette section, vous allez créer un bot Amazon Lex à l'aide du ScheduleAppointment plan fourni dans la console Amazon Lex.
1. Connectez-vous à la console Amazon Lex AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Sur la page **Bots**, choisissez **Créer**.
1. Sur la page **Create your Lex bot**, procédez comme suit :
+ Choisissez le modèle **ScheduleAppointment**.
+ Laissez le nom du bot par défaut (ScheduleAppointment).
1. Choisissez **Créer**.
Cette étape enregistre et crée le bot. La console envoie les demandes suivantes à Amazon Lex pendant le processus de création :
+ Création d'une nouvelle version des types d'option (à partir de la version \$1LATEST). Pour plus d'informations sur les types d'option définis dans ce modèle de présentation de bot, consultez [Présentation du plan du bot () ScheduleAppointment](ex1-sch-appt.md#ex1-sch-appt-bp-summary-bot).
+ Création d'une version de l'intention `MakeAppointment` (à partir de la version &LATEST). Dans certains cas, la console envoie une demande pour l'opération d'API `update` avant de créer une nouvelle version.
+ Mise à jour de la version \$1LATEST du bot.
Amazon Lex développe actuellement un modèle d'apprentissage automatique pour le bot. Lorsque vous testez le bot dans la console, celle-ci utilise l'API d'exécution pour renvoyer les données de l'utilisateur à Amazon Lex. Amazon Lex utilise ensuite le modèle d'apprentissage automatique pour interpréter les données saisies par l'utilisateur.
1. La console affiche le ScheduleAppointment bot. Dans l'onglet **Editor**, passez en revue les détails de l'intention préconfigurée (`MakeAppointment`).
1. Testez le bot dans la fenêtre de test. Utilisez la capture d'écran suivante pour engager une conversation test avec le bot :
![\[Conversation avec un agent, au cours de laquelle l'agent demande le type de rendez-vous, la date et l'heure du rendez-vous, puis confirme les détails du rendez-vous.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/appt-test-no-lambda.png)
Notez ce qui suit :
+ A partir de l'entrée utilisateur initiale (« Book an appointment »), le bot déduit l'intention (`MakeAppointment`).
+ Le bot utilise ensuite les invites préconfigurées pour obtenir des données d'option auprès de l'utilisateur.
+ Le modèle de présentation de bot comporte l'intention `MakeAppointment` configurée avec l'invite de confirmation suivante :
```
{Time} is available, should I go ahead and book your appointment?
```
Une fois que l'utilisateur a fourni toutes les données d'emplacement, Amazon Lex renvoie une réponse au client avec un message de confirmation. Le client affiche le message pour l'utilisateur :
```
16:00 is available, should I go ahead and book your appointment?
```
Notez que le bot accepte les valeurs de date et d'heure de rendez-vous, car vous n'avez aucun code pour initialiser ou valider les données utilisateur. Dans la section suivante, vous allez ajouter une fonction Lambda à cet effet.
**Étape suivante**
[Étape 2 : Création d'une fonction Lambda](ex1-sch-appt-create-lambda-function.md)
# Étape 2 : Création d'une fonction Lambda
Dans cette section, vous allez créer une fonction Lambda à l'aide d'un blueprint (lex-make-appointment-python) fourni dans la console Lambda. Vous testez également la fonction Lambda en l'invoquant à l'aide d'exemples de données d'événements Amazon Lex fournis par la console.
1. Connectez-vous à la AWS Lambda console AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Choisissez **Create a Lambda function**.
1. Pour **Sélectionner un plan**, tapez **lex** pour trouver le plan, puis choisissez le **lex-make-appointment-python**plan.
1. Configurez la fonction Lambda comme suit.
+ Entrez le nom de la fonction Lambda ()`MakeAppointmentCodeHook`.
+ Pour le rôle, choisissez **Create a new role from template(s)** et tapez un nom de rôle.
+ Laissez les autres valeurs par défaut.
1. Choisissez **Créer une fonction**.
1. Si vous utilisez une langue autre que l'anglais (États-Unis) (en-US), mettez à jour les noms d'intention comme décrit dans[Mettre à jour un plan pour un environnement régional spécifique](lex-lambda-blueprints.md#blueprint-update-locale).
1. Testez la fonction Lambda.
1. Choisissez **Actions**, puis **Configure test event**.
1. Dans la liste **Sample event template**, choisissez **Lex-Make Appointment (preview)**. Cet exemple d'événement utilise le request/response modèle Amazon Lex, avec des valeurs définies pour correspondre à une demande de votre bot Amazon Lex. Pour plus d'informations sur le request/response modèle Amazon Lex, consultez[Utilisation des fonctions Lambda](using-lambda.md).
1. Choisissez **Save and test**.
1. Vérifiez que la fonction Lambda s'est correctement exécutée. Dans ce cas, la réponse correspond au modèle de réponse Amazon Lex.
**Étape suivante**
[Etape 3 : Mise à jour l'intention : configuration d'un hook de code](ex1-sch-appt-create-integrate.md)
# Etape 3 : Mise à jour l'intention : configuration d'un hook de code
Dans cette section, vous allez mettre à jour la configuration de l'`MakeAppointment`intention d'utiliser la fonction Lambda comme code hook pour les activités de validation et d'exécution.
1. Dans la console Amazon Lex, sélectionnez le ScheduleAppointment bot. La console indique l'**MakeAppointment**intention. Modifiez la configuration de l'intention comme suit.
**Note**
Vous ne pouvez mettre à jour que les versions \$1LATEST de toutes les ressources Amazon Lex, y compris les intentions. Assurez-vous que la version d'intention est définie sur \$1LATEST. Vous n'avez pas encore publié une version de votre bot. Celui-ci doit donc toujours être à la version \$1LATEST dans la console.
1. Dans la section **Options**, choisissez **Initialization and validation code hook**, puis choisissez la fonction Lambda dans la liste.
1. Dans la section **Fulfillment**, choisissez la **fonction AWS Lambda**, puis choisissez la fonction Lambda dans la liste.
1. Choisissez **Goodbye message** et entrez un message.
1. Choisissez **Enregistrer**, puis **Création**.
1. Testez le bot, comme dans l'image suivante :
![\[Conversation avec un agent, au cours de laquelle l'agent demande le type de rendez-vous, la date et l'heure du rendez-vous, puis confirme le rendez-vous.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/appt-test-with-lambda.png)
**Étape suivante**
[Etape 4 : Déploiement du bot sur la plateforme Facebook Messenger](ex-sch-appt-fb-integration.md)
# Etape 4 : Déploiement du bot sur la plateforme Facebook Messenger
Dans la section précédente, vous avez testé le ScheduleAppointment bot à l'aide du client dans la console Amazon Lex. Actuellement, la console Amazon Lex ne prend pas en charge les cartes de réponse. Pour tester les cartes de réponse générées dynamiquement que le bot prend en charge, déployez le bot sur la plateforme Facebook Messenger et testez-la.
Pour obtenir des instructions, veuillez consulter [Intégration d'un robot Amazon Lex à Facebook Messenger](fb-bot-association.md).
**Étape suivante**
[Détails du flux d'informations](ex1-sch-appt-info-flow-details.md)
# Détails du flux d'informations
Le modèle de bot `ScheduleAppointment` illustre l'utilisation de cartes de réponse générées dynamiquement. Dans cet exercice, la fonction Lambda inclut des cartes de réponse dans sa réponse à Amazon Lex. Amazon Lex inclut les cartes-réponses dans sa réponse au client. Cette section décrit les deux éléments suivants :
+ Flux de données entre le client et Amazon Lex.
La section part du principe que le client envoie des demandes à Amazon Lex à l'aide de l'API `PostText` d'exécution et affiche request/response les détails correspondants. Pour plus d'informations sur l'API d'exécution `PostText`, consultez [PostText](API_runtime_PostText.md).
**Note**
Pour un exemple de flux d'informations entre le client et Amazon Lex dans lequel le client utilise l'`PostContent`API, consultez[Étape 2a (facultatif) : Vérification des détails du flux d'informations vocales (console)](gs-bp-details-postcontent-flow.md).
+ Flux de données entre Amazon Lex et la fonction Lambda. Pour de plus amples informations, veuillez consulter [Format d'événement et de réponse d'entrée de la fonction Lambda](lambda-input-response-format.md).
**Note**
L'exemple suppose que vous utilisez le client Facebook Messenger, qui ne transmet pas les attributs de session dans la demande à Amazon Lex. En conséquence, les exemples de demandes illustrés dans cette section montrent le champ `sessionAttributes` vide. Si vous testez le bot à l'aide du client fourni dans la console Amazon Lex, le client inclut les attributs de session.
Cette section décrit ce qui se passe après chaque entrée utilisateur.
1. Utilisateur : Types **Book an appointment**.
1. Le client (console) envoie la demande [PostContent](API_runtime_PostContent.md) suivante à Amazon Lex :
```
POST /bot/ScheduleAppointment/alias/$LATEST/user/bijt6rovckwecnzesbthrr1d7lv3ja3n/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"book appointment",
"sessionAttributes":{}
}
```
L'URI et le corps de la demande fournissent des informations à Amazon Lex :
+ URI de demande — Fournit le nom du bot (ScheduleAppointment), l'alias du bot (\$1LATEST) et l'ID du nom d'utilisateur. Le code `text` de fin indique qu'il s'agit d'une demande d'API `PostText` (pas `PostContent`).
+ Corps de la demande – Inclut l'entrée utilisateur (`inputText`) et un champ `sessionAttributes` vide.
1. À partir du`inputText`, Amazon Lex détecte l'intention (`MakeAppointment`). Le service invoque la fonction Lambda, qui est configurée comme un crochet de code, pour effectuer l'initialisation et la validation en transmettant l'événement suivant. Pour en savoir plus, consultez [Format d'un événement d'entrée](lambda-input-response-format.md#using-lambda-input-event-format).
```
{
"currentIntent": {
"slots": {
"AppointmentType": null,
"Date": null,
"Time": null
},
"name": "MakeAppointment",
"confirmationStatus": "None"
},
"bot": {
"alias": null,
"version": "$LATEST",
"name": "ScheduleAppointment"
},
"userId": "bijt6rovckwecnzesbthrr1d7lv3ja3n",
"invocationSource": "DialogCodeHook",
"outputDialogMode": "Text",
"messageVersion": "1.0",
"sessionAttributes": {}
}
```
Outre les informations envoyées par le client, Amazon Lex inclut également les données suivantes :
+ `currentIntent` – Fournit les informations d'intention actuelles.
+ `invocationSource`— Indique l'objectif de l'appel de la fonction Lambda. Dans ce cas, le but est d'effectuer l'initialisation et la validation des données utilisateur. (Amazon Lex sait que l'utilisateur n'a pas encore fourni toutes les données de créneau pour répondre à son intention.)
+ `messageVersion`— Actuellement, Amazon Lex ne prend en charge que la version 1.0.
1. Pour le moment, toutes les valeurs d'option sont null (il n'y a rien à valider). La fonction Lambda renvoie la réponse suivante à Amazon Lex, demandant au service d'obtenir des informations pour le slot. `AppointmentType` Pour plus d'informations sur le format de réponse, consultez [Format de la réponse](lambda-input-response-format.md#using-lambda-response-format).
```
{
"dialogAction": {
"slotToElicit": "AppointmentType",
"intentName": "MakeAppointment",
"responseCard": {
"genericAttachments": [
{
"buttons": [
{
"text": "cleaning (30 min)",
"value": "cleaning"
},
{
"text": "root canal (60 min)",
"value": "root canal"
},
{
"text": "whitening (30 min)",
"value": "whitening"
}
],
"subTitle": "What type of appointment would you like to schedule?",
"title": "Specify Appointment Type"
}
],
"version": 1,
"contentType": "application/vnd.amazonaws.card.generic"
},
"slots": {
"AppointmentType": null,
"Date": null,
"Time": null
},
"type": "ElicitSlot",
"message": {
"content": "What type of appointment would you like to schedule?",
"contentType": "PlainText"
}
},
"sessionAttributes": {}
}
```
La réponse inclut les champs `dialogAction` et `sessionAttributes`. Entre autres, le champ `dialogAction` renvoie les champs suivants :
+ `type`— En définissant ce champ sur`ElicitSlot`, la fonction Lambda demande à Amazon Lex d'obtenir la valeur pour l'emplacement spécifié dans le champ. `slotToElicit` La fonction Lambda fournit également un message `message` à transmettre à l'utilisateur.
+ `responseCard`— Identifie une liste de valeurs possibles pour le `AppointmentType` slot. Un client qui prend en charge les cartes de réponse (par exemple, Facebook Messenger) affiche une carte de réponse pour permettre à l'utilisateur de choisir un type de rendez-vous, comme dans l'image suivante :
![\[Carte-réponse indiquant le type de rendez-vous à fixer et trois options : nettoyage (30 minutes), canal radiculaire (60 minutes) et blanchiment (30 minutes).\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/respcard-10.png)
1. Comme indiqué `dialogAction.type` dans la réponse de la fonction Lambda, Amazon Lex renvoie la réponse suivante au client :
![\[Réponse JSON contenant des informations sur l'intention de prendre rendez-vous et le créneau de type de rendez-vous à obtenir.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/appt-10.png)
Le client lit la réponse, puis affiche le message suivant : « Quel type de rendez-vous souhaitez-vous prendre ? » et la carte de réponse (si le client prend en charge les cartes de réponse).
1. Utilisateur : En fonction du client, l'utilisateur a deux options :
+ Si la carte de réponse est affichée, choisissez **root canal (60 min)** ou tapez **root canal**.
+ Si le client ne prend pas en charge les cartes de réponse, tapez **root canal**.
1. Le client envoie la `PostText` demande suivante à Amazon Lex (des sauts de ligne ont été ajoutés pour des raisons de lisibilité) :
```
POST /bot/BookTrip/alias/$LATEST/user/bijt6rovckwecnzesbthrr1d7lv3ja3n/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "root canal",
"sessionAttributes": {}
}
```
1. Amazon Lex invoque la fonction Lambda pour la validation des données utilisateur en envoyant l'événement suivant en tant que paramètre :
```
{
"currentIntent": {
"slots": {
"AppointmentType": "root canal",
"Date": null,
"Time": null
},
"name": "MakeAppointment",
"confirmationStatus": "None"
},
"bot": {
"alias": null,
"version": "$LATEST",
"name": "ScheduleAppointment"
},
"userId": "bijt6rovckwecnzesbthrr1d7lv3ja3n",
"invocationSource": "DialogCodeHook",
"outputDialogMode": "Text",
"messageVersion": "1.0",
"sessionAttributes": {}
}
```
Dans les données d'événement, notez les points suivants :
+ `invocationSource` continue d'être `DialogCodeHook`. Dans cette étape, nous validons seulement les données utilisateur.
+ Amazon Lex définit le `AppointmentType` champ de l'`currentIntent.slots`emplacement sur`root canal`.
+ Amazon Lex transmet simplement le `sessionAttributes` champ entre le client et la fonction Lambda.
1. La fonction Lambda valide les données saisies par l'utilisateur et renvoie la réponse suivante à Amazon Lex, demandant au service d'obtenir une valeur pour la date du rendez-vous.
```
{
"dialogAction": {
"slotToElicit": "Date",
"intentName": "MakeAppointment",
"responseCard": {
"genericAttachments": [
{
"buttons": [
{
"text": "2-15 (Wed)",
"value": "Wednesday, February 15, 2017"
},
{
"text": "2-16 (Thu)",
"value": "Thursday, February 16, 2017"
},
{
"text": "2-17 (Fri)",
"value": "Friday, February 17, 2017"
},
{
"text": "2-20 (Mon)",
"value": "Monday, February 20, 2017"
},
{
"text": "2-21 (Tue)",
"value": "Tuesday, February 21, 2017"
}
],
"subTitle": "When would you like to schedule your root canal?",
"title": "Specify Date"
}
],
"version": 1,
"contentType": "application/vnd.amazonaws.card.generic"
},
"slots": {
"AppointmentType": "root canal",
"Date": null,
"Time": null
},
"type": "ElicitSlot",
"message": {
"content": "When would you like to schedule your root canal?",
"contentType": "PlainText"
}
},
"sessionAttributes": {}
}
```
Là encore, la réponse inclut les champs `dialogAction` et `sessionAttributes`. Entre autres, le champ `dialogAction` renvoie les champs suivants :
+ `type`— En définissant ce champ sur`ElicitSlot`, la fonction Lambda demande à Amazon Lex d'obtenir la valeur pour l'emplacement spécifié dans le champ. `slotToElicit` La fonction Lambda fournit également un message `message` à transmettre à l'utilisateur.
+ `responseCard`— Identifie une liste de valeurs possibles pour le `Date` slot. Un client qui prend en charge les cartes de réponse (par exemple, Facebook Messenger) affiche une carte de réponse qui permet à l'utilisateur de choisir une date de rendez-vous, comme dans l'image suivante :
![\[Carte-réponse indiquant la date pour planifier le canal radiculaire et trois options : 2-15, 2-16 et 2-17.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/respcard-20.png)
Bien que la fonction Lambda ait renvoyé cinq dates, le client (Facebook Messenger) dispose d'une limite de trois boutons pour une carte-réponse. Par conséquent, vous voyez uniquement les trois premières valeurs dans la capture d'écran.
Ces dates sont codées en dur dans la fonction Lambda. Dans une application de production, vous pouvez utiliser un calendrier pour obtenir les dates disponibles en temps réel. Les dates étant dynamiques, vous devez générer la carte de réponse de manière dynamique dans la fonction Lambda.
1. Amazon Lex remarque `dialogAction.type` et renvoie la réponse suivante au client, qui inclut les informations de la réponse de la fonction Lambda.
![\[Réponse JSON contenant l'intention de prendre rendez-vous, le type de rendez-vous renseigné et un message demandant la date du rendez-vous.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/appt-20.png)
Le client affiche le message : **When would you like to schedule your root canal?** et la carte de réponse (si le client prend en charge les cartes de réponse).
1. Utilisateur : Types **Thursday**.
1. Le client envoie la `PostText` demande suivante à Amazon Lex (des sauts de ligne ont été ajoutés pour des raisons de lisibilité) :
```
POST /bot/BookTrip/alias/$LATEST/user/bijt6rovckwecnzesbthrr1d7lv3ja3n/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "Thursday",
"sessionAttributes": {}
}
```
1. Amazon Lex invoque la fonction Lambda pour la validation des données utilisateur en envoyant l'événement suivant en tant que paramètre :
```
{
"currentIntent": {
"slots": {
"AppointmentType": "root canal",
"Date": "2017-02-16",
"Time": null
},
"name": "MakeAppointment",
"confirmationStatus": "None"
},
"bot": {
"alias": null,
"version": "$LATEST",
"name": "ScheduleAppointment"
},
"userId": "u3fpr9gghj02zts7y5tpq5mm4din2xqy",
"invocationSource": "DialogCodeHook",
"outputDialogMode": "Text",
"messageVersion": "1.0",
"sessionAttributes": {}
}
```
Dans les données d'événement, notez les points suivants :
+ `invocationSource` continue d'être `DialogCodeHook`. Dans cette étape, nous validons seulement les données utilisateur.
+ Amazon Lex définit le `Date` champ de l'`currentIntent.slots`emplacement sur`2017-02-16`.
+ Amazon Lex fait simplement passer le `sessionAttributes` lien entre le client et la fonction Lambda.
1. La fonction Lambda valide les données saisies par l'utilisateur. Cette fois, la fonction Lambda détermine qu'aucun rendez-vous n'est disponible à la date spécifiée. Il renvoie la réponse suivante à Amazon Lex, demandant au service de demander à nouveau une valeur pour la date du rendez-vous.
```
{
"dialogAction": {
"slotToElicit": "Date",
"intentName": "MakeAppointment",
"responseCard": {
"genericAttachments": [
{
"buttons": [
{
"text": "2-15 (Wed)",
"value": "Wednesday, February 15, 2017"
},
{
"text": "2-17 (Fri)",
"value": "Friday, February 17, 2017"
},
{
"text": "2-20 (Mon)",
"value": "Monday, February 20, 2017"
},
{
"text": "2-21 (Tue)",
"value": "Tuesday, February 21, 2017"
}
],
"subTitle": "When would you like to schedule your root canal?",
"title": "Specify Date"
}
],
"version": 1,
"contentType": "application/vnd.amazonaws.card.generic"
},
"slots": {
"AppointmentType": "root canal",
"Date": null,
"Time": null
},
"type": "ElicitSlot",
"message": {
"content": "We do not have any availability on that date, is there another day which works for you?",
"contentType": "PlainText"
}
},
"sessionAttributes": {
"bookingMap": "{\"2017-02-16\": []}"
}
}
```
Là encore, la réponse inclut les champs `dialogAction` et `sessionAttributes`. Entre autres, le champ `dialogAction` renvoie les champs suivants :
+ `dialogAction` field:
+ `type`— La fonction Lambda définit cette valeur sur `ElicitSlot` et réinitialise le `slotToElicit` champ sur. `Date` La fonction Lambda fournit également une information appropriée `message` à transmettre à l'utilisateur.
+ `responseCard` – Renvoie une liste de valeurs pour l'option `Date`.
+ `sessionAttributes`- Cette fois, la fonction Lambda inclut l'attribut `bookingMap` session. Sa valeur est la date demandée du rendez-vous et les rendez-vous disponibles (un objet vide indique qu'aucun rendez-vous n'est disponible).
1. Amazon Lex remarque `dialogAction.type` et renvoie la réponse suivante au client, qui inclut les informations de la réponse de la fonction Lambda.
![\[Réponse JSON indiquant l'intention de prendre rendez-vous et message précisant qu'il n'y a pas de disponibilité à la date demandée par le client.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/appt-30.png)
Le client affiche le message : **We do not have any availability on that date, is there another day which works for you?** et la carte de réponse (si le client prend en charge les cartes de réponse).
1. Utilisateur : En fonction du client, l'utilisateur a deux options :
+ Si la carte de réponse est affichée, choisissez **2-15 (Wed)** ou tapez **Wednesday**.
+ Si le client ne prend pas en charge les cartes de réponse, tapez **Wednesday**.
1. Le client envoie la `PostText` demande suivante à Amazon Lex :
```
POST /bot/BookTrip/alias/$LATEST/user/bijt6rovckwecnzesbthrr1d7lv3ja3n/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "Wednesday",
"sessionAttributes": {
}
}
```
**Note**
Le client Facebook Messenger ne définit pas d'attributs de session. Si vous souhaitez conserver les états de session entre les demandes, vous devez le faire dans la fonction Lambda. Dans une application réelle, vous pouvez avoir besoin de conserver ces attributs de session dans une base de données principale.
1. Amazon Lex invoque la fonction Lambda pour la validation des données utilisateur en envoyant l'événement suivant en tant que paramètre :
```
{
"currentIntent": {
"slots": {
"AppointmentType": "root canal",
"Date": "2017-02-15",
"Time": null
},
"name": "MakeAppointment",
"confirmationStatus": "None"
},
"bot": {
"alias": null,
"version": "$LATEST",
"name": "ScheduleAppointment"
},
"userId": "u3fpr9gghj02zts7y5tpq5mm4din2xqy",
"invocationSource": "DialogCodeHook",
"outputDialogMode": "Text",
"messageVersion": "1.0",
"sessionAttributes": {
}
}
```
Amazon Lex a `currentIntent.slots` été mis à jour en définissant l'`Date`emplacement sur`2017-02-15`.
1. La fonction Lambda valide les données saisies par l'utilisateur et renvoie la réponse suivante à Amazon Lex, en lui demandant de déterminer la valeur de l'heure du rendez-vous.
```
{
"dialogAction": {
"slots": {
"AppointmentType": "root canal",
"Date": "2017-02-15",
"Time": "16:00"
},
"message": {
"content": "What time on 2017-02-15 works for you? 4:00 p.m. is our only availability, does that work for you?",
"contentType": "PlainText"
},
"type": "ConfirmIntent",
"intentName": "MakeAppointment",
"responseCard": {
"genericAttachments": [
{
"buttons": [
{
"text": "yes",
"value": "yes"
},
{
"text": "no",
"value": "no"
}
],
"subTitle": "Is 4:00 p.m. on 2017-02-15 okay?",
"title": "Confirm Appointment"
}
],
"version": 1,
"contentType": "application/vnd.amazonaws.card.generic"
}
},
"sessionAttributes": {
"bookingMap": "{\"2017-02-15\": [\"10:00\", \"16:00\", \"16:30\"]}"
}
}
```
Là encore, la réponse inclut les champs `dialogAction` et `sessionAttributes`. Entre autres, le champ `dialogAction` renvoie les champs suivants :
+ `dialogAction` field:
+ `type`— La `Lambda` fonction définit cette valeur sur`ConfirmIntent`, demandant à Amazon Lex d'obtenir la confirmation par l'utilisateur de l'heure de rendez-vous suggérée dans le`message`.
+ `responseCard`— Renvoie une liste de yes/no valeurs parmi lesquelles l'utilisateur peut choisir. Si le client prend en charge les cartes de réponse, il affiche la carte de réponse, comme illustré dans l'exemple suivant :
![\[Carte-réponse indiquant la confirmation du rendez-vous et deux options : oui et non.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/respcard-30.png)
+ `sessionAttributes`- La fonction Lambda définit l'attribut de `bookingMap` session avec sa valeur définie sur la date du rendez-vous et les rendez-vous disponibles à cette date. Dans cet exemple, il s'agit de rendez-vous de 30 minutes. Pour une dévitalisation qui nécessite une heure, seul 4 p.m peut être réservé.
1. Comme indiqué `dialogAction.type` dans la réponse de la fonction Lambda, Amazon Lex renvoie la réponse suivante au client :
![\[Réponse JSON indiquant l'intention de prendre rendez-vous et tous les créneaux sont remplis.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/appt-40.png)
Le client affiche le message suivant : **À quelle heure le 15/02/2017 vous convient ? 16 h 00 est notre seule disponibilité, est-ce que cela vous convient ?**
1. Utilisateur : choisissez **yes**.
Amazon Lex invoque la fonction Lambda avec les données d'événement suivantes. Comme l'utilisateur a répondu**yes**, Amazon Lex définit le « `confirmationStatus` à `Confirmed` » et définit le `Time` champ « `currentIntent.slots ` à `4 p.m` ».
```
{
"currentIntent": {
"slots": {
"AppointmentType": "root canal",
"Date": "2017-02-15",
"Time": "16:00"
},
"name": "MakeAppointment",
"confirmationStatus": "Confirmed"
},
"bot": {
"alias": null,
"version": "$LATEST",
"name": "ScheduleAppointment"
},
"userId": "u3fpr9gghj02zts7y5tpq5mm4din2xqy",
"invocationSource": "FulfillmentCodeHook",
"outputDialogMode": "Text",
"messageVersion": "1.0",
"sessionAttributes": {
}
}
```
Lorsque le `confirmationStatus` est confirmé, la fonction Lambda traite l'intention (prend un rendez-vous chez le dentiste) et renvoie la réponse suivante à Amazon Lex :
```
{
"dialogAction": {
"message": {
"content": "Okay, I have booked your appointment. We will see you at 4:00 p.m. on 2017-02-15",
"contentType": "PlainText"
},
"type": "Close",
"fulfillmentState": "Fulfilled"
},
"sessionAttributes": {
"formattedTime": "4:00 p.m.",
"bookingMap": "{\"2017-02-15\": [\"10:00\"]}"
}
}
```
Notez ce qui suit :
+ La fonction Lambda a mis à jour les `sessionAttributes`.
+ `dialogAction.type`est défini sur`Close`, ce qui indique à Amazon Lex de ne pas s'attendre à une réponse de l'utilisateur.
+ `dialogAction.fulfillmentState` est défini sur `Fulfilled`, indiquant que l'intention est traitée avec succès.
Le client affiche le message suivant : **OK, j'ai pris votre rendez-vous. Nous vous verrons à 16 h le 15/02/2017.**