Fase 5 (facoltativo): Revisione dei dettagli del flusso di informazioni (console)

Questa sezione spiega il flusso di informazioni tra il client e Amazon Lex per ogni input dell'utente, inclusa l'integrazione della funzione Lambda.

Nota

La sezione presuppone che il client invii richieste ad Amazon Lex utilizzando l'APIPostText di runtime e mostri i dettagli della richiesta e della risposta di conseguenza. Per un esempio del flusso di informazioni tra il client e Amazon Lex in cui il client utilizza l'PostContentAPI, consultaFase 2a (facoltativo): Revisione dei dettagli del flusso di informazioni parlate (console) .

Per ulteriori informazioni sull'API di runtime PostText e ulteriori dettagli sulle richieste e le risposte mostrate nelle fasi seguenti, consulta l'argomento PostText.

Utente: Vorrei ordinare dei fiori.
1. Il client (console) invia la seguente richiesta PostText ad Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"

{
    "inputText": "I would like to order some flowers",
    "sessionAttributes": {}
}
```
  Sia l'URI della richiesta che il corpo forniscono informazioni ad Amazon Lex:
  - URI di richiesta: fornisce il nome del bot (OrderFlowers), l'alias del bot ($LATEST) e il nome utente (una stringa casuale che identifica l'utente). Il codice text finale indica che si tratta di una richiesta API PostText (non PostContent).
  - Corpo della richiesta: include l'input utente (inputText) e il campo sessionAttributes vuoto. Quando il client effettua la prima richiesta non vi sono attributi della sessione. La funzione Lambda li avvia in un secondo momento.
2. Da lìinputText, Amazon Lex rileva l'intento (OrderFlowers). Questo intento è configurato con una funzione Lambda come hook di codice per l'inizializzazione e la convalida dei dati utente. Pertanto, Amazon Lex richiama quella funzione Lambda passando le seguenti informazioni come dati dell'evento:
```
{
    "messageVersion": "1.0",
    "invocationSource": "DialogCodeHook",
    "userId": "ignw84y6seypre4xly5rimopuri2xwnd",
    "sessionAttributes": {},
    "bot": {
        "name": "OrderFlowers",
        "alias": null,
        "version": "$LATEST"
    },
    "outputDialogMode": "Text",
    "currentIntent": {
        "name": "OrderFlowers",
        "slots": {
            "PickupTime": null,
            "FlowerType": null,
            "PickupDate": null
        },
        "confirmationStatus": "None"
    }
}
```
  Per ulteriori informazioni, consulta Formato dell'evento di input.
  
  Oltre alle informazioni inviate dal cliente, Amazon Lex include anche i seguenti dati aggiuntivi:
  - messageVersion— Attualmente Amazon Lex supporta solo la versione 1.0.
  - invocationSource— Indica lo scopo dell'invocazione della funzione Lambda. In questo caso, lo scopo è eseguire l'inizializzazione e la convalida dei dati utente. Al momento, Amazon Lex sa che l'utente non ha fornito tutti i dati dello slot necessari per soddisfare l'intento.
  - Informazioni su currentIntent con tutti i valori dello slot impostati su null.
3. Al momento, tutti i valori dello slot sono nulli. Non c'è nulla da convalidare per la funzione Lambda. La funzione Lambda restituisce la seguente risposta ad Amazon Lex:
```
{
    "sessionAttributes": {},
    "dialogAction": {
        "type": "Delegate",
        "slots": {
            "PickupTime": null,
            "FlowerType": null,
            "PickupDate": null
        }
    }
}
```
  Per informazioni sul formato della risposta, consulta l'argomento Formato della risposta.
  
  Tieni presente quanto segue:
  - dialogAction.type— Impostando questo valore suDelegate, la funzione Lambda delega ad Amazon Lex la responsabilità di decidere la prossima linea d'azione.
    
    Nota
    Se la funzione Lambda rileva qualcosa nella convalida dei dati utente, indica ad Amazon Lex cosa fare dopo, come mostrato nei passaggi successivi.
4. Secondo ildialogAction.type, Amazon Lex decide la prossima linea d'azione. Poiché nessuno slot è popolato, decide di ottenere il valore dello slot FlowerType Inoltre, seleziona uno dei messaggi di richiesta per l'ottenimento del valore ("What type of flowers would you like to order?") dello slot e invia la seguente risposta al client:
  
  Il client visualizza il messaggio nella risposta.
Utente: rosa
1. Il client invia la seguentePostText richiesta ad Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"

{
    "inputText": "roses",
    "sessionAttributes": {}
}
```
  Nel corpo della richiesta, inputText fornisce l'input utente. sessionAttributes rimane vuoto.
