@ejfdelgado/ejflab-common 1.8.4 → 1.9.0

package/package.json

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

package/src/flowchart/FlowChartExec.js

@@ -85,19 +85,28 @@ class FlowChartExec {
     }
 
     saveBufferData(sourceId, pathId, buffer) {
-        //console.log(`saveBufferData ${sourceId} ${pathId}`, buffer);
-        if (!this.bufferData[sourceId]) {
-            this.bufferData[sourceId] = {};
+        let pathId2 = pathId;
+        if (!pathId2.startsWith(".")) {
+            pathId2 = "." + pathId2;
         }
-        this.bufferData[sourceId][pathId] = buffer;
+        const compoundKey = `${sourceId}${pathId2}`;
+        const parts = /^(.*)\.([^.]+)$/.exec(compoundKey);
+        if (!parts) {
+            console.log("ERROR! Key must contain at least two parts separated with a dot");
+            return;
+        }
+        const baseKey = parts[1];
+        const endKey = parts[2];
+        SimpleObj.recreate(this.bufferData, compoundKey, true);
+        const baseObject = SimpleObj.getValue(this.bufferData, baseKey, {});
+        baseObject[endKey] = buffer;
     }
 
     readBufferData(sourceId, pathId) {
-        //console.log(`readBufferData ${sourceId} ${pathId}`);
-        if (!this.bufferData[sourceId]) {
-            this.bufferData[sourceId] = {};
+        if (!pathId.startsWith(".")) {
+            pathId = "." + pathId;
         }
-        return this.bufferData[sourceId][pathId];
+        return SimpleObj.getValue(this.bufferData, `${sourceId}${pathId}`, null);
     }
 
     registerPendingCall(id, val = true) {
@@ -278,12 +287,13 @@ class FlowChartExec {
         return this.loadFlowChartInternal(paths, true);
     }
 
-    complementFlowChart(paths, indexPath) {
-        console.log("complementFlowChart...");
-        return this.loadFlowChartInternal(paths, false, indexPath);
+    complementFlowChart(paths, indexPath, parentNode) {
+        //console.log(`complementFlowChart indexPath=${indexPath}`);
+        return this.loadFlowChartInternal(paths, false, indexPath, parentNode);
     }
 
-    loadFlowChartInternal(paths, initialize, indexPath) {
+    loadFlowChartInternal(paths, initialize, indexPath, parentNode = {}) {
+        //console.log(`loadFlowChartInternal indexPath=${indexPath}`);
         if (initialize) {
             this.flowchart = {
                 shapes: [],
@@ -316,7 +326,12 @@ class FlowChartExec {
                 // Write metadata of node
                 const placeMetadata = (node) => {
                     node.indexPath = indexPath;
+                    // Read the parent meta
+                    if (parentNode.meta) {
+                        SimpleObj.recreate(node, "meta", JSON.parse(JSON.stringify(parentNode.meta)));
+                    }
                     SimpleObj.recreate(node, `meta.${indexPath}`, index);
+                    //console.log(node.prefix + ":" + JSON.stringify(node.meta));
                 }
                 localFlowChart.shapes.forEach(placeMetadata);
                 localFlowChart.arrows.forEach(placeMetadata);
@@ -391,7 +406,9 @@ class FlowChartExec {
                 if (node.meta) {
                     // Render skiping meta
                     const skipUndefined = true;
+                    //console.log(`${rendered} ${JSON.stringify(node.meta)}`);
                     rendered = this.renderer.render(rendered, node.meta, skipUndefined);
+                    //console.log(`${rendered}`);
                 }
                 rendered = this.renderer.render(rendered, this.data);
                 let value;
@@ -418,7 +435,7 @@ class FlowChartExec {
             let instance = this.createInstance(commandName, id, txt, args);
             index++;
             const response1 = `${commandName}${JSON.stringify(args)}`;
-            const { canContinue, abort } = await instance.executeAsNode(args, argsTxt);
+            const { canContinue, abort } = await instance.executeAsNode(args, argsTxt, node);
             if (abort) {
                 // Panic and halt all
                 this.mustEnd = true;
@@ -455,7 +472,7 @@ class FlowChartExec {
             }
             index++;
             const response1 = `${commandName}${JSON.stringify(args)}`;
-            const { canContinue, abort } = await instance.executeAsArrow(args, argsTxt);
+            const { canContinue, abort } = await instance.executeAsArrow(args, argsTxt, node);
             if (abort) {
                 // Panic and halt all
                 this.mustEnd = true;

package/src/flowchart/steps/CommandMinio.js

@@ -8,12 +8,17 @@ class CommandMinio extends CommandBasic {
         const minioSrv = this.context.getSuperContext().getMinioClient();
 
         if (action == "write") {
-            const objectPath = this.args[2];
+            let objectPath = this.args[2];
             const sourcePath = this.args[3];
             const metadata = this.args[4];
+            let extra = this.resolveArgument(objectPath);
+            if (typeof extra == "string") {
+                objectPath = extra;
+            }
             //console.log(`CommandMinio.write bucket ${bucketName} objectPath ${objectPath} from ${sourcePath}`);
             //console.log(metadata);
             const bytes = this.resolveArgument(sourcePath);
+            //console.log(bytes);
             // Armar el payload para minio
             const payload = {
                 objectPath, bytes, metadata

package/src/flowchart/steps/CommandSet.js

@@ -5,7 +5,7 @@ class CommandSet extends CommandBasic {
     async computation() {
         const path = this.args[0];
         const val = this.args[1];
-        SimpleObj.recreate(this.context.data, path, val);
+        this.writeArgument(path, val);
     }
 }
 

package/src/flowchart/steps/StepBasic.js

@@ -66,7 +66,8 @@ class StepBasic {
             SimpleObj.recreate(this.context.data, `performance.${id}.time`, val.time);
         }
     }
-    async executeAsNode(args, argsTxtIndividual) {
+    async executeAsNode(args, argsTxtIndividual, node) {
+        this.node = node;
         this.argsTxtIndividual = argsTxtIndividual;
         const answer = {
             canContinue: false,
@@ -100,7 +101,8 @@ class StepBasic {
             return answer;
         }
     }
-    async executeAsArrow(args, argsTxtIndividual) {
+    async executeAsArrow(args, argsTxtIndividual, node) {
+        this.node = node;
         this.argsTxtIndividual = argsTxtIndividual;
         const answer = {
             canContinue: false,
@@ -202,7 +204,7 @@ class StepBasic {
             // It reads from buffer
             buffer = this.context.readBufferData(sourceId, pathId);
             if (!buffer) {
-                console.log(`No buffer in ${sourceId} ${pathId}`);
+                console.log(`No buffer in ${sourceId}${pathId}`);
                 return undefined;
             }
         } else {
@@ -212,15 +214,43 @@ class StepBasic {
         return buffer;
     }
 
-    resolveArgument(val) {
-        const partsSource = /^(b\.([^.]+)\.([^.]+)|d\.(.+))$/i.exec(val);
+    breakPath(val) {
+        const partsSource = /^(b\.([^.]+)([^\s]+)|d.(.+))$/i.exec(val);
         if (partsSource == null) {
-            console.log(`${val} doesn't match ^(b\.([^.]+)\.([^.]+)|d\.(.+))$`);
+            //console.log(`${val} doesn't match ^(b\.([^.]+)([^\s]+)|d.(.+))$`);
             return undefined;
         }
-        const buffer = this.readInputFrom(!partsSource[4], partsSource[2], partsSource[3], partsSource[4]);
+        return {
+            isBuffer: !partsSource[4],
+            sourceId: partsSource[2],
+            pathId: partsSource[3],
+            completePath: partsSource[4]
+        };
+    }
+
+    resolveArgument(val) {
+        const breaked = this.breakPath(val);
+        let buffer = null;
+        if (breaked) {
+            buffer = this.readInputFrom(breaked.isBuffer, breaked.sourceId, breaked.pathId, breaked.completePath);
+        } else {
+            buffer = SimpleObj.getValue(this.context.data, val, null);
+        }
         return buffer;
     }
+
+    writeArgument(path, val) {
+        const braked = this.breakPath(path);
+        if (braked) {
+            if (braked.isBuffer) {
+                this.context.saveBufferData(braked.sourceId, braked.pathId, val);
+            } else {
+                SimpleObj.recreate(this.context.data, braked.completePath, val);
+            }
+        } else {
+            SimpleObj.recreate(this.context.data, path, val);
+        }
+    }
 }
 
 module.exports = {

package/src/flowchart/steps/StepMultiple.js

@@ -23,7 +23,7 @@ class StepMultiple extends StepBasic {
         // 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], []);
+        this.list = this.resolveArgument(this.args[1]);
         const WORKSPACE = SimpleObj.getValue(this.context.data, "env.WORKSPACE", ".");
         const flowChartTemplateName = this.args[0];
         const indexPath = this.args[2];
@@ -38,13 +38,15 @@ class StepMultiple extends StepBasic {
         }
         if (routeMultiple) {
             const extraConfiguration = {};
-
+            let prefixName = `${flowChartTemplateName}_`;
+            if (typeof this.node.prefix == "string") {
+                prefixName = this.node.prefix + "_" + prefixName;
+            }
             for (let i = 0; i < this.list.length; i++) {
-                extraConfiguration[`${flowChartTemplateName}_${i}`] = routeMultiple;
+                extraConfiguration[prefixName + i] = routeMultiple;
             }
             this.completePaths(extraConfiguration, WORKSPACE);
-
-            roomData.model.flowchart = this.context.complementFlowChart(extraConfiguration, indexPath);
+            roomData.model.flowchart = this.context.complementFlowChart(extraConfiguration, indexPath, this.node);
             let changes = roomData.builder.trackDifferences(roomData.model, [], null, ["flowchart"]);
             roomData.model = roomData.builder.affect(changes);
             superContext.emitToRoom(room, "flowChartModified");

package/src/flowchart/steps/StepMultipleDone.js

@@ -10,7 +10,7 @@ class StepMultipleDone extends StepBasic {
     async execFirst() { }
 
     async canContinue() {
-        this.list = SimpleObj.getValue(this.context.data, this.args[0], []);
+        this.list = this.resolveArgument(this.args[0]);
         if (!(this.list instanceof Array)) {
             console.log(`In StepMultipleDone, warning ${this.args[0]} is not a list!`);
             return true;