Etapa 5 (opcional): Revise os detalhes do fluxo de informações (console)

Esta seção explica o fluxo de informações entre o cliente e o Amazon Lex para cada entrada do usuário, incluindo a integração da função do Lambda.

nota

A seção supõe que o cliente envia solicitações ao Amazon Lex usando a API de runtime PostText e mostra os detalhes da solicitação e da resposta adequadamente. Para obter um exemplo do fluxo de informações entre o cliente e o Amazon Lex no qual o cliente usa a API PostContent, consulte Etapa 2a (opcional): revisar os detalhes do fluxo de informações falado (console) .

Para obter mais informações sobre a API de runtime PostText e detalhes adicionais sobre as solicitações e respostas mostradas nas etapas a seguir, consulte PostText.

Usuário: "Eu gostaria de encomendar flores."
1. O cliente (console) envia a seguinte solicitação PostText para o 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": {}
}
```
  O URI de solicitação e o corpo fornecem informações ao Amazon Lex:
  - URI de solicitação: fornece o nome do bot (OrderFlowers), o alias do bot ($LATEST) e o nome do usuário (uma string aleatória que identifica o usuário). O text final indica que esta é uma solicitação de API PostText (e não PostContent).
  - Corpo da solicitação – inclui a entrada do usuário (inputText) e sessionAttributes vazio. Quando o cliente faz a primeira solicitação, não há atributos de sessão. A função do Lambda as inicia posteriormente.
2. A partir de inputText, o Amazon Lex detecta a intenção (OrderFlowers). Essa intenção é configurada com uma função do Lambda como um hook de código para inicialização e validação dos dados do usuário. Portanto, o Amazon Lex invoca aquela função do Lambda especificando as seguintes informações como dados de 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"
    }
}
```
  Para obter mais informações, consulte Formato de eventos de entrada.
  
  Além das informações enviadas pelo cliente, o Amazon Lex também inclui os seguintes dados adicionais:
  - messageVersion – atualmente, o Amazon Lex oferece suporte apenas à versão 1.0.
  - invocationSource – indica o objetivo da invocação da função do Lambda. Nesse caso, é para executar os dados de inicialização e validação do usuário. Neste ponto, o Amazon Lex sabe que o usuário não forneceu todos os dados do slot para atender à intenção.
  - Informações currentIntent com todos os valores de slot definidos como nulo.
3. No momento, todos os valores de slot são nulos. Não há nada para a função do Lambda validar. A função do Lambda retorna a seguinte resposta para Amazon Lex:
```
{
    "sessionAttributes": {},
    "dialogAction": {
        "type": "Delegate",
        "slots": {
            "PickupTime": null,
            "FlowerType": null,
            "PickupDate": null
        }
    }
}
```
  Para obter mais informações sobre o formato de resposta, consulte Formato de resposta.
  
  Observe o seguinte:
  - dialogAction.type – ao definir esse valor para Delegate, a função do Lambda delega a responsabilidade de decidir a próxima ação a Amazon Lex.
    
    nota
    Se a função do Lambda detectar qualquer coisa na validação dos dados do usuário, ela instruirá o Amazon Lex sobre o que fazer em seguida, conforme mostrado nas próximas etapas.
4. De acordo com o dialogAction.type, o Amazon Lex decide a próxima ação. Como nenhum dos slots estão preenchidos, ele decide escolher o valor para o slot FlowerType. Ele seleciona uma das solicitações de escolha de valor ("What type of flowers would you like to order? (Que tipo de flores você deseja encomendar?)") para este slot e envia a resposta a seguir de volta ao cliente:
  
  O cliente exibe a mensagem na resposta.
Usuário: rosas
1. O cliente envia a seguinte solicitação PostText para o Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"

{
    "inputText": "roses",
    "sessionAttributes": {}
}
```
  No corpo da solicitação, o inputText fornece entradas do usuário. O sessionAttributes permanece vazio.
2. O Amazon Lex primeiro interpreta o inputText no contexto da intenção atual. O serviço lembra que havia solicitado ao usuário específico informações sobre o slot FlowerType. Ele atualiza o valor do slot na intenção atual e invoca a função do Lambda com os seguintes dados do 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": "roses",
            "PickupDate": null
        },
        "confirmationStatus": "None"
    }
}
```
  Observe o seguinte:
  - invocationSource – continua sendo DialogCodeHook (estamos simplesmente validando os dados do usuário).
  - currentIntent.slots – o Amazon Lex atualizou o slot FlowerType para rosas.
3. De acordo com o valor invocationSource de DialogCodeHook, a função do Lambda executa a validação dos dados do usuário. Ele reconhece roses como um valor de slot válido (e define Price como um atributo de sessão) e retorna a seguinte resposta ao Amazon Lex.
```
{
    "sessionAttributes": {
        "Price": 25
    },
    "dialogAction": {
        "type": "Delegate",
        "slots": {
            "PickupTime": null,
            "FlowerType": "roses",
            "PickupDate": null
        }
    }
}
```
  Observe o seguinte:
  - sessionAttributes – a função do Lambda adicionou o Price (das rosas) como atributo de sessão.
  - dialogAction.type – é definido como Delegate. Os dados do usuário eram válidos, então a função do Lambda direciona o Amazon Lex para escolher a próxima ação.
4. De acordo com o dialogAction.type, o Amazon Lex escolherá a próxima ação. O Amazon Lex sabe que precisa de mais dados de slot, então escolhe o próximo slot não preenchido (PickupDate) com a maior prioridade de acordo com a configuração de intenção. O Amazon Lex seleciona uma das mensagens de solicitação ("What day do you want to check in?") para esse slot, de acordo com a configuração da intenção, e envia a seguinte resposta de volta ao cliente:
  
  O cliente simplesmente exibe a mensagem na resposta – "Em que dia você deseja receber as rosas?."
Usuário: amanhã
1. O cliente envia a seguinte solicitação PostText para o Amazon Lex:
```
POST /bot/OrderFlowers/alias/$LATEST/user/ignw84y6seypre4xly5rimopuri2xwnd/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"

{
    "inputText": "tomorrow",
    "sessionAttributes": {
        "Price": "25"
    }
}
```
  No corpo da solicitação, inputText fornece entradas do usuário e o cliente passa os atributos de sessão de volta ao serviço.
2. O Amazon Lex lembra do contexto para o qual estava escolhendo dados para o slot PickupDate. Nesse contexto, ele sabe que o valor inputText é para o slot PickupDate. Em seguida, o Amazon Lex invoca a função do Lambda enviando o seguinte 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"
    }
}
```
  O Amazon Lex atualizou o currentIntent.slots definindo o valor PickupDate. Observe também que o serviço passa o sessionAttributes como é para a função do Lambda.
3. De acordo com o valor invocationSource de DialogCodeHook, a função do Lambda executa a validação dos dados do usuário. Ela reconhece que o valor de slot PickupDate é válido e retorna a seguinte resposta a Amazon Lex:
```
{
    "sessionAttributes": {
        "Price": 25
    },
    "dialogAction": {
        "type": "Delegate",
        "slots": {
            "PickupTime": null,
            "FlowerType": "roses",
            "PickupDate": "2017-01-05"
        }
    }
}
```
  Observe o seguinte:
  - sessionAttributes – sem alteração.
  - dialogAction.type – é definido como Delegate. Os dados do usuário eram válidos, e a função do Lambda direciona Amazon Lex para escolher a próxima ação.
4. De acordo com o dialogAction.type, o Amazon Lex escolherá a próxima ação. O Amazon Lex sabe que precisa de mais dados de slot, então escolhe o próximo slot não preenchido (PickupTime) com a maior prioridade de acordo com a configuração de intenção. O Amazon Lex seleciona uma das mensagens de aviso ("Entregar as rosas a que horas em 05/01/2017?") para esse slot de acordo com a configuração de intenção e envia a seguinte resposta de volta ao cliente:
  
  O cliente exibe a mensagem na resposta – "Entregar as rosas em que horário em 05/01/2017?"
Usuário: 16h
1. O cliente envia a seguinte solicitação PostText para o 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"
    }
}
```
  No corpo da solicitação, inputText fornece entradas do usuário. O cliente passa o sessionAttributes na solicitação.