2. Amazon Lex lo interpreta innanzituttoinputText nel contesto dell'intento attuale. Il servizio ricorda che aveva richiesto all'utente specifico le informazioni sullo slot FlowerType Aggiorna il valore dello slot nell'intento corrente e richiama la funzione Lambda con i seguenti dati sugli eventi:
```
{
    "messageVersion": "1.0",
    "invocationSource": "DialogCodeHook",
    "userId": "ignw84y6seypre4xly5rimopuri2xwnd",
    "sessionAttributes": {},
    "bot": {
        "name": "OrderFlowers",
        "alias": null,
        "version": "$LATEST"
    },
    "outputDialogMode": "Text",
    "currentIntent": {
        "name": "OrderFlowers",
        "slots": {
            "PickupTime": null,
            "FlowerType": "roses",
            "PickupDate": null
        },
        "confirmationStatus": "None"
    }
}
```
  Tieni presente quanto segue:
  - invocationSource: continua a essere DialogCodeHook (stiamo semplicemente convalidando i dati utente).
  - currentIntent.slots— Amazon Lex ha aggiornato loFlowerType slot alle rose.
3. In base alinvocationSource valore diDialogCodeHook, la funzione Lambda esegue la convalida dei dati utente. Riconosceroses come valore di slot valido (e viene impostatoPrice come attributo di sessione) e restituisce la seguente risposta ad Amazon Lex.
```
{
    "sessionAttributes": {
        "Price": 25
    },
    "dialogAction": {
        "type": "Delegate",
        "slots": {
            "PickupTime": null,
            "FlowerType": "roses",
            "PickupDate": null
        }
    }
}
```
  Tieni presente quanto segue:
  - sessionAttributes— La funzione Lambda è stata aggiuntaPrice (delle rose) come attributo di sessione.
  - dialogAction.type: è impostato su Delegate. I dati utente erano validi, quindi la funzione Lambda indirizza Amazon Lex a scegliere la prossima linea d'azione.
4. Secondo ildialogAction.type, Amazon Lex sceglie la prossima linea d'azione. Amazon Lex sa di aver bisogno di più dati sugli slot, quindi sceglie il successivo slot non riempito (PickupDate) con la massima priorità in base alla configurazione dell'intento. Amazon Lex seleziona uno dei messaggi di richiesta di promozione del valore: «In che giorno vuoi che vengano ritirate le rose?» —per questo slot in base alla configurazione dell'intento, quindi invia la seguente risposta al client:
  
  Il client visualizza semplicemente il messaggio nella risposta: "What day do you want the roses to be picked up?"
Utente: domani
1. Il client invia la seguentePostText richiesta ad Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"

