Drosselung von Massen-SMS-Kampagnen mit Python und Vonage SMS API

Einführung

Massen-SMS sind sehr nützlich, wenn Marketing-Teams Werbekampagnen durchführen müssen. Unternehmen können sie auch einsetzen, um Informationen an eine große Gruppe von Personen zu übermitteln.

Probleme können auftreten, wenn Sie eine Massen-SMS-Kampagne versenden, die Antworten an eine große Zielgruppe generieren soll. Wenn Sie zum Beispiel Tausende von eingehenden Antworten auf einmal erhalten, könnte Ihr Team überfordert sein. Eine Lösung für dieses Problem ist der Einsatz von Drosselungen. Sie können zum Beispiel eine Kampagne so gestalten, dass die Nachrichten in Stapeln, zu bestimmten Zeiten oder beidem gesendet werden.

In diesem Artikel erfahren Sie, wie Sie die Drosselung von Massen-SMS in Python mithilfe des Django REST-Frameworks und der Vonage Messages API implementieren können. Die Webanwendung, die wir in diesem Tutorial erstellen, ermöglicht es Ihnen, mehreren Benutzern in bestimmten Zeitintervallen Nachrichten in Stapeln zu senden.

Die Vonage Messages API ermöglicht es Entwicklern, SMS-basierte Anwendungen zu entwickeln und Messaging-Funktionen in ihre Apps für SMS, WhatsApp, Messenger usw. zu implementieren. Django ist ein Python-Framework, das für die Entwicklung von Webanwendungen verwendet wird. Django REST-Framework ermöglicht Entwicklern die Erstellung von RESTful APIs mit Django erstellen.

Voraussetzungen

1. Ein kostenloses Vonage API-Konto

2. Eine Vonage-Anwendung. Sie können dieser Anleitung folgen um eine Anwendung in Ihrem Vonage Dashboard zu erstellen.

3. Python (Version 3.6 oder eine neuere). Sie können Python herunterladen von der offiziellen Website.

4. Der Python-Paketmanager pip. Sie finden Anweisungen zur Installation von pip finden Sie hier.

5. Das Python-Werkzeug virtualenv zur Erstellung isolierter virtuellen Umgebungen für Python-Projekte.

Vonage API-Konto

Um dieses Tutorial durchzuführen, benötigen Sie ein Vonage API-Konto. Wenn Sie noch keines haben, können Sie sich noch heute anmelden und mit einem kostenlosen Guthaben beginnen. Sobald Sie ein Konto haben, finden Sie Ihren API-Schlüssel und Ihr API-Geheimnis oben auf dem Vonage-API-Dashboard.

Sind Sie bereit, mit dem Bau zu beginnen?

Erleben Sie nahtlose Konnektivität, Echtzeit-Messaging und kristallklare Sprach- und Videoanrufe - alles auf Knopfdruck.

Einrichtung und Installation

Sie beginnen mit der Einrichtung der Projektabhängigkeiten und der Installation der Module, die Sie mit pip benötigen. Als Nächstes erstellen Sie das Django-Projekt für das Lernprogramm.

Abhängigkeiten installieren

Erstellen Sie zunächst ein neues Verzeichnis und eine virtuelle Umgebung. Aktivieren Sie dann die neu erstellte virtuelle Umgebung:

mkdir test_project && cd test_project
python -m venv env
source env/bin/activate

Mit den obigen Befehlen wurden die folgenden Pakete installiert:

1. Django: das Django-Framework-Paket.

2. djangorestframeworkDas Django REST Framework für die Erstellung von APIs in Django.

3. django-cors-headers: Dies ermöglicht unserer API, herkunftsübergreifende Anfragen an andere Server zu stellen.

4. vonage: das Vonage Python Server SDK.

Ein Django-Projekt erstellen

Verwenden Sie nun das django-admin um ein Django-Projekt zu erstellen, das vonage_project:

django-admin startproject vonage_project

Als nächstes müssen Sie die Django-cors-headers für die Anwendung. Auf diese Weise können andere Ursprünge und Frontend-Applikationen eine Anfrage an Ihre Django-Anwendung stellen. Gehen Sie zum MIDDLEWARE in der Datei settings.py Datei und fügen Sie die folgenden Middleware-Klassen hinzu:

