@ejfdelgado/ejflab-back 1.1.0

package/srv/common/MyStore.mjs

@@ -0,0 +1,169 @@
+
+import { Firestore } from '@google-cloud/firestore'
+
+const firestore = new Firestore();
+firestore.settings({
+    ignoreUndefinedProperties: true
+});
+
+export class MyStore {
+    // https://www.npmjs.com/package/@google-cloud/firestore
+    static async runTransaction(theFunction) {
+        /**
+         * Con las bibliotecas cliente de Cloud Firestore, puede agrupar 
+         * varias operaciones en una sola transacción. Las transacciones 
+         * son útiles cuando desea actualizar el valor de un campo según 
+         * su valor actual o el valor de algún otro campo. Una transacción 
+         * consta de cualquier cantidad de operaciones get() seguidas de 
+         * cualquier cantidad de operaciones de escritura, como set() , 
+         * update() o delete() . En el caso de una edición simultánea, 
+         * Cloud Firestore vuelve a ejecutar toda la transacción. 
+         * Por ejemplo, si una transacción lee documentos y otro cliente 
+         * modifica cualquiera de esos documentos, Cloud Firestore vuelve 
+         * a intentar la transacción. Esta función garantiza que la 
+         * transacción se ejecute con datos actualizados y coherentes.
+         */
+        return await firestore.runTransaction(theFunction);
+    }
+
+    static getBatch() {
+        /**
+         * Si no necesita leer ningún documento en su conjunto de operaciones, 
+         * puede ejecutar varias operaciones de escritura como un solo lote que 
+         * contiene cualquier combinación de operaciones set() , update() o delete() . 
+         * Un lote de escrituras se completa de forma atómica y puede escribir en 
+         * varios documentos.
+         */
+        return firestore.batch();
+    }
+
+    static async readByIds(collection, ids, firestoreInstance = null) {
+        const lista = [];
+        const theJson = {};
+        if (ids.length == 0) {
+            return theJson;
+        }
+        for (let i = 0; i < ids.length; i++) {
+            const id = ids[i];
+            lista.push(firestore.doc(`${process.env.ENV ? process.env.ENV : "pro"}-${collection}/${id}`));
+        }
+        let response;
+        if (firestoreInstance == null) {
+            response = await firestore.getAll(...lista);
+        } else {
+            response = await firestoreInstance.getAll(...lista);
+        }
+        for (let j = 0; j < response.length; j++) {
+            const doc = response[j];
+            const data = doc.data();
+            if (data) {
+                data.id = doc.id;
+                theJson[data.id] = data;
+            }
+        }
+        return theJson;
+    }
+
+    // Si no encuentra retorna undefined
+    static async readById(collection, id, firestoreInstance = null) {
+        const document = firestore.doc(`${process.env.ENV ? process.env.ENV : "pro"}-${collection}/${id}`);
+        let doc;
+        if (firestoreInstance == null) {
+            doc = await document.get();
+        } else {
+            doc = await firestoreInstance.get(document);
+        }
+        const theJson = doc.data();
+        if (theJson) {
+            theJson.id = id;
+        }
+        return theJson;
+    }
+
+    static async create(collection, payload, firestoreInstance = null) {
+        const elDoc = await firestore.collection(`${process.env.ENV ? process.env.ENV : "pro"}-${collection}`).add(payload);
+        if (firestoreInstance == null) {
+            payload.id = elDoc.id;
+            return payload;
+        } else {
+            // Please check it later, could not work
+            firestoreInstance.add(elDoc, payload);
+        }
+    }
+
+    static async createById(collection, id, payload, firestoreInstance = null) {
+        const document = firestore.doc(`${process.env.ENV ? process.env.ENV : "pro"}-${collection}/${id}`);
+        if (firestoreInstance == null) {
+            await document.set(payload);
+        } else {
+            firestoreInstance.set(document, payload);// no retorna promesa, sino la misma instancia
+        }
+        return document;
+    }
+
+    static async updateOrCreateById(collection, id, payload, firestoreInstance = null) {
+        const localKey = `${process.env.ENV ? process.env.ENV : "pro"}-${collection}/${id}`;
+        const document = firestore.doc(localKey);
+        if (firestoreInstance == null) {
+            await document.set(payload, { merge: true });
+        } else {
+            firestoreInstance.set(document, payload, { merge: true });// no retorna promesa, sino la misma instancia
+        }
+    }
+
+    static async updateById(collection, id, payload, firestoreInstance = null) {
+        const document = firestore.doc(`${process.env.ENV ? process.env.ENV : "pro"}-${collection}/${id}`);
+        if (firestoreInstance == null) {
+            await document.update(payload);
+        } else {
+            firestoreInstance.update(document, payload);// no retorna promesa, sino la misma instancia
+        }
+    }
+
+    static async deleteById(collection, id, firestoreInstance = null) {
+        const document = firestore.doc(`${process.env.ENV ? process.env.ENV : "pro"}-${collection}/${id}`);
+        if (firestoreInstance == null) {
+            await document.delete();
+        } else {
+            firestoreInstance.delete(document);// no retorna promesa, sino la misma instancia
+        }
+    }
+
+    static async paginate(collection, orderColumns, offset = 0, pageSize = 20, where = [], firestoreInstance = null, select = []) {
+        const collectionReference = firestore.collection(`${process.env.ENV ? process.env.ENV : "pro"}-${collection}`);
+        let theQuery = collectionReference;
+        for (let i = 0; i < orderColumns.length; i++) {
+            const orderColumn = orderColumns[i];
+            theQuery = theQuery.orderBy(orderColumn.name, orderColumn.dir);
+        }
+
+        for (let i = 0; i < where.length; i++) {
+            const aWhere = where[i];
+            theQuery = theQuery.where(aWhere.key, aWhere.oper, aWhere.value)
+        }
+        let documents;
+
+        theQuery = theQuery
+            .offset(offset)
+            .limit(pageSize);
+
+        if (select.length > 0) {
+            theQuery = theQuery.select(...select);
+        }
+
+        if (firestoreInstance == null) {
+            documents = await theQuery.get();
+        } else {
+            documents = await firestoreInstance.get(theQuery);
+        }
+
+        const data = documents.docs.map((d) => {
+            const temp = d.data();
+            temp.id = d.id;
+            return temp;
+        });
+        return data;
+    }
+}
+
+

