@ejfdelgado/ejflab-back 1.1.0

package/srv/PayUSrv.mjs

@@ -0,0 +1,186 @@
+import axios from "axios";
+import geoip from 'geoip-lite';
+import { PayUSrvConstants } from "./PayUSrvConstants.mjs";
+import { SecretsSrv } from "./SecretsSrv.mjs";
+
+/**
+ * It is important to validate the length and numbers of credit cards by franchise, together with the security codes.
+ */
+export class PayUSrv {
+    static DEFAULTS = {
+        "timeout": 60000,//Maximum said by payu
+        "language": PayUSrvConstants.LANGUAGES[0].val,
+        "country": PayUSrvConstants.COUNTRIES[0].val,
+        "currency": PayUSrvConstants.CURRENCIES[0].val,
+        //"keysprefix": "edelgado@panal.co-payu-",
+        "keysprefix": "info@pais.tv+",
+        //"keysprefix": "edgar.jose.fernando.delgado@gmail.com+",
+    };
+    static mode = "dev";
+    static endpoint = PayUSrvConstants.ENDPOINTS[PayUSrv.mode];
+
+    /*
+    [
+        {
+            txt: "AMEX",
+            val: "12"
+        },
+        {
+            txt: "PSE",
+            val: "254"
+        },
+    ]
+    */
+    static async paymentmethods(req, res, next) {
+        const clientIp = req.headers['x-forwarded-for'] || req.socket.remoteAddress;
+        const response = await PayUSrv.getPaymentMethodsLocal(clientIp);
+        res.status(200).json(response.data.paymentMethods).end();
+    }
+    /*
+    [
+        {
+            val: "fd8273ef-2fe8-4598-91d6-f09ecdff42c9",
+            txt: "ALIANZA FIDUCIARIA S A",
+            pseCode: "5016"
+        },
+    ]
+    */
+    static async psebanks(req, res, next) {
+        const clientIp = req.headers['x-forwarded-for'] || req.socket.remoteAddress;
+        const response = await PayUSrv.getPSEBankListLocal(clientIp);
+        res.status(200).json(response.data.banks).end();
+    }
+    static async ping(req, res, next) {
+        const response = await PayUSrv.pingLocal();
+        res.status(200).json(response.data).end();
+    }
+    static async getPSEBankListLocal(clientIp) {
+        const country = PayUSrv.getCurrentCountryFromIp(clientIp);
+        PayUSrv.checkValidCountry(country);
+        const request = {
+            "command": "GET_BANKS_LIST",
+            "bankListInformation": {
+                paymentMethod: "PSE",
+                paymentCountry: country,
+            }
+        };
+        const response = await PayUSrv.generalRequest(request);
+        PayUSrv.checkReponseError(response);
+        const NO_PSE_CODES = ["0"];
+        response.data.banks = response.data.banks.filter((el) => {
+            return NO_PSE_CODES.indexOf(el.pseCode) < 0;
+        }).map((el) => {
+            return { val: el.id, txt: el.description, pseCode: el.pseCode };
+        });
+        return response;
+    }
+    static async pingLocal() {
+        const request = {
+            "command": "PING",
+        };
+        const response = await PayUSrv.generalRequest(request);
+        PayUSrv.checkReponseError(response);
+        return response;
+    }
+    static async getPaymentMethodsLocal(clientIp) {
+        const country = PayUSrv.getCurrentCountryFromIp(clientIp);
+        PayUSrv.checkValidCountry(country);
+        const request = {
+            "command": "GET_PAYMENT_METHODS",
+        };
+        const response = await PayUSrv.generalRequest(request);
+        PayUSrv.checkReponseError(response);
+        // Se debe filtrar por país actual
+        response.data.paymentMethods = response.data.paymentMethods.filter((oneMethod) => {
+            return oneMethod.country == country && oneMethod.enabled;
+        }).map((actual) => {
+            return { txt: actual.description, val: actual.id };
+        });
+
+        return response;
+    }
+    static async generalRequest(extra) {
+        const credentials = await PayUSrv.getCredentials();
+        const request = {
+            "test": PayUSrv.isTest(),
+            "language": PayUSrv.DEFAULTS.language,
+
+            "merchant": {
+                "apiLogin": credentials.payu_api_login,
+                "apiKey": credentials.payu_api_key,
+            }
+        };
+        Object.assign(request, extra);
+        // Call the service...
+        const url = PayUSrv.endpoint.serviceCgi;
+        const options = {
+            timeout: PayUSrv.DEFAULTS.timeout,
+            headers: {
+                'Content-Type': 'application/json; charset=utf-8',
+                'Accept': 'application/json',
+            },
+        };
+        const response = await new Promise((resolve, reject) => {
+            axios.post(url, request, options)
+                .then(res => { resolve(res) })
+                .catch(error => {
+                    if (error.code === 'ECONNABORTED') {
+                        reject(error);
+                    } else {
+                        reject(error);
+                    }
+                });
+        });
+
+        //console.log(response.data);
+        //console.log(`response.status = ${response.status}`);
+        //console.log(`response.statusText = ${response.statusText}`);
+        //console.log(response.headers);
+        //console.log(response.config);
+
+        if ([200].indexOf(response.status) < 0) {
+            throw new Error(response.statusText);
+        }
+
+        return response;
+    }
+    static getCurrentCountryFromIp(clientIp) {
+        clientIp = "186.102.39.136";
+        const detail = geoip.lookup(clientIp);
+        //console.log(`clientIp = ${clientIp} detail.country = ${detail.country}`);
+        if (detail == null) {
+            //throw new Error("No se puede determinar en qué país te encuentras.");
+            return PayUSrv.DEFAULTS.country;
+        } else {
+            // 2 letter ISO-3166-1 country code
+            return detail.country;
+        }
+    }
+    static checkReponseError(response) {
+        if (response.data.code !== "SUCCESS") {
+            if (typeof response.data.error == "string") {
+                throw new Error(response.data.error);
+            }
+        }
+    }
+    static checkValidCountry(country) {
+        if (PayUSrvConstants.VALID_COUNTRIES.indexOf(country) < 0) {
+            throw new Error(`Tu país ${country} no acepta pagos por este medio.`);
+        }
+    }
+    static setMode(mode) {
+        if (["dev", "pro"].indexOf(mode) < 0) {
+            throw Error("Se debe seleccionar un modo dev o pro");
+        }
+        PayUSrv.mode = mode;
+        PayUSrv.endpoint = PayUSrvConstants.ENDPOINTS[PayUSrv.mode];
+    }
+    static async getCredentials() {
+        const respuesta = await SecretsSrv.localRead(["payu_api_login", "payu_api_key"], PayUSrv.DEFAULTS.keysprefix);
+        const mapa = respuesta.mapa;
+        return mapa;
+    }
+    static isTest() {
+        return !(PayUSrv.mode == "pro");
+    }
+}