2. O Amazon Lex entende o contexto. Ele entende que estava escolhendo dados para o slot PickupTime. Neste contexto, ele sabe que o valor inputText é para o slot PickupTime. Em seguida, o Amazon Lex invoca a função do Lambda enviando o seguinte 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"
    }
}
```
  O Amazon Lex atualizou o currentIntent.slots definindo o valor PickupTime.
3. De acordo com o valor invocationSource de DialogCodeHook, a função do Lambda executa a validação dos dados do usuário. Ela reconhece que o valor de slot PickupDate é válido e retorna a seguinte resposta a Amazon Lex.
```
{
    "sessionAttributes": {
        "Price": 25
    },
    "dialogAction": {
        "type": "Delegate",
        "slots": {
            "PickupTime": "16:00",
            "FlowerType": "roses",
            "PickupDate": "2017-01-05"
        }
    }
}
```
  Observe o seguinte:
  - sessionAttributes – nenhuma alteração no atributo de sessão.
  - dialogAction.type – é definido como Delegate. Os dados do usuário eram válidos, então a função do Lambda direciona o Amazon Lex para escolher a próxima ação.
4. Neste ponto, o Amazon Lex sabe que tem todos os dados do slot. Essa intenção é configurada com um prompt de confirmação. Portanto, o Amazon Lex envia a seguinte resposta ao usuário solicitando confirmação antes de atender a intenção:
  
  O cliente simplesmente exibe a mensagem na resposta e aguarda a resposta do usuário.
Usuário: Sim
1. O cliente envia a seguinte solicitação PostText para o 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. O Amazon Lex interpreta o inputText no contexto de confirmação da intenção atual. O Amazon Lex entende que o usuário deseja prosseguir com o pedido. Dessa vez, o Amazon Lex invoca a função do Lambda para cumprir a intenção enviando o seguinte evento, que define o invocationSource como FulfillmentCodeHook caso ele envie para a função do Lambda. O Amazon Lex também define o confirmationStatus como Confirmed.
```
{
    "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"
    }
}
```
  Observe o seguinte:
  - invocationSource – Dessa vez, o Amazon Lex define esse valor como FulfillmentCodeHook, direcionando a função do Lambda a atender à intenção.
  - confirmationStatus – é definido como Confirmed.
3. Dessa vez, a função do Lambda cumpre a intenção OrderFlowers e retorna a seguinte resposta:
```
{
    "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"
        }
    }
}
```
  Observe o seguinte:
  - Define o dialogAction.type: a função do Lambda define esse valor como Close, direcionando Amazon Lex para não esperar uma resposta do usuário.
  - dialogAction.fulfillmentState – é definido como Fulfilled e inclui uma message adequada para transmitir para o usuário.
4. Amazon Lex analisa o fulfillmentState e envia a resposta seguinte de volta para o cliente.
  
  Em seguida, o Amazon Lex retorna o seguinte ao cliente:
  
  Observe que:
  - dialogState: o Amazon Lex define esse valor como fulfilled.
  - message – é a mesma mensagem que a função do Lambda forneceu.
  O cliente exibe a mensagem.
Agora teste o bot novamente. Para estabelecer um novo contexto (de usuário), selecione o link Clear na janela de teste. Agora, forneça dados de slot inválidos para a intenção OrderFlowers. Desta vez, a função do Lambda executa a validação dos dados, redefine os valores dos dados do slot inválidos como nulos e pede ao Amazon Lex para solicitar dados válidos ao usuário. Por exemplo, tente o seguinte:
- Jasmim como o tipo de flor (não é um dos tipos de flor suportados).
- Ontem como o dia em que você deseja receber as flores.
- Após fazer o pedido, digite outro tipo de flor em vez de responder "sim" para confirmar o pedido. Em resposta, a função do Lambda atualiza o Price no atributo da sessão mantendo um total cumulativo de encomendas de flores.
A função do Lambda também executará a atividade de cumprimento.

Próxima etapa

Etapa 6: Atualize a configuração de intenção para adicionar um enunciado (console)

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Etapa 4: Adicione a função do Lambda como hook de código (console)

Etapa 6: Atualize a configuração de intenção para adicionar um enunciado (console)