@ejfdelgado/ejflab-back 1.1.0

package/srv/SocketIOCall.mjs

@@ -0,0 +1,494 @@
+import { CallUserProcessor } from "./callprocessors/CallUserProcessor.mjs";
+import { MakeAnswerProcessor } from "./callprocessors/MakeAnswerProcessor.mjs";
+import { Mutex } from 'async-mutex';
+import { AskRoomProcessor } from "./callprocessors/AskRoomProcessor.mjs";
+import { ClientChangeProcessor } from "./callprocessors/ClientChangeProcessor.mjs";
+import { MyTuples } from "@ejfdelgado/ejflab-common/src/MyTuples.js";
+import { SimpleObj } from "@ejfdelgado/ejflab-common/src/SimpleObj.js";
+import { IdGen } from "@ejfdelgado/ejflab-common/src/IdGen.js";
+import { GetModelProcessor } from "./callprocessors/GetModelProcessor.mjs";
+import { LoadFlowChartProcessor } from "./callprocessors/LoadFlowChartProcessor.mjs";
+import { DestroyModelProcessor } from "./callprocessors/DestroyModelProcessor.mjs";
+import { OnIceCandidateProcessor } from "./callprocessors/OnIceCandidateProcessor.mjs";
+import { AskIceServersProcessor } from "./callprocessors/AskIceServersProcessor.mjs";
+import EventEmitter from 'node:events';
+import { StartFlowChartProcessor } from "./callprocessors/StartFlowChartProcessor.mjs";
+import { StopFlowChartProcessor } from "./callprocessors/StopFlowChartProcessor.mjs";
+import { RegisterSourceProcessor } from "./callprocessors/RegisterSourceProcessor.mjs";
+import { DisconnectProcessor } from "./callprocessors/DisconnectProcessor.mjs";
+import { CheckSrcResponseProcessor } from "./callprocessors/CheckSrcResponseProcessor.mjs";
+import { PauseFlowChartProcessor } from "./callprocessors/PauseFlowChartProcessor.mjs";
+import { ReadSrcResponseProcessor } from "./callprocessors/ReadSrcResponseProcessor.mjs";
+import { RegisterProcessorProcessor } from "./callprocessors/RegisterProcessorProcessor.mjs";
+import { ProcessResponseProcessor } from "./callprocessors/ProcessResponseProcessor.mjs";
+import { SubscribemeProcessor } from "./callprocessors/SubscribemeProcessor.mjs";
+import { SendChatProcessor } from "./callprocessors/SendChatProcessor.mjs";
+import { UpdateMyInformationProcessor } from "./callprocessors/UpdateMyInformationProcessor.mjs";
+import axios from "axios";
+import { encode, decode } from "@msgpack/msgpack";
+import { ChatSetSawProcessor } from "./callprocessors/ChatSetSawProcessor.mjs";
+import { MilvusSrv } from "./MilvusSrv.mjs";
+import { MongoSrv } from "./MongoSrv.mjs";
+import { MinioSrv } from "./MinioSrv.mjs";
+import { OpenVideoChatProcessor } from "./callprocessors/OpenVideoChatProcessor.mjs";
+import { CloseVideoChatProcessor } from "./callprocessors/CloseVideoChatProcessor.mjs";
+import { IncludeOtherPeersProcessor } from "./callprocessors/IncludeOtherPeersProcessor.mjs";
+
+export class SocketIOCall {
+    static io;
+    static mutex = new Mutex();
+
+    static mapSockets = {};
+    static socketToRoom = {};
+    static roomLiveTupleModel = {};
+    static mapFlowChartExec = {};
+    static socketIdToSocket = {};
+    static socketRoomUUIDMap = {};
+
+    static echoLog(message) {
+        console.log(message);
+        SocketIOCall.io.emit('echoLog', { message });
+    }
+
+    static setFlowChartExec(room, instance) {
+        this.mapFlowChartExec[room] = instance;
+        instance.setSuperContext(this);
+    }
+
+    static getAxios() {
+        return axios;
+    }
+
+    static getMilvusClient() {
+        return MilvusSrv;
+    }
+
+    static getMongoClient() {
+        return MongoSrv;
+    }
+
+    static getMinioClient() {
+        return MinioSrv;
+    }
+
+    static async autoCreateRoomFlowChart(room) {
+        console.log(`autoCreateRoomFlowChart ${room}`);
+        const root_folder = process.env.WORKSPACE;
+        const payload = {
+            names: {},
+            conf: {
+                debug: false,
+                sleep: 100
+            },
+            dataPath: {
+                "state.processors": `${root_folder}/flowcharts/processors/processors.json`,
+            },
+            skipValidation: true,
+            room,
+        };
+        const socket = null;
+        await new LoadFlowChartProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        return this.mapFlowChartExec[room];
+    }
+
+    static async getFlowChartExec(room) {
+        let created = this.mapFlowChartExec[room];
+        const AUTO_ROOMS = ["processors"];
+        if (!created && AUTO_ROOMS.indexOf(room) >= 0) {
+            created = await SocketIOCall.autoCreateRoomFlowChart(room);
+        }
+        return created;
+    }
+
+    static getRoomLiveTupleModel(room, rebuild = false) {
+        const builderConfig = {
+            MAX_SEND_SIZE: 10000,
+            LOW_PRESSURE_MS: 0,
+            // No tiene sentido porque como la actualización es asincrona, nunca se sabe si falló
+            BACK_OFF_MULTIPLIER: 100,
+        };
+        let actual = SocketIOCall.roomLiveTupleModel[room];
+        if (!actual || rebuild) {
+            //console.log(`Creating room model builder... ${room}`);
+            actual = {
+                model: {},
+            };
+            const builder = MyTuples.getBuilder(builderConfig);
+            builder.setProcesor((changes) => {
+                changes.orig = "server";
+                SocketIOCall.io.to(room).emit("clientChange", changes);
+            });
+            builder.build(actual.model);
+            builder.end();
+            actual.statusEmitter = new EventEmitter();
+            builder.addActivityListener((status) => {
+                actual.statusEmitter.emit("status", status);
+            });
+            actual.builder = builder;
+            SocketIOCall.roomLiveTupleModel[room] = actual;
+        }
+        return actual;
+    }
+
+    static async registerSocket(socket) {
+        console.log("registerSocket...");
+        SocketIOCall.socketIdToSocket[socket.id] = socket;
+        const headers = SocketIOCall.getCustomHeaders(socket);
+        const room = headers.room;
+        const release = await SocketIOCall.mutex.acquire();
+        let currentList = SocketIOCall.mapSockets[room];
+        SocketIOCall.socketToRoom[socket.id] = room;
+        if (!currentList) {
+            currentList = [socket.id];
+            SocketIOCall.mapSockets[room] = currentList;
+        } else {
+            if (currentList.indexOf(socket.id) < 0) {
+                currentList.push(socket.id);
+            }
+        }
+        // Assure room existence
+        if (!(room in SocketIOCall.socketRoomUUIDMap)) {
+            SocketIOCall.socketRoomUUIDMap[room] = {};
+        }
+        const myUUID = headers.uuid;
+        if (typeof myUUID == "string" && myUUID !== "null") {
+            SocketIOCall.socketRoomUUIDMap[room][myUUID] = socket.id;
+        }
+        console.log(JSON.stringify(SocketIOCall.socketRoomUUIDMap, null, 4));
+        release();
+        console.log(`${socket.id} joins ${headers.room}`);
+        socket.join(headers.room);
+        SocketIOCall.getRoomLiveTupleModel(room);
+    }
+
+    static getSocketIdFromRoomAndUUID(room, uuid) {
+        const roomMap = SocketIOCall.socketRoomUUIDMap[room];
+        if (!roomMap) {
+            return null;
+        }
+        return roomMap[uuid];
+    }
+
+    static async unregisterSocket(socket) {
+        delete SocketIOCall.socketIdToSocket[socket.id];
+        const headers = SocketIOCall.getCustomHeaders(socket);
+        const room = headers.room;
+        const release = await SocketIOCall.mutex.acquire();
+        let currentList = SocketIOCall.mapSockets[room];
+        if (currentList) {
+            currentList = currentList.filter((elem) => {
+                return elem != socket.id;
+            });
+            SocketIOCall.mapSockets[room] = currentList;
+        }
+        if (room in SocketIOCall.socketRoomUUIDMap) {
+            if (headers.uuid in SocketIOCall.socketRoomUUIDMap[room]) {
+                delete SocketIOCall.socketRoomUUIDMap[room][headers.uuid];
+            }
+            if (Object.keys(SocketIOCall.socketRoomUUIDMap[room]).length == 0) {
+                delete SocketIOCall.socketRoomUUIDMap[room];
+            }
+            console.log(JSON.stringify(SocketIOCall.socketRoomUUIDMap, null, 4));
+        }
+        release();
+    }
+
+    static getCustomHeaders(socket) {
+        const headersKey = ["room", "uuid"];
+        const headers = socket.handshake.headers;
+        const response = {};
+        headersKey.forEach((key) => {
+            response[key] = headers[key];
+        });
+        return response;
+    }
+
+    static async checkAndNotifyRoomPeers(socket) {
+        await SocketIOCall.registerSocket(socket);
+        // Le digo a los que están en el room quién llegó
+        const headers = SocketIOCall.getCustomHeaders(socket);
+        SocketIOCall.io.to(headers.room).emit("updateUserList", {
+            socketIds: SocketIOCall.mapSockets[headers.room]
+        });
+    }
+
+    static async sendCurrentModel(socket) {
+        //console.log(`Emmit to ${socket.id} model!`);
+        const headers = SocketIOCall.getCustomHeaders(socket);
+        const room = headers.room;
+        const dataRoom = SocketIOCall.getRoomLiveTupleModel(room);
+        // Le notifico el modelo actual
+        SocketIOCall.io.to(socket.id).emit("setModel", {
+            model: dataRoom.model
+        });
+    }
+
+    static getRoomFromSocket(socket) {
+        return SocketIOCall.socketToRoom[socket.id]
+    }
+
+    static async connect(socket) {
+        SocketIOCall.echoLog(`connect... ${socket.id}`);
+
+        await SocketIOCall.checkAndNotifyRoomPeers(socket);
+
+        socket.on("callUser", (payload) => {
+            SocketIOCall.echoLog(`${socket.id} sends callUser`);
+            new CallUserProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+        socket.on("makeAnswer", (payload) => {
+            SocketIOCall.echoLog(`${socket.id} sends makeAnswer`);
+            new MakeAnswerProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+        socket.on("onicecandidate", (payload) => {
+            SocketIOCall.echoLog(`${socket.id} sends onicecandidate`);
+            new OnIceCandidateProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+        socket.on("disconnect", (payload) => {
+            SocketIOCall.echoLog(`${socket.id} sends disconnect with ${JSON.stringify(payload)}`);
+            new DisconnectProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+            SocketIOCall.disconnect(socket);
+        });
+        /*
+        socket.on("reconnect", (payload) => {
+            SocketIOCall.echoLog(`${socket.id} sends reconnect with ${JSON.stringify(payload)}`);
+            SocketIOCall.sendCurrentModel();
+        });*/
+        socket.on("askRoom", (payload) => {
+            SocketIOCall.echoLog(`${socket.id} sends askRoom with ${JSON.stringify(payload)}`);
+            new AskRoomProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+        socket.on("clientChange", (payload) => {
+            new ClientChangeProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+        socket.on("getModel", (payload) => {
+            new GetModelProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+        socket.on("loadFlowchart", (payload) => {
+            SocketIOCall.echoLog(`${socket.id} sends loadFlowchart with ${JSON.stringify(payload)}`);
+            new LoadFlowChartProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+        socket.on("startFlowChart", (payload) => {
+            SocketIOCall.echoLog(`${socket.id} sends startFlowChart with ${JSON.stringify(payload)}`);
+            new StartFlowChartProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+        socket.on("stopFlowChart", (payload) => {
+            SocketIOCall.echoLog(`${socket.id} sends stopFlowChart with ${JSON.stringify(payload)}`);
+            new StopFlowChartProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+        socket.on("pauseFlowChart", (payload) => {
+            SocketIOCall.echoLog(`${socket.id} sends pauseFlowChart with ${JSON.stringify(payload)}`);
+            new PauseFlowChartProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+        socket.on("destroyModel", (payload) => {
+            SocketIOCall.echoLog(`${socket.id} sends destroyModel with ${JSON.stringify(payload)}`);
+            new DestroyModelProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+        socket.on("askiceservers", (payload) => {
+            SocketIOCall.echoLog(`${socket.id} sends askiceservers with ${JSON.stringify(payload)}`);
+            new AskIceServersProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+        socket.on("registerSource", (payload) => {
+            SocketIOCall.echoLog(`${socket.id} sends registerSource with ${JSON.stringify(payload)}`);
+            new RegisterSourceProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+        socket.on("registerProcessor", (payload) => {
+            SocketIOCall.echoLog(`${socket.id} sends registerProcessor with ${JSON.stringify(payload)}`);
+            new RegisterProcessorProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+
+        socket.on("checkSrcResponse", (payload) => {
+            //SocketIOCall.echoLog(`${socket.id} sends checkSrcResponse with ${JSON.stringify(payload)}`);
+            new CheckSrcResponseProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+        socket.on("readSrcResponse", (payload) => {
+            //SocketIOCall.echoLog(`${socket.id} sends readSrcResponse with ${JSON.stringify(payload)}`);
+            new ReadSrcResponseProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+        socket.on("processResponse", (payload) => {
+            //SocketIOCall.echoLog(`${socket.id} sends processResponse with ${JSON.stringify(payload)}`);
+            new ProcessResponseProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+        socket.on("subscribeme", (payload) => {
+            SocketIOCall.echoLog(`${socket.id} sends subscribeme with ${JSON.stringify(payload)}`);
+            new SubscribemeProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+        socket.on("sendChat", (payload) => {
+            //SocketIOCall.echoLog(`${socket.id} sends sendChat with ${JSON.stringify(payload)}`);
+            new SendChatProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+        socket.on("updateMyInformation", (payload) => {
+            //SocketIOCall.echoLog(`${socket.id} sends updateMyInformation with ${JSON.stringify(payload)}`);
+            new UpdateMyInformationProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+        socket.on("chatSetSawProcessor", (payload) => {
+            //SocketIOCall.echoLog(`${socket.id} sends chatSetSawProcessor with ${JSON.stringify(payload)}`);
+            new ChatSetSawProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+        socket.on("openVideoChat", (payload) => {
+            //SocketIOCall.echoLog(`${socket.id} sends openVideoChat with ${JSON.stringify(payload)}`);
+            new OpenVideoChatProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+        socket.on("closeVideoChat", (payload) => {
+            //SocketIOCall.echoLog(`${socket.id} sends closeVideoChat with ${JSON.stringify(payload)}`);
+            new CloseVideoChatProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+        socket.on("includeOtherPeers", (payload) => {
+            //SocketIOCall.echoLog(`${socket.id} sends includeOtherPeers with ${JSON.stringify(payload)}`);
+            new IncludeOtherPeersProcessor(SocketIOCall, SocketIOCall.io, socket).execute(payload);
+        });
+    }
+
+    static async disconnect(socket) {
+        const headers = SocketIOCall.getCustomHeaders(socket);
+        // Lo saco de la lista en memoria
+        await SocketIOCall.unregisterSocket(socket);
+        SocketIOCall.io.to(headers.room).emit("removeUser", {
+            socketId: socket.id
+        });
+    }
+
+    static handle(io) {
+        SocketIOCall.io = io;
+        SocketIOCall.getFlowChartExec("processors");
+        io.on("connection", SocketIOCall.connect);
+        return () => { }
+    }
+
+    static async processorResponse(req, res, next) {
+        const buffer = req.body;
+        const decoded = decode(buffer);
+        await new ProcessResponseProcessor(SocketIOCall, SocketIOCall.io, null).execute(decoded);
+        res.status(200).send({
+            status: "ok",
+        });
+    }
+
+    static async loadFlowChart(req, res, next) {
+        const buffer = req.body;
+        await new LoadFlowChartProcessor(SocketIOCall, SocketIOCall.io, null).execute(buffer);
+        if (buffer.autoStart === true) {
+            new StartFlowChartProcessor(SocketIOCall, SocketIOCall.io, null).execute(buffer);
+        }
+        res.status(200).send({
+            status: "ok",
+        });
+    }
+
+    static async processorProcess(req, res, next) {
+        console.log(`processorProcess...`);
+        const buffer = req.body;
+
+        let decoded = buffer;
+        if (/\/processor_process$/.exec(req.path) != null) {
+            decoded = decode(buffer);
+        }
+        //console.log(decoded);
+        const { processorMethod, room, channel } = decoded;
+        const parts = /(^[^\d\.]+)(\d*)\.(.*)$/.exec(processorMethod);
+        if (!parts) {
+            throw Error(`processorMethod ${processorMethod} does not matches /(^[^\d\.]+)(\d*)\.(.*)$/`);
+        }
+        const processor = parts[1];
+        const instance = parts[2];
+        decoded['method'] = parts[3];
+
+        // Get socket destiny if channel is websocket
+        let socketId = null;
+        let postUrl = null;
+        const processorsModel = SocketIOCall.getRoomLiveTupleModel("processors");
+        if (channel == "websocket") {
+            const path = `model.data.state.processors.${processor}.socket`;
+            socketId = SimpleObj.getValue(processorsModel, path, null);
+            if (!socketId) {
+                throw Error(`Not processor with valid socketId for ${processor}`);
+            }
+        } else if (channel == "post") {
+            const path = `model.data.state.processors.${processor}.postUrl`;
+            postUrl = SimpleObj.getValue(processorsModel, path, null);
+            if (!postUrl) {
+                throw Error(`Not processor with postUrl for ${processor}`);
+            }
+        }
+
+        // Complete data if room provided, room is optional
+        if (room) {
+            const allModel = SocketIOCall.getRoomLiveTupleModel(room);
+            const pathData = `model.data.state.processors.${processor}.${instance}`;
+            const temp = SimpleObj.getValue(allModel, pathData, null);
+            if (decoded['data']) {
+                if (temp) {
+                    Object.assign(decoded['data'], temp);
+                }
+            } else {
+                decoded['data'] = temp;
+            }
+        }
+
+        const messageUID = IdGen.num2ord(new Date().getTime());
+
+        if (!decoded['id']) {
+            decoded['id'] = `${processorMethod}-${messageUID}`;
+        }
+
+        let promesa = Promise.resolve({});
+
+        if (channel == "websocket") {
+            promesa = new Promise((resolve, reject) => {
+                const socket = SocketIOCall.socketIdToSocket[socketId];
+                if (!socket) {
+                    reject(`No socket with id ${socketId} for processor ${processor}`);
+                }
+                const listener = (valor) => {
+                    if (valor.id == decoded['id']) {
+                        socket.off("processResponse", listener);
+                        resolve(valor);
+                    }
+                };
+                socket.on("processResponse", listener);
+            });
+            SocketIOCall.io.to(socketId).emit("process", decoded);
+        } else if (channel == "post") {
+            const options = {
+                maxBodyLength: Infinity,
+                maxContentLength: Infinity,
+                headers: { "Content-Type": "application/octet-stream" }
+            };
+            const encoded = encode(decoded);
+            const buffer = Buffer.from(encoded);
+            console.log(`POST to ${postUrl}...`);
+            const temp = await axios.post(`${postUrl}/syncprocess`, buffer, options);
+            console.log(`POST to ${postUrl}... OK!`);
+            promesa = Promise.resolve({ data: temp.data });
+        }
+
+
+        const respuesta = await promesa;
+        res.status(200).send({
+            status: "ok",
+            response: respuesta
+        });
+    }
+
+    static async introspect(req, res, next) {
+        const body = req.body;
+        const rooms = Object.keys(SocketIOCall.roomLiveTupleModel);
+        const path = `model.data.scope.progress`;
+        const data = rooms.map((room) => {
+            const modelo = SocketIOCall.roomLiveTupleModel[room];
+            const progress = SimpleObj.getValue(modelo, path, null);
+            return {
+                room: room,
+                percentage: progress
+            };
+        }).filter((data) => {
+            return typeof data.percentage == "number" && ["processors", "public"].indexOf(data.room) < 0;
+        });
+
+        const response = {
+            status: "ok",
+            response: data
+        };
+        res.status(200).send(response);
+    }
+}

package/srv/TupleSrv.mjs

@@ -0,0 +1,141 @@
+import { MyStore } from "./common/MyStore.mjs";
+import { MalaPeticionException, NoExisteException } from "./MyError.mjs";
+import { General } from "./common/General.mjs";
+import MyDatesBack from "@ejfdelgado/ejflab-common/src/MyDatesBack.mjs";
+import { KeysSrv } from "./KeysSrv.mjs";
+
+const TUPLE_TYPE = "tuple";
+const TUPLE_TEMP_TYPE = "tuple-temp";
+const MAX_READ_SIZE = 60;
+
+/*
+{
+    id: "${pageId}:${actual.k}",
+    v: { },
+    act: YYYYMMddHHmmSSmmm,
+    cre: YYYYMMddHHmmSSmmm
+}
+*/
+export class TupleSrv {
+
+    static async deleteAll(req, res, next) {
+        const pageId = req.params['pageId'];
+        const { max, offset } = General.readMaxOffset(req, MAX_READ_SIZE);
+        if (!pageId) {
+            throw new MalaPeticionException("Falta el id");
+        }
+        // Se debe validar el permiso de borrado
+        // TODO
+
+        // Se debe realizar la lectura como tal
+        const where = [
+            { key: "pg", oper: "==", value: pageId },
+        ];
+        const response = await MyStore.paginate(TUPLE_TYPE, [{ name: "act", dir: 'asc' }], offset, max, where);
+
+        const batch = MyStore.getBatch();
+        for (let i = 0; i < response.length; i++) {
+            const actual = response[i];
+            MyStore.deleteById(TUPLE_TYPE, actual.id, batch);
+        }
+        // Commit the batch
+        await batch.commit();
+        res.status(200).send({ count: response.length });
+    }
+
+    static async read(req, res, next) {
+        //const AHORA = MyDatesBack.getDayAsContinuosNumberHmmSSmmm(new Date());
+        const AHORA = new Date().getTime();
+        // Se debe leer el parametro id, offset, max
+        const pageId = req.params['pageId'];
+        const { max, offset } = General.readMaxOffset(req, MAX_READ_SIZE);
+
+        if (!pageId) {
+            throw new MalaPeticionException("Falta el id");
+        }
+
+        // Se debe validar el permiso de lectura
+        // TODO
+
+        // Se debe realizar la lectura como tal
+        const where = [
+            { key: "pg", oper: "==", value: pageId },
+        ];
+        const response = await MyStore.paginate(TUPLE_TYPE, [{ name: "act", dir: 'asc' }], offset, max, where);
+        for (let i = 0; i < response.length; i++) {
+            const actual = response[i];
+        }
+        res.status(200).send({
+            t: AHORA,
+            payload: response,
+        });
+    }
+    static async save(req, res, next) {
+        const token = res.locals.token;
+        //const AHORA = MyDatesBack.getDayAsContinuosNumberHmmSSmmm(new Date());
+        const AHORA = new Date().getTime();
+        // Se debe leer el parametro id y body
+        const pageId = req.params['pageId'];
+        const live = General.readParam(req, "live");
+        const secret = General.readParam(req, "secret");
+        const body = General.readParam(req, "body", undefined);
+
+        if (!pageId) {
+            throw new MalaPeticionException("Falta el id");
+        }
+        if (body === undefined) {
+            throw new MalaPeticionException("Falta el body");
+        }
+
+        // Se debe validar el permiso de esritura
+        // TODO
+
+        const batch = MyStore.getBatch();
+        // Se deben escribir los borrados
+        const borrados = body["-"];
+        for (let i = 0; i < borrados.length; i++) {
+            const actual = borrados[i];
+            MyStore.deleteById(TUPLE_TYPE, `${pageId}:${actual.k}`, batch);
+        }
+        // Se deben escribir las adiciones
+        const adiciones = body["+"];
+        for (let i = 0; i < adiciones.length; i++) {
+            const actual = adiciones[i];
+            const payload = {
+                v: actual.v,
+                act: AHORA,
+                cre: AHORA,
+                pg: pageId,
+                k: actual.k,
+            };
+            MyStore.createById(TUPLE_TYPE, `${pageId}:${actual.k}`, payload, batch);
+        }
+
+        // Se deben escribir las actualizaciones
+        const actualizaciones = body["*"];
+        for (let i = 0; i < actualizaciones.length; i++) {
+            const actual = actualizaciones[i];
+            const payload = {
+                v: actual.v,
+                act: AHORA,
+            };
+            MyStore.updateOrCreateById(TUPLE_TYPE, `${pageId}:${actual.k}`, payload, batch);
+        }
+
+        // Place the live changes
+        if (live == "1") {
+            let nuevo = {};
+            if (secret == "1") {
+                const cifrado = await KeysSrv.cifrar(body, pageId);
+                nuevo = { pg: pageId, cifrado, who: token.uid, t: AHORA };
+            } else {
+                nuevo = { pg: pageId, body, who: token.uid, t: AHORA };
+            }
+            MyStore.createById(TUPLE_TEMP_TYPE, `${pageId}:${token.uid}`, nuevo, batch);
+        }
+
+        // Commit the batch
+        await batch.commit();
+        res.status(204).send();
+    }
+}

package/srv/UtilesSrv.mjs

@@ -0,0 +1,8 @@
+
+export class UtilesSrv {
+  static async fecha(req, res) {
+    const ans = {};
+    ans["unixtime"] = new Date().getTime();
+    res.status(200).json(ans).end();
+  }
+}

package/srv/callprocessors/AskIceServersProcessor.mjs

@@ -0,0 +1,14 @@
+import fs from "fs";
+import { GenericProcessor } from "./GenericProcessor.mjs";
+
+export class AskIceServersProcessor extends GenericProcessor {
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+    execute(args) {
+        // Reads from credentilas file...
+        const text = fs.readFileSync(`./credentials/webrtcconfig.json`, 'utf8');
+        const parsed = JSON.parse(text);
+        this.io.to(this.socket.id).emit("oniceservers", parsed);
+    }
+}

package/srv/callprocessors/AskRoomProcessor.mjs

@@ -0,0 +1,15 @@
+import { GenericProcessor } from "./GenericProcessor.mjs";
+
+
+export class AskRoomProcessor extends GenericProcessor {
+    constructor(context, io, socket) {
+        super(context, io, socket);
+    }
+    execute(args) {
+        const headers = this.context.getCustomHeaders(this.socket);
+        this.io.to(this.socket.id).emit("updateUserList", {
+            socketIds: this.context.mapSockets[headers.room]
+        });
+        this.context.sendCurrentModel(this.socket);
+    }
+}