Aviso de fim do suporte: em 15 de setembro de 2025, o suporte para o Amazon Lex V1 AWS será interrompido. Após 15 de setembro de 2025, você não poderá mais acessar o console do Amazon Lex V1 nem os respectivos recursos. Se você estiver usando o Amazon Lex V2, consulte o [guia do Amazon Lex V2](https://docs.aws.amazon.com/lexv2/latest/dg/what-is.html) em vez disso.
As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Agendar uma consulta
O exemplo de bot neste exercício marca consultas em uma clínica odontológica. O exemplo também ilustra o uso de cartões de resposta para obter entradas do usuário com botões. Especificamente, o exemplo ilustra a geração dinâmica de cartões de resposta em runtime.
Você pode configurar cartões de resposta no momento da construção (também chamados de cartões de resposta estáticos) ou gerá-los dinamicamente em uma AWS Lambda função. Neste exemplo, o bot usa os seguintes cartões de resposta:
+ Um cartão de resposta que lista botões para o tipo de consulta. Para obter um exemplo, veja a imagem a seguir.
![\[Cartão de resposta solicitando o tipo de consulta a ser agendada e três opções: limpeza (30 minutos), canal radicular (60 minutos) e clareamento (90 minutos).\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/respcard-10.png)
+ Um cartão de resposta que lista botões para a data de consulta. Para obter um exemplo, veja a imagem a seguir.
![\[Cartão de resposta perguntando a data para agendar a consulta e três opções: 2-15, 2-16 e 2-17.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/respcard-20.png)
+ Um cartão de resposta que lista botões para confirmar um horário de consulta sugerido. Para obter um exemplo, veja a imagem a seguir.
![\[Cartão de resposta solicitando a confirmação da hora e data da consulta com duas opções: sim e não.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/respcard-30.png)
As datas e os horários de consulta disponíveis variam, o que exige que você gere cartões de resposta em runtime. Você usa uma AWS Lambda função para gerar esses cartões de resposta dinamicamente. A função do Lambda retorna cartões de resposta em sua resposta a Amazon Lex. Amazon Lex inclui o cartão de resposta em sua resposta ao cliente.
Se um cliente (por exemplo, Facebook Messenger) oferecer suporte a cartões de resposta, o usuário poderá escolher na lista de botões ou digitar a resposta. Caso contrário, o usuário simplesmente digitará a resposta.
Além do botão mostrado no exemplo anterior, você também pode incluir imagens, anexos e outras informações úteis a serem exibidas nos cartões de resposta. Para obter mais informações sobre cartões de resposta, consulte [Cartões de resposta](howitworks-manage-prompts.md#msg-prompts-resp-card).
Neste exercício, você faz o seguinte:
+ Crie e teste um bot (usando o ScheduleAppointment blueprint). Para este exercício, você usará um esquema de bot para configurar e testar o bot rapidamente. Para obter uma lista de esquemas disponíveis, consulte [Amazon Lex e AWS Lambda Blueprints](lex-lambda-blueprints.md).Este bot está pré-configurado com uma intenção (`MakeAppointment`).
+ Crie e teste uma função Lambda (usando o lex-make-appointment-python esquema fornecido pelo Lambda). Configure a intenção `MakeAppointment` para usar essa função do Lambda como um hook de código para executar a inicialização, a validação e o cumprimento de tarefas.
**nota**
A função do Lambda de exemplo fornecida exibe uma conversa dinâmica baseada na disponibilidade inventada de uma consulta odontológica. Em uma aplicação real, você pode usar um calendário real para definir uma consulta.
+ Atualize a configuração de intenção `MakeAppointment` para usar a função do Lambda como hook de código. Em seguida, teste a end-to-end experiência.
+ Publique o bot de agendamento de consultas no Facebook Messenger para você possa ver os cartões de resposta em ação (atualmente, o cliente no console do Amazon Lex não oferece suporte a cartões de resposta).
As seções a seguir fornecem informações resumidas sobre os esquemas usados por você neste exercício.
**Topics**
+ [Visão geral do Bot Blueprint () ScheduleAppointment](#ex1-sch-appt-bp-summary-bot)
+ [Visão geral da função Lambda Blueprint () lex-make-appointment-python](#ex1-sch-appt-summary-lambda)
+ [Etapa 1: criar um bot do Amazon Lex](ex1-sch-appt-create-bot.md)
+ [Etapa 2: criar uma função do Lambda](ex1-sch-appt-create-lambda-function.md)
+ [Etapa 3: atualizar a intenção - configuração de um hook de código](ex1-sch-appt-create-integrate.md)
+ [Etapa 4: implantar o bot na plataforma do Facebook Messenger](ex-sch-appt-fb-integration.md)
+ [Detalhes do fluxo de informações](ex1-sch-appt-info-flow-details.md)
## Visão geral do Bot Blueprint () ScheduleAppointment
O ScheduleAppointment esquema que você usa para criar um bot para este exercício é pré-configurado com o seguinte:
+ **Tipos de slot** – um tipo de slot personalizado chamado `AppointmentTypeValue`, com os valores de enumeração `root canal`, `cleaning` e `whitening`.
+ **Intenção** – uma intenção (`MakeAppointment`), que está pré-configurada da seguinte forma:
+ **Slots** – a intenção está configurado com os seguintes slots:
+ Slot `AppointmentType`, do tipo de slot personalizado `AppointmentTypes`.
+ Slot `Date`, do tipo de slot integrado `AMAZON.DATE`.
+ Slot `Time`, do tipo de slot integrado `AMAZON.TIME`.
+ **Declarações**: a intenção está pré-configurada com as seguintes declarações:
+ "Eu gostaria de marcar uma consulta"
+ "Marcar uma consulta"
+ “Reserve um \$1AppointmentType\$1”
Se o usuário disser qualquer um desses, Amazon Lex determinará que `MakeAppointment` é a intenção e, em seguida, usará os prompts para escolher os dados de slot.
+ **Prompts** – a intenção está pré-configurada com os seguintes prompts:
+ Prompt do slot `AppointmentType` – "Que tipo de consulta você deseja marcar?"
+ Solicitar a `Date` vaga — “Quando devo agendar seu \$1AppointmentType\$1?”
+ Solicitar o `Time` horário — “A que horas você deseja agendar o \$1AppointmentType\$1?” and
"Em que horário em \$1Date\$1?"
+ Prompt de confirmação – "\$1Time\$1 está disponível. Posso prosseguir e marcar sua consulta?"
+ Mensagem de cancelamento – "OK, não marcarei a consulta."
## Visão geral da função Lambda Blueprint () lex-make-appointment-python
A função Lambda blueprint (lex-make-appointment-python) é um gancho de código para bots que você cria usando o blueprint do ScheduleAppointment bot.
Esse código do blueprint da função Lambda pode realizar tanto tarefas initialization/validation quanto tarefas de cumprimento.
+ A função do Lambda exibe uma conversa dinâmica baseada em um exemplo de disponibilidade para uma consulta odontológica (em aplicativos reais, você pode usar um calendário). Para o dia ou a data que o usuário especificar, o código será configurado da seguinte forma:
+ Se não houver consultas disponíveis, a função do Lambda retornará uma resposta direcionando o Amazon Lex a solicitar outro dia ou data ao usuário (definindo o tipo `dialogAction` como `ElicitSlot)`. Para obter mais informações, consulte [Formato de resposta](lambda-input-response-format.md#using-lambda-response-format).
+ Se houver apenas uma consulta disponível no dia ou data especificada, a função do Lambda sugerirá o horário disponível na resposta e direcionará o Amazon Lex a obter a confirmação do usuário definindo a `dialogAction` na resposta como `ConfirmIntent`. Isso ilustra como você pode melhorar a experiência do usuário sugerindo proativamente o horário disponível para uma consulta.
+ Se houver várias consultas disponíveis, a função do Lambda retornará uma lista de horários disponíveis na resposta ao Amazon Lex. Amazon Lex retorna uma resposta ao cliente com a mensagem da função do Lambda.
+ Como o hook de código de atendimento, a função do Lambda retorna um mensagem de resumo indicando que uma consulta está agendada (ou seja, a intenção está atendida).
**nota**
Neste exemplo, mostramos como usar cartões de resposta. A função do Lambda cria e retorna um cartão de resposta ao Amazon Lex. As listas de cartão de resposta lista dias e horários disponíveis como botões para o usuário escolher. Ao testar o bot usando o cliente fornecido pelo console do Amazon Lex, não é possível ver o cartão de resposta. Para vê-lo, você deve integrar o bot com uma plataforma de mensagens, como Facebook Messenger. Para instruções, consulte [Integração de um bot do Amazon Lex com o Facebook Messenger](fb-bot-association.md). Para obter mais informações sobre cartões de resposta, consulte [Gerenciamento de mensagens](howitworks-manage-prompts.md).
Quando o Amazon Lex invoca a função do Lambda, ela passa os dados do evento como entrada. Um dos campos do evento é `invocationSource`, que a função do Lambda usa para escolher entre uma validação de entrada e uma atividade de atendimento. Para obter mais informações, consulte [Formato de eventos de entrada](lambda-input-response-format.md#using-lambda-input-event-format).
**Próxima etapa**
[Etapa 1: criar um bot do Amazon Lex](ex1-sch-appt-create-bot.md)
# Etapa 1: criar um bot do Amazon Lex
Nesta seção, você cria um bot do Amazon Lex usando o ScheduleAppointment blueprint, que é fornecido no console do Amazon Lex.
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon Lex em [https://console.aws.amazon.com/lex/](https://console.aws.amazon.com/lex/).
1. Na página **Bots**, selecione **Create**.
1. Na página **Create your Lex bot**:
+ Escolha o esquema **ScheduleAppointment**.
+ Deixe o nome padrão do bot (ScheduleAppointment).
1. Escolha **Criar**.
Esta etapa salva e cria o bot. O console envia as seguintes solicitações para Amazon Lex durante o processo de criação:
+ Crie uma nova versão dos tipos de slot (da versão \$1LATEST). Para obter mais informações sobre tipos de slot neste esquema de bot, consulte [Visão geral do Bot Blueprint () ScheduleAppointment](ex1-sch-appt.md#ex1-sch-appt-bp-summary-bot).
+ Crie uma versão da intenção `MakeAppointment` (da versão \$1LATEST). Em alguns casos, o console envia uma solicitação para a operação da API `update` antes de criar uma nova versão.
+ Atualize a versão \$1LATEST do bot.
Neste ponto, o Amazon Lex cria um modelo de machine learning para o bot. Quando você testa o bot no console, o console usa a API de runtime para enviar entradas do usuário de volta para o Amazon Lex. Em seguida, o Amazon Lex usa o modelo de machine learning para interpretar a entrada do usuário.
1. O console mostra o ScheduleAppointment bot. Na guia **Editor**, analise os detalhes da intenção pré-configurada (`MakeAppointment`).
1. Teste o bot na janela de teste. Use a seguinte captura de tela para ter uma conversa de teste com o bot:
![\[Conversa com um atendente, na qual o atendente pergunta o tipo de compromisso, a data e a hora de um compromisso e, em seguida, confirma os detalhes do compromisso.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/appt-test-no-lambda.png)
Observe o seguinte:
+ Na entrada inicial do usuário ("Marcar uma consulta"), o bot infere a intenção (`MakeAppointment`).
+ Em seguida, ele usa os prompts configurados para obter dados de slot do usuário.
+ O esquema de bot tem a intenção `MakeAppointment` configurada com o seguinte prompt de confirmação:
```
{Time} is available, should I go ahead and book your appointment?
```
Depois que o usuário fornece todos os dados do slot, o Amazon Lex retorna uma resposta ao cliente com um prompt de confirmação como a mensagem. O cliente exibe a mensagem para o usuário:
```
16:00 is available, should I go ahead and book your appointment?
```
Observe que o bot aceita quaisquer data e horário de consulta, pois você não tem nenhum código para inicializar ou validar os dados do usuário. Na próxima seção, adicione uma função do Lambda para fazer isso.
**Próxima etapa**
[Etapa 2: criar uma função do Lambda](ex1-sch-appt-create-lambda-function.md)
# Etapa 2: criar uma função do Lambda
Nesta seção, você cria uma função Lambda usando um blueprint (lex-make-appointment-python) fornecido no console Lambda. Você também testa a função do Lambda invocando-a usando dados do evento de exemplo do Amazon Lex fornecido pelo console.
1. Faça login no Console de gerenciamento da AWS e abra o AWS Lambda console em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Escolha **Create a Lambda function**.
1. Em **Selecionar blueprint**, digite **lex** para encontrar o blueprint e, em seguida, escolha o **lex-make-appointment-python**blueprint.
1. Configure a função do Lambda da seguinte forma.
+ Digite o nome da função do Lambda (`MakeAppointmentCodeHook`).
+ Para a função, escolha **Create a new role from template(s)** e, em seguida, digite um nome de função.
+ Deixe outros valores padrão.
1. Escolha **Criar função**.
1. Se você estiver usando uma localidade diferente do inglês (EUA) (en-US), atualize os nomes das intenções conforme descrito em [Atualização de um esquema para uma localidade específica](lex-lambda-blueprints.md#blueprint-update-locale).
1. Testar a função do Lambda.
1. Escolha **Actions** e, em seguida, escolha **Configure test event**.
1. Na lista **Sample event template**, escolha **Lex-Make Appointment (preview)**. Esse exemplo de evento usa o request/response modelo Amazon Lex, com valores definidos para corresponder a uma solicitação do seu bot Amazon Lex. Para obter informações sobre o request/response modelo Amazon Lex, consulte[Uso de funções do Lambda](using-lambda.md).
1. Escolha **Save and test**.
1. Verifique se a função do Lambda foi executada com êxito. A resposta, neste caso, corresponde ao modelo de resposta do Amazon Lex.
**Próxima etapa**
[Etapa 3: atualizar a intenção - configuração de um hook de código](ex1-sch-appt-create-integrate.md)
# Etapa 3: atualizar a intenção - configuração de um hook de código
Nesta seção, você atualiza a configuração da intenção `MakeAppointment` para usar a função do Lambda como hook de código para a validação e as atividades de cumprimento.
1. No console do Amazon Lex, selecione o ScheduleAppointment bot. O console mostra a **MakeAppointment**intenção. Modifique a configuração de intenção da seguinte forma.
**nota**
Você pode atualizar apenas as versões \$1LATEST de qualquer um dos recursos do Amazon Lex incluindo as intenções. Verifique se a versão da intenção está definida como \$1LATEST. Você ainda não publicou uma versão de seu bot, então a versão ainda deve ser \$1LATEST no console.
1. Na seção **Options**, escolha **Initialization and validation code hook** e, em seguida, escolha a função do Lambda na lista.
1. Na seção **Fulfillment**, escolha **AWS Lambda function** e, em seguida, escolha a função do Lambda na lista.
1. Escolha **Goodbye message** e digite uma mensagem.
1. Escolha **Save** e, em seguida, **Build**.
1. Teste o bot, como na imagem a seguir:
![\[Conversa com um atendente, na qual o atendente pergunta o tipo de consulta, data e hora da consulta e, em seguida, confirma a consulta.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/appt-test-with-lambda.png)
**Próxima etapa**
[Etapa 4: implantar o bot na plataforma do Facebook Messenger](ex-sch-appt-fb-integration.md)
# Etapa 4: implantar o bot na plataforma do Facebook Messenger
Na seção anterior, você testou o ScheduleAppointment bot usando o cliente no console do Amazon Lex. No momento, o console Amazon Lex não oferece suporte a cartões de resposta. Para testar os cartões de resposta gerados dinamicamente aos quais o bot oferece suporte, implante o bot na plataforma do Facebook Messenger e teste-o.
Para instruções, consulte [Integração de um bot do Amazon Lex com o Facebook Messenger](fb-bot-association.md).
**Próxima etapa**
[Detalhes do fluxo de informações](ex1-sch-appt-info-flow-details.md)
# Detalhes do fluxo de informações
O esquema de bot `ScheduleAppointment` exibe, principalmente, o uso de cartões de resposta gerados dinamicamente. A função do Lambda neste exercício inclui cartões de resposta em sua resposta ao Amazon Lex. Amazon Lex inclui os cartões de resposta em sua resposta ao cliente. Esta seção explica o seguinte:
+ Fluxo de dados entre o cliente e Amazon Lex.
A seção pressupõe que o cliente envie solicitações para o Amazon Lex usando a API `PostText` de tempo de execução e mostre request/response os detalhes adequadamente. Para obter mais informações sobre a API de runtime `PostText`, consulte [PostText](API_runtime_PostText.md).
**nota**
Para obter um exemplo do fluxo de informações entre o cliente e Amazon Lex em que o cliente usa a API `PostContent`, consulte [Etapa 2a (opcional): revisar os detalhes do fluxo de informações falado (console)](gs-bp-details-postcontent-flow.md).
+ Fluxo de dados entre Amazon Lex e a função do Lambda. Para obter mais informações, consulte [Evento de entrada de função do Lambda e formato de resposta](lambda-input-response-format.md).
**nota**
O exemplo supõe que você esteja usando o cliente Facebook Messenger, que não passa atributos de sessão na solicitação para Amazon Lex. Dessa forma, os exemplos de solicitações desta seção mostram `sessionAttributes` vazio. Se você testar o bot usando o cliente fornecido no console Amazon Lex, o cliente incluirá os atributos de sessão.
Esta seção descreve o que acontece após cada entrada do usuário.
1. Usuário: tipos **Book an appointment**
1. O cliente (console) envia a seguinte solicitação [PostContent](API_runtime_PostContent.md) para o Amazon Lex:
```
POST /bot/ScheduleAppointment/alias/$LATEST/user/bijt6rovckwecnzesbthrr1d7lv3ja3n/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText":"book appointment",
"sessionAttributes":{}
}
```
O URI de solicitação e o corpo fornecem informações ao Amazon Lex:
+ URI de solicitação — fornece o nome do bot (ScheduleAppointment), o alias do bot (\$1LATEST) e o ID do nome do usuário. O `text` final indica que esta é uma solicitação de API `PostText` (não `PostContent`).
+ Corpo da solicitação: inclui a entrada do usuário (`inputText`) e `sessionAttributes` vazio.
1. A partir de `inputText`, o Amazon Lex detecta a intenção (`MakeAppointment`). O serviço invoca a função do Lambda, que está configurada como um hook de código, para executar a inicialização e a validação passando o seguinte evento. Para obter detalhes, consulte [Formato de eventos de entrada](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": {}
}
```
Além das informações enviadas pelo cliente, o Amazon Lex também inclui os seguintes dados:
+ `currentIntent` - Fornece informações de intenção atuais.
+ `invocationSource`: indica o objetivo da invocação da função do Lambda. Nesse caso, o objetivo é executar os dados de inicialização e validação do usuário. (Amazon Lex sabe que o usuário não forneceu todos os dados de slot para cumprir a intenção.)
+ `messageVersion`: atualmente, o Amazon Lex oferece suporte apenas à versão 1.0.
1. No momento, todos os valores de slot são nulos (não há nada para validar). A função do Lambda retorna a seguinte resposta para o Amazon Lex direcionando o serviço a obter informações para o slot `AppointmentType`. Para obter mais informações sobre o formato de resposta, consulte [Formato de resposta](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": {}
}
```
A resposta inclui os campos `dialogAction` e `sessionAttributes`. Dentre outras coisas, o campo `dialogAction` retorna os seguintes campos:
+ `type`: ao definir esse campo como `ElicitSlot`, a função do Lambda direciona o Amazon Lex a escolher o valor para o slot especificado no campo `slotToElicit`. A função do Lambda também fornece uma `message` para transmitir ao usuário.
+ `responseCard`: identifica uma lista de valores possíveis para o slot `AppointmentType`. Um cliente que oferece suporte a cartões de resposta (por exemplo, Facebook Messenger) exibe um cartão de resposta para permitir que o usuário escolha um tipo de consulta da seguinte forma:
![\[Cartão de resposta perguntando o tipo de consulta a ser agendada e três opções: limpeza (30 minutos), canal radicular (60 minutos) e clareamento (30 minutos).\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/respcard-10.png)
1. Como indicado pelo `dialogAction.type` na resposta da função do Lambda, Amazon Lex envia a seguinte resposta de volta para o cliente:
![\[Resposta JSON contendo informações sobre a intenção de marcar uma consulta e o tipo de horário a ser obtido.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/appt-10.png)
O cliente lê a resposta e, em seguida, exibe a mensagem: "Que tipo de consulta você deseja marcar?" e o cartão de resposta (se o cliente oferece suporte a cartões de resposta).
1. Usuário: dependendo do cliente, o usuário tem duas opções:
+ Se o cartão de resposta for exibido, escolha **root canal (60 min) (canal de raiz (60 min))** ou digite **root canal**.
+ Se o cliente não oferecer suporte a cartões de resposta, digite **root canal**.
1. O cliente envia a seguinte solicitação `PostText` ao Amazon Lex (quebras de linha foram adicionadas para legibilidade):
```
POST /bot/BookTrip/alias/$LATEST/user/bijt6rovckwecnzesbthrr1d7lv3ja3n/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "root canal",
"sessionAttributes": {}
}
```
1. O Amazon Lex invoca a função do Lambda para validação dos dados do usuário enviando o seguinte evento como parâmetro:
```
{
"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": {}
}
```
Nos dados de evento, observe o seguinte:
+ `invocationSource` continua sendo `DialogCodeHook`. Nesta etapa, estamos apenas validando os dados do usuário.
+ O Amazon Lex define o campo `AppointmentType` no slot `currentIntent.slots` como `root canal`.
+ Amazon Lex simplesmente passa o campo `sessionAttributes` entre o cliente e a função do Lambda.
1. A função do Lambda valida a entrada do usuário e retorna a seguinte resposta ao Amazon Lex, direcionando o serviço a escolher um valor para a data da consulta.
```
{
"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": {}
}
```
Novamente, a resposta inclui os campos `dialogAction` e `sessionAttributes`. Dentre outras coisas, o campo `dialogAction` retorna os seguintes campos:
+ `type`: ao definir esse campo como `ElicitSlot`, a função do Lambda direciona o Amazon Lex a escolher o valor para o slot especificado no campo `slotToElicit`. A função do Lambda também fornece uma `message` para transmitir ao usuário.
+ `responseCard`: identifica uma lista de valores possíveis para o slot `Date`. Um cliente que oferece suporte a cartões de resposta (por exemplo, Facebook Messenger) exibe um cartão de resposta que permite que o usuário escolha uma data de consulta:
![\[Cartão de resposta com a data para programar o canal radicular e três opções: 2-15, 2-16 e 2-17.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/respcard-20.png)
Apesar de a função do Lambda ter retornado cinco datas, o cliente (Facebook Messenger) tem um limite de três botões por cartão de resposta. Portanto, você verá apenas os primeiros três valores na captura de tela.
Essas datas são codificadas na função do Lambda. Em uma aplicação de produção, você pode usar um calendário para obter datas disponíveis em tempo real. Como as datas são dinâmicas, você deve gerar o cartão de resposta dinamicamente na função do Lambda.
1. O Amazon Lex observa o `dialogAction.type` e retorna a resposta a seguir ao cliente que inclui informações da reposta da função do Lambda.
![\[Resposta JSON contendo a intenção de marcar um compromisso, o tipo de compromisso preenchido e uma mensagem indicando a data do compromisso.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/appt-20.png)
O cliente exibe a mensagem: **When would you like to schedule your root canal? (Quando você deseja agendar seu canal de raiz?)** e o cartão de resposta (se o cliente oferecer suporte a cartões de resposta).
1. Usuário: tipos **Thursday**
1. O cliente envia a seguinte solicitação `PostText` ao Amazon Lex (quebras de linha foram adicionadas para legibilidade):
```
POST /bot/BookTrip/alias/$LATEST/user/bijt6rovckwecnzesbthrr1d7lv3ja3n/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "Thursday",
"sessionAttributes": {}
}
```
1. O Amazon Lex invoca a função do Lambda para validação dos dados do usuário enviando o seguinte evento como parâmetro:
```
{
"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": {}
}
```
Nos dados de evento, observe o seguinte:
+ `invocationSource` continua sendo `DialogCodeHook`. Nesta etapa, estamos apenas validando os dados do usuário.
+ O Amazon Lex define o campo `Date` no slot `currentIntent.slots` como `2017-02-16`.
+ Amazon Lex simplesmente passa o campo `sessionAttributes` entre o cliente e a função do Lambda.
1. A função do Lambda valida a entrada do usuário. Desta vez, a função do Lambda determina que não há consultas disponíveis na data especificada. Ela retorna a seguinte resposta ao Amazon Lex direcionando o serviço a escolher novamente um valor para a data da consulta.
```
{
"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\": []}"
}
}
```
Novamente, a resposta inclui os campos `dialogAction` e `sessionAttributes`. Dentre outras coisas, o `dialogAction` retorna os seguintes campos:
+ campo `dialogAction`:
+ `type` - A função do Lambda define esse valor como `ElicitSlot` e redefine o campo `slotToElicit` como `Date`. A função do Lambda também fornece um `message` adequado para transmitir ao usuário.
+ `responseCard` - Retorna uma lista de valores para o slot `Date`.
+ `sessionAttributes`: dessa vez, a função do Lambda inclui o atributo de sessão `bookingMap`. Seu valor é a data solicitada da consulta e das consultas disponíveis (um objeto vazio indica que não há consultas disponíveis).
1. O Amazon Lex observa o `dialogAction.type` e retorna a resposta a seguir ao cliente que inclui informações da reposta da função do Lambda.
![\[Resposta JSON mostrando a intenção de marcar uma consulta e mensagem esclarecendo que não há disponibilidade na data solicitada pelo cliente.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/appt-30.png)
O cliente exibe a mensagem: **We do not have any availability on that date, is there another day which works for you? (Não temos nenhuma disponibilidade nessa data, há outro dia que funcione para você?)** e o cartão de resposta (se o cliente oferecer suporte a cartões de resposta).
1. Usuário: dependendo do cliente, o usuário tem duas opções:
+ Se o cartão de resposta for exibido, escolha **2-15 (Wed) (15/2 (quarta))** ou digite **Wednesday**.
+ Se o cliente não oferecer suporte a cartões de resposta, digite **Wednesday**.
1. O cliente envia a seguinte solicitação `PostText` para o Amazon Lex:
```
POST /bot/BookTrip/alias/$LATEST/user/bijt6rovckwecnzesbthrr1d7lv3ja3n/text
"Content-Type":"application/json"
"Content-Encoding":"amz-1.0"
{
"inputText": "Wednesday",
"sessionAttributes": {
}
}
```
**nota**
O cliente Facebook Messenger não define atributos de sessão. Se desejar manter estados de sessão entre as solicitações, você deverá fazer isso na função do Lambda. Em uma aplicação real, talvez você precise manter esses atributos de sessão em banco de dados de back-end.
1. O Amazon Lex invoca a função do Lambda para validação dos dados do usuário enviando o seguinte evento como parâmetro:
```
{
"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 atualizou `currentIntent.slots` definindo o slot `Date` como `2017-02-15`.
1. A função do Lambda valida a entrada do usuário e retorna a seguinte resposta ao Amazon Lex, direcionando-o a escolher o valor para o horário da consulta.
```
{
"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\"]}"
}
}
```
Novamente, a resposta inclui os campos `dialogAction` e `sessionAttributes`. Dentre outras coisas, o `dialogAction` retorna os seguintes campos:
+ campo `dialogAction`:
+ `type`: a função do `Lambda` define esse valor como `ConfirmIntent`, direcionando o Amazon Lex a obter a confirmação do usuário do horário da consulta sugerido na `message`.
+ `responseCard`— Retorna uma lista de yes/no valores para o usuário escolher. Se o cliente for compatível com cartões de resposta, ele exibirá o cartão de resposta, como mostrado no exemplo a seguir:
![\[Cartão de resposta mostrando a confirmação da consulta e duas opções: sim e não.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/respcard-30.png)
+ `sessionAttributes`: a função do Lambda define o atributo de sessão `bookingMap` com o valor definido como a data da consulta e as consultas disponíveis naquela data. Neste exemplo, são consultas de 30 minutos. Para um canal de raiz que leva uma hora, apenas 16h pode ser marcada.
1. Como indicado no `dialogAction.type` na resposta da função do Lambda, o Amazon Lex retorna a seguinte resposta ao cliente:
![\[Resposta JSON mostrando a intenção de marcar uma consulta e todas as vagas preenchidas.\]](http://docs.aws.amazon.com/pt_br/lex/latest/dg/images/appt-40.png)
O cliente exibe a mensagem: **Qual é o melhor horário para você em 15/02/2017? Nossa única disponibilidade é às 16h. Tudo bem para você?**
1. Usuário: selecione **yes**.
Amazon Lex invoca a função do Lambda com os seguintes dados de evento: Como o usuário respondeu **yes**, o Amazon Lex define `confirmationStatus` como `Confirmed` e define o campo `Time` no `currentIntent.slots ` como `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": {
}
}
```
Como o `confirmationStatus` é confirmado, a função do Lambda processa a intenção (marca uma consulta odontológica) e retorna a seguinte resposta ao 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\"]}"
}
}
```
Observe o seguinte:
+ A função do Lambda atualizou o `sessionAttributes`.
+ `dialogAction.type` é definido como `Close`, que direciona Amazon Lex a não esperar uma resposta do usuário.
+ `dialogAction.fulfillmentState` é definido como `Fulfilled`, indicando que a intenção foi cumprida com êxito.
O cliente exibe a mensagem: **Ok, já agendei sua consulta. Nos vemos às 16h do dia 15/02/2017**.