@ejfdelgado/ejflab-common 1.0.0

package/src/CsvFormatterFilters.js

@@ -0,0 +1,79 @@
+class CsvFormatterFilters {
+    static randomMemory = {};
+    static formatRandomMemory() {
+        console.log("Formating random memory");
+        CsvFormatterFilters.randomMemory = {};
+    }
+    static parseInt(valor, myDefault = NaN) {
+        const temp = parseInt(valor);
+        if (isNaN(temp)) {
+            return myDefault;
+        } else {
+            return temp;
+        }
+    }
+    static parseFloat(valor, myDefault = NaN) {
+        const temp = parseFloat(valor);
+        if (isNaN(temp)) {
+            return myDefault;
+        } else {
+            return temp;
+        }
+    }
+    static json(valor) {
+        return JSON.stringify(valor);
+    }
+    static rand(val, ...args) {
+        let listaBase = args;
+        if (!(listaBase instanceof Array)) {
+            return "";
+        }
+        const keyMemory = val;
+        let lista = CsvFormatterFilters.randomMemory[keyMemory];
+        if (!(lista instanceof Array) || lista.length == 0) {
+            lista = [...listaBase];
+            CsvFormatterFilters.randomMemory[keyMemory] = lista;
+        }
+        const random = Math.random();
+        //console.log(`random = ${random}`);
+        const myRandom = Math.floor(random * lista.length);
+        let choosed = "" + lista[myRandom];
+        // Se saca de la lista
+        lista.splice(myRandom, 1);
+        if (/^\s*true\s*$/i.exec(choosed) !== null) {
+            choosed = true;
+        } else if (/^\s*false\s*$/i.exec(choosed) !== null) {
+            choosed = false;
+        } else if (/^\s*\d+\s*$/.exec(choosed) !== null) {
+            choosed = parseInt(choosed);
+        }
+        return choosed;
+    }
+    static testRandom() {
+        const lista = ["a", "b"];
+        for (let i = 0; i < 10; i++) {
+            console.log(CsvFormatterFilters.rand(lista));
+        }
+    }
+    static map(myMap) {
+        return (key) => {
+            return myMap[key];
+        }
+    }
+    static noNewLine(valor, replacer = "") {
+        if (typeof valor == "string") {
+            return valor.replace(/(?:\r\n|\r|\n)/g, replacer);
+        }
+        return valor;
+    }
+    static replace(valor, pattern, replacer = "") {
+        if (typeof valor == "string") {
+            return valor.replace(pattern, replacer);
+        }
+        return valor;
+    }
+}
+
+module.exports = {
+    CsvFormatterFilters
+}

package/src/CsvParser.js

@@ -0,0 +1,51 @@
+const { CsvWithFilters } = require("./CsvWithFilters");
+const { SimpleObj } = require("./SimpleObj");
+
+class CsvParser extends CsvWithFilters {
+    constructor() {
+        super();
+        this.sep = ";";
+    }
+    setSeparator(val) {
+        this.sep = val;
+    }
+    parse(txt, header = null, skipFirstLine = false, defaultValue = null) {
+        const SEPARATOR = new RegExp(`${this.sep}`, "g");
+        const filas = txt.split(/(?:\r\n|\r|\n)/);
+        let myHeader;
+        if (typeof header == "string") {
+            myHeader = header;
+            if (skipFirstLine) {
+                filas.splice(0, 1);
+            }
+        } else {
+            // asume first line is header
+            myHeader = filas.splice(0, 1)[0];
+        }
+        // Deduce columns
+        const columnDesc = super.getColumnDescription(myHeader, this.sep);
+        const resultado = [];
+        for (let i = 0; i < filas.length; i++) {
+            const fila = filas[i];
+            const values = fila.split(SEPARATOR);
+            let actual = {};
+            for (let j = 0; j < columnDesc.length; j++) {
+                const desc = columnDesc[j];
+                if (j < values.length) {
+                    let value = values[j];
+                    value = super.filterValue(value, desc);
+                    actual = SimpleObj.recreate(actual, desc.id, value);
+                } else {
+                    actual = SimpleObj.recreate(actual, desc.id, defaultValue);
+                }
+
+            }
+            resultado.push(actual);
+        }
+        return resultado;
+    }
+}
+
+module.exports = {
+    CsvParser
+}