package/srv/common/Usuario.mjs

@@ -0,0 +1,101 @@
+import { MyUtilities } from "@ejfdelgado/ejflab-common/src/MyUtilities.js";
+import { MyFileService } from "../MyFileService.mjs";
+import { MyConstants } from "@ejfdelgado/ejflab-common/src/MyConstants.js";
+import { MyStore } from "./MyStore.mjs";
+import { General } from "./General.mjs";
+import { MalaPeticionException } from "../MyError.mjs";
+
+const USER_TYPE = "user";
+
+export class Usuario {
+    metadatos = null;
+    id = null;
+    email = null;
+    phone = null;
+    constructor(token) {
+        this.metadatos = token;
+        if (this.metadatos != null) {
+            if (this.metadatos.email) {
+                this.email = this.metadatos.email;
+            }
+            const contenedor = this.metadatos["firebase"];
+            const identidades = contenedor["identities"];
+            if ("email" in identidades) {
+                this.id = identidades["email"][0];
+                this.email = this.id;
+            } else if ("phone" in identidades) {
+                this.id = identidades["phone"][0];
+                this.phone = this.id;
+            }
+        }
+    }
+    static async getCurrentUser(req, res, next) {
+        const user = res.locals.user;
+        const token = res.locals.token;
+        const sessionToken = res.locals.sessionToken;
+        if (sessionToken) {
+            res.cookie('yo', sessionToken, { maxAge: 1000 * 60 * 60 * 24, httpOnly: true });
+        }
+        // Debo buscar el usuario de base de datos
+        const response = await MyStore.readById(USER_TYPE, user.id);
+        if (response) {
+            res.status(200).send(response);
+        } else {
+            // Si no existe lo creo
+            const AHORA = new Date().getTime();
+            const email = user.email;
+            const prefijoEmail = /^[^@]+/.exec(email)[0]
+            const nuevo = {
+                email: email,
+                name: (token.name ? token.name : prefijoEmail),//El nombre será la primera parte del mail
+                phone: user.phone,
+            };
+            const q = `${nuevo.name ? nuevo.name : ""} ${prefijoEmail}`;
+            user.search = MyUtilities.partirTexto(q, true);
+            if (token.picture) {
+                nuevo.picture = await MyFileService.fetchUrl2Bucket(token.picture, token, MyConstants.USER.DEFAULT_FOLDER, MyConstants.USER.DEFAULT_FILE);
+            } else {
+                // Podría aquí hacerce un random
+                nuevo.picture = MyConstants.USER.DEFAULT_IMAGE;
+            }
+            nuevo.created = AHORA;
+            nuevo.updated = AHORA;
+            await MyStore.createById(USER_TYPE, user.id, nuevo);
+            nuevo.id = user.id;
+            res.status(200).send(nuevo);
+        }
+    }
+
+    static async saveMyUser(req, res, next) {
+        const user = res.locals.user;
+        const datos = General.readParam(req, "datos");
+        if (!datos || !(typeof datos == "object")) {
+            throw new MalaPeticionException("Falta datos");
+        }
+        const AHORA = new Date().getTime();
+        const updated = {
+            updated: AHORA,
+        };
+        const LLAVES = ["name", "email", "phone", "created"];
+        const LLAVES_SEARCH = ["name", "phone"];
+        let searchable = "";
+        for (let i = 0; i < LLAVES.length; i++) {
+            const llave = LLAVES[i];
+            const valor = datos[llave];
+            if (LLAVES_SEARCH.indexOf(llave) >= 0 && typeof valor == "string") {
+                searchable += valor + " ";
+            }
+            updated[llave] = valor;
+        }
+        updated.search = MyUtilities.partirTexto(searchable);
+        updated.search.push(user.id);
+        if (typeof datos.email == "string" && datos.email.length > 0) {
+            updated.search.push(datos.email);
+        }
+        await MyStore.updateById(USER_TYPE, user.id, updated);
+        updated.id = user.id;
+        updated.picture = datos.picture;
+        delete updated.search;
+        res.status(200).send(updated);
+    }
+}

