Comunicação privada por SMS

Às vezes, a gente quer que duas pessoas troquem mensagens de texto sem revelar seus números de telefone reais.

Por exemplo, se você opera um serviço de reserva de táxi, deseja que seus clientes e motoristas possam se comunicar para coordenar horários de embarque, locais etc. Mas você não quer que o motorista saiba o número de telefone do cliente, a fim de proteger a privacidade dele. E, por outro lado, você não quer que o cliente saiba o número do motorista e possa reservar serviços de táxi diretamente, contornando seu aplicativo.

Neste tutorial

Este tutorial se baseia no caso de uso de SMS privadas. Ele ensina como criar um sistema de proxy de SMS usando o Node.js e o Node Server SDK, utilizando um número de telefone virtual para ocultar os números reais dos participantes.

Para compilar o aplicativo, siga estas etapas:

Pré-requisitos

Para concluir este tutorial, você precisa de:

  • A Account da Vonage - para obter sua chave e seu segredo da API e para alugar números virtuais.
  • A Número da Vonage - para ocultar o número real de cada usuário. Você pode alugar um número no painel do desenvolvedor.
  • O código-fonte no GitHub — as instruções de instalação estão no README.
  • Node.js instalado e configurado.
  • ngrok - (opcional) para tornar seu servidor web de desenvolvimento acessível aos servidores da Vonage pela Internet.
  • Todos os clientes sediados nos EUA devem registrar uma marca e uma campanha para cumprir as exigências de 10 diretrizes para DLCs.

Criar o aplicativo web básico

Este aplicativo utiliza o Expresso estrutura para o roteamento e o SDK do Node Server para enviar e receber SMS. Nós usamos dotenv para que possamos configurar o aplicativo em um .env arquivo de texto.

Em server.js Inicializamos as dependências do aplicativo e iniciamos o servidor web. Definimos um manipulador de rota para a página inicial do aplicativo (/) para que você possa verificar se o servidor está funcionando acessando http://localhost:3000:

require('dotenv').config();
const express = require('express');
const bodyParser = require('body-parser');
const SmsProxy = require('./SmsProxy');

const app = express();
app.set('port', (process.env.PORT || 3000));
app.use(bodyParser.urlencoded({ extended: false }));

app.listen(app.get('port'), function () {
    console.log('SMS Proxy App listening on port', app.get('port'));
});

const smsProxy = new SmsProxy();

app.get('/', (req, res) => {
    res.send('Hello world');
})

Observe que estamos instanciando um objeto da SmsProxy classe para lidar com o encaminhamento das mensagens enviadas ao seu número virtual para o número real do destinatário. Abordamos o processo de proxy propriamente dito em encaminhar a mensagem SMS, mas, por enquanto, saiba que essa classe inicializa nexmo usando a chave e o segredo da SMS API que você configurará na próxima etapa. Isso permite que seu aplicativo envie e receba SMS:

const Nexmo = require('nexmo');

class SmsProxy {

