Workspace Reorg Implemented - Ready to Debug

StrategySpace/Workspace/FunctionLibraries/AttachDetach.js

@@ -1,4 +1,4 @@
-function newDetachAttach () {
+function newAttachDetach () {
   thisObject = {
     detachNode: detachNode,
     attachNode: attachNode

StrategySpace/Workspace/FunctionLibraries/Delete.js

@@ -1,218 +0,0 @@
-function destroyPart (node) {
-  canvas.floatingSpace.strategyPartConstructor.destroyStrategyPart(node.payload)
-}
-
-function deleteStrategy (node) {
-  let payload = node.payload
-  if (payload.parentNode !== undefined) {
-    for (let j = 0; j < payload.parentNode.strategies.length; j++) {
-      let strategy = payload.parentNode.strategies[j]
-      if (strategy.id === node.id) {
-        payload.parentNode.strategies.splice(j, 1)
-      }
-    }
-  }
-  deleteTriggerStage(node.triggerStage)
-  deleteOpenStage(node.openStage)
-  deleteManageStage(node.manageStage)
-  deleteCloseStage(node.closeStage)
-  destroyPart(node)
-  cleanNode(node)
-}
-
-function deleteTriggerStage (node) {
-  let payload = node.payload
-  if (payload.parentNode !== undefined) {
-    payload.parentNode.triggerStage = undefined
-  }
-  deleteEvent(node.entryPoint)
-  deleteEvent(node.exitPoint)
-  deleteEvent(node.sellPoint)
-
-  destroyPart(node)
-  cleanNode(node)
-}
-
-function deleteOpenStage (node) {
-  let payload = node.payload
-  if (payload.parentNode !== undefined) {
-    payload.parentNode.openStage = undefined
-  }
-  deleteInitialDefinition(node.initialDefinition)
-
-  destroyPart(node)
-  cleanNode(node)
-}
-
-function deleteManageStage (node) {
-  let payload = node.payload
-  if (payload.parentNode !== undefined) {
-    payload.parentNode.manageStage = undefined
-  }
-  deleteManagedItem(node.stopLoss)
-  deleteManagedItem(node.buyOrder)
-
-  destroyPart(node)
-  cleanNode(node)
-}
-
-function deleteCloseStage (node) {
-  let payload = node.payload
-  if (payload.parentNode !== undefined) {
-    payload.parentNode.closeStage = undefined
-  }
-  destroyPart(node)
-  cleanNode(node)
-}
-
-function deleteInitialDefinition (node) {
-  let payload = node.payload
-  if (payload.parentNode !== undefined) {
-    payload.parentNode.initialDefinition = undefined
-  }
-
-  destroyPart(node)
-  cleanNode(node)
-}
-
-function deleteEvent (node) {
-  let payload = node.payload
-  if (payload.parentNode !== undefined) {
-    switch (node.type) {
-      case 'Trigger On Event': {
-        payload.parentNode.entryPoint = undefined
-        break
-      }
-      case 'Trigger Off Event': {
-        payload.parentNode.exitPoint = undefined
-        break
-      }
-      case 'Take Position Event': {
-        payload.parentNode.sellPoint = undefined
-        break
-      }
-    }
-  }
-
-  while (node.situations.length > 0) {
-    deleteSituation(node.situations[0])
-  }
-  destroyPart(node)
-  cleanNode(node)
-}
-
-function deleteManagedItem (node) {
-  let payload = node.payload
-  if (payload.parentNode !== undefined) {
-    switch (node.type) {
-      case 'Stop Loss': {
-        payload.parentNode.stopLoss = undefined
-        break
-      }
-      case 'Take Profit': {
-        payload.parentNode.buyOrder = undefined
-        break
-      }
-    }
-  }
-
-  while (node.phases.length > 0) {
-    deletePhase(node.phases[0])
-  }
-  destroyPart(node)
-  cleanNode(node)
-}
-
-function deletePhase (node) {
-  let payload = node.payload
-  if (payload.parentNode !== undefined) {
-    for (let k = 0; k < payload.parentNode.phases.length; k++) {
-      let phase = payload.parentNode.phases[k]
-      if (phase.id === node.id) {
-        while (phase.situations.length > 0) {
-          let situation = phase.situations[0]
-          deleteSituation(situation)
-        }
-        phase.situations = []
-      /* Before deleting this phase we need to give its chainParent to the next phase down the chain */
-        if (k < payload.parentNode.phases.length - 1) {
-          payload.parentNode.phases[k + 1].payload.chainParent = payload.chainParent
-        }
-      /* Continue destroying this phase */
-        payload.parentNode.phases.splice(k, 1)
-        destroyPart(phase)
-        cleanNode(phase)
-        return
-      }
-    }
-  } else {
-    while (node.situations.length > 0) {
-      let situation = node.situations[0]
-      deleteSituation(situation)
-    }
-    node.situations = []
-    destroyPart(node)
-    cleanNode(node)
-  }
-}
-
-function deleteSituation (node) {
-  let payload = node.payload
-  if (payload.parentNode !== undefined) {
-    for (let j = 0; j < payload.parentNode.situations.length; j++) {
-      let situation = payload.parentNode.situations[j]
-      if (situation.id === node.id) {
-        while (situation.conditions.length > 0) {
-          let condition = situation.conditions[0]
-          deleteCondition(condition)
-        }
-        situation.conditions = []
-        payload.parentNode.situations.splice(j, 1)
-        destroyPart(situation)
-        cleanNode(situation)
-        return
-      }
-    }
-  } else {
-    while (node.conditions.length > 0) {
-      let condition = node.conditions[0]
-      deleteCondition(condition)
-    }
-    node.conditions = []
-    destroyPart(node)
-    cleanNode(node)
-  }
-}
-
-function deleteCondition (node) {
-  let payload = node.payload
-  if (payload.parentNode !== undefined) {
-    for (let i = 0; i < payload.parentNode.conditions.length; i++) {
-      let condition = payload.parentNode.conditions[i]
-      if (condition.id === node.id) {
-        payload.parentNode.conditions.splice(i, 1)
-        destroyPart(node)
-        cleanNode(condition)
-        return
-      }
-    }
-  } else {
-    destroyPart(node)
-    cleanNode(node)
-  }
-}
-
-function cleanNode (node) {
-  node.payload.targetPosition.x = undefined
-  node.payload.targetPosition.y = undefined
-  node.payload.visible = undefined
-  node.payload.subTitle = undefined
-  node.payload.title = undefined
-  node.payload.node = undefined
-  node.payload.parentNode = undefined
-  node.payload.chainParent = undefined
-  node.payload.onMenuItemClick = undefined
-  node.handle = undefined
-  node.payload = undefined
-  node.cleaned = true
-}

StrategySpace/Workspace/FunctionLibraries/NodeDeleter.js

@@ -0,0 +1,235 @@
+function newNodeDeleter () {
+  thisObject = {
+    deleteStrategy: deleteStrategy,
+    deleteTriggerStage: deleteTriggerStage,
+    deleteOpenStage: deleteOpenStage,
+    deleteManageStage: deleteManageStage,
+    deleteInitialDefinition: deleteInitialDefinition,
+    deleteEvent: deleteEvent,
+    deleteManagedItem: deleteManagedItem,
+    deletePhase: deletePhase,
+    deleteSituation: deleteSituation,
+    deleteCondition: deleteCondition
+  }
+
+  return thisObject
+
+  function destroyPart (node) {
+    canvas.floatingSpace.strategyPartConstructor.destroyStrategyPart(node.payload)
+  }
+
+  function deleteStrategy (node) {
+    let payload = node.payload
+    if (payload.parentNode !== undefined) {
+      for (let j = 0; j < payload.parentNode.strategies.length; j++) {
+        let strategy = payload.parentNode.strategies[j]
+        if (strategy.id === node.id) {
+          payload.parentNode.strategies.splice(j, 1)
+        }
+      }
+    }
+    deleteTriggerStage(node.triggerStage)
+    deleteOpenStage(node.openStage)
+    deleteManageStage(node.manageStage)
+    deleteCloseStage(node.closeStage)
+    destroyPart(node)
+    cleanNode(node)
+  }
+
+  function deleteTriggerStage (node) {
+    let payload = node.payload
+    if (payload.parentNode !== undefined) {
+      payload.parentNode.triggerStage = undefined
+    }
+    deleteEvent(node.entryPoint)
+    deleteEvent(node.exitPoint)
+    deleteEvent(node.sellPoint)
+
+    destroyPart(node)
+    cleanNode(node)
+  }
+
+  function deleteOpenStage (node) {
+    let payload = node.payload
+    if (payload.parentNode !== undefined) {
+      payload.parentNode.openStage = undefined
+    }
+    deleteInitialDefinition(node.initialDefinition)
+
+    destroyPart(node)
+    cleanNode(node)
+  }
+
+  function deleteManageStage (node) {
+    let payload = node.payload
+    if (payload.parentNode !== undefined) {
+      payload.parentNode.manageStage = undefined
+    }
+    deleteManagedItem(node.stopLoss)
+    deleteManagedItem(node.buyOrder)
+
+    destroyPart(node)
+    cleanNode(node)
+  }
+
+  function deleteCloseStage (node) {
+    let payload = node.payload
+    if (payload.parentNode !== undefined) {
+      payload.parentNode.closeStage = undefined
+    }
+    destroyPart(node)
+    cleanNode(node)
+  }
+
+  function deleteInitialDefinition (node) {
+    let payload = node.payload
+    if (payload.parentNode !== undefined) {
+      payload.parentNode.initialDefinition = undefined
+    }
+
+    destroyPart(node)
+    cleanNode(node)
+  }
+
+  function deleteEvent (node) {
+    let payload = node.payload
+    if (payload.parentNode !== undefined) {
+      switch (node.type) {
+        case 'Trigger On Event': {
+          payload.parentNode.entryPoint = undefined
+          break
+        }
+        case 'Trigger Off Event': {
+          payload.parentNode.exitPoint = undefined
+          break
+        }
+        case 'Take Position Event': {
+          payload.parentNode.sellPoint = undefined
+          break
+        }
+      }
+    }
+
+    while (node.situations.length > 0) {
+      deleteSituation(node.situations[0])
+    }
+    destroyPart(node)
+    cleanNode(node)
+  }
+
+  function deleteManagedItem (node) {
+    let payload = node.payload
+    if (payload.parentNode !== undefined) {
+      switch (node.type) {
+        case 'Stop Loss': {
+          payload.parentNode.stopLoss = undefined
+          break
+        }
+        case 'Take Profit': {
+          payload.parentNode.buyOrder = undefined
+          break
+        }
+      }
+    }
+
+    while (node.phases.length > 0) {
+      deletePhase(node.phases[0])
+    }
+    destroyPart(node)
+    cleanNode(node)
+  }
+
+  function deletePhase (node) {
+    let payload = node.payload
+    if (payload.parentNode !== undefined) {
+      for (let k = 0; k < payload.parentNode.phases.length; k++) {
+        let phase = payload.parentNode.phases[k]
+        if (phase.id === node.id) {
+          while (phase.situations.length > 0) {
+            let situation = phase.situations[0]
+            deleteSituation(situation)
+          }
+          phase.situations = []
+      /* Before deleting this phase we need to give its chainParent to the next phase down the chain */
+          if (k < payload.parentNode.phases.length - 1) {
+            payload.parentNode.phases[k + 1].payload.chainParent = payload.chainParent
+          }
+      /* Continue destroying this phase */
+          payload.parentNode.phases.splice(k, 1)
+          destroyPart(phase)
+          cleanNode(phase)
+          return
+        }
+      }
+    } else {
+      while (node.situations.length > 0) {
+        let situation = node.situations[0]
+        deleteSituation(situation)
+      }
+      node.situations = []
+      destroyPart(node)
+      cleanNode(node)
+    }
+  }
+
+  function deleteSituation (node) {
+    let payload = node.payload
+    if (payload.parentNode !== undefined) {
+      for (let j = 0; j < payload.parentNode.situations.length; j++) {
+        let situation = payload.parentNode.situations[j]
+        if (situation.id === node.id) {
+          while (situation.conditions.length > 0) {
+            let condition = situation.conditions[0]
+            deleteCondition(condition)
+          }
+          situation.conditions = []
+          payload.parentNode.situations.splice(j, 1)
+          destroyPart(situation)
+          cleanNode(situation)
+          return
+        }
+      }
+    } else {
+      while (node.conditions.length > 0) {
+        let condition = node.conditions[0]
+        deleteCondition(condition)
+      }
+      node.conditions = []
+      destroyPart(node)
+      cleanNode(node)
+    }
+  }
+
+  function deleteCondition (node) {
+    let payload = node.payload
+    if (payload.parentNode !== undefined) {
+      for (let i = 0; i < payload.parentNode.conditions.length; i++) {
+        let condition = payload.parentNode.conditions[i]
+        if (condition.id === node.id) {
+          payload.parentNode.conditions.splice(i, 1)
+          destroyPart(node)
+          cleanNode(condition)
+          return
+        }
+      }
+    } else {
+      destroyPart(node)
+      cleanNode(node)
+    }
+  }
+
+  function cleanNode (node) {
+    node.payload.targetPosition.x = undefined
+    node.payload.targetPosition.y = undefined
+    node.payload.visible = undefined
+    node.payload.subTitle = undefined
+    node.payload.title = undefined
+    node.payload.node = undefined
+    node.payload.parentNode = undefined
+    node.payload.chainParent = undefined
+    node.payload.onMenuItemClick = undefined
+    node.handle = undefined
+    node.payload = undefined
+    node.cleaned = true
+  }
+}

StrategySpace/Workspace/FunctionLibraries/PartsConstructor.js

@@ -1,205 +0,0 @@
-function createPartFromNode (node, parentNode, chainParent) {
-  switch (node.type) {
-    case 'Condition':
-      {
-        let condition = node
-        createPart('Condition', condition.name, condition, parentNode, chainParent, 'Condition')
-        return
-      }
-    case 'Situation': {
-      let situation = node
-      createPart('Situation', situation.name, situation, parentNode, chainParent, 'Situation')
-      for (let m = 0; m < node.conditions.length; m++) {
-        let condition = node.conditions[m]
-        createPartFromNode(condition, situation, situation)
-      }
-      return
-    }
-    case 'Phase': {
-      let phase = node
-      createPart('Phase', phase.name, phase, parentNode, chainParent, phase.subType)
-      for (let m = 0; m < node.situations.length; m++) {
-        let situation = node.situations[m]
-        createPartFromNode(situation, phase, phase)
-      }
-      return
-    }
-    case 'Stop': {
-      let lastPhase
-      let stop = node
-      createPart('Stop', stop.name, stop, parentNode, chainParent, 'Stop')
-      for (let m = 0; m < node.phases.length; m++) {
-        let phase = node.phases[m]
-        let thisChainParent
-        if (m === 0) {
-          thisChainParent = node
-        } else {
-          thisChainParent = lastPhase
-        }
-        lastPhase = phase
-        createPartFromNode(phase, stop, thisChainParent)
-      }
-      return
-    }
-    case 'Take Profit': {
-      let lastPhase
-      let takeProfit = node
-      createPart('Take Profit', takeProfit.name, takeProfit, parentNode, chainParent, 'Take Profit')
-      for (let m = 0; m < node.phases.length; m++) {
-        let phase = node.phases[m]
-        let thisChainParent
-        if (m === 0) {
-          thisChainParent = node
-        } else {
-          thisChainParent = lastPhase
-        }
-        lastPhase = phase
-        createPartFromNode(phase, takeProfit, thisChainParent)
-      }
-      return
-    }
-    case 'Initial Definition': {
-      createPart('Initial Definition', node.name, node, parentNode, chainParent, 'Initial Definition')
-      return
-    }
-    case 'Take Position Event': {
-      let event = node
-      createPart('Take Position Event', event.name, event, parentNode, chainParent, 'Take Position Event')
-      for (let m = 0; m < node.situations.length; m++) {
-        let situation = node.situations[m]
-        createPartFromNode(situation, event, event)
-      }
-      return
-    }
-    case 'Trigger On Event': {
-      let event = node
-      createPart('Trigger On Event', event.name, event, parentNode, chainParent, 'Trigger On Event')
-      for (let m = 0; m < node.situations.length; m++) {
-        let situation = node.situations[m]
-        createPartFromNode(situation, event, event)
-      }
-      return
-    }
-    case 'Trigger Off Event': {
-      let event = node
-      createPart('Trigger Off Event', event.name, event, parentNode, chainParent, 'Trigger Off Event')
-      for (let m = 0; m < node.situations.length; m++) {
-        let situation = node.situations[m]
-        createPartFromNode(situation, event, event)
-      }
-      return
-    }
-    case 'Trigger Stage': {
-      let stage = node
-      createPart('Trigger Stage', stage.name, stage, parentNode, chainParent, 'Trigger Stage')
-
-      if (node.entryPoint !== undefined) {
-        createPartFromNode(node.entryPoint, stage, stage)
-      }
-      if (node.exitPoint !== undefined) {
-        createPartFromNode(node.exitPoint, stage, stage)
-      }
-      if (node.sellPoint !== undefined) {
-        createPartFromNode(node.sellPoint, stage, stage)
-      }
-      return
-    }
-    case 'Open Stage': {
-      let stage = node
-      createPart('Open Stage', stage.name, stage, parentNode, chainParent, 'Open Stage')
-
-      if (node.initialDefinition !== undefined) {
-        createPartFromNode(node.initialDefinition, stage, stage)
-      }
-      return
-    }
-    case 'Manage Stage': {
-      let stage = node
-      createPart('Manage Stage', stage.name, stage, parentNode, chainParent, 'Manage Stage')
-
-      if (node.stopLoss !== undefined) {
-        createPartFromNode(node.stopLoss, stage, stage)
-      }
-      if (node.buyOrder !== undefined) {
-        createPartFromNode(node.buyOrder, stage, stage)
-      }
-      return
-    }
-    case 'Close Stage': {
-      let stage = node
-      createPart('Close Stage', stage.name, stage, parentNode, chainParent, 'Close Stage')
-      return
-    }
-    case 'Strategy': {
-      let strategy = node
-      createPart('Strategy', strategy.name, strategy, parentNode, chainParent, 'Strategy')
-      if (node.triggerStage !== undefined) {
-        createPartFromNode(node.triggerStage, strategy, strategy)
-      }
-      if (node.openStage !== undefined) {
-        createPartFromNode(node.openStage, strategy, strategy)
-      }
-      if (node.manageStage !== undefined) {
-        createPartFromNode(node.manageStage, strategy, strategy)
-      }
-      if (node.closeStage !== undefined) {
-        createPartFromNode(node.closeStage, strategy, strategy)
-      }
-      return
-    }
-    case 'Trading System': {
-      let tradingSystem = node
-      createPart('Trading System', tradingSystem.name, tradingSystem, parentNode, chainParent, 'Trading System')
-      for (let m = 0; m < node.strategies.length; m++) {
-        let strategy = node.strategies[m]
-        createPartFromNode(strategy, tradingSystem, tradingSystem)
-      }
-      return
-    }
-  }
-}
-
-function createPart (partType, name, node, parentNode, chainParent, title) {
-  let payload = {}
-
-  if (name === '' || name === undefined) { name = 'My ' + partType }
-  if (node.savedPayload !== undefined) {
-    payload.targetPosition = {
-      x: node.savedPayload.targetPosition.x,
-      y: node.savedPayload.targetPosition.y
-    }
-    node.savedPayload.targetPosition = undefined
-  } else {
-    if (chainParent === undefined) {
-      payload.targetPosition = {
-        x: spawnPosition.x,
-        y: spawnPosition.y
-      }
-    } else {
-      payload.targetPosition = {
-        x: chainParent.payload.position.x,
-        y: chainParent.payload.position.y
-      }
-    }
-  }
-
-  if (title !== undefined) {
-    payload.subTitle = title
-  } else {
-    payload.subTitle = partType
-  }
-
-  payload.visible = true
-  payload.title = name
-  payload.node = node
-  payload.parentNode = parentNode
-  payload.chainParent = chainParent
-  payload.onMenuItemClick = onMenuItemClick
-
-  if (node.id === undefined) {
-    node.id = newUniqueId()
-  }
-  node.payload = payload
-  node.type = partType
-  canvas.floatingSpace.strategyPartConstructor.createStrategyPart(payload)
-}

StrategySpace/Workspace/FunctionLibraries/PartsFromNodes.js

@@ -0,0 +1,213 @@
+function newPartsFromNodes () {
+  thisObject = {
+    createPartFromNode: createPartFromNode
+  }
+
+  return newPartsFromNodes
+
+  function createPartFromNode (node, parentNode, chainParent) {
+    switch (node.type) {
+      case 'Condition':
+        {
+          let condition = node
+          createPart('Condition', condition.name, condition, parentNode, chainParent, 'Condition')
+          return
+        }
+      case 'Situation': {
+        let situation = node
+        createPart('Situation', situation.name, situation, parentNode, chainParent, 'Situation')
+        for (let m = 0; m < node.conditions.length; m++) {
+          let condition = node.conditions[m]
+          createPartFromNode(condition, situation, situation)
+        }
+        return
+      }
+      case 'Phase': {
+        let phase = node
+        createPart('Phase', phase.name, phase, parentNode, chainParent, phase.subType)
+        for (let m = 0; m < node.situations.length; m++) {
+          let situation = node.situations[m]
+          createPartFromNode(situation, phase, phase)
+        }
+        return
+      }
+      case 'Stop': {
+        let lastPhase
+        let stop = node
+        createPart('Stop', stop.name, stop, parentNode, chainParent, 'Stop')
+        for (let m = 0; m < node.phases.length; m++) {
+          let phase = node.phases[m]
+          let thisChainParent
+          if (m === 0) {
+            thisChainParent = node
+          } else {
+            thisChainParent = lastPhase
+          }
+          lastPhase = phase
+          createPartFromNode(phase, stop, thisChainParent)
+        }
+        return
+      }
+      case 'Take Profit': {
+        let lastPhase
+        let takeProfit = node
+        createPart('Take Profit', takeProfit.name, takeProfit, parentNode, chainParent, 'Take Profit')
+        for (let m = 0; m < node.phases.length; m++) {
+          let phase = node.phases[m]
+          let thisChainParent
+          if (m === 0) {
+            thisChainParent = node
+          } else {
+            thisChainParent = lastPhase
+          }
+          lastPhase = phase
+          createPartFromNode(phase, takeProfit, thisChainParent)
+        }
+        return
+      }
+      case 'Initial Definition': {
+        createPart('Initial Definition', node.name, node, parentNode, chainParent, 'Initial Definition')
+        return
+      }
+      case 'Take Position Event': {
+        let event = node
+        createPart('Take Position Event', event.name, event, parentNode, chainParent, 'Take Position Event')
+        for (let m = 0; m < node.situations.length; m++) {
+          let situation = node.situations[m]
+          createPartFromNode(situation, event, event)
+        }
+        return
+      }
+      case 'Trigger On Event': {
+        let event = node
+        createPart('Trigger On Event', event.name, event, parentNode, chainParent, 'Trigger On Event')
+        for (let m = 0; m < node.situations.length; m++) {
+          let situation = node.situations[m]
+          createPartFromNode(situation, event, event)
+        }
+        return
+      }
+      case 'Trigger Off Event': {
+        let event = node
+        createPart('Trigger Off Event', event.name, event, parentNode, chainParent, 'Trigger Off Event')
+        for (let m = 0; m < node.situations.length; m++) {
+          let situation = node.situations[m]
+          createPartFromNode(situation, event, event)
+        }
+        return
+      }
+      case 'Trigger Stage': {
+        let stage = node
+        createPart('Trigger Stage', stage.name, stage, parentNode, chainParent, 'Trigger Stage')
+
+        if (node.entryPoint !== undefined) {
+          createPartFromNode(node.entryPoint, stage, stage)
+        }
+        if (node.exitPoint !== undefined) {
+          createPartFromNode(node.exitPoint, stage, stage)
+        }
+        if (node.sellPoint !== undefined) {
+          createPartFromNode(node.sellPoint, stage, stage)
+        }
+        return
+      }
+      case 'Open Stage': {
+        let stage = node
+        createPart('Open Stage', stage.name, stage, parentNode, chainParent, 'Open Stage')
+
+        if (node.initialDefinition !== undefined) {
+          createPartFromNode(node.initialDefinition, stage, stage)
+        }
+        return
+      }
+      case 'Manage Stage': {
+        let stage = node
+        createPart('Manage Stage', stage.name, stage, parentNode, chainParent, 'Manage Stage')
+
+        if (node.stopLoss !== undefined) {
+          createPartFromNode(node.stopLoss, stage, stage)
+        }
+        if (node.buyOrder !== undefined) {
+          createPartFromNode(node.buyOrder, stage, stage)
+        }
+        return
+      }
+      case 'Close Stage': {
+        let stage = node
+        createPart('Close Stage', stage.name, stage, parentNode, chainParent, 'Close Stage')
+        return
+      }
+      case 'Strategy': {
+        let strategy = node
+        createPart('Strategy', strategy.name, strategy, parentNode, chainParent, 'Strategy')
+        if (node.triggerStage !== undefined) {
+          createPartFromNode(node.triggerStage, strategy, strategy)
+        }
+        if (node.openStage !== undefined) {
+          createPartFromNode(node.openStage, strategy, strategy)
+        }
+        if (node.manageStage !== undefined) {
+          createPartFromNode(node.manageStage, strategy, strategy)
+        }
+        if (node.closeStage !== undefined) {
+          createPartFromNode(node.closeStage, strategy, strategy)
+        }
+        return
+      }
+      case 'Trading System': {
+        let tradingSystem = node
+        createPart('Trading System', tradingSystem.name, tradingSystem, parentNode, chainParent, 'Trading System')
+        for (let m = 0; m < node.strategies.length; m++) {
+          let strategy = node.strategies[m]
+          createPartFromNode(strategy, tradingSystem, tradingSystem)
+        }
+        return
+      }
+    }
+  }
+
+  function createPart (partType, name, node, parentNode, chainParent, title) {
+    let payload = {}
+
+    if (name === '' || name === undefined) { name = 'My ' + partType }
+    if (node.savedPayload !== undefined) {
+      payload.targetPosition = {
+        x: node.savedPayload.targetPosition.x,
+        y: node.savedPayload.targetPosition.y
+      }
+      node.savedPayload.targetPosition = undefined
+    } else {
+      if (chainParent === undefined) {
+        payload.targetPosition = {
+          x: spawnPosition.x,
+          y: spawnPosition.y
+        }
+      } else {
+        payload.targetPosition = {
+          x: chainParent.payload.position.x,
+          y: chainParent.payload.position.y
+        }
+      }
+    }
+
+    if (title !== undefined) {
+      payload.subTitle = title
+    } else {
+      payload.subTitle = partType
+    }
+
+    payload.visible = true
+    payload.title = name
+    payload.node = node
+    payload.parentNode = parentNode
+    payload.chainParent = chainParent
+    payload.onMenuItemClick = onMenuItemClick
+
+    if (node.id === undefined) {
+      node.id = newUniqueId()
+    }
+    node.payload = payload
+    node.type = partType
+    canvas.floatingSpace.strategyPartConstructor.createStrategyPart(payload)
+  }
+}

StrategySpace/Workspace/FunctionLibraries/ProtocolNode.js

@@ -1,195 +1,202 @@
-function getProtocolNode (node) {
-  switch (node.type) {
-    case 'Condition':
-      {
-        let condition = {
+function newProtocolNode () {
+  thisObject = {
+    getProtocolNode: getProtocolNode
+  }
+  return thisObject
+
+  function getProtocolNode (node) {
+    switch (node.type) {
+      case 'Condition':
+        {
+          let condition = {
+            type: node.type,
+            subType: node.subType,
+            name: node.name,
+            code: node.code
+          }
+          return condition
+        }
+      case 'Situation': {
+        let situation = {
           type: node.type,
           subType: node.subType,
           name: node.name,
-          code: node.code
+          conditions: []
         }
-        return condition
-      }
-    case 'Situation': {
-      let situation = {
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        conditions: []
-      }
 
-      for (let m = 0; m < node.conditions.length; m++) {
-        let condition = getProtocolNode(node.conditions[m])
-        situation.conditions.push(condition)
-      }
-      return situation
-    }
-    case 'Phase': {
-      let phase = {
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        code: node.code,
-        situations: []
+        for (let m = 0; m < node.conditions.length; m++) {
+          let condition = getProtocolNode(node.conditions[m])
+          situation.conditions.push(condition)
+        }
+        return situation
       }
+      case 'Phase': {
+        let phase = {
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          code: node.code,
+          situations: []
+        }
 
-      for (let m = 0; m < node.situations.length; m++) {
-        let situation = getProtocolNode(node.situations[m])
-        phase.situations.push(situation)
-      }
-      return phase
-    }
-    case 'Stop': {
-      if (node === undefined) { return }
-      let stop = {
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        phases: []
+        for (let m = 0; m < node.situations.length; m++) {
+          let situation = getProtocolNode(node.situations[m])
+          phase.situations.push(situation)
+        }
+        return phase
       }
+      case 'Stop': {
+        if (node === undefined) { return }
+        let stop = {
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          phases: []
+        }
 
-      for (let m = 0; m < node.phases.length; m++) {
-        let phase = getProtocolNode(node.phases[m])
-        stop.phases.push(phase)
-      }
-      return stop
-    }
-    case 'Take Profit': {
-      if (node === undefined) { return }
-      let takeProfit = {
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        phases: []
+        for (let m = 0; m < node.phases.length; m++) {
+          let phase = getProtocolNode(node.phases[m])
+          stop.phases.push(phase)
+        }
+        return stop
       }
+      case 'Take Profit': {
+        if (node === undefined) { return }
+        let takeProfit = {
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          phases: []
+        }
 
-      for (let m = 0; m < node.phases.length; m++) {
-        let phase = getProtocolNode(node.phases[m])
-        takeProfit.phases.push(phase)
-      }
-      return takeProfit
-    }
-    case 'Take Position Event': {
-      if (node === undefined) { return }
-      let event = {
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        situations: []
+        for (let m = 0; m < node.phases.length; m++) {
+          let phase = getProtocolNode(node.phases[m])
+          takeProfit.phases.push(phase)
+        }
+        return takeProfit
       }
+      case 'Take Position Event': {
+        if (node === undefined) { return }
+        let event = {
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          situations: []
+        }
 
-      for (let m = 0; m < node.situations.length; m++) {
-        let situation = getProtocolNode(node.situations[m])
-        event.situations.push(situation)
-      }
-      return event
-    }
-    case 'Trigger On Event': {
-      if (node === undefined) { return }
-      let event = {
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        situations: []
+        for (let m = 0; m < node.situations.length; m++) {
+          let situation = getProtocolNode(node.situations[m])
+          event.situations.push(situation)
+        }
+        return event
       }
+      case 'Trigger On Event': {
+        if (node === undefined) { return }
+        let event = {
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          situations: []
+        }
 
-      for (let m = 0; m < node.situations.length; m++) {
-        let situation = getProtocolNode(node.situations[m])
-        event.situations.push(situation)
-      }
-      return event
-    }
-    case 'Trigger Off Event': {
-      if (node === undefined) { return }
-      let event = {
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        situations: []
+        for (let m = 0; m < node.situations.length; m++) {
+          let situation = getProtocolNode(node.situations[m])
+          event.situations.push(situation)
+        }
+        return event
       }
+      case 'Trigger Off Event': {
+        if (node === undefined) { return }
+        let event = {
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          situations: []
+        }
 
-      for (let m = 0; m < node.situations.length; m++) {
-        let situation = getProtocolNode(node.situations[m])
-        event.situations.push(situation)
+        for (let m = 0; m < node.situations.length; m++) {
+          let situation = getProtocolNode(node.situations[m])
+          event.situations.push(situation)
+        }
+        return event
       }
-      return event
-    }
-    case 'Initial Definition': {
-      if (node === undefined) { return }
-      let object = {
-        type: node.type,
-        subType: node.subType,
-        name: node.name
+      case 'Initial Definition': {
+        if (node === undefined) { return }
+        let object = {
+          type: node.type,
+          subType: node.subType,
+          name: node.name
+        }
+        return object
       }
-      return object
-    }
-    case 'Trigger Stage': {
-      if (node === undefined) { return }
-      let stage = {
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        entryPoint: getProtocolNode(node.entryPoint),
-        exitPoint: getProtocolNode(node.exitPoint),
-        sellPoint: getProtocolNode(node.sellPoint)
+      case 'Trigger Stage': {
+        if (node === undefined) { return }
+        let stage = {
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          entryPoint: getProtocolNode(node.entryPoint),
+          exitPoint: getProtocolNode(node.exitPoint),
+          sellPoint: getProtocolNode(node.sellPoint)
+        }
+        return stage
       }
-      return stage
-    }
-    case 'Open Stage': {
-      if (node === undefined) { return }
-      let stage = {
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        initialDefinition: getProtocolNode(node.initialDefinition)
+      case 'Open Stage': {
+        if (node === undefined) { return }
+        let stage = {
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          initialDefinition: getProtocolNode(node.initialDefinition)
+        }
+        return stage
       }
-      return stage
-    }
-    case 'Manage Stage': {
-      if (node === undefined) { return }
-      let stage = {
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        stopLoss: getProtocolNode(node.stopLoss),
-        buyOrder: getProtocolNode(node.buyOrder)
+      case 'Manage Stage': {
+        if (node === undefined) { return }
+        let stage = {
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          stopLoss: getProtocolNode(node.stopLoss),
+          buyOrder: getProtocolNode(node.buyOrder)
+        }
+        return stage
       }
-      return stage
-    }
-    case 'Close Stage': {
-      if (node === undefined) { return }
-      let stage = {
-        type: node.type,
-        subType: node.subType,
-        name: node.name
+      case 'Close Stage': {
+        if (node === undefined) { return }
+        let stage = {
+          type: node.type,
+          subType: node.subType,
+          name: node.name
+        }
+        return stage
       }
-      return stage
-    }
-    case 'Strategy': {
-      let strategy = {
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        triggerStage: getProtocolNode(node.triggerStage),
-        openStage: getProtocolNode(node.openStage),
-        manageStage: getProtocolNode(node.manageStage),
-        closeStage: getProtocolNode(node.closeStage)
-      }
-      return strategy
-    }
-    case 'Trading System': {
-      let tradingSystem = {
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        strategies: []
+      case 'Strategy': {
+        let strategy = {
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          triggerStage: getProtocolNode(node.triggerStage),
+          openStage: getProtocolNode(node.openStage),
+          manageStage: getProtocolNode(node.manageStage),
+          closeStage: getProtocolNode(node.closeStage)
+        }
+        return strategy
       }
+      case 'Trading System': {
+        let tradingSystem = {
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          strategies: []
+        }
 
-      for (let m = 0; m < node.strategies.length; m++) {
-        let strategy = getProtocolNode(node.strategies[m])
-        tradingSystem.strategies.push(strategy)
+        for (let m = 0; m < node.strategies.length; m++) {
+          let strategy = getProtocolNode(node.strategies[m])
+          tradingSystem.strategies.push(strategy)
+        }
+        return tradingSystem
       }
-      return tradingSystem
     }
   }
 }

StrategySpace/Workspace/FunctionLibraries/WorkspaceNode.js

@@ -1,246 +1,253 @@
-function getWorkspaceNode (node) {
-  switch (node.type) {
-    case 'Condition':
-      {
-        let condition = {
+function newProtocolNode () {
+  thisObject = {
+    getWorkspaceNode: getWorkspaceNode
+  }
+  return thisObject
+
+  function getWorkspaceNode (node) {
+    switch (node.type) {
+      case 'Condition':
+        {
+          let condition = {
+            id: node.id,
+            type: node.type,
+            subType: node.subType,
+            name: node.name,
+            code: node.code,
+            savedPayload: getSavedPayload(node)
+          }
+          return condition
+        }
+      case 'Situation': {
+        let situation = {
+          id: node.id,
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          conditions: [],
+          savedPayload: getSavedPayload(node)
+        }
+
+        for (let m = 0; m < node.conditions.length; m++) {
+          let condition = getWorkspaceNode(node.conditions[m])
+          situation.conditions.push(condition)
+        }
+        return situation
+      }
+      case 'Phase': {
+        let phase = {
           id: node.id,
           type: node.type,
           subType: node.subType,
           name: node.name,
           code: node.code,
+          situations: [],
           savedPayload: getSavedPayload(node)
         }
-        return condition
-      }
-    case 'Situation': {
-      let situation = {
-        id: node.id,
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        conditions: [],
-        savedPayload: getSavedPayload(node)
-      }
 
-      for (let m = 0; m < node.conditions.length; m++) {
-        let condition = getWorkspaceNode(node.conditions[m])
-        situation.conditions.push(condition)
-      }
-      return situation
-    }
-    case 'Phase': {
-      let phase = {
-        id: node.id,
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        code: node.code,
-        situations: [],
-        savedPayload: getSavedPayload(node)
+        for (let m = 0; m < node.situations.length; m++) {
+          let situation = getWorkspaceNode(node.situations[m])
+          phase.situations.push(situation)
+        }
+        return phase
       }
+      case 'Stop': {
+        if (node === undefined) { return }
+        let stop = {
+          id: node.id,
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          phases: [],
+          savedPayload: getSavedPayload(node)
+        }
 
-      for (let m = 0; m < node.situations.length; m++) {
-        let situation = getWorkspaceNode(node.situations[m])
-        phase.situations.push(situation)
-      }
-      return phase
-    }
-    case 'Stop': {
-      if (node === undefined) { return }
-      let stop = {
-        id: node.id,
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        phases: [],
-        savedPayload: getSavedPayload(node)
+        for (let m = 0; m < node.phases.length; m++) {
+          let phase = getWorkspaceNode(node.phases[m])
+          stop.phases.push(phase)
+        }
+        return stop
       }
+      case 'Take Profit': {
+        if (node === undefined) { return }
+        let takeProfit = {
+          id: node.id,
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          phases: [],
+          savedPayload: getSavedPayload(node)
+        }
 
-      for (let m = 0; m < node.phases.length; m++) {
-        let phase = getWorkspaceNode(node.phases[m])
-        stop.phases.push(phase)
-      }
-      return stop
-    }
-    case 'Take Profit': {
-      if (node === undefined) { return }
-      let takeProfit = {
-        id: node.id,
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        phases: [],
-        savedPayload: getSavedPayload(node)
+        for (let m = 0; m < node.phases.length; m++) {
+          let phase = getWorkspaceNode(node.phases[m])
+          takeProfit.phases.push(phase)
+        }
+        return takeProfit
       }
+      case 'Take Position Event': {
+        if (node === undefined) { return }
+        let event = {
+          id: node.id,
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          situations: [],
+          savedPayload: getSavedPayload(node)
+        }
 
-      for (let m = 0; m < node.phases.length; m++) {
-        let phase = getWorkspaceNode(node.phases[m])
-        takeProfit.phases.push(phase)
-      }
-      return takeProfit
-    }
-    case 'Take Position Event': {
-      if (node === undefined) { return }
-      let event = {
-        id: node.id,
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        situations: [],
-        savedPayload: getSavedPayload(node)
+        for (let m = 0; m < node.situations.length; m++) {
+          let situation = getWorkspaceNode(node.situations[m])
+          event.situations.push(situation)
+        }
+        return event
       }
+      case 'Trigger On Event': {
+        if (node === undefined) { return }
+        let event = {
+          id: node.id,
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          situations: [],
+          savedPayload: getSavedPayload(node)
+        }
 
-      for (let m = 0; m < node.situations.length; m++) {
-        let situation = getWorkspaceNode(node.situations[m])
-        event.situations.push(situation)
-      }
-      return event
-    }
-    case 'Trigger On Event': {
-      if (node === undefined) { return }
-      let event = {
-        id: node.id,
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        situations: [],
-        savedPayload: getSavedPayload(node)
+        for (let m = 0; m < node.situations.length; m++) {
+          let situation = getWorkspaceNode(node.situations[m])
+          event.situations.push(situation)
+        }
+        return event
       }
+      case 'Trigger Off Event': {
+        if (node === undefined) { return }
+        let event = {
+          id: node.id,
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          situations: [],
+          savedPayload: getSavedPayload(node)
+        }
 
-      for (let m = 0; m < node.situations.length; m++) {
-        let situation = getWorkspaceNode(node.situations[m])
-        event.situations.push(situation)
+        for (let m = 0; m < node.situations.length; m++) {
+          let situation = getWorkspaceNode(node.situations[m])
+          event.situations.push(situation)
+        }
+        return event
       }
-      return event
-    }
-    case 'Trigger Off Event': {
-      if (node === undefined) { return }
-      let event = {
-        id: node.id,
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        situations: [],
-        savedPayload: getSavedPayload(node)
+      case 'Initial Definition': {
+        if (node === undefined) { return }
+        let object = {
+          id: node.id,
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          savedPayload: getSavedPayload(node)
+        }
+        return object
       }
+      case 'Trigger Stage': {
+        if (node === undefined) { return }
+        let stage = {
+          id: node.id,
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          entryPoint: getWorkspaceNode(node.entryPoint),
+          exitPoint: getWorkspaceNode(node.exitPoint),
+          sellPoint: getWorkspaceNode(node.sellPoint),
+          savedPayload: getSavedPayload(node)
+        }
+        return stage
+      }
+      case 'Open Stage': {
+        if (node === undefined) { return }
+        let stage = {
+          id: node.id,
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          initialDefinition: getWorkspaceNode(node.initialDefinition),
+          savedPayload: getSavedPayload(node)
+        }
+        return stage
+      }
+      case 'Manage Stage': {
+        if (node === undefined) { return }
+        let stage = {
+          id: node.id,
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          stopLoss: getWorkspaceNode(node.stopLoss),
+          buyOrder: getWorkspaceNode(node.buyOrder),
+          savedPayload: getSavedPayload(node)
+        }
+        return stage
+      }
+      case 'Close Stage': {
+        if (node === undefined) { return }
+        let stage = {
+          id: node.id,
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          savedPayload: getSavedPayload(node)
+        }
+        return stage
+      }
+      case 'Strategy': {
+        let strategy = {
+          id: node.id,
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          entryPoint: getWorkspaceNode(node.entryPoint),
+          exitPoint: getWorkspaceNode(node.exitPoint),
+          sellPoint: getWorkspaceNode(node.sellPoint),
+          stopLoss: getWorkspaceNode(node.stopLoss),
+          buyOrder: getWorkspaceNode(node.buyOrder),
+          savedPayload: getSavedPayload(node)
+        }
+        return strategy
+      }
+      case 'Trading System': {
+        let tradingSystem = {
+          id: node.id,
+          type: node.type,
+          subType: node.subType,
+          name: node.name,
+          strategies: [],
+          savedPayload: getSavedPayload(node)
+        }
 
-      for (let m = 0; m < node.situations.length; m++) {
-        let situation = getWorkspaceNode(node.situations[m])
-        event.situations.push(situation)
+        for (let m = 0; m < node.strategies.length; m++) {
+          let strategy = getWorkspaceNode(node.strategies[m])
+          tradingSystem.strategies.push(strategy)
+        }
+        return tradingSystem
       }
-      return event
-    }
-    case 'Initial Definition': {
-      if (node === undefined) { return }
-      let object = {
-        id: node.id,
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        savedPayload: getSavedPayload(node)
-      }
-      return object
-    }
-    case 'Trigger Stage': {
-      if (node === undefined) { return }
-      let stage = {
-        id: node.id,
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        entryPoint: getWorkspaceNode(node.entryPoint),
-        exitPoint: getWorkspaceNode(node.exitPoint),
-        sellPoint: getWorkspaceNode(node.sellPoint),
-        savedPayload: getSavedPayload(node)
-      }
-      return stage
-    }
-    case 'Open Stage': {
-      if (node === undefined) { return }
-      let stage = {
-        id: node.id,
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        initialDefinition: getWorkspaceNode(node.initialDefinition),
-        savedPayload: getSavedPayload(node)
-      }
-      return stage
-    }
-    case 'Manage Stage': {
-      if (node === undefined) { return }
-      let stage = {
-        id: node.id,
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        stopLoss: getWorkspaceNode(node.stopLoss),
-        buyOrder: getWorkspaceNode(node.buyOrder),
-        savedPayload: getSavedPayload(node)
-      }
-      return stage
-    }
-    case 'Close Stage': {
-      if (node === undefined) { return }
-      let stage = {
-        id: node.id,
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        savedPayload: getSavedPayload(node)
-      }
-      return stage
-    }
-    case 'Strategy': {
-      let strategy = {
-        id: node.id,
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        entryPoint: getWorkspaceNode(node.entryPoint),
-        exitPoint: getWorkspaceNode(node.exitPoint),
-        sellPoint: getWorkspaceNode(node.sellPoint),
-        stopLoss: getWorkspaceNode(node.stopLoss),
-        buyOrder: getWorkspaceNode(node.buyOrder),
-        savedPayload: getSavedPayload(node)
-      }
-      return strategy
-    }
-    case 'Trading System': {
-      let tradingSystem = {
-        id: node.id,
-        type: node.type,
-        subType: node.subType,
-        name: node.name,
-        strategies: [],
-        savedPayload: getSavedPayload(node)
-      }
-
-      for (let m = 0; m < node.strategies.length; m++) {
-        let strategy = getWorkspaceNode(node.strategies[m])
-        tradingSystem.strategies.push(strategy)
-      }
-      return tradingSystem
     }
   }
-}
 
-function getSavedPayload (node) {
-  let savedPayload = {
-    position: {
-      x: node.payload.position.x,
-      y: node.payload.position.y
-    },
-    targetPosition: {
-      x: node.payload.targetPosition.x,
-      y: node.payload.targetPosition.y
-    },
-    floatingObject: {
-      isPinned: node.payload.floatingObject.isPinned
-    },
-    uiObject: {
-      isRunning: node.payload.uiObject.isRunning
+  function getSavedPayload (node) {
+    let savedPayload = {
+      position: {
+        x: node.payload.position.x,
+        y: node.payload.position.y
+      },
+      targetPosition: {
+        x: node.payload.targetPosition.x,
+        y: node.payload.targetPosition.y
+      },
+      floatingObject: {
+        isPinned: node.payload.floatingObject.isPinned
+      },
+      uiObject: {
+        isRunning: node.payload.uiObject.isRunning
+      }
     }
+    return savedPayload
   }
-  return savedPayload
 }

StrategySpace/Workspace/Workspace.js

@@ -34,6 +34,12 @@ function newWorkspace () {
 
   let rootNodes = []
 
+  functionLibraryAttachDetach = newAttachDetach()
+  functionLibraryNodeDeleter = newNodeDeleter()
+  functionLibraryPartsFromNodes = newPartsFromNodes()
+  functionLibraryProtocolNode = newProtocolNode()
+  functionLibraryWorkspaceNodes = newWorkspaceNode()
+
   return thisObject
 
   function finalize () {
@@ -43,6 +49,12 @@ function newWorkspace () {
   }
 
   async function initialize () {
+    functionLibraryAttachDetach = newAttachDetach()
+    functionLibraryNodeDeleter = newNodeDeleter()
+    functionLibraryPartsFromNodes = newPartsFromNodes()
+    functionLibraryProtocolNode = newProtocolNode()
+    functionLibraryWorkspaceNodes = newWorkspaceNode()
+
     let savedWorkspace = window.localStorage.getItem('workspace')
     if (savedWorkspace === null) {
       initializeLoadingFromStrategizer()
@@ -55,7 +67,7 @@ function newWorkspace () {
       } else {
         for (let i = 0; i < rootNodes.length; i++) {
           let rootNode = rootNodes[i]
-          createPartFromNode(rootNode, undefined, undefined)
+          functionLibraryPartsFromNodes.createPartFromNode(rootNode, undefined, undefined)
         }
       }
     }
@@ -70,7 +82,7 @@ function newWorkspace () {
       }
       thisObject.idAtStrategizer = tradingSystem.id
       rootNodes.push(adaptedTradingSystem)
-      generateStrategyParts(adaptedTradingSystem)
+      functionLibraryPartsFromNodes.createPartFromNode(adaptedTradingSystem, undefined, undefined)
       thisObject.tradingSystem = adaptedTradingSystem
       thisObject.tradingSystem.payload.uiObject.setRunningStatus()
     }
@@ -81,13 +93,11 @@ function newWorkspace () {
   }
 
   function detachNode (node) {
-    let functionsLibrary = newDetachAttach()
-    functionsLibrary.detachNode(node)
+    functionLibraryAttachDetach.detachNode(node)
   }
 
   function attachNode (node) {
-    let functionsLibrary = newDetachAttach()
-    functionsLibrary.attachNode(node)
+    functionLibraryAttachDetach.attachNode(node)
   }
 
   function physics () {
@@ -95,7 +105,7 @@ function newWorkspace () {
     let stringifyReadyNodes = []
     for (let i = 0; i < rootNodes.length; i++) {
       let rootNode = rootNodes[i]
-      let workspaceNode = getWorkspaceNode(rootNode)
+      let workspaceNode = functionLibraryWorkspaceNodes.getWorkspaceNode(rootNode)
       stringifyReadyNodes.push(workspaceNode)
     }
     let workspace = {
@@ -112,101 +122,9 @@ function newWorkspace () {
     spawnPosition.y = point.y
 
     let dirtyNode = JSON.parse(nodeText)
-    let rootNode = getProtocolNode(dirtyNode)
+    let rootNode = functionLibraryProtocolNode.getProtocolNode(dirtyNode)
     rootNodes.push(rootNode)
-    createPartFromNode(rootNode, undefined, undefined)
-  }
-
-  function generateStrategyParts (node) {
-    let lastPhase
-    let tradingSystem = node
-
-    createPart('Trading System', tradingSystem.name, tradingSystem, undefined, undefined)
-
-    for (m = 0; m < tradingSystem.strategies.length; m++) {
-      let strategy = tradingSystem.strategies[m]
-      createPart('Strategy', strategy.name, strategy, tradingSystem, tradingSystem)
-
-      createPart('Trigger On Event', '', strategy.entryPoint, strategy, strategy)
-      for (let k = 0; k < strategy.entryPoint.situations.length; k++) {
-        let situation = strategy.entryPoint.situations[k]
-        createPart('Situation', situation.name, situation, strategy.entryPoint, strategy.entryPoint, 'Trigger On' + ' ' + 'Situation')
-
-        for (let m = 0; m < situation.conditions.length; m++) {
-          let condition = situation.conditions[m]
-          createPart('Condition', condition.name, condition, situation, situation, 'Condition')
-        }
-      }
-
-      createPart('Trigger Off Event', '', strategy.exitPoint, strategy, strategy)
-      for (let k = 0; k < strategy.exitPoint.situations.length; k++) {
-        let situation = strategy.exitPoint.situations[k]
-        createPart('Situation', situation.name, situation, strategy.exitPoint, strategy.exitPoint, 'Trigger Off' + ' ' + 'Situation')
-
-        for (let m = 0; m < situation.conditions.length; m++) {
-          let condition = situation.conditions[m]
-          createPart('Condition', condition.name, condition, situation, situation, 'Condition')
-        }
-      }
-
-      createPart('Take Position Event', '', strategy.sellPoint, strategy, strategy)
-      for (let k = 0; k < strategy.sellPoint.situations.length; k++) {
-        let situation = strategy.sellPoint.situations[k]
-        createPart('Situation', situation.name, situation, strategy.sellPoint, strategy.sellPoint, 'Take Position' + ' ' + 'Situation')
-
-        for (let m = 0; m < situation.conditions.length; m++) {
-          let condition = situation.conditions[m]
-          createPart('Condition', condition.name, condition, situation, situation, 'Condition')
-        }
-      }
-
-      createPart('Stop', '', strategy.stopLoss, strategy, strategy)
-      for (let p = 0; p < strategy.stopLoss.phases.length; p++) {
-        let phase = strategy.stopLoss.phases[p]
-
-        let chainParent
-        if (p === 0) {
-          chainParent = strategy.stopLoss
-        } else {
-          chainParent = lastPhase
-        }
-        lastPhase = phase
-        createPart('Phase', phase.name, phase, strategy.stopLoss, chainParent, 'Stop Phase')
-
-        for (let k = 0; k < phase.situations.length; k++) {
-          let situation = phase.situations[k]
-          createPart('Situation', situation.name, situation, phase, phase, 'Situation')
-
-          for (let m = 0; m < situation.conditions.length; m++) {
-            let condition = situation.conditions[m]
-            createPart('Condition', condition.name, condition, situation, situation, 'Condition')
-          }
-        }
-      }
-
-      createPart('Take Profit', '', strategy.buyOrder, strategy, strategy)
-      for (let p = 0; p < strategy.buyOrder.phases.length; p++) {
-        let phase = strategy.buyOrder.phases[p]
-        let chainParent
-        if (p === 0) {
-          chainParent = strategy.buyOrder
-        } else {
-          chainParent = lastPhase
-        }
-        lastPhase = phase
-        createPart('Phase', phase.name, phase, strategy.buyOrder, chainParent, 'Take Profit Phase')
-
-        for (let k = 0; k < phase.situations.length; k++) {
-          let situation = phase.situations[k]
-          createPart('Situation', situation.name, situation, phase, phase, 'Situation')
-
-          for (let m = 0; m < situation.conditions.length; m++) {
-            let condition = situation.conditions[m]
-            createPart('Condition', condition.name, condition, situation, situation, 'Condition')
-          }
-        }
-      }
-    }
+    functionLibraryPartsFromNodes.createPartFromNode(rootNode, undefined, undefined)
   }
 
   async function onMenuItemClick (payload, action) {
@@ -223,7 +141,7 @@ function newWorkspace () {
         break
       case 'Download':
 
-        let text = JSON.stringify(getProtocolNode(payload.node))
+        let text = JSON.stringify(functionLibraryProtocolNode.getProtocolNode(payload.node))
         let nodeName = payload.node.name
         if (nodeName === undefined) {
           nodeName = ''
@@ -326,35 +244,35 @@ function newWorkspace () {
         }
         break
       case 'Delete Strategy': {
-        deleteStrategy(payload.node)
+        functionLibraryNodeDeleter.deleteStrategy(payload.node)
         break
       }
       case 'Delete Trigger Stage': {
-        deleteTriggerStage(payload.node)
+        functionLibraryNodeDeleter.deleteTriggerStage(payload.node)
         break
       }
       case 'Delete Open Stage': {
-        deleteOpenStage(payload.node)
+        functionLibraryNodeDeleter.deleteOpenStage(payload.node)
         break
       }
       case 'Delete Manage Stage': {
-        deleteManageStage(payload.node)
+        functionLibraryNodeDeleter.deleteManageStage(payload.node)
         break
       }
       case 'Delete Close Stage': {
-        deleteClose(payload.node)
+        functionLibraryNodeDeleter.deleteClose(payload.node)
         break
       }
       case 'Delete Phase': {
-        deletePhase(payload.node)
+        functionLibraryNodeDeleter.deletePhase(payload.node)
         break
       }
       case 'Delete Situation': {
-        deleteSituation(payload.node)
+        functionLibraryNodeDeleter.deleteSituation(payload.node)
         break
       }
       case 'Delete Condition': {
-        deleteCondition(payload.node)
+        functionLibraryNodeDeleter.deleteCondition(payload.node)
         break
       }
       default: