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.
# Détails du flux d'informations
Dans cet exercice, vous avez engagé une conversation avec le BookTrip bot Amazon Lex à l'aide du client de fenêtre de test fourni dans la console Amazon Lex. Cette section décrit les éléments suivants :
+ Le 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 les détails des demandes et des réponses en conséquence. Pour plus d'informations sur l'API d'exécution `PostText`, consultez [PostText](API_runtime_PostText.md).
**Note**
Pour un exemple du 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).
+ Le 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).
**Topics**
+ [Flux de données : intention Book Hotel](#data-flow-book-hotel)
+ [Flux de données : intention BookCar](#data-flow-book-car)
## Flux de données : intention Book Hotel
Cette section explique ce qui se passe après chaque entrée utilisateur.
1. Utilisateur : « book a hotel »
1. Le client (console) envoie la demande [PostText](API_runtime_PostText.md) suivante à Amazon Lex :
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"book a hotel",
"sessionAttributes":{}
}
```
L'URI et le corps de la demande fournissent des informations à Amazon Lex :
+ URI de demande — Fournit le nom du bot (BookTrip), l'alias du bot (\$1LATEST) et le nom d'utilisateur. Le code `text` de fin indique qu'il s'agit d'une demande d'API `PostText` (et non `PostContent`).
+ Corps de la demande – Inclut l'entrée utilisateur (`inputText`) et un champ `sessionAttributes` vide. Au départ, il s'agit d'un objet vide et la fonction Lambda définit d'abord les attributs de session.
1. À partir du`inputText`, Amazon Lex détecte l'intention (BookHotel). Cette intention est configurée avec une fonction Lambda en tant que crochet de code pour l'initialisation/validation des données utilisateur. Amazon Lex invoque donc cette fonction Lambda en transmettant les informations suivantes comme paramètre d'événement ([Format d'un événement d'entrée](lambda-input-response-format.md#using-lambda-input-event-format)voir) :
```
{
"messageVersion":"1.0",
"invocationSource":"DialogCodeHook",
"userId":"wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes":{
},
"bot":{
"name":"BookTrip",
"alias":null,
"version":"$LATEST"
},
"outputDialogMode":"Text",
"currentIntent":{
"name":"BookHotel",
"slots":{
"RoomType":null,
"CheckInDate":null,
"Nights":null,
"Location":null
},
"confirmationStatus":"None"
}
}
```
Outre les informations envoyées par le client, Amazon Lex inclut également les données supplémentaires suivantes :
+ `messageVersion`— Actuellement, Amazon Lex ne prend en charge que la version 1.0.
+ `invocationSource`— Indique l'objectif de l'appel de la fonction Lambda. Dans ce cas, il s'agit d'effectuer l'initialisation et la validation des données utilisateur (pour le moment, Amazon Lex sait que l'utilisateur n'a pas fourni toutes les données d'emplacement conformément à son intention).
+ `currentIntent` – Toutes les valeurs d'option sont définies sur null.
1. Pour l'instant, toutes les valeurs d'option sont null. La fonction Lambda n'a rien à valider. La fonction Lambda renvoie la réponse suivante à Amazon Lex. 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).
```
{
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",\"Location\":null,\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"dialogAction":{
"type":"Delegate",
"slots":{
"RoomType":null,
"CheckInDate":null,
"Nights":null,
"Location":null
}
}
}
```
**Note**
`currentReservation`— La fonction Lambda inclut cet attribut de session. Sa valeur est une copie des informations d'option actuelles et du type de réservation.
Seuls la fonction Lambda et le client peuvent mettre à jour ces attributs de session. Amazon Lex transmet simplement ces valeurs.
`dialogAction.type`— En définissant cette valeur sur`Delegate`, la fonction Lambda délègue la responsabilité de la prochaine action à Amazon Lex.
Si la fonction Lambda détecte quoi que ce soit lors de la validation des données utilisateur, elle indique à Amazon Lex la marche à suivre.
1. Conformément au`dialogAction.type`, Amazon Lex décide de la marche à suivre : obtenir des données auprès de l'utilisateur pour le slot. `Location` Il sélectionne l'un des messages d'invite (« What city will you be staying in? ») pour cette option, selon la configuration d'intention, puis envoie la réponse suivante à l'utilisateur :
![\[Réponse JSON contenant l'état du dialogue, le nom de l'intention, le message, la carte de réponse, les attributs de session, l'emplacement à obtenir et les emplacements.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/book-hotel-10.png)
Les attributs de session sont transmis au client.
Le client lit la réponse, puis affiche le message : « What city will you be staying in? »
1. Utilisateur : « Moscow »
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/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"Moscow",
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":null,
\"RoomType\":null,
\"CheckInDate\":null,
\"Nights\":null}"
}
}
```
En plus de `inputText`, le client inclut les mêmes attributs de session `currentReservation` que ceux qu'il a reçus.
1. Amazon Lex interprète d'abord le `inputText` dans le contexte de l'intention actuelle (le service se souvient qu'il avait demandé à l'utilisateur concerné des informations sur le `Location` slot). Il met à jour la valeur du slot en fonction de l'intention actuelle et appelle la fonction Lambda à l'aide de l'événement suivant :
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":null,\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookHotel",
"slots": {
"RoomType": null,
"CheckInDate": null,
"Nights": null,
"Location": "Moscow"
},
"confirmationStatus": "None"
}
}
```
**Note**
`invocationSource` continue d'être `DialogCodeHook`. Dans cette étape, nous validons seulement les données utilisateur.
Amazon Lex transmet simplement l'attribut de session à la fonction Lambda.
En effet`currentIntent.slots`, Amazon Lex a mis à jour l'`Location`emplacement en`Moscow`.
1. La fonction Lambda effectue la validation des données utilisateur et détermine qu'il s'`Moscow`agit d'un emplacement non valide.
**Note**
Dans cet exercice, la fonction Lambda contient une simple liste de villes valides et ne `Moscow` figure pas sur cette liste. Dans une application de production, vous pouvez utiliser une base de données principale pour obtenir ces informations.
Il rétablit la valeur de l'emplacement à zéro et demande à Amazon Lex de demander à nouveau à l'utilisateur une autre valeur en envoyant la réponse suivante :
```
{
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Moscow\",\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"dialogAction": {
"type": "ElicitSlot",
"intentName": "BookHotel",
"slots": {
"RoomType": null,
"CheckInDate": null,
"Nights": null,
"Location": null
},
"slotToElicit": "Location",
"message": {
"contentType": "PlainText",
"content": "We currently do not support Moscow as a valid destination. Can you try a different city?"
}
}
}
```
**Note**
`currentIntent.slots.Location` est réinitialisé à null.
`dialogAction.type`est défini sur`ElicitSlot`, ce qui demande à Amazon Lex d'inviter à nouveau l'utilisateur en fournissant les informations suivantes :
`dialogAction.slotToElicit` – option pour laquelle obtenir des données auprès de l'utilisateur.
`dialogAction.message` – `message` à transmettre à l'utilisateur.
1. Amazon Lex remarque `dialogAction.type` et transmet les informations au client dans la réponse suivante :
![\[Réponse JSON contenant l'état du dialogue, le nom de l'intention, le message, la carte de réponse, les attributs de session, l'emplacement à obtenir et les emplacements.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/book-hotel-20.png)
Le client affiche simplement le message : « We currently do not support Moscow as a valid destination. Can you try a different city? »
1. Utilisateur : « Chicago »
1. Le client envoie la `PostText` demande suivante à Amazon Lex :
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"Chicago",
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":\"Moscow\",
\"RoomType\":null,
\"CheckInDate\":null,
\"Nights\":null}"
}
}
```
1. Amazon Lex connaît le contexte et sait qu'il s'agissait d'obtenir des données pour le `Location` slot. Dans ce contexte, il sait que la valeur `inputText` est pour l'option `Location`. Il invoque ensuite la fonction Lambda en envoyant l'événement suivant :
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":Moscow,\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookHotel",
"slots": {
"RoomType": null,
"CheckInDate": null,
"Nights": null,
"Location": "Chicago"
},
"confirmationStatus": "None"
}
}
```
Amazon Lex a mis à jour le `currentIntent.slots` en configurant l'`Location`emplacement sur`Chicago`.
1. Selon la `invocationSource` valeur de`DialogCodeHook`, la fonction Lambda effectue la validation des données utilisateur. Il reconnaît `Chicago` comme une valeur d'emplacement valide, met à jour l'attribut de session en conséquence, puis renvoie la réponse suivante à Amazon Lex.
```
{
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
},
"dialogAction": {
"type": "Delegate",
"slots": {
"RoomType": null,
"CheckInDate": null,
"Nights": null,
"Location": "Chicago"
}
}
}
```
**Note**
`currentReservation`— La fonction Lambda met à jour cet attribut de session en définissant la `Location` valeur sur. `Chicago`
`dialogAction.type` – Est défini sur `Delegate`. Les données utilisateur étaient valides et la fonction Lambda indique à Amazon Lex de choisir le plan d'action suivant.
1. Selon`dialogAction.type`, Amazon Lex choisit la prochaine ligne de conduite. Amazon Lex sait qu'il a besoin de plus de données d'emplacement et choisit le prochain emplacement vide (`CheckInDate`) ayant la priorité la plus élevée en fonction de la configuration prévue. Il sélectionne l'un des messages d'invite (« What day do you want to check in? ») pour cette option, selon la configuration d'intention, puis renvoie la réponse suivante au client :
![\[Réponse JSON contenant l'état du dialogue, le nom de l'intention, le message, la carte de réponse, les attributs de session, l'emplacement à obtenir et les emplacements. Le créneau de localisation est désormais rempli en tant que Chicago.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/book-hotel-30.png)
Le client affiche le message : « What day do you want to check in? »
1. L'interaction de l'utilisateur se poursuit : l'utilisateur fournit des données, la fonction Lambda valide les données, puis délègue le plan d'action suivant à Amazon Lex. Finalement, l'utilisateur fournit toutes les données d'emplacement, la fonction Lambda valide toutes les entrées de l'utilisateur, puis Amazon Lex reconnaît qu'il possède toutes les données d'emplacement.
**Note**
Dans cet exercice, une fois que l'utilisateur a fourni toutes les données relatives aux créneaux, la fonction Lambda calcule le prix de la réservation d'hôtel et le renvoie sous la forme d'un autre attribut de session (). `currentReservationPrice`
À ce stade, l'intention est prête à être réalisée, mais elle est configurée avec une invite de confirmation demandant la confirmation de l'utilisateur avant qu'Amazon Lex puisse réaliser l'intention. BookHotel Amazon Lex envoie donc le message suivant au client pour lui demander une confirmation avant de réserver l'hôtel :
![\[Réponse JSON contenant l'état du dialogue, le nom de l'intention, le message, la carte de réponse, les attributs de session, l'emplacement à obtenir et les emplacements. Tous les emplacements sont désormais pourvus.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/book-hotel-40.png)
Le client affiche le message : « Okay, I have you down for a 5 night in Chicago starting 2016-12-18. Shall I book the reservation? »
1. Utilisateur : « yes »
1. Le client envoie la `PostText` demande suivante à Amazon Lex :
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"Yes",
"sessionAttributes":{
"currentReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":\"Chicago\",
\"RoomType\":\"queen\",
\"CheckInDate\":\"2016-12-18\",
\"Nights\":\"5\"}",
"currentReservationPrice":"1195"
}
}
```
1. Amazon Lex interprète le `inputText` dans le contexte de la confirmation de l'intention actuelle. Amazon Lex comprend que l'utilisateur souhaite procéder à la réservation. Cette fois, Amazon Lex invoque la fonction Lambda pour répondre à l'intention en envoyant l'événement suivant. En définissant le `invocationSource` to `FulfillmentCodeHook` dans l'événement, il envoie à la fonction Lambda. Amazon Lex définit également la valeur `confirmationStatus` à`Confirmed`.
```
{
"messageVersion": "1.0",
"invocationSource": "FulfillmentCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}",
"currentReservationPrice": "956"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookHotel",
"slots": {
"RoomType": "queen",
"CheckInDate": "2016-12-18",
"Nights": "5",
"Location": "Chicago"
},
"confirmationStatus": "Confirmed"
}
}
```
**Note**
`invocationSource`— Cette fois, Amazon Lex a défini cette valeur sur`FulfillmentCodeHook`, demandant à la fonction Lambda de répondre à l'intention.
`confirmationStatus` – Est défini sur `Confirmed`.
1. Cette fois, la fonction Lambda répond à l' BookHotel intention, Amazon Lex effectue la réservation, puis renvoie la réponse suivante :
```
{
"sessionAttributes": {
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}"
},
"dialogAction": {
"type": "Close",
"fulfillmentState": "Fulfilled",
"message": {
"contentType": "PlainText",
"content": "Thanks, I have placed your reservation. Please let me know if you would like to book a car rental, or another hotel."
}
}
}
```
**Note**
`lastConfirmedReservation`— Il s'agit d'un nouvel attribut de session ajouté par la fonction Lambda (au lieu de`currentReservation`,`currentReservationPrice`).
`dialogAction.type`— La fonction Lambda définit cette valeur sur`Close`, indiquant qu'Amazon Lex ne s'attend pas à une réponse de l'utilisateur.
`dialogAction.fulfillmentState` – Est défini sur `Fulfilled` et inclut un `message` approprié à transmettre à l'utilisateur.
1. Amazon Lex examine le `fulfillmentState` et envoie la réponse suivante au client :
![\[Réponse JSON contenant l'état du dialogue, le nom de l'intention, le message, la carte de réponse, les attributs de session, l'emplacement à obtenir et les emplacements. Tous les créneaux sont remplis et un champ de dernière réservation confirmée sous les attributs de session est maintenant rempli.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/book-hotel-60.png)
**Note**
`dialogState`— Amazon Lex définit cette valeur sur`Fulfilled`.
`message`— C'est le même message que celui fourni par la fonction Lambda.
Le client affiche le message.
## Flux de données : intention BookCar
Dans cet exercice, le BookTrip bot prend en charge deux intentions (BookHotel et BookCar). Après avoir réservé une chambre d'hôtel, l'utilisateur peut continuer la conversation pour réserver une voiture. Tant que la session n'a pas expiré, dans chaque demande ultérieure le client continue à envoyer les attributs de session (dans cet exemple, `lastConfirmedReservation`). La fonction Lambda peut utiliser ces informations pour initialiser les données d'emplacement conformément à l'intention. BookCar Ceci montre comment utiliser des attributs de session dans le partage de données entre les intentions.
Plus précisément, lorsque l'utilisateur choisit l' BookCar intention, la fonction Lambda utilise les informations pertinentes contenues dans l'attribut de session pour préremplir les emplacements (PickUpDate ReturnDate, et PickUpCity) correspondant à l'intention. BookCar
**Note**
La console Amazon Lex fournit le lien **Effacer** que vous pouvez utiliser pour effacer tous les attributs de session précédents.
Suivez les étapes de cette procédure pour poursuivre la conversation.
1. Utilisateur : « also book a car »
1. Le client envoie la `PostText` demande suivante à Amazon Lex.
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"also book a car",
"sessionAttributes":{
"lastConfirmedReservation":""{\"ReservationType\":\"Hotel\",
\"Location\":\"Chicago\",
\"RoomType\":\"queen\",
\"CheckInDate\":\"2016-12-18\",
\"Nights\":\"5\"}"
}
}
```
Le client inclut l'attribut de session `lastConfirmedReservation`.
1. Amazon Lex détecte l'intention (BookCar) à partir du`inputText`. Cette intention est également configurée pour appeler la fonction Lambda afin d'effectuer l'initialisation et la validation des données utilisateur. Amazon Lex appelle la fonction Lambda avec l'événement suivant :
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookCar",
"slots": {
"PickUpDate": null,
"ReturnDate": null,
"DriverAge": null,
"CarType": null,
"PickUpCity": null
},
"confirmationStatus": "None"
}
}
```
**Note**
`messageVersion`— Actuellement, Amazon Lex ne prend en charge que la version 1.0.
`invocationSource` – Indique que l'objectif de l'appel est d'effectuer l'initialisation et la validation des données utilisateur.
`currentIntent`— Il inclut le nom de l'intention et les emplacements. Pour l'instant, toutes les valeurs d'option sont null.
1. La fonction Lambda remarque toutes les valeurs d'emplacement nulles sans rien à valider. Cependant, elle utilise les attributs de session pour initialiser certaines des valeurs d'option (`PickUpDate`, `ReturnDate` et `PickUpCity`), puis elle renvoie la réponse suivante :
```
{
"sessionAttributes": {
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}",
"currentReservation": "{\"ReservationType\":\"Car\",\"PickUpCity\":null,\"PickUpDate\":null,\"ReturnDate\":null,\"CarType\":null}",
"confirmationContext": "AutoPopulate"
},
"dialogAction": {
"type": "ConfirmIntent",
"intentName": "BookCar",
"slots": {
"PickUpCity": "Chicago",
"PickUpDate": "2016-12-18",
"ReturnDate": "2016-12-22",
"CarType": null,
"DriverAge": null
},
"message": {
"contentType": "PlainText",
"content": "Is this car rental for your 5 night stay in Chicago on 2016-12-18?"
}
}
}
```
**Note**
En plus de`lastConfirmedReservation`, la fonction Lambda inclut d'autres attributs de session (`currentReservation`et`confirmationContext`).
`dialogAction.type`est défini sur`ConfirmIntent`, ce qui indique à Amazon Lex qu'une réponse oui ou non est attendue de la part de l'utilisateur (le ConfirmmationContext est défini sur AutoPopulate, la fonction Lambda sait que la réponse de l'utilisateur vise à obtenir la confirmation de yes/no l'utilisateur de l'initialisation effectuée par la fonction Lambda (données d'emplacement renseignées automatiquement).
La fonction Lambda inclut également dans la réponse un message d'information à renvoyer au `dialogAction.message` client par Amazon Lex.
Le terme `ConfirmIntent` (valeur de `dialogAction.type`) n'est pas lié à une intention de bot. Dans l'exemple, la fonction Lambda utilise ce terme pour demander à Amazon Lex d'obtenir une yes/no réponse de l'utilisateur.
1. Selon le`dialogAction.type`, Amazon Lex renvoie la réponse suivante au client :
![\[Réponse JSON contenant l'état du dialogue, le nom de l'intention, le message, la carte de réponse, les attributs de session, l'emplacement à obtenir et les emplacements.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/book-car-10.png)
Le client affiche le message : « Is this car rental for your 5 night stay in Chicago on 2016-12-18? »
1. Utilisateur : « yes »
1. Le client envoie la `PostText` demande suivante à Amazon Lex.
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"yes",
"sessionAttributes":{
"confirmationContext":"AutoPopulate",
"currentReservation":"{\"ReservationType\":\"Car\",
\"PickUpCity\":null,
\"PickUpDate\":null,
\"ReturnDate\":null,
\"CarType\":null}",
"lastConfirmedReservation":"{\"ReservationType\":\"Hotel\",
\"Location\":\"Chicago\",
\"RoomType\":\"queen\",
\"CheckInDate\":\"2016-12-18\",
\"Nights\":\"5\"}"
}
}
```
1. Amazon Lex lit le `inputText` et connaît le contexte (demande à l'utilisateur de confirmer le peuplement automatique). Amazon Lex invoque la fonction Lambda en envoyant l'événement suivant :
```
{
"messageVersion": "1.0",
"invocationSource": "DialogCodeHook",
"userId": "wch89kjqcpkds8seny7dly5x3otq68j3",
"sessionAttributes": {
"confirmationContext": "AutoPopulate",
"currentReservation": "{\"ReservationType\":\"Car\",\"PickUpCity\":null,\"PickUpDate\":null,\"ReturnDate\":null,\"CarType\":null}",
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}"
},
"bot": {
"name": "BookTrip",
"alias": null,
"version": "$LATEST"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "BookCar",
"slots": {
"PickUpDate": "2016-12-18",
"ReturnDate": "2016-12-22",
"DriverAge": null,
"CarType": null,
"PickUpCity": "Chicago"
},
"confirmationStatus": "Confirmed"
}
}
```
L'utilisateur ayant répondu « Oui », Amazon Lex définit le « `confirmationStatus` à `Confirmed` ».
1. À partir de`confirmationStatus`, la fonction Lambda sait que les valeurs préremplies sont correctes. La fonction Lambda effectue les opérations suivantes :
+ Elle met à jour l'attribut de session `currentReservation` sur la valeur d'option qu'elle a préremplie.
+ Elle définit `dialogAction.type` sur `ElicitSlot`
+ Elle définit la valeur de `slotToElicit` sur `DriverAge`.
La réponse suivantes est envoyée :
```
{
"sessionAttributes": {
"currentReservation": "{\"ReservationType\":\"Car\",\"PickUpCity\":\"Chicago\",\"PickUpDate\":\"2016-12-18\",\"ReturnDate\":\"2016-12-22\",\"CarType\":null}",
"lastConfirmedReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":\"queen\",\"CheckInDate\":\"2016-12-18\",\"Nights\":\"5\"}"
},
"dialogAction": {
"type": "ElicitSlot",
"intentName": "BookCar",
"slots": {
"PickUpDate": "2016-12-18",
"ReturnDate": "2016-12-22",
"DriverAge": null,
"CarType": null,
"PickUpCity": "Chicago"
},
"slotToElicit": "DriverAge",
"message": {
"contentType": "PlainText",
"content": "How old is the driver of this car rental?"
}
}
}
```
1. Amazon Lex renvoie la réponse suivante :
![\[Réponse JSON indiquant l'intention de réserver une voiture et un message indiquant l'emplacement pour le créneau Driver Age.\]](http://docs.aws.amazon.com/fr_fr/lex/latest/dg/images/book-car-20.png)
Le client affiche le message « Quel âge a le chauffeur de cette location de voiture ? » et la conversation continue.