Refactoring for Tasks

FloatingSpace/StrategyPart.js

@@ -246,20 +246,20 @@ function newStrategyPart () {
         compatibleType = '->' + 'Definition'
         compatibleSubType = undefined
         break
-      case 'Backend Process':
+      case 'Task':
         compatibleType = '->' + 'Backend'
         compatibleSubType = undefined
         break
       case 'Sensor':
-        compatibleType = '->' + 'Backend Process'
+        compatibleType = '->' + 'Task'
         compatibleSubType = undefined
         break
       case 'Indicator':
-        compatibleType = '->' + 'Backend Process'
+        compatibleType = '->' + 'Task'
         compatibleSubType = undefined
         break
       case 'Trading Engine':
-        compatibleType = '->' + 'Backend Process'
+        compatibleType = '->' + 'Task'
         compatibleSubType = undefined
         break
       case 'Bot Process':
@@ -365,7 +365,7 @@ function newStrategyPart () {
       if (compatibleType.indexOf('->' + nearbyNode.type) >= 0) {
         /* Discard objects with busy coonection ports */
         if (thisObject.payload.node.type === 'Backend' && nearbyNode.backend !== undefined) { continue }
-        if (thisObject.payload.node.type === 'Backend Process' && nearbyNode.backendProcess !== undefined) { continue }
+        if (thisObject.payload.node.type === 'Task' && nearbyNode.task !== undefined) { continue }
         if (thisObject.payload.node.type === 'Sensor' && nearbyNode.bot !== undefined) { continue }
         if (thisObject.payload.node.type === 'Indicator' && nearbyNode.bot !== undefined) { continue }
         if (thisObject.payload.node.type === 'Trading Engine' && nearbyNode.bot !== undefined) { continue }

FloatingSpace/StrategyPartConstructor.js

@@ -321,9 +321,9 @@ function newStrategyPartConstructor () {
         addLeftIcons(menuItemsInitialValues, floatingObject)
         menuItemsInitialValues.push(
           {
-            action: 'Add Backend Process',
+            action: 'Add Task',
             actionFunction: payload.onMenuItemClick,
-            label: 'Add Backend Process',
+            label: 'Add Task',
             visible: false,
             relatedStrategyPart: 'Backend',
             rawRadius: 8,
@@ -364,11 +364,11 @@ function newStrategyPartConstructor () {
             )
         break
       }
-      case 'Backend Process': {
+      case 'Task': {
         addLeftIcons(menuItemsInitialValues, floatingObject)
         menuItemsInitialValues.push(
           {
-            action: 'Run Backend Process',
+            action: 'Run Task',
             actionFunction: payload.onMenuItemClick,
             label: 'Run',
             visible: false,
@@ -382,7 +382,7 @@ function newStrategyPartConstructor () {
         )
         menuItemsInitialValues.push(
           {
-            action: 'Stop Backend Process',
+            action: 'Stop Task',
             actionFunction: payload.onMenuItemClick,
             label: 'Stop',
             visible: false,
@@ -435,7 +435,7 @@ function newStrategyPartConstructor () {
           )
         menuItemsInitialValues.push(
           {
-            action: 'Delete Backend Process',
+            action: 'Delete Task',
             askConfirmation: true,
             confirmationLabel: 'Confirm to Delete',
             actionFunction: payload.onMenuItemClick,
@@ -2144,7 +2144,7 @@ function newStrategyPartConstructor () {
         level_1()
         break
       }
-      case 'Backend Process': {
+      case 'Task': {
         level_1()
         break
       }

FloatingSpace/StrategyPartTitle.js

@@ -55,7 +55,7 @@ function newStrategyPartTitle () {
       case 'Backend': {
         break
       }
-      case 'Backend Process': {
+      case 'Task': {
         break
       }
       case 'Sensor': {

Spaces/StrategySpace.js

@@ -41,7 +41,7 @@ function newStrategySpace () {
     const relationshipArray = [
       ['Definition', 'text'],
       ['Backend', 'task'],
-      ['Backend Process', 'timeline'],
+      ['Task', 'timeline'],
       ['Sensor', 'pipette'],
       ['Indicator', 'vector'],
       ['Trading Engine', 'brainstorming'],

StrategySpace/Workspace/FunctionLibraries/AttachDetach.js

@@ -54,8 +54,8 @@ function newAttachDetach () {
         completeDetachment(node, rootNodes)
         return
       }
-      case 'Backend Process': {
-        node.payload.parentNode.backendProcess = undefined
+      case 'Task': {
+        node.payload.parentNode.task = undefined
         completeDetachment(node, rootNodes)
         return
       }
@@ -255,10 +255,10 @@ function newAttachDetach () {
         completeAttachment(node, rootNodes)
       }
         break
-      case 'Backend Process': {
+      case 'Task': {
         node.payload.parentNode = attachToNode
         node.payload.chainParent = attachToNode
-        node.payload.parentNode.backendProcesses.push(node)
+        node.payload.parentNode.tasks.push(node)
         completeAttachment(node, rootNodes)
       }
         break

StrategySpace/Workspace/FunctionLibraries/NodeChildren.js

@@ -14,8 +14,8 @@ function newNodeChildren () {
       case 'Backend': {
         return countChildrenBackend(parentNode, childNode)
       }
-      case 'Backend Process': {
-        return countChildrenBackendProcess(parentNode, childNode)
+      case 'Task': {
+        return countChildrenTask(parentNode, childNode)
       }
       case 'Sensor': {
         return countChildrenSensor(parentNode, childNode)
@@ -160,8 +160,8 @@ function newNodeChildren () {
       childIndex: undefined
     }
 
-    for (let i = 0; i < parentNode.backendProcesses.length; i++) {
-      let child = parentNode.backendProcesses[i]
+    for (let i = 0; i < parentNode.tasks.length; i++) {
+      let child = parentNode.tasks[i]
       response.childrenCount++
       if (child.id === childNode.id) {
         response.childIndex = response.childrenCount
@@ -170,7 +170,7 @@ function newNodeChildren () {
     return response
   }
 
-  function countChildrenBackendProcess (parentNode, childNode) {
+  function countChildrenTask (parentNode, childNode) {
     let response = {
       childrenCount: 0,
       childIndex: undefined

StrategySpace/Workspace/FunctionLibraries/NodeDeleter.js

@@ -2,7 +2,7 @@ function newNodeDeleter () {
   thisObject = {
     deleteDefinition: deleteDefinition,
     deleteBackend: deleteBackend,
-    deleteBackendProcess: deleteBackendProcess,
+    deleteTask: deleteTask,
     deleteSensor: deleteBot,
     deleteIndicator: deleteBot,
     deleteTradingEngine: deleteBot,
@@ -56,8 +56,8 @@ function newNodeDeleter () {
           deleteBackend(rootNode, rootNodes)
           break
         }
-        case 'Backend Process': {
-          deleteBackendProcess(rootNode, rootNodes)
+        case 'Task': {
+          deleteTask(rootNode, rootNodes)
           break
         }
         case 'Sensor': {
@@ -234,21 +234,21 @@ function newNodeDeleter () {
     if (payload.parentNode !== undefined) {
       payload.parentNode.backend = undefined
     }
-    while (node.backendProcesses.length > 0) {
-      deleteBackendProcess(node.backendProcesses[0], rootNodes)
+    while (node.tasks.length > 0) {
+      deleteTask(node.tasks[0], rootNodes)
     }
     completeDeletion(node, rootNodes)
     destroyPart(node)
     cleanNode(node)
   }
 
-  function deleteBackendProcess (node, rootNodes) {
+  function deleteTask (node, rootNodes) {
     let payload = node.payload
     if (payload.parentNode !== undefined) {
-      for (let j = 0; j < payload.parentNode.backendProcesses.length; j++) {
-        let backendProcess = payload.parentNode.backendProcesses[j]
-        if (backendProcess.id === node.id) {
-          payload.parentNode.backendProcesses.splice(j, 1)
+      for (let j = 0; j < payload.parentNode.tasks.length; j++) {
+        let task = payload.parentNode.tasks[j]
+        if (task.id === node.id) {
+          payload.parentNode.tasks.splice(j, 1)
         }
       }
     }
@@ -277,8 +277,8 @@ function newNodeDeleter () {
     let payload = node.payload
     if (payload.parentNode !== undefined) {
       for (let j = 0; j < payload.parentNode.botProcesses.length; j++) {
-        let backendProcess = payload.parentNode.botProcesses[j]
-        if (backendProcess.id === node.id) {
+        let task = payload.parentNode.botProcesses[j]
+        if (task.id === node.id) {
           payload.parentNode.botProcesses.splice(j, 1)
         }
       }

StrategySpace/Workspace/FunctionLibraries/PartsFromNodes.js

@@ -2,7 +2,7 @@ function newPartsFromNodes () {
   thisObject = {
     createPartFromNode: createPartFromNode,
     addBackend: addBackend,
-    addBackendProcess: addBackendProcess,
+    addTask: addTask,
     addSensor: addSensor,
     addIndicator: addIndicator,
     addTradingEngine: addTradingEngine,
@@ -340,14 +340,14 @@ function newPartsFromNodes () {
       }
       case 'Backend': {
         createPart('Backend', node.name, node, parentNode, chainParent, 'Backend')
-        for (let m = 0; m < node.backendProcesses.length; m++) {
-          let backendProcess = node.backendProcesses[m]
-          createPartFromNode(backendProcess, node, node)
+        for (let m = 0; m < node.tasks.length; m++) {
+          let task = node.tasks[m]
+          createPartFromNode(task, node, node)
         }
         return
       }
-      case 'Backend Process': {
-        createPart('Backend Process', node.name, node, parentNode, chainParent, 'Backend Process')
+      case 'Task': {
+        createPart('Task', node.name, node, parentNode, chainParent, 'Task')
         if (node.bot !== undefined) {
           createPartFromNode(node.bot, node, node)
         }
@@ -387,7 +387,7 @@ function newPartsFromNodes () {
   function addBackend (node) {
     if (node.backend === undefined) {
       node.backend = {
-        backendProcesses: []
+        tasks: []
       }
       createPart('Backend', '', node.backend, node, node)
     }
@@ -395,14 +395,14 @@ function newPartsFromNodes () {
     return node.backend
   }
 
-  function addBackendProcess (node) {
-    let backendProcess = {
-      name: 'New Backend Process'
+  function addTask (node) {
+    let task = {
+      name: 'New Task'
     }
-    node.backendProcesses.push(backendProcess)
-    createPart('Backend Process', backendProcess.name, backendProcess, node, node, 'Backend Process')
+    node.tasks.push(task)
+    createPart('Task', task.name, task, node, node, 'Task')
 
-    return backendProcess
+    return task
   }
 
   function addSensor (node) {

StrategySpace/Workspace/FunctionLibraries/ProtocolNode.js

@@ -365,16 +365,16 @@ function newProtocolNode () {
           type: node.type,
           subType: node.subType,
           name: node.name,
-          backendProcesses: []
+          tasks: []
         }
 
-        for (let m = 0; m < node.backendProcesses.length; m++) {
-          let backendProcess = getProtocolNode(node.backendProcesses[m], removePersonalData, parseJSONStrings)
-          backend.backendProcesses.push(backendProcess)
+        for (let m = 0; m < node.tasks.length; m++) {
+          let task = getProtocolNode(node.tasks[m], removePersonalData, parseJSONStrings)
+          backend.tasks.push(task)
         }
         return backend
       }
-      case 'Backend Process': {
+      case 'Task': {
         let object = {
           type: node.type,
           subType: node.subType,

StrategySpace/Workspace/FunctionLibraries/StringifyNode.js

@@ -431,18 +431,18 @@ function newStringifyNode () {
           type: node.type,
           subType: node.subType,
           name: node.name,
-          backendProcesses: [],
+          tasks: [],
           savedPayload: getSavedPayload(node)
         }
 
-        for (let m = 0; m < node.backendProcesses.length; m++) {
-          let backendProcess = prepareForStringify(node.backendProcesses[m], removePersonalData)
-          backend.backendProcesses.push(backendProcess)
+        for (let m = 0; m < node.tasks.length; m++) {
+          let task = prepareForStringify(node.tasks[m], removePersonalData)
+          backend.tasks.push(task)
         }
 
         return backend
       }
-      case 'Backend Process': {
+      case 'Task': {
         let object = {
           id: node.id,
           type: node.type,

StrategySpace/Workspace/Workspace.js

@@ -209,7 +209,7 @@ function newWorkspace () {
         }
 
         break
-      case 'Run Backend Process':
+      case 'Run Task':
         {
           /* Check if it is possible to Run or not */
           if (payload.node.bot === undefined) { return }
@@ -223,18 +223,18 @@ function newWorkspace () {
           payload.uiObject.play()
 
           let event = {
-            backendProcessId: payload.node.id,
+            taskId: payload.node.id,
             definition: JSON.stringify(functionLibraryProtocolNode.getProtocolNode(payload.node, false, true)) // <-  We need to do this workaround in order no to send unescaped charactars to the backend.
           }
-          systemEventHandler.raiseEvent('Backend Server', 'Run Backend Process', event)
+          systemEventHandler.raiseEvent('Backend Server', 'Run Task', event)
         }
         break
-      case 'Stop Backend Process':
+      case 'Stop Task':
         {
           let event = {
-            backendProcessId: payload.node.id
+            taskId: payload.node.id
           }
-          systemEventHandler.raiseEvent('Backend Server', 'Stop Backend Process', event)
+          systemEventHandler.raiseEvent('Backend Server', 'Stop Task', event)
 
           payload.uiObject.stop()
 
@@ -252,9 +252,9 @@ function newWorkspace () {
           functionLibraryPartsFromNodes.addBackend(payload.node)
         }
         break
-      case 'Add Backend Process':
+      case 'Add Task':
         {
-          functionLibraryPartsFromNodes.addBackendProcess(payload.node)
+          functionLibraryPartsFromNodes.addTask(payload.node)
         }
         break
       case 'Add Sensor':
@@ -381,8 +381,8 @@ function newWorkspace () {
         functionLibraryNodeDeleter.deleteBackend(payload.node, workspaceNode.rootNodes)
         break
       }
-      case 'Delete Backend Process': {
-        functionLibraryNodeDeleter.deleteBackendProcess(payload.node, workspaceNode.rootNodes)
+      case 'Delete Task': {
+        functionLibraryNodeDeleter.deleteTask(payload.node, workspaceNode.rootNodes)
         break
       }
       case 'Delete Sensor': {