Guia de implementação da Verify API Nexmo

Este guia de implementação irá orientá-lo sobre como configurar um servidor para usar a Verify API com seus aplicativos para iOS ou Android.

Não é aconselhável que os desenvolvedores armazenem suas chaves e segredos de API em dispositivos do lado do cliente, como aplicativos para dispositivos Android ou iOS. Portanto, em vez de integrar diretamente a própria Verify API ao seu aplicativo móvel, recomenda-se interagir com a API no seu próprio servidor, sobre o qual você tem controle.

Neste tutorial, você aprenderá a configurar um servidor Node.js que funcionará como um proxy para interagir com a Verify API do Nexmo. Depois de configurar esse servidor proxy de API, você poderá seguir nosso iOS e Android para aprender como se conectar a esse servidor.

Configurando seu servidor

A título de demonstração, criamos um exemplo de servidor que você poderia configurar no Glitch: https://glitch.com/~nexmo-Verify. Você também pode ver o código-fonte no GitHub.

O código-fonte do aplicativo está documentado com comentários, mas abordaremos as partes importantes nas seções a seguir.

Um aplicativo Express simples com Node.js

Este aplicativo Node.js é um simples aplicativo com body-parser para analisar respostas JSON. O aplicativo também usa nexmo-node, o cliente da API REST da Nexmo para Node.js.

Depois de obter sua chave e seu segredo da API, você pode acessar server.js para iniciar o cliente Nexmo:

const Nexmo = require('nexmo');
const nexmo = new Nexmo({
  apiKey: API_KEY,
  apiSecret: API_SECRET
});

Toda a lógica do nosso servidor proxy está no server.js arquivo. Vamos analisá-lo, ponto de conexão por ponto de conexão.

Solicitação de verificação

Para dar início ao processo de Verify, o aplicativo móvel enviará uma POST para o servidor proxy com um corpo JSON de {"number": 14155550100} Não se esqueça de incluir o código do país! O servidor proxy processará a solicitação da seguinte forma:

app.post('/request', (req, res) => {
  // A user registers with a mobile phone number
  let phoneNumber = req.body.number;

  console.log(phoneNumber);

  nexmo.verify.request({number: phoneNumber, brand: 'Awesome Company'}, (err, result) => {
    if(err) {
      console.log(err);

      //Oops! Something went wrong, respond with 500: Server Error
      res.status(500).send(err);
    } else {
      console.log(result);

      if(result && result.status == '0') {
        //A status of 0 means success! Respond with 200: OK
        res.status(200).send(result);
      } else {
        //A status other than 0 means that something is wrong with the request. Respond with 400: Bad Request
        //The rest of the status values can be found here: https://developer.nexmo.com/api/verify#status-values
        res.status(400).send(result);
      }
    }
  });
});

Iniciar o processo de verificação com a nexmo-node biblioteca é simples. Basta incluir o número de telefone do usuário que o aplicativo está verificando e a marca à qual o aplicativo está associado. A marca será usada na mensagem enviada aos usuários que estiverem verificando seus números de telefone. Por exemplo, ao usar a marca “Awesome Company”, os usuários receberão a seguinte mensagem ao verificarem seus números de telefone: “Código da Awesome Company: 8571. Válido por 5 minutos.”

Queremos seguir os paradigmas RESTful; portanto, se ocorrer um erro ao fazer a solicitação, enviaremos de volta um 500 com o erro no corpo da resposta. Se a solicitação for bem-sucedida, responderemos com um 200 e um corpo em JSON que inclua o ID da solicitação e o status da solicitação.

Observação importante: Anote isso request_id , pois você precisará verificar o código de autenticação de duas etapas ou cancelar a solicitação de verificação.

A API retornará um 200 somente se o status da solicitação for 0, o que significa que a solicitação foi bem-sucedida. A resposta a essa solicitação terá a seguinte aparência:

{
  "request_id":"requestId",
  "status":"status",
  "error_text":"error"
}

Se o status for diferente de 0, significa que houve algum problema com nossa solicitação. Portanto, a API responderá com uma 400 e uma resposta que inclua um error_text String.

Verificação de cheques

Depois que um usuário iniciar a solicitação de verificação, ele precisará inserir seu código e verificar o status. O endpoint a seguir permitirá que seus aplicativos clientes façam isso.

