Comment envoyer des SMS via l'API SMPP en utilisant Javascript/Node.js

L'API SMPP (Short Message Peer-to-Peer) est un protocole largement adopté pour l'échange de messages SMS entre entités SMS. Pour les développeurs JavaScript/Node.JS travaillant avec Ozeki SMS Gateway, ce guide explique comment implémenter les interactions du protocole SMPP en utilisant Node.js, avec des exemples pratiques pour la gestion des connexions et l'envoi de messages.

Configuration d'un client API SMPP en JavaScript (Node.js) pour l'envoi de SMS

Pour envoyer des SMS via l'API SMPP, vous devez d'abord serveur SMPP d'Ozeki SMS Gateway.

Une fois cela fait, vous pouvez utiliser le package smpp de npm pour gérer les opérations du protocole SMPP :

npm install smpp

Configuration de base de la connexion

Voici comment établir une connexion SMPP dans Node.js :

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

session.on('connect', () => {
    console.log('Connecté au serveur SMPP');
    
    session.bind_transceiver({
        system_id: 'your_username',
        password: 'your_password'
    }, (pdu) => {
        if (pdu.command_status === 0) {
            console.log('Connexion au serveur SMPP réussie');
        } else {
            console.error('Échec de la connexion :', pdu.command_status);
        }
    });
});

session.on('error', (error) => {
    console.error('Erreur de connexion SMPP :', error);
});

Gestion des connexions API SMPP dans Node.js pour la messagerie SMS

Les connexions SMPP nécessitent des messages keep-alive pour maintenir la session :

// Envoyer enquire_link toutes les 30 secondes
const keepAliveInterval = setInterval(() => {
    session.enquire_link({}, (pdu) => {
        if (pdu.command_status !== 0) {
            console.error('Échec du keep-alive :', pdu.command_status);
        }
    });
}, 30000);

// Gérer la fermeture de session
session.on('close', () => {
    clearInterval(keepAliveInterval);
    console.log('Connexion SMPP fermée');
});

Envoi de SMS avec JavaScript via l'API SMPP (Exemple Node.js)

Pour envoyer un SMS en utilisant la PDU submit_sm :

function sendSMS(from, to, message) {
    session.submit_sm({
        source_addr: from,
        destination_addr: to,
        short_message: message,
        data_coding: 0, // Encodage GSM 7-bit
        source_addr_ton: 1, // Format international
        source_addr_npi: 1, // Plan de numérotation ISDN
        dest_addr_ton: 1,  // Format international
        dest_addr_npi: 1    // Plan de numérotation ISDN
    }, (pdu) => {
        if (pdu.command_status === 0) {
            console.log(`Message envoyé avec succès, ID du message : ${pdu.message_id}`);
        } else {
            console.error('Échec de l'envoi du message :', pdu.command_status);
        }
    });
}

// Exemple d'utilisation
sendSMS('12345', '+1234567890', 'Bonjour depuis le client SMPP Node.js !');

Gestion des rapports de livraison SMS en JavaScript via l'API SMPP

Pour recevoir les notifications de livraison :

session.on('pdu', (pdu) => {
    if (pdu.command === 'deliver_sm') {
        const messageId = pdu.receipted_message_id;
        const status = pdu.message_state;
        
        console.log(`Rapport de livraison pour ${messageId} : ${status}`);
        
        // Envoyer la réponse
        session.deliver_sm_resp({
            sequence_number: pdu.sequence_number
        });
    }
});

Implémentation complète d'un client API SMPP en JavaScript (Node.js) pour l'envoi de SMS

Voici une implémentation complète avec gestion des erreurs et reconnexion :

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('Connecté au serveur SMPP');
            this.bind();
        });

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

        this.session.on('close', () => {
            console.log('Connexion fermée');
            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('Connexion au serveur SMPP réussie');
                this.startKeepAlive();
            } else {
                console.error('Échec de la connexion :', pdu.command_status);
                this.session.close();
            }
        });
    }

    startKeepAlive() {
        this.keepAliveInterval = setInterval(() => {
            this.session.enquire_link({}, (pdu) => {
                if (pdu.command_status !== 0) {
                    console.error('Échec du 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(`Erreur SMPP : ${pdu.command_status}`));
                }
            });
        });
    }

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

    reconnect() {
        this.cleanup();
        setTimeout(() => {
            console.log('Tentative de reconnexion...');
            this.connect();
        }, 5000);
    }
}

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

client.sendSMS('12345', '+1234567890', 'Bonjour depuis le client SMPP complet !')
    .then(messageId => console.log('ID du message :', messageId))
    .catch(err => console.error('Erreur :', err));

Gestion des erreurs et bonnes pratiques

  • Implémentez toujours une gestion appropriée des erreurs réseau
  • Utilisez les promesses/async-await pour un meilleur contrôle du flux
  • Implémentez une file d'attente de messages pour l'envoi en volume élevé
  • Surveillez l'état de la connexion et implémentez une reconnexion automatique
  • Gérez correctement les différents encodages de caractères

Conclusion

Ce guide a démontré comment implémenter un client SMPP en JavaScript/Node.JS pour travailler avec Ozeki SMS Gateway. L'exemple complet inclut la gestion des connexions, l'envoi de messages et la gestion des rapports de livraison. En utilisant le package smpp, vous pouvez vous concentrer sur la logique de votre application tandis que la bibliothèque gère les détails bas niveau du protocole.

Pour une utilisation en production, envisagez d'implémenter des fonctionnalités supplémentaires comme une file d'attente de messages, un journalisation appropriée et une surveillance. Le protocole SMPP prend en charge de nombreuses fonctionnalités avancées comme la concaténation de messages et différents schémas d'encodage qui peuvent être explorés au fur et à mesure que vos besoins évoluent.

More information