MIDDLEWARE = [
    ...
    'corsheaders.middleware.CorsMiddleware',
    'django.middleware.common.CommonMiddleware',
    ...
]

Als nächstes erstellen Sie eine Django-App namens myapp um unsere Massen-SMS-Funktionalität zu hosten:

cd vonage
django-admin startapp myapp

Erstellen von Bulk-SMS-Funktionen

In diesem Abschnitt werden Sie die Massen-SMS-Funktion mit der Vonage SMS API einrichten. Sie werden auch eine Drosselungsfunktion implementieren.

Initialisieren der Vonage-Bibliothek

Normalerweise müssen Sie die Vonage-Bibliothek initialisieren, um die Vonage-API zum Senden von Nachrichten zu verwenden. Die neue Vonage Messages API befindet sich jedoch noch im Beta-Stadium und Python wird noch nicht unterstützt. Dennoch können wir die Messages API verwenden.

Fügen Sie zunächst den folgenden Code in die views.py Datei hinzu:

import base64

vonageCredentials = 'API_KEY:API_SECRET'
encodedData = vonageCredentials.encode("utf-8")
b64value = b64encode(encodedData).decode("ascii")

Ersetzen Sie im obigen Code die API_KEY und API_SECRET Werte durch die Werte aus Ihrem Vonage-Dashboard. Die Variable vonageCredentials Variable nimmt Ihre Vonage-Anmeldedaten auf: Ihren API-Schlüssel und Ihren geheimen Schlüssel in der Form 'API_KEY: API_SECRET.' Anschließend kodieren und dekodieren Sie die Zeichenfolge mit Ihren Anmeldeinformationen in base64-Form, um sie als ASCII-Standardzeichen zu übergeben.

Erstellen einer Ansicht zum Senden von SMS-Nachrichten

Erstellen Sie nun eine Ansicht für den Versand der SMS-Nachrichten in views.py wie folgt:

from django.views.decorators.csrf import csrf_exempt
from rest_framework.decorators import parser_classes
from rest_framework.parsers import JSONParser
import json
import requests
import base64
import time
from django.http.response import JsonResponse

vonageCredentials = 'API_KEY:API_SECRET'
encodedData = vonageCredentials.encode("utf-8")
b64value = base64.b64encode(encodedData).decode("ascii")

@ csrf_exempt
@ parser_classes(\[JSONParser])
def sendMessage(self, request):
    pass

Im obigen Code haben Sie die csrf_exempt, parser_classes, und JSONParser Klasse importiert, um die Definition von Dekoratoren für die Ansicht zu ermöglichen. Sie importierten auch die json, JsonResponseund andere Module, die Sie in Ihrer Webanwendung benötigen werden. Dann haben Sie die sendMessage Funktion, in die Sie die Logik für das Senden der Nachricht einfügen werden.

Als nächstes fügen Sie Code innerhalb der sendMessage Ansicht, um Anfragen und Benutzereingaben zu akzeptieren. Ändern Sie view.py wie folgt:

def sendMessage(self, request):
    if request.method == 'POST':
        body_unicode = request.body.decode('utf-8')
        body_data = json.loads(body_unicode)

        sender = body_data['sender']
        recipients = body_data['recipients']
        message_string = body_data['message_string']
        batch_size = body_data['batch_size']
        delay_period = body_data['delay_period']

Im obigen Code haben Sie angegeben, dass die Ansicht POST-Anfragen in der Zeile: request.method == 'POST'. Dann haben Sie den Anforderungskörper im JSON-Format dekodiert. Danach haben Sie den Textkörper der Anforderung in die darin enthaltenen Elemente zerlegt. Die Elemente sind die folgenden vom Benutzer erhaltenen Eingaben:

1. senderEine Variable, die die Informationen über den Absender der Nachricht enthält.

2. recipients: eine Liste mit den Telefonnummern der SMS-Empfänger.

3. message_string: den Text, den Sie in der Massen-SMS-Kampagne versenden werden.

4. batch_size: Legt die Anzahl der Empfänger fest, an die eine SMS auf einmal gesendet werden soll.

