@ejfdelgado/ejflab-back 1.1.0

package/srv/ImagiationSrv.mjs

@@ -0,0 +1,408 @@
+import { MyStore } from "./common/MyStore.mjs";
+import { General } from "./common/General.mjs";
+import axios from "axios";
+
+const MAX_READ_SIZE = 60;
+
+export class ImagiationSrv {
+    static async save(req, res, next) {
+        const token = res.locals.token;
+        const AHORA = new Date().getTime();
+        const image = General.readParam(req, "image");
+        const pageId = req.params['pageId'];
+        const pageType = "imagiation";
+
+        if (image instanceof Array) {
+            for (let i = 0; i < image.length; i++) {
+                const image1 = image[i];
+                image1.author = token.email;
+                image1.updated = AHORA;
+                image1.pg = pageId;
+                image1.pageType = pageType;
+                ImagiationSrv.serializeImage(image1);
+                if (image1.id) {
+                    await MyStore.updateById("imagiationimg", image1.id, image1);
+                } else {
+                    image1.created = AHORA;
+                    await MyStore.create("imagiationimg", image1);
+                }
+                ImagiationSrv.deserializeImage(image1);
+            }
+        } else {
+            image.author = token.email;
+            image.updated = AHORA;
+            image.pg = pageId;
+            image.pageType = pageType;
+            ImagiationSrv.serializeImage(image);
+            if (image.id) {
+                await MyStore.updateById("imagiationimg", image.id, image);
+            } else {
+                image.created = AHORA;
+                await MyStore.create("imagiationimg", image);
+            }
+            ImagiationSrv.deserializeImage(image);
+        }
+
+        res.status(200).send({
+            status: "ok",
+            image
+        });
+    }
+    static serializeImage(image) {
+        const tags = image.tags;
+        const nuevo = [];
+        for (let i = 0; i < tags.length; i++) {
+            const tag = tags[i];
+            for (let j = 0; j < tag.length; j++) {
+                nuevo.push(tag[j]);
+            }
+        }
+        image.tags = nuevo;
+    }
+    static deserializeImage(image) {
+        const tags = image.tags;
+        const nuevo = [];
+        const total = Math.floor(tags.length / 5);
+        for (let i = 0; i < total; i++) {
+            nuevo.push([tags[5 * i], tags[5 * i + 1], tags[5 * i + 2], tags[5 * i + 3], tags[5 * i + 4]]);
+        }
+        image.tags = nuevo;
+    }
+    static async read(req, res, next) {
+        const { max, offset } = General.readMaxOffset(req, MAX_READ_SIZE);
+        const max_date = parseInt(General.readParam(req, "max_date", 0));
+        const min_date = parseInt(General.readParam(req, "min_date", 0));
+        let response = [];
+        const pageId = req.params['pageId'];
+        // Se debe realizar la lectura como tal
+        const where = [
+            { key: "pg", oper: "==", value: pageId },
+        ];
+        if (!isNaN(max_date) && max_date > 0) {
+            where.push({ key: "created", oper: "<=", value: max_date });
+        }
+        if (!isNaN(min_date) && min_date > 0) {
+            where.push({ key: "created", oper: ">=", value: min_date });
+        }
+        response = await MyStore.paginate("imagiationimg", [{ name: "created", dir: 'desc' }], offset, max, where);
+        for (let i = 0; i < response.length; i++) {
+            const image = response[i];
+            ImagiationSrv.deserializeImage(image);
+        }
+        res.status(200).send({
+            status: "ok",
+            images: response,
+        });
+    }
+    static async delete(req, res, next) {
+        const image = General.readParam(req, "image");
+
+        if (image instanceof Array) {
+            for (let i = 0; i < image.length; i++) {
+                if (image1.id) {
+                    await MyStore.deleteById("imagiationimg", image1.id);
+                }
+            }
+        } else {
+            await MyStore.deleteById("imagiationimg", image.id);
+        }
+
+        res.status(200).send({
+            status: "ok",
+            image: []
+        });
+    }
+
+    static async tagsSave(req, res, next) {
+        const pageId = req.params['pageId'];
+        const tag = General.readParam(req, "tag");
+        await MyStore.updateOrCreateById("imagiationtag", pageId, { txt: JSON.stringify(tag) });
+        res.status(200).send({
+            status: "ok",
+        });
+    }
+
+    static async tagsRead(req, res, next) {
+        const pageId = req.params['pageId'];
+        let existente = await MyStore.readById("imagiationtag", pageId);
+        if (!existente) {
+            existente = { txt: "{}" };
+            await MyStore.createById("imagiationtag", pageId, existente);
+        }
+        // Se tumba el id si está
+        delete existente.id;
+
+        const actual = JSON.parse(existente.txt);
+        const keys = Object.keys(actual);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const val = actual[key];
+            if (typeof val == "string") {
+                actual[key] = { txt: val, ref: null };
+            }
+        }
+        res.status(200).send({
+            status: "ok",
+            tag: actual,
+        });
+    }
+
+    static async jobsSave(req, res, next) {
+        const token = res.locals.token;
+        const AHORA = new Date().getTime();
+        const pageId = req.params['pageId'];
+        const pageType = req.params['pageType'];
+        const job = General.readParam(req, "job");
+        if (job.id) {
+            // Primero se lee el estado
+            const old = await MyStore.readById("imagiationjob", job.id);
+            if (old.state != 'pending') {
+                throw new Error("No se puede hacer la modificación");
+            }
+            job.pageType = pageType;
+            job.updated = AHORA;
+            await MyStore.updateById("imagiationjob", job.id, job);
+        } else {
+            job.pageType = pageType;
+            job.pg = pageId;
+            job.created = AHORA;
+            job.updated = AHORA;
+            job.state = 'pending';
+            job.progress = 0;
+            job.owner = token.email;
+            if (!job.workerType) {
+                job.workerType = 'predefined';
+            }
+            job.started = 0;
+            await MyStore.create("imagiationjob", job);
+        }
+
+        res.status(200).send({
+            status: "ok",
+            jobs: [job],
+        });
+    }
+
+    static async jobsRead(req, res, next) {
+        const { max, offset } = General.readMaxOffset(req, MAX_READ_SIZE);
+        let response = [];
+        const pageId = req.params['pageId'];
+        // Se debe realizar la lectura como tal
+        const where = [
+            { key: "pg", oper: "==", value: pageId },
+        ];
+        response = await MyStore.paginate("imagiationjob", [{ name: "created", dir: 'desc' }], offset, max, where);
+        res.status(200).send({
+            status: "ok",
+            jobs: response,
+        });
+    }
+
+    static async jobRead(req, res, next) {
+        const jobId = General.readParam(req, "jobId");
+        const response = await MyStore.readById("imagiationjob", jobId);
+        const jobs = [];
+        if (response) {
+            jobs.push(response);
+        }
+        res.status(200).send({
+            status: "ok",
+            jobs,
+        });
+    }
+
+    static serializeModel(model) {
+        const configs = model.configs;
+        if (configs) {
+            for (let i = 0; i < configs.length; i++) {
+                configs[i] = JSON.stringify(configs[i]);
+            }
+        } else {
+            model.configs = [];
+        }
+        return model;
+    }
+
+    static deserializeModel(model) {
+        const configs = model.configs;
+        if (configs) {
+            for (let i = 0; i < configs.length; i++) {
+                configs[i] = JSON.parse(configs[i]);
+            }
+        } else {
+            model.configs = [];
+        }
+        return model;
+    }
+
+    static async confSave(req, res, next) {
+        const token = res.locals.token;
+        const AHORA = new Date().getTime();
+        const pageId = req.params['pageId'];
+        const pageType = req.params['pageType'];
+        let conf = General.readParam(req, "conf");
+        conf = ImagiationSrv.serializeModel(conf);
+        if (conf.id) {
+            conf.pageType = pageType;
+            conf.updated = AHORA;
+            await MyStore.updateById("imagiationconf", conf.id, conf);
+        } else {
+            // No existe
+            conf.pageType = pageType;
+            conf.pg = pageId;
+            conf.created = AHORA;
+            conf.updated = AHORA;
+            conf.owner = token.email;
+            await MyStore.create("imagiationconf", conf);
+        }
+
+        res.status(200).send({
+            status: "ok",
+            confs: [ImagiationSrv.deserializeModel(conf)],
+        });
+    }
+
+    static async confsRead(req, res, next) {
+        const { max, offset } = General.readMaxOffset(req, MAX_READ_SIZE);
+        let response = [];
+        const pageId = req.params['pageId'];
+        // Se debe realizar la lectura como tal
+        const where = [
+            { key: "pg", oper: "==", value: pageId },
+        ];
+        response = await MyStore.paginate("imagiationconf", [{ name: "created", dir: 'desc' }], offset, max, where);
+        response = response.map((elem) => {
+            return ImagiationSrv.deserializeModel(elem);
+        });
+        res.status(200).send({
+            status: "ok",
+            confs: response,
+        });
+    }
+
+    static async confRead(req, res, next) {
+        const confId = General.readParam(req, "confId");
+        const response = await MyStore.readById("imagiationconf", confId);
+        const confs = [];
+        if (response) {
+            confs.push(ImagiationSrv.deserializeModel(response));
+        }
+        res.status(200).send({
+            status: "ok",
+            confs,
+        });
+    }
+
+    static async confDelete(req, res, next) {
+        const confId = General.readParam(req, "confId");
+        const response = await MyStore.deleteById("imagiationconf", confId);
+        res.status(200).send({
+            status: "ok",
+        });
+    }
+
+    static serializeStatistic(stat) {
+        const respuesta = {
+            founds: []
+        };
+        for (let i = 0; i < stat.length; i++) {
+            const valor = stat[i];
+            const name = `count_${valor.name}`;
+            if (!(name in respuesta)) {
+                respuesta[name] = 1;
+                respuesta.founds.push(valor.name);
+            } else {
+                respuesta[name] += 1;
+            }
+        }
+        return respuesta;
+    }
+
+    static deserializeStatistic(stat) {
+        const founds = stat.founds;
+        const mapa = {};
+        for (let i = 0; i < founds.length; i++) {
+            const name = founds[i];
+            if (!(name in mapa)) {
+                mapa[name] = { count: 0 };
+            }
+            const conteoActual = stat[`count_${name}`];
+            mapa[name].count += conteoActual;
+        }
+        stat.founds = mapa;
+    }
+
+    static async storeStatistic(req, res, next) {
+        const AHORA = new Date().getTime();
+        const confId = General.readParam(req, "confId");
+        const pageId = req.params['pageId'];
+        const data = General.readParam(req, "data");
+
+        // De la configuración saco el nombre
+        const conf = await MyStore.readById("imagiationconf", confId);
+        if (!conf) {
+            throw Error("No conf");
+        }
+        const stat = ImagiationSrv.serializeStatistic(data.list);
+        const statExtra = {
+            t: AHORA,
+            pg: pageId,
+            confId,
+            confName: conf.name,
+            lat: data.lat,
+            lon: data.lon,
+            geohashs: data.geohashs,
+            geohash7: data.geohash7,
+            geohash8: data.geohash8,
+            big: data.uri,
+            thumb: data.uri.replace(/^(.*)\.([^\.]+)/, "$1_xs.$2")
+        };
+        // Eventualmente la lat y lon de la configuración si no vienen
+        if (!(statExtra.lat) && !(statExtra.lat)) {
+            statExtra.lat = conf.lat;
+            statExtra.lon = conf.lon;
+        }
+        Object.assign(stat, statExtra);
+        await MyStore.create("imagiationstat", stat);
+        res.status(200).send({
+            status: "ok",
+        });
+    }
+
+    static async pageStatistics(req, res, next) {
+        const { max, offset } = General.readMaxOffset(req, MAX_READ_SIZE);
+        const max_date = parseInt(General.readParam(req, "max_date", 0));
+        const min_date = parseInt(General.readParam(req, "min_date", 0));
+        let response = [];
+        const pageId = req.params['pageId'];
+        // Se debe realizar la lectura como tal
+        const where = [
+            { key: "pg", oper: "==", value: pageId },
+        ];
+        if (!isNaN(max_date) && max_date > 0) {
+            where.push({ key: "t", oper: "<=", value: max_date });
+        }
+        if (!isNaN(min_date) && min_date > 0) {
+            where.push({ key: "t", oper: ">=", value: min_date });
+        }
+        response = await MyStore.paginate("imagiationstat", [{ name: "t", dir: 'desc' }], offset, max, where);
+        /*
+        for (let i = 0; i < response.length; i++) {
+            const image = response[i];
+            ImagiationSrv.deserializeStatistic(image);
+        }
+        */
+        res.status(200).send({
+            status: "ok",
+            images: response,
+        });
+    }
+
+    static async statDelete(req, res, next) {
+        const statId = General.readParam(req, "statId");
+        const response = await MyStore.deleteById("imagiationstat", statId);
+        res.status(200).send({
+            status: "ok",
+        });
+    }
+}

package/srv/KeysSrv.mjs

@@ -0,0 +1,104 @@
+
+import { MyDates } from "@ejfdelgado/ejflab-common/src/MyDates.js";
+import { ModuloDatoSeguro } from "@ejfdelgado/ejflab-common/src/ModuloDatoSeguro.js";
+import { General } from "./common/General.mjs";
+import { MyStore } from "./common/MyStore.mjs";
+import { ModuloDatoSeguroBack } from "@ejfdelgado/ejflab-common/src/ModuloDatoSeguroBack.mjs";
+
+const KEYS_TYPE = "page-key";
+const DEFAULT_KEY_SIZE = 10;
+
+export class KeysSrv {
+    static async getOrGeneratePageKeys(pageId) {
+        // Cada página debe tener algo como esto:
+        const {
+            actual,
+            siguiente,
+            anterior,
+        } = MyDates.getDates();
+
+        // Busco el registro por pageId
+        const response = await MyStore.readById(KEYS_TYPE, pageId);
+        const payload = {};
+        if (!response) {
+            // Toca crearlo desde ceros todo
+            payload[actual] = ModuloDatoSeguro.generateKey(DEFAULT_KEY_SIZE);
+            payload[siguiente] = ModuloDatoSeguro.generateKey(DEFAULT_KEY_SIZE);
+            payload[anterior] = ModuloDatoSeguro.generateKey(DEFAULT_KEY_SIZE);
+            await MyStore.createById(KEYS_TYPE, pageId, payload);
+        } else {
+            payload[actual] = response[actual];
+            payload[siguiente] = response[siguiente];
+            payload[anterior] = response[anterior];
+            let modificado = false;
+            if (!(actual in payload) || !payload[actual]) {
+                payload[actual] = ModuloDatoSeguro.generateKey(DEFAULT_KEY_SIZE);
+                modificado = true;
+            }
+            if (!(siguiente in payload) || !payload[siguiente]) {
+                payload[siguiente] = ModuloDatoSeguro.generateKey(DEFAULT_KEY_SIZE);
+                modificado = true;
+            }
+            if (!(anterior in payload) || !payload[anterior]) {
+                payload[anterior] = ModuloDatoSeguro.generateKey(DEFAULT_KEY_SIZE);
+                modificado = true;
+            }
+            if (modificado) {
+                await MyStore.updateById(KEYS_TYPE, pageId, payload);
+            }
+        }
+        return payload;
+    }
+
+    static async cifrar(objeto, pageId) {
+        const llavero = await KeysSrv.getOrGeneratePageKeys(pageId);
+        const actual = MyDates.getDayAsContinuosNumber(new Date());
+        const pass = llavero[actual];
+        const resultado = ModuloDatoSeguroBack.cifrarSimple(objeto, pass);
+        return resultado;
+    }
+
+    static async decifrar(texto, pageId) {
+        const llavero = await KeysSrv.getOrGeneratePageKeys(pageId);
+        const {
+            actual,
+            siguiente,
+            anterior,
+        } = MyDates.getDates();
+        let resultado = undefined;
+        const llaves = [];
+        llaves.push(llavero[actual]);
+        llaves.push(llavero[anterior]);
+        llaves.push(llavero[siguiente]);
+        for (let i = 0; i < llaves.length; i++) {
+            const llave = llaves[i];
+            try {
+                resultado = ModuloDatoSeguroBack.decifrarSimple(texto, llave);
+            } catch (e) {
+
+            }
+        }
+        return resultado;
+    }
+
+    static async getPageKeys(req, res, next) {
+        const pageId = req.params['pageId'];
+        const llavero = await KeysSrv.getOrGeneratePageKeys(pageId);
+        res.status(200).send(llavero);
+    }
+
+    static async cifrarWeb(req, res, next) {
+        const key = General.readParam(req, "key");
+        const payload = General.readParam(req, "payload");
+        const resultado = ModuloDatoSeguroBack.cifrarSimple(payload, key);
+        console.log(resultado);
+        res.status(200).send(resultado);
+    }
+
+    static async decifrarWeb(req, res, next) {
+        const key = General.readParam(req, "key");
+        const payload = General.readParam(req, "payload");
+        const resultado = ModuloDatoSeguroBack.decifrarSimple(payload, key);
+        res.status(200).send(resultado);
+    }
+}

package/srv/MainHandler.mjs

@@ -0,0 +1,140 @@
+import url from "url";
+import fs from "fs";
+import path from "path";
+import { guessMimeType } from "./common/MimeTypeMap.mjs";
+import { MainReplacer } from "./MainReplacer.mjs";
+import { MyRoutes } from "@ejfdelgado/ejflab-common/src/MyRoutes.js";
+import { PageSrv } from "./PageSrv.mjs";
+import { ModuloDatoSeguro } from "@ejfdelgado/ejflab-common/src/ModuloDatoSeguro.js";
+import { ModuloDatoSeguroBack } from "@ejfdelgado/ejflab-common/src/ModuloDatoSeguroBack.mjs";
+import { MyConstants } from "@ejfdelgado/ejflab-common/src/MyConstants.js";
+
+export class MainHandler {
+    static LOCAL_FOLDER = path.resolve() + "/dist/bundle";
+    static async handle(req, res, next) {
+        const originalUrl = req.getUrl();
+        const theUrl = url.parse(originalUrl);
+        if (theUrl.pathname == "/socket.io/") {
+            return next();
+        }
+        const rutas = MainHandler.decodeUrl(theUrl);
+        const encoding = req.query.encoding;
+        const rta = await MainHandler.resolveLocalFile(rutas, encoding);
+        if (
+            rta != null &&
+            typeof rta.data == "string" &&
+            rta.metadata.filename == "index.html"
+        ) {
+            const partes = MyRoutes.splitPageData(theUrl.path);
+            if (MyConstants.NO_AUTO_PAGE_NAVITATION.indexOf(partes.pageType) >= 0) {
+                partes.pageId = null;
+            }
+            const replaces = await PageSrv.loadCurrentPage(partes.pageType, partes.pageId);
+            const firebaseJson = await MainHandler.resolveLocalFileSingle(MyConstants.FIREBASE_CONFIG_FILE, "utf8", path.resolve());
+            // Acá se debe inyectar el password y el json se lee de local y se cifra
+            replaces.time = "" + new Date().getTime();
+            replaces.pass = ModuloDatoSeguro.generateKey();
+            replaces.firebase = ModuloDatoSeguroBack.cifrarSimple(JSON.parse(firebaseJson), replaces.pass);
+            MainReplacer.replace(rta, replaces, theUrl);
+        }
+        MainHandler.makeResponse(rta, req, res);
+    }
+
+    static decodeUrl(localPath) {
+        const respuestas = [];
+        respuestas.push(localPath.pathname);
+        respuestas.push("/index.html");
+        const ans = {
+            files: respuestas,
+            pageType: null,
+            pageId: null,
+        };
+        return ans;
+    }
+
+    static makeResponse(rta, req, res) {
+        const downloadFlag = (req.query && req.query.download);
+        if (rta != null) {
+            if (rta.redirect) {
+                res.redirect(rta.redirect);
+            } else {
+                res.writeHead(200, {
+                    "Content-Type": rta.metadata.contentType,
+                    "Content-disposition":
+                        downloadFlag ? "attachment;filename=" + rta.metadata.filename : "inline",
+                });
+                res.end(rta.data);
+            }
+        } else {
+            res.status(202).end();
+        }
+    }
+
+    static async resolveLocalFile(localPath, encoding = "utf8") {
+        for (let i = 0; i < localPath.files.length; i++) {
+            const filename = localPath.files[i];
+            const contentType = guessMimeType(filename);
+            let contenido;
+            if (["text/html"].indexOf(contentType) >= 0) {
+                contenido = await MainHandler.resolveLocalFileSingle(
+                    filename,
+                    encoding
+                );
+            } else {
+                contenido = await MainHandler.resolveLocalFileSingle(filename);
+            }
+            if (contenido != null) {
+                return {
+                    data: contenido,
+                    metadata: {
+                        contentType: contentType,
+                        filename: /[^/]*$/.exec(filename)[0],
+                        fullPath: filename,
+                    },
+                };
+            }
+        }
+        return null;
+    }
+
+    static async resolveLocalFileSingle(filename, encoding, rootFolder = MainHandler.LOCAL_FOLDER) {
+        return new Promise((resolve, reject) => {
+            const somePath = path.join(rootFolder, filename);
+
+            fs.access(somePath, (err) => {
+                if (err) {
+                    resolve(null);
+                } else {
+                    if (!fs.lstatSync(somePath).isFile()) {
+                        resolve(null);
+                        return;
+                    }
+                    if (typeof encoding == "string") {
+                        fs.readFile(somePath, encoding, function (err, data) {
+                            if (err) {
+                                reject(err);
+                                return;
+                            }
+                            resolve(data);
+                        });
+                    } else {
+                        fs.readFile(somePath, function (err, data) {
+                            if (err) {
+                                reject(err);
+                                return;
+                            }
+                            resolve(data);
+                        });
+                    }
+                }
+            });
+        });
+    }
+
+    static addGetUrl(req, res, next) {
+        req.getUrl = function () {
+            return req.protocol + "://" + req.get("host") + req.originalUrl;
+        };
+        return next();
+    }
+}