From 7efa2b2a02fa59cbe4bb4899098aa9d99f290a9c Mon Sep 17 00:00:00 2001 From: Luis Fernando Molina Date: Sun, 26 May 2019 20:17:38 +0200 Subject: [PATCH] Stages Concept Implemented --- FloatingSpace/StrategyPart.js | 41 ++- FloatingSpace/StrategyPartConstructor.js | 228 +++++++++++++- FloatingSpace/StrategyPartTitle.js | 15 + Spaces/StrategySpace.js | 5 + StrategySpace/Workspace.js | 360 ++++++++++++++++++++--- 5 files changed, 606 insertions(+), 43 deletions(-) diff --git a/FloatingSpace/StrategyPart.js b/FloatingSpace/StrategyPart.js index 8076cb23c..d19a6b35b 100644 --- a/FloatingSpace/StrategyPart.js +++ b/FloatingSpace/StrategyPart.js @@ -185,6 +185,46 @@ function newStrategyPart () { compatibleType = 'Trading System' compatibleSubType = undefined break + case 'Trigger Stage': + compatibleType = 'Strategy' + compatibleSubType = undefined + break + case 'Open Stage': + compatibleType = 'Strategy' + compatibleSubType = undefined + break + case 'Manage Stage': + compatibleType = 'Strategy' + compatibleSubType = undefined + break + case 'Close Stage': + compatibleType = 'Strategy' + compatibleSubType = undefined + break + case 'Take Position Event': + compatibleType = 'Trigger Stage' + compatibleSubType = undefined + break + case 'Trigger Off Event': + compatibleType = 'Trigger Stage' + compatibleSubType = undefined + break + case 'Trigger On Event': + compatibleType = 'Trigger Stage' + compatibleSubType = undefined + break + case 'Initial Information': + compatibleType = 'Open Stage' + compatibleSubType = undefined + break + case 'Stop': + compatibleType = 'Manage Stage' + compatibleSubType = undefined + break + case 'Take Profit': + compatibleType = 'Manage Stage' + compatibleSubType = undefined + break case 'Phase': compatibleType = 'Stop' + '.' + 'Take Profit' + '.' + 'Phase' compatibleSubType = undefined @@ -674,4 +714,3 @@ function newStrategyPart () { } } } - diff --git a/FloatingSpace/StrategyPartConstructor.js b/FloatingSpace/StrategyPartConstructor.js index 2ea714253..e250cd258 100644 --- a/FloatingSpace/StrategyPartConstructor.js +++ b/FloatingSpace/StrategyPartConstructor.js @@ -186,6 +186,174 @@ function newStrategyPartConstructor () { }] break } + case 'Trigger Stage': { + menuItemsInitialValues = [ + { + action: 'Pin / Unpin', + actionFunction: floatingObject.pinToggle, + actionStatus: floatingObject.getPinStatus, + currentStatus: false, + label: undefined, + visible: false, + iconPathOn: 'target', + iconPathOff: 'security', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: -135 + }, + { + action: 'Delete Trigger Stage', + actionFunction: payload.onMenuItemClick, + label: 'Delete This Stage', + visible: false, + iconPathOn: 'trash', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: -20 + }, + { + action: 'Download', + actionFunction: payload.onMenuItemClick, + label: 'Download', + visible: false, + iconPathOn: 'upload', + iconPathOff: 'upload', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 20 + }] + break + } + case 'Open Stage': { + menuItemsInitialValues = [ + { + action: 'Pin / Unpin', + actionFunction: floatingObject.pinToggle, + actionStatus: floatingObject.getPinStatus, + currentStatus: false, + label: undefined, + visible: false, + iconPathOn: 'target', + iconPathOff: 'security', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: -135 + }, + { + action: 'Delete Open Stage', + actionFunction: payload.onMenuItemClick, + label: 'Delete This Stage', + visible: false, + iconPathOn: 'trash', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: -20 + }, + { + action: 'Download', + actionFunction: payload.onMenuItemClick, + label: 'Download', + visible: false, + iconPathOn: 'upload', + iconPathOff: 'upload', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 20 + }] + break + } + case 'Manage Stage': { + menuItemsInitialValues = [ + { + action: 'Pin / Unpin', + actionFunction: floatingObject.pinToggle, + actionStatus: floatingObject.getPinStatus, + currentStatus: false, + label: undefined, + visible: false, + iconPathOn: 'target', + iconPathOff: 'security', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: -135 + }, + { + action: 'Delete Manage Stage', + actionFunction: payload.onMenuItemClick, + label: 'Delete This Stage', + visible: false, + iconPathOn: 'trash', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: -20 + }, + { + action: 'Download', + actionFunction: payload.onMenuItemClick, + label: 'Download', + visible: false, + iconPathOn: 'upload', + iconPathOff: 'upload', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 20 + }] + break + } + case 'Close Stage': { + menuItemsInitialValues = [ + { + action: 'Pin / Unpin', + actionFunction: floatingObject.pinToggle, + actionStatus: floatingObject.getPinStatus, + currentStatus: false, + label: undefined, + visible: false, + iconPathOn: 'target', + iconPathOff: 'security', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: -135 + }, + { + action: 'Delete Close Stage', + actionFunction: payload.onMenuItemClick, + label: 'Delete This Stage', + visible: false, + iconPathOn: 'trash', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: -20 + }, + { + action: 'Download', + actionFunction: payload.onMenuItemClick, + label: 'Download', + visible: false, + iconPathOn: 'upload', + iconPathOff: 'upload', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 20 + }] + break + } case 'Trigger On Event': { menuItemsInitialValues = [ { @@ -315,6 +483,48 @@ function newStrategyPartConstructor () { }] break } + case 'Initial Information': { + menuItemsInitialValues = [ + { + action: 'Pin / Unpin', + actionFunction: floatingObject.pinToggle, + actionStatus: floatingObject.getPinStatus, + currentStatus: false, + label: undefined, + visible: false, + iconPathOn: 'target', + iconPathOff: 'security', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: -135 + }, + { + action: 'Delete Initial Information', + actionFunction: payload.onMenuItemClick, + label: 'Delete This Stage', + visible: false, + iconPathOn: 'trash', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: -20 + }, + { + action: 'Download', + actionFunction: payload.onMenuItemClick, + label: 'Download', + visible: false, + iconPathOn: 'upload', + iconPathOff: 'upload', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 20 + }] + break + } case 'Stop': { menuItemsInitialValues = [ { @@ -609,6 +819,22 @@ function newStrategyPartConstructor () { level_1() break } + case 'Trigger Stage': { + level_1() + break + } + case 'Open Stage': { + level_1() + break + } + case 'Manage Stage': { + level_1() + break + } + case 'Close Stage': { + level_1() + break + } case 'Trigger On Event': { level_2() break @@ -621,7 +847,7 @@ function newStrategyPartConstructor () { level_2() break } - case 'Trade Exit Event': { + case 'Initial Information': { level_2() break } diff --git a/FloatingSpace/StrategyPartTitle.js b/FloatingSpace/StrategyPartTitle.js index 865b1039b..ebf30a659 100644 --- a/FloatingSpace/StrategyPartTitle.js +++ b/FloatingSpace/StrategyPartTitle.js @@ -56,6 +56,18 @@ function newStrategyPartTitle () { thisObject.allwaysVisible = true break } + case 'Trigger Stage': { + break + } + case 'Open Stage': { + break + } + case 'Manage Stage': { + break + } + case 'Close Stage': { + break + } case 'Trigger On Event': { break } @@ -65,6 +77,9 @@ function newStrategyPartTitle () { case 'Take Position Event': { break } + case 'Initial Information': { + break + } case 'Stop': { break } diff --git a/Spaces/StrategySpace.js b/Spaces/StrategySpace.js index 3685ae89b..dbd43540a 100644 --- a/Spaces/StrategySpace.js +++ b/Spaces/StrategySpace.js @@ -42,9 +42,14 @@ function newStrategySpace () { const relationshipArray = [ ['Trading System', 'analysis'], ['Strategy', 'quality'], + ['Trigger Stage', 'chronometer'], + ['Open Stage', 'photo-camera'], + ['Manage Stage', 'video-player'], + ['Close Stage', 'timeline'], ['Trigger On Event', 'startup'], ['Trigger Off Event', 'support'], ['Take Position Event', 'compass'], + ['Initial Information', 'task'], ['Stop', 'pixel'], ['Take Profit', 'competition'], ['Phase', 'placeholder'], diff --git a/StrategySpace/Workspace.js b/StrategySpace/Workspace.js index 180c97dec..8b9c80fcb 100644 --- a/StrategySpace/Workspace.js +++ b/StrategySpace/Workspace.js @@ -93,7 +93,7 @@ function newWorkspace () { rootNodes: stringifyReadyNodes } let textToSave = JSON.stringify(workspace) - window.localStorage.setItem('workspace', textToSave) + // window.localStorage.setItem('workspace', textToSave) } function spawn (nodeText, point) { @@ -167,6 +167,10 @@ function newWorkspace () { } 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') @@ -194,14 +198,62 @@ function newWorkspace () { } 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') - createPartFromNode(node.entryPoint, strategy, strategy) - createPartFromNode(node.exitPoint, strategy, strategy) - createPartFromNode(node.sellPoint, strategy, strategy) - createPartFromNode(node.stopLoss, strategy, strategy) - createPartFromNode(node.buyOrder, strategy, 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': { @@ -232,6 +284,18 @@ function newWorkspace () { } } break + case 'Trigger Stage': { + return + } + case 'Open Stage': { + return + } + case 'Manage Stage': { + return + } + case 'Close Stage': { + return + } case 'Trigger On Event': { return } @@ -242,6 +306,9 @@ function newWorkspace () { break case 'Take Position Event': { return + } + case 'Initial Definition': { + return } break case 'Stop': { @@ -562,30 +629,47 @@ function newWorkspace () { let strategy = { name: 'New Strategy', active: true, - entryPoint: { - situations: [] + triggerStage: { + entryPoint: { + situations: [] + }, + exitPoint: { + situations: [] + }, + sellPoint: { + situations: [] + } }, - exitPoint: { - situations: [] + openStage: { + initialDefinition: {} }, - sellPoint: { - situations: [] + manageStage: { + stopLoss: { + phases: [] + }, + buyOrder: { + phases: [] + } }, - stopLoss: { - phases: [] - }, - buyOrder: { - phases: [] + closeStage: { } } strategyParent.strategies.push(strategy) createPart('Strategy', strategy.name, strategy, strategyParent, strategyParent, 'Strategy') - createPart('Trigger On Event', '', strategy.entryPoint, strategy, strategy) - createPart('Trigger Off Event', '', strategy.exitPoint, strategy, strategy) - createPart('Take Position Event', '', strategy.sellPoint, strategy, strategy) - createPart('Stop', '', strategy.stopLoss, strategy, strategy) - createPart('Take Profit', '', strategy.buyOrder, strategy, strategy) + createPart('Trigger Stage', '', strategy.triggerStage, strategy, strategy, 'Trigger Stage') + 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('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) } break case 'Add Phase': @@ -635,6 +719,22 @@ function newWorkspace () { deleteStrategy(payload.node) break } + case 'Delete Trigger Stage': { + deleteTriggerStage(payload.node) + break + } + case 'Delete Open Stage': { + deleteOpenStage(payload.node) + break + } + case 'Delete Manage Stage': { + deleteManageStage(payload.node) + break + } + case 'Delete Close Stage': { + deleteClose(payload.node) + break + } case 'Delete Phase': { deletePhase(payload.node) break @@ -658,29 +758,92 @@ function newWorkspace () { for (let j = 0; j < payload.parentNode.strategies.length; j++) { let strategy = payload.parentNode.strategies[j] if (strategy.id === node.id) { - deleteEvent(strategy.entryPoint) - deleteEvent(strategy.exitPoint) - deleteEvent(strategy.sellPoint) - deleteManagedItem(strategy.stopLoss) - deleteManagedItem(strategy.buyOrder) payload.parentNode.strategies.splice(j, 1) - destroyPart(strategy) - cleanNode(strategy) - return } } - } else { - deleteEvent(node.entryPoint) - deleteEvent(node.exitPoint) - deleteEvent(node.sellPoint) - deleteManagedItem(node.stopLoss) - deleteManagedItem(node.buyOrder) - destroyPart(node) - cleanNode(node) } + 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]) } @@ -689,6 +852,20 @@ function newWorkspace () { } 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]) } @@ -911,17 +1088,62 @@ function newWorkspace () { } return event } - case 'Strategy': { - let strategy = { + case 'Initial Definition': { + let object = { + type: node.type, + subType: node.subType, + name: node.name + } + return object + } + case 'Trigger Stage': { + let stage = { type: node.type, subType: node.subType, name: node.name, entryPoint: getProtocolNode(node.entryPoint), exitPoint: getProtocolNode(node.exitPoint), - sellPoint: getProtocolNode(node.sellPoint), + sellPoint: getProtocolNode(node.sellPoint) + } + return stage + } + case 'Open Stage': { + let stage = { + type: node.type, + subType: node.subType, + name: node.name, + initialDefinition: getProtocolNode(node.initialDefinition) + } + return stage + } + case 'Manage Stage': { + let stage = { + type: node.type, + subType: node.subType, + name: node.name, stopLoss: getProtocolNode(node.stopLoss), buyOrder: getProtocolNode(node.buyOrder) } + return stage + } + case 'Close Stage': { + let stage = { + type: node.type, + subType: node.subType, + name: node.name + } + 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': { @@ -1068,6 +1290,62 @@ function newWorkspace () { } return event } + case 'Initial Definition': { + let object = { + id: node.id, + type: node.type, + subType: node.subType, + name: node.name, + savedPayload: getSavedPayload(node) + } + return object + } + case 'Trigger Stage': { + 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': { + 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': { + 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': { + 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,