O melhor portal de Marketing e Vendas para a sua empresa
Novo padrão de comunicação, o RCS promete ser uma evolução do SMS e trazer os mesmos recursos de grandes aplicativos como o WhatsApp.
min de leitura
Entre chats, e-mails, redes sociais e WhatsApp, várias foram as soluções tecnológicas criadas a favor de uma comunicação mais rápida e facilitada. E em breve teremos acesso a mais uma opção de canal de comunicação: o RCS.
Aqui você encontrará:
Tal tecnologia teve origem em 2008 com a Associação Mundial das Operadoras Móveis (GSMA) — instituição responsável pela padronização das telecomunicações móveis no mundo — e tinha como objetivo evoluir as funcionalidades do famoso SMS. Porém somente oito anos depois com aporte de gigantes como Samsung, Motorola, Google e Microsoft que ela ganhou mais visibilidade.
Em 2017, a linguagem recebeu novas APIs que, entre outras coisas, permitem a integração do RCS com outros aplicativos.
De acordo com a GSMA, nove são os princípios essenciais para garantir a confiança no RCS e conferir seu lugar como a plataforma de comunicação escolhida:
Trata-se deRich Communication Services ou, em tradução livre, Serviços de Comunicação Rica. Esse formato, bem como WhatsApp irá possibilitar o envio de textos, imagens, GIFs, vídeos, arquivos, áudios, botões interativos e até mesmo carrosséis de produtos. Um dos diferenciais desse padrão é transmissão de mensagens multimídia entre celulares, e para isso os celulares nem mesmo precisam de conexão Wi-fi.
O fato de o RCS oferecer uma Interface de Programação de Aplicativos (API) aberta e gratuita, colabora a integração deste com chatbots, sistemas de atendimento ao cliente, entre outros softwares. Em 2019, a Mobilesquared lançou um relatório que apontava um futuro bem positivo para o RCS:
O padrão RCS vem para trazer importantes funcionalidades e de forma simples. O que para as empresas é uma grande vantagem, já que elas terão mais uma opção de canal de comunicação com clientes.
Ele traz recursos e funções de grandes aplicativos de comunicação, como WhatsApp, Facebook Messenger e Telegram, possibilitando o envio de outros formatos além de mensagens de texto. Tudo isso é feito através do Messages (Google), aplicativo nativo do sistema Android.
A seguir alguns dos recursos do RCS que podem melhorar a experiência do cliente:
Os recursos avançados do RCS possibilitam a criação de experiências memoráveis para os clientes como:
A partir do RCS toda a comunicação de sua empresa pode ser marcada, ou seja, na sua mensagem a identidade da sua marca ficará evidente por meio do nome da mesma, o logotipo e as cores características. Isso torna suas mensagens muito mais atraentes visualmente.
Saber construir e manter um relacionamento com o cliente é fundamental para qualquer empresa. Através de chatbots habilitados para RCS, você utiliza a automação da conversa para oferecer a seus clientes notificações relevantes e captar padrões de comunicação repetitivos. Com bots você pode ter conversas com clientes, em qualquer lugar, a qualquer hora.
A tecnologia do RCS possibilita que você obtenha informações relevantes e detalhadas acerca de seus clientes. Essa análise pode ser feita a partir de mensagens entregues, mensagens visualizadas e acompanhamento de eventos na tela, ou seja, uma visão apurada de como os consumidores estão interagindo com sua marca.
Isso corrobora para campanhas de marketing mais direcionadas e melhora a taxa de conversão ao longo das interações.
Diferentes são os setores que podem aproveitar os benefícios do RCS e solucionar algumas de suas dores. A exemplo disso temos o e-commerce. Uma das métricas que deve ser acompanhada de perto por esse setor é o abandono de carrinhos. Segundo um estudo da E-commerce Radar, em 2017, cerca de 82% dos consumidores brasileiros desistiram de comprar.
Para Robson Ribas, arquiteto de produtos na Zenvia, o RCS é um canal perfeito para impactar o usuário com conteúdo atraente, próximo ao momento de decisão pelos seguintes motivos:
Outros pontos de apoio para empresas
A premissa é fazer com que o RCS seja utilizado de forma nativa em dispositivos móveis, ou seja, um recurso de fábrica de tais aparelhos daqui alguns anos. E o alcance seria significativo. O WhatsApp, aplicativo que já está presente em 99% dos celulares dos brasileiros ainda precisa ser baixado pelos usuários. Mas no caso do RCS, o intuito é que no futuro ele já venha pré-instalado em qualquer aparelho
Nem sempre o texto é suficiente para chamar a atenção de um cliente em potencial. Por isso, o RCS permite outros formatos como imagens e vídeos. O consumidor poderá receber notificações a respeito de novos produtos e serviços de maneira mais atraente e personalizada.
A partir do RCS são desenvolvidos diálogos reais com clientes, o que dá abertura para feedbacks em tempo real ou a solução de um problema de forma rápida e discreta. Outra característica que agrega valor é a possibilidade de criar grupos, o que pode ser muito útil para comunicação interna.
Já que o RCS será uma ferramenta voltado a uma comunicação multicanal, faz sentido falarmos de ações integradas, por exemplo, elaborar um conteúdo a ser divulgado via RCS em vários canais.
Se sua empresa conta com um sistema CRM (Gestão de Relacionamento de Clientes, em tradução livre), uma dica valiosa é abastecer tal sistema com dados provenientes das interações através do RCS Business Messaging.
Os golpes por aplicativos de mensagens aumentaram cerca de 25% durante a pandemia. Entre março e junho deste ano, 50 milhões de mensagens foram disparadas. Destas, 10 milhões a mais do que no mesmo período do ano passado.
Já o relatório Spam and Phishing, produzido pela Kaspersky, o Brasil é o quinto país que mais sofreu com tentativas de phishing no segundo trimestre deste ano. O documento aponta que pelo menos 1 em cada 8 brasileiros sofreu tentativa deste tipo de golpe no período.
O padrão RCS é uma ótima alternativa segundo Ribas, já que dispõe de “Remetente Verificado”, ou seja, confirmação de que a mensagem foi real enviada pela marca.
“Para se tornar um remetente verificado é preciso que a empresa passe por uma análise e concorde com toda a política de segurança e termos de uso do produto do Google”, explica o arquiteto de produtos. Um dos pontos de segurança é o selo de verificação exibido ao lado da marca.
Tal certificação garante a tranquilidade do usuário final. Isso quer dizer que o remetente é confiável e que, portanto, a probabilidade de um caso de phishing ocorrer, como o uso indevido da marca, é menor.
A criptografia também auxilia o usuário contra golpes. Os recursos de bate-papo do Google, por exemplo, usam criptografia Transport Layer Security (TLS) para proteger as mensagens. Isso significa que qualquer pessoa que tente interceptar as mensagens apenas visualizará o texto criptografado e ilegível.
Ribas reforça que “além de contribuir na prevenção de phishing e de ter as mensagens criptografadas, é importante ressaltar o cuidado também dispensado na proteção dos dados, que certifica o correto armazenamento e descarte de informações de acordo com os termos da LGPD”.
A segurança dentro desse novo padrão de comunicação também pode ser vista por meio da autenticação de dois fatores (2FA) e alertas de movimentação suspeita.
Atualmente o RCS do Google está disponível em países como França, México, Espanha, Reino Unido e Estados Unidos. Quanto à implantação no Brasil, Ribas afirma que nosso caso é bem particular. “Para que o usuário receba um RCS, é preciso que a operadora esteja preparada e que tenha um fornecedor de infraestrutura ou cloud associado. Aqui, as quatro operadoras, que respondem por mais de 90% do mercado, já estão habilitadas”. Todas selecionaram o Google como parceiro.
De acordo com o arquiteto de produtos, em alguns países o processo está um pouco mais fragmentado, já que nem todas as operadoras estão prontas ou com parceiros diferentes. Já o cenário brasileiro se apresenta de forma mais favorável para adotar e acelerar o uso comercial de RCS. “
No caso da Zenvia, Ribas conta que são realizadas várias pesquisas a fim de mapear os principais casos de uso desse padrão. Outra medida é trabalhar próximo a clientes, especialmente os de perfil early adopter, para descobrir casos que fazem sentido dentro de diversas verticais, como Varejo, Financeiro, Tecnologia e Saúde.
A chegada do RCS promete revolucionar a comunicação, especialmente no que se refere ao relacionamento com o cliente, porém isso não implica que o SMS, daqui a alguns anos, será substituído por esse novo padrão.
“O SMS seguirá relevante e ainda crescendo em volume de mensagens nos próximos anos, mas o RCS vem para complementar a oferta de canais de comunicação entre marcas e consumidores”, explica Ribas.
Para o arquiteto de produtos, ainda há um longo caminho para que o RCS esteja presente, de fato, em todos os smartphones, assim como ocorre com o SMS. “A tendência é que os recursos de conteúdo rico, aliados à segurança da comunicação e à identificação da marca que está mandando a mensagem, façam do RCS o canal preferido na comunicação entre marcas e consumidores”.
O recurso de RCS permite o desenvolvimento de diversas ideias, já que permite diversas funcionalidades de chat. Assim, a criatividade é limite.
Para a construção do nosso chatbot, vamos utilizar a API da Zenvia de RCS, que permite o envio e o recebimento de mensagens gratuitamente em um ambiente de testes chamado de Sandbox.
O projeto final criado neste tutorial está disponível no nosso repositório do github.
Vamos começar criando uma conta, basta acessar este site, clicar em “CRIAR UMA CONTA” no canto superior direito e preencher os campos.
Após criar a conta, siga o seguinte fluxo: Menu superior > Produtos > Desenvolvedores > Sandbox > Criar novo > Escolha o canal “RCS” > Próximo
Informe o número de celular que irá receber as mensagens da Sandbox e clique em “Enviar Mensagem”. Se seu RCS estiver corretamente configurado, você irá receber uma mensagem de boas vindas e uma palavra-chave, basta respondê-la com esta palavra-chava e seu número estará configurado para o uso no ambiente testes:
Pode ocorrer um erro ao tentar cadastrar o celular na Sandbox, isso significa que você precisa ativar o recurso no celular:
Em caso de erro para criar o canal RCS, é preciso verificar se o RCS está ativado em seu celular e se ele e sua operadora são compatíveis.
Para ativar é preciso ter o APP “Mensagens” do Google, ir nos “3 pontinhos” → Configurações → Recursos de chat.
Se aparecer o seguinte erro, significa que você precisa atualizar o Carrier Services do Google:
Se mesmo atualizando o Carrier Services, significa que seu celular não é compatível.
1- Instale o Node no seu computador (de preferência a versão LTS);
1.1- opcional – Instale o yarn. O node possui um gerenciador de pacotes padrão chamado npm (Node Package Manager), porém existe um gerenciador diferente chamado yarn. No restante deste artigo, haverão as opções de instalação para ambos gerenciadores de pacote como no passo a seguir.
2- Inicie o projeto criando o package.json com o seguinte comando no terminal:
npm init
yarn init3 – Instale o ts-node, ts-node-dev e o typescript como dependências de desenvolvimento:
npm i ts-node ts-node-dev typescript -D
yarn add ts-node ts-node-dev typescript -D3.1 – Instale o arquivo de configuração do typescript:
npx typescript --init4 – Abra o arquivo package.json e insira o script para iniciar o servidor assim como na área grifada em cinza:
{
"name": "zenvia-rcs-chatbot",
"version": "1.0.0",
"description": "This project aims to create an example of creating a chatbot for RCS.",
"main": "index.js",
"scripts": {
"dev": "ts-node-dev index.ts"
},
"author": "Henry Kimura",
"license": "MIT",
"devDependencies": {
"ts-node": "^9.0.0",
"ts-node-dev": "^1.0.0",
"typescript": "^4.0.5"
}
}1 – Instale a dependência request-promise para o Node:
npm i request-promise
yarn add request-promise2 – Após ter configurado seu número de testes com a SandBox anteriormente, ele aparecerá na aba de contatos:
3 – Copie o código de exemplo abaixo e substitua SEU-TOKEN pelo seu token gerado pela plataforma Zenvia, substitua o REMETENTE e o DESTINATÁRIO também:
import { post } from 'request-promise'
post({
uri: 'https://api.zenvia.com/v2/channels/rcs/messages',
headers: {
'X-API-TOKEN': 'SEU_TOKEN',
},
body: {
from: 'REMETENTE',
to: 'DESTINATARIO',
contents: [
{
type: 'text',
text: 'Lembre-se que sua consulta está marcada para às 15:00',
},
],
},
json: true,
})
.then((response) => {
console.log('Response:', response)
})
.catch((error) => {
console.log('Error:', error)
})As informações solicitadas podem ser encontradas nesta tela:
4 – Crie um arquivo index.ts, cole o código copiado anteriormente e salve o arquivo.
5 – Abra o terminal na pasta do projeto e execute o script criado anteriormente no package.json:
npm run dev
yarn dev6 – Se estiver tudo certo, você receberá a mensagem configurada no código:
Até o momento apenas criamos um exemplo para enviar uma mensagem definida. Agora vamos para um exemplo mais divertido onde o usuário manda uma mensagem e recebe uma resposta.
Primeiro vamos precisar configurar um webhook, que é uma forma de recebimento de informações quando um evento acontece. No nosso caso, a API da Zenvia irá enviar um objeto JSON com informações sobre uma mensagem recebida pela API.
1- Vamos começar instalando o express para lidar com o recebimento das requisições e o body-parser para lidar melhor com o manuseio de objetos:
npm i express
npm i @types/express -D
npm i body-parser
yarn add express
yarn add @types/express -D
yarn add body-parser2- Renomeie o arquivo index.ts para sendMessage.ts e crie um novo index.ts com este código:
import express, { Request, Response } from 'express'
import bodyParser from 'body-parser'
// Inicializa o express e define uma porta
const app = express()
const PORT = 3000
// Indica para o express usar o JSON parsing do body-parser
app.use(bodyParser.json())
app.post('/hook', (req: Request, res: Request) => {
const { event } = req.body
const message = event.body.message.contents[0].text // Armazena em uma variável a mensagem
res.status(200).end() // Responde quem solicitou nosso webhook com status 200
})
// Inicia o express na porta definida anteriormente
app.listen(PORT, () => console.log(`Server running on port ${PORT}`))3- Precisamos tornar nosso webhook visível para que a API da Zenvia possa nos enviar as informações da mensagem recebida, para isto vamos utilizar o ngrok. Faça login no site, baixe a versão para Windows, extraia o zip, execute a aplicação (abrirá um terminal), autentique-se digitando ngrok authtoken SEU_TOKEN (seu token está na primeira tela do seu dashboard) e exponha a porta da aplicação (3000) digitando ngrok http 3000
1- Após expor a porta da sua aplicação copie o link que aparecerá no terminal:
2- Vamos utilizar uma plataforma chamada pipedream para receber a informação da Zenvia e enviar ao nosso webhook. O pipedream é uma plataforma de workflow e vamos utilizá-la para fazer o fluxo de receber a informação e enviar para nós. Comece criando sua conta na plataforma. Após isso, siga o caminho https://pipedream.com/workflows > New + > HTTP / Webhook > New Requests (Payload Only) > <Dê algum nome> > Create Source > <Copie o link do seu recurso>:
3- Cole seu link do pipedream no campo “Message Webhook URL” e clique em “Salvar”:
4- Adicione um nó e selecione “Run Node.js code” e ligue seu gatilho:
5- Insira o código abaixo no nó e insira seu URL do ngrok no baseUrl e clique em deploy:
const axios = require('axios')
const api = axios.create({
baseURL: 'SEU URL DO NGROK'
})
const sensitiveCall = await api.post('/hook', {
event
})
6 – Mande uma mensagem de teste pelo Celular e verifique se seu webhook recebeu a informação. O conteúdo da mensagem estará dentro do corpo da requisição, desta forma: req.body.event.body.message.contents[0].text
7 – Agora que estamos recebendo a mensagem, vamos criar um sistema bem simples onde o chatbot recebe um “Oi” e ele responde com um “Olá! Como posso ajudar?“. Para começar, precisamos alterar o arquivo sendMessage.ts. Do jeito que ele está, este arquivo apenas envia uma mensagem específica ao nosso contato, vamos torná-lo em uma função dinâmica e exportável.
Vamos criar uma função exportável para mandar mensagem dinamicamente no sendMessage.ts, onde o parâmetro message da função, terá o conteúdo da mensagem que será enviada ao usuário:
import { post } from 'request-promise'
const sendMessage = (message) => {
post({
uri: 'https://api.zenvia.com/v2/channels/whatsapp/messages',
headers: {
'X-API-TOKEN': 'SEU_TOKEN',
},
body: {
from: 'REMETENTE',
to: 'DESTINATARIO',
contents: [
{
type: 'text',
text: message,
},
],
},
json: true,
})
.then((response) => {
console.log('Response:', response)
})
.catch((error) => {
console.log('Error:', error)
})
}
export default sendMessageAdicione esta linha de importação no index.ts:
import express from 'express'
import bodyParser from 'body-parser'
import sendMessage from './sendMessage'
//...Por fim, vamos alterar a rota /hook no arquivo index.ts
//...
app.post('/hook', (req: Request, res: Response) => {
const { event } = req.body
const message = event.body.message.contents[0].text // Armazena em uma variável a mensagem
if (message.toLowerCase().trim() === 'oi') { // Verifica se a mensagem enviada foi um "Oi"
sendMessage(`Olá! Como posso te ajudar?`)
} else { // Se não, mande a seguinte mensagem
sendMessage('Me desculpe, não entendi.')
}
res.status(200).end() // Responde quem solicitou nosso webhook com status 200
})
//...Nosso chatbot agora está funcionando, podendo receber uma mensagem e respondê-la
Com isso tudo apresentado você já consegue colher e enviar mensagens. A partir daqui a criatividade é o limite para a criação do seu chatbot.
Agora vamos criar um chatbot para ser o seu Assistente Pessoal que consiga guardar informações e lembrar o usuário destas informações em um horário específico, liste todas as informações guardadas e consiga removê-las também.
Agora a nossa aplicação vai ficar um pouco mais complexa e interessante, necessitando de um banco de dados para armazenar informações.
Para fins de aprendizado, vamos utilizar o SQLite pois é muito simples de ser configurado e não precisa ser instalado na sua máquina. Também utilizaremos um query builder chamado Knex.js, onde podemos contruir consultas em javascript e posteriormente podemos alterar o banco de dados que as consultas permanecerão as mesmas,
1 – Instale a dependência do SQLite
npm i sqlite3
yarn add sqlite32 – Instale a dependência o Knex.js
npm install knex --save
yarn add knex3 – Crie o arquivo de configuração knex com o nome knexfile.ts
import path from 'path' // lida com caminhos de arquivos
module.exports = {
client: 'sqlite3',
connection: {
filename: path.resolve(__dirname, 'src', 'database', 'database.sqlite'),
},
migrations: {
directory: path.resolve(__dirname, 'src', 'database', 'migrations'),
},
useNullAsDefault: true,
}4 – Crie uma pasta src, dentro dela cria outra chamada database e crie o arquivo connection.ts
import knex from 'knex'
import path from 'path'
const db = knex({
client: 'sqlite3',
connection: {
filename: path.resolve(__dirname, 'database.sqlite')
},
useNullAsDefault: true,
})
export default db5 – Dentro da pasta database, crie outra chamada migrations e crie o arquivo 00_create_appointments.ts
import Knex from 'knex'
async function up(knex: Knex) {
return knex.schema.createTable('appointments', (table) => {
table.increments('id').primary(),
table.string('description').notNullable(),
table.timestamp('datetime').notNullable()
})
}
async function down(knex: Knex) {
return knex.schema.dropTable('appointments')
}
module.exports = { up, down }5.1 – Em seguida, crie o banco de dados executando:
npx knex --knexfile knexfile.ts migrate:latest 1- Crie o arquivo PastaDoProjeto/src/functions/interpretsMessage.ts com a função que irá interpretar a mensagem recebida e direcionar para demais outras funções:
import sendMessage from './sendMessage'
import createAppointment from './createAppointment'
const interpretsMessage = (message: any) => {
switch (message.toLowerCase().trim()) {
case 'ajuda': // Verifica se a mensagem enviada foi "ajuda"
sendMessage(`
Olá! Digite algum dos comandos para saber mais:\n \t*lembrete*
`)
break
case 'lembrete': // Verifica se a mensagem enviada foi "lembrete"
sendMessage(
`Entendido. Mande uma mensagem com o seguinte formato:\n Me lembre de _____ dia __/__/____ às __:__`
)
break
default: // Se não foi nenhuma das anteriores
if (message.split(' ')[1] === 'lembre') { // Verifica se é para armazenar o compromisso
const description = message.split('Me lembre de ')[1].split(' dia')[0] // Armazena a descrição em uma variável
const date = message.split('dia ')[1].split(' às')[0].split('/') // Armazena a data em uma variável
const time = message.split('às ')[1] // Armazena o horário em uma variável
const when = `${date[2]}-${date[1]}-${date[0]} ${time}` // Junta a data e o horário em uma variável
const appointment = { // Armazena a descrição e quando o deve ser enviado o lembrete do compromisso em um objeto
description,
when,
}
createAppointment(appointment) // Chama a função de criar o compromisso no banco de dados (será criada logo a seguir)
} else {
// Se não, mande a seguinte mensagem
sendMessage(
'Me desculpe, não entendi. Digite *ajuda* para saber todos os comandos.'
)
break
}
}
}
export default interpretsMessage2 – No index.ts importe a função interpretsMessage, remova a importação da função sendMessage e altere a rota /hooks:
import express, { Request, Response } from 'express'
import bodyParser from 'body-parser'
import interpretsMessage from './src/functions/interpretsMessage'
// Inicializa o express e define uma porta
const app = express()
const PORT = 3000
// Indica para o express usar o JSON parsing do body-parser
app.use(bodyParser.json())
app.post('/hook', (req: Request, res: Response) => {
const message = req.body.message.contents[0].text // Armazena em uma variável a mensagem
interpretsMessage(message)
res.status(200).end() // Responde quem solicitou nosso webhook com status 200
})
// Inicia o express na porta definida anteriormente
app.listen(PORT, () => console.log(`Server running on port ${PORT}`))3 – Crie o arquivo PastaDoProjeto/src/functions/createAppointment.ts com a função de criação de um novo lembrete:
import db from '../database/connection' // Importação da conexão com o Banco de Dados
interface Appointment { // Formato do parâmetro appointment
description: string
when: string
}
async function createAppointment(appointment: Appointment) {
const { description, when } = appointment // Coletando as informações do parâmetro
await db('appointments').insert({ // Inserindo no banco de dados o compromisso
description,
when,
})
}
export default createAppointment1- Vamos criar uma função que executa a cada 1 minuto e faz uma consulta ao banco de dados verificando se existe algum compromisso para aquele momento. Instale o node-cron e importe ele no index.ts para criarmos o laço
npm i node-cron
npm i @types/node-cron -D
yarn add node-cron
yarn add @types/node-cron -Dimport express, { Request, Response } from 'express'
import bodyParser from 'body-parser'
import interpretsMessage from './src/functions/interpretsMessage'
import cron from 'node-cron'
// Inicializa o express e define uma porta
const app = express()
const PORT = 3000
// Indica para o express usar o JSON parsing do body-parser
app.use(bodyParser.json())
app.post('/hook', (req: Request, res: Response) => {
const message = req.body.message.contents[0].text // Armazena em uma variável a mensagem
interpretsMessage(message)
res.status(200).end() // Responde quem solicitou nosso webhook com status 200
})
cron.schedule('* * * * *', () => { // Laço que executa a cada 1 minuto
checkAndSendReminder() // Função que será criada a seguir
})
// Inicia o express na porta definida anteriormente
app.listen(PORT, () => console.log(`Server running on port ${PORT}`))2 – Mova o arquivo sendMessage.ts para o diretório PastaDoProjeto/src/functions/
3 – Devemos criar a função que verifica no banco de dados se há um compromisso e mandar um lembrete. Crie o arquivo no seguinte caminho PastaDoProjeto/src/functions/checkAndSendAppointment.ts
import db from '../database/connection' // Importação da conexão com o Banco de Dados
import sendMessage from './sendMessage' // Importação da função de envio de mensagem
const fixZero = (datetime: string) => {
//Função para corrigir 0 no horário
if (datetime.split(':')[0].substr(-2, 1) === ' ') {
return `${datetime.substr(0, 11)}0${datetime.substr(11, 4)}`
} else {
return datetime
}
}
export const checkAndSendReminder = async () => { // Função que verica a existência de compromisso e envia lembrete se houver
// Captura a data e o horário atual
const generatedDatetime = fixZero(new Date().toLocaleString('pt-BR')).substr(0, 16).split(' ')
// Adequa a data para o formato guardado no bando de dados
const datetime = `${generatedDatetime[0].split('/')[2]}-${generatedDatetime[0].split('/')[1]}-${generatedDatetime[0].split('/')[0]} ${generatedDatetime[1]}`
const appointments = await db('appointments').where('datetime', '=', datetime).select('*') // Busca no Banco de Dados se existe um compromisso agora
if (appointments.length !== 0) { // Se houver algum compromisso envia uma mensagem de lembrete
const message = `Lembre-se que você precisa: ${appointments.map(
(appointment) => `\n*${appointment.description}*`
)}`
sendMessage(message)
}
}4 – Vamos criar uma função que remove compromissos do banco de dados. Crie o arquivo PastaDoProjeto/src/functions/removeAppointments.ts com o seguinte código:
import db from '../database/connection' // Importação da conexão do Banco de Dados
import sendMessage from './sendMessage' // Importação da função de envio de mensagem
async function removeAppointments(datetime: string, notificateUser: boolean) {
const removedAppointment = await db('appointments').where('datetime', datetime).del() // Tenta remover do banco de dados os compromissos na data e hora especificadas
if (notificateUser === true && typeof removedAppointment === 'number') { // Caso seja para notificar o usuario
if (removedAppointment === 1) { // Verifica se foi removido apenas um compromisso
sendMessage('Lembrete apagado com sucesso.')
}
if (removedAppointment > 1) { // Verifica se foram removidos diversos compromissos
sendMessage('Lembretes apagados com sucesso.')
}
}
}
export default removeAppointments5 – Para evitar que acumule informações desnecessárias, sempre que o usuário receber o lembrete, vamos apagar o compromisso no banco de dados. Para isto, vamos alterar o arquivo checkAndSendReminder.ts:
import db from '../database/connection' // Importação da conexão com o Banco de Dados
import sendMessage from './sendMessage' // Importação da função de envio de mensagem
import removeAppointments from './removeAppointments' // Importação da função de remoção de compromisso
const fixZero = (datetime: string) => { //Função para corrigir 0 no horário
if (datetime.split(':')[0].substr(-2, 1) === ' ') {
return `${datetime.substr(0, 11)}0${datetime.substr(11, 4)}`
} else {
return datetime
}
}
export const checkAndSendReminder = async () => { // Função que verica a existência de compromisso e envia lembrete se houver
// Captura a data e o horário atual
const generatedDatetime = fixZero(new Date().toLocaleString('pt-BR')).substr(0, 16).split(' ')
// Adequa a data para o formato guardado no bando de dados
const datetime = `${generatedDatetime[0].split('/')[2]}-${generatedDatetime[0].split('/')[1]}-${generatedDatetime[0].split('/')[0]} ${generatedDatetime[1]}`
const appointments = await db('appointments').where('datetime', '=', datetime).select('*') // Busca no Banco de Dados se existe um compromisso agora
if (appointments.length !== 0) { // Se houver algum compromisso envia uma mensagem de lembrete
const message = `Lembre-se que você precisa: ${appointments.map(
(appointment) => `\n*${appointment.description}*`
)}`
sendMessage(message)
removeAppointments(datetime, false) // Remove o compromisso no banco de dados e não notifica o usuário
}
}6 – Vamos agora confirmar ao usuário quando um compromisso for agendado com sucesso. Altere o arquivo createAppointment.ts:
import db from '../database/connection'
import sendMessage from './sendMessage'
interface Appointment {
description: string
datetime: string
}
async function createAppointment(appointment: Appointment) {
const { description, datetime } = appointment
const insertedAppointment = await db('appointments').insert({
description,
datetime,
})
if (typeof insertedAppointment[0] === 'number') {
sendMessage('Compromisso agendado com sucesso.')
}
}
export default createAppointment7- Agora precisamos permitir que o usuário remova compromissos, para isto vamos alterar o arquivo interpretsMessage.ts
import sendMessage from './sendMessage'
import createAppointment from './createAppointment'
import removeAppointments from './removeAppointments'
const interpretsMessage = (message: any) => {
switch (message.toLowerCase().trim()) {
case 'ajuda': // Verifica se a mensagem enviada foi "ajuda"
sendMessage(`
Olá! Digite algum dos comandos para saber mais:\n\t*lembrete*\n\t*esqueça*
`)
break
case 'lembrete': // Verifica se a mensagem enviada foi "lembrete"
sendMessage(
`Entendido. Mande uma mensagem com o seguinte formato:\n Me lembre de _____ dia __/__/____ às __:__`
)
break
case 'esqueça': // Verifica se a mensagem enviada foi "esqueça"
sendMessage(
`Entendido. Mande uma mensagem com o seguinte formato:\n Desmarque tudo no dia __/__/____ às __:__`
)
break
default: // Se não foi nenhuma das anteriores
if (message.split(' ')[1] === 'lembre') { // Verifica se é para armazenar o compromisso
const description = message.split('Me lembre de ')[1].split(' dia')[0] // Armazena a descrição em uma variável
const date = message.split('dia ')[1].split(' às')[0].split('/') // Armazena a data em uma variável
const time = message.split('às ')[1] // Armazena o horário em uma variável
const datetime = `${date[2]}-${date[1]}-${date[0]} ${time}` // Junta a data e o horário em uma variável
const appointment = {
description,
datetime,
}
createAppointment(appointment) // Chama a função de criar o compromisso no banco de dados
} else if (message.substr(0, 9) === 'desmarque') { // Verifica se é para remover o compromisso
const date = message.split('dia ')[1].split(' às')[0].split('/')
const time = message.split('às ')[1]
removeAppointments(`${date[2]}-${date[1]}-${date[0]} ${time}`, true)
} else {
// Se não, mande a seguinte mensagem
sendMessage('Digite *ajuda* para saber todos os comandos.')
break
}
}
}
export default interpretsMessage8 – Teste e veja seu Assistente Pessoal funcionando:
9 – Vamos criar a função que liste todos os compromissos no arquivo indexAppointments.ts:
import db from '../database/connection' // Importação da conexão do Banco de Dados
import sendMessage from './sendMessage' // Importação da função de envio de mensagem
const showDate = (datetime: string) => { // Altera a exibição da data e da hora
const date_time = datetime.split(' ')
const date = date_time[0].split('-')
return `${date[2]}/${date[1]}/${date[0]} às ${date_time[1]}`
}
async function indexAppointments() {
const indexedAppointment = await db('appointments').select('*') // Busca no banco de dados os compromissos na data e hora especificadas
if (indexedAppointment.length !== 0) { // Verifica se encontrou dados
const message = `*Seus compromissos são:*${indexedAppointment.map(
(appointment) => `\n\t${showDate(appointment.datetime)} - ${appointment.description}`
)}`
sendMessage(message) // Manda mensagem com os agendamentos
} else {
sendMessage('Você não possui compromissos marcados.')
}
}
export default indexAppointments10 – Altere mais uma vez o arquivo interpretsMessage.ts para adicionar a função de agenda
import sendMessage from './sendMessage'
import createAppointment from './createAppointment'
import removeAppointments from './removeAppointments'
import indexAppointments from './indexAppointments'
//...
case 'esqueça': // Verifica se a mensagem enviada foi "esqueça"
sendMessage(
`Entendido. Mande uma mensagem com o seguinte formato:\n Desmarque tudo no dia __/__/____ às __:__`
)
break
case 'agenda': // Verifica se a mensagem enviada foi "agenda"
indexAppointments()
break
default:
//...Agora seu Assistente Pessoal está pronto para guardar seus compromissos, te lembrar quando chegar o momento, listar todos os compromissos agendados e remover compromissos em uma determinada hora e data.
Conheça mais o potencial do RCS na página da Zenvia e através do seu curso online clicando aqui.
Leia Também:
