Private SMS-Kommunikation

Manchmal möchten Sie, dass zwei Parteien SMS austauschen, ohne ihre tatsächlichen Telefonnummern preiszugeben.

Wenn Sie zum Beispiel einen Taxibuchungsdienst betreiben, möchten Sie, dass Ihre Kunden und Fahrer miteinander kommunizieren können, um Abholzeiten, Standorte usw. zu koordinieren. Aber Sie wollen nicht, dass Ihr Fahrer die Telefonnummer Ihres Kunden kennt, damit Sie dessen Privatsphäre schützen können. Umgekehrt möchten Sie nicht, dass Ihre Kunden die Nummer des Fahrers kennen und unter Umgehung Ihrer Anwendung direkt Taxidienste buchen können.

In diesem Lernprogramm

Dieses Lernprogramm basiert auf dem Privater SMS-Nutzungsfall. Hier lernen Sie, wie Sie mit Node.js und dem Node Server SDK ein SMS-Proxy-System aufbauen, das eine virtuelle Telefonnummer verwendet, um die echten Nummern der Teilnehmer zu maskieren.

Um die Anwendung zu erstellen, führen Sie die folgenden Schritte durch:

Voraussetzungen

Für die Durchführung dieses Tutorials benötigen Sie

  • A Vonage-Konto - für Ihren API-Schlüssel und Ihr Geheimnis und um virtuelle Numbers zu mieten.
  • A Vonage-Nummer - um die tatsächliche Nummer eines jeden Nutzers zu verbergen. Sie können eine Nummer in der Entwickler-Dashboard.
  • Die Quellcode auf GitHub - Installationsanweisungen sind in der README.
  • Node.js installiert und konfiguriert.
  • ngrok - (optional), um Ihren Entwicklungs-Webserver über das Internet für die Server von Vonage zugänglich zu machen.
  • Alle in den USA ansässigen Kunden müssen eine Marke und eine Kampagne registrieren, um die 10 DLC-Leitlinien.

Erstellen Sie die grundlegende Webanwendung

Diese Anwendung verwendet die Express Rahmen für das Routing und die Node Server SDK zum Senden und Empfangen von SMS. Wir verwenden dotenv so dass wir die Anwendung in einem .env Textdatei.

Unter server.js initialisieren wir die Abhängigkeiten der Anwendung und starten den Webserver. Wir stellen einen Route-Handler für die Homepage der Anwendung (/), so dass Sie testen können, ob der Server läuft, indem Sie 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');
})

Beachten Sie, dass wir ein Objekt des Typs SmsProxy Klasse, um die Weiterleitung von Nachrichten, die an Ihre virtuelle Nummer gesendet werden, an die reale Nummer des Empfängers zu steuern. Wir behandeln den eigentlichen Proxy-Prozess in Bevollmächtigung der SMSaber beachten Sie zunächst, dass diese Klasse die nexmo unter Verwendung des API-Schlüssels und des Geheimnisses, die Sie im nächsten Schritt konfigurieren werden. Dies ermöglicht Ihrer Anwendung das Senden und Empfangen von 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
            });
    }
    ...

Konfigurieren Sie die Anwendung

Kopieren Sie die example.env Datei zur Verfügung gestellt .env und ändern Sie sie so ab, dass sie Ihren Vonage API-Schlüssel und Ihr Geheimnis sowie Ihre Vonage-Nummer enthält. Sie finden diese Informationen in der Datei Entwickler-Dashboard:

VONAGE_API_KEY=YOUR_VONAGE_API_KEY
VONAGE_API_SECRET=YOUR_VONAGE_API_SECRET
VONAGE_NUMBER=YOUR_VONAGE_NUMBER

Einen Chat erstellen

Um die Anwendung zu nutzen, machen Sie eine POST Anfrage an den /chat und übergibt dabei die echten Telefonnummern von zwei Benutzern. (Eine Beispielanforderung finden Sie unter den Chat starten).

Der Routenhandler für /chat ist unten dargestellt:

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');

});

Das Chat-Objekt wird in der Datei createChat() Methode der smsProxy Klasse. Sie speichert die reale Zahl eines jeden Benutzers:

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

    this.sendSMS();
}

Nachdem wir nun einen Chat eingerichtet haben, müssen wir jedem Nutzer mitteilen, wie er den anderen kontaktieren kann.

Vorstellen der Benutzer

Hinweis: In diesem Lernprogramm erhält jeder Nutzer die virtuelle Nummer per SMS. In Produktionssystemen könnte dies über E-Mail, In-App-Benachrichtigungen oder als vordefinierte Nummer erfolgen.

In der sendSMS() Methode der smsProxy Klasse verwenden wir die sendSms() um zwei Nachrichten an die virtuelle Nummer von der realen Nummer jedes Nutzers zu senden.

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');
}

Wir müssen nun diese eingehenden Nachrichten auf der virtuellen Nummer abfangen und sie an die reale Nummer des Empfängers weiterleiten.

Empfangen eingehender SMS

Wenn ein Benutzer eine Nachricht an den anderen sendet, sendet er sie an die virtuelle Nummer der Anwendung und nicht an die reale Nummer des Zielbenutzers. Wenn Vonage eine eingehende SMS an die virtuelle Nummer empfängt, stellt es eine HTTP-Anfrage an den mit dieser Nummer verbundenen Webhook-Endpunkt:

