@ejfdelgado/ejflab-back 1.1.0

package/srv/MyShell.mjs

@@ -0,0 +1,205 @@
+import path from "path";
+import fs from "fs";
+import { spawn } from "child_process";
+import { General } from "./common/General.mjs";
+import { InesperadoException } from "./MyError.mjs";
+import { IdGen } from "@ejfdelgado/ejflab-common/src/IdGen.js";
+
+export class ExecFolder {
+    constructor() {
+        // Debe crear una carpeta aleatoria
+        this.folderName = IdGen.num2ord(new Date().getTime());
+        this.folderPath = `/tmp/ejflabs/${this.folderName}/`;
+        fs.mkdirSync(this.folderPath, { recursive: true });
+    }
+    destroyFolder() {
+        fs.rmSync(this.folderPath, { recursive: true, force: true });
+    }
+    static async removeDir(path) {
+        return new Promise((resolve, reject) => {
+            try {
+                if (fs.existsSync(path)) {
+                    const files = fs.readdirSync(path)
+                    if (files.length > 0) {
+                        files.forEach(function (filename) {
+                            if (fs.statSync(path + "/" + filename).isDirectory()) {
+                                removeDir(path + "/" + filename)
+                            } else {
+                                fs.unlinkSync(path + "/" + filename)
+                            }
+                        })
+                    }
+                    fs.rmdirSync(path);
+                }
+                resolve();
+            } catch (err) {
+                reject(err);
+            }
+        });
+    }
+    writeTextFile(fileName, content) {
+        const folderPath = this.folderPath;
+        return new Promise((resolve, reject) => {
+            try {
+                const path = `${folderPath}${fileName}`;
+                fs.writeFileSync(path, content);
+                resolve(path);
+            } catch (err) {
+                reject(err);
+            }
+        });
+    }
+    readTextFile(fileName) {
+        const folderPath = this.folderPath;
+        return new Promise((resolve, reject) => {
+            try {
+                const ruta = `${folderPath}${fileName}`;
+                const data = fs.readFileSync(ruta, 'utf8');
+                resolve(data);
+            } catch (err) {
+                reject(err);
+            }
+        });
+    }
+    static async copyDir(src, dest) {
+        return new Promise(async (resolve, reject) => {
+            const copy = async (copySrc, copyDest) => {
+                return new Promise(async (resolve2, reject2) => {
+                    try {
+                        const list = fs.readdirSync(copySrc);
+                        const promesas = [];
+                        list.forEach(async (item) => {
+                            const ss = path.resolve(copySrc, item);
+                            try {
+                                const stat = fs.statSync(ss);
+                                const curSrc = path.resolve(copySrc, item);
+                                const curDest = path.resolve(copyDest, item);
+                                if (stat.isFile()) {
+                                    promesas.push(new Promise((resolve3, reject3) => {
+                                        const stream = fs.createReadStream(curSrc)
+                                            .pipe(fs.createWriteStream(curDest));
+                                        stream.on('error', reject3);
+                                        stream.on('finish', resolve3);
+                                    }));
+                                } else if (stat.isDirectory()) {
+                                    fs.mkdirSync(curDest, { recursive: true });
+                                    await copy(curSrc, curDest);
+                                }
+                            } catch (err2) {
+                                reject2(err2);
+                            }
+                        });
+                        try {
+                            await Promise.all(promesas);
+                            resolve2();
+                        } catch (err3) {
+                            reject2(err3);
+                        }
+                    } catch (err1) {
+                        reject2(err1);
+                    }
+                });
+            };
+
+            try {
+                await createFolderIfNotExists(dest);
+                await copy(src, dest);
+                resolve();
+            } catch (err0) {
+                reject(err0);
+            }
+        });
+    }
+}
+
+export class MyShell {
+
+    //http://localhost:8081/srv/shell?cmd=solvePnP&payload={"v2": [[282, 274], [397, 227], [577, 271], [462, 318], [270, 479], [450, 523], [566, 475]], "v3": [[0.5, 0.5, -0.5], [0.5, 0.5, 0.5], [-0.5, 0.5, 0.5], [-0.5, 0.5, -0.5], [0.5, -0.5, -0.5], [-0.5, -0.5, -0.5], [-0.5, -0.5, 0.5]]}
+    //http://localhost:8081/srv/shell?cmd=ls%20-la
+    static async run(req, res, next) {
+        const cmd = General.readParam(req, "cmd");
+        const payload = General.readParam(req, "payload");
+        const dato = await MyShell.runLocal(cmd, payload);
+        res.setHeader('content-type', 'text/plain');
+        res.end(dato);
+    }
+    static async runCommand(command, workingDirectory = "./") {
+        return new Promise((resolve, reject) => {
+            console.log(`Running ${command} at ${workingDirectory}`);
+            exec(command, {
+                cwd: workingDirectory
+            }, function (err, stdout, stderr) {
+                console.log(stdout);
+                if (err !== null) {
+                    reject(err);
+                } else {
+                    resolve();
+                }
+            });
+        });
+    }
+    static existsExecutable(execPath) {
+        try {
+            if (fs.lstatSync(execPath).isFile()) {
+                return true;
+            }
+        } catch (err) { }
+        return false;
+    }
+    //MyShell.getBinDir()
+    static getBinDir() {
+        const DIR = process.env.BIN_DIR || "bin-docker";
+        return DIR;
+    }
+    static async runLocal(command, payload = null) {
+        const args = command.split(/\s+/g);
+        const command1 = args.splice(0, 1)[0];
+        let execPath = path.join(process.cwd(), `/${MyShell.getBinDir()}/${command1}`);
+        if (!MyShell.existsExecutable(execPath)) {
+            execPath = command1;
+        }
+        if (payload !== null) {
+            args.push(payload);
+        }
+        const dirPath = path.join(process.cwd(), `/${MyShell.getBinDir()}/libs`);
+        const options = { env: { LD_LIBRARY_PATH: dirPath } };
+        const ls = spawn(execPath, args, options);
+
+        return new Promise((resolve, reject) => {
+            let total = "";
+            let isError = false;
+            ls.stdout.on("data", data => {
+                total += data.toString();
+            });
+
+            ls.stderr.on("data", data => {
+                //console.log(`stderr: ${data}`);
+                //reject(new Error(data));
+                total += data.toString();
+                isError = true;
+            });
+
+            ls.on('error', (error) => {
+                //console.log(`error: ${error.message}`);
+                reject(error);
+            });
+
+            ls.on("close", code => {
+                //console.log(`child process exited with code ${code}`);
+                if (isError) {
+                    reject(total);
+                } else {
+                    let parsed = {};
+                    try {
+                        parsed = JSON.parse(total);
+                    } catch (err) { }
+                    if (typeof parsed.error == "string") {
+                        reject(new InesperadoException(parsed.error));
+                    }
+                    resolve(total);
+                }
+            });
+        });
+
+    }
+}

package/srv/MySqlSrv.mjs

@@ -0,0 +1,43 @@
+import * as mysql from "mysql2/promise";
+
+export class MySqlSrv {
+    connectionPromise = null;
+    connection = null;
+    constructor() {
+    }
+
+    getConnectionParams() {
+        const host = process.env.PMA_HOST || "localhost";
+        const port = parseInt(process.env.PMA_PORT || "6033");
+        const database = process.env.MYSQL_DATABASE || "policia_vr";
+        const user = process.env.MYSQL_ROOT_USER || "root";
+        const password = process.env.MYSQL_ROOT_PASSWORD || "p0l1c14";
+        return {
+            host,
+            port,
+            user,
+            database,
+            password,
+            waitForConnections: true,
+            connectionLimit: 10,
+            maxIdle: 10, // max idle connections, the default value is the same as `connectionLimit`
+            idleTimeout: 60000, // idle connections timeout, in milliseconds, the default value 60000
+            queueLimit: 0,
+            enableKeepAlive: true,
+            keepAliveInitialDelay: 0
+        };
+    }
+
+    async connect() {
+        this.connectionPromise = mysql.createPool(this.getConnectionParams());
+        this.connection = await this.connectionPromise;
+    }
+
+    async checkConnection() {
+        await this.connectionPromise;
+    }
+
+    async disconnect() {
+        this.connection.end();
+    }
+}

package/srv/Network.mjs

@@ -0,0 +1,111 @@
+import md5 from "md5";
+import { Buffer } from "buffer";
+import { MyError } from "./MyError.mjs";
+import { MyUtilities } from "@ejfdelgado/ejflab-common/src/MyUtilities.js";
+
+function stringify(circ) {
+    var cache = [];
+    const text = JSON.stringify(circ, (key, value) => {
+        if (typeof value === 'object' && value !== null) {
+            if (cache.includes(value)) return;
+            cache.push(value);
+        }
+        return value;
+    });
+    cache = null;
+    return text;
+};
+
+function cors(req, res, next) {
+    if (req.method == 'OPTIONS') {
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'POST, GET, PUT, DELETE');
+        res.setHeader('Access-Control-Allow-Headers', '*');
+        res.setHeader('Access-Control-Max-Age', '3600');
+        res.status(204).send('');
+    } else {
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        next();
+    }
+}
+
+async function commonHeaders(req, res, next) {
+    res.setHeader('Content-Type', 'application/json');
+    await next();
+}
+
+function getVerifyKey(body, sometime) {
+    return md5(Buffer.from(md5(body) + sometime).toString("base64"));
+}
+
+async function verifyConstant(req, res, next) {
+    const verifyHeader = req.headers["x-constant"];
+    const someTimeHeader = req.headers["x-mytime"];
+    const reqBody = req.body;
+    const calculado = getVerifyKey(JSON.stringify(reqBody), someTimeHeader);
+    if (verifyHeader != calculado) {
+        res.status(403).send({ message: "Operación no permitida" });
+    } else {
+        await next();
+    }
+}
+
+function urlNorFound(req, res, next) {
+    res.status(404).send("Sorry can't find that!");
+}
+
+function getEnvVariables() {
+    return {
+        GAE_APPLICATION: process.env.GAE_APPLICATION,
+        GAE_DEPLOYMENT_ID: process.env.GAE_DEPLOYMENT_ID,
+        GAE_ENV: process.env.GAE_ENV,
+        GAE_INSTANCE: process.env.GAE_INSTANCE,
+        GAE_MEMORY_MB: process.env.GAE_MEMORY_MB,
+        GAE_RUNTIME: process.env.GAE_RUNTIME,
+        GAE_SERVICE: process.env.GAE_SERVICE,
+        GAE_VERSION: process.env.GAE_VERSION,
+        GOOGLE_CLOUD_PROJECT: process.env.GOOGLE_CLOUD_PROJECT,
+        NODE_ENV: process.env.NODE_ENV,
+        PORT: process.env.PORT,
+        ENV: process.env.ENV ? process.env.ENV : "pro",
+    };
+}
+
+function handleErrors(error, res) {
+    if (error instanceof MyError && typeof error.httpCode == "number") {
+        res.status(error.httpCode);
+    } else {
+        res.status(500);
+    }
+    const response = {
+        status: "error",
+        message: error.message,
+    };
+    res.send(response);
+}
+
+function handleErrorsDecorator(someFun) {
+    return async (req, res, next) => {
+        try {
+            await someFun(req, res, next);
+        } catch (error) {
+            console.log(error);
+            if (error.response && error.response.body) {
+                console.log(JSON.stringify(error.response.body));
+            }
+            res.locals.myerror = error;
+            handleErrors(error, res);
+        }
+    };
+}
+
+export {
+    cors,
+    getEnvVariables,
+    urlNorFound,
+    commonHeaders,
+    handleErrors,
+    handleErrorsDecorator,
+    verifyConstant,
+    stringify
+}

package/srv/OpenCVSrv.mjs

@@ -0,0 +1,27 @@
+import { General } from "./common/General.mjs";
+import { ExecFolder, MyShell } from "./MyShell.mjs";
+
+export class OpenCVSrv {
+    static async solvePnPLocal(payload) {
+        const cmd = "solvePnP";
+        const points3d = payload.points3d;
+        let folder = null;
+        if (points3d) {
+            folder = new ExecFolder();
+            payload.points3dPath = await folder.writeTextFile("points3d.json", JSON.stringify(points3d));
+            delete payload.points3d;
+        }
+        const payloadTxt = JSON.stringify(payload);
+        const dato = await MyShell.runLocal(cmd, payloadTxt);
+        if (folder) {
+            folder.destroyFolder();
+        }
+        return dato;
+    }
+    static async solvePnP(req, res, next) {
+        const payload = General.readParam(req, "payload");
+        const dato = await OpenCVSrv.solvePnPLocal(payload);
+        res.setHeader('content-type', 'text/json');
+        res.end(dato);
+    }
+}

package/srv/PageSrv.mjs

