Refactoring Out old names

FloatingSpace/StrategyPart.js

@@ -255,12 +255,12 @@ function newStrategyPart () {
         if (thisObject.payload.node.type === 'Open Stage' && nearbyNode.openStage !== undefined) { continue }
         if (thisObject.payload.node.type === 'Manage Stage' && nearbyNode.manageStage !== undefined) { continue }
         if (thisObject.payload.node.type === 'Close Stage' && nearbyNode.closeStage !== undefined) { continue }
-        if (thisObject.payload.node.type === 'Take Position Event' && nearbyNode.sellPoint !== undefined) { continue }
-        if (thisObject.payload.node.type === 'Trigger Off Event' && nearbyNode.exitPoint !== undefined) { continue }
-        if (thisObject.payload.node.type === 'Trigger On Event' && nearbyNode.entryPoint !== undefined) { continue }
+        if (thisObject.payload.node.type === 'Take Position Event' && nearbyNode.takePosition !== undefined) { continue }
+        if (thisObject.payload.node.type === 'Trigger Off Event' && nearbyNode.triggerOff !== undefined) { continue }
+        if (thisObject.payload.node.type === 'Trigger On Event' && nearbyNode.triggerOn !== undefined) { continue }
         if (thisObject.payload.node.type === 'Initial Definition' && nearbyNode.initialDefinition !== undefined) { continue }
         if (thisObject.payload.node.type === 'Stop' && nearbyNode.stopLoss !== undefined) { continue }
-        if (thisObject.payload.node.type === 'Take Profit' && nearbyNode.buyOrder !== undefined) { continue }
+        if (thisObject.payload.node.type === 'Take Profit' && nearbyNode.takeProfit !== undefined) { continue }
         /* Discard Phases without partent */
         if (thisObject.payload.node.type === 'Phase' && nearbyNode.type === 'Phase' && nearbyNode.payload.parentNode === undefined) { continue }
         if (foundCompatible === false) {

StrategySpace/ConstGetStrategies.js

@@ -6,7 +6,7 @@ const GRAPHQL_QUERY_GET_STRATEGIES = Apollo.gql`
               subStrategies(activeOnly: true){
                   name
                   active
-                  entryPoint{
+                  triggerOn{
                   situations{
                       name
                       conditions{
@@ -15,7 +15,7 @@ const GRAPHQL_QUERY_GET_STRATEGIES = Apollo.gql`
                       }
                   }
                   }
-                  exitPoint{
+                  triggerOff{
                   situations{
                       name
                       conditions{
@@ -24,7 +24,7 @@ const GRAPHQL_QUERY_GET_STRATEGIES = Apollo.gql`
                       }
                   }
                   }
-                  sellPoint{
+                  takePosition{
                   situations{
                       name
                       conditions{
@@ -55,7 +55,7 @@ const GRAPHQL_QUERY_GET_STRATEGIES = Apollo.gql`
                       }
                   }
                   }
-                  buyOrder{
+                  takeProfit{
                   phases{
                       name
                       code

StrategySpace/StrategizerGateway.js

@@ -118,25 +118,25 @@ function newStrategizerGateway () {
       let strategy = {
         name: strategizerGatewayStrategy.name,
         active: strategizerGatewayStrategy.active,
-        entryPoint: {
+        triggerOn: {
           situations: []
         },
-        exitPoint: {
+        triggerOff: {
           situations: []
         },
-        sellPoint: {
+        takePosition: {
           situations: []
         },
         stopLoss: {
           phases: []
         },
-        buyOrder: {
+        takeProfit: {
           phases: []
         }
       }
 
-      for (let k = 0; k < strategizerGatewayStrategy.entryPoint.situations.length; k++) {
-        let strategizerGatewaySituation = strategizerGatewayStrategy.entryPoint.situations[k]
+      for (let k = 0; k < strategizerGatewayStrategy.triggerOn.situations.length; k++) {
+        let strategizerGatewaySituation = strategizerGatewayStrategy.triggerOn.situations[k]
         let situation = {
           name: strategizerGatewaySituation.name,
           conditions: []
@@ -150,11 +150,11 @@ function newStrategizerGateway () {
           }
           situation.conditions.push(condition)
         }
-        strategy.entryPoint.situations.push(situation)
+        strategy.triggerOn.situations.push(situation)
       }
 
-      for (let k = 0; k < strategizerGatewayStrategy.exitPoint.situations.length; k++) {
-        let strategizerGatewaySituation = strategizerGatewayStrategy.exitPoint.situations[k]
+      for (let k = 0; k < strategizerGatewayStrategy.triggerOff.situations.length; k++) {
+        let strategizerGatewaySituation = strategizerGatewayStrategy.triggerOff.situations[k]
         let situation = {
           name: strategizerGatewaySituation.name,
           conditions: []
@@ -168,11 +168,11 @@ function newStrategizerGateway () {
           }
           situation.conditions.push(condition)
         }
-        strategy.exitPoint.situations.push(situation)
+        strategy.triggerOff.situations.push(situation)
       }
 
-      for (let k = 0; k < strategizerGatewayStrategy.sellPoint.situations.length; k++) {
-        let strategizerGatewaySituation = strategizerGatewayStrategy.sellPoint.situations[k]
+      for (let k = 0; k < strategizerGatewayStrategy.takePosition.situations.length; k++) {
+        let strategizerGatewaySituation = strategizerGatewayStrategy.takePosition.situations[k]
         let situation = {
           name: strategizerGatewaySituation.name,
           conditions: []
@@ -186,7 +186,7 @@ function newStrategizerGateway () {
           }
           situation.conditions.push(condition)
         }
-        strategy.sellPoint.situations.push(situation)
+        strategy.takePosition.situations.push(situation)
       }
 
       for (let p = 0; p < strategizerGatewayStrategy.stopLoss.phases.length; p++) {
@@ -217,8 +217,8 @@ function newStrategizerGateway () {
         strategy.stopLoss.phases.push(phase)
       }
 
-      for (let p = 0; p < strategizerGatewayStrategy.buyOrder.phases.length; p++) {
-        let strategizerGatewayPhase = strategizerGatewayStrategy.buyOrder.phases[p]
+      for (let p = 0; p < strategizerGatewayStrategy.takeProfit.phases.length; p++) {
+        let strategizerGatewayPhase = strategizerGatewayStrategy.takeProfit.phases[p]
         let phase = {
           name: strategizerGatewayPhase.name,
           code: strategizerGatewayPhase.code,
@@ -242,7 +242,7 @@ function newStrategizerGateway () {
           }
           phase.situations.push(situation)
         }
-        strategy.buyOrder.phases.push(phase)
+        strategy.takeProfit.phases.push(phase)
       }
       dataToSave.strategy.subStrategies.push(strategy)
     }

StrategySpace/Workspace/FunctionLibraries/AttachDetach.js

@@ -43,19 +43,19 @@ function newAttachDetach () {
         return
       }
       case 'Trigger On Event': {
-        node.payload.parentNode.entryPoint = undefined
+        node.payload.parentNode.triggerOn = undefined
         completeDetachment(node, rootNodes)
         return
       }
         break
       case 'Trigger Off Event': {
-        node.payload.parentNode.exitPoint = undefined
+        node.payload.parentNode.triggerOff = undefined
         completeDetachment(node, rootNodes)
         return
       }
         break
       case 'Take Position Event': {
-        node.payload.parentNode.sellPoint = undefined
+        node.payload.parentNode.takePosition = undefined
         completeDetachment(node, rootNodes)
         return
       }
@@ -72,7 +72,7 @@ function newAttachDetach () {
       }
         break
       case 'Take Profit': {
-        node.payload.parentNode.buyOrder = undefined
+        node.payload.parentNode.takeProfit = undefined
         completeDetachment(node, rootNodes)
         return
       }
@@ -169,21 +169,21 @@ function newAttachDetach () {
       case 'Trigger On Event': {
         node.payload.parentNode = attachToNode
         node.payload.chainParent = attachToNode
-        node.payload.parentNode.entryPoint = node
+        node.payload.parentNode.triggerOn = node
         completeAttachment(node, rootNodes)
       }
         break
       case 'Trigger Off Event': {
         node.payload.parentNode = attachToNode
         node.payload.chainParent = attachToNode
-        node.payload.parentNode.exitPoint = node
+        node.payload.parentNode.triggerOff = node
         completeAttachment(node, rootNodes)
       }
         break
       case 'Take Position': {
         node.payload.parentNode = attachToNode
         node.payload.chainParent = attachToNode
-        node.payload.parentNode.sellPoint = node
+        node.payload.parentNode.takePosition = node
         completeAttachment(node, rootNodes)
       }
         break
@@ -197,7 +197,7 @@ function newAttachDetach () {
       case 'Take Profit': {
         node.payload.parentNode = attachToNode
         node.payload.chainParent = attachToNode
-        node.payload.parentNode.buyOrder = node
+        node.payload.parentNode.takeProfit = node
         completeAttachment(node, rootNodes)
       }
         break

StrategySpace/Workspace/FunctionLibraries/NodeDeleter.js

@@ -54,14 +54,14 @@ function newNodeDeleter () {
     } else {
       completeDeletion(node, rootNodes)
     }
-    if (node.entryPoint !== undefined) {
-      deleteEvent(node.entryPoint)
+    if (node.triggerOn !== undefined) {
+      deleteEvent(node.triggerOn)
     }
-    if (node.exitPoint !== undefined) {
-      deleteEvent(node.exitPoint)
+    if (node.triggerOff !== undefined) {
+      deleteEvent(node.triggerOff)
     }
-    if (node.sellPoint !== undefined) {
-      deleteEvent(node.sellPoint)
+    if (node.takePosition !== undefined) {
+      deleteEvent(node.takePosition)
     }
     destroyPart(node)
     cleanNode(node)
@@ -91,8 +91,8 @@ function newNodeDeleter () {
     if (node.stopLoss !== undefined) {
       deleteManagedItem(node.stopLoss)
     }
-    if (node.buyOrder !== undefined) {
-      deleteManagedItem(node.buyOrder)
+    if (node.takeProfit !== undefined) {
+      deleteManagedItem(node.takeProfit)
     }
     destroyPart(node)
     cleanNode(node)
@@ -126,15 +126,15 @@ function newNodeDeleter () {
     if (payload.parentNode !== undefined) {
       switch (node.type) {
         case 'Trigger On Event': {
-          payload.parentNode.entryPoint = undefined
+          payload.parentNode.triggerOn = undefined
           break
         }
         case 'Trigger Off Event': {
-          payload.parentNode.exitPoint = undefined
+          payload.parentNode.triggerOff = undefined
           break
         }
         case 'Take Position Event': {
-          payload.parentNode.sellPoint = undefined
+          payload.parentNode.takePosition = undefined
           break
         }
       }
@@ -158,7 +158,7 @@ function newNodeDeleter () {
           break
         }
         case 'Take Profit': {
-          payload.parentNode.buyOrder = undefined
+          payload.parentNode.takeProfit = undefined
           break
         }
       }

StrategySpace/Workspace/FunctionLibraries/PartsFromNodes.js

@@ -108,14 +108,14 @@ function newPartsFromNodes () {
         let stage = node
         createPart('Trigger Stage', stage.name, stage, parentNode, chainParent, 'Trigger Stage')
 
-        if (node.entryPoint !== undefined) {
-          createPartFromNode(node.entryPoint, stage, stage)
+        if (node.triggerOn !== undefined) {
+          createPartFromNode(node.triggerOn, stage, stage)
         }
-        if (node.exitPoint !== undefined) {
-          createPartFromNode(node.exitPoint, stage, stage)
+        if (node.triggerOff !== undefined) {
+          createPartFromNode(node.triggerOff, stage, stage)
         }
-        if (node.sellPoint !== undefined) {
-          createPartFromNode(node.sellPoint, stage, stage)
+        if (node.takePosition !== undefined) {
+          createPartFromNode(node.takePosition, stage, stage)
         }
         return
       }
@@ -135,8 +135,8 @@ function newPartsFromNodes () {
         if (node.stopLoss !== undefined) {
           createPartFromNode(node.stopLoss, stage, stage)
         }
-        if (node.buyOrder !== undefined) {
-          createPartFromNode(node.buyOrder, stage, stage)
+        if (node.takeProfit !== undefined) {
+          createPartFromNode(node.takeProfit, stage, stage)
         }
         return
       }
@@ -180,13 +180,13 @@ function newPartsFromNodes () {
       name: 'New Strategy',
       active: true,
       triggerStage: {
-        entryPoint: {
+        triggerOn: {
           situations: []
         },
-        exitPoint: {
+        triggerOff: {
           situations: []
         },
-        sellPoint: {
+        takePosition: {
           situations: []
         }
       },
@@ -197,7 +197,7 @@ function newPartsFromNodes () {
         stopLoss: {
           phases: []
         },
-        buyOrder: {
+        takeProfit: {
           phases: []
         }
       },
@@ -211,31 +211,31 @@ function newPartsFromNodes () {
     createPart('Open Stage', '', strategy.openStage, strategy, strategy, 'Open Stage')
     createPart('Manage Stage', '', strategy.manageStage, strategy, strategy, 'Manage Stage')
     createPart('Close Stage', '', strategy.closeStage, strategy, strategy, 'Close Stage')
-    createPart('Trigger On Event', '', strategy.triggerStage.entryPoint, strategy.triggerStage, strategy.triggerStage)
-    createPart('Trigger Off Event', '', strategy.triggerStage.exitPoint, strategy.triggerStage, strategy.triggerStage)
-    createPart('Take Position Event', '', strategy.triggerStage.sellPoint, strategy.triggerStage, strategy.triggerStage)
+    createPart('Trigger On Event', '', strategy.triggerStage.triggerOn, strategy.triggerStage, strategy.triggerStage)
+    createPart('Trigger Off Event', '', strategy.triggerStage.triggerOff, strategy.triggerStage, strategy.triggerStage)
+    createPart('Take Position Event', '', strategy.triggerStage.takePosition, strategy.triggerStage, strategy.triggerStage)
     createPart('Initial Definition', '', strategy.openStage.initialDefinition, strategy.openStage, strategy.openStage)
     createPart('Stop', '', strategy.manageStage.stopLoss, strategy.manageStage, strategy.manageStage)
-    createPart('Take Profit', '', strategy.manageStage.buyOrder, strategy.manageStage, strategy.manageStage)
+    createPart('Take Profit', '', strategy.manageStage.takeProfit, strategy.manageStage, strategy.manageStage)
   }
 
   function addMissingStages (node) {
     if (node.triggerStage === undefined) {
       node.triggerStage = {
-        entryPoint: {
+        triggerOn: {
           situations: []
         },
-        exitPoint: {
+        triggerOff: {
           situations: []
         },
-        sellPoint: {
+        takePosition: {
           situations: []
         }
       }
       createPart('Trigger Stage', '', node.triggerStage, node, node, 'Trigger Stage')
-      createPart('Trigger On Event', '', node.triggerStage.entryPoint, node.triggerStage, node.triggerStage)
-      createPart('Trigger Off Event', '', node.triggerStage.exitPoint, node.triggerStage, node.triggerStage)
-      createPart('Take Position Event', '', node.triggerStage.sellPoint, node.triggerStage, node.triggerStage)
+      createPart('Trigger On Event', '', node.triggerStage.triggerOn, node.triggerStage, node.triggerStage)
+      createPart('Trigger Off Event', '', node.triggerStage.triggerOff, node.triggerStage, node.triggerStage)
+      createPart('Take Position Event', '', node.triggerStage.takePosition, node.triggerStage, node.triggerStage)
     }
     if (node.openStage === undefined) {
       node.openStage = {
@@ -250,13 +250,13 @@ function newPartsFromNodes () {
         stopLoss: {
           phases: []
         },
-        buyOrder: {
+        takeProfit: {
           phases: []
         }
       }
       createPart('Manage Stage', '', node.manageStage, node, node, 'Manage Stage')
       createPart('Stop', '', node.manageStage.stopLoss, node.manageStage, node.manageStage)
-      createPart('Take Profit', '', node.manageStage.buyOrder, node.manageStage, node.manageStage)
+      createPart('Take Profit', '', node.manageStage.takeProfit, node.manageStage, node.manageStage)
     }
     if (node.triggerStage === undefined) {
       createPart('Close Stage', '', node.closeStage, node, node, 'Close Stage')
@@ -264,23 +264,23 @@ function newPartsFromNodes () {
   }
 
   function addMissingEvents (node) {
-    if (node.entryPoint === undefined) {
-      node.entryPoint = {
+    if (node.triggerOn === undefined) {
+      node.triggerOn = {
         situations: []
       }
-      createPart('Trigger On Event', '', node.entryPoint, node, node)
+      createPart('Trigger On Event', '', node.triggerOn, node, node)
     }
-    if (node.exitPoint === undefined) {
-      node.exitPoint = {
+    if (node.triggerOff === undefined) {
+      node.triggerOff = {
         situations: []
       }
-      createPart('Trigger Off Event', '', node.exitPoint, node, node)
+      createPart('Trigger Off Event', '', node.triggerOff, node, node)
     }
-    if (node.sellPoint === undefined) {
-      node.sellPoint = {
+    if (node.takePosition === undefined) {
+      node.takePosition = {
         situations: []
       }
-      createPart('Take Position Event', '', node.sellPoint, node, node)
+      createPart('Take Position Event', '', node.takePosition, node, node)
     }
   }
 
@@ -291,11 +291,11 @@ function newPartsFromNodes () {
       }
       createPart('Stop', '', node.stopLoss, node, node)
     }
-    if (node.buyOrder === undefined) {
-      node.buyOrder = {
+    if (node.takeProfit === undefined) {
+      node.takeProfit = {
         phases: []
       }
-      createPart('Take Profit', '', node.buyOrder, node, node)
+      createPart('Take Profit', '', node.takeProfit, node, node)
     }
   }
 

StrategySpace/Workspace/FunctionLibraries/ProtocolNode.js

@@ -129,9 +129,9 @@ function newProtocolNode () {
           type: node.type,
           subType: node.subType,
           name: node.name,
-          entryPoint: getProtocolNode(node.entryPoint),
-          exitPoint: getProtocolNode(node.exitPoint),
-          sellPoint: getProtocolNode(node.sellPoint)
+          triggerOn: getProtocolNode(node.triggerOn),
+          triggerOff: getProtocolNode(node.triggerOff),
+          takePosition: getProtocolNode(node.takePosition)
         }
         return stage
       }
@@ -150,7 +150,7 @@ function newProtocolNode () {
           subType: node.subType,
           name: node.name,
           stopLoss: getProtocolNode(node.stopLoss),
-          buyOrder: getProtocolNode(node.buyOrder)
+          takeProfit: getProtocolNode(node.takeProfit)
         }
         return stage
       }

StrategySpace/Workspace/FunctionLibraries/WorkspaceNode.js

@@ -148,9 +148,9 @@ function newWorkspaceNode () {
           type: node.type,
           subType: node.subType,
           name: node.name,
-          entryPoint: getWorkspaceNode(node.entryPoint),
-          exitPoint: getWorkspaceNode(node.exitPoint),
-          sellPoint: getWorkspaceNode(node.sellPoint),
+          triggerOn: getWorkspaceNode(node.triggerOn),
+          triggerOff: getWorkspaceNode(node.triggerOff),
+          takePosition: getWorkspaceNode(node.takePosition),
           savedPayload: getSavedPayload(node)
         }
         return stage
@@ -173,7 +173,7 @@ function newWorkspaceNode () {
           subType: node.subType,
           name: node.name,
           stopLoss: getWorkspaceNode(node.stopLoss),
-          buyOrder: getWorkspaceNode(node.buyOrder),
+          takeProfit: getWorkspaceNode(node.takeProfit),
           savedPayload: getSavedPayload(node)
         }
         return stage