Unter server.jsbieten wir einen Route-Handler für die /webhooks/inbound-sms Anfrage, die die Server von Vonage an Ihre Anwendung stellen, wenn Ihre virtuelle Nummer eine SMS erhält. Wir verwenden eine POST Anfrage hier, aber Sie könnten auch GET oder POST-JSON. Dies ist im Dashboard konfigurierbar, wie unter Ihre Anwendung dem Internet aussetzen.

Wir rufen die from und text Parameter aus der eingehenden Anfrage und übergeben sie an die SmsProxy Klasse, um zu bestimmen, an welche reelle Zahl sie gesendet werden soll:

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);
});

Wir geben eine 204 Status (No content), um den erfolgreichen Empfang der Nachricht zu bestätigen. Dies ist ein wichtiger Schritt, denn wenn wir den Empfang nicht bestätigen, werden die Server von Vonage wiederholt versuchen, die Nachricht zuzustellen.

Festlegen, wie die SMS weitergeleitet werden soll

Da Sie nun die echte Nummer des Benutzers kennen, der die SMS sendet, können Sie die Nachricht an die echte Nummer des anderen Benutzers weiterleiten. Diese Logik ist in der Datei getDestinationRealNumber() Methode der SmsProxy Klasse:

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;
}

Da Sie nun wissen, an welchen Benutzer die Nachricht gesendet werden soll, müssen Sie sie nur noch abschicken!

Vertretung der SMS

Die SMS wird an die echte Telefonnummer des Empfängers weitergeleitet. Die from Nummer ist immer die virtuelle Nummer (um die Anonymität des Nutzers zu wahren), die to ist die tatsächliche Telefonnummer des Benutzers.

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);
}

Probieren Sie es aus

Öffnen Sie Ihre Anwendung für das Internet

Wenn die SMS API eine SMS empfängt, die für Ihre virtuelle Nummer bestimmt ist, benachrichtigt sie Ihre Anwendung über eine Webhook. Der Webhook bietet einen Mechanismus, mit dem die Server von Vonage mit den Ihren kommunizieren können.

Damit Ihre Anwendung für die Server von Vonage zugänglich ist, muss sie im Internet öffentlich zugänglich sein. Eine Möglichkeit, dies während der Entwicklung und des Testens zu erreichen, ist die Verwendung von ngrokein Dienst, der lokale Server über sichere Tunnel dem öffentlichen Internet zugänglich macht. Siehe dieser Blogbeitrag für weitere Einzelheiten.

Herunterladen und installieren ngrokund starten Sie ihn dann mit dem folgenden Befehl:

ngrok http 3000

Dadurch werden öffentliche URLs (HTTP und HTTPS) für jede Website erstellt, die auf Ihrem lokalen Rechner auf Port 3000 läuft.

Verwenden Sie die ngrok Webschnittstelle unter http://localhost:4040 und notieren Sie sich die URLs, die ngrok bietet.

Gehen Sie zu Ihrem Account-Einstellungen und geben Sie die vollständige URL zu Ihrem Webhook-Endpunkt in das Textfeld "Eingehende Nachrichten" ein. Wenn Sie zum Beispiel Folgendes verwenden ngrok dann könnte Ihre URL folgendermaßen aussehen:

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

Stellen Sie sicher, dass Sie POST aus der Dropdown-Liste "HTTP-Methode", damit Vonage weiß, dass Ihre Anwendung erwartet, dass die Nachrichtendetails über eine POST Anfrage.

Start des Chats

Machen Sie eine POST Anfrage an Ihre Anwendung /chat Endpunkt und übergibt die echten Numbers Ihrer Nutzer als Anfrageparameter.

Sie könnten verwenden Postbote für diese oder eine curl Befehl ähnlich dem folgenden, wobei Sie Folgendes ersetzen USERA_REAL_NUMBER und USERB_REAL_NUMBER mit den tatsächlichen Numbers Ihrer Nutzer:

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

Den Chat fortsetzen

Jeder Nutzer sollte einen Text von der virtuellen Nummer der Anwendung erhalten. Wenn ein Nutzer auf diese Nummer antwortet, wird sie an die reale Nummer des anderen Nutzers übermittelt, scheint aber von der virtuellen Nummer zu kommen.

Schlussfolgerung

In diesem Tutorial haben Sie gelernt, wie man einen SMS-Proxy erstellt, der es zwei Benutzern ermöglicht, SMS auszutauschen, ohne dass einer von ihnen die echte Nummer des anderen sieht.

Wie geht es weiter?

Sie können diese Beispielanwendung erweitern, um dieselbe virtuelle Nummer für mehrere Chats zu verwenden, indem Sie SmsProxy.createChat() zu instanziieren und dann eine separate chat Objekt für verschiedene Benutzerpaare. So könnten Sie zum Beispiel ein chat Objekt für userA und userB um sich zu unterhalten und eine andere für userC und userD.

Sie können Routen erstellen, die es Ihnen ermöglichen, alle laufenden Chats zu sehen und auch einen Chat zu beenden, wenn er zu Ende ist.

Die folgenden Ressourcen helfen Ihnen dabei, mehr über das in diesem Lernprogramm Gelernte zu erfahren: