@ejfdelgado/ejflab-back 1.1.0

package/srv/callprocessors/SendChatProcessor.mjs

@@ -0,0 +1,71 @@
+import { SimpleObj } from "@ejfdelgado/ejflab-common/src/SimpleObj.js";
+import { GenericProcessor } from "./GenericProcessor.mjs";
+
+
+export class SendChatProcessor extends GenericProcessor {
+    MAX_COUNT_TIMESTAMS = 6;
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+    execute(args) {
+        const { text, author, open } = args;
+        const room = this.context.getRoomFromSocket(this.socket);
+        const roomData = this.context.getRoomLiveTupleModel(room);
+        if (!roomData.model.data) {
+            roomData.model.data = {};
+        }
+        if (!roomData.model.data.chat) {
+            roomData.model.data.chat = [];
+        }
+        const now = new Date().getTime();
+        roomData.model.data.chat.push({
+            text,
+            date: now,
+            author: {
+                uid: author,
+            },
+        });
+        let changes = roomData.builder.trackDifferences(roomData.model, [], null, ["data", "data.chat"]);
+        roomData.model = roomData.builder.affect(changes);
+        // Also notify last message time
+        const roomPublicData = this.context.getRoomLiveTupleModel("public");
+        if (roomPublicData.model.data) {
+            const tupleKey = `data.lastmsg.${room}.${author}.arr`;
+            const arr = SimpleObj.getValue(roomPublicData.model, tupleKey, []);
+            arr.push(now);
+            const sobrantes = arr.length - this.MAX_COUNT_TIMESTAMS;
+            if (sobrantes > 0) {
+                arr.splice(0, sobrantes);
+            }
+            SimpleObj.recreate(roomPublicData.model, tupleKey, arr);
+            const changePaths = [
+                "data",
+                "data.lastmsg",
+                `data.lastmsg.${room}`,
+                `data.lastmsg.${room}.${author}`,
+                `data.lastmsg.${room}.${author}.arr`
+            ];
+            let changes2 = roomPublicData.builder.trackDifferences(roomPublicData.model, [], null, changePaths);
+            roomPublicData.model = roomPublicData.builder.affect(changes2);
+
+            if (open) {
+                // Get the other id
+                let otherId;
+                if (room.startsWith(author)) {
+                    otherId = room.substring(author.length + 1);
+                } else {
+                    otherId = room.substring(0, room.length - (author.length + 1));
+                }
+                console.log(`I'm ${author} and other is ${otherId}`);
+                const otherSocket = SimpleObj.getValue(roomPublicData.model, `data.people.${otherId}.socket`, null);
+                if (otherSocket) {
+                    this.io.to(otherSocket).emit("openChat", {
+                        room,
+                    });
+                }
+            }
+        }
+
+
+    }
+}

package/srv/callprocessors/StartFlowChartProcessor.mjs

@@ -0,0 +1,48 @@
+import { GenericProcessor } from "./GenericProcessor.mjs";
+
+export class StartFlowChartProcessor extends GenericProcessor {
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+    async execute(args) {
+        let { room } = args;
+        if (!room) {
+            if (this.socket) {
+                room = this.context.getRoomFromSocket(this.socket);
+            } else {
+                room = "public";
+            }
+        }
+        const instance = await this.context.getFlowChartExec(room);
+        if (!instance) {
+            console.log(`No instance for room ${room}`);
+            return;
+        }
+        const roomData = this.context.getRoomLiveTupleModel(room);
+        const now = new Date().getTime();
+        // weird
+        const data1 = instance.getData();
+        roomData.model.data = data1;
+        roomData.model.data.scope.start = now;
+        let changes1 = roomData.builder.trackDifferences(roomData.model, [], null, ["data", "data.scope"]);
+        roomData.model = roomData.builder.affect(changes1);
+        instance.executeIteration(async (status) => {
+            const data = instance.getData();
+            //data['scope'].current = now;
+            roomData.model.data = data;
+            roomData.model.currentNodes = status.currentNodes;
+            roomData.model.history = status.history;
+
+            let changes = roomData.builder.trackDifferences(roomData.model, [], null, ["data", "currentNodes", "history"]);
+            roomData.model = roomData.builder.affect(changes);
+            if (changes.total > 0) {
+                roomData.model.version = roomData.model.version + 1;
+                changes = roomData.builder.trackDifferences(roomData.model, [], null, ["version"]);
+                roomData.model = roomData.builder.affect(changes);
+            }
+
+        }).then(() => {
+            this.io.to(room).emit("flowchartEnd", {});
+        });
+    }
+}

package/srv/callprocessors/StopFlowChartProcessor.mjs

@@ -0,0 +1,16 @@
+import { GenericProcessor } from "./GenericProcessor.mjs";
+
+export class StopFlowChartProcessor extends GenericProcessor {
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+    async execute(args) {
+        const room = this.context.getRoomFromSocket(this.socket);
+        const instance = await this.context.getFlowChartExec(room);
+        if (!instance) {
+            console.log(`No instance to stop`);
+            return;
+        }
+        instance.stop();
+    }
+}

package/srv/callprocessors/SubscribemeProcessor.mjs

@@ -0,0 +1,13 @@
+import { GenericProcessor } from "./GenericProcessor.mjs";
+
+
+export class SubscribemeProcessor extends GenericProcessor {
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+    execute(args) {
+        const { ref } = args;
+        console.log(`Joining ${this.socket.id} to ${ref}`);
+        this.socket.join(ref);
+    }
+}

package/srv/callprocessors/UpdateMyInformationProcessor.mjs

@@ -0,0 +1,30 @@
+import { GenericProcessor } from "./GenericProcessor.mjs";
+
+
+export class UpdateMyInformationProcessor extends GenericProcessor {
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+    execute(args) {
+        const { userUID, data } = args;
+        const room = this.context.getRoomFromSocket(this.socket);
+        const roomData = this.context.getRoomLiveTupleModel(room);
+        if (!roomData.model.data) {
+            roomData.model.data = {};
+        }
+        if (!roomData.model.data.people) {
+            roomData.model.data.people = {};
+        }
+        data.socket = this.socket.id;
+        let oldValue = roomData.model.data.people[userUID];
+        if (oldValue) {
+            data.since = oldValue.since;
+        }
+        if (!data.since) {
+            data.since = new Date().getTime();
+        }
+        roomData.model.data.people[userUID] = data;
+        let changes = roomData.builder.trackDifferences(roomData.model, [], null, ["data", "data.people"]);
+        roomData.model = roomData.builder.affect(changes);
+    }
+}

package/srv/common/FirebasConfig.mjs

@@ -0,0 +1,160 @@
+import { initializeApp } from 'firebase-admin/app';
+import { getAuth } from 'firebase-admin/auth';
+import { MyError } from '../MyError.mjs';
+import { Usuario } from './Usuario.mjs';
+import fs from "fs";
+import { General } from './General.mjs';
+import { MyConstants } from '@ejfdelgado/ejflab-common/src/MyConstants.js';
+
+function getFirebaseConfig() {
+    const firebaseJson = fs.readFileSync(MyConstants.FIREBASE_CONFIG_FILE, { encoding: "utf8" });
+    return JSON.parse(firebaseJson);
+}
+
+try {
+    initializeApp(getFirebaseConfig());
+} catch (err) {
+    console.log(err);
+    console.log("Firebase capability not configured");
+}
+function getOAuthToken(req) {
+    const authcookie = General.readParam(req, "authcookie")
+    if (authcookie == "1" && "yo" in req.cookies) {
+        let token = req.cookies["yo"];
+        return token;
+    }
+    if ('authentication' in req.headers) {
+        return req.headers.authentication.replace(/bearer\s*/ig, '');
+    }
+    if ('rawHeaders' in req) {
+        const lista = req.rawHeaders;
+        const tamanio = lista.length / 2;
+        for (let i = 0; i < tamanio; i++) {
+            const key = lista[i * 2];
+            const value = lista[i * 2 + 1];
+            //'authorization' es interno!
+            if (['x-forwarded-authorization'].indexOf(key.toLowerCase()) >= 0) {
+                return value.replace(/bearer\s*/ig, '');
+            }
+        }
+    }
+    if ('authorization' in req.headers) {
+        return req.headers.authorization.replace(/bearer\s*/ig, '');
+    }
+    if ('Authorization' in req.headers) {
+        return req.headers.Authorization.replace(/bearer\s*/ig, '');
+    }
+    return null;
+}
+
+async function checkAutenticated(req) {
+    const sessionToken = getOAuthToken(req);
+    return new Promise((resolve, reject) => {
+        if (!sessionToken) {
+            reject(new MyError("Missing Authorization header.", 403));
+            return;
+        }
+        getAuth()
+            .verifyIdToken(sessionToken)
+            .then((decodedToken) => {
+                resolve({
+                    decodedToken,
+                    sessionToken,
+                });
+            })
+            .catch((error) => {
+                reject(new MyError(error.message, 403));
+            });
+    });
+}
+
+async function disableUser(uid) {
+    return new Promise((resolve, reject) => {
+        getAuth()
+            .updateUser(uid, { disabled: true, })
+            .then(() => {
+                resolve();
+            })
+            .catch((error) => {
+                reject(new MyError(error.message, 403));
+            });
+    });
+}
+
+async function checkAuthenticated(req, res, next) {
+    try {
+        const {
+            decodedToken,
+            sessionToken,
+        } = await checkAutenticated(req);
+        res.locals.token = decodedToken;
+        res.locals.sessionToken = sessionToken;
+        res.locals.user = new Usuario(res.locals.token);
+        await next();
+    } catch (err) {
+        res.status(428).send({ message: err.message });
+    }
+}
+
+async function checkAuthenticatedSilent(req, res, next) {
+    try {
+        const {
+            decodedToken,
+            sessionToken,
+        } = await checkAutenticated(req);
+        res.locals.token = decodedToken;
+        res.locals.sessionToken = sessionToken;
+        res.locals.user = new Usuario(res.locals.token);
+        await next();
+    } catch (err) {
+        //console.log(err);
+        res.locals.token = null;
+        res.locals.user = null;
+        await next();
+    }
+}
+
+async function isAdmin(req, res, next) {
+    const fixedAdmins = [
+        "edgar.jose.fernando.delgado@gmail.com",
+        "info@pais.tv",
+    ];
+    try {
+        const token = res.locals.token;
+        const estaEnListaAdmins = (fixedAdmins.indexOf(token.email) >= 0);
+        const esDominioPanal = token.email.endsWith("@pais.tv");
+        if (!(esDominioPanal || estaEnListaAdmins)) {
+            res.status(403).send({ message: `Acción no permitida para ${token.email}` });
+        } else {
+            await next();
+        }
+
+    } catch (err) {
+        res.status(428).send({ message: err.message });
+    }
+}
+
+async function checkVerified(req, res, next) {
+    try {
+        const token = res.locals.token;
+        if (token.email_verified == false) {
+            res.status(424).send({ message: "Para continuar primero debes verificar tu correo" });
+        } else {
+            await next();
+        }
+
+    } catch (err) {
+        res.status(428).send({ message: err.message });
+    }
+}
+
+export {
+    getFirebaseConfig,
+    getOAuthToken,
+    checkAutenticated,
+    checkAuthenticated,
+    checkAuthenticatedSilent,
+    checkVerified,
+    isAdmin,
+    disableUser,
+}

package/srv/common/General.mjs

@@ -0,0 +1,69 @@
+import md5 from 'md5';
+
+export class General {
+    static readMaxOffset(req, MAX_READ_SIZE) {
+        const offsetR = parseInt(General.readParam(req, "offset"));
+        const maxR = parseInt(General.readParam(req, "max"));
+        let offset = 0;
+        if (!isNaN(offsetR)) {
+            offset = Math.max(0, offsetR);
+        }
+        let max = 0;
+        if (!isNaN(maxR)) {
+            max = Math.min(MAX_READ_SIZE, maxR);
+        }
+        return {
+            max,
+            offset,
+        };
+    }
+    static readParam(req, name, pred = null) {
+        const nameLower = name.toLowerCase();
+        if (req.body && name in req.body) {
+            return req.body[name];
+        } else if (req.query && name in req.query) {
+            return req.query[name];
+        } else if (req.query && nameLower in req.query) {
+            return req.query[nameLower];
+        } else if (req.params && name in req.params) {
+            return req.params[name];
+        } else if (req.locals?.extra) {
+            if (name in req.locals.extra) {
+                return req.locals.extra[name];
+            }
+        }
+        return pred;
+    }
+    static getSuffixPath(keyName, suffix) {
+        const keyNameXs = keyName.replace(/^(.+)\.([^./]+)$/ig, `$1${suffix}.$2`);
+        if (keyNameXs == keyName) {
+            // fallback when no extension
+            return keyName + suffix;
+        }
+        return keyNameXs;
+    }
+    static randomIntFromInterval(min, max) {
+        return Math.floor(Math.random() * (max - min + 1) + min);
+    }
+    static toBase64(texto) {
+        return Buffer.from(texto, 'utf8').toString('base64');
+    }
+    static fromBase64(texto) {
+        return Buffer.from(texto, "base64").toString('utf8');
+    }
+    static getNameParts() {
+        const ahora = new Date();
+        const epochText = ahora.getTime() + "";
+        return {
+            year: ahora.getFullYear(),
+            month: ('0' + (ahora.getMonth() + 1)).slice(-2),
+            day: ('0' + ahora.getDate()).slice(-2),
+            hours: ('0' + ahora.getHours()).slice(-2),
+            minutes: ('0' + ahora.getMinutes()).slice(-2),
+            seconds: ('0' + ahora.getSeconds()).slice(-2),
+            millis: ('00' + ahora.getMilliseconds()).slice(-3),
+            epoch: epochText,
+            hash: md5(epochText),
+        };
+    }
+}

package/srv/common/MimeTypeMap.mjs

@@ -0,0 +1,142 @@
+export const EXTENSION_MAP = {
+  abs: "audio/x-mpeg",
+  ai: "application/postscript",
+  aif: "audio/x-aiff",
+  aifc: "audio/x-aiff",
+  aiff: "audio/x-aiff",
+  aim: "application/x-aim",
+  art: "image/x-jg",
+  asf: "video/x-ms-asf",
+  asx: "video/x-ms-asf",
+  au: "audio/basic",
+  avi: "video/x-msvideo",
+  avx: "video/x-rad-screenplay",
+  bcpio: "application/x-bcpio",
+  bin: "application/octet-stream",
+  bmp: "image/bmp",
+  body: "text/html",
+  cdf: "application/x-cdf",
+  cer: "application/x-x509-ca-cert",
+  class: "application/java",
+  cpio: "application/x-cpio",
+  csh: "application/x-csh",
+  css: "text/css",
+  dib: "image/bmp",
+  doc: "application/msword",
+  dtd: "text/plain",
+  dv: "video/x-dv",
+  dvi: "application/x-dvi",
+  eps: "application/postscript",
+  etx: "text/x-setext",
+  exe: "application/octet-stream",
+  gif: "image/gif",
+  gtar: "application/x-gtar",
+  gz: "application/x-gzip",
+  hdf: "application/x-hdf",
+  hqx: "application/mac-binhex40",
+  htc: "text/x-component",
+  htm: "text/html",
+  html: "text/html",
+  ief: "image/ief",
+  jad: "text/vnd.sun.j2me.app-descriptor",
+  jar: "application/octet-stream",
+  java: "text/plain",
+  jnlp: "application/x-java-jnlp-file",
+  jpe: "image/jpeg",
+  jpeg: "image/jpeg",
+  jpg: "image/jpeg",
+  js: "text/javascript",
+  kar: "audio/x-midi",
+  latex: "application/x-latex",
+  m3u: "audio/x-mpegurl",
+  mac: "image/x-macpaint",
+  man: "application/x-troff-man",
+  me: "application/x-troff-me",
+  mid: "audio/x-midi",
+  midi: "audio/x-midi",
+  mif: "application/x-mif",
+  mjs: "text/javascript",
+  mov: "video/quicktime",
+  movie: "video/x-sgi-movie",
+  mp1: "audio/x-mpeg",
+  mp2: "audio/x-mpeg",
+  mp3: "audio/x-mpeg",
+  mpa: "audio/x-mpeg",
+  mpe: "video/mpeg",
+  mpeg: "video/mpeg",
+  mpega: "audio/x-mpeg",
+  mpg: "video/mpeg",
+  mpv2: "video/mpeg2",
+  ms: "application/x-wais-source",
+  nc: "application/x-netcdf",
+  oda: "application/oda",
+  pbm: "image/x-portable-bitmap",
+  pct: "image/pict",
+  pdf: "application/pdf",
+  pgm: "image/x-portable-graymap",
+  pic: "image/pict",
+  pict: "image/pict",
+  pls: "audio/x-scpls",
+  png: "image/png",
+  pnm: "image/x-portable-anymap",
+  pnt: "image/x-macpaint",
+  ppm: "image/x-portable-pixmap",
+  ps: "application/postscript",
+  psd: "image/x-photoshop",
+  qt: "video/quicktime",
+  qti: "image/x-quicktime",
+  qtif: "image/x-quicktime",
+  ras: "image/x-cmu-raster",
+  rgb: "image/x-rgb",
+  rm: "application/vnd.rn-realmedia",
+  roff: "application/x-troff",
+  rtf: "application/rtf",
+  rtx: "text/richtext",
+  sh: "application/x-sh",
+  shar: "application/x-shar",
+  smf: "audio/x-midi",
+  snd: "audio/basic",
+  src: "application/x-wais-source",
+  sv4cpio: "application/x-sv4cpio",
+  sv4crc: "application/x-sv4crc",
+  svg: "image/svg+xml",
+  swf: "application/x-shockwave-flash",
+  t: "application/x-troff",
+  tar: "application/x-tar",
+  tcl: "application/x-tcl",
+  tex: "application/x-tex",
+  texi: "application/x-texinfo",
+  texinfo: "application/x-texinfo",
+  tif: "image/tiff",
+  tiff: "image/tiff",
+  tr: "application/x-troff",
+  tsv: "text/tab-separated-values",
+  txt: "text/plain",
+  ulw: "audio/basic",
+  ustar: "application/x-ustar",
+  xbm: "image/x-xbitmap",
+  xpm: "image/x-xpixmap",
+  xwd: "image/x-xwindowdump",
+  wav: "audio/x-wav",
+  wbmp: "image/vnd.wap.wbmp",
+  wml: "text/vnd.wap.wml",
+  wmlc: "application/vnd.wap.wmlc",
+  wmls: "text/vnd.wap.wmlscript",
+  wmlscriptc: "application/vnd.wap.wmlscriptc",
+  wrl: "x-world/x-vrml",
+  Z: "application/x-compress",
+  z: "application/x-compress",
+  zip: "application/zip",
+};
+
+export function guessMimeType(path) {
+  const partesExt = /[.]([^/.]+)$/.exec(path);
+  if (partesExt == null) {
+    return "application/octet-stream";
+  }
+  const guessed = EXTENSION_MAP[partesExt[1]];
+  if (guessed != undefined) {
+    return guessed;
+  }
+  return "application/octet-stream";
+}