{
    "inputText": "tomorrow",
    "sessionAttributes": {
        "Price": "25"
    }
}
```
  Nel corpo della richiesta, inputText fornisce l'input utente e il client trasferisce gli attributi di sessione al servizio.
2. Amazon Lex ricorda il contesto, ossia che stava raccogliendo dati per loPickupDate slot. In questo contesto, sa che il valore inputText è per lo slot PickupDate. Amazon Lex richiama quindi la funzione Lambda inviando il seguente evento:
```
{
    "messageVersion": "1.0",
    "invocationSource": "DialogCodeHook",
    "userId": "ignw84y6seypre4xly5rimopuri2xwnd",
    "sessionAttributes": {
        "Price": "25"
    },
    "bot": {
        "name": "OrderFlowersCustomWithRespCard",
        "alias": null,
        "version": "$LATEST"
    },
    "outputDialogMode": "Text",
    "currentIntent": {
        "name": "OrderFlowers",
        "slots": {
            "PickupTime": null,
            "FlowerType": "roses",
            "PickupDate": "2017-01-05"
        },
        "confirmationStatus": "None"
    }
}
```
  Amazon Lex ha aggiornato ilcurrentIntent.slots impostando ilPickupDate valore. Si noti inoltre che il servizio passa ilsessionAttributes file così com'è alla funzione Lambda.
3. In base alinvocationSource valore diDialogCodeHook, la funzione Lambda esegue la convalida dei dati utente. Riconosce che il valorePickupDate dello slot è valido e restituisce la seguente risposta ad Amazon Lex:
```
{
    "sessionAttributes": {
        "Price": 25
    },
    "dialogAction": {
        "type": "Delegate",
        "slots": {
            "PickupTime": null,
            "FlowerType": "roses",
            "PickupDate": "2017-01-05"
        }
    }
}
```
  Tieni presente quanto segue:
  - sessionAttributes: nessuna modifica.
  - dialogAction.type: è impostato su Delegate. I dati utente erano validi e la funzione Lambda indica ad Amazon Lex di scegliere la prossima linea d'azione.
4. Secondo ildialogAction.type, Amazon Lex sceglie la prossima linea d'azione. Amazon Lex sa di aver bisogno di più dati sugli slot, quindi sceglie il successivo slot non riempito (PickupTime) con la massima priorità in base alla configurazione dell'intento. Amazon Lex seleziona uno dei messaggi rapidi («Consegnare le rose a che ora il 05/01/2017?») per questo slot in base alla configurazione dell'intento e invia la seguente risposta al client:
  
  Il cliente visualizza il messaggio nella risposta: «Consegnare le rose a che ora il 05/01/2017?»
Utente: 16:00
1. Il client invia la seguentePostText richiesta ad Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"

{
    "inputText": "4 pm",
    "sessionAttributes": {
        "Price": "25"
    }
}
```
  Nel corpo della richiesta, inputText fornisce l'input utente. Il client trasferisce sessionAttributes nella richiesta.
2. Amazon Lex comprende il contesto. Comprende inoltre che stava richiedendo i dati dello slot PickupTime. In questo contesto, sa che ilinputText valore è per loPickupTime slot. Amazon Lex richiama quindi la funzione Lambda inviando il seguente evento:
```
{
    "messageVersion": "1.0",
    "invocationSource": "DialogCodeHook",
    "userId": "ignw84y6seypre4xly5rimopuri2xwnd",
    "sessionAttributes": {
        "Price": "25"
    },
    "bot": {
        "name": "OrderFlowersCustomWithRespCard",
        "alias": null,
        "version": "$LATEST"
    },
    "outputDialogMode": "Text",
    "currentIntent": {
        "name": "OrderFlowers",
        "slots": {
            "PickupTime": "16:00",
            "FlowerType": "roses",
            "PickupDate": "2017-01-05"
        },
        "confirmationStatus": "None"
    }
}
```
  Amazon Lex ha aggiornato ilcurrentIntent.slots impostando ilPickupTime valore.
3. In base alinvocationSource valore diDialogCodeHook, la funzione Lambda esegue la convalida dei dati utente. Riconosce che il valorePickupDate dello slot è valido e restituisce la seguente risposta ad Amazon Lex.
```
{
    "sessionAttributes": {
        "Price": 25
    },
    "dialogAction": {
        "type": "Delegate",
        "slots": {
            "PickupTime": "16:00",
            "FlowerType": "roses",
            "PickupDate": "2017-01-05"
        }
    }
}
```
  Tieni presente quanto segue:
  - sessionAttributes: nessuna modifica dell'attributo di sessione.
  - dialogAction.type: è impostato su Delegate. I dati utente erano validi, quindi la funzione Lambda indirizza Amazon Lex a scegliere la prossima linea d'azione.
4. Al momento Amazon Lex sa di avere tutti i dati relativi agli slot. Tuttavia, poiché questo intento è configurato con un prompt di conferma, Pertanto, Amazon Lex invia la seguente risposta all'utente chiedendo conferma prima di soddisfare l'intento:
  
  Il client visualizza semplicemente il messaggio nella risposta e attende la risposta dell'utente.
