Flux de données : intention Book Hotel Flux de données : intention BookCar

Si vous utilisez Amazon Lex V2, consultez plutôt le guide Amazon Lex V2.

Si vous utilisez Amazon Lex V1, nous vous recommandons de mettre à niveau vos robots vers Amazon Lex V2. Nous n'ajoutons plus de nouvelles fonctionnalités à la V1 et recommandons vivement d'utiliser la V2 pour tous les nouveaux robots.

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.

Note
Pour un exemple du flux d'informations entre le client et Amazon Lex dans lequel le client utilise l'PostContentAPI, consultezÉtape 2a (facultatif) : Vérification des détails du flux d'informations vocales (console) .
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.

Flux de données : intention Book Hotel

Cette section explique ce qui se passe après chaque entrée utilisateur.

Utilisateur : « book a hotel »
1. Le client (console) envoie la demande PostText 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 ($LATEST) 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.
2. À partir duinputText, 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 en tant que paramètre d'événement (Format d'un événement d'entréevoir) :
```
{
   "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.
3. 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.
```
{
   "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 surDelegate, 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.
4. Conformément audialogAction.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 :
  
  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? »
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.
2. 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 effetcurrentIntent.slots, Amazon Lex a mis à jour l'Locationemplacement enMoscow.
3. La fonction Lambda effectue la validation des données utilisateur et détermine qu'il s'Moscowagit 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 de saisir 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.typeest défini surElicitSlot, 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.
4. Amazon Lex remarque dialogAction.type et transmet les informations au client dans la réponse suivante :
  
  Le client affiche simplement le message : « We currently do not support Moscow as a valid destination. Can you try a different city? »

Utilisateur : « Chicago »

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}"
   }
}

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'Locationemplacement surChicago.

Selon la invocationSource valeur deDialogCodeHook, 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.
SelondialogAction.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 :

Le client affiche le message : « What day do you want to check in? »

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 :

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? »

Utilisateur : « yes »

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"
   }
}

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 surFulfillmentCodeHook, demandant à la fonction Lambda de répondre à l'intention.
confirmationStatus – Est défini sur Confirmed.

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 decurrentReservation,currentReservationPrice).
- dialogAction.type— La fonction Lambda définit cette valeur surClose, 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.
Amazon Lex examine le fulfillmentState et envoie la réponse suivante au client :
Note
- dialogState— Amazon Lex définit cette valeur surFulfilled.
- 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.

Utilisateur : « also book a car »

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.

Amazon Lex détecte l'intention (BookCar) à partir duinputText. 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.

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 delastConfirmedReservation, la fonction Lambda inclut d'autres attributs de session (currentReservationetconfirmationContext).
- dialogAction.typeest défini surConfirmIntent, 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 oui/non de l'utilisateur vise à obtenir la confirmation de 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.
  
  Note
  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 réponse oui/non de la part de l'utilisateur.
Selon ledialogAction.type, Amazon Lex renvoie la réponse suivante au client :

Le client affiche le message : « Is this car rental for your 5 night stay in Chicago on 2016-12-18? »

Utilisateur : « yes »

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\"}"
   }
}

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 ».

À partir deconfirmationStatus, 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?"
        }
    }
}

Amazon Lex renvoie la réponse suivante :

Le client affiche le message « Quel âge a le chauffeur de cette location de voiture ? » et la conversation continue.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Étape 4 : Ajouter la fonction Lambda en tant que crochet de code

Exemple : Utilisation d'une carte de réponse