Wie man SMS über die SMPP API mit Javascript/Node.js sendet

Das Short Message Peer-to-Peer (SMPP) API ist ein weit verbreitetes Protokoll für den Austausch von SMS-Nachrichten zwischen SMS-Entitäten. Für JavaScript/Node.JS-Entwickler, die mit Ozeki SMS Gateway arbeiten, erklärt dieser Leitfaden, wie man SMPP-Protokollinteraktionen mit Node.js implementiert, einschließlich praktischer Beispiele für Verbindungsmanagement und Nachrichtenversand.

Einrichten eines SMPP API Clients in JavaScript (Node.js) für den SMS-Versand

Um SMS über die SMPP API zu senden, müssen Sie zunächst einen SMPP-Benutzer einrichten und dann Ihren Client mit dem SMPP-Server von Ozeki SMS Gateway verbinden.

Sobald dies erledigt ist, können Sie das smpp-Paket von npm verwenden, um SMPP-Protokolloperationen durchzuführen:

npm install smpp

Grundlegende Verbindungseinrichtung

So stellen Sie eine SMPP-Verbindung in Node.js her:

const smpp = require('smpp');
const session = smpp.connect({
    host: 'your.ozeki.server',
    port: 2775
});

session.on('connect', () => {
    console.log('Mit SMPP-Server verbunden');
    
    session.bind_transceiver({
        system_id: 'your_username',
        password: 'your_password'
    }, (pdu) => {
        if (pdu.command_status === 0) {
            console.log('Erfolgreich mit SMPP-Server verbunden');
        } else {
            console.error('Verbindung fehlgeschlagen:', pdu.command_status);
        }
    });
});

session.on('error', (error) => {
    console.error('SMPP-Verbindungsfehler:', error);
});

Verwaltung von SMPP API Verbindungen in Node.js für SMS-Nachrichten

SMPP-Verbindungen erfordern Keep-Alive-Nachrichten, um die Sitzung aufrechtzuerhalten:

// Sende enquire_link alle 30 Sekunden
const keepAliveInterval = setInterval(() => {
    session.enquire_link({}, (pdu) => {
        if (pdu.command_status !== 0) {
            console.error('Keep-Alive fehlgeschlagen:', pdu.command_status);
        }
    });
}, 30000);

// Behandle Sitzungsende
session.on('close', () => {
    clearInterval(keepAliveInterval);
    console.log('SMPP-Verbindung geschlossen');
});

SMS-Versand mit JavaScript über die SMPP API (Node.js Beispiel)

So senden Sie eine SMS mit dem submit_sm PDU:

function sendSMS(from, to, message) {
    session.submit_sm({
        source_addr: from,
        destination_addr: to,
        short_message: message,
        data_coding: 0, // GSM 7-bit Kodierung
        source_addr_ton: 1, // Internationales Format
        source_addr_npi: 1, // ISDN-Nummerierungsplan
        dest_addr_ton: 1,  // Internationales Format
        dest_addr_npi: 1    // ISDN-Nummerierungsplan
    }, (pdu) => {
        if (pdu.command_status === 0) {
            console.log(`Nachricht erfolgreich gesendet, message_id: ${pdu.message_id}`);
        } else {
            console.error('Nachrichtensendung fehlgeschlagen:', pdu.command_status);
        }
    });
}

// Beispielaufruf
sendSMS('12345', '+1234567890', 'Hallo vom Node.js SMPP-Client!');

Handhabung von SMS-Zustellberichten in JavaScript mit der SMPP API

So empfangen Sie Zustellbenachrichtigungen:

session.on('pdu', (pdu) => {
    if (pdu.command === 'deliver_sm') {
        const messageId = pdu.receipted_message_id;
        const status = pdu.message_state;
        
        console.log(`Zustellbericht für ${messageId}: ${status}`);
        
        // Sende Antwort
        session.deliver_sm_resp({
            sequence_number: pdu.sequence_number
        });
    }
});

Vollständige SMPP-API-Client-Implementierung in JavaScript (Node.js) für SMS-Versand

