Datenfluss: Absicht zur Buchung eines Hotels Datenfluss: Absicht Auto buchen

Wenn Sie Amazon Lex V2 verwenden, lesen Sie stattdessen das Amazon Lex V2-Handbuch.

Wenn Sie Amazon Lex V1 verwenden, empfehlen wir, Ihre Bots auf Amazon Lex V2 zu aktualisieren. Wir fügen V1 keine neuen Funktionen mehr hinzu und empfehlen dringend, V2 für alle neuen Bots zu verwenden.

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

In dieser Übung haben Sie mithilfe des in der Amazon Lex Lex-Konsole bereitgestellten Testfensterclients eine Konversation mit dem Amazon Lex BookTrip Lex-Bot geführt. In diesem Abschnitt wird Folgendes erklärt:

Der Datenfluss zwischen dem Kunden und Amazon Lex.

In diesem Abschnitt wird davon ausgegangen, dass der Client mithilfe derPostText Runtime-API Anfragen an Amazon Lex sendet, und die Anfrage- und Antwortdetails werden entsprechend angezeigt. Weitere Informationen zur PostText finden Sie unter PostText.

Anmerkung
Ein Beispiel für den Informationsfluss zwischen dem Client und Amazon Lex, bei dem der Client diePostContent API verwendet, finden Sie unterSchritt 2a (optional): Prüfen der Details des Informationsflusses gesprochener Inhalte (Konsole) .
Der Datenfluss zwischen Amazon Lex und der Lambda-Funktion. Weitere Informationen finden Sie unter Lambda-Funktions-Eingabe-Ereignis und Antwort-Format.

Themen

Datenfluss: Absicht zur Buchung eines Hotels
Datenfluss: Absicht Auto buchen

Datenfluss: Absicht zur Buchung eines Hotels

In diesem Abschnitt wird erklärt, was nach jeder Benutzereingabe geschieht.

Benutzer: „Buche ein Hotel“
1. Der Client (Konsole) sendet die folgende PostText-Anforderung an Amazon Lex:
```
POST /bot/BookTrip/alias/$LATEST/user/wch89kjqcpkds8seny7dly5x3otq68j3/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"

{
   "inputText":"book a hotel",
   "sessionAttributes":{}
}
```
  Sowohl die Anfrage-URI als auch der Text stellen Informationen für Amazon Lex bereit:
  - Anforderungs-URI — Stellt den Botnamen (BookTrip), den Bot-Alias ($LATEST) und den Benutzernamen bereit. Der abschließende text zeigt an, dass es sich um eine PostText-API-Anforderung handelt (und nicht um PostContent).
  - Anforderungsinhalt: Enthält die Benutzereingabe (inputText) und leere sessionAttributes. Anfänglich ist dies ein leeres Objekt und die Lambda-Funktion legt zuerst die Sitzungsattribute fest.
2. Anhand desinputText erkennt Amazon Lex die Absicht (BookHotel). Diese Absicht wird mit einer Lambda-Funktion als Code-Hook für die Initialisierung/Validierung von Benutzerdaten konfiguriert. Daher ruft Amazon Lex diese Lambda-Funktion auf, indem es die folgenden Informationen als Ereignisparameter übergibt (sieheEingabe-Ereignis-Format):
```
{
   "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"
   }
}
```
  Zusätzlich zu den vom Kunden gesendeten Informationen enthält Amazon Lex auch die folgenden zusätzlichen Daten:
  - messageVersion— Derzeit unterstützt Amazon Lex nur die Version 1.0.
  - invocationSource— Gibt den Zweck des Aufrufs einer Lambda-Funktion an. In diesem Fall erfolgt die Initialisierung und Validierung der Benutzerdaten (Amazon Lex weiß derzeit, dass der Benutzer nicht alle Slot-Daten zur Erfüllung der Absicht angegeben hat).
  - currentIntent: Alle Slot-Werte werden auf Null gesetzt.
