Bug Fixes + Folders

TaskServer/server.js

@@ -102,6 +102,177 @@ global.PROCESS_INFO = function (processKey, node, infoMessage) {
     global.EVENT_SERVER_CLIENT.raiseEvent(processKey, 'Info', event)
 }
 
+global.NODE_BRANCH_TO_ARRAY = function (node, nodeType) {
+    let resultArray = []
+    scanNodeBranch(node, nodeType)
+    return resultArray
+
+    function scanNodeBranch(startingNode) {
+        let nodeDefinition = global.APP_SCHEMA_MAP.get(startingNode.type)
+        if (nodeDefinition === undefined) { return }
+
+        if (startingNode.type === nodeType) {
+            resultArray.push(startingNode)
+            return
+        }
+
+        if (nodeDefinition.properties === undefined) { return }
+        for (let i = 0; i < nodeDefinition.properties.length; i++) {
+            let property = nodeDefinition.properties[i]
+
+            switch (property.type) {
+                case 'node': {
+                    scanNodeBranch(startingNode[property.name])
+                }
+                    break
+                case 'array': {
+                    let startingNodePropertyArray = startingNode[property.name]
+                    if (startingNodePropertyArray !== undefined) {
+                        for (let m = 0; m < startingNodePropertyArray.length; m++) {
+                            scanNodeBranch(startingNodePropertyArray[m])
+                        }
+                    }
+                    break
+                }
+            }
+        }
+    }
+}
+
+global.FIND_NODE_IN_NODE_MESH = function (node, nodeType) {
+    /*
+    This function scans a node mesh for a certain node type and 
+    returns the first instance found. 
+    */
+    let nodeFound
+    scanNodeMesh(node, nodeType)
+    return nodeFound
+
+    function scanNodeMesh(startingNode) {
+        if (startingNode === undefined) { return }
+        if (nodeFound !== undefined) { return }
+
+        let nodeDefinition = APP_SCHEMA_MAP.get(startingNode.type)
+        if (nodeDefinition === undefined) { return }
+
+        if (startingNode.type === nodeType) {
+            nodeFound = startingNode
+            return
+        }
+
+        /* We scan through this node children */
+        if (nodeDefinition.properties !== undefined) {
+            for (let i = 0; i < nodeDefinition.properties.length; i++) {
+                let property = nodeDefinition.properties[i]
+
+                switch (property.type) {
+                    case 'node': {
+                        scanNodeMesh(startingNode[property.name])
+                    }
+                        break
+                    case 'array': {
+                        let startingNodePropertyArray = startingNode[property.name]
+                        if (startingNodePropertyArray !== undefined) {
+                            for (let m = 0; m < startingNodePropertyArray.length; m++) {
+                                scanNodeMesh(startingNodePropertyArray[m])
+                            }
+                        }
+                        break
+                    }
+                }
+            }
+        }
+        /* We scan parents nodes. */
+        if (startingNode.parentNode !== undefined) {
+            scanNodeMesh(startingNode.parentNode)
+        }
+        /* We scan reference parents too. */
+        if (startingNode.referenceParent !== undefined) {
+            scanNodeMesh(startingNode.referenceParent)
+        }
+    }
+}
+
+global.NODE_MESH_TO_PATH_ARRAY = function (node, nodeId) {
+    /*
+    This function scans a node mesh for a certain node if and 
+    returns an array with the path within that mesh to the
+    requested node. 
+    */
+    let nodeArray = []
+    scanNodeMesh(node)
+    return nodeArray
+
+    function scanNodeMesh(startingNode) {
+        if (startingNode === undefined) { return }
+
+        let nodeDefinition = APP_SCHEMA_MAP.get(startingNode.type)
+        if (nodeDefinition === undefined) { return }
+
+        if (startingNode.id === nodeId) {
+            nodeArray.push(startingNode)
+            return
+        }
+
+        /* We scan through this node children */
+        if (nodeDefinition.properties !== undefined) {
+            for (let i = 0; i < nodeDefinition.properties.length; i++) {
+                let property = nodeDefinition.properties[i]
+
+                switch (property.type) {
+                    case 'node': {
+                        scanNodeMesh(startingNode[property.name])
+                        if (nodeArray.length > 0) {
+                            nodeArray.unshift(startingNode)
+                            return
+                        }
+                    }
+                        break
+                    case 'array': {
+                        let startingNodePropertyArray = startingNode[property.name]
+                        if (startingNodePropertyArray !== undefined) {
+                            for (let m = 0; m < startingNodePropertyArray.length; m++) {
+                                scanNodeMesh(startingNodePropertyArray[m])
+                                if (nodeArray.length > 0) {
+                                    nodeArray.unshift(startingNode)
+                                    return
+                                }
+                            }
+                        }
+                        break
+                    }
+                }
+            }
+        }
+        /* We scan parents nodes. */
+        if (startingNode.parentNode !== undefined) {
+            scanNodeMesh(startingNode.parentNode)
+            if (nodeArray.length > 0) {
+                nodeArray.unshift(startingNode)
+                return
+            }
+        }
+        /* We scan reference parents too. */
+        if (startingNode.referenceParent !== undefined) {
+            scanNodeMesh(startingNode.referenceParent)
+            if (nodeArray.length > 0) {
+                nodeArray.unshift(startingNode)
+                return
+            }
+        }
+    }
+}
+
+global.FIND_NODE_IN_NODE_ARRAY = function (nodeArray, nodeType) {
+    for (let i=0; i < nodeArray.length; i++) {
+        let node = nodeArray[i]
+        if (node.type === nodeType) {
+            return node
+        } 
+    }
+}
+
+
 process.on('uncaughtException', function (err) {
     console.log('[ERROR] Task Server -> server -> uncaughtException -> err.message = ' + err.message)
     console.log('[ERROR] Task Server -> server -> uncaughtException -> err.stack = ' + err.stack)
@@ -230,7 +401,8 @@ function preLoader() {
             global.EVENT_SERVER_CLIENT.listenToEvent('Task Server - ' + taskId, 'Run Task', undefined, 'Task Server - ' + taskId, undefined, eventReceived)
             global.EVENT_SERVER_CLIENT.raiseEvent('Task Manager - ' + taskId, 'Nodejs Process Ready for Task')
             function eventReceived(message) {
-                global.TASK_NODE = message
+                global.APP_SCHEMA_ARRAY = JSON.parse(message.event.appSchema)
+                setUpAppSchema()
                 global.TASK_NODE = JSON.parse(message.event.taskDefinition)
                 global.TASK_NETWORK = JSON.parse(message.event.networkDefinition)
                 bootLoader()
@@ -245,7 +417,8 @@ function preLoader() {
             //console.log('[INFO] Task Server -> server -> preLoader -> Waiting for event to start debugging...')
             global.EVENT_SERVER_CLIENT.listenToEvent('Task Server', 'Debug Task Started', undefined, 'Task Server', undefined, startDebugging)
             function startDebugging(message) {
-                global.TASK_NODE = message
+                global.APP_SCHEMA_ARRAY = JSON.parse(message.event.appSchema)
+                setUpAppSchema()
                 global.TASK_NODE = JSON.parse(message.event.taskDefinition)
                 global.TASK_NETWORK = JSON.parse(message.event.networkDefinition)
                 bootLoader()
@@ -255,6 +428,16 @@ function preLoader() {
             console.log('[ERROR] Task Server -> server -> preLoader -> global.TASK_NODE = ' + JSON.stringify(global.TASK_NODE).substring(0, 1000))
         }
     }
+
+    function setUpAppSchema() {
+        /* Setup the APP_SCHEMA_MAP based on the APP_SCHEMA_ARRAY */
+        global.APP_SCHEMA_MAP = new Map()
+        for (let i = 0; i < global.APP_SCHEMA_ARRAY.length; i++) {
+            let nodeDefinition = global.APP_SCHEMA_ARRAY[i]
+            let key = nodeDefinition.type
+            global.APP_SCHEMA_MAP.set(key, nodeDefinition)
+        }
+    }
 }
 
 function bootLoader() {