@ejfdelgado/ejflab-back 1.1.0

package/srv/MainReplacer.mjs

@@ -0,0 +1,77 @@
+import { MyConstants } from "@ejfdelgado/ejflab-common/src/MyConstants.js";
+import { MyUtilities } from "@ejfdelgado/ejflab-common/src/MyUtilities.js"
+
+export class MainReplacer {
+    static replace(rta, replaces, theUrl) {
+        const REMPLAZOS = [
+            {
+                old: /name="og:title"[\s]+content="[^"]*"/,
+                new: `name="og:title" content="${MyUtilities.htmlEntities(replaces.tit)}"`,
+                empty: typeof replaces.tit != "string" || replaces.tit.length == 0,
+            },
+            {
+                old: /name="og:description"[\s]+content="[^"]*"/,
+                new: `name="og:description" content="${MyUtilities.htmlEntities(
+                    replaces.desc
+                )}"`,
+                empty: typeof replaces.desc != "string" || replaces.desc.length == 0,
+            },
+            {
+                old: /name="og:image"[\s]+content="[^"]*"/,
+                new: `name="og:image" content="${replaces.img}"`,
+                empty: typeof replaces.img != "string" || replaces.img.length == 0,
+            },
+            {
+                old: /name="og:url"[\s]+content="[^"]*"/,
+                new: `name="og:url" content="${theUrl.href}"`,
+            },
+            {
+                old: /name="keywords"[\s]+content="[^"]*"/,
+                new: `name="keywords" content="${replaces.kw}"`,
+                empty: typeof replaces.kw != "string" || replaces.kw.length == 0,
+            },
+            {
+                old: /<title>.*?<\/title>/,
+                new: `<title>${MyUtilities.htmlEntities(replaces.tit)}<\/title>`,
+                empty: typeof replaces.tit != "string" || replaces.tit.length == 0,
+            },
+            {
+                old: /name="pageId"[\s]*content="[^"]*"/,
+                new: `name="pageId" content="${replaces.id}"`,
+                empty: typeof replaces.id != "string" || replaces.id.length == 0,
+            },
+            {
+                old: /name="random"[\s]*content="[^"]*"/,
+                new: `name="random" content="${replaces.pass}"`,
+                empty: typeof replaces.pass != "string" || replaces.pass.length == 0,
+            },
+            {
+                old: /name="custom"[\s]*content="[^"]*"/,
+                new: `name="custom" content="${replaces.firebase}"`,
+                empty: typeof replaces.firebase != "string" || replaces.firebase.length == 0,
+            },
+            {
+                old: /name="time"[\s]*content="[^"]*"/,
+                new: `name="time" content="${replaces.time}"`,
+                empty: typeof replaces.time != "string" || replaces.time.length == 0,
+            },
+            {
+                old: /<base[\s]*href="[^"]*">/,
+                new: `<base href="${MyConstants.SRV_ROOT}">`,
+                empty: typeof replaces.time != "string" || replaces.time.length == 0,
+            }
+        ];
+        if (
+            rta != null &&
+            typeof rta.data == "string" &&
+            rta.metadata.filename == "index.html"
+        ) {
+            for (let i = 0; i < REMPLAZOS.length; i++) {
+                const remplazo = REMPLAZOS[i];
+                if (!remplazo.empty) {
+                    rta.data = rta.data.replace(remplazo.old, remplazo.new);
+                }
+            }
+        }
+    }
+}

package/srv/MfaSrv.mjs

@@ -0,0 +1,266 @@
+import { MyStore } from "./common/MyStore.mjs";
+import { General } from "./common/General.mjs";
+import axios from "axios";
+import { ModuloDatoSeguroBack } from "@ejfdelgado/ejflab-common/src/ModuloDatoSeguroBack.mjs";
+
+const MAX_READ_SIZE = 60;
+
+const FACE_SERVER = process.env.FACE_SERVER;
+
+export class MfaSrv {
+    static async computeVector(req, res, next) {
+        const imgId = General.readParam(req, "imgid");
+        const url = `${FACE_SERVER}compute?imgid=${imgId}`;
+        const responseRequest = await new Promise((resolve, reject) => {
+            const options = {};
+            axios.get(url, options)
+                .then(res => {
+                    resolve(res)
+                })
+                .catch(error => {
+                    reject(Error(error.response.data))
+                });
+        });
+        const response = responseRequest.data;
+        res.status(200).send({
+            status: "ok",
+            response
+        });
+    }
+    static async validateFace(req, res, next) {
+        const base64 = General.readParam(req, "base64");
+        const searchtype = General.readParam(req, "searchtype");
+        const value = General.readParam(req, "value");
+        const url = `${FACE_SERVER}validateface`;
+        const responseRequest = await new Promise((resolve, reject) => {
+            const options = {};
+            axios.post(url, { base64, searchtype, value }, options)
+                .then(res => { resolve(res) })
+                .catch(error => {
+                    reject(Error(error.response.data))
+                });
+        });
+        const response = responseRequest.data;
+        res.status(200).send({
+            status: "ok",
+            response
+        });
+    }
+    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 = "mfa";
+
+        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;
+                MfaSrv.serializeImage(image1);
+                if (image1.id) {
+                    await MyStore.updateById("mfaimg", image1.id, image1);
+                } else {
+                    image1.created = AHORA;
+                    await MyStore.create("mfaimg", image1);
+                }
+                MfaSrv.deserializeImage(image1);
+            }
+        } else {
+            image.author = token.email;
+            image.updated = AHORA;
+            image.pg = pageId;
+            image.pageType = pageType;
+            MfaSrv.serializeImage(image);
+            if (image.id) {
+                await MyStore.updateById("mfaimg", image.id, image);
+            } else {
+                image.created = AHORA;
+                await MyStore.create("mfaimg", image);
+            }
+            MfaSrv.deserializeImage(image);
+        }
+
+        res.status(200).send({
+            status: "ok",
+            image
+        });
+    }
+    static serializeImage(image) {
+        //
+    }
+    static deserializeImage(image) {
+        //
+    }
+    static async validateuid(req, res, next) {
+        const pageId = req.params['pageId'];
+        const uid = General.readParam(req, "uid");
+        const imgid = General.readParam(req, "imgid");
+        const page = await MyStore.readById("page", pageId);
+        const pass = page.pass;
+        if (!pass) {
+            throw Error("Primero debe generar las llaves secretas de la página");
+        }
+        let validated = false;
+        try {
+            const decifrado = ModuloDatoSeguroBack.decifrarSimple(uid, pass);
+            const respuesta = /^(.{2})_([^_]*)_(.{2})$/.exec(decifrado);
+            validated = (respuesta != null && respuesta[2] == imgid);
+        } catch (err) { }
+        res.status(200).send({
+            status: "ok",
+            validated,
+        });
+    }
+    static async rotate(req, res, next) {
+        const pageId = req.params['pageId'];
+        const imgid = General.readParam(req, "imgid");
+        const page = await MyStore.readById("page", pageId);
+        const pass = page.pass;
+        if (!pass) {
+            throw Error("Primero debe generar las llaves secretas de la página");
+        }
+        const rand1 = ModuloDatoSeguroBack.generateKey(2);
+        const rand2 = ModuloDatoSeguroBack.generateKey(2);
+        const dato = `${rand1}_${imgid}_${rand2}`;
+        const uid = ModuloDatoSeguroBack.cifrarSimple(dato, pass);
+        // Guardo el uid
+        await MyStore.updateById("mfaimg", imgid, { uid });
+        res.status(200).send({
+            status: "ok",
+            uid,
+        });
+    }
+    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 });
+        }
+        const select = ["created", "updated", "author", "pg", "urlBig", "urlThumbnail", "name", "lastname", "idType", "uid", "face_confidence", "embedding_time"];
+        response = await MyStore.paginate("mfaimg", [{ name: "created", dir: 'desc' }], offset, max, where, null, select);
+        for (let i = 0; i < response.length; i++) {
+            const image = response[i];
+            MfaSrv.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("mfaimg", image1.id);
+                }
+            }
+        } else {
+            await MyStore.deleteById("mfaimg", image.id);
+        }
+
+        res.status(200).send({
+            status: "ok",
+            image: []
+        });
+    }
+
+    static async createUpdateEnrollmentLink(req, res, next) {
+        const imgid = General.readParam(req, "imgid");
+        const origin = General.readParam(req, "origin");
+        const pageId = req.params['pageId'];
+        const AHORA = new Date().getTime();
+
+        let [mfaenrollment, image, page] = await Promise.all([
+            MyStore.readById("mfaenrollment", imgid),
+            MyStore.readById("mfaimg", imgid),
+            MyStore.readById("page", pageId),
+        ]);
+
+        if (mfaenrollment) {
+            mfaenrollment.created = AHORA;
+            await MyStore.updateById("mfaenrollment", imgid, mfaenrollment);
+        } else {
+            mfaenrollment = {
+                created: AHORA,
+                name: `${image.name} ${image.lastname}`,
+                id: imgid,
+            };
+            await MyStore.createById("mfaenrollment", imgid, mfaenrollment);
+        }
+
+        const cifrado = ModuloDatoSeguroBack.cifrar({ id: mfaenrollment.id, t: AHORA }, page.public2);
+
+        const url = `${origin}/mfaenrollment/?pg=${pageId}&data=${cifrado}`;
+        //const srv = `http://localhost:8081/srv/mfa/${pageId}/executeenrollment?pass=hey&data=${cifrado}`;
+
+        res.status(200).send({
+            status: "ok",
+            mfaenrollment,
+            url,
+            //srv
+        });
+    }
+
+    static async executeEnrollment(req, res, next) {
+        const data = General.readParam(req, "data");
+        const pass = General.readParam(req, "pass");
+        const pageId = req.params['pageId'];
+        const AHORA = new Date().getTime();
+        const MAX_TIME = 1000 * 60 * 60 * 24 * 1;// 1 día
+
+        if (!data) {
+            throw Error("Err A");
+        }
+
+        if (!pass) {
+            throw Error("Err Z");
+        }
+
+        const page = await MyStore.readById("page", pageId);
+        if (!page) {
+            throw Error("Err 0");
+        }
+        const decifrado = ModuloDatoSeguroBack.decifrar(data, page.private2);
+        const imgid = decifrado.id;
+        const t = decifrado.t;
+
+        const mfaenrollment = await MyStore.readById("mfaenrollment", imgid);
+        if (!mfaenrollment) {
+            throw Error("Err 1");
+        }
+        if (mfaenrollment.created != t) {
+            throw Error("Err B");
+        }
+        const difference = AHORA - mfaenrollment.created;
+        if (difference > MAX_TIME) {
+            throw Error("El enlace caducó, pide ayuda a soporte.");
+        }
+
+        await MyStore.runTransaction(async (firebaseInstance) => {
+            await Promise.all([
+                MyStore.updateById("mfaimg", imgid, { pass }, firebaseInstance),
+                MyStore.deleteById("mfaenrollment", imgid, firebaseInstance),
+            ]);
+        });
+
+        res.status(200).send({
+            status: "ok",
+        });
+    }
+}

package/srv/MilvusSrv.mjs

@@ -0,0 +1,152 @@
+import { MilvusClient, DataType } from "@zilliz/milvus2-sdk-node";
+
+export class MilvusSrv {
+    // MilvusSrv.checkErrors(res);
+    static checkErrors(res) {
+        let status = res;
+        if ("status" in status) {
+            status = status.status;
+        }
+        if (status.error_code != "Success") {
+            throw new Error(status.reason);
+        }
+    }
+    static connect() {
+        const uri = process.env.MILVUS_URI;
+        console.log(`Milvus uri ${uri}`);
+        const parts = /^\s*(https?):\/\/([^:]+):(\d+)\s*$/i.exec(uri)
+        const scheme = parts[1];
+        const host = parts[2];
+        const port = parts[3];
+        const client = new MilvusClient(uri);
+        return {
+            scheme,
+            host,
+            port,
+            client
+        }
+    }
+    static async existsDatabase(client, name) {
+        const res = await client.listDatabases();
+        return res.db_names.indexOf(name) >= 0;
+    }
+    static async existsCollection(client, name) {
+        const resListCollections = await client.listCollections();
+        MilvusSrv.checkErrors(resListCollections);
+        const { data } = resListCollections;
+        return data.indexOf(name) >= 0;
+    }
+    static async introspect(client) {
+        const res = await client.listDatabases();
+        MilvusSrv.checkErrors(res);
+        const databases = res.db_names;
+        for (let i = 0; i < databases.length; i++) {
+            const database = databases[i];
+            console.log(`- Database: ${database}`);
+            const resUseDatabase = await client.useDatabase({ db_name: database });
+            MilvusSrv.checkErrors(resUseDatabase);
+            const resListCollections = await client.listCollections();
+            MilvusSrv.checkErrors(resListCollections);
+            const { data } = resListCollections;
+            for (let j = 0; j < data.length; j++) {
+                const collection = data[j];
+                console.log(`    - Collection: ${collection.name}`);
+            }
+        }
+    }
+    static async dropDatabaseTemp(client) {
+        const res = await client.listDatabases();
+        MilvusSrv.checkErrors(res);
+        const databases = res.db_names;
+        for (let i = 0; i < databases.length; i++) {
+            const database = databases[i];
+            if (database.startsWith("temp_")) {
+                await MilvusSrv.dropDatabase(client, database)
+            }
+        }
+    }
+    static async dropCollection(client, collection_name) {
+        console.log(`Drop collection ${collection_name}...`);
+        const resHasCollection = await client.hasCollection({ collection_name });
+        MilvusSrv.checkErrors(resHasCollection);
+        if (!resHasCollection.value) {
+            console.log(`Drop collection ${collection_name} NOT EXISTS...`);
+            return false;
+        }
+        const resDrop = await client.dropCollection({ collection_name });
+        MilvusSrv.checkErrors(resDrop);
+        console.log(`Drop collection ${collection_name}... OK`);
+        return true;
+    }
+    static async dropDatabase(client, name) {
+        console.log(`Drop database ${name}...`);
+        const resUseDatabase1 = await client.useDatabase({ db_name: name });
+        MilvusSrv.checkErrors(resUseDatabase1);
+        const resListCollections = await client.listCollections();
+        MilvusSrv.checkErrors(resListCollections);
+        const { data } = resListCollections;
+        for (let j = 0; j < data.length; j++) {
+            const collection = data[j];
+            await MilvusSrv.dropCollection(client, collection.name);
+        }
+        const resDropDatabase = await client.dropDatabase({ db_name: name });
+        MilvusSrv.checkErrors(resDropDatabase);
+    }
+    static async useDatabase(client, name, recreate = false) {
+        console.log(`Use database ${name} recreate? ${recreate}...`);
+        if (!await MilvusSrv.existsDatabase(client, name)) {
+            console.log(`Creating '${name}' database...`);
+            const resCreate = await client.createDatabase({ db_name: name });
+            MilvusSrv.checkErrors(resCreate);
+        } else {
+            if (recreate) {
+                console.log(`Recreating '${name}' database...`);
+                await MilvusSrv.dropDatabase(client, name);
+                const resCreate = await client.createDatabase({ db_name: name });
+                MilvusSrv.checkErrors(resCreate);
+            } else {
+                console.log(`Using old '${name}' database...`);
+            }
+        }
+        const resUseDatabase2 = await client.useDatabase({ db_name: name });
+        MilvusSrv.checkErrors(resUseDatabase2);
+        console.log(`Use database ${name} recreate? ${recreate}... OK`);
+    }
+    static getDataType(text) {
+        const parts = text.split(".");
+        return DataType[parts[1]];
+    }
+    static async createCollectionWithSchema(client, myJson, recreate = false) {
+        // Translate data types
+        const myCopy = JSON.parse(JSON.stringify(myJson));
+        const collection_name = myCopy.collection_name;
+        const exists = await this.existsCollection(client, collection_name);
+        if (exists) {
+            if (recreate) {
+                // Erase
+                await MilvusSrv.dropCollection(client, collection_name);
+            } else {
+                // Do nothing
+                console.log(`Using old collection ${collection_name}`);
+                return;
+            }
+        }
+        const { fields } = myCopy;
+        for (let i = 0; i < fields.length; i++) {
+            const field = fields[i];
+            field.data_type = MilvusSrv.getDataType(field.data_type);
+        }
+        const res = await client.createCollection(myCopy);
+        MilvusSrv.checkErrors(res);
+    }
+    static async ping(req, res, next) {
+        const { client } = MilvusSrv.connect();
+        const databases = await client.listDatabases();
+        MilvusSrv.checkErrors(databases);
+        const response = {
+            databases,
+            status: "ok",
+        };
+        res.status(200).send(response);
+    }
+}

package/srv/MinioSrv.mjs

@@ -0,0 +1,154 @@
+import * as Minio from 'minio';
+import { Buffer } from 'buffer';
+import { NoExisteException } from './MyError.mjs';
+import { decode } from "@msgpack/msgpack";
+
+export class MinioSrv {
+    static getClient() {
+        const uri = process.env.MINIO_URI;
+        const uriParts = /^\s*([^:]+):(\d+)\s*$/.exec(uri);
+        if (!uriParts) {
+            throw new Error(`Bad MINIO_URI ${uri}`);
+        }
+        const minioClient = new Minio.Client({
+            endPoint: uriParts[1],
+            port: parseInt(uriParts[2]),
+            useSSL: false,
+            accessKey: process.env.MINIO_ACCESS_KEY,
+            secretKey: process.env.MINIO_SECRET_KEY,
+        });
+        return minioClient;
+    }
+    static async assureBucket(minioClient, bucket, region = "us-east-1") {
+        const exists = await minioClient.bucketExists(bucket)
+        if (exists) {
+            //console.log(`Bucket ${bucket} exists.`);
+        } else {
+            await minioClient.makeBucket(bucket, region)
+            //console.log(`Bucket ${bucket} created in "${region}".`);
+        }
+    }
+    static async putObject(minioClient, bucketName, objectPath, buffer, metadata = {}) {
+        return new Promise((resolve, reject) => {
+            minioClient.putObject(bucketName, objectPath, buffer, Buffer.byteLength(buffer), metadata, function (err, etag) {
+                if (err) {
+                    reject(err);
+                } else {
+                    resolve(etag);
+                }
+            });
+        });
+    }
+    static async stream2Buffer(stream) {
+        return new Promise((resolve, reject) => {
+            const _buf = [];
+            stream.on("data", (chunk) => _buf.push(chunk));
+            stream.on("end", () => resolve(Buffer.concat(_buf)));
+            stream.on("error", (err) => reject(err));
+        });
+    }
+    static async getObject(minioClient, bucketName, objectPath) {
+        const readedMetadataPromise = minioClient.statObject(bucketName, objectPath);
+        const dataStreamPromise = new Promise(async (resolve, reject) => {
+            try {
+                const dataStream = await minioClient.getObject(bucketName, objectPath);
+                const bytes = await MinioSrv.stream2Buffer(dataStream);
+                resolve(bytes);
+            } catch (err) {
+                reject(err);
+            }
+        });
+        try {
+            const [readedMetadata, bytes] = await Promise.all([readedMetadataPromise, dataStreamPromise]);
+            const metadata = readedMetadata.metaData;
+            metadata['Last-Modified'] = readedMetadata.lastModified;
+            return {
+                data: bytes,
+                metadata,
+            };
+        } catch (err) {
+            if (err.code == 'NotFound') {
+                throw new NoExisteException(`Not found ${objectPath} on ${bucketName}`);
+            } else {
+                throw err;
+            }
+        }
+    }
+    static async test(req, res, next) {
+        const minioClient = MinioSrv.getClient();
+        const bucketName = "public";
+        const objectPath = "local/myFile.txt";
+        const b64string = "Hola cómo estás?";
+        const metaData = { 'Content-Type': 'text/plain; charset=utf-8' };
+
+        await MinioSrv.assureBucket(minioClient, bucketName);
+        const buffer = Buffer.from(b64string, 'utf8');
+        const putResponse = await MinioSrv.putObject(minioClient, bucketName, objectPath, buffer, metaData);
+
+        const getResponse = await MinioSrv.getObject(minioClient, bucketName, objectPath);
+
+        const headers = getResponse.metadata;
+        headers['Content-disposition'] = "inline; filename=name.txt";
+        //headers['Cache-Control'] = "max-age=0";
+
+        res.writeHead(200, headers);
+        res.end(getResponse.data);
+    }
+    static async readFile(req, res, next) {
+        const bucketName = req.params['bucket'];
+        const downloadFlag = req.query ? req.query.download : false;
+        const minioClient = MinioSrv.getClient();
+        await MinioSrv.assureBucket(minioClient, bucketName);
+        const cleanedUrl = decodeURIComponent(req.originalUrl.replace(/^\//, "").replace(/\?.*$/, ""));
+        const urlParts = /^srv\/minio\/[^\/]+\/(.*)$/.exec(cleanedUrl);
+        const objectPath = urlParts[1];
+        const getResponse = await MinioSrv.getObject(minioClient, bucketName, objectPath);
+        const headers = getResponse.metadata;
+        const fileName = /([^\/]+)$/.exec(objectPath)[1];
+        if (downloadFlag != undefined) {
+            headers['Content-disposition'] = `attachment; filename=${fileName}`;
+        } else {
+            headers['Content-disposition'] = `inline; filename=${fileName}`;
+        }
+        if (req.query.max_age) {
+            headers["Cache-Control"] = `max-age=${req.query.max_age}`;
+        }
+        res.writeHead(200, headers);
+        res.end(getResponse.data);
+    }
+    static async writeFileLocal(bucketName, fileList) {
+        const minioClient = MinioSrv.getClient();
+        await MinioSrv.assureBucket(minioClient, bucketName);
+        const promesas = [];
+        // Ensure it is an array
+        if (!(fileList instanceof Array)) {
+            fileList = [fileList];
+        }
+        for (let i = 0; i < fileList.length; i++) {
+            const someFile = fileList[i];
+            const { objectPath, bytes, metadata } = someFile;
+            const promesa = MinioSrv.putObject(minioClient, bucketName, objectPath, bytes, metadata);
+            promesas.push(promesa);
+        }
+        await Promise.all(promesas);
+    }
+    static async writeFile(req, res, next) {
+        const bucketName = req.params['bucket'];
+        const buffer = req.body;
+        const fileList = decode(buffer);
+        await MinioSrv.writeFileLocal(bucketName, fileList);
+        const response = {
+            status: "ok",
+        };
+        res.status(200).send(response);
+    }
+    static async ping(req, res, next) {
+        const minioClient = MinioSrv.getClient();
+        const buckets = await minioClient.listBuckets();
+        const response = {
+            buckets,
+            status: "ok",
+        };
+        res.status(200).send(response);
+    }
+}