package/src/CsvParser.test.js

@@ -0,0 +1,41 @@
+const fs = require('fs');
+const { CsvParser } = require("./CsvParser");
+const sortify = require("./sortify");
+
+const myTest = () => {
+    const cases = [
+        { csv: "./data/case0.csv", json: "./data/case0.json", header: null, skipFirstLine: false },
+        { csv: "./data/case1.csv", json: "./data/case1.json", header: "name;friends.0.name;friends.1.name;", skipFirstLine: false },
+        { csv: "./data/case2.csv", json: "./data/case2.json", header: "name;friends.0.name;friends.1.name;", skipFirstLine: true },
+        { csv: "./data/case3.csv", json: "./data/case3.json", header: "name;friends.0.name;friends.1.name|emptyStringIsNull;", skipFirstLine: true },
+    ];
+
+    const parser = new CsvParser();
+
+    parser.registerFunction("emptyStringIsNull", (val) => {
+        if (typeof val == "string" && val.trim().length == 0) {
+            return null;
+        }
+        return val;
+    });
+
+    for (let i = 0; i < cases.length; i++) {
+        const myCase = cases[i];
+        const {
+            csv, json
+        } = myCase;
+        const dataCsv = fs.readFileSync(csv, { encoding: "utf8" });
+        const dataJson = JSON.parse(fs.readFileSync(json, { encoding: "utf8" }));
+
+        const response = parser.parse(dataCsv, myCase.header, myCase.skipFirstLine);
+        const myExpected = sortify(dataJson);
+        const actual = sortify(response);
+        if (actual !== myExpected) {
+            throw Error(`expected:\n${myExpected}\nactual:\n${actual}`);
+        } else {
+            console.log(`case ${i + 1} OK!`);
+        }
+    }
+};
+
+myTest();

package/src/CsvWithFilters.js

@@ -0,0 +1,114 @@
+
+class CsvWithFilters {
+    static PATTERN_FILTER = "\\s*([^|\\s]+)(\\s*\\|\\s*([^:\\s]+)\\s*(\\s*:\\s*([^:\\s]+)*)?)?";
+    constructor() {
+        this.filterRegistry = {
+            classes: {
+
+            },
+            methods: {
+
+            },
+        };
+    }
+    registerClass(name, myClass) {
+        if (name) {
+            this.filterRegistry.classes[name] = myClass;
+            console.log(`registerClass(${name}) OK`);
+        }
+    }
+    registerFunction(key, myFunction) {
+        if (typeof myFunction == "function") {
+            this.filterRegistry.methods[key] = myFunction;
+            //console.log(`registerFunction(${key}) OK`);
+        }
+    }
+    filterValue(valor, columna, dato, defaultBase) {
+        if (columna.theclass && columna.theclass in this.filterRegistry.classes) {
+            const oneclass = this.filterRegistry.classes[columna.theclass];
+            if (columna.themethod) {
+                const onemethod = oneclass[columna.themethod];
+                if (typeof onemethod == "function") {
+                    let myarguments = [];
+                    if (columna.useRow) {
+                        myarguments.push(dato);
+                    } else {
+                        myarguments.push(valor);
+                    }
+                    myarguments = myarguments.concat(columna.argumentos);
+                    valor = onemethod(...myarguments);
+                }
+            }
+        } else if (columna.themethod && columna.themethod in this.filterRegistry.methods) {
+            const onemethod = this.filterRegistry.methods[columna.themethod];
+            let myarguments = [];
+            if (columna.useRow) {
+                myarguments.push(dato);
+            } else {
+                myarguments.push(valor);
+            }
+            if (["rand"].indexOf(columna.themethod) >= 0) {
+                if (myarguments[0] === undefined) {
+                    myarguments[0] = defaultBase;
+                }
+            }
+            myarguments = myarguments.concat(columna.argumentos);
+            valor = onemethod(...myarguments);
+        }
+        return valor;
+    }
+    getColumnDescription(header, separator = ";") {
+        const columnas = [];
+        const patron = new RegExp(`([^${separator}]+)`, "g");
+        let partes = null;
+        do {
+            partes = patron.exec(header);
+            if (partes !== null) {
+                const completo = partes[1];
+                const patron2 = new RegExp(CsvWithFilters.PATTERN_FILTER, "g");
+                const subpartes = patron2.exec(completo);
+                if (subpartes !== null) {
+                    const desc = {
+                        id: subpartes[1],
+                        useRow: false,
+                    };
+                    if (subpartes[3] !== undefined) {
+                        let subpartes3 = subpartes[3];
+                        if (subpartes3[subpartes3.length - 1] == "*") {
+                            subpartes3 = subpartes3.substring(0, subpartes3.length - 1);
+                            desc.useRow = true;
+                        }
+                        let classMethod = subpartes3.split(".");
+                        if (classMethod.length == 1) {
+                            desc.themethod = classMethod[0];
+                        } else {
+                            desc.theclass = classMethod[0];
+                            desc.themethod = classMethod[1];
+                        }
+                        const argumentos = [];
+                        if (subpartes[5]) {
+                            argumentos.push(JSON.parse(subpartes[5]));
+                            let siguiente = null;
+                            siguiente = patron2.exec(completo);
+                            if (siguiente !== null) {
+                                siguiente[0].split(":").map((siguienteFixed) => {
+                                    if (siguienteFixed.trim().length > 0) {
+                                        argumentos.push(JSON.parse(siguienteFixed));
+                                    }
+
+                                });
+                            }
+                        }
+                        desc.argumentos = argumentos;
+                    }
+                    columnas.push(desc);
+                }
+            }
+        } while (partes !== null);
+        return columnas;
+    }
+};
+
+module.exports = {
+    CsvWithFilters
+}