package/srv/PayUSrvConstants.mjs

@@ -0,0 +1,46 @@
+
+// https://d1ril7hq6s7m5z.cloudfront.net/latam/en/docs/getting-started/response-codes-and-variables.html
+export class PayUSrvConstants {
+    static ENDPOINTS = {
+        // Credenciales de prueba?
+        // https://developers.payulatam.com/latam/es/docs/getting-started/test-your-solution.html
+        "dev": {
+            "serviceCgi": "https://sandbox.api.payulatam.com/payments-api/4.0/service.cgi",
+            "paymentsUrl": "https://sandbox.api.payulatam.com/payments-api/",
+            "reportsUrl": "https://sandbox.api.payulatam.com/reports-api/",
+
+        },
+        "pro": {
+            "serviceCgi": "https://api.payulatam.com/payments-api/4.0/service.cgi",
+            "paymentsUrl": "https://api.payulatam.com/payments-api/",
+            "reportsUrl": "https://api.payulatam.com/reports-api/",
+        }
+    }
+    //https://d1ril7hq6s7m5z.cloudfront.net/latam/en/docs/getting-started/response-codes-and-variables.html#processing-countries
+    static VALID_COUNTRIES = ["AR", "BR", "CL", "CO", "MX", "PA", "PE"];
+    static DOCUMENT_TYPES = [
+        { txt: "Cédula de ciudadanía", val: "CC" },
+        { txt: "Cédula de extrangería", val: "CE" },
+        { txt: "Teléfono móvil", val: "CEL" },
+        { txt: "Nit", val: "NIT" },
+        { txt: "Registro civil", val: "RC" },
+        { txt: "Tarjeta de identidad", val: "TI" },
+    ];
+    static LANGUAGES = [
+        { txt: "Español", val: "es" },
+        { txt: "English", val: "en" },
+        { txt: "Português", val: "pt" },
+    ];
+    static COUNTRIES = [
+        { txt: "Colombia", val: "CO" },
+    ];
+    static CURRENCIES = [
+        { txt: "Peso Colombiano", val: "COP" },
+        { txt: "Dolar Estadounidense", val: "USD" },
+        { txt: "Peso Argentino", val: "ARS" },
+        { txt: "Real Brasilero", val: "BRL" },
+        { txt: "Peso Chileno", val: "CLP" },
+        { txt: "Peso Mexicano", val: "MXN" },
+        { txt: "Sol Peruano", val: "PEN" },
+    ];
+}