5. delay_periodZeitspanne zwischen dem Versand von SMS-Batches (gemessen in Sekunden).

Nun erstellen Sie eine Funktion, die die Liste der Telefonnummern der Empfänger in Stapel aufteilt. Fügen Sie den folgenden Code außerhalb der sendMessage Funktion in der Datei views.py Datei ein:

def batch(recipients, batch_size=1):
    for i in range(0, len(recipients), batch_size):
        yield recipients[i:min(i + batch_size, len(recipients))]

Sie definierten eine Funktion namens batch. Sie nimmt zwei Parameter an: die recipients Liste und die batch_size Ganzzahl, die angibt, an wie viele Empfänger Sie eine Nachricht auf einmal senden möchten. Sie verwenden eine for-Schleife und das Schlüsselwort yield, um einen Stapel von Telefonnummern zu erstellen. Wenn dies unklar ist, können Sie mehr über die Bereich und yield Schlüsselwörter lesen.

Nun werden Sie die Logik implementieren, um das Senden von Nachrichten zu ermöglichen. Ändern Sie die sendMessage Ansicht wie unten gezeigt:

@ csrf_exempt
@ parser_classes([JSONParser])
def sendMessage(request):
    if request.method == 'POST':
        body_unicode = request.body.decode('utf-8')
        body_data = json.loads(body_unicode)

        sender = body_data['sender']
        recipients = body_data['recipients']
        message_string = body_data['message_string']
        batch_size = body_data['batch_size']
        delay_period = body_data['delay_period']

        for eachBatch in batch(recipients, batch_size):
            for number in eachBatch:
                response = requests.post('https://api.nexmo.com/v0.1/messages',
                     headers={
                         "Authorization": "Basic %s" % b64value,
                         "Content-type": "application/json",
                         "Accept": "application/json"},
                     json={
                         "to": {
                             "type": "sms",
                             "number": number
                         },
                         "from": {
                             "type": "sms",
                             "number": sender
                         },
                         "message": {
                             "content": {
                                 "type": "text",
                                 "text": message_string
                             }
                         }
                     })
                print("message sent to ", number)
            time.sleep(delay_period)
        try:
            return JsonResponse("OK", status=200, safe=False)

        except Exception as e:
            return JsonResponse({'the error is': str(e)}, status=403)

Es gibt zwei for-Schleifen innerhalb der sendSmsMessage Funktion. Die externe for Anweisung durchläuft die Stapel von Telefonnummern mit Hilfe der batch Funktion, die Sie zuvor in diesem Artikel definiert haben. Sie teilen die Telefonnummern der Empfänger in Stapel auf, indem Sie "batch_size" aus der POST-Anforderung verwenden.

Dann haben Sie eine innere Schleife, die jede Nummer in jedem Stapel nimmt und eine POST-Anforderung an die Vonage Messages API am Endpunkt https://api.nexmo.com/v0.1/messages stellt. Der Header der Anforderung enthält die base64-kodierten Anmeldeinformationen, die Sie zuvor als "b64value" erstellt haben, sowie eine JSON-Nutzlast zur Übermittlung an die Messages API. Die JSON-Nutzdaten enthalten die folgenden Informationen:

• senderEine Variable, die die Informationen über den Absender der Nachricht enthält.

• recipients: eine Liste mit den Telefonnummern der SMS-Empfänger.

• message_string: der Text, der in der Massen-SMS enthalten sein soll.

• batch_size: die Anzahl der Empfänger, an die eine Nachricht auf einmal gesendet werden soll.

• delay_periodZeitspanne zwischen den zu versendenden SMS-Batches.

Nach einer erfolgreichen Anfrage an den Endpunkt der Messages API geht die SMS an den Empfänger, und der Code druckt eine Meldung auf Ihrem Terminal aus, um Sie über die gesendete Nachricht zu informieren. Dann arbeitet Ihr Code an der Versendung des nächsten Stapels.

Nachdem Sie eine Nachricht an alle Empfänger in einem Stapel gesendet haben, wird die übergeordnete for-Schleife nach der Verzögerungszeit ausgeführt, die Sie mit time.sleep(delay_period).

