

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
<a name="ex1-sch-appt-info-flow-details"></a>

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