Utente: Sì
1. Il client invia la seguentePostText richiesta ad Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"

{
    "inputText": "yes",
    "sessionAttributes": {
        "Price": "25"
    }
}
```
2. Amazon Lex lo interpretainputText nel contesto della conferma dell'intento attuale. Amazon Lex comprende che l'utente desidera procedere con l'ordine. Questa volta Amazon Lex richiama la funzione Lambda per soddisfare l'intento inviando il seguente evento, che imposta ilinvocationSource valore toFulfillmentCodeHook nel caso in cui venga inviato alla funzione Lambda. Amazon Lex imposta ancheconfirmationStatus ilConfirmed.
```
{
    "messageVersion": "1.0",
    "invocationSource": "FulfillmentCodeHook",
    "userId": "ignw84y6seypre4xly5rimopuri2xwnd",
    "sessionAttributes": {
        "Price": "25"
    },
    "bot": {
        "name": "OrderFlowersCustomWithRespCard",
        "alias": null,
        "version": "$LATEST"
    },
    "outputDialogMode": "Text",
    "currentIntent": {
        "name": "OrderFlowers",
        "slots": {
            "PickupTime": "16:00",
            "FlowerType": "roses",
            "PickupDate": "2017-01-05"
        },
        "confirmationStatus": "Confirmed"
    }
}
```
  Tieni presente quanto segue:
  - invocationSource— Questa volta Amazon Lex ha impostato questo valore suFulfillmentCodeHook, indirizzando la funzione Lambda a soddisfare l'intento.
  - confirmationStatus: è impostato su Confirmed.
3. Questa volta, la funzione Lambda soddisfa l'OrderFlowersintento e restituisce la seguente risposta:
```
{
    "sessionAttributes": {
        "Price": "25"
    },
    "dialogAction": {
        "type": "Close",
        "fulfillmentState": "Fulfilled",
        "message": {
            "contentType": "PlainText",
            "content": "Thanks, your order for roses has been placed and will be ready for pickup by 16:00 on 2017-01-05"
        }
    }
}
```
  Tieni presente quanto segue:
  - Imposta il valoredialogAction.type — La funzione Lambda imposta questo valore suClose, indicando ad Amazon Lex di non aspettarsi una risposta da parte dell'utente.
  - dialogAction.fulfillmentState: è impostato su Fulfilled (Soddisfatto) e include un elemento message appropriato da trasmettere all'utente.
4. Amazon Lex lo esaminafulfillmentState e invia al client la seguente.
  
  Amazon Lex restituisce quindi quanto segue al cliente:
  
  Nota:
  - dialogState— Amazon Lex imposta questo valore sufulfilled.
  - message— è lo stesso messaggio fornito dalla funzione Lambda.
  Il client visualizza il messaggio.
A questo punto, esegui nuovamente il test del bot. Per stabilire un nuovo contesto (utente), scegli il collegamento Clear (Cancella) nella finestra di prova. A questo punto, fornisci dei dati non validi dello slot per l'intento OrderFlowers. Questa volta la funzione Lambda esegue la convalida dei dati, reimposta il valore dei dati dello slot non valido su nullo e chiede ad Amazon Lex di richiedere all'utente di immettere dati validi. Ad esempio, prova quanto seguente:
- Gelsomino come tipo di fiore (non è uno dei tipi di fiore supportati).
- Ieri come giorno in cui si desidera ritirare i fiori.
- Dopo aver effettuato l'ordine, inserisci un altro tipo di fiore invece che rispondere "yes" per confermare l'ordine. In risposta, la funzione Lambda aggiorna l'attributoPrice in the session, mantenendo un totale continuo degli ordini di fiori.
La funzione Lambda svolge anche l'attività di adempimento.

Fase successiva

Fase 6: Aggiornamento della configurazione dell'intento per aggiungere un'enunciazione (console)

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Passaggio 4: aggiungere la funzione Lambda come Code Hook (console)

Fase 6: Aggiornamento della configurazione dell'intento per aggiungere un'enunciazione (console)