3. Zu diesem Zeitpunkt sind alle Slot-Werte auf Null gesetzt. Die Lambda-Funktion muss nichts validieren. Die Lambda-Funktion gibt die folgende Antwort an Amazon Lex zurück. Weitere Informationen über das Antwortformat finden Sie unter Reaktion-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
      }
   }
}
```
  Anmerkung
  currentReservation— Die Lambda-Funktion beinhaltet dieses Sitzungsattribut. Sein Wert ist eine Kopie der aktuellen Slot-Informationen und des Reservierungstyps.
  
  Nur die Lambda-Funktion und der Client können diese Sitzungsattribute aktualisieren. Amazon Lex übergibt diese Werte einfach.
  
  dialogAction.type— Wenn Sie diesen Wert auf festlegenDelegate, delegiert die Lambda-Funktion die Verantwortung für die nächste Vorgehensweise an Amazon Lex.
  
  Wenn die Lambda-Funktion bei der Benutzerdatenüberprüfung etwas entdeckt, weist sie Amazon Lex an, was als Nächstes zu tun ist.
4. Gemäß demdialogAction.type entscheidet Amazon Lex über die nächste Vorgehensweise — das Abrufen von Daten vom Benutzer für denLocation Slot. Es wählt eine der Aufforderungsmitteilungen ("In welcher Stadt werden Sie bleiben?") gemäß der Konfiguration der Absicht für diesen Slot aus und sendet dann die folgende Antwort an den Benutzer:
  
  Die Sitzungsattribute werden an den Client übergeben.
  
  Der Client liest die Antwort und zeigt dann die Mitteilung an: „In welcher Stadt werden Sie bleiben?“
Benutzer: „Moskau“
1. Der Client sendet die folgendePostText Anfrage an Amazon Lex (aus Gründen der Lesbarkeit wurden Zeilenumbrüche hinzugefügt):
```
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}"
   }
}
```
  Zusätzlich zu dem inputText fügt der Client die gleichen currentReservation-Sitzungsattribute hinzu, die er erhalten hat.
2. Amazon Lex interpretiert das zuerstinputText im Kontext der aktuellen Absicht (der Service erinnert sich, dass er den bestimmten Benutzer um Informationen zumLocation Slot gebeten hat). Es aktualisiert den Slot-Wert für die aktuelle Absicht und ruft die Lambda-Funktion mithilfe des folgenden Ereignisses auf:
```
{
    "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"
    }
}
```
  Anmerkung
  invocationSource ist weiterhin DialogCodeHook. In diesem Schritt validieren wir nur Benutzerdaten.
  
  Amazon Lex übergibt lediglich das Sitzungs-Atx an die Lambda-Funktion an die Lambda-Funktion.
  
  DenncurrentIntent.slots Amazon Lex hat denLocation Slot aktualisiert aufMoscow.
3. Die Lambda-Funktion führt die Benutzerdatenvalidierung durch und stellt fest, dassMoscow es sich um einen ungültigen Standort handelt.
  
  Anmerkung
  Die Lambda-Funktion in dieser Übung hat eine einfache Liste gültiger Städte undMoscow ist nicht in der Liste enthalten. In einer Produktionsanwendung würden Sie eventuell eine Backend-Datenbank verwenden, um diese Information zu erhalten.
  
  Es setzt den Slot-Wert wieder auf Null zurück und weist Amazon Lex an, den Benutzer erneut zur Eingabe eines anderen Werts aufzufordern, indem die folgende Antwort gesendet wird:
```
{
    "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?"
        }
    }
}
```
  Anmerkung
  currentIntent.slots.Location wird auf Null zurückgesetzt.
  
  dialogAction.typeist auf gesetztElicitSlot, was Amazon Lex anweist, den Benutzer erneut aufzufordern, indem er Folgendes angibt:
  
  dialogAction.slotToElicit: Slot, für den Daten vom Benutzer erfragt werden
  
  dialogAction.message: Eine an den Benutzer zu übermittelnde message
4. Amazon Lex bemerkt dasdialogAction.type und leitet die Informationen in der folgenden Antwort an den Kunden weiter:
  
  Der Client zeigt die Mitteilung einfach an: „Wir unterstützen derzeit Moskau als gültiges Ziel nicht. Können Sie es mit einer anderen Stadt versuchen?“

Benutzer: „Chicago“

Der Kunde sendet die folgendePostText Anfrage an 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 kennt den Kontext, in dem es Daten für denLocation Slot abgerufen hat. In diesem Kontext weiß es, dass der Wert inputText für den Slot Location ist. Anschließend wird die Lambda-Funktion aufgerufen, indem das folgende Ereignis gesendet wird:


{
    "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 hat das aktualisiert,currentIntent.slots indem derLocation Slot auf gesetzt wurdeChicago.

Entsprechend deminvocationSource Wert vonDialogCodeHook führt die Lambda-Funktion eine Benutzerdatenvalidierung durch. Es wirdChicago als gültiger Slot-Wert erkannt, aktualisiert das Sitzungsattribut entsprechend und gibt dann die folgende Antwort an Amazon Lex zurück.
```
{
    "sessionAttributes": {
        "currentReservation": "{\"ReservationType\":\"Hotel\",\"Location\":\"Chicago\",\"RoomType\":null,\"CheckInDate\":null,\"Nights\":null}"
    },
    "dialogAction": {
        "type": "Delegate",
        "slots": {
            "RoomType": null,
            "CheckInDate": null,
            "Nights": null,
            "Location": "Chicago"
        }
    }
}
```
Anmerkung
- currentReservation— Die Lambda-Funktion aktualisiert dieses Sitzungsattribut, indem sie dasLocation auf setztChicago.
- dialogAction.type: Wird auf Delegate gesetzt. Die Benutzerdaten waren gültig, und die Lambda-Funktion weist Amazon Lex an, die nächste Vorgehensweise zu wählen.
LautdialogAction.type Amazon Lex wählt Amazon Lex die nächste Vorgehensweise. Amazon Lex weiß, dass mehr Steckplatzdaten benötigt werden, und wählt entsprechend der gewünschten Konfiguration den nächsten unbesetzten Steckplatz (CheckInDate) mit der höchsten Priorität aus. Es wählt eine der Aufforderungsmitteilungen ("An welchem Tag möchten Sie einchecken?") gemäß der Konfiguration der Absicht für diesen Slot aus und sendet dann die folgende Antwort an den Kunden:

Der Client zeigt die Nachricht an: „An welchem Tag möchten Sie anreisen?“

Die Benutzerinteraktion wird fortgesetzt — der Benutzer stellt Daten bereit, die Lambda-Funktion validiert Daten und delegiert dann die nächste Vorgehensweise an Amazon Lex. Schließlich stellt der Benutzer alle Slot-Daten zur Verfügung, die Lambda-Funktion validiert alle Benutzereingaben, und dann erkennt Amazon Lex, dass alle Slot-Daten vorliegen.

Anmerkung
In dieser Übung berechnet die Lambda-Funktion den Preis der Hotelreservierung, nachdem der Benutzer alle Slot-Daten angegeben hat, und gibt ihn als weiteres Sitzungsattribut (currentReservationPrice) zurück.

Zu diesem Zeitpunkt ist die Absicht bereit, erfüllt zu werden, aber die BookHotel Absicht ist mit einer Bestätigungsaufforderung konfiguriert, die eine Bestätigung durch den Benutzer erfordert, bevor Amazon Lex die Absicht erfüllen kann. Daher sendet Amazon Lex die folgende Nachricht an den Kunden und bittet ihn um Bestätigung, bevor das Hotel gebucht wird:

Der Client zeigt die Nachricht an: „Okay, ich habe einen Aufenthalt für 5 Nächte in Chicago ab 18.12.2016 notiert. Soll ich die Reservierung vornehmen?“

Benutzer: „Ja“

Der Kunde sendet die folgendePostText Anfrage an 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 interpretiert dasinputText im Kontext der Bestätigung der aktuellen Absicht. Amazon Lex geht davon aus, dass der Benutzer mit der Reservierung fortfahren möchte. Dieses Mal ruft Amazon Lex die Lambda-Funktion auf, um die Absicht zu erfüllen, indem das folgende Ereignis gesendet wird. Wenn das EreignisinvocationSourceFulfillmentCodeHook auf gesetzt wird, wird es an die Lambda-Funktion gesendet. Amazon Lex gibt auch dieconfirmationStatus Messlatte vorConfirmed.


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

Anmerkung

invocationSource— Dieses Mal hat Amazon Lex diesen Wert auf festgelegtFulfillmentCodeHook und die Lambda-Funktion angewiesen, die Absicht zu erfüllen.
confirmationStatus: Wird auf Confirmed gesetzt.

Dieses Mal erfüllt die Lambda-Funktion die BookHotel Absicht, Amazon Lex schließt die Reservierung ab und gibt dann die folgende Antwort zurück:
```
{
    "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."
        }
    }
}
```
Anmerkung
- lastConfirmedReservation— Ist ein neues Sitzungsattribut, das die Lambda-Funktion hinzugefügt hat (anstelle voncurrentReservation,currentReservationPrice).
- dialogAction.type— Die Lambda-Funktion legt diesen Wert auf festClose, was darauf hinweist, dass Amazon Lex keine Benutzerantwort erwartet.
- dialogAction.fulfillmentState: Ist auf Fulfilled eingestellt und enthält eine geeignete message zur Übermittlung an den Benutzer.
Amazon Lex überprüft dasfulfillmentState und sendet die folgende Antwort an den Kunden:
Anmerkung
- dialogState— Amazon Lex legt diesen Wert auf festFulfilled.
- message— Ist dieselbe Meldung, die die Lambda-Funktion bereitgestellt hat.
Der Client zeigt die Mitteilung an.

Datenfluss: Absicht Auto buchen

Der BookTrip Bot in dieser Übung unterstützt zwei Absichten (BookHotel und BookCar). Nach der Buchung eines Hotels kann der Benutzer die Unterhaltung fortsetzen, um ein Auto zu buchen. Solange die Zeit der Sitzung noch nicht abgelaufen ist, sendet der Client bei jeder folgenden Anforderung weiter Sitzungsattribute (in diesem Beispiel die lastConfirmedReservation). Die Lambda-Funktion kann diese Informationen verwenden, um Slot-Daten für die BookCar Absicht zu initialisieren. Dies zeigt, wie Sie Sitzungsattribute für die gemeinsame Nutzung von Informationen für mehrere Absichten verwenden können.

Insbesondere wenn der Benutzer die BookCar Absicht auswählt, verwendet die Lambda-Funktion relevante Informationen im Sitzungsattribut, um die Steckplätze (PickUpDate ReturnDate, und PickUpCity) für die BookCar Absicht vorab auszufüllen.

Anmerkung

Die Amazon Lex Lex-Konsole bietet den Link Löschen, mit dem Sie alle vorherigen Sitzungsattribute löschen können.

Führen Sie die folgenden Schritte aus, um die Unterhaltung fortzusetzen.

Benutzer: „Buche ebenfalls ein Auto“

Der Kunde sendet die folgendePostText Anfrage an 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\"}"
   }
}

Der Client schließt das Sitzungsattribut lastConfirmedReservation ein.

Amazon Lex erkennt die Absicht (BookCar) aus deminputText. Diese Absicht ist auch so konfiguriert, dass die Lambda-Funktion aufgerufen wird, um die Initialisierung und Validierung der Benutzerdaten durchzuführen. Amazon Lex die Lambda-Funktion mit dem folgenden Ereignis:


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

Anmerkung

messageVersion— Derzeit unterstützt Amazon Lex nur die Version 1.0.
invocationSource: Zeigt an, dass der Zweck des Aufrufs ist, Initialisierung und Validierung von Benutzerdaten durchzuführen.
currentIntent— Es enthält den Namen der Absicht und die Slots. Zu diesem Zeitpunkt sind alle Slot-Werte auf Null gesetzt.

Die Lambda-Funktion bemerkt alle Null-Slot-Werte, ohne dass etwas zu validieren ist. Sie verwendet jedoch Sitzungsattribute, um einige der Slot-Werte zu initialisieren (PickUpDate, ReturnDate und PickUpCity), und gibt dann die folgende Antwort zurück:
```
{
    "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?"
        }
    }
}
```
Anmerkung
- Zusätzlich zu demlastConfirmedReservation enthält die Lambda-Funktion weitere Sitzungsattribute (currentReservationundconfirmationContext).
- dialogAction.typeist auf gesetztConfirmIntent, wodurch Amazon Lex darüber informiert wird, dass vom Benutzer eine Antwort mit Ja, Nein erwartet wird (der confirmationContext ist auf gesetzt AutoPopulate, die Lambda-Funktion weiß, dass die Ja/Nein-Benutzerantwort dazu dient, eine Bestätigung des Benutzers über die von der Lambda-Funktion ausgeführte Initialisierung zu erhalten (auto aufgefüllte Slot-Daten).
  
  Die Lambda-Funktion enthält in der Antwort auch eine informative Meldung in derdialogAction.message, damit Amazon Lex an den Client zurückgesendet werden kann.
  
  Anmerkung
  Der Ausdruck ConfirmIntent (Wert des dialogAction.type) hat keinen Bezug zu einer Bot-Absicht. Im Beispiel verwendet die Lambda-Funktion diesen Begriff, um Amazon Lex anzuweisen, eine Ja/Nein-Antwort vom Benutzer zu erhalten.
Laut demdialogAction.type gibt Amazon Lex die folgende Antwort an den Kunden zurück:

Der Client zeigt die Mitteilung an: „Ist dieser Mietwagen für Ihren 5-Nächte-Aufenthalt in Chicago am 18.12.2016?“

Benutzer: „Ja“

Der Kunde sendet die folgendePostText Anfrage an 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 liest deninputText und kennt den Kontext (hat den Benutzer gebeten, die auto Auffüllung zu bestätigen). Amazon Lex die Lambda-Funktion, indem es das folgende Ereignis auf:


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

Da der Benutzer mit Ja geantwortet hat, legt Amazon LexconfirmationStatus die Einstellung festConfirmed.

Aus demconfirmationStatus weiß die Lambda-Funktion, dass die vorab ausgefüllten Werte korrekt sind. Die Lambda-Funktion:

Sie aktualisiert das Sitzungsattribut currentReservation auf den vorab ausgefüllten Slot-Wert.
Sie setzt den dialogAction.type auf ElicitSlot.
Sie setzt den Wert slotToElicit auf DriverAge.

Die folgende Antwort wird gesendet:


{
    "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 gibt folgende Antwort zurück:

Der Kunde zeigt die Meldung „Wie alt ist der Fahrer dieser Autovermietung?“ und die Unterhaltung wird fortgesetzt.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Schritt 4: Fügen Sie die Lambda-Funktion als Code-Hook hinzu

Beispiel: Mit Antwortkarte