

Hinweis zum Ende des Supports: Am 15. September 2025 AWS wird der Support für Amazon Lex V1 eingestellt. Nach dem 15. September 2025 können Sie nicht mehr auf die Amazon-Lex-V1-Konsole oder die Amazon-Lex-V1-Ressourcen zugreifen. Wenn Sie Amazon Lex V2 verwenden, lesen Sie stattdessen das [Amazon Lex V2-Handbuch](https://docs.aws.amazon.com/lexv2/latest/dg/what-is.html). 

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Informationsfluss im Detail
<a name="ex1-sch-appt-info-flow-details"></a>

Der Bot-Plan `ScheduleAppointment` veranschaulicht vor allem die Verwendung von dynamisch generierten Antwortkarten. Die Lambda-Funktion in dieser Übung beinhaltet Antwortkarten in ihrer Antwort auf Amazon Lex. Amazon Lex fügt der Antwort an den Kunden die Antwortkarten bei. In diesem Abschnitt wird Folgendes erklärt:
+ Datenfluss zwischen Client und Amazon Lex.

   

  In diesem Abschnitt wird davon ausgegangen, dass der Client Anfragen über die `PostText` Runtime-API an Amazon Lex sendet, und die entsprechenden request/response Details werden angezeigt. Weitere Informationen zur `PostText` finden Sie unter [PostText](API_runtime_PostText.md).
**Anmerkung**  
Ein Beispiel für den Informationsfluss zwischen Client und Amazon Lex, bei dem der Client die `PostContent` API verwendet, finden Sie unter[Schritt 2a (optional): Prüfen der Details des Informationsflusses gesprochener Inhalte (Konsole)](gs-bp-details-postcontent-flow.md).

   
+ Datenfluss zwischen Amazon Lex und der Lambda-Funktion. Weitere Informationen finden Sie unter [Eingabeereignis und Antwortformat der Lambda-Funktion](lambda-input-response-format.md).

**Anmerkung**  
Das Beispiel geht davon aus, dass Sie den Facebook Messenger-Client verwenden, der keine Sitzungsattribute in der Anfrage an Amazon Lex weitergibt. Entsprechend zeigen die in diesem Abschnitt gezeigten Beispielanforderungen leere `sessionAttributes` an. Wenn Sie den Bot mit dem in der Amazon Lex Lex-Konsole bereitgestellten Client testen, enthält der Client die Sitzungsattribute.

In diesem Abschnitt wird beschrieben, was nach jeder Benutzereingabe geschieht.

1. Benutzer: Gibt **Book an appointment** ein.

   1. Der Client (Konsole) sendet die folgende [PostContent](API_runtime_PostContent.md)-Anforderung an Amazon Lex:

      ```
      POST /bot/{{ScheduleAppointment}}/alias/{{$LATEST}}/user/{{bijt6rovckwecnzesbthrr1d7lv3ja3n}}/text
      "Content-Type":"application/json"
      "Content-Encoding":"amz-1.0"
      
      {
         "inputText":"book appointment",
         "sessionAttributes":{}
      }
      ```

      Sowohl die Anforderungs-URI als auch der Text stellen Amazon Lex Informationen zur Verfügung:
      + Anfrage-URI — Gibt den Bot-Namen (ScheduleAppointment), den Bot-Alias ($LATEST) und die Benutzer-ID an. Der abschließende `text` zeigt an, dass es eine `PostText` (nicht `PostContent`)-API-Anforderung ist.
      + Anforderungsinhalt: Enthält die Benutzereingabe (`inputText`) und leere `sessionAttributes`. 

   1. Anhand `inputText` von erkennt Amazon Lex die Absicht (`MakeAppointment`). Der Dienst ruft die Lambda-Funktion auf, die als Code-Hook konfiguriert ist, um die Initialisierung und Validierung durchzuführen, indem das folgende Ereignis übergeben wird. Details hierzu finden Sie unter [Eingabe-Ereignis-Format](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": {}
      }
      ```

      Zusätzlich zu den vom Kunden gesendeten Informationen enthält Amazon Lex auch die folgenden Daten:
      + `currentIntent`: Liefert aktuelle Informationen zur Absicht.
      + `invocationSource`— Zeigt den Zweck des Aufrufs der Lambda-Funktion an. In diesem Fall besteht der Zweck darin, die Initialisierung und Validierung der Benutzerdaten durchzuführen. (Amazon Lex weiß, dass der Benutzer noch nicht alle Slot-Daten bereitgestellt hat, um die Absicht zu erfüllen.)
      + `messageVersion`— Derzeit unterstützt Amazon Lex nur die Version 1.0. 

   1. Derzeit sind alle Slot-Werte Null (es gibt nichts zu validieren). Die Lambda-Funktion gibt die folgende Antwort an Amazon Lex zurück und weist den Service an, Informationen für den Slot abzurufen. `AppointmentType` Weitere Informationen über das Antwortformat finden Sie unter [Reaktion-Format](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": {}
      }
      ```

      Die Antwort enthält die Felder `dialogAction` und `sessionAttributes`. Unter anderem gibt das Feld `dialogAction` die folgenden Felder zurück: 
      + `type`— Wenn dieses Feld auf gesetzt wird`ElicitSlot`, weist die Lambda-Funktion Amazon Lex an, den Wert für den im Feld angegebenen Slot abzurufen. `slotToElicit` Die Lambda-Funktion bietet auch eine`message`, die dem Benutzer vermittelt werden soll.
      + `responseCard`— Identifiziert eine Liste möglicher Werte für den `AppointmentType` Slot. Ein Client, der Antwortkarten unterstützt (z. B. der Facebook Messenger), zeigt eine Antwortkarte an, damit der Benutzer einen Termintyp auswählen kann, wie in der folgenden Abbildung dargestellt:  
![Auf der Antwortkarte werden die Art des zu vereinbarenden Termins und drei Optionen abgefragt: Reinigung (30 Minuten), Wurzelkanalbehandlung (60 Minuten) und Zahnaufhellung (30 Minuten).](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/respcard-10.png)

   1. Wie `dialogAction.type` in der Antwort der Lambda-Funktion angegeben, sendet Amazon Lex die folgende Antwort zurück an den Client:   
![JSON-Antwort mit Informationen über die Absicht, einen Termin zu vereinbaren, und den Termintyp, der abgerufen werden soll.](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/appt-10.png)

      Der Kunde liest die Antwort und zeigt dann die Meldung an: „Welche Art von Termin möchten Sie vereinbaren?“ und die Antwortkarte an (wenn der Client Antwortkarten unterstützt).

1. Benutzer: Je nach Client hat der Benutzer zwei Optionen:
   + Wenn die Antwortkarte angezeigt wird, wählen Sie **Wurzelkanal (60 Minuten)** aus oder geben **root canal** ein.
   + Wenn der Client keine Antwortkarten unterstützt, geben Sie **root canal** ein.

   1. Der Client sendet die folgende `PostText` Anfrage an Amazon Lex (aus Gründen der Lesbarkeit wurden Zeilenumbrüche hinzugefügt):

      ```
      POST /bot/{{BookTrip}}/alias/{{$LATEST}}/user/{{bijt6rovckwecnzesbthrr1d7lv3ja3n}}/text
      "Content-Type":"application/json"
      "Content-Encoding":"amz-1.0"
      
      {
         "inputText": "root canal",
          "sessionAttributes": {}
      }
      ```

   1. Amazon Lex ruft die Lambda-Funktion für die Überprüfung von Benutzerdaten auf, indem das folgende Ereignis als Parameter gesendet wird:

      ```
      {
          "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": {}
      }
      ```

      Beachten Sie in den Ereignisdaten Folgendes:
      + `invocationSource` ist weiterhin `DialogCodeHook`. In diesem Schritt validieren wir nur Benutzerdaten.
      + Amazon Lex legt das `AppointmentType` Feld im `currentIntent.slots` Steckplatz auf fest`root canal`.
      + Amazon Lex übergibt einfach das `sessionAttributes` Feld zwischen dem Client und der Lambda-Funktion.

   1. Die Lambda-Funktion validiert die Benutzereingabe und gibt die folgende Antwort an Amazon Lex zurück, in der der Service angewiesen wird, einen Wert für das Termindatum zu ermitteln.

      ```
      {
          "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": {}
      }
      ```

      Die Antwort enthält wieder die Felder `dialogAction` und `sessionAttributes`. Unter anderem gibt das Feld `dialogAction` die folgenden Felder zurück: 
      + `type`— Wenn dieses Feld auf gesetzt wird`ElicitSlot`, weist die Lambda-Funktion Amazon Lex an, den Wert für den im Feld angegebenen Slot abzurufen. `slotToElicit` Die Lambda-Funktion bietet auch eine`message`, die dem Benutzer vermittelt werden soll.
      + `responseCard`— Identifiziert eine Liste möglicher Werte für den `Date` Slot. Ein Client, der Antwortkarten unterstützt (z. B. Facebook Messenger), zeigt eine Antwortkarte an, mit der der Benutzer einen Termin auswählen kann, wie in der folgenden Abbildung dargestellt:  
![Antwortkarte mit Angabe des Termins für den Wurzelkanaltermin und drei Optionen: 2-15, 2-16 und 2-17.](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/respcard-20.png)

        Obwohl die Lambda-Funktion fünf Daten zurückgab, hat der Client (Facebook Messenger) ein Limit von drei Schaltflächen für eine Antwortkarte. Daher sehen Sie nur die ersten drei Werte im Screenshot.

        Diese Daten sind in der Lambda-Funktion fest codiert. In einer Produktionsanwendung würden Sie eventuell einen Kalender verwenden, um verfügbare Daten in Echtzeit zu erhalten. Da die Daten dynamisch sind, müssen Sie die Antwortkarte dynamisch in der Lambda-Funktion generieren.

   1. Amazon Lex bemerkt das `dialogAction.type` und gibt die folgende Antwort an den Client zurück, die Informationen aus der Antwort der Lambda-Funktion enthält.  
![JSON-Antwort, die die Absicht, einen Termin zu vereinbaren, die ausgefüllte Terminart und eine Nachricht mit dem Datum des Termins enthält.](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/appt-20.png)

      Der Client zeigt die Nachricht: **When would you like to schedule your root canal? (Wann möchten Sie Ihren Wurzelkanal einplanen?)** und die Antwortkarte an (wenn der Client Antwortkarten unterstützt).

1. Benutzer: Gibt **Thursday** ein.

   1. Der Client sendet die folgende `PostText` Anfrage an Amazon Lex (aus Gründen der Lesbarkeit wurden Zeilenumbrüche hinzugefügt):

      ```
      POST /bot/{{BookTrip}}/alias/{{$LATEST}}/user/{{bijt6rovckwecnzesbthrr1d7lv3ja3n}}/text
      "Content-Type":"application/json"
      "Content-Encoding":"amz-1.0"
      
      {
         "inputText": "Thursday",
          "sessionAttributes": {}
      }
      ```

   1. Amazon Lex ruft die Lambda-Funktion für die Überprüfung von Benutzerdaten auf, indem das folgende Ereignis als Parameter gesendet wird:

      ```
      {
          "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": {}
      }
      ```

      Beachten Sie in den Ereignisdaten Folgendes:
      + `invocationSource` ist weiterhin `DialogCodeHook`. In diesem Schritt validieren wir nur die Benutzerdaten.
      + Amazon Lex legt das `Date` Feld im `currentIntent.slots` Steckplatz auf fest`2017-02-16`.
      + Amazon Lex leitet einfach das `sessionAttributes` zwischen dem Client und der Lambda-Funktion weiter.

   1. Die Lambda-Funktion validiert die Benutzereingabe. Diesmal stellt die Lambda-Funktion fest, dass am angegebenen Datum keine Termine verfügbar sind. Es gibt die folgende Antwort an Amazon Lex zurück und weist den Service an, erneut einen Wert für das Termindatum zu ermitteln.

      ```
      {
          "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\": []}"
         }
      }
      ```

      Die Antwort enthält wieder die Felder `dialogAction` und `sessionAttributes`. Unter anderem gibt die `dialogAction` die folgenden Felder zurück: 
      + `dialogAction` field:
        + `type`— Die Lambda-Funktion setzt diesen Wert auf `ElicitSlot` und setzt das `slotToElicit` Feld auf zurück. `Date` Die Lambda-Funktion bietet auch eine geeignete`message`, um sie dem Benutzer zu vermitteln.
        + `responseCard`: Gibt eine Liste von Werten für den Slot `Date` zurück.
      + `sessionAttributes`- Diesmal beinhaltet die Lambda-Funktion das `bookingMap` Sitzungsattribut. Sein Wert ist das gewünschte Datum des Termins und verfügbare Termine (ein leeres Objekt zeigt an, dass kein Termin verfügbar ist).

   1. Amazon Lex bemerkt das `dialogAction.type` und gibt die folgende Antwort an den Client zurück, die Informationen aus der Antwort der Lambda-Funktion enthält.  
![JSON-Antwort, aus der hervorgeht, dass die Absicht besteht, einen Termin zu vereinbaren, und eine Nachricht, in der klargestellt wird, dass an dem vom Kunden gewünschten Datum keine Verfügbarkeit besteht.](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/appt-30.png)

      Der Client zeigt die Nachricht an: **Wir haben keinen Termin zu diesem Datum, gibt es einen anderen Tag, der für Sie in Frage kommt?** und die Antwortkarte an (wenn der Client Antwortkarten unterstützt).

1. Benutzer: Je nach Client hat der Benutzer zwei Optionen:
   + Wenn die Antwortkarte angezeigt wird, wählen Sie **2-15 (Wed) (2-15 (Mit))** aus oder geben **Wednesday** ein.
   + Wenn der Client keine Antwortkarten unterstützt, geben Sie **Wednesday** ein.

   1. Der Client sendet die folgende `PostText` Anfrage an Amazon Lex:

      ```
      POST /bot/{{BookTrip}}/alias/{{$LATEST}}/user/{{bijt6rovckwecnzesbthrr1d7lv3ja3n}}/text
      "Content-Type":"application/json"
      "Content-Encoding":"amz-1.0"
      
      {
         "inputText": "Wednesday",
          "sessionAttributes": {
         }
      }
      ```

      
**Anmerkung**  
Der Facebook Messenger-Client setzt keine Sitzungsattribute. Wenn Sie den Sitzungsstatus zwischen Anfragen beibehalten möchten, müssen Sie dies in der Lambda-Funktion tun. In einer realen Anwendung müssen Sie diese Sitzungsattribute möglicherweise in einer Backend-Datenbank speichern.

   1. Amazon Lex ruft die Lambda-Funktion für die Überprüfung von Benutzerdaten auf, indem das folgende Ereignis als Parameter gesendet wird:

      ```
      {
          "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 wurde aktualisiert, `currentIntent.slots` indem der `Date` Slot auf gesetzt wurde`2017-02-15`. 

   1. Die Lambda-Funktion validiert die Benutzereingabe und gibt die folgende Antwort an Amazon Lex zurück, die das Unternehmen anweist, den Wert für die Terminzeit zu ermitteln. 

      ```
      {
          "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\"]}"
          }
      }
      ```

      Die Antwort enthält wieder die Felder `dialogAction` und `sessionAttributes`. Unter anderem gibt die `dialogAction` die folgenden Felder zurück: 
      + `dialogAction` field:
        + `type`— Die `Lambda` Funktion setzt diesen Wert auf und weist Amazon Lex an`ConfirmIntent`, eine Bestätigung des vom Benutzer vorgeschlagenen Termins einzuholen. `message`
        + `responseCard`— Gibt eine yes/no Werteliste zurück, aus der der Benutzer wählen kann. Wenn der Client Antwortkarten unterstützt, zeigt er die Antwortkarte an, wie in folgendem Beispiel gezeigt:  
![Antwortkarte mit Bestätigung des Termins und zwei Optionen: Ja und Nein.](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/respcard-30.png)
      + `sessionAttributes`- Die Lambda-Funktion setzt das `bookingMap` Sitzungsattribut mit seinem Wert auf das Termindatum und die verfügbaren Termine an diesem Datum. In diesem Beispiel sind es Termine von je 30 Minuten. Für eine Wurzelbehandlung, die eine Stunde dauert, kann nur der Termin um 16 Uhr gebucht werden.

        

   1. Wie `dialogAction.type` in der Antwort der Lambda-Funktion angegeben, gibt Amazon Lex die folgende Antwort an den Client zurück:   
![JSON-Antwort, aus der hervorgeht, dass die Absicht besteht, einen Termin zu vereinbaren, und dass alle Termine ausgefüllt sind.](http://docs.aws.amazon.com/de_de/lex/latest/dg/images/appt-40.png)

      Der Client zeigt die Meldung an: **Welcher Zeitpunkt am 15.02.2017 funktioniert für Sie? 16:00 Uhr ist unsere einzige Verfügbarkeit, funktioniert das** für dich?

   

1. Benutzer: Wählt **yes**. 

   Amazon Lex ruft die Lambda-Funktion mit den folgenden Ereignisdaten auf. Da der Benutzer geantwortet hat**yes**, setzt Amazon Lex das `confirmationStatus` auf `Confirmed` und setzt das `Time` Feld `currentIntent.slots ` auf`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": {
      }
   }
   ```

   Da das bestätigt `confirmationStatus` ist, verarbeitet die Lambda-Funktion die Absicht (bucht einen Zahnarzttermin) und gibt die folgende Antwort an Amazon Lex zurück: 

   ```
   {
       "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\"]}"
       }
   }
   ```

   Beachten Sie Folgendes:
   + Die Lambda-Funktion hat die `sessionAttributes` aktualisiert.
   + `dialogAction.type`ist auf gesetzt`Close`, was Amazon Lex anweist, keine Benutzerantwort zu erwarten. 
   + `dialogAction.fulfillmentState` wird auf `Fulfilled` gesetzt, wodurch angezeigt wird, dass die Absicht erfolgreich erfüllt wurde.

   Der Kunde zeigt die Meldung an: **Okay, ich habe Ihren Termin gebucht. Wir sehen uns am 15.02.2017 um 16:00 Uhr.**