package/srv/common/Utilidades.mjs

@@ -0,0 +1,43 @@
+
+export class Utilidades {
+  static leerRefererPath(myrequest) {
+    let urlTotal = Utilidades.leerHeader(myrequest, [
+      //"referer",
+      "X-Referer",
+    ]);
+    let elhost = Utilidades.leerHeader(myrequest, [
+      //"host",
+      //"Host",
+      "X-Host",
+    ]);
+    if (urlTotal == null || elhost == null) {
+      return "";
+    }
+    urlTotal = urlTotal.replace(/^https?:\/\//ig, "");
+    elhost = elhost.replace(/^https?:\/\//ig, "");
+
+    let elreferer = urlTotal;
+    const elindice = elreferer.indexOf(elhost) + elhost.length;
+    let temp = urlTotal.substr(elindice);
+    let indiceQuery = temp.indexOf("?");
+    if (indiceQuery >= 0) {
+      temp = temp.substr(0, indiceQuery);
+    }
+    indiceQuery = temp.indexOf("#");
+    if (indiceQuery >= 0) {
+      temp = temp.substr(0, indiceQuery);
+    }
+    temp = temp.replace(/[\/]$/, "");
+    return temp;
+  }
+  static leerHeader(myrequest, lista) {
+    for (let i = 0; i < lista.length; i++) {
+      const a = lista[i];
+      const val = myrequest.header(a);
+      if (["", null, undefined].indexOf(val) < 0) {
+        return val;
+      }
+      return null;
+    }
+  }
+}