Wenn Sie den Versand der SMS-Nachrichten beendet haben, gibt Ihr Code ein 200 - OK JsonResponse.

Der vollständige views.py Code lautet wie folgt:

from django.views.decorators.csrf import csrf_exempt
from rest_framework.decorators import parser_classes
from rest_framework.parsers import JSONParser
import json
import requests
import base64
import time
from django.http.response import JsonResponse


# Create your views here.
vonageCredentials = 'ba779f8e:fFImpyBSezdXV1Nd'
encodedData = vonageCredentials.encode("utf-8")
b64value = base64.b64encode(encodedData).decode("ascii")
print(b64value)


@ csrf_exempt
@ parser_classes([JSONParser])
def sendMessage(request):
    if request.method == 'POST':
        body_unicode = request.body.decode('utf-8')
        body_data = json.loads(body_unicode)

        sender = body_data['sender']
        recipients = body_data['recipients']
        message_string = body_data['message_string']
        batch_size = body_data['batch_size']
        delay_period = body_data['delay_period']

        for eachBatch in batch(recipients, batch_size):
            for number in eachBatch:
                response = requests.post('https://api.nexmo.com/v0.1/messages',
                     headers={
                         "Authorization": "Basic %s" % b64value,
                         "Content-type": "application/json",
                         "Accept": "application/json"},
                     json={
                         "to": {
                             "type": "sms",
                             "number": number
                         },
                         "from": {
                             "type": "sms",
                             "number": sender
                         },
                         "message": {
                             "content": {
                                 "type": "text",
                                 "text": message_string
                             }
                         }
                     })
                print("message sent to ", number)
            time.sleep(delay_period)
        try:
            return JsonResponse("OK", status=200, safe=False)

        except Exception as e:
            return JsonResponse({'the error is': str(e)}, status=403)


def batch(recipients, batch_size=1):
    for i in range(0, len(recipients), batch_size):
        yield recipients[i:min(i + batch_size, len(recipients))]

Definieren Sie einen URL-Pfad

Da Sie eine Ansicht für den Empfang von Anfragen erstellt haben, benötigen Sie eine entsprechende URL, damit die Benutzer auf die Ansicht zugreifen können, um Anfragen zu stellen. Daher fügen Sie einen Pfad zur urlpatterns innerhalb der urls.py Datei des Projekts. Wechseln Sie in das Unterverzeichnis des Projekts und fügen Sie den folgenden Code hinzu:

from django.urls import path
from myapp.views import sendMessage

urlpatterns = [
   ...
    path('message/', sendMessage),
]

Wie oben gezeigt, haben Sie path und die sendMessage Ansicht. Dann fügten Sie einen Pfad mit der URL message/ in die Liste der urlpatterns.

Testanwendung API

Sie können die oben entwickelte Funktionalität mit dem Postman Werkzeug zur Simulation und Dokumentation von APIs testen. Sie können anmelden für einen kostenlosen Postman Account anmelden.

Um diesen Test durchzuführen, müssen Sie auch den Testserver von Django wie folgt starten:

Python manage.py runserver

Nehmen wir an, Sie beabsichtigen, die folgenden Angaben für Ihre SMS-Massenkampagne zu verwenden.

{
    "sender": "Your Vonage number.",
    "recipients": ["First number to send to.", "Second number to send to"],
    "message_string": "Hello, World!",
    "batch_size": 3,
    "delay_period": 3600
}

Sie können die oben genannten Details in den Körper einer Postman-Anfrage als JSON eingeben, wie in der folgenden Abbildung gezeigt:

Stellen Sie sicher, dass Sie die "recipients" Telefonnummern durch echte Nummern und ersetzen Sie "sender" durch Ihre Vonage-Nummer, bevor Sie die Anfrage senden. Dann werden die Nachrichten Ihren Empfängern zugestellt.

Schlussfolgerung

In diesem Artikel haben Sie eine Massen-SMS-Drosselung mit Vonage in einer Django REST API implementiert. Sie können diese Lösung nun in Ihre Projekte integrieren und weitere Lösungen mit Vonage erstellen. Sie können unseren Authentifizierungsleitfaden lesen, um die Authentifizierung mit Vonage-APIs.