Jak wysyłać SMS-y przez SMPP API za pomocą Javascript/Node.js

Short Message Peer-to-Peer (SMPP) API to szeroko stosowany protokół do wymiany wiadomości SMS między podmiotami SMS. Dla programistów JavaScript/Node.JS pracujących z Ozeki SMS Gateway, ten przewodnik wyjaśnia, jak zaimplementować interakcje z protokołem SMPP za pomocą Node.js, wraz z praktycznymi przykładami zarządzania połączeniami i wysyłania wiadomości.

Konfiguracja klienta SMPP API w JavaScript (Node.js) do wysyłania SMS

Aby wysyłać SMS-y przez SMPP API, najpierw musisz skonfigurować użytkownika SMPP, a następnie powiązać swojego klienta z serwerem SMPP Ozeki SMS Gateway.

Po wykonaniu tych czynności możesz użyć pakietu smpp z npm do obsługi operacji protokołu SMPP:

npm install smpp

Podstawowa konfiguracja połączenia

Oto jak nawiązać połączenie SMPP w Node.js:

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

session.on('connect', () => {
    console.log('Połączono z serwerem SMPP');
    
    session.bind_transceiver({
        system_id: 'your_username',
        password: 'your_password'
    }, (pdu) => {
        if (pdu.command_status === 0) {
            console.log('Pomyślnie powiązano z serwerem SMPP');
        } else {
            console.error('Błąd powiązania:', pdu.command_status);
        }
    });
});

session.on('error', (error) => {
    console.error('Błąd połączenia SMPP:', error);
});

Zarządzanie połączeniami SMPP API w Node.js do wysyłania wiadomości SMS

Połączenia SMPP wymagają wiadomości keep-alive do utrzymania sesji:

// Wysyłaj enquire_link co 30 sekund
const keepAliveInterval = setInterval(() => {
    session.enquire_link({}, (pdu) => {
        if (pdu.command_status !== 0) {
            console.error('Błąd keep-alive:', pdu.command_status);
        }
    });
}, 30000);

// Obsługa zamknięcia sesji
session.on('close', () => {
    clearInterval(keepAliveInterval);
    console.log('Połączenie SMPP zamknięte');
});

Wysyłanie SMS-ów za pomocą JavaScript przez SMPP API (przykład Node.js)

Aby wysłać SMS za pomocą PDU submit_sm:

function sendSMS(from, to, message) {
    session.submit_sm({
        source_addr: from,
        destination_addr: to,
        short_message: message,
        data_coding: 0, // Kodowanie GSM 7-bitowe
        source_addr_ton: 1, // Format międzynarodowy
        source_addr_npi: 1, // Plan numeracji ISDN
        dest_addr_ton: 1,  // Format międzynarodowy
        dest_addr_npi: 1    // Plan numeracji ISDN
    }, (pdu) => {
        if (pdu.command_status === 0) {
            console.log(`Wiadomość wysłana pomyślnie, message_id: ${pdu.message_id}`);
        } else {
            console.error('Błąd wysyłania wiadomości:', pdu.command_status);
        }
    });
}

// Przykład użycia
sendSMS('12345', '+1234567890', 'Witaj z klienta SMPP Node.js!');

Obsługa raportów dostarczenia SMS w JavaScript za pomocą SMPP API

Aby odbierać powiadomienia o dostarczeniu:

session.on('pdu', (pdu) => {
    if (pdu.command === 'deliver_sm') {
        const messageId = pdu.receipted_message_id;
        const status = pdu.message_state;
        
        console.log(`Raport dostarczenia dla ${messageId}: ${status}`);
        
        // Wyślij odpowiedź
        session.deliver_sm_resp({
            sequence_number: pdu.sequence_number
        });
    }
});

Oto kompletna implementacja z obsługą błędów i ponownym łączem:

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('Połączono z serwerem SMPP');
            this.bind();
        });

        this.session.on('error', (error) => {
            console.error('Błąd połączenia:', error);
            this.reconnect();
        });

        this.session.on('close', () => {
            console.log('Połączenie zamknięte');
            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('Pomyślnie połączono z serwerem SMPP');
                this.startKeepAlive();
            } else {
                console.error('Błąd połączenia:', pdu.command_status);
                this.session.close();
            }
        });
    }

    startKeepAlive() {
        this.keepAliveInterval = setInterval(() => {
            this.session.enquire_link({}, (pdu) => {
                if (pdu.command_status !== 0) {
                    console.error('Błąd keep-alive:', 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(`Błąd SMPP: ${pdu.command_status}`));
                }
            });
        });
    }

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

    reconnect() {
        this.cleanup();
        setTimeout(() => {
            console.log('Próba ponownego połączenia...');
            this.connect();
        }, 5000);
    }
}

// Przykład użycia
const client = new SMPPClient({
    host: 'your.ozeki.server',
    port: 2775,
    system_id: 'your_username',
    password: 'your_password'
});

client.sendSMS('12345', '+1234567890', 'Witaj od kompletnego klienta SMPP!')
    .then(messageId => console.log('ID wiadomości:', messageId))
    .catch(err => console.error('Błąd:', err));

Obsługa błędów i najlepsze praktyki

• Zawsze implementuj właściwą obsługę błędów dla problemów z siecią
• Używaj obietnic/async-await dla lepszej kontroli przepływu
• Zaimplementuj kolejkowanie wiadomości dla wysyłania dużych ilości
• Monitoruj stan połączenia i zaimplementuj automatyczne ponowne łączenie
• Prawidłowo obsługuj różne kodowania znaków

Podsumowanie

Ten przewodnik pokazał, jak zaimplementować klienta SMPP w JavaScript/Node.JS do pracy z Ozeki SMS Gateway. Kompletny przykład zawiera zarządzanie połączeniem, wysyłanie wiadomości i obsługę raportów dostawy. Korzystając z pakietu smpp, możesz skupić się na logice aplikacji, podczas gdy biblioteka zajmuje się szczegółami protokołu niskiego poziomu.

Do użytku produkcyjnego rozważ zaimplementowanie dodatkowych funkcji, takich jak kolejkowanie wiadomości, właściwe logowanie i monitorowanie. Protokół SMPP obsługuje wiele zaawansowanych funkcji, takich jak łączenie wiadomości i różne schematy kodowania, które można eksplorować w miarę wzrostu potrzeb.