@@ -0,0 +1,234 @@
+import { MyUtilities } from "@ejfdelgado/ejflab-common/src/MyUtilities.js";
+import { MyRoutes } from "@ejfdelgado/ejflab-common/src/MyRoutes.js"
+import { General } from "./common/General.mjs";
+import { MyStore } from "./common/MyStore.mjs";
+import { Utilidades } from "./common/Utilidades.mjs";
+import { MalaPeticionException, NoExisteException } from "./MyError.mjs";
+import { AuthorizationSrv } from "./AuthorizationSrv.mjs";
+import { MyConstants } from "@ejfdelgado/ejflab-common/src/MyConstants.js";
+import { ModuloDatoSeguroBack } from "@ejfdelgado/ejflab-common/src/ModuloDatoSeguroBack.mjs";
+
+
+
+const PAGE_TYPE = "page";
+const PAGE_DELETE_TYPE = "page-delete";
+const MAX_READ_SIZE = 30;
+
+export class PageSrv {
+    static async deletePage(req, res, next) {
+        let respuesta = {};
+        const pageId = req.params['pageId'];
+        const ahora = new Date().getTime();
+        // Crear una entidad como evidencia de que el borrado está en proceso
+        await MyStore.createById(PAGE_DELETE_TYPE, pageId, {
+            state: 0,
+            created: ahora,
+            updated: ahora,
+        });
+        // Se borra la página como tal
+        await MyStore.deleteById(PAGE_TYPE, pageId);
+        res.status(200).send(respuesta);
+    }
+    static async savePage(req, res, next) {
+        let respuesta = {};
+        const pageId = req.params['pageId'];
+        const datos = General.readParam(req, "datos");
+        if (!pageId) {
+            throw new MalaPeticionException("Falta el id");
+        }
+        if (!datos || !(typeof datos == "object")) {
+            throw new MalaPeticionException("Falta datos");
+        }
+        const response = await MyStore.readById(PAGE_TYPE, pageId);
+        if (response) {
+            const { tit, desc } = datos;
+            const q = MyUtilities.partirTexto(`${typeof tit == 'string' ? tit : ''} ${typeof desc == 'string' ? desc : ''}`, true);
+            //Se agrega al buscable el correo del autor
+            q.push(response.usr);
+            const updated = {
+                tit,
+                desc,
+                q,
+            };
+            if (res.locals && res.locals.uri) {
+                updated.img = res.locals.uri;
+            }
+            await MyStore.updateById(PAGE_TYPE, pageId, updated);
+            Object.assign(response, updated);
+            respuesta = response;
+        } else {
+            throw new NoExisteException(`Does not exists ${pageId}`);
+        }
+        PageSrv.cleanSecrets(respuesta);
+        res.status(200).send(respuesta);
+    }
+    static async createNewPage(req, res, next) {
+        const user = res.locals.user;
+        const elpath = Utilidades.leerRefererPath(req);
+        const partes = MyRoutes.splitPageData(elpath);
+        const elUsuario = user.metadatos.email;
+        const nueva = await PageSrv.commonCreateNewPage(elUsuario, partes.pageType);
+        PageSrv.cleanSecrets(nueva);
+        res.status(200).send(nueva);
+    }
+    static async getCurrentPage(req, res, next) {
+        const user = res.locals.user;
+        const elpath = Utilidades.leerRefererPath(req);
+        const partes = MyRoutes.splitPageData(elpath);
+        const respuesta = await PageSrv.loadCurrentPage(partes.pageType, partes.pageId, user);
+        PageSrv.cleanSecrets(respuesta);
+        res.status(200).send(respuesta);
+    }
+    // PageSrv.cleanSecrets(page)
+    static async cleanSecrets(page) {
+        if (page) {
+            delete page['private'];
+            delete page['private2'];
+            delete page['public2'];
+            delete page['pass'];
+        }
+        return page;
+    }
+    static async rotateSecret1(req, res, next) {
+        let respuesta = {};
+        const pageId = req.params['pageId'];
+        if (!pageId) {
+            throw new MalaPeticionException("Falta el id");
+        }
+        const actualizacion = { pass: ModuloDatoSeguroBack.generateKey(4) };
+        await MyStore.updateById(PAGE_TYPE, pageId, actualizacion);
+        res.status(200).send(respuesta);
+    }
+    static async rotateSecret2(req, res, next) {
+        let respuesta = {};
+        const pageId = req.params['pageId'];
+        if (!pageId) {
+            throw new MalaPeticionException("Falta el id");
+        }
+        const actualizacion = ModuloDatoSeguroBack.generateKeyPair();
+        await MyStore.updateById(PAGE_TYPE, pageId, actualizacion);
+        res.status(200).send(respuesta);
+    }
+    static async rotateSecret3(req, res, next) {
+        let respuesta = {};
+        const pageId = req.params['pageId'];
+        if (!pageId) {
+            throw new MalaPeticionException("Falta el id");
+        }
+        const par = ModuloDatoSeguroBack.generateKeyPair();
+        const actualizacion = {
+            public2: par.public,
+            private2: par.private,
+        };
+        await MyStore.updateById(PAGE_TYPE, pageId, actualizacion);
+        res.status(200).send(respuesta);
+    }
+    static async commonCreateNewPage(elUsuario, pageType) {
+        const AHORA = new Date().getTime() / 1000;
+        const nueva = {
+            usr: elUsuario,
+            path: pageType,
+            date: AHORA,
+            act: AHORA,
+            tit: "Título",
+            desc: "Descripción",
+            img: MyConstants.getDefaultPageImage(pageType),
+            kw: "",
+        };
+        try {
+            nueva.pass = ModuloDatoSeguroBack.generateKey(4);
+            const par = ModuloDatoSeguroBack.generateKeyPair();
+            const par2 = ModuloDatoSeguroBack.generateKeyPair();
+            nueva.public = par.public;
+            nueva.private = par.private;
+            nueva.public2 = par2.public;
+            nueva.private2 = par2.private;
+        } catch (err) { }
+        await MyStore.create(PAGE_TYPE, nueva);
+        // Se deben agregar los permisos
+        const promesasPermisos = [];
+        promesasPermisos.push(AuthorizationSrv.createPagePermision("owner", nueva.id, elUsuario));
+        const publicRole = MyConstants.getDefaultPublicPageRole(pageType);
+        if (publicRole != "none") {
+            promesasPermisos.push(AuthorizationSrv.createPagePermision(publicRole, nueva.id));
+        }
+        await Promise.all(promesasPermisos);
+        return nueva;
+    }
+    static async loadCurrentPage(pageType, pageId, usuario = null) {
+        const AHORA = new Date().getTime() / 1000;
+        if (usuario == null && pageId == null) {
+            return {};
+        }
+        if (typeof pageId == "string") {
+            // Si hay id se debe buscar con Id y listo
+            const response = await MyStore.readById(PAGE_TYPE, pageId);
+            if (response) {
+                return response;
+            } else {
+                throw new NoExisteException(`Does not exists ${pageId}`);
+            }
+        } else {
+            if (usuario) {
+                const elUsuario = usuario.metadatos.email;
+                const where = [
+                    { key: "usr", oper: "==", value: elUsuario },
+                    { key: "path", oper: "==", value: pageType },
+                ];
+                const max = 1;
+                // Si no hay id pero hay usuario logeado se debe buscar por aut y pageType
+                const response = await MyStore.paginate(PAGE_TYPE, [{ name: "act", dir: 'desc' }], 0, max, where);
+                if (response.length > 0) {
+                    return response[0];
+                } else {
+                    // Si no existe lo crea y devuelve el valor por defecto
+                    const nueva = await PageSrv.commonCreateNewPage(elUsuario, pageType);
+                    return nueva;
+                }
+            }
+        }
+    }
+    static async iterateMyPages(req, res, next) {
+        const token = res.locals.token;
+        const { max, offset } = General.readMaxOffset(req, MAX_READ_SIZE);
+        const q = General.readParam(req, "q");
+        const path = General.readParam(req, "path");
+        if (!path) {
+            throw new MalaPeticionException("Falta el path");
+        }
+        // Que sea mio
+        const where = [
+            { key: "usr", oper: "==", value: token.email },
+            { key: "path", oper: "==", value: path },
+        ];
+        if (typeof q == 'string' && q.trim().length > 0) {
+            const partes = MyUtilities.partirTexto(q, false, true);
+            where.push({
+                key: "q", oper: "array-contains-any", value: partes
+            });
+        }
+        const select = ["date", "path", "img", "act", "usr", "kw", "tit", "desc", "public"];
+        const response = await MyStore.paginate(PAGE_TYPE, [{ name: "act", dir: 'desc' }], offset, max, where, null, select);
+        res.status(200).send(response);
+    }
+    static async iterateAllPages(req, res, next) {
+        const { max, offset } = General.readMaxOffset(req, MAX_READ_SIZE);
+        const q = General.readParam(req, "q");
+        const path = General.readParam(req, "path");
+        if (!path) {
+            throw new MalaPeticionException("Falta el path");
+        }
+        const where = [
+            { key: "path", oper: "==", value: path },
+        ];
+        if (typeof q == 'string' && q.trim().length > 0) {
+            const partes = MyUtilities.partirTexto(q, false, true);
+            where.push({
+                key: "q", oper: "array-contains-any", value: partes
+            });
+        }
+        const select = ["date", "path", "img", "act", "usr", "kw", "tit", "desc", "public"];
+        const response = await MyStore.paginate(PAGE_TYPE, [{ name: "act", dir: 'desc' }], offset, max, where, null, select);
+        res.status(200).send(response);
+    }
+}