@ejfdelgado/ejflab-common 1.8.2 → 1.8.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ejfdelgado/ejflab-common",
   "type": "commonjs",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ejfdelgado/ejflab-common.git"

package/src/MyTemplate.js

@@ -194,7 +194,7 @@ class MyTemplate extends CsvWithFilters {
             };
         }
     }
-    render(template, data) {
+    render(template, data, skipUndefined = false) {
 
         let iteration = {};
         do {
@@ -209,19 +209,32 @@ class MyTemplate extends CsvWithFilters {
         } while (iteration.times > 0);
 
         // Replace values
-        return this.replaceBareValues(template, data);
+        return this.replaceBareValues(template, data, undefined, undefined, undefined, false, skipUndefined);
     }
-    replaceBareValues(template, data, open = "\\{", close = "\\}", closeNoScape = "}", useStringify = false) {
+    replaceBareValues(template, data, open = "\\{", close = "\\}", closeNoScape = "}", useStringify = false, skipUndefined = false) {
         const myPattern = new RegExp("\\$\\s*" + open + "([^" + closeNoScape + "]+)\\s*" + close, "g");
         template = template.replace(myPattern, (match, g1) => {
             const response = this.getColumnDescription(g1)[0];
             const valor = SimpleObj.getValue(data, response.id);
             if (!useStringify) {
                 const temp = this.filterValue(valor, response, undefined, response.id);
-                if (typeof temp == "object") {
-                    return JSON.stringify(temp);
+                if (!skipUndefined) {
+                    // Duplicated code...
+                    if (typeof temp == "object") {
+                        return JSON.stringify(temp);
+                    }
+                    return temp;
+                } else {
+                    if (temp === undefined) {
+                        return match;
+                    } else {
+                        // Duplicated code...
+                        if (typeof temp == "object") {
+                            return JSON.stringify(temp);
+                        }
+                        return temp;
+                    }
                 }
-                return temp;
             } else {
                 const temp = this.filterValue(valor, response, undefined, response.id);
                 return JSON.stringify(temp);

package/src/MyTemplate.test.js

@@ -63,7 +63,19 @@ function myTest() {
                 ]
             },
             exp: "Filtrado 3 sí debe salir",
-        }
+        },
+        {
+            txt: "my name is ${name} ${lastname} and I like ${colors.0.id} ${colors.0.id}",
+            data: { lastname: "Delgado" },
+            exp: "my name is ${name} Delgado and I like ${colors.0.id} ${colors.0.id}",
+            skipUndefined: true,
+        },
+        {
+            txt: "my name is ${name} ${lastname} and I like ${colors.0.id} ${colors.0.id}",
+            data: { lastname: "Delgado" },
+            exp: "my name is undefined Delgado and I like undefined undefined",
+            skipUndefined: false,
+        },
     ];
 
     renderer.registerFunction("json", CsvFormatterFilters.json);
@@ -75,7 +87,7 @@ function myTest() {
 
     for (let i = 0; i < cases.length; i++) {
         const myCase = cases[i];
-        const actual = renderer.render(myCase.txt, myCase.data);
+        const actual = renderer.render(myCase.txt, myCase.data, myCase.skipUndefined === true);
         //console.log(actual);
         if (actual !== myCase.exp) {
             throw Error(`expected:\n${myCase.exp}\nactual:\n${actual}`);

package/src/flowchart/FlowChartExec.js

@@ -28,6 +28,7 @@ const { CommandMongo } = require('./steps/CommandMongo');
 const { CommandMinio } = require('./steps/CommandMinio');
 const { CommandPostgres } = require('./steps/CommandPostgres.js');
 const { StepMultiple } = require('./steps/StepMultiple.js');
+const { StepMultipleDone } = require('./steps/StepMultipleDone.js');
 
 class FlowChartExec {
     executionPromise = null;
@@ -61,6 +62,7 @@ class FlowChartExec {
         this.registry["process"] = StepProcess;
         this.registry["require"] = StepCheckProcessor;
         this.registry["multiple"] = StepMultiple;
+        this.registry["multipleDone"] = StepMultipleDone;
 
         // Nodes
         this.registry["inc"] = CommandInc;
@@ -276,11 +278,12 @@ class FlowChartExec {
         return this.loadFlowChartInternal(paths, true);
     }
 
-    complementFlowChart(paths) {
-        return this.loadFlowChartInternal(paths, false);
+    complementFlowChart(paths, indexPath) {
+        console.log("complementFlowChart...");
+        return this.loadFlowChartInternal(paths, false, indexPath);
     }
 
-    loadFlowChartInternal(paths, initialize) {
+    loadFlowChartInternal(paths, initialize, indexPath) {
         if (initialize) {
             this.flowchart = {
                 shapes: [],
@@ -295,6 +298,12 @@ class FlowChartExec {
         };
         const llaves = Object.keys(paths);
         llaves.forEach((prefix) => {
+            // Get index Number from prefix if matches the pattern
+            const prefixGroupsNumber = /_([\d]+)$/.exec(prefix);
+            let index = null;
+            if (prefixGroupsNumber) {
+                index = parseInt(prefixGroupsNumber[1]);
+            }
             const path = paths[prefix];
             const xmlFlowText = fs.readFileSync(path, 'utf8');
             const parser = new XMLParser(options);
@@ -303,6 +312,19 @@ class FlowChartExec {
             this.interpretColor(localFlowChart.shapes);
             // 
             const check = this.checkTypeOfChart(localFlowChart);
+            if (typeof indexPath == "string" && !isNaN(index)) {
+                // Write metadata of node
+                const placeMetadata = (node) => {
+                    node.indexPath = indexPath;
+                    SimpleObj.recreate(node, `meta.${indexPath}`, index);
+                }
+                localFlowChart.shapes.forEach(placeMetadata);
+                localFlowChart.arrows.forEach(placeMetadata);
+                const startingPoints = this.getNodesWithText("start", undefined, localFlowChart);
+                if (this.actualNodes instanceof Array && startingPoints instanceof Array) {
+                    this.actualNodes.push(...startingPoints);
+                }
+            }
             this.flowchart.shapes.push(...localFlowChart.shapes);
             this.flowchart.arrows.push(...localFlowChart.arrows);
             this.flowchart.prefixes.push(prefix);
@@ -313,8 +335,6 @@ class FlowChartExec {
             }
         });
 
-        //console.log(JSON.stringify(this.flowchart.flux, null, 4));
-
         // Se indexan los nodos por id
         const BLACK_LIST = ["flux"];
         this.flowchart.shapes.forEach((node) => {
@@ -359,7 +379,7 @@ class FlowChartExec {
         return instance;
     }
 
-    interpretArguments(argTxt) {
+    interpretArguments(argTxt, node) {
         //console.log(`Interpret ${argTxt}`);
         const tokens = argTxt.split(";");
         const args = [];
@@ -367,7 +387,13 @@ class FlowChartExec {
             const token = tokens[i];
             // Interpret with template
             if (token.trim().length > 0) {
-                const rendered = this.renderer.render(token, this.data);
+                let rendered = token;
+                if (node.meta) {
+                    // Render skiping meta
+                    const skipUndefined = true;
+                    rendered = this.renderer.render(rendered, node.meta, skipUndefined);
+                }
+                rendered = this.renderer.render(rendered, this.data);
                 let value;
                 try {
                     value = eval(rendered);
@@ -388,7 +414,7 @@ class FlowChartExec {
         }
         let index = 0;
         const answered = await MyUtilities.replaceAsync2(txt, /(([a-z]+)«([^»]*)»)/ig, async (match, g1, commandName, argsTxt) => {
-            const args = this.interpretArguments(argsTxt);
+            const args = this.interpretArguments(argsTxt, node);
             let instance = this.createInstance(commandName, id, txt, args);
             index++;
             const response1 = `${commandName}${JSON.stringify(args)}`;
@@ -416,7 +442,7 @@ class FlowChartExec {
         }
         let index = 0;
         const answered = await MyUtilities.replaceAsync2(txt, /(([a-z]+)«([^»]*)»)/ig, async (match, g1, commandName, argsTxt) => {
-            const args = this.interpretArguments(argsTxt);
+            const args = this.interpretArguments(argsTxt, node);
             let instance = null;
             if (create || !this.instances[id][`${index}`]) {
                 instance = this.createInstance(commandName, id, txt, args);

package/src/flowchart/steps/StepMultiple.js

@@ -20,25 +20,38 @@ class StepMultiple extends StepBasic {
         }
     }
     async execFirst() {
+        // console.log(`StepMultiple ${JSON.stringify(this.args)}`);
         // Reads the list to iterate
         const room = this.context.getRoom();
         this.list = SimpleObj.getValue(this.context.data, this.args[1], []);
-        const WORKSPACE = SimpleObj.getValue(this.context.data, "env.WORKSPACE", "./");
-        //console.log(`WORKSPACE=${WORKSPACE}`);
-        //console.log(`My list ${JSON.stringify(this.list)}`);
-        // Loads the draw.io file
+        const WORKSPACE = SimpleObj.getValue(this.context.data, "env.WORKSPACE", ".");
         const flowChartTemplateName = this.args[0];
-        const extraConfiguration = {
-            Print: '${WORKSPACE}/flowcharts/multiple/flow01N.drawio',
-        };
-        this.completePaths(extraConfiguration, WORKSPACE);
+        const indexPath = this.args[2];
         // Force update the model
         const superContext = this.context.getSuperContext();
         const roomData = superContext.getRoomLiveTupleModel(room);
-        roomData.model.flowchart = this.context.complementFlowChart(extraConfiguration);
-        let changes = roomData.builder.trackDifferences(roomData.model, [], null, ["flowchart"]);
-        roomData.model = roomData.builder.affect(changes);
-        superContext.emitToRoom(room, "flowChartModified");
+        const routeMultiple = SimpleObj.getValue(roomData, `model.multiples.${flowChartTemplateName}`, null);
+        //console.log(`flowChartTemplateName=${flowChartTemplateName} routeMultiple=${routeMultiple}`)
+        if (typeof indexPath !== "string") {
+            console.log(`In StepMultiple, indexPath is not a string ${JSON.stringify(this.args)}`);
+            return;
+        }
+        if (routeMultiple) {
+            const extraConfiguration = {};
+
+            for (let i = 0; i < this.list.length; i++) {
+                extraConfiguration[`${flowChartTemplateName}_${i}`] = routeMultiple;
+            }
+            this.completePaths(extraConfiguration, WORKSPACE);
+
+            roomData.model.flowchart = this.context.complementFlowChart(extraConfiguration, indexPath);
+            let changes = roomData.builder.trackDifferences(roomData.model, [], null, ["flowchart"]);
+            roomData.model = roomData.builder.affect(changes);
+            superContext.emitToRoom(room, "flowChartModified");
+        } else {
+            console.log(`In StepMultiple, can't find model.multiples.${flowChartTemplateName}`);
+            //console.log(JSON.stringify(roomData, null, 4));
+        }
     }
 
     async canContinue() {

package/src/flowchart/steps/StepMultipleDone.js

@@ -0,0 +1,30 @@
+const { StepBasic } = require("./StepBasic");
+const { SimpleObj } = require("../../SimpleObj");
+
+class StepMultipleDone extends StepBasic {
+    list = [];
+    constructor(context, id, commandName, argsTxt) {
+        super(context, id, commandName, argsTxt);
+        super.alwaysEvaluateCanContinue = true;
+    }
+    async execFirst() { }
+
+    async canContinue() {
+        this.list = SimpleObj.getValue(this.context.data, this.args[0], []);
+        if (!(this.list instanceof Array)) {
+            console.log(`In StepMultipleDone, warning ${this.args[0]} is not a list!`);
+            return true;
+        }
+        for (let i = 0; i < this.list.length; i++) {
+            const element = this.list[i];
+            if (element.done !== true) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+
+module.exports = {
+    StepMultipleDone
+};