Cómo enviar SMS a través de la API SMPP usando Javascript/Node.js

El protocolo API SMPP (Short Message Peer-to-Peer) es un protocolo ampliamente adoptado para intercambiar mensajes SMS entre entidades SMS. Para desarrolladores de JavaScript/Node.JS que trabajan con Ozeki SMS Gateway, esta guía explica cómo implementar interacciones del protocolo SMPP usando Node.js, incluyendo ejemplos prácticos para la gestión de conexiones y el envío de mensajes.

Configuración de un cliente SMPP API en JavaScript (Node.js) para enviar SMS

Para enviar SMS a través de la API SMPP, primero debes servidor SMPP de Ozeki SMS Gateway.

Una vez hecho esto, puedes usar el paquete smpp de npm para manejar las operaciones del protocolo SMPP:

npm install smpp

Configuración básica de conexión

Aquí se muestra cómo establecer una conexión SMPP en Node.js:

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

session.on('connect', () => {
    console.log('Conectado al servidor SMPP');
    
    session.bind_transceiver({
        system_id: 'tu_usuario',
        password: 'tu_contraseña'
    }, (pdu) => {
        if (pdu.command_status === 0) {
            console.log('Vinculación exitosa al servidor SMPP');
        } else {
            console.error('Error en la vinculación:', pdu.command_status);
        }
    });
});

session.on('error', (error) => {
    console.error('Error de conexión SMPP:', error);
});

Gestión de conexiones SMPP API en Node.js para mensajería SMS

Las conexiones SMPP requieren mensajes keep-alive para mantener la sesión:

// Enviar enquire_link cada 30 segundos
const keepAliveInterval = setInterval(() => {
    session.enquire_link({}, (pdu) => {
        if (pdu.command_status !== 0) {
            console.error('Error en keep-alive:', pdu.command_status);
        }
    });
}, 30000);

// Manejar cierre de sesión
session.on('close', () => {
    clearInterval(keepAliveInterval);
    console.log('Conexión SMPP cerrada');
});

Envío de SMS con JavaScript a través de la API SMPP (Ejemplo en Node.js)

Para enviar un SMS usando el PDU submit_sm:

function sendSMS(from, to, message) {
    session.submit_sm({
        source_addr: from,
        destination_addr: to,
        short_message: message,
        data_coding: 0, // Codificación GSM 7-bit
        source_addr_ton: 1, // Formato internacional
        source_addr_npi: 1, // Plan de numeración ISDN
        dest_addr_ton: 1,  // Formato internacional
        dest_addr_npi: 1    // Plan de numeración ISDN
    }, (pdu) => {
        if (pdu.command_status === 0) {
            console.log(`Mensaje enviado exitosamente, ID: ${pdu.message_id}`);
        } else {
            console.error('Error en el envío del mensaje:', pdu.command_status);
        }
    });
}

// Ejemplo de uso
sendSMS('12345', '+1234567890', '¡Hola desde el cliente SMPP en Node.js!');

Manejo de informes de entrega de SMS en JavaScript usando la API SMPP

Para recibir notificaciones de entrega:

session.on('pdu', (pdu) => {
    if (pdu.command === 'deliver_sm') {
        const messageId = pdu.receipted_message_id;
        const status = pdu.message_state;
        
        console.log(`Informe de entrega para ${messageId}: ${status}`);
        
        // Enviar respuesta
        session.deliver_sm_resp({
            sequence_number: pdu.sequence_number
        });
    }
});

Implementación completa de un cliente SMPP API en JavaScript (Node.js) para envío de SMS

Aquí hay una implementación completa con manejo de errores y reconexión:

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('Conectado al servidor SMPP');
            this.bind();
        });

        this.session.on('error', (error) => {
            console.error('Error de conexión:', error);
            this.reconnect();
        });

        this.session.on('close', () => {
            console.log('Conexión cerrada');
            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('Vinculación exitosa al servidor SMPP');
                this.startKeepAlive();
            } else {
                console.error('Error en la vinculación:', pdu.command_status);
                this.session.close();
            }
        });
    }

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

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

    reconnect() {
        this.cleanup();
        setTimeout(() => {
            console.log('Intentando reconectar...');
            this.connect();
        }, 5000);
    }
}

// Ejemplo de uso
const client = new SMPPClient({
    host: 'tu.servidor.ozeki',
    port: 2775,
    system_id: 'tu_usuario',
    password: 'tu_contraseña'
});

client.sendSMS('12345', '+1234567890', '¡Hola desde el cliente SMPP completo!')
    .then(messageId => console.log('ID del mensaje:', messageId))
    .catch(err => console.error('Error:', err));

Manejo de errores y mejores prácticas

  • Implementa siempre un manejo adecuado de errores para problemas de red
  • Usa promesas/async-await para un mejor control de flujo
  • Implementa colas de mensajes para envíos de alto volumen
  • Monitorea el estado de la conexión e implementa reconexión automática
  • Maneja correctamente diferentes codificaciones de caracteres

Conclusión

Esta guía ha demostrado cómo implementar un cliente SMPP en JavaScript/Node.JS para trabajar con Ozeki SMS Gateway. El ejemplo completo incluye gestión de conexiones, envío de mensajes y manejo de informes de entrega. Al usar el paquete smpp, puedes centrarte en la lógica de tu aplicación mientras la biblioteca maneja los detalles de bajo nivel del protocolo.

Para uso en producción, considera implementar características adicionales como colas de mensajes, registro adecuado y monitoreo. El protocolo SMPP soporta muchas características avanzadas como concatenación de mensajes y diferentes esquemas de codificación que puedes explorar a medida que tus necesidades crezcan.

More information