app.post('/check', (req, res) => {
  //To verify the phone number the request ID and code are required.
  let code = req.body.code;
  let requestId = req.body.requestId;

  console.log("Code: " + code + " Request ID: " + requestId);

  nexmo.verify.check({request_id: requestId, code: code}, (err, result) => {
    if(err) {
      console.log(err);

      //Oops! Something went wrong, respond with 500: Server Error
      res.status(500).send(err);
    } else {
      console.log(result)

      if(result && result.status == '0') {
        //A status of 0 means success! Respond with 200: OK
        res.status(200).send(result);
        console.log('Account verified!')
      } else {
        //A status other than 0 means that something is wrong with the request. Respond with 400: Bad Request
        //The rest of the status values can be found here: https://developer.nexmo.com/api/verify#status-values
        res.status(400).send(result);
        console.log('Error verifying account')
      }
    }
  });
});

Este endpoint é semelhante ao /request ponto de extremidade que criamos anteriormente. Para esse ponto de extremidade, POST pode ser feita uma chamada para o /check endpoint com um corpo JSON contendo o code e request_id parâmetros da seguinte forma:

{"code": "5309",
"request_id": "aaaaaaaa-bbbb-cccc-dddd-0123456789ab"}

Se o aplicativo móvel do cliente enviar o código correto com o ID da solicitação correspondente, o servidor responderá com um 200 OK e a resposta JSON da Verify API. Se houver algum problema com a solicitação, o servidor responderá com um 400 e uma error_text String. A resposta a uma solicitação de verificação bem-sucedida terá a seguinte aparência:

{
  "request_id": "aaaaaaaafffffffff0000000099999999",
  "status": "0",
  "event_id": "aaaaaaaafffffffff0000000099999999",
  "price": "0.10000000",
  "currency": "EUR"
}

Cancelar verificação

O último endpoint a ser implementado nos permitirá cancelar uma solicitação de verificação. Isso pode ser necessário caso um usuário digite um número de telefone errado ou decida que não deseja mais fazer login no aplicativo.

app.post('/cancel', (req, res) => {
  //User sends the request id to cancel the verification request
  let requestId = req.body.request_id;

  console.log("Request ID: " + requestId);

  nexmo.verify.control({request_id: requestId, cmd:'cancel'}, (err, result) => {
    if(err) {
      console.log(err);

      //Oops! Something went wrong, respond with 500: Server Error
      res.status(500).send(err);
    } else {
      if(result && result.status == '0') {
        //A status of 0 means the verify request was succesfully cancelled! Respond with 200: OK
        res.status(200).send(result);
      } else {
        //A status other than 0 means that something is wrong with the request. Respond with 400: Bad Request
        //The rest of the status values can be found here: https://developer.nexmo.com/api/verify#status-values
        res.status(400).send(result);
      }
    }
  });
});

Assim como antes, o servidor enviará um 200 se tudo estiver certo. Se houver um erro na solicitação feita pelo cliente, o servidor responderá com um 400 e um error_text String. Se ocorrer qualquer outro erro, o servidor responderá com um 500 e um erro no corpo da resposta. Desde que não haja erro, o servidor responderá com este JSON no corpo:

{
  "status":"0",
  "command":"cancel"
}

Colocando em produção

Você pode configurar facilmente este Node.js como uma prova de conceito remixando nosso projeto no Glitch: https://glitch.com/edit/#!/remix/nexmo-Verify. Basta inserir suas próprias chaves e segredos de API no .env arquivo. Em breve, adicionaremos um botão do Heroku e instruções sobre como configurar esse aplicativo como uma função sem servidor Função do Firebase.

Próximos passos

Agora que você configurou seu servidor, pode desenvolver um aplicativo para Android ou iOS para se conectar a ele. Leia os tutoriais a seguir para saber como fazer isso:

• Adicione a autenticação de dois fatores a aplicativos Android com a Verify API da Nexmo

• Adicione a autenticação de dois fatores a aplicativos iOS com Swift e a Verify API da Nexmo

Riscos/Isenção de responsabilidade

Para maior proteção do seu servidor, limite as solicitações ao servidor com base no endereço IP. Limite de Taxa Express é um bom recurso.