Hier ist eine vollständige Implementierung mit Fehlerbehandlung und Wiederherstellung der Verbindung:

const smpp = require('smpp');

class SMPPClient {
    constructor(config) {
        this.config = config;
        this.session = null;
        this.keepAliveInterval = null;
        this.connect();
    }

    connect() {
        this.session = smpp.connect(this.config);
        
        this.session.on('connect', () => {
            console.log('Mit SMPP-Server verbunden');
            this.bind();
        });

        this.session.on('error', (error) => {
            console.error('Verbindungsfehler:', error);
            this.reconnect();
        });

        this.session.on('close', () => {
            console.log('Verbindung geschlossen');
            this.cleanup();
            this.reconnect();
        });
    }

    bind() {
        this.session.bind_transceiver({
            system_id: this.config.system_id,
            password: this.config.password
        }, (pdu) => {
            if (pdu.command_status === 0) {
                console.log('Erfolgreich an SMPP-Server gebunden');
                this.startKeepAlive();
            } else {
                console.error('Bind fehlgeschlagen:', pdu.command_status);
                this.session.close();
            }
        });
    }

    startKeepAlive() {
        this.keepAliveInterval = setInterval(() => {
            this.session.enquire_link({}, (pdu) => {
                if (pdu.command_status !== 0) {
                    console.error('Keep-alive fehlgeschlagen:', pdu.command_status);
                }
            });
        }, 30000);
    }

    sendSMS(from, to, message) {
        return new Promise((resolve, reject) => {
            this.session.submit_sm({
                source_addr: from,
                destination_addr: to,
                short_message: message,
                data_coding: 0
            }, (pdu) => {
                if (pdu.command_status === 0) {
                    resolve(pdu.message_id);
                } else {
                    reject(new Error(`SMPP-Fehler: ${pdu.command_status}`));
                }
            });
        });
    }

    cleanup() {
        if (this.keepAliveInterval) {
            clearInterval(this.keepAliveInterval);
            this.keepAliveInterval = null;
        }
    }

    reconnect() {
        this.cleanup();
        setTimeout(() => {
            console.log('Versuche erneut zu verbinden...');
            this.connect();
        }, 5000);
    }
}

// Anwendungsbeispiel
const client = new SMPPClient({
    host: 'your.ozeki.server',
    port: 2775,
    system_id: 'your_username',
    password: 'your_password'
});

client.sendSMS('12345', '+1234567890', 'Hallo vom vollständigen SMPP-Client!')
    .then(messageId => console.log('Nachrichten-ID:', messageId))
    .catch(err => console.error('Fehler:', err));

Fehlerbehandlung und Best Practices

  • Implementieren Sie immer eine ordnungsgemäße Fehlerbehandlung für Netzwerkprobleme
  • Verwenden Sie Promises/Async-Await für eine bessere Ablaufsteuerung
  • Implementieren Sie Nachrichten-Warteschlangen für den Versand großer Mengen
  • Überwachen Sie den Verbindungsstatus und implementieren Sie automatische Wiederherstellung
  • Behandeln Sie verschiedene Zeichenkodierungen korrekt

Fazit

Diese Anleitung hat gezeigt, wie ein SMPP-Client in JavaScript/Node.JS implementiert wird, um mit Ozeki SMS Gateway zu arbeiten. Das vollständige Beispiel umfasst Verbindungsmanagement, Nachrichtenversand und Behandlung von Zustellberichten. Durch die Verwendung des smpp-Pakets können Sie sich auf Ihre Anwendungslogik konzentrieren, während die Bibliothek die Low-Level-Protokolldetails behandelt.

Für den Produktionseinsatz sollten Sie zusätzliche Funktionen wie Nachrichten-Warteschlangen, ordnungsgemäße Protokollierung und Überwachung implementieren. Das SMPP-Protokoll unterstützt viele erweiterte Funktionen wie Nachrichtenzusammenführung und verschiedene Kodierungsschemata, die Sie bei Bedarf erkunden können.

More information