tigogestion

/*
Dirección del servicio:
login
http://tigogestion.tigo.com.co:9020/webservice/Auth.php/?method=login

saldo
http://tigogestion.tigo.com.co:9020/webservice/Bridge.php?method=getBalance

recarga
http://tigogestion.tigo.com.co:9020/webservice/Bridge.php?method=eRechargeSeller

paquete
http://tigogestion.tigo.com.co:9020/webservice/Bridge.php?method=eSellProductSeller

El POST lo encuentra en cada función
*/

var qs = require('querystring');
process.env['NODE_TLS_REJECT_UNAUTHORIZED'] = '0';

var config = {
    server: 'tigogestion.tigo.com.co',
    port: 9020,
    cookie: '',
    conn_mode: 'https',
    name: 'Movilbox'
};

module.exports = Movilbox;

function Movilbox(account) {
    this.account = account;
    this.connected = false;
    this.name = account.conn_name;
    this.enabled = true;
    this.last_balance_value = 0;
    this.txt_state = 'Desconectado';
    var self = this;

    this.last_balance = function last_balance() {
        return this.last_balance_value;
    };

    this.last_balance_label = function last_balance_label() {
        return this.last_balance_value;
    };

    this.login = function login(cb) {
        try {
            var sha1 = require('sha1');
            g('/webservice/Auth.php/?method=login', {
                method: 'POST',
                post: {
                    usr: self.account.prov_user,
                    pwd: sha1(self.account.prov_pass),
                    ipadress: '0.0.0.0',
                    latitude: 'undefined',
                    longitude: 'undefined',
                    '?callback': '?'
                }
            }, function (res_data, response, error) {
                try {
                    if (error) {
                        console.error(error);
                        cb(false);
                        return;
                    }
                    var buf = new Buffer(res_data, 'base64');
                    var token = '';
                    token += buf;
                    var re = /({.*})/;
                    var m;

                    if ((m = re.exec(token)) !== null) {
                        if (m.index === re.lastIndex) {
                            re.lastIndex++;
                        }
                        self.token_auth = JSON.parse(m[1]);
                    }
                    if (self.token_auth.responseCode === "E") {
                        self.print("No se pudo iniciar sesion: %s", self.token_auth.errorMessage);
                        self.txt_state = self.token_auth.errorMessage;
                        cb(false);
                        return;
                    } else {
                        self.token = res_data;
                        self.connected = true;
                        self.txt_state = 'Conectado';
                        cb(true);
                        return;
                    }
                } catch (err) {
                    console.error(err.stack);
                    cb(false);
                    return;
                }
            });
        } catch (err) {
            console.error(err.stack);
            cb(false);
            return;
        }
    };

    this.get_balance = function get_balance(callback, args) {
        try {
            if (self.connected === false) {
                callback(0, args);
                return;
            }
            g('/webservice/Bridge.php?method=getBalance', {
                method: 'POST',
                content_type: 'application/json',
                post: {
                    msisdn: self.token_auth.msisdn,
                    dealer: self.token_auth.dealer
                }, headers: {
                    'Referer': 'https://tigogestion.tigo.com.co:9020/app/components/pdv/pdvView.html',
                    'token': self.token
                }
            }, function (res_data, response, error) {
                if (error) {
                    callback(-1, args);
                    return;
                }
                try {
                    var json_res = JSON.parse(res_data);
                    if (json_res.responseCode === "S") {
                        self.last_balance_value = json_res.balancePartition39;
                        callback(json_res.balancePartition39, args);
                    } else {
                        self.print("No se pudo consultar el saldo: %s", json_res.errorMessage);
                        callback(-1, args);
                    }
                    return;
                } catch (err) {
                    self.print("NO se pudo consultar el saldo por exception: respuesta: %s", res_data);
                    callback(-1, args);
                    return;
                }
            });
        } catch (e) {
            console.error(e.stack);
        }
    };

    this.recharge = function (number, operator, amount, callback, payload) {
        try {
            self.print("Solicitud de recarga [%s][%s]", number, amount);
            if (self.connected === false) {
                callback({
                    result: 'error',
                    error: 99,
                    error_description: 'la plataforma no está conectada con movilbox',
                    number: number,
                    operator: operator,
                    amount: amount
                }, payload);
                return;
            }

            if (operator !== 'tigo') {
                callback({
                    result: 'error',
                    error: 98,
                    error_description: 'el operador no es TIGO',
                    number: number,
                    operator: operator,
                    amount: amount
                }, payload);
                return;
            }

            g('/webservice/Bridge.php?method=eRechargeSeller', {
                method: 'POST',
                content_type: 'application/json',
                post: {
                    msisdn: number,
                    amount: amount
                }, headers: {
                    'Referer': 'https://tigogestion.tigo.com.co:9020/app/components/pdv/pdvView.html',
                    'token': self.token
                }
            }, function (res_data, response, error) {
                if (error) {
                    callback({
                        result: 'error',
                        error: error.message,
                        error_description: error.message,
                        number: number,
                        operator: operator,
                        amount: amount
                    }, payload);
                    return;
                }
                try {
                    var json_res = JSON.parse(res_data);
                    if (json_res.responseCode === "S") {
                        self.print("la recarga se ha realizado con éxito: [%s][%s][%s]",
                            number, amount, json_res.transactionID);
                        callback({
                            result: 'success',
                            recharge_id: json_res.transactionID,
                            number: number,
                            operator: operator,
                            amount: amount
                        }, payload);
                        return;
                    } else {

                        self.print("ocurrió un error enviando la recarga: [%s][%s][%s]",
                            number, operator, json_res.errorMessage);
                        callback({
                            result: 'error',
                            error: json_res.messageCode,
                            error_description: json_res.errorMessage,
                            number: number,
                            operator: operator,
                            amount: amount
                        }, payload);
                        return;
                    }
                } catch (err) {
                    console.error(err.stack);
                    callback({
                        result: 'error',
                        error: '006',
                        error_description: error.message,
                        number: number,
                        operator: operator,
                        amount: amount
                    }, payload);
                    return;
                }
            });
        } catch (e) {
            console.log("Got error: " + e.stack);
            callback({
                result: 'error',
                error: '007',
                error_description: e.message,
                number: number,
                operator: operator,
                amount: amount
            }, payload);
            return;
        }
    };

    this.recharge_package = function (number, operator, package_obj, callback, payload) {
        try {
            self.print("Solicitud de recarga paquete: [%s][%s]", number, package_obj.id);
            if (self.connected === false) {
                callback({
                    result: 'error',
                    error: '000',
                    error_description: 'la plataforma no está conectada con movilbox',
                    number: number,
                    operator: operator,
                    amount: package_obj.valor_venta,
                    package: package_obj
                }, payload);
                return;
            }

            if (operator !== 'tigo') {
                callback({
                    result: 'error',
                    error: '001',
                    error_description: 'el operador no es tigo',
                    number: number,
                    operator: operator,
                    amount: package_obj.valor_venta,
                    package: package_obj
                }, payload);
                return;
            }
            g('/webservice/Bridge.php?method=eSellProductSeller', {
                method: 'POST',
                content_type: 'application/json',
                post: {
                    msisdn: number,
                    resourceId: package_obj.id
                }, headers: {
                    'Referer': 'https://tigogestion.tigo.com.co:9020/app/components/pdv/pdvView.html',
                    'token': self.token
                }
            }, function (res_data, response, error) {
                if (error) {
                    callback({
                        result: 'error',
                        error: '002',
                        error_description: error.message,
                        number: number,
                        operator: operator,
                        amount: package_obj.valor_venta,
                        package: package_obj
                    }, payload);
                    return;
                }
                try {
                    var json_res = JSON.parse(res_data);
                    if (json_res.responseCode === "S") {
                        self.print("la recarga se ha realizado con éxito: [%s][%s][%s]",
                            number, package_obj.id, json_res.transactionID);
                        callback({
                            result: 'success',
                            recharge_id: json_res.transactionID,
                            number: number,
                            operator: operator,
                            amount: package_obj.valor_venta,
                            package: package_obj
                        }, payload);
                        return;
                    } else {
                        self.print("ocurrió un error enviando la recarga: [%s][%s][%s]",
                            number, package_obj.id, json_res.errorMessage);
                        callback({
                            result: 'error',
                            error: json_res.messageCode,
                            error_description: json_res.errorMessage,
                            number: number,
                            operator: operator,
                            amount: package_obj.valor_venta,
                            package: package_obj
                        }, payload);
                        return;
                    }
                } catch (err) {
                    console.log("datos recibidos: " + res_data);
                    console.error(err.stack);
                    callback({
                        result: 'success',
                        recharge_id: $.create_id(),
                        number: number,
                        operator: operator,
                        amount: package_obj.valor_venta,
                        package: package_obj
                    }, payload);
                    return;
                }
            });
        } catch (e) {
            console.log("Got error: " + e.stack);
            callback({
                result: 'error',
                error: '004',
                error_description: e.message,
                number: number,
                operator: operator,
                amount: package_obj.valor_venta,
                package: package_obj
            }, payload);
            return;
        }
    };

    this.start = function start(callback) {
        self.print("iniciando conexión: [%s][%s]", account.prov_user, account.prov_pass);
        self.login(function (login) {
            if (login) {
                self.get_balance(function (balance) {
                    self.print("Se ha reiniciado la conexión. user: [%s] pass: [%s] saldo: [%s]",
                        account.prov_user, account.prov_pass, balance);
                    if (callback) {
                        callback();
                    }
                });
            } else {
                self.print("No se pudo iniciar la conexión: user: [%s] pass: [%s]",
                    account.prov_user, account.prov_pass);
            }
        });
    };

    this.print = function print() {
        try {
            var argumentsArray = Array.prototype.slice.apply(arguments);
            var message = argumentsArray[0];
            argumentsArray.splice(0, 1);
            for (var index in argumentsArray) {
                message = message.replace('%s', argumentsArray[index])
            }
            console.log("[%s][%s] %s", config.name, account.conn_name, message)
        } catch (e) {
        }
    };

    function g(path, options, callback) {
        try {
            var http = require(config.conn_mode);

            var opts = {
                host: config.server,
                method: (typeof options.method === 'undefined' ? 'GET' : options.method),
                port: config.port,
                path: path,
                timeout: 10000,
                headers: {
                    'Connection': 'close',
                    'Host': config.server
                }
            };
            if (self.token) {
                opts.headers.token = self.token;
            }

            var post = '';
            if (opts.method === 'POST') {
                opts.headers['Content-Type'] = 'text/html;charset=UTF-8';
                opts.headers['Content-Length'] = 0;
                if (typeof options.post !== 'undefined') {
                    if (typeof options.content_type === 'undefined' || options.content_type.indexOf('json') === -1) {
                        opts.headers['Content-Type'] = 'application/x-www-form-urlencoded';
                        post = qs.stringify(options.post);
                    } else if (options.content_type.indexOf('json') >= 0) {
                        opts.headers['Content-Type'] = 'application/json;charset=UTF-8';
                        post = JSON.stringify(options.post);
                    }

                    opts.headers['Content-Length'] = Buffer.byteLength(post);
                }
            }

            if (typeof options.headers !== 'undefined') {
                for (var key in options.headers) {
                    opts.headers[key] = options.headers[key];
                }
            }

            var res_data = '';
            var req = http.request(opts, function (response) {
                response.setEncoding('utf8');
                response.on('data', function (chunk) {
                    res_data += chunk;
                });
                response.on('end', function () {
                    callback(res_data, response, false);
                });
            });

            req.on('error', function (e) {
                self.print("[g] " + path + "  Got error on connection: " + e.message);
                callback(false, false, e);
            });
            if (opts.method !== 'GET') {
                req.write(post);
            }
            req.setTimeout(120000);
            req.end();
        } catch (e) {
            self.print("[g] " + path + "  Got error on application: " + e.message);
            callback(false, false, e);
        }
    }

    this.start(function () {
    });

    this.interval = setInterval(function () {
        self.login(function (data) {
            self.print("se ha reiniciado la conexión. conectado: [%s]", data ? 'SI' : 'NO');
        });

    }, 600000);

    this.end = function end() {
        clearInterval(self.interval);
    };
}