package/src/FaceEncoder.js

@@ -0,0 +1,64 @@
+const fromCharCode = String.fromCharCode;
+class FaceEncoder {
+
+    static serialize(listModel) {
+        let response = "";
+        for (let j = 0; j < listModel.length; j++) {
+            const model = listModel[j];
+            const { id, list } = model;
+            const tam = list.length;
+            response += id + ":" + tam + ":";
+            for (let i = 0; i < list.length; i++) {
+                const number = list[i];
+                const buffer = new ArrayBuffer(8);
+                new DataView(buffer).setFloat64(0, number, false);
+                const temp = [].slice.call(new Uint8Array(buffer));
+                response += fromCharCode(temp[0]) + fromCharCode(temp[1]) + fromCharCode(temp[2]) + fromCharCode(temp[3]) + fromCharCode(temp[4]) + fromCharCode(temp[5]) + fromCharCode(temp[6]) + fromCharCode(temp[7]);
+            }
+        }
+        return Buffer.from(response, "ascii");
+    }
+
+    static deserialize(buff) {
+        const todo = [];
+        let startIndex = 0;
+        do {
+            const partes = /^([^:]+):(\d+):(.*)$/.exec(buff.subarray(0, 30));
+            if (partes == null) {
+                return null;
+            }
+            const response = {
+                id: partes[1]
+            };
+            const tamanioName = partes[1].length + 2 + partes[2].length;
+            const tam = parseInt(partes[2]);
+            const list = [];
+            for (let i = 0; i < tam; i++) {
+                const octets = buff.subarray(tamanioName + i * 8, tamanioName + (i + 1) * 8);
+                const buffer = new ArrayBuffer(8);
+                new Uint8Array(buffer).set(octets);
+                const numero = new DataView(buffer).getFloat64(0, false);
+                list.push(numero);
+            }
+            response.list = list;
+            todo.push(response);
+            startIndex = tamanioName + tam * 8;
+            buff = buff.subarray(startIndex);
+        } while (buff.length > 0);
+        return todo;
+    }
+
+    static test() {
+        const serialized = FaceEncoder.serialize([
+            { id: "c240hGuQdHQ7VKRYcCjr", list: [3333333333333.123456789, 3333333333333.123456789] },
+            { id: "c250hGuQdHQ7VKRYcC25", list: [3345333333333.123456789, 6337333333333.123456789] }
+        ]);
+        console.log(serialized);
+        console.log(serialized.length + " Bytes");
+        console.log(100 * (4096 * 8 + 20 + 2) / 1024 / 1024 + " MB");
+        const returned = FaceEncoder.deserialize(serialized);
+        console.log(JSON.stringify(returned, null, 4));
+    }
+}
+
+//FaceEncoder.test();