    constructor() {

        this.nexmo = new Nexmo({
            apiKey: process.env.VONAGE_API_KEY,
            apiSecret: process.env.VONAGE_API_SECRET
        }, {
                debug: true
            });
    }
    ...

Configurar o aplicativo

Copie o example.env arquivo fornecido a .env e modifique-o para incluir sua chave e seu segredo da API da Vonage, além do seu número da Vonage. Você pode encontrar essas informações no painel do desenvolvedor:

VONAGE_API_KEY=YOUR_VONAGE_API_KEY
VONAGE_API_SECRET=YOUR_VONAGE_API_SECRET
VONAGE_NUMBER=YOUR_VONAGE_NUMBER

Criar um chat

Para usar o aplicativo, você faz um POST solicitação à /chat route, passando os números de telefone reais de dois usuários. (Você pode ver um exemplo de solicitação em iniciar o bate-papo).

O manipulador de rota para /chat é mostrado a seguir:

app.post('/chat', (req, res) => {
    const userANumber = req.body.userANumber;
    const userBNumber = req.body.userBNumber;

    smsProxy.createChat(userANumber, userBNumber, (err, result) => {
        if (err) {
            res.status(500).json(err);
        }
        else {
            res.json(result);
        }
    });
    res.send('OK');

});

O objeto de bate-papo é criado no createChat() método do smsProxy classe. Ela armazena o número real de cada usuário:

createChat(userANumber, userBNumber) {
    this.chat = {
        userA: userANumber,
        userB: userBNumber
    };

    this.sendSMS();
}

Agora que criamos um chat, precisamos informar a cada usuário como ele pode entrar em contato com o outro.

Apresente os usuários

Nota: Neste tutorial, cada usuário recebe o número virtual por SMS. Em sistemas de produção, ele poderia ser fornecido por e-mail, por meio de notificações no aplicativo ou como um número predefinido.

No sendSMS() método do smsProxy Na aula, usamos o sendSms() método para enviar duas mensagens para o número virtual a partir do número real de cada usuário.

sendSMS() {
    /*
        Send a message from userA to the virtual number
    */
    this.nexmo.message.sendSms(process.env.VIRTUAL_NUMBER,
                                this.chat.userA,
                                'Reply to this SMS to talk to UserA');

    /*
        Send a message from userB to the virtual number
    */
    this.nexmo.message.sendSms(process.env.VIRTUAL_NUMBER,
                                this.chat.userB,
                                'Reply to this SMS to talk to UserB');
}

Agora precisamos interceptar essas mensagens recebidas no número virtual e redirecioná-las para o número real do destinatário.

Receber SMS recebidas

Quando um usuário envia uma mensagem para outro, ele a envia para o número virtual do aplicativo, em vez do número real do destinatário. Quando a Vonage recebe um SMS de entrada nesse número virtual, ela faz uma solicitação HTTP para o endpoint do webhook associado a esse número:

Em server.js, fornecemos um manipulador de rota para o /webhooks/inbound-sms solicitação que os servidores da Vonage enviam ao seu aplicativo quando seu número virtual recebe um SMS. Estamos usando um POST solicite aqui, mas você também pode usar GET ou POST-JSON. Isso pode ser configurado no painel, conforme descrito em expor seu aplicativo à internet.

Nós recuperamos o from e text parâmetros da solicitação recebida e os repassar para o SmsProxy classe para determinar a qual número real enviá-lo:

app.get('/webhooks/inbound-sms', (req, res) => {
    const from = req.query.msisdn;
    const to = req.query.to;
    const text = req.query.text;

    // Route virtual number to real number
    smsProxy.proxySms(from, text);

    res.sendStatus(204);
});

Nós retornamos um 204 status (No content) para confirmar o recebimento da mensagem. Essa é uma etapa importante, pois, se não confirmarmos o recebimento, os servidores da Vonage farão tentativas repetidas de entregá-la.

Determine como encaminhar o SMS

Agora que você sabe o número real do usuário que enviou o SMS, pode encaminhar a mensagem para o número real do outro usuário. Essa lógica está implementada no getDestinationRealNumber() método do SmsProxy classe:

getDestinationRealNumber(from) {
    let destinationRealNumber = null;

    // Use `from` numbers to work out who is sending to whom
    const fromUserA = (from === this.chat.userA);
    const fromUserB = (from === this.chat.userB);

    if (fromUserA || fromUserB) {
        destinationRealNumber = fromUserA ? this.chat.userB : this.chat.userA;
    }

    return destinationRealNumber;
}

Agora que você já sabe para qual usuário enviar a mensagem, basta enviá-la!

Encaminhar o SMS

Encaminhe a mensagem SMS para o número de telefone real do destinatário pretendido. O from o número é sempre o número virtual (para preservar o anonimato do usuário), o to é o número de telefone real do usuário.

proxySms(from, text) {
    // Determine which real number to send the SMS to
    const destinationRealNumber = this.getDestinationRealNumber(from);

    if (destinationRealNumber  === null) {
        console.log(`No chat found for this number);
        return;
    }

    // Send the SMS from the virtual number to the real number
    this.nexmo.message.sendSms(process.env.VIRTUAL_NUMBER,
                                destinationRealNumber,
                                text);
}

Experimente

Torne seu aplicativo acessível pela Internet

Quando a SMS API recebe uma mensagem de texto destinada ao seu número virtual, ela avisa seu aplicativo por meio de um webhook. O webhook oferece um mecanismo para que os servidores da Vonage se comuniquem com os seus.

Para que seu aplicativo seja acessível aos servidores da Vonage, ele deve estar disponível publicamente na Internet. Uma maneira de fazer isso durante o desenvolvimento e os testes é usar ngrok, um serviço que expõe servidores locais à Internet pública por meio de túneis seguros. Veja esta postagem no blog para mais detalhes.

Baixe e instale ngrok, em seguida, inicie-o com o seguinte comando:

ngrok http 3000

Isso cria URLs públicas (HTTP e HTTPS) para qualquer site que esteja em execução na porta 3000 no seu computador local.

Use o ngrok interface web em http://localhost:4040 e anote os URLs que ngrok prevê.

Acesse o seu configurações da conta página e insira a URL completa do seu endpoint de webhook na caixa de texto “Mensagens recebidas”. Por exemplo, se você estiver usando ngrok nesse caso, sua URL pode ser semelhante à seguinte:

https://33ab96a2.ngrok.io/webhooks/inbound-sms

Certifique-se de selecionar POST na lista suspensa “Método HTTP”, para que a Vonage saiba que seu aplicativo espera que os detalhes da mensagem sejam entregues por meio de um POST solicitação.

Inicie o bate-papo

Faça um POST enviar uma solicitação para o seu aplicativo /chat endpoint, passando os números reais dos seus usuários como parâmetros da solicitação.

Você poderia usar Carteiro para isso, ou um curl um comando semelhante ao seguinte, substituindo USERA_REAL_NUMBER e USERB_REAL_NUMBER com os números reais dos seus usuários:

curl -X POST \ 'http://localhost:3000/chat?userANumber=USERA_REAL_NUMBER&userBNumber=USERB_REAL_NUMBER'

Continuar a conversa

Cada usuário deve receber uma mensagem de texto do número virtual do aplicativo. Quando um usuário responde a esse número, a mensagem é encaminhada para o número real do outro usuário, mas parece ter sido enviada a partir do número virtual.

Conclusão

Neste tutorial, você aprendeu a criar um proxy de SMS para permitir que dois usuários troquem mensagens SMS sem que nenhum deles veja o número real do outro.

E agora, para onde vamos?

Você poderia ampliar este aplicativo de exemplo para usar o mesmo número virtual para hospedar vários chats, utilizando SmsProxy.createChat() para instanciar e, em seguida, persistir um objeto separado chat objeto para diferentes pares de usuários. Assim, por exemplo, você poderia ter um chat objeto para userA e userB para conversar e outro para userC e userD.

Você poderia criar rotas que permitam visualizar todos os chats atuais e também encerrar um chat quando ele terminar.

Os recursos a seguir vão ajudá-lo a saber mais sobre o que você aprendeu neste tutorial: