@ejfdelgado/ejflab-back 1.1.0

package/srv/callprocessors/CallUserProcessor.mjs

@@ -0,0 +1,17 @@
+import { GenericProcessor } from "./GenericProcessor.mjs";
+
+
+export class CallUserProcessor extends GenericProcessor {
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+    execute(args) {
+        console.log(`CallUserProcessor... to ${args.to}`);
+        //console.log(JSON.stringify(args, null, 4));
+        // Redirects to other:
+        this.io.to(args.to).emit("callMade", {
+            offer: args.offer,
+            socket: this.socket.id,
+        });
+    }
+}

package/srv/callprocessors/ChatSetSawProcessor.mjs

@@ -0,0 +1,42 @@
+import { GenericProcessor } from "./GenericProcessor.mjs";
+
+
+export class ChatSetSawProcessor extends GenericProcessor {
+    MAX_COUNT_TIMESTAMS = 6;
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+    execute(args) {
+        const now = new Date().getTime();
+        const { author } = args;
+        const room = this.context.getRoomFromSocket(this.socket);
+        // Also notify last message time
+        const roomPublicData = this.context.getRoomLiveTupleModel("public");
+        if (roomPublicData.model.data) {
+            let lastmsg = roomPublicData.model.data.lastmsg;
+            if (!lastmsg) {
+                lastmsg = {};
+                roomPublicData.model.data.lastmsg = lastmsg;
+                lastmsg[room] = {}
+            }
+            let tiempos = lastmsg[room][author];
+            if (!tiempos) {
+                tiempos = {
+                    last: now,
+                };
+                lastmsg[room][author] = tiempos;
+            } else {
+                tiempos.last = now;
+            }
+            const changePaths = [
+                "data",
+                "data.lastmsg",
+                `data.lastmsg.${room}`,
+                `data.lastmsg.${room}.${author}`,
+                `data.lastmsg.${room}.${author}.last`
+            ];
+            let changes2 = roomPublicData.builder.trackDifferences(roomPublicData.model, [], null, changePaths);
+            roomPublicData.model = roomPublicData.builder.affect(changes2);
+        }
+    }
+}

package/srv/callprocessors/CheckSrcResponseProcessor.mjs

@@ -0,0 +1,28 @@
+import { SimpleObj } from "@ejfdelgado/ejflab-common/src/SimpleObj.js";
+import { GenericProcessor } from "./GenericProcessor.mjs";
+
+
+export class CheckSrcResponseProcessor extends GenericProcessor {
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+    async execute(args) {
+        const { uid, metadata } = args;
+        const room = this.context.getRoomFromSocket(this.socket);
+        const instance = await this.context.getFlowChartExec(room);
+        if (!instance) {
+            return;
+        }
+        const roomData = this.context.getRoomLiveTupleModel(room);
+        roomData.model.data = instance.getData();
+        const configuration = SimpleObj.getValue(roomData.model, `data.state.sources.${uid}.data`, null);
+        if (configuration) {
+            for (let key in metadata) {
+                const oldData = configuration[key];
+                oldData.metadata = metadata[key];
+            }
+            let changes = roomData.builder.trackDifferences(roomData.model, [], null, ["data", "data.state", "data.state.sources", `data.state.sources.${uid}`]);
+            roomData.model = roomData.builder.affect(changes);
+        }
+    }
+}

package/srv/callprocessors/ClientChangeProcessor.mjs

@@ -0,0 +1,19 @@
+import { GenericProcessor } from "./GenericProcessor.mjs";
+
+
+export class ClientChangeProcessor extends GenericProcessor {
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+    execute(args) {
+        const { changes } = args;
+        const socketId = this.socket.id;
+        const room = this.context.socketToRoom[socketId];
+        // Apply to local model
+        const roomData = this.context.getRoomLiveTupleModel(room);
+        roomData.model = roomData.builder.affect(changes);
+        //Share to others the change
+        //console.log(`emit to ${room} clientChange ${JSON.stringify(changes)}`);
+        this.io.to(room).emit("clientChange", changes);
+    }
+}

package/srv/callprocessors/CloseVideoChatProcessor.mjs

@@ -0,0 +1,16 @@
+import { GenericProcessor } from "./GenericProcessor.mjs";
+
+
+export class CloseVideoChatProcessor extends GenericProcessor {
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+    execute(args) {
+        console.log(`CloseVideoChatProcessor... to ${args.room}`);
+        //console.log(JSON.stringify(args, null, 4));
+        // Redirects to other:
+        this.io.to(args.room).emit("closeVideoChat", {
+            room: args.room,
+        });
+    }
+}

package/srv/callprocessors/DestroyModelProcessor.mjs

@@ -0,0 +1,16 @@
+import { GenericProcessor } from "./GenericProcessor.mjs";
+
+
+export class DestroyModelProcessor extends GenericProcessor {
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+    execute(args) {
+        const socketId = this.socket.id;
+        const room = this.context.getRoomFromSocket(this.socket);
+        this.context.getRoomLiveTupleModel(room, true);
+        // Emmit to client do the same!
+        this.io.to(room).emit("setModel", { model: {} });
+        this.io.to(room).emit("flowchartUnloaded", {});
+    }
+}

package/srv/callprocessors/DisconnectProcessor.mjs

@@ -0,0 +1,53 @@
+import { GenericProcessor } from "./GenericProcessor.mjs";
+import { SimpleObj } from "@ejfdelgado/ejflab-common/src/SimpleObj.js";
+
+
+export class DisconnectProcessor extends GenericProcessor {
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+
+    clearClientSocket(sources, socketId) {
+        for (let sourceKey in sources) {
+            const source = sources[sourceKey];
+            if (source.socket == socketId) {
+                source.socket = null;
+                break;
+            }
+        }
+    }
+
+    clearPersonFromPeople(people, socketId) {
+        for (let personId in people) {
+            const onePerson = people[personId];
+            if (onePerson.socket == socketId) {
+                delete people[personId]
+                break;
+            }
+        }
+    }
+
+    async execute(args) {
+        const socketId = this.socket.id;
+        // Busco los sources
+        const room = this.context.getRoomFromSocket(this.socket);
+        const instance = await this.context.getFlowChartExec(room);
+        const roomData = this.context.getRoomLiveTupleModel(room);
+        if (instance) {
+            roomData.model.data = instance.getData();
+        }
+        const sources = SimpleObj.getValue(roomData.model, "data.state.sources", {});
+        const processors = SimpleObj.getValue(roomData.model, "data.state.processors", {});
+        this.clearClientSocket(sources, socketId);
+        this.clearClientSocket(processors, socketId);
+        //
+        const people = SimpleObj.getValue(roomData.model, "data.people", null);
+        if (people) {
+            this.clearPersonFromPeople(people, socketId);
+        }
+
+        const observe = ["data", "data.state", "data.state.sources", "data.state.processors", "data.people"];
+        let changes = roomData.builder.trackDifferences(roomData.model, [], null, observe);
+        roomData.model = roomData.builder.affect(changes);
+    }
+}

package/srv/callprocessors/GenericProcessor.mjs

@@ -0,0 +1,7 @@
+export class GenericProcessor {
+    constructor(context, io, socket) {
+        this.context = context;
+        this.io = io;
+        this.socket = socket;
+    }
+}

package/srv/callprocessors/GetModelProcessor.mjs

@@ -0,0 +1,11 @@
+import { GenericProcessor } from "./GenericProcessor.mjs";
+
+
+export class GetModelProcessor extends GenericProcessor {
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+    execute(args) {
+        this.context.sendCurrentModel(this.socket);
+    }
+}

package/srv/callprocessors/IncludeOtherPeersProcessor.mjs

@@ -0,0 +1,12 @@
+import { GenericProcessor } from "./GenericProcessor.mjs";
+
+
+export class IncludeOtherPeersProcessor extends GenericProcessor {
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+    execute(args) {
+        console.log(`IncludeOtherPeersProcessor... to ${args.to}`);
+        this.io.to(args.to).emit("includeOtherPeers", {});
+    }
+}

package/srv/callprocessors/LoadFlowChartProcessor.mjs

@@ -0,0 +1,103 @@
+import { FlowChartExec } from "@ejfdelgado/ejflab-common/src/flowchart/FlowChartExec.js";
+import { GenericProcessor } from "./GenericProcessor.mjs";
+import fs from "fs";
+import { SimpleObj } from "@ejfdelgado/ejflab-common/src/SimpleObj.js";
+import { Buffer } from 'buffer';
+
+const WORKSPACE = process.env.WORKSPACE;
+
+export class LoadFlowChartProcessor extends GenericProcessor {
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+
+    completePaths(objeto) {
+        if (!objeto) {
+            return;
+        }
+        for (let llave in objeto) {
+            let valor = objeto[llave];
+            if (typeof valor == "string") {
+                valor = valor.replaceAll("${WORKSPACE}", WORKSPACE);
+                objeto[llave] = valor;
+            }
+        }
+    }
+
+    async execute(args) {
+        let { names, conf, dataPath, dataVal, room, skipValidation } = args;
+        console.log(`LoadFlowChartProcessor at room ${room}...`);
+        this.completePaths(names);
+        this.completePaths(dataPath);
+        if (!room) {
+            if (this.socket) {
+                room = this.context.getRoomFromSocket(this.socket);
+            } else {
+                room = "public";
+            }
+        }
+        console.log(`Creating flowchart into ${room}`);
+        let instance = null;
+        if (skipValidation === false) {
+            instance = await this.context.getFlowChartExec(room);
+            if (instance && instance.isRunning()) {
+                console.log("It is already running, must stop or pause first.");
+                return;
+            }
+        }
+
+        let data = {};
+        if (dataPath) {
+            const keysData = Object.keys(dataPath);
+            for (let i = 0; i < keysData.length; i++) {
+                const keyData = keysData[i];
+                const dataObject = JSON.parse(fs.readFileSync(dataPath[keyData], 'utf8'));
+                if (keyData.length == 0) {
+                    Object.assign(data, dataObject);
+                } else {
+                    SimpleObj.recreate(data, keyData, dataObject);
+                }
+            }
+        }
+
+        if (dataVal) {
+            const keysDataVal = Object.keys(dataVal);
+            for (let i = 0; i < keysDataVal.length; i++) {
+                const keyData = keysDataVal[i];
+                const dataObject = dataVal[keyData];
+                SimpleObj.recreate(data, keyData, dataObject);
+            }
+        }
+
+        data['scope'] = { room, progress: 0 };
+
+        // Leer el archivo y su data
+        instance = new FlowChartExec();
+        instance.setSocketIO(this.io, room);
+        instance.setConf(conf);
+        instance.setData(data);
+        this.context.setFlowChartExec(room, instance);
+        const flowchart = instance.loadFlowChart(names);
+        // Asignarlo al modelo
+        const roomData = this.context.getRoomLiveTupleModel(room);
+
+        roomData.model.currentNodes = [];
+        roomData.model.history = [];
+        roomData.model.flowchart = flowchart;
+        roomData.model.data = data;
+        roomData.model.version = 0;
+        // So it will be capable to reload from this point
+        roomData.model.request = Buffer.from(JSON.stringify(args), "utf8").toString("base64");
+        const changes = roomData.builder.trackDifferences(roomData.model);
+        roomData.model = roomData.builder.affect(changes);
+
+        // Notify
+        const statusFun = (status) => {
+            if (status === false) {
+                this.io.to(room).emit("flowchartLoaded", {});
+                roomData.statusEmitter.off("status", statusFun);
+            }
+        };
+        roomData.statusEmitter.on("status", statusFun);
+    }
+}

package/srv/callprocessors/MakeAnswerProcessor.mjs

@@ -0,0 +1,17 @@
+import { GenericProcessor } from "./GenericProcessor.mjs";
+
+
+export class MakeAnswerProcessor extends GenericProcessor {
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+    execute(args) {
+        console.log(`MakeAnswerProcessor... to ${args.to}`);
+        //console.log(JSON.stringify(args, null, 4));
+        // Redirects to other:
+        this.io.to(args.to).emit("answerMade", {
+            socket: this.socket.id,
+            answer: args.answer
+        });
+    }
+}

package/srv/callprocessors/OnIceCandidateProcessor.mjs

@@ -0,0 +1,13 @@
+import { GenericProcessor } from "./GenericProcessor.mjs";
+
+
+export class OnIceCandidateProcessor extends GenericProcessor {
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+    execute(args) {
+        // Just redirects to room
+        args.from = this.socket.id;
+        this.io.to(args.to).emit("onicecandidate", args);
+    }
+}

package/srv/callprocessors/OpenVideoChatProcessor.mjs

@@ -0,0 +1,17 @@
+import { GenericProcessor } from "./GenericProcessor.mjs";
+
+
+export class OpenVideoChatProcessor extends GenericProcessor {
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+    execute(args) {
+        console.log(`OpenVideoChatProcessor... to ${args.uuid}`);
+        // Redirects to other:
+        // Translate args.uuid to socketId of args.room
+        const socketId = this.context.getSocketIdFromRoomAndUUID("public", args.uuid);
+        this.io.to(socketId).emit("openVideoChat", {
+            room: args.room,
+        });
+    }
+}

package/srv/callprocessors/PauseFlowChartProcessor.mjs

@@ -0,0 +1,16 @@
+import { GenericProcessor } from "./GenericProcessor.mjs";
+
+export class PauseFlowChartProcessor 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.pause();
+    }
+}

package/srv/callprocessors/ProcessResponseProcessor.mjs

@@ -0,0 +1,123 @@
+import { GenericProcessor } from "./GenericProcessor.mjs";
+import { SimpleObj } from "@ejfdelgado/ejflab-common/src/SimpleObj.js";
+
+export class ProcessResponseProcessor extends GenericProcessor {
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+    async execute(args) {
+        const { processorId, id, data } = args;
+        let room = "";
+        if (args.room) {
+            room = args.room;
+        } else if (this.socket) {
+            room = this.context.getRoomFromSocket(this.socket);
+        }
+
+        if (!room) {
+            console.log(`No room provided`);
+            return;
+        }
+
+        const instance = await this.context.getFlowChartExec(room);
+        if (!instance) {
+            console.log(`No instance found for room ${room}`);
+            return;
+        }
+
+        // Check for ignore timedout messages
+        if (!instance.existsPendingCall(id)) {
+            console.log(`WARNING: Ignoring message id ${id}`);
+            return;
+        }
+
+        // Handling errors
+        if (data["error"]) {
+            console.log(`Processors name ${processorId} returns an error ${JSON.stringify(data["error"])}`);
+            // Halt everything
+            if (!instance.canRetry(id, new Error(data["error"]))) {
+                instance.stop();
+                return;
+            }
+        }
+
+        // Reads output description
+        const roomData = this.context.getRoomLiveTupleModel(room);
+
+        const partsName = /^([^\.\d]+)(\d*)\.?([^'.]*)$/.exec(processorId);
+        if (!partsName) {
+            console.log(`The processor name ${processorId} does not match ^([^\.\d]+)(\d*)\.?([^'.]*)$`);
+            return;
+        }
+        let method = "main";
+        const processorMethod = partsName[0];
+        const processorName = partsName[1];
+        const instanceNumber = partsName[2];
+        let processorInstance = partsName[1];
+        if (typeof partsName[2] == "string") {
+            processorInstance += instanceNumber;
+        }
+        if (typeof partsName[3] == "string" && partsName[3].trim().length > 0) {
+            method = partsName[3];
+        }
+
+        const outputConnectionsConf = SimpleObj.getValue(roomData.model, `flowchart.flux.${processorInstance}.${method}.out`, null);
+        if (!outputConnectionsConf) {
+            console.log(`WARN: No output connection flux configuration for ${processorInstance}.${method}`);
+            //return;
+        }
+
+        roomData.model.data = instance.getData();
+        let countLocalChanges = 0;
+        if (!!outputConnectionsConf) {
+            outputConnectionsConf.forEach((outputConnectionsConfOne) => {
+                const { key, val } = outputConnectionsConfOne;
+                const output = val;
+                const dataLocal = data[key];
+                if (dataLocal != undefined) {
+                    // Sends dataResponse to val
+                    const outputParts = /^(b\.([^.]+)\.([^.]+)|d\.(.+))$/i.exec(output);
+                    if (!outputParts) {
+                        console.log(`${output} does not match ^(b\.([^.]+)\.([^.]+)|d\.(.+))$`);
+                        return;
+                    }
+                    if (!outputParts[4]) {
+                        const processorIdLocal = outputParts[2];
+                        const sourcePath = outputParts[3];
+                        instance.saveBufferData(processorIdLocal, sourcePath, dataLocal);
+                        // Publish to others
+                        const destiny = `${room}.${output}`;
+                        //console.log(`Publishing to ${destiny} ok?`);
+                        this.io.to(destiny).emit("processResponse", {
+                            processorId,
+                            sourcePath,
+                            data: dataLocal
+                        });
+                    } else {
+                        // Affect the model in the given point
+                        const path = outputParts[4];
+                        SimpleObj.recreate(roomData.model.data, path, dataLocal);
+                        countLocalChanges++;
+                        // Publish to others
+                        const destiny = `${room}.d.${path}`;
+                        //console.log(`Publishing to ${destiny} ok?`);
+                        this.io.to(destiny).emit("processResponse", {
+                            processorId,
+                            sourcePath: path,
+                            data: dataLocal
+                        });
+                    }
+                } else {
+                    console.log(`Skip output connection ${val} with no value`);
+                }
+            });
+        }
+
+        if (countLocalChanges > 0) {
+            const changes = roomData.builder.trackDifferences(roomData.model, [], null, ["data"]);
+            roomData.model = roomData.builder.affect(changes);
+        }
+
+        instance.clearPendingCall(id);
+    }
+}

package/srv/callprocessors/ReadSrcResponseProcessor.mjs

@@ -0,0 +1,30 @@
+import { SimpleObj } from "@ejfdelgado/ejflab-common/src/SimpleObj.js";
+import { GenericProcessor } from "./GenericProcessor.mjs";
+
+
+export class ReadSrcResponseProcessor extends GenericProcessor {
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+    async execute(args) {
+        const { response, sourcePair, id } = args;
+        const room = this.context.getRoomFromSocket(this.socket);
+        const instance = await this.context.getFlowChartExec(room);
+        if (!instance) {
+            return;
+        }
+        const sourceId = sourcePair.split(".")[0];
+        for (let sourcePath in response) {
+            const buffer = response[sourcePath];
+            instance.saveBufferData(sourceId, sourcePath, buffer);
+            // Publish to others
+            this.io.to(`${room}.${sourceId}.${sourcePath}`).emit("readSrcResponse", {
+                sourceId,
+                sourcePath,
+                buffer
+            });
+        }
+        instance.clearPendingCall(id);
+
+    }
+}

package/srv/callprocessors/RegisterProcessorProcessor.mjs

@@ -0,0 +1,23 @@
+import { SimpleObj } from "@ejfdelgado/ejflab-common/src/SimpleObj.js";
+import { GenericProcessor } from "./GenericProcessor.mjs";
+
+
+export class RegisterProcessorProcessor extends GenericProcessor {
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+    async execute(args) {
+        const { uid } = args;
+        const room = this.context.getRoomFromSocket(this.socket);
+        const instance = await this.context.getFlowChartExec(room);
+        if (!instance) {
+            console.log(`No flowchart for room ${room}`);
+            return;
+        }
+        const roomData = this.context.getRoomLiveTupleModel(room);
+        roomData.model.data = instance.getData();
+        SimpleObj.recreate(roomData.model, `data.state.processors.${uid}.socket`, this.socket.id);
+        let changes = roomData.builder.trackDifferences(roomData.model, [], null, ["data", "data.state", "data.state.processors"]);
+        roomData.model = roomData.builder.affect(changes);
+    }
+}

package/srv/callprocessors/RegisterSourceProcessor.mjs

@@ -0,0 +1,22 @@
+import { SimpleObj } from "@ejfdelgado/ejflab-common/src/SimpleObj.js";
+import { GenericProcessor } from "./GenericProcessor.mjs";
+
+
+export class RegisterSourceProcessor extends GenericProcessor {
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+    async execute(args) {
+        const { uid } = args;
+        const room = this.context.getRoomFromSocket(this.socket);
+        const instance = await this.context.getFlowChartExec(room);
+        if (!instance) {
+            return;
+        }
+        const roomData = this.context.getRoomLiveTupleModel(room);
+        roomData.model.data = instance.getData();
+        SimpleObj.recreate(roomData.model, `data.state.sources.${uid}.socket`, this.socket.id);
+        let changes = roomData.builder.trackDifferences(roomData.model, [], null, ["data", "data.state", "data.state.sources"]);
+        roomData.model = roomData.builder.affect(changes);
+    }
+}