package/srv/PostgresSrv.mjs

@@ -0,0 +1,109 @@
+import pg from 'pg'
+import fs from "fs";
+import { MyTemplate } from '@ejfdelgado/ejflab-common/src/MyTemplate.js';
+const { Pool } = pg
+
+
+export class PostgresSrv {
+    static renderer = new MyTemplate();
+    static pool = null;
+    static {
+        PostgresSrv.renderer.registerFunction("noQuotes", PostgresSrv.noQuotes);
+        PostgresSrv.renderer.registerFunction("sanitizeText", PostgresSrv.sanitizeText);
+        const types = pg.types;
+        types.setTypeParser(types.builtins.INT8, function (val) {
+            const bigNumber = BigInt(val);
+            if (bigNumber > Number.MAX_SAFE_INTEGER) {
+                // Fallback...
+                return 0;
+            }
+            return Number(bigNumber);
+        });
+    }
+    static noQuotes(val, ...args) {
+        return val.replace(/'/g, "''");
+    }
+    static sanitizeText(val, ...args) {
+        let text = val;
+        text = PostgresSrv.noQuotes(text);
+        return text;
+    }
+    static getConnectionParams() {
+        const host = process.env.POSTGRES_HOST || "postgres";
+        const port = parseInt(process.env.POSTGRES_PORT || "5432");
+        const database = process.env.POSTGRES_DB || "nogales";
+        const user = process.env.POSTGRES_USER || "user";
+        const password = process.env.POSTGRES_PASSWORD || "pass";
+        return {
+            host,
+            port,
+            database,
+            user,
+            password
+        };
+    }
+
+    static async executeTextInTransaction(sql, model = {}) {
+        const pool = PostgresSrv.getPool();
+        const client = await pool.connect();
+        await client.query('BEGIN')
+        try {
+            // Insert into media
+            const result = await PostgresSrv.executeText(sql, model, client);
+            await client.query('COMMIT');
+            return result;
+        } catch (e) {
+            await client.query('ROLLBACK');
+            throw e
+        } finally {
+            client.release();
+        }
+    }
+
+    static async executeText(sql, model = {}, client = null) {
+        const sqlRendered = PostgresSrv.renderer.render(sql, model);
+        console.log(sqlRendered);
+        let localClient = false;
+        if (!client) {
+            const pool = PostgresSrv.getPool();
+            localClient = true;
+            client = await pool.connect()
+        }
+        const result = await client.query(sqlRendered);
+        if (localClient) {
+            client.release();
+        }
+        return result;
+    }
+
+    static async executeFile(path, model = {}, client = null) {
+        const sql = fs.readFileSync(path, "utf-8");
+        return await PostgresSrv.executeText(sql, model, client);
+    }
+
+    static async executeFileInTransaction(path, model = {}) {
+        const sql = fs.readFileSync(path, "utf-8");
+        return await PostgresSrv.executeTextInTransaction(sql, model);
+    }
+
+    static getPool() {
+        if (PostgresSrv.pool == null) {
+            const params = PostgresSrv.getConnectionParams();
+            PostgresSrv.pool = new Pool({
+                user: params.user,
+                password: params.password,
+                host: params.host,
+                port: params.port,
+                database: params.database,
+            });
+        }
+        return PostgresSrv.pool;
+    }
+
+    static async test(req, res, next) {
+        const model = { other: "other" };
+        const result = await PostgresSrv.executeText("SELECT NOW() as ping", model);
+        const row = result.rows[0];
+        res.status(200).send({ row });
+    }
+}

package/srv/SecretsSrv.mjs

@@ -0,0 +1,126 @@
+import { MyRoutes } from "@ejfdelgado/ejflab-common/src/MyRoutes.js";
+import { ModuloDatoSeguroBack } from "@ejfdelgado/ejflab-common/src/ModuloDatoSeguroBack.mjs";
+import { General } from "./common/General.mjs";
+import { MyStore } from "./common/MyStore.mjs";
+import { Utilidades } from "./common/Utilidades.mjs";
+
+const SECRET_TYPE = "secret";
+
+export class SecretsSrv {
+    static masterName = "dont_use";
+    static masterPub = "key_pub";
+    static masterPri = "key_pri";
+    static async getMasterKey(prefix) {
+        let response = null;
+        const dbData = await MyStore.readById(SECRET_TYPE, prefix + SecretsSrv.masterName);
+        if (dbData == undefined) {
+            // Debe crear una llave, guardarla y retornarla
+            response = ModuloDatoSeguroBack.generateKey(10);
+            await MyStore.createById(SECRET_TYPE, prefix + SecretsSrv.masterName, { val: response });
+        } else {
+            response = dbData.val;
+        }
+        let changed = "";
+        const intermediate = `${process.env.SPAN}`;
+        for (let i = 0; i < response.length; i++) {
+            const car = intermediate[i % intermediate.length];
+            changed += `${response[i]}${car}`;
+        }
+        return changed;
+    }
+    // SecretsSrv.localRead(["llave1", "llave2"], "edelgado@panal.co+");
+    // {mapa: {llave1: "XXXXX", llave2: undefined}, lista: [{key: "llave1", val: "XXXXX"}, undefined]}
+    static async localRead(arg, prefix) {
+        const master = await SecretsSrv.getMasterKey(prefix);
+        const argsPrefix = arg.map(v => prefix + v);
+        const response = await MyStore.readByIds(SECRET_TYPE, argsPrefix);
+        const lista = [];
+        const mapa = {};
+        for (let i = 0; i < argsPrefix.length; i++) {
+            const key = argsPrefix[i];
+            if (key in response) {
+                const payload = response[key];
+                const one = { key: arg[i] };
+                one.val = ModuloDatoSeguroBack.decifrarSimple(payload.val, master);
+                lista.push(one);
+                mapa[one.key] = one.val;
+            } else {
+                lista.push(undefined);
+                mapa[arg[i]] = undefined;
+            }
+        }
+        return {
+            lista,
+            arg,
+            master,
+            mapa,
+        };
+    }
+    // SecretsSrv.localSave({"llave1": "secreto"}, "edelgado@panal.co+");
+    static async localSave(arg, prefix) {
+        const master = await SecretsSrv.getMasterKey(prefix);
+        const keys = Object.keys(arg);
+        const promises = [];
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            let secreto = arg[key];
+            secreto = ModuloDatoSeguroBack.cifrarSimple(secreto, master);
+            promises.push(MyStore.createById(SECRET_TYPE, prefix + key, { val: secreto }));
+        }
+        await Promise.all(promises);
+        return {
+            arg,
+            master
+        };
+    }
+    static generateOldPrefix(req, res) {
+        const elpath = Utilidades.leerRefererPath(req);
+        const partes = MyRoutes.splitPageData(elpath);
+        const token = res.locals.token;
+        return `${token.email}${partes.pageType}/`;
+    }
+    static generatePrefix(req, res) {
+        const token = res.locals.token;
+        return `${token.email}+`;
+    }
+    static async read(req, res, next) {
+        const ans = {};
+        ans.keys = General.readParam(req, "key");
+        const prefix = SecretsSrv.generatePrefix(req, res);
+        const response = await SecretsSrv.localRead(ans.keys, prefix);
+        Object.assign(ans, response);
+        res.status(200).json(ans.lista).end();
+    }
+    static async save(req, res, next) {
+        const ans = {};
+        ans.map = General.readParam(req, "map");
+        const prefix = SecretsSrv.generatePrefix(req, res);
+        const response = await SecretsSrv.localSave(ans.map, prefix);
+        Object.assign(ans, response);
+        res.status(200).json(Object.keys(ans.map).length).end();
+    }
+    static async getPubKey(req, res, next) {
+        const ans = {};
+        const myKeys = [
+            SecretsSrv.masterPub,
+            SecretsSrv.masterPri
+        ];
+        const prefix = SecretsSrv.generatePrefix(req, res);
+        const dbData = await SecretsSrv.localRead(myKeys, prefix);
+        if (dbData[0] == undefined || dbData[1] == undefined) {
+            // Debe crear una llave, guardarla y retornarla
+            const pair = ModuloDatoSeguroBack.generateKeyPair();
+            const myMap = {};
+            myMap[SecretsSrv.masterPub] = pair.public;
+            myMap[SecretsSrv.masterPri] = pair.private;
+            const response = await SecretsSrv.localSave(myMap, prefix);
+            console.log("response=" + JSON.stringify(response));
+        } else {
+            const cipherPub = dbData[myKeys[0]];
+            const cipherPri = dbData[myKeys[1]];
+            console.log("cipherPub=" + JSON.stringify(cipherPub));
+            console.log("cipherPri=" + JSON.stringify(cipherPri));
+        }
+        res.status(200).json(ans).end();
+    }
+}