diff --git a/FloatingSpace/FloatingLayer.js b/FloatingSpace/FloatingLayer.js index a366a4b40..4e2d57269 100644 --- a/FloatingSpace/FloatingLayer.js +++ b/FloatingSpace/FloatingLayer.js @@ -75,40 +75,38 @@ function newFloatingLayer () { if (container !== undefined) { return container } } + for (let i = 0; i < invisibleFloatingObjects.length; i++) { + let floatingObject = invisibleFloatingObjects[i] + container = floatingObject.getContainer(point) + if (container !== undefined) { return container } + } + return container } function addFloatingObject (pFloatingObject) { currentHandle++ pFloatingObject.handle = currentHandle // Math.floor((Math.random() * 10000000) + 1); - invisibleFloatingObjects.push(pFloatingObject) + visibleFloatingObjects.push(pFloatingObject) } function removeFloatingObject (pFloatingObjectHandle) { - try { - for (let i = 0; i < invisibleFloatingObjects.length; i++) { - let floatingObject = invisibleFloatingObjects[i] + for (let i = 0; i < invisibleFloatingObjects.length; i++) { + let floatingObject = invisibleFloatingObjects[i] - if (floatingObject.handle === pFloatingObjectHandle) { - invisibleFloatingObjects.splice(i, 1) // Delete item from array. - return - } + if (floatingObject.handle === pFloatingObjectHandle) { + invisibleFloatingObjects.splice(i, 1) // Delete item from array. + return } + } - for (let i = 0; i < visibleFloatingObjects.length; i++) { - let floatingObject = visibleFloatingObjects[i] + for (let i = 0; i < visibleFloatingObjects.length; i++) { + let floatingObject = visibleFloatingObjects[i] - if (floatingObject.handle === pFloatingObjectHandle) { - visibleFloatingObjects.splice(i, 1) // Delete item from array. - return - } + if (floatingObject.handle === pFloatingObjectHandle) { + visibleFloatingObjects.splice(i, 1) // Delete item from array. + return } - - if (ERROR_LOG === true) { logger.write('[ERROR] removeFloatingObject -> Floating Object Not Found.') } - if (ERROR_LOG === true) { logger.write('[ERROR] removeFloatingObject -> Floating Object cannot be killed.') } - if (ERROR_LOG === true) { logger.write('[ERROR] removeFloatingObject -> pFloatingObjectHandle = ' + pFloatingObjectHandle) } - } catch (err) { - if (ERROR_LOG === true) { logger.write('[ERROR] removeFloatingObject -> err= ' + err.stack) } } } @@ -153,126 +151,74 @@ function newFloatingLayer () { } function draw () { + drawInvisibleObjects() drawVisibleObjects() + } - function drawVisibleObjects () { - /* We draw all the visibleFloatingObjects. */ - - for (let i = 0; i < visibleFloatingObjects.length; i++) { - let floatingObject = visibleFloatingObjects[i] - floatingObject.drawBackground() - } - - for (let i = 0; i < visibleFloatingObjects.length; i++) { - let floatingObject = visibleFloatingObjects[i] - floatingObject.drawMiddleground() - } - - for (let i = 0; i < visibleFloatingObjects.length; i++) { - let floatingObject = visibleFloatingObjects[visibleFloatingObjects.length - i - 1] - floatingObject.drawForeground() - } - - for (let i = 0; i < visibleFloatingObjects.length; i++) { - let floatingObject = visibleFloatingObjects[i] - floatingObject.drawOnFocus() - } - - makeVisible() + function drawInvisibleObjects () { + for (let i = 0; i < invisibleFloatingObjects.length; i++) { + let floatingObject = invisibleFloatingObjects[i] + floatingObject.drawBackground() } - function makeVisible () { - try { - /* Now we check if any of the created FloatingObjects where enabled to run under the Physics Engine. */ - - for (let i = 0; i < invisibleFloatingObjects.length; i++) { - let floatingObject = invisibleFloatingObjects[i] - - let payload = { - position: undefined, - visible: false - } - - switch (floatingObject.type) { - - case 'Profile Ball': { - payload.targetPosition = floatingObject.payload.profile.position - payload.visible = floatingObject.payload.profile.visible - break - } - case 'Note': { - if (floatingObject.payload.notes[floatingObject.payloadNoteIndex] !== undefined) { - payload.targetPosition = floatingObject.payload.notes[floatingObject.payloadNoteIndex].position - payload.visible = floatingObject.payload.notes[floatingObject.payloadNoteIndex].visible - } - break - } - case 'Strategy Part': { - payload.targetPosition = floatingObject.payload.targetPosition - payload.visible = floatingObject.payload.visible - break - } - default: { - break - } - } - - if (payload.visible === true) { - visibleFloatingObjects.push(floatingObject) - - invisibleFloatingObjects.splice(i, 1) // Delete item from array. - - return // Only one at the time. - } - } - - makeInvisible() - } catch (err) { - if (ERROR_LOG === true) { logger.write('[ERROR] physics -> makeVisible -> err= ' + err.stack) } - } + for (let i = 0; i < invisibleFloatingObjects.length; i++) { + let floatingObject = invisibleFloatingObjects[i] + floatingObject.drawMiddleground() } - function makeInvisible () { - try { - /* Finally we check if any of the currently visible floatingObjects has become invisible and must be removed from the Physics Engine. */ + for (let i = 0; i < invisibleFloatingObjects.length; i++) { + let floatingObject = invisibleFloatingObjects[invisibleFloatingObjects.length - i - 1] + floatingObject.drawForeground() + } - for (let i = 0; i < visibleFloatingObjects.length; i++) { - let floatingObject = visibleFloatingObjects[i] + for (let i = 0; i < invisibleFloatingObjects.length; i++) { + let floatingObject = invisibleFloatingObjects[i] + floatingObject.drawOnFocus() + } + } - let payload = { - position: undefined, - visible: true - } + function drawVisibleObjects () { + for (let i = 0; i < visibleFloatingObjects.length; i++) { + let floatingObject = visibleFloatingObjects[i] + floatingObject.drawBackground() + } - switch (floatingObject.type) { + for (let i = 0; i < visibleFloatingObjects.length; i++) { + let floatingObject = visibleFloatingObjects[i] + floatingObject.drawMiddleground() + } - case 'Profile Ball': { - payload.visible = floatingObject.payload.profile.visible - break - } - case 'Note': { - payload.visible = floatingObject.payload.notes[floatingObject.payloadNoteIndex].visible - break - } - case 'Strategy Part': { - payload.visible = floatingObject.payload.visible - break - } - default: { - break - } - } + for (let i = 0; i < visibleFloatingObjects.length; i++) { + let floatingObject = visibleFloatingObjects[visibleFloatingObjects.length - i - 1] + floatingObject.drawForeground() + } - if (payload.visible === false) { - invisibleFloatingObjects.push(floatingObject) + for (let i = 0; i < visibleFloatingObjects.length; i++) { + let floatingObject = visibleFloatingObjects[i] + floatingObject.drawOnFocus() + } + } - visibleFloatingObjects.splice(i, 1) // Delete item from array. + function makeVisible () { + for (let i = 0; i < invisibleFloatingObjects.length; i++) { + let floatingObject = invisibleFloatingObjects[i] - return // Only one at the time. - } - } - } catch (err) { - if (ERROR_LOG === true) { logger.write('[ERROR] physics -> makeInvisible -> err= ' + err.stack) } + if (floatingObject.isFrozen === false) { + visibleFloatingObjects.push(floatingObject) + invisibleFloatingObjects.splice(i, 1) // Delete item from array. + return // Only one at the time. + } + } + } + + function makeInvisible () { + for (let i = 0; i < visibleFloatingObjects.length; i++) { + let floatingObject = visibleFloatingObjects[i] + + if (floatingObject.isFrozen === true) { + invisibleFloatingObjects.push(floatingObject) + visibleFloatingObjects.splice(i, 1) // Delete item from array. + return // Only one at the time. } } } @@ -299,12 +245,19 @@ function newFloatingLayer () { */ try { + makeVisible() + makeInvisible() applyPhysics() function applyPhysics () { /* This function makes all the calculations to apply phisycs on all visible floatingObjects in this layer. */ try { + for (let i = 0; i < invisibleFloatingObjects.length; i++) { + let floatingObject = invisibleFloatingObjects[i] + floatingObject.physics() + } + for (let i = 0; i < visibleFloatingObjects.length; i++) { let floatingObject = visibleFloatingObjects[i] @@ -313,6 +266,12 @@ function newFloatingLayer () { floatingObject.container.frame.position.y = floatingObject.container.frame.position.y + floatingObject.currentSpeed.y } + if (floatingObject.friction < floatingObject.targetFriction) { + floatingObject.friction = floatingObject.friction + 0.00001 + } else { + floatingObject.friction = floatingObject.friction - 0.00001 + } + floatingObject.currentSpeed.x = floatingObject.currentSpeed.x * floatingObject.friction // Desaceleration factor. floatingObject.currentSpeed.y = floatingObject.currentSpeed.y * floatingObject.friction // Desaceleration factor. @@ -784,4 +743,3 @@ function newFloatingLayer () { } } } - diff --git a/FloatingSpace/FloatingObject.js b/FloatingSpace/FloatingObject.js index 6bc85f59d..10164b2ab 100644 --- a/FloatingSpace/FloatingObject.js +++ b/FloatingSpace/FloatingObject.js @@ -16,14 +16,19 @@ function newFloatingObject () { currentSpeed: 0, // This is the current speed of the floating object. currentMass: 0, // This is the current mass of the floating object, including its zoom applied. friction: 0, // This is a factor that will ultimatelly desacelerate the floating object. + targetFriction: 0, rawMass: 0, // This is the mass value without zoom. rawRadius: 0, // This is the radius of this floating object without zoom. targetRadius: 0, // This is the target radius of the floating object with zoom applied. It should be animated until reaching this value. isPinned: false, + isFrozen: false, + frozenManually: false, getPinStatus: getPinStatus, + getFreezeStatus: getFreezeStatus, nearbyFloatingObjects: [], setPosition: setPosition, pinToggle: pinToggle, + freezeToggle: freezeToggle, physics: physics, initializeMass: initializeMass, initializeRadius: initializeRadius, @@ -115,9 +120,34 @@ function newFloatingObject () { return thisObject.isPinned } + function getFreezeStatus () { + return thisObject.isFrozen + } + + function freezeToggle () { + if (thisObject.isFrozen !== true) { + thisObject.isFrozen = true + thisObject.frozenManually = true + } else { + thisObject.isFrozen = false + thisObject.frozenManually = false + } + return thisObject.isFrozen + } + function physics () { thisObjectPhysics() thisObject.payload.uiObject.physics() + frozenPhysics() + } + + function frozenPhysics () { + if (thisObject.frozenManually === false) { + let parent = thisObject.payload.chainParent + if (parent !== undefined) { + thisObject.isFrozen = parent.payload.floatingObject.isFrozen + } + } } function thisObjectPhysics () { diff --git a/FloatingSpace/StrategyPart.js b/FloatingSpace/StrategyPart.js index 8076cb23c..095597d4c 100644 --- a/FloatingSpace/StrategyPart.js +++ b/FloatingSpace/StrategyPart.js @@ -20,6 +20,7 @@ function newStrategyPart () { isRunning: undefined, run: run, setRunningStatus: setRunningStatus, + setNotRunningStatus: setNotRunningStatus, getReadyToAttach: getReadyToAttach, showAvailabilityToAttach: showAvailabilityToAttach, highlight: highlight, @@ -185,18 +186,70 @@ 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 Definition': + compatibleType = 'Open Stage' + compatibleSubType = undefined + break + case 'Stop': + compatibleType = 'Manage Stage' + '.' + 'Initial Definition' + compatibleSubType = undefined + break + case 'Take Profit': + compatibleType = 'Manage Stage' + '.' + 'Initial Definition' + compatibleSubType = undefined + break case 'Phase': compatibleType = 'Stop' + '.' + 'Take Profit' + '.' + 'Phase' compatibleSubType = undefined break + case 'Formula': + compatibleType = 'Phase' + compatibleSubType = undefined + break + case 'Next Phase Event': + compatibleType = 'Phase' + compatibleSubType = undefined + break case 'Situation': - compatibleType = 'Phase' + '.' + 'Take Position Event' + '.' + 'Trigger On Event' + '.' + 'Trigger Off Event' + compatibleType = 'Take Position Event' + '.' + 'Trigger On Event' + '.' + 'Trigger Off Event' + '.' + 'Next Phase Event' compatibleSubType = undefined break case 'Condition': compatibleType = 'Situation' compatibleSubType = undefined break + case 'Code': + compatibleType = 'Condition' + compatibleSubType = undefined + break default: return } @@ -210,7 +263,37 @@ function newStrategyPart () { let floatingObject = nearby[1] let nearbyNode = floatingObject.payload.node if (compatibleType.indexOf(nearbyNode.type) >= 0) { + /* Discard objects with busy coonection ports */ + if (thisObject.payload.node.type === 'Trigger Stage' && nearbyNode.triggerStage !== undefined) { continue } + 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.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.takeProfit !== undefined) { continue } + if (thisObject.payload.node.type === 'Formula' && nearbyNode.formula !== undefined) { continue } + if (thisObject.payload.node.type === 'Next Phase Event' && nearbyNode.nextPhaseEvent !== undefined) { continue } + if (thisObject.payload.node.type === 'Code' && nearbyNode.code !== undefined) { continue } + /* Discard Phases without partent */ if (thisObject.payload.node.type === 'Phase' && nearbyNode.type === 'Phase' && nearbyNode.payload.parentNode === undefined) { continue } + /* Control maxPhases */ + if (thisObject.payload.node.type === 'Phase') { + if (nearbyNode.maxPhases !== undefined) { + if (nearbyNode.phases.length >= nearbyNode.maxPhases) { + continue + } + } + } + if (thisObject.payload.node.type === 'Phase' && nearbyNode.type === 'Phase') { + if (nearbyNode.payload.parentNode.maxPhases !== undefined) { + if (nearbyNode.payload.parentNode.phases.length >= nearbyNode.payload.parentNode.maxPhases) { + continue + } + } + } if (foundCompatible === false) { if (distance < thisObject.container.frame.radius * 1.5 + floatingObject.container.frame.radius * 1.5) { nearbyNode.payload.uiObject.getReadyToAttach() @@ -262,10 +345,16 @@ function newStrategyPart () { function detachingPhysics () { if (isDragging !== true) { return } + if (thisObject.isFrozen === true) { return } let distanceToChainParent = Math.sqrt(Math.pow(thisObject.payload.position.x - thisObject.payload.targetPosition.x, 2) + Math.pow(thisObject.payload.position.y - thisObject.payload.targetPosition.y, 2)) let ratio = distanceToChainParent / previousDistance + if (previousDistance === 0) { + previousDistance = distanceToChainParent + return + } previousDistance = distanceToChainParent + if (thisObject.isOnFocus !== true) { return } if (thisObject.payload.chainParent === undefined) { return } if (thisObject.payload.parentNode === undefined) { return } @@ -311,16 +400,21 @@ function newStrategyPart () { } function run () { - canvas.strategySpace.workspace.tradingSystem = thisObject.payload.node - canvas.cockpitSpace.restartSimulation.restart() setRunningStatus() + canvas.cockpitSpace.restartSimulation.restart() } function setRunningStatus () { + canvas.strategySpace.workspace.tradingSystem = thisObject.payload.node thisObject.isRunning = true runningCounter = 30 } + function setNotRunningStatus () { + canvas.strategySpace.workspace.tradingSystem = undefined + thisObject.isRunning = false + } + function iconPhysics () { icon = canvas.strategySpace.iconByPartType.get(thisObject.payload.node.type) executingIcon = canvas.strategySpace.iconCollection.get('attractive') @@ -431,10 +525,17 @@ function newStrategyPart () { if (thisObject.container.frame.radius > 1) { /* Target Line */ + let LINE_STYLE + if (thisObject.payload.floatingObject.isFrozen === true) { + LINE_STYLE = UI_COLOR.TURQUOISE + } else { + LINE_STYLE = UI_COLOR.TITANIUM_YELLOW + } + browserCanvasContext.beginPath() browserCanvasContext.moveTo(position.x, position.y) browserCanvasContext.lineTo(targetPoint.x, targetPoint.y) - browserCanvasContext.strokeStyle = 'rgba(' + UI_COLOR.TITANIUM_YELLOW + ', 1)' + browserCanvasContext.strokeStyle = 'rgba(' + LINE_STYLE + ', 1)' browserCanvasContext.setLineDash([3, 4]) browserCanvasContext.lineWidth = 2 browserCanvasContext.stroke() diff --git a/FloatingSpace/StrategyPartConstructor.js b/FloatingSpace/StrategyPartConstructor.js index 2ea714253..a2eacd2be 100644 --- a/FloatingSpace/StrategyPartConstructor.js +++ b/FloatingSpace/StrategyPartConstructor.js @@ -44,6 +44,9 @@ function newStrategyPartConstructor () { if (payload.node.savedPayload.floatingObject.isPinned === true) { floatingObject.pinToggle() } + if (payload.node.savedPayload.floatingObject.isFrozen === true) { + floatingObject.freezeToggle() + } } let strategyPart = newStrategyPart() @@ -90,6 +93,20 @@ function newStrategyPartConstructor () { currentRadius: 0, angle: -135 }, + { + action: 'Freeze / Unfreeze', + actionFunction: floatingObject.freezeToggle, + actionStatus: floatingObject.getFreezeStatus, + currentStatus: true, + label: undefined, + visible: false, + iconPathOn: 'broken-link', + iconPathOff: 'security', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 135 + }, { action: 'Run Trading System', actionFunction: payload.uiObject.run, @@ -100,7 +117,7 @@ function newStrategyPartConstructor () { rawRadius: 8, targetRadius: 0, currentRadius: 0, - angle: -60 + angle: -80 }, { action: 'Save Trading System', @@ -115,7 +132,19 @@ function newStrategyPartConstructor () { rawRadius: 8, targetRadius: 0, currentRadius: 0, - angle: -20 + angle: -40 + }, + { + action: 'Delete Trading System', + actionFunction: payload.onMenuItemClick, + label: 'Delete Trading System', + visible: false, + iconPathOn: 'trash', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 0 }, { action: 'New Strategy', @@ -128,7 +157,7 @@ function newStrategyPartConstructor () { rawRadius: 8, targetRadius: 0, currentRadius: 0, - angle: 20 + angle: 40 }, { action: 'Download', @@ -140,7 +169,7 @@ function newStrategyPartConstructor () { rawRadius: 8, targetRadius: 0, currentRadius: 0, - angle: 60 + angle: 80 }] break } @@ -160,6 +189,32 @@ function newStrategyPartConstructor () { currentRadius: 0, angle: -135 }, + { + action: 'Freeze / Unfreeze', + actionFunction: floatingObject.freezeToggle, + actionStatus: floatingObject.getFreezeStatus, + currentStatus: true, + label: undefined, + visible: false, + iconPathOn: 'broken-link', + iconPathOff: 'security', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 135 + }, + { + action: 'Add Missing Stages', + actionFunction: payload.onMenuItemClick, + label: 'Add Missing Stages', + visible: false, + iconPathOn: 'target', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: -40 + }, { action: 'Delete Strategy', actionFunction: payload.onMenuItemClick, @@ -170,6 +225,266 @@ function newStrategyPartConstructor () { rawRadius: 8, targetRadius: 0, currentRadius: 0, + angle: 0 + }, + { + action: 'Download', + actionFunction: payload.onMenuItemClick, + label: 'Download', + visible: false, + iconPathOn: 'upload', + iconPathOff: 'upload', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 40 + }] + 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: 'Freeze / Unfreeze', + actionFunction: floatingObject.freezeToggle, + actionStatus: floatingObject.getFreezeStatus, + currentStatus: true, + label: undefined, + visible: false, + iconPathOn: 'broken-link', + iconPathOff: 'security', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 135 + }, + { + action: 'Add Missing Events', + actionFunction: payload.onMenuItemClick, + label: 'Add Missing Events', + visible: false, + iconPathOn: 'target', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: -40 + }, + { + action: 'Delete Trigger Stage', + actionFunction: payload.onMenuItemClick, + label: 'Delete This Stage', + visible: false, + iconPathOn: 'trash', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 0 + }, + { + action: 'Download', + actionFunction: payload.onMenuItemClick, + label: 'Download', + visible: false, + iconPathOn: 'upload', + iconPathOff: 'upload', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 40 + }] + 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: 'Freeze / Unfreeze', + actionFunction: floatingObject.freezeToggle, + actionStatus: floatingObject.getFreezeStatus, + currentStatus: true, + label: undefined, + visible: false, + iconPathOn: 'broken-link', + iconPathOff: 'security', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 135 + }, + { + action: 'Add Initial Definition', + actionFunction: payload.onMenuItemClick, + label: 'Add Initial Definition', + visible: false, + iconPathOn: 'target', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: -40 + }, + { + action: 'Delete Open Stage', + actionFunction: payload.onMenuItemClick, + label: 'Delete This Stage', + visible: false, + iconPathOn: 'trash', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 0 + }, + { + action: 'Download', + actionFunction: payload.onMenuItemClick, + label: 'Download', + visible: false, + iconPathOn: 'upload', + iconPathOff: 'upload', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 40 + }] + 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: 'Freeze / Unfreeze', + actionFunction: floatingObject.freezeToggle, + actionStatus: floatingObject.getFreezeStatus, + currentStatus: true, + label: undefined, + visible: false, + iconPathOn: 'broken-link', + iconPathOff: 'security', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 135 + }, + { + action: 'Add Missing Items', + actionFunction: payload.onMenuItemClick, + label: 'Add Missing Items', + visible: false, + iconPathOn: 'target', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: -40 + }, + { + action: 'Delete Manage Stage', + actionFunction: payload.onMenuItemClick, + label: 'Delete This Stage', + visible: false, + iconPathOn: 'trash', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 0 + }, + { + action: 'Download', + actionFunction: payload.onMenuItemClick, + label: 'Download', + visible: false, + iconPathOn: 'upload', + iconPathOff: 'upload', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 40 + }] + 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: 'Freeze / Unfreeze', + actionFunction: floatingObject.freezeToggle, + actionStatus: floatingObject.getFreezeStatus, + currentStatus: true, + label: undefined, + visible: false, + iconPathOn: 'broken-link', + 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 }, { @@ -202,6 +517,20 @@ function newStrategyPartConstructor () { currentRadius: 0, angle: -135 }, + { + action: 'Freeze / Unfreeze', + actionFunction: floatingObject.freezeToggle, + actionStatus: floatingObject.getFreezeStatus, + currentStatus: true, + label: undefined, + visible: false, + iconPathOn: 'broken-link', + iconPathOff: 'security', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 135 + }, { action: 'Add Situation', actionFunction: payload.onMenuItemClick, @@ -213,7 +542,19 @@ function newStrategyPartConstructor () { rawRadius: 8, targetRadius: 0, currentRadius: 0, - angle: -20 + angle: -40 + }, + { + action: 'Delete Event', + actionFunction: payload.onMenuItemClick, + label: 'Delete This Event', + visible: false, + iconPathOn: 'trash', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 0 }, { action: 'Download', @@ -225,7 +566,7 @@ function newStrategyPartConstructor () { rawRadius: 8, targetRadius: 0, currentRadius: 0, - angle: 20 + angle: 40 }] break } @@ -245,6 +586,20 @@ function newStrategyPartConstructor () { currentRadius: 0, angle: -135 }, + { + action: 'Freeze / Unfreeze', + actionFunction: floatingObject.freezeToggle, + actionStatus: floatingObject.getFreezeStatus, + currentStatus: true, + label: undefined, + visible: false, + iconPathOn: 'broken-link', + iconPathOff: 'security', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 135 + }, { action: 'Add Situation', actionFunction: payload.onMenuItemClick, @@ -256,7 +611,19 @@ function newStrategyPartConstructor () { rawRadius: 8, targetRadius: 0, currentRadius: 0, - angle: -20 + angle: -40 + }, + { + action: 'Delete Event', + actionFunction: payload.onMenuItemClick, + label: 'Delete This Event', + visible: false, + iconPathOn: 'trash', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 0 }, { action: 'Download', @@ -268,7 +635,7 @@ function newStrategyPartConstructor () { rawRadius: 8, targetRadius: 0, currentRadius: 0, - angle: 20 + angle: 40 }] break } @@ -288,6 +655,20 @@ function newStrategyPartConstructor () { currentRadius: 0, angle: -135 }, + { + action: 'Freeze / Unfreeze', + actionFunction: floatingObject.freezeToggle, + actionStatus: floatingObject.getFreezeStatus, + currentStatus: true, + label: undefined, + visible: false, + iconPathOn: 'broken-link', + iconPathOff: 'security', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 135 + }, { action: 'Add Situation', actionFunction: payload.onMenuItemClick, @@ -299,7 +680,19 @@ function newStrategyPartConstructor () { rawRadius: 8, targetRadius: 0, currentRadius: 0, - angle: -20 + angle: -40 + }, + { + action: 'Delete Event', + actionFunction: payload.onMenuItemClick, + label: 'Delete This Event', + visible: false, + iconPathOn: 'trash', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 0 }, { action: 'Download', @@ -311,7 +704,75 @@ function newStrategyPartConstructor () { rawRadius: 8, targetRadius: 0, currentRadius: 0, - angle: 20 + angle: 40 + }] + break + } + case 'Initial Definition': { + 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: 'Freeze / Unfreeze', + actionFunction: floatingObject.freezeToggle, + actionStatus: floatingObject.getFreezeStatus, + currentStatus: true, + label: undefined, + visible: false, + iconPathOn: 'broken-link', + iconPathOff: 'security', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 135 + }, + { + action: 'Add Missing Items', + actionFunction: payload.onMenuItemClick, + label: 'Add Missing Items', + visible: false, + iconPathOn: 'target', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: -40 + }, + { + action: 'Delete Initial Definition', + actionFunction: payload.onMenuItemClick, + label: 'Delete This Definition', + visible: false, + iconPathOn: 'trash', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 0 + }, + { + action: 'Download', + actionFunction: payload.onMenuItemClick, + label: 'Download', + visible: false, + iconPathOn: 'upload', + iconPathOff: 'upload', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 40 }] break } @@ -331,6 +792,20 @@ function newStrategyPartConstructor () { currentRadius: 0, angle: -135 }, + { + action: 'Freeze / Unfreeze', + actionFunction: floatingObject.freezeToggle, + actionStatus: floatingObject.getFreezeStatus, + currentStatus: true, + label: undefined, + visible: false, + iconPathOn: 'broken-link', + iconPathOff: 'security', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 135 + }, { action: 'Add Phase', actionFunction: payload.onMenuItemClick, @@ -342,7 +817,19 @@ function newStrategyPartConstructor () { rawRadius: 8, targetRadius: 0, currentRadius: 0, - angle: -20 + angle: -40 + }, + { + action: 'Delete Managed Item', + actionFunction: payload.onMenuItemClick, + label: 'Delete This Item', + visible: false, + iconPathOn: 'trash', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 0 }, { action: 'Download', @@ -354,7 +841,7 @@ function newStrategyPartConstructor () { rawRadius: 8, targetRadius: 0, currentRadius: 0, - angle: 20 + angle: 40 }] break } @@ -374,6 +861,20 @@ function newStrategyPartConstructor () { currentRadius: 0, angle: -135 }, + { + action: 'Freeze / Unfreeze', + actionFunction: floatingObject.freezeToggle, + actionStatus: floatingObject.getFreezeStatus, + currentStatus: true, + label: undefined, + visible: false, + iconPathOn: 'broken-link', + iconPathOff: 'security', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 135 + }, { action: 'Add Phase', actionFunction: payload.onMenuItemClick, @@ -385,7 +886,19 @@ function newStrategyPartConstructor () { rawRadius: 8, targetRadius: 0, currentRadius: 0, - angle: -20 + angle: -40 + }, + { + action: 'Delete Managed Item', + actionFunction: payload.onMenuItemClick, + label: 'Delete This Item', + visible: false, + iconPathOn: 'trash', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 0 }, { action: 'Download', @@ -397,16 +910,11 @@ function newStrategyPartConstructor () { rawRadius: 8, targetRadius: 0, currentRadius: 0, - angle: 20 + angle: 40 }] break } case 'Phase': { - strategyPart.codeEditor = newCodeEditor() - strategyPart.codeEditor.isVisibleFunction = strategyPart.isVisibleFunction - strategyPart.codeEditor.initialize() - strategyPart.codeEditor.container.connectToParent(strategyPart.container, false, false, true, true, false, false, false, false) - menuItemsInitialValues = [ { action: 'Pin / Unpin', @@ -423,26 +931,40 @@ function newStrategyPartConstructor () { angle: -135 }, { - action: 'Edit Code', - actionFunction: strategyPart.codeEditor.activate, - label: 'Edit Code', + action: 'Freeze / Unfreeze', + actionFunction: floatingObject.freezeToggle, + actionStatus: floatingObject.getFreezeStatus, + currentStatus: true, + label: undefined, visible: false, - iconPathOn: 'html', - iconPathOff: 'html', + iconPathOn: 'broken-link', + iconPathOff: 'security', rawRadius: 8, targetRadius: 0, currentRadius: 0, - angle: -60, - dontShowAtFullscreen: true + angle: 135 }, { - action: 'Add Situation', + action: 'Add Formula', actionFunction: payload.onMenuItemClick, - label: 'Add Situation', + label: 'Add Formula', visible: false, - iconPathOn: 'pyramid', - iconPathOff: 'pyramid', - relatedStrategyPart: 'Situation', + iconPathOn: 'schedule', + iconPathOff: 'schedule', + relatedStrategyPart: 'Formula', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: -60 + }, + { + action: 'Add Next Phase Event', + actionFunction: payload.onMenuItemClick, + label: 'Add Next Phase Event', + visible: false, + iconPathOn: 'pipette', + iconPathOff: 'pipette', + relatedStrategyPart: 'Next Phase Event', rawRadius: 8, targetRadius: 0, currentRadius: 0, @@ -474,6 +996,149 @@ function newStrategyPartConstructor () { }] break } + case 'Formula': { + strategyPart.codeEditor = newCodeEditor() + strategyPart.codeEditor.isVisibleFunction = strategyPart.isVisibleFunction + strategyPart.codeEditor.initialize() + strategyPart.codeEditor.container.connectToParent(strategyPart.container, false, false, true, true, false, false, false, false) + + 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: 'Freeze / Unfreeze', + actionFunction: floatingObject.freezeToggle, + actionStatus: floatingObject.getFreezeStatus, + currentStatus: true, + label: undefined, + visible: false, + iconPathOn: 'broken-link', + iconPathOff: 'security', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 135 + }, + { + action: 'Edit Formula', + actionFunction: strategyPart.codeEditor.activate, + label: 'Edit Formula', + visible: false, + iconPathOn: 'html', + iconPathOff: 'html', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: -40, + dontShowAtFullscreen: true + }, + { + action: 'Delete Formula', + actionFunction: payload.onMenuItemClick, + label: 'Delete This Formula', + visible: false, + iconPathOn: 'trash', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 0 + }, + { + action: 'Download', + actionFunction: payload.onMenuItemClick, + label: 'Download', + visible: false, + iconPathOn: 'upload', + iconPathOff: 'upload', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 40 + }] + break + } + case 'Next Phase Event': { + 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: 'Freeze / Unfreeze', + actionFunction: floatingObject.freezeToggle, + actionStatus: floatingObject.getFreezeStatus, + currentStatus: true, + label: undefined, + visible: false, + iconPathOn: 'broken-link', + iconPathOff: 'security', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 135 + }, + { + action: 'Add Situation', + actionFunction: payload.onMenuItemClick, + label: 'Add Situation', + visible: false, + iconPathOn: 'pyramid', + iconPathOff: 'pyramid', + relatedStrategyPart: 'Situation', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: -40 + }, + { + action: 'Delete Event', + actionFunction: payload.onMenuItemClick, + label: 'Delete This Event', + visible: false, + iconPathOn: 'trash', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 0 + }, + { + action: 'Download', + actionFunction: payload.onMenuItemClick, + label: 'Download', + visible: false, + iconPathOn: 'upload', + iconPathOff: 'upload', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 40 + }] + break + } case 'Situation': { menuItemsInitialValues = [ { @@ -490,6 +1155,20 @@ function newStrategyPartConstructor () { currentRadius: 0, angle: -135 }, + { + action: 'Freeze / Unfreeze', + actionFunction: floatingObject.freezeToggle, + actionStatus: floatingObject.getFreezeStatus, + currentStatus: true, + label: undefined, + visible: false, + iconPathOn: 'broken-link', + iconPathOff: 'security', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 135 + }, { action: 'Add Condition', actionFunction: payload.onMenuItemClick, @@ -530,6 +1209,75 @@ function newStrategyPartConstructor () { break } case 'Condition': { + 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: 'Freeze / Unfreeze', + actionFunction: floatingObject.freezeToggle, + actionStatus: floatingObject.getFreezeStatus, + currentStatus: true, + label: undefined, + visible: false, + iconPathOn: 'broken-link', + iconPathOff: 'security', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 135 + }, + { + action: 'Add Code', + actionFunction: payload.onMenuItemClick, + label: 'Add Code', + visible: false, + iconPathOn: 'html', + iconPathOff: 'html', + relatedStrategyPart: 'Code', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: -40 + }, + { + action: 'Delete Condition', + actionFunction: payload.onMenuItemClick, + label: 'Delete This Condition', + visible: false, + iconPathOn: 'trash', + iconPathOff: 'trash', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 0 + }, + { + action: 'Download', + actionFunction: payload.onMenuItemClick, + label: 'Download', + visible: false, + iconPathOn: 'upload', + iconPathOff: 'upload', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 40 + }] + break + } + case 'Code': { strategyPart.codeEditor = newCodeEditor() strategyPart.codeEditor.isVisibleFunction = strategyPart.isVisibleFunction strategyPart.codeEditor.initialize() @@ -550,6 +1298,20 @@ function newStrategyPartConstructor () { currentRadius: 0, angle: -135 }, + { + action: 'Freeze / Unfreeze', + actionFunction: floatingObject.freezeToggle, + actionStatus: floatingObject.getFreezeStatus, + currentStatus: true, + label: undefined, + visible: false, + iconPathOn: 'broken-link', + iconPathOff: 'security', + rawRadius: 8, + targetRadius: 0, + currentRadius: 0, + angle: 135 + }, { action: 'Edit Code', actionFunction: strategyPart.codeEditor.activate, @@ -564,9 +1326,9 @@ function newStrategyPartConstructor () { dontShowAtFullscreen: true }, { - action: 'Delete Condition', + action: 'Delete Code', actionFunction: payload.onMenuItemClick, - label: 'Delete This Condition', + label: 'Delete This Code', visible: false, iconPathOn: 'trash', iconPathOff: 'trash', @@ -598,7 +1360,8 @@ function newStrategyPartConstructor () { } function setFloatingObjectBasicProperties (floatingObject, payload) { - const FRICTION = 0.97 + const FRICTION = 0.94 + const INITIAL_FRICTION = 0.99 switch (payload.node.type) { case 'Trading System': { @@ -609,40 +1372,68 @@ function newStrategyPartConstructor () { level_1() break } + case 'Trigger Stage': { + level_2() + break + } + case 'Open Stage': { + level_2() + break + } + case 'Manage Stage': { + level_2() + break + } + case 'Close Stage': { + level_2() + break + } case 'Trigger On Event': { - level_2() - break - } - case 'Trigger Off Event': { - level_2() - break - } - case 'Take Position Event': { - level_2() - break - } - case 'Trade Exit Event': { - level_2() - break - } - case 'Stop': { - level_2() - break - } - case 'Take Profit': { - level_2() - break - } - case 'Phase': { level_3() break } + case 'Trigger Off Event': { + level_3() + break + } + case 'Take Position Event': { + level_3() + break + } + case 'Initial Definition': { + level_3() + break + } + case 'Stop': { + level_3() + break + } + case 'Take Profit': { + level_3() + break + } + case 'Phase': { + level_2() + break + } + case 'Formula': { + level_5() + break + } + case 'Next Phase Event': { + level_5() + break + } case 'Situation': { - level_4() + level_5() break } case 'Condition': { - level_5() + level_6() + break + } + case 'Code': { + level_6() break } default: { @@ -652,7 +1443,8 @@ function newStrategyPartConstructor () { } function level_0 () { - floatingObject.friction = 0.93 + floatingObject.targetFriction = 0.93 + floatingObject.friction = INITIAL_FRICTION floatingObject.initializeMass(500) floatingObject.initializeRadius(45) @@ -663,7 +1455,8 @@ function newStrategyPartConstructor () { } function level_1 () { - floatingObject.friction = 0.94 + floatingObject.targetFriction = 0.94 + floatingObject.friction = INITIAL_FRICTION floatingObject.initializeMass(250) floatingObject.initializeRadius(45) @@ -674,9 +1467,10 @@ function newStrategyPartConstructor () { } function level_2 () { - floatingObject.friction = FRICTION + floatingObject.targetFriction = FRICTION + floatingObject.friction = INITIAL_FRICTION - floatingObject.initializeMass(50) + floatingObject.initializeMass(100) floatingObject.initializeRadius(40) floatingObject.initializeImageSize(70) floatingObject.initializeFontSize(10) @@ -685,7 +1479,8 @@ function newStrategyPartConstructor () { } function level_3 () { - floatingObject.friction = FRICTION + floatingObject.targetFriction = FRICTION + floatingObject.friction = INITIAL_FRICTION floatingObject.initializeMass(10) floatingObject.initializeRadius(35) @@ -696,7 +1491,8 @@ function newStrategyPartConstructor () { } function level_4 () { - floatingObject.friction = FRICTION + floatingObject.targetFriction = FRICTION + floatingObject.friction = INITIAL_FRICTION floatingObject.initializeMass(10) floatingObject.initializeRadius(30) @@ -707,10 +1503,22 @@ function newStrategyPartConstructor () { } function level_5 () { - floatingObject.friction = FRICTION + floatingObject.targetFriction = FRICTION + floatingObject.friction = INITIAL_FRICTION floatingObject.initializeMass(10) floatingObject.initializeRadius(25) + floatingObject.initializeImageSize(40) + floatingObject.initializeFontSize(10) + + floatingObject.fillStyle = 'rgba(' + UI_COLOR.RED + ', 1)' + } + function level_6 () { + floatingObject.targetFriction = FRICTION + floatingObject.friction = INITIAL_FRICTION + + floatingObject.initializeMass(10) + floatingObject.initializeRadius(20) floatingObject.initializeImageSize(30) floatingObject.initializeFontSize(10) diff --git a/FloatingSpace/StrategyPartTitle.js b/FloatingSpace/StrategyPartTitle.js index 865b1039b..496eb5aef 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 Definition': { + break + } case 'Stop': { break } @@ -74,12 +89,21 @@ function newStrategyPartTitle () { case 'Phase': { break } + case 'Formula': { + break + } + case 'Next Phase Event': { + break + } case 'Situation': { break } case 'Condition': { break } + case 'Code': { + break + } default: { if (ERROR_LOG === true) { logger.write('[ERROR] initialize -> Part Type not Recognized -> type = ' + payload.node.type) } } @@ -262,4 +286,3 @@ function newStrategyPartTitle () { return title } } - diff --git a/Globals.js b/Globals.js index b458ec7bc..ada8e2e55 100644 --- a/Globals.js +++ b/Globals.js @@ -134,6 +134,9 @@ if (testUser !== null) { LOGGED_IN_ACCESS_TOKEN_LOCAL_STORAGE_KEY = "access_token" } +const DEFAULT_FORMULA_TEXT = '// Write your formula here' +const DEFAULT_CODE_TEXT = '// Write your code here' + const USDT_BTC_HTH = 19900; // This is needed to know the scale of the market time line. const WIDHTER_VOLUME_BAR_BASE_FACTOR = 2.5; diff --git a/Images/AAMasters/AAMariam-Trading-Bot/Mariam.png b/Images/AAMasters/AAMariam-Trading-Bot/Mariam.png deleted file mode 100644 index 3e0e6cac2..000000000 Binary files a/Images/AAMasters/AAMariam-Trading-Bot/Mariam.png and /dev/null differ diff --git a/Images/AAMasters/AAMasters.png b/Images/AAMasters/AAMasters.png deleted file mode 100644 index 2949bda39..000000000 Binary files a/Images/AAMasters/AAMasters.png and /dev/null differ diff --git a/Images/AAMasters/AAOlivia-Indicator-Bot/Olivia.png b/Images/AAMasters/AAOlivia-Indicator-Bot/Olivia.png deleted file mode 100644 index 4a0f89279..000000000 Binary files a/Images/AAMasters/AAOlivia-Indicator-Bot/Olivia.png and /dev/null differ diff --git a/Images/AAMasters/AARobert-Trading-Bot/Robert.png b/Images/AAMasters/AARobert-Trading-Bot/Robert.png deleted file mode 100644 index c863ad3db..000000000 Binary files a/Images/AAMasters/AARobert-Trading-Bot/Robert.png and /dev/null differ diff --git a/Images/AAMasters/AATom-Indicator-Bot/Tom.png b/Images/AAMasters/AATom-Indicator-Bot/Tom.png deleted file mode 100644 index dfd356173..000000000 Binary files a/Images/AAMasters/AATom-Indicator-Bot/Tom.png and /dev/null differ diff --git a/Images/AAMasters/PlottersCandlesVolumes/Candles.png b/Images/AAMasters/PlottersCandlesVolumes/Candles.png deleted file mode 100644 index f1e093cd5..000000000 Binary files a/Images/AAMasters/PlottersCandlesVolumes/Candles.png and /dev/null differ diff --git a/Images/AAMasters/PlottersCandlesVolumes/Volumes.png b/Images/AAMasters/PlottersCandlesVolumes/Volumes.png deleted file mode 100644 index aaea183a6..000000000 Binary files a/Images/AAMasters/PlottersCandlesVolumes/Volumes.png and /dev/null differ diff --git a/Images/AAMasters/PlottersStairsPatterns/CandleStairs.png b/Images/AAMasters/PlottersStairsPatterns/CandleStairs.png deleted file mode 100644 index a21beb7a0..000000000 Binary files a/Images/AAMasters/PlottersStairsPatterns/CandleStairs.png and /dev/null differ diff --git a/Images/AAMasters/PlottersStairsPatterns/VolumeStairs.png b/Images/AAMasters/PlottersStairsPatterns/VolumeStairs.png deleted file mode 100644 index 363096eee..000000000 Binary files a/Images/AAMasters/PlottersStairsPatterns/VolumeStairs.png and /dev/null differ diff --git a/Images/AAMasters/PlottersTrading/Competition.png b/Images/AAMasters/PlottersTrading/Competition.png deleted file mode 100644 index a4ee16263..000000000 Binary files a/Images/AAMasters/PlottersTrading/Competition.png and /dev/null differ diff --git a/Images/AAMasters/PlottersTrading/History.png b/Images/AAMasters/PlottersTrading/History.png deleted file mode 100644 index a6809adfd..000000000 Binary files a/Images/AAMasters/PlottersTrading/History.png and /dev/null differ diff --git a/Images/AAMasters/PlottersTrading/Live.png b/Images/AAMasters/PlottersTrading/Live.png deleted file mode 100644 index 71f565286..000000000 Binary files a/Images/AAMasters/PlottersTrading/Live.png and /dev/null differ diff --git a/Images/AASpartans/AAKing-Trading-Bot/King.png b/Images/AASpartans/AAKing-Trading-Bot/King.png deleted file mode 100644 index c9622fcc1..000000000 Binary files a/Images/AASpartans/AAKing-Trading-Bot/King.png and /dev/null differ diff --git a/Images/AASpartans/AASpartans.png b/Images/AASpartans/AASpartans.png deleted file mode 100644 index d1c7106fa..000000000 Binary files a/Images/AASpartans/AASpartans.png and /dev/null differ diff --git a/Images/AAVikings/AAArtudito-Trading-Bot/Artudito.png b/Images/AAVikings/AAArtudito-Trading-Bot/Artudito.png deleted file mode 100644 index a32ade82a..000000000 Binary files a/Images/AAVikings/AAArtudito-Trading-Bot/Artudito.png and /dev/null differ diff --git a/Images/AAVikings/AAGauss-Indicator-Bot/Gauss.png b/Images/AAVikings/AAGauss-Indicator-Bot/Gauss.png deleted file mode 100644 index b0c7df225..000000000 Binary files a/Images/AAVikings/AAGauss-Indicator-Bot/Gauss.png and /dev/null differ diff --git a/Images/AAVikings/AAVikings.png b/Images/AAVikings/AAVikings.png deleted file mode 100644 index 315b1b4f1..000000000 Binary files a/Images/AAVikings/AAVikings.png and /dev/null differ diff --git a/Images/AAVikings/PlotterLinearRegressionCurve/LRC.png b/Images/AAVikings/PlotterLinearRegressionCurve/LRC.png deleted file mode 100644 index a2cefe275..000000000 Binary files a/Images/AAVikings/PlotterLinearRegressionCurve/LRC.png and /dev/null differ diff --git a/Images/Algoteers/Algoteers.png b/Images/Algoteers/Algoteers.png deleted file mode 100644 index 39529f0c2..000000000 Binary files a/Images/Algoteers/Algoteers.png and /dev/null differ diff --git a/Images/Algoteers/Mousequeton-Trading-Bot/Mousequeton.png b/Images/Algoteers/Mousequeton-Trading-Bot/Mousequeton.png deleted file mode 100644 index 1592c4d9f..000000000 Binary files a/Images/Algoteers/Mousequeton-Trading-Bot/Mousequeton.png and /dev/null differ diff --git a/Images/CryptoRockets/CryptoRockets.png b/Images/CryptoRockets/CryptoRockets.png deleted file mode 100644 index f5977429c..000000000 Binary files a/Images/CryptoRockets/CryptoRockets.png and /dev/null differ diff --git a/Images/CryptoRockets/RocketFeller-Trading-Bot/rocketfeller.png b/Images/CryptoRockets/RocketFeller-Trading-Bot/rocketfeller.png deleted file mode 100644 index c2151550e..000000000 Binary files a/Images/CryptoRockets/RocketFeller-Trading-Bot/rocketfeller.png and /dev/null differ diff --git a/Images/DummyTeam/DummyBot-Trading-Bot/DummyBot.png b/Images/DummyTeam/DummyBot-Trading-Bot/DummyBot.png deleted file mode 100644 index ff37c3d91..000000000 Binary files a/Images/DummyTeam/DummyBot-Trading-Bot/DummyBot.png and /dev/null differ diff --git a/Images/DummyTeam/DummyTeam.png b/Images/DummyTeam/DummyTeam.png deleted file mode 100644 index 1e5f3e9fc..000000000 Binary files a/Images/DummyTeam/DummyTeam.png and /dev/null differ diff --git a/Images/Icons/chart-scale.png b/Images/Icons/chart-scale.png deleted file mode 100644 index bcffba53f..000000000 Binary files a/Images/Icons/chart-scale.png and /dev/null differ diff --git a/Images/Icons/pause.png b/Images/Icons/pause.png deleted file mode 100644 index 2cfc0ff09..000000000 Binary files a/Images/Icons/pause.png and /dev/null differ diff --git a/Images/Icons/play.png b/Images/Icons/play.png deleted file mode 100644 index 81862cec5..000000000 Binary files a/Images/Icons/play.png and /dev/null differ diff --git a/Images/Icons/trash.png b/Images/Icons/trash.png deleted file mode 100644 index 427c65d5d..000000000 Binary files a/Images/Icons/trash.png and /dev/null differ diff --git a/Images/KnightsTemplar/Inquisitor-Trading-Bot/Inquisitor.png b/Images/KnightsTemplar/Inquisitor-Trading-Bot/Inquisitor.png deleted file mode 100644 index 2fd9598e3..000000000 Binary files a/Images/KnightsTemplar/Inquisitor-Trading-Bot/Inquisitor.png and /dev/null differ diff --git a/Images/KnightsTemplar/KnightsTemplar.png b/Images/KnightsTemplar/KnightsTemplar.png deleted file mode 100644 index 77cd3ef80..000000000 Binary files a/Images/KnightsTemplar/KnightsTemplar.png and /dev/null differ diff --git a/Images/PotterHeads/Nimbus2000-Trading-Bot/Nimbus2000.png b/Images/PotterHeads/Nimbus2000-Trading-Bot/Nimbus2000.png deleted file mode 100644 index c2dcf5b31..000000000 Binary files a/Images/PotterHeads/Nimbus2000-Trading-Bot/Nimbus2000.png and /dev/null differ diff --git a/Images/PotterHeads/PotterHeads.png b/Images/PotterHeads/PotterHeads.png deleted file mode 100644 index ab8a6183c..000000000 Binary files a/Images/PotterHeads/PotterHeads.png and /dev/null differ diff --git a/Images/Titanomachy/Atlas-Trading-Bot/Atlas.png b/Images/Titanomachy/Atlas-Trading-Bot/Atlas.png deleted file mode 100644 index 91d7d8d2f..000000000 Binary files a/Images/Titanomachy/Atlas-Trading-Bot/Atlas.png and /dev/null differ diff --git a/Images/Titanomachy/Titanomachy.png b/Images/Titanomachy/Titanomachy.png deleted file mode 100644 index fc03818f3..000000000 Binary files a/Images/Titanomachy/Titanomachy.png and /dev/null differ diff --git a/Images/aa-logo-background.png b/Images/aa-logo-background.png deleted file mode 100644 index cb84e7a21..000000000 Binary files a/Images/aa-logo-background.png and /dev/null differ diff --git a/Images/aa-logo-dark-8.png b/Images/aa-logo-dark-8.png deleted file mode 100644 index a6bcfcb90..000000000 Binary files a/Images/aa-logo-dark-8.png and /dev/null differ diff --git a/Images/aa-logo-vert.png b/Images/aa-logo-vert.png deleted file mode 100644 index c866edb8f..000000000 Binary files a/Images/aa-logo-vert.png and /dev/null differ diff --git a/Images/aa-logo.png b/Images/aa-logo.png deleted file mode 100644 index 9701ee1c0..000000000 Binary files a/Images/aa-logo.png and /dev/null differ diff --git a/Images/bitcoin-logo-background.png b/Images/bitcoin-logo-background.png deleted file mode 100644 index 1627225c4..000000000 Binary files a/Images/bitcoin-logo-background.png and /dev/null differ diff --git a/Images/bitcoin-logo.png b/Images/bitcoin-logo.png deleted file mode 100644 index 17f314ce3..000000000 Binary files a/Images/bitcoin-logo.png and /dev/null differ diff --git a/Images/favicon.ico b/Images/favicon.ico deleted file mode 100644 index cd2c5d6af..000000000 Binary files a/Images/favicon.ico and /dev/null differ diff --git a/Images/menu.icon.off.1.gif b/Images/menu.icon.off.1.gif deleted file mode 100644 index 163aa9533..000000000 Binary files a/Images/menu.icon.off.1.gif and /dev/null differ diff --git a/Images/menu.icon.off.2.gif b/Images/menu.icon.off.2.gif deleted file mode 100644 index e157299e2..000000000 Binary files a/Images/menu.icon.off.2.gif and /dev/null differ diff --git a/Images/menu.icon.off.3.gif b/Images/menu.icon.off.3.gif deleted file mode 100644 index f8879f485..000000000 Binary files a/Images/menu.icon.off.3.gif and /dev/null differ diff --git a/Images/menu.icon.off.4.gif b/Images/menu.icon.off.4.gif deleted file mode 100644 index c5934962c..000000000 Binary files a/Images/menu.icon.off.4.gif and /dev/null differ diff --git a/Images/menu.icon.on.1.gif b/Images/menu.icon.on.1.gif deleted file mode 100644 index 3f840dee1..000000000 Binary files a/Images/menu.icon.on.1.gif and /dev/null differ diff --git a/Images/menu.icon.on.2.gif b/Images/menu.icon.on.2.gif deleted file mode 100644 index 85580ee33..000000000 Binary files a/Images/menu.icon.on.2.gif and /dev/null differ diff --git a/Images/menu.icon.on.3.gif b/Images/menu.icon.on.3.gif deleted file mode 100644 index 3e79c9081..000000000 Binary files a/Images/menu.icon.on.3.gif and /dev/null differ diff --git a/Images/menu.icon.on.4.gif b/Images/menu.icon.on.4.gif deleted file mode 100644 index 031f9b5c5..000000000 Binary files a/Images/menu.icon.on.4.gif and /dev/null differ diff --git a/Images/poloniex-logo-background.png b/Images/poloniex-logo-background.png deleted file mode 100644 index b589e405f..000000000 Binary files a/Images/poloniex-logo-background.png and /dev/null differ diff --git a/Images/poloniex-logo.png b/Images/poloniex-logo.png deleted file mode 100644 index 798c46a19..000000000 Binary files a/Images/poloniex-logo.png and /dev/null differ diff --git a/Images/tether-logo-background.png b/Images/tether-logo-background.png deleted file mode 100644 index db90501a4..000000000 Binary files a/Images/tether-logo-background.png and /dev/null differ diff --git a/Images/tether-logo.png b/Images/tether-logo.png deleted file mode 100644 index 7f8fc88f7..000000000 Binary files a/Images/tether-logo.png and /dev/null differ diff --git a/Spaces/CockpitSpace.js b/Spaces/CockpitSpace.js index 9de6a2eb1..3767afe41 100644 --- a/Spaces/CockpitSpace.js +++ b/Spaces/CockpitSpace.js @@ -54,8 +54,15 @@ } else { INITIAL_POSITION = 100 } + thisObject.container.frame.position.y = browserCanvas.height * INITIAL_POSITION / 100 - COCKPIT_SPACE_HEIGHT + let localStorage = window.localStorage.getItem(MODULE_NAME) + if (localStorage !== null) { + storage = JSON.parse(localStorage) + thisObject.container.frame.position.y = storage.spacePosition + } + canvasBrowserResizedEventSubscriptionId = window.canvasApp.eventHandler.listenToEvent('Browser Resized', resize) selfMouseClickEventSubscriptionId = thisObject.container.eventHandler.listenToEvent('onMouseClick', onMouseClick) @@ -126,6 +133,10 @@ } COCKPIT_SPACE_POSITION = thisObject.container.frame.position.y + let storage = { + spacePosition: COCKPIT_SPACE_POSITION + } + window.localStorage.setItem(MODULE_NAME, JSON.stringify(storage)) viewPort.resize() } diff --git a/Spaces/StrategySpace.js b/Spaces/StrategySpace.js index 3685ae89b..d99d48d32 100644 --- a/Spaces/StrategySpace.js +++ b/Spaces/StrategySpace.js @@ -42,14 +42,22 @@ 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 Definition', 'task'], ['Stop', 'pixel'], ['Take Profit', 'competition'], ['Phase', 'placeholder'], + ['Formula', 'pipette'], + ['Next Phase Event', 'schedule'], ['Situation', 'pyramid'], - ['Condition', 'testing'] + ['Condition', 'testing'], + ['Code', 'html'] ] for (let i = 0; i < relationshipArray.length; i++) { diff --git a/StrategySpace/ConstGetStrategies.js b/StrategySpace/ConstGetStrategies.js index aa77d1d5c..b3b9c2c09 100644 --- a/StrategySpace/ConstGetStrategies.js +++ b/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 diff --git a/StrategySpace/StrategizerGateway.js b/StrategySpace/StrategizerGateway.js index 2f2ad4195..222449458 100644 --- a/StrategySpace/StrategizerGateway.js +++ b/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) } diff --git a/StrategySpace/Workspace.js b/StrategySpace/Workspace.js deleted file mode 100644 index 180c97dec..000000000 --- a/StrategySpace/Workspace.js +++ /dev/null @@ -1,1124 +0,0 @@ - -function newWorkspace () { - const MODULE_NAME = 'Workspace' - - let thisObject = { - tradingSystem: undefined, - container: undefined, - idAtStrategizer: undefined, - physics: physics, - spawn: spawn, - detachNode: detachNode, - attachNode: attachNode, - getContainer: getContainer, - initialize: initialize, - finalize: finalize - } - - thisObject.container = newContainer() - thisObject.container.initialize(MODULE_NAME) - thisObject.container.isClickeable = false - thisObject.container.isDraggeable = false - thisObject.container.isWheelable = false - thisObject.container.detectMouseOver = false - thisObject.container.frame.radius = 0 - thisObject.container.frame.position.x = 0 - thisObject.container.frame.position.y = 0 - thisObject.container.frame.width = 0 - thisObject.container.frame.height = 0 - - spawnPosition = { - x: canvas.floatingSpace.container.frame.width / 2, - y: canvas.floatingSpace.container.frame.height / 2 - } - - let rootNodes = [] - - return thisObject - - function finalize () { - thisObject.tradingSystem = undefined - thisObject.container.finalize() - thisObject.container = undefined - } - - async function initialize () { - let savedWorkspace = window.localStorage.getItem('workspace') - if (savedWorkspace === null) { - initializeLoadingFromStrategizer() - } else { - workspace = JSON.parse(savedWorkspace) - rootNodes = workspace.rootNodes - thisObject.idAtStrategizer = workspace.idAtStrategizer - if (thisObject.idAtStrategizer === undefined) { - initializeLoadingFromStrategizer() - } else { - for (let i = 0; i < rootNodes.length; i++) { - let rootNode = rootNodes[i] - createPartFromNode(rootNode, undefined, undefined) - } - } - } - } - - async function initializeLoadingFromStrategizer () { - await canvas.strategySpace.strategizerGateway.loadFromStrategyzer() - let tradingSystem = canvas.strategySpace.strategizerGateway.strategizerData - if (tradingSystem !== undefined) { - let adaptedTradingSystem = { - strategies: tradingSystem.subStrategies - } - thisObject.idAtStrategizer = tradingSystem.id - rootNodes.push(adaptedTradingSystem) - generateStrategyParts(adaptedTradingSystem) - thisObject.tradingSystem = adaptedTradingSystem - thisObject.tradingSystem.payload.uiObject.setRunningStatus() - } - } - - function getContainer (point) { - - } - - function physics () { - /* Here we will save all the workspace related objects into the local storage */ - let stringifyReadyNodes = [] - for (let i = 0; i < rootNodes.length; i++) { - let rootNode = rootNodes[i] - let workspaceNode = getWorkspaceNode(rootNode) - stringifyReadyNodes.push(workspaceNode) - } - let workspace = { - idAtStrategizer: thisObject.idAtStrategizer, - rootNodes: stringifyReadyNodes - } - let textToSave = JSON.stringify(workspace) - window.localStorage.setItem('workspace', textToSave) - } - - function spawn (nodeText, point) { - point = canvas.floatingSpace.container.frame.unframeThisPoint(point) - spawnPosition.x = point.x - spawnPosition.y = point.y - - let dirtyNode = JSON.parse(nodeText) - let rootNode = getProtocolNode(dirtyNode) - rootNodes.push(rootNode) - createPartFromNode(rootNode, undefined, undefined) - } - - 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 '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 '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) - 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 detachNode (node) { - switch (node.type) { - case 'Trading System': { - return - } - case 'Strategy': { - let payload = node.payload - for (let i = 0; i < payload.parentNode.strategies.length; i++) { - let strategy = payload.parentNode.strategies[i] - if (strategy.id === node.id) { - payload.parentNode.strategies.splice(i, 1) - } - completeDetachment(node) - } - } - break - case 'Trigger On Event': { - return - } - break - case 'Trigger Off Event': { - return - } - break - case 'Take Position Event': { - return - } - break - case 'Stop': { - return - } - break - case 'Take Profit': { - return - } - break - case 'Condition': { - let payload = node.payload - 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) - } - } - completeDetachment(node) - } - break - case 'Situation': { - let payload = node.payload - for (let i = 0; i < payload.parentNode.situations.length; i++) { - let situation = payload.parentNode.situations[i] - if (situation.id === node.id) { - payload.parentNode.situations.splice(i, 1) - } - } - completeDetachment(node) - } - break - case 'Phase': { - let payload = node.payload - for (let i = 0; i < payload.parentNode.phases.length; i++) { - let phase = payload.parentNode.phases[i] - if (phase.id === node.id) { - if (i < payload.parentNode.phases.length - 1) { - let nextPhase = payload.parentNode.phases[i + 1] - if (i > 0) { - let previousPhase = payload.parentNode.phases[i - 1] - nextPhase.payload.chainParent = previousPhase - } else { - nextPhase.payload.chainParent = payload.parentNode - } - } - payload.parentNode.phases.splice(i, 1) - completeDetachment(node) - return - } - } - } - } - } - - function attachNode (node, attachToNode) { - switch (node.type) { - case 'Strategy': { - node.payload.parentNode = attachToNode - node.payload.chainParent = attachToNode - node.payload.parentNode.strategies.push(node) - completeAttachment(node) - } - break - case 'Phase': { - switch (attachToNode.type) { - case 'Stop': { - node.payload.parentNode = attachToNode - if (attachToNode.phases.length > 0) { - let phase = attachToNode.phases[attachToNode.phases.length - 1] - node.payload.chainParent = phase - } else { - node.payload.chainParent = attachToNode - } - attachToNode.phases.push(node) - completeAttachment(node) - } - break - case 'Take Profit': { - node.payload.parentNode = attachToNode - if (attachToNode.phases.length > 0) { - let phase = attachToNode.phases[attachToNode.phases.length - 1] - node.payload.chainParent = phase - } else { - node.payload.chainParent = attachToNode - } - attachToNode.phases.push(node) - completeAttachment(node) - } - break - case 'Phase': { - node.payload.parentNode = attachToNode.payload.parentNode - for (let i = 0; i < node.payload.parentNode.phases.length; i++) { - let phase = node.payload.parentNode.phases[i] - if (attachToNode.id === phase.id) { - if (i === node.payload.parentNode.phases.length - 1) { - node.payload.chainParent = attachToNode - node.payload.parentNode.phases.push(node) - completeAttachment(node) - } else { - node.payload.chainParent = attachToNode - let nextPhase = node.payload.parentNode.phases[i + 1] - nextPhase.payload.chainParent = node - node.payload.parentNode.phases.splice(i + 1, 0, node) - completeAttachment(node) - return - } - } - } - } - } - } - break - case 'Situation': { - node.payload.parentNode = attachToNode - node.payload.chainParent = attachToNode - node.payload.parentNode.situations.push(node) - completeAttachment(node) - } - break - case 'Condition': { - node.payload.parentNode = attachToNode - node.payload.chainParent = attachToNode - node.payload.parentNode.conditions.push(node) - completeAttachment(node) - } - break - } - } - - function completeDetachment (node) { - node.payload.parentNode = undefined - node.payload.chainParent = undefined - rootNodes.push(node) - } - - function completeAttachment (node) { - for (let i = 0; i < rootNodes.length; i++) { - let rootNode = rootNodes[i] - if (rootNode.id === node.id) { - rootNodes.splice(i, 1) - 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) - } - - function destroyPart (node) { - canvas.floatingSpace.strategyPartConstructor.destroyStrategyPart(node.payload) - } - - 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') - } - } - } - } - } - - async function onMenuItemClick (payload, action) { - switch (action) { - case 'Save Trading System': - { - let result = await canvas.strategySpace.strategizerGateway.saveToStrategyzer() - return result - break - } - - case 'Edit Code': - - break - case 'Download': - - let text = JSON.stringify(getProtocolNode(payload.node)) - let nodeName = payload.node.name - if (nodeName === undefined) { - nodeName = '' - } else { - nodeName = '.' + nodeName - } - let fileName = payload.node.type + nodeName + '.json' - download(fileName, text) - - break - - case 'New Strategy': - { - let strategyParent = payload.node - - let strategy = { - name: 'New Strategy', - active: true, - entryPoint: { - situations: [] - }, - exitPoint: { - situations: [] - }, - sellPoint: { - situations: [] - }, - stopLoss: { - phases: [] - }, - buyOrder: { - phases: [] - } - } - - 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) - } - break - case 'Add Phase': - { - let phaseParent = payload.node - let m = phaseParent.phases.length - let phase = { - name: 'New Phase', - code: '', - situations: [] - } - phaseParent.phases.push(phase) - let phaseChainParent - if (m > 0) { - phaseChainParent = phaseParent.phases[m - 1] - } else { - phaseChainParent = phaseParent - } - createPart('Phase', phase.name, phase, phaseParent, phaseChainParent, 'Phase') - } - break - case 'Add Situation': - { - let phase = payload.node - let m = phase.situations.length - let situation = { - name: 'New Situation', - conditions: [] - } - phase.situations.push(situation) - createPart('Situation', situation.name, situation, phase, phase, 'Situation') - } - break - case 'Add Condition': - { - let situation = payload.node - let m = situation.conditions.length - let condition = { - name: 'New Condition', - code: '' - } - situation.conditions.push(condition) - createPart('Condition', condition.name, condition, situation, situation, 'Condition') - } - break - case 'Delete Strategy': { - deleteStrategy(payload.node) - break - } - case 'Delete Phase': { - deletePhase(payload.node) - break - } - case 'Delete Situation': { - deleteSituation(payload.node) - break - } - case 'Delete Condition': { - deleteCondition(payload.node) - break - } - default: - - } - } - - 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) { - 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) - } - } - - function deleteEvent (node) { - while (node.situations.length > 0) { - deleteSituation(node.situations[0]) - } - destroyPart(node) - cleanNode(node) - } - - function deleteManagedItem (node) { - 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 - } - - function download (filename, text) { - let element = document.createElement('a') - element.setAttribute('href', 'data:text/plain;charset=utf-8,' + encodeURIComponent(text)) - element.setAttribute('download', filename) - element.style.display = 'none' - document.body.appendChild(element) - element.click() - document.body.removeChild(element) - } - - 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, - 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.situations.length; m++) { - let situation = getProtocolNode(node.situations[m]) - phase.situations.push(situation) - } - return phase - } - case 'Stop': { - 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': { - 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': { - 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': { - 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': { - 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 'Strategy': { - let strategy = { - type: node.type, - subType: node.subType, - name: node.name, - entryPoint: getProtocolNode(node.entryPoint), - exitPoint: getProtocolNode(node.exitPoint), - sellPoint: getProtocolNode(node.sellPoint), - stopLoss: getProtocolNode(node.stopLoss), - buyOrder: getProtocolNode(node.buyOrder) - } - 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) - } - return tradingSystem - } - } - } - - 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) - } - - for (let m = 0; m < node.situations.length; m++) { - let situation = getWorkspaceNode(node.situations[m]) - phase.situations.push(situation) - } - return phase - } - case 'Stop': { - 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': { - 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': { - 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': { - 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': { - 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 '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 - } - } - return savedPayload - } -} diff --git a/StrategySpace/Workspace/FunctionLibraries/AttachDetach.js b/StrategySpace/Workspace/FunctionLibraries/AttachDetach.js new file mode 100644 index 000000000..750290153 --- /dev/null +++ b/StrategySpace/Workspace/FunctionLibraries/AttachDetach.js @@ -0,0 +1,326 @@ +function newAttachDetach () { + thisObject = { + detachNode: detachNode, + attachNode: attachNode + } + + return thisObject + + function detachNode (node, rootNodes) { + switch (node.type) { + case 'Trading System': { + return + } + case 'Strategy': { + let payload = node.payload + for (let i = 0; i < payload.parentNode.strategies.length; i++) { + let strategy = payload.parentNode.strategies[i] + if (strategy.id === node.id) { + payload.parentNode.strategies.splice(i, 1) + } + completeDetachment(node, rootNodes) + } + } + break + case 'Trigger Stage': { + node.payload.parentNode.triggerStage = undefined + completeDetachment(node, rootNodes) + return + } + case 'Open Stage': { + node.payload.parentNode.openStage = undefined + completeDetachment(node, rootNodes) + return + } + case 'Manage Stage': { + node.payload.parentNode.manageStage = undefined + completeDetachment(node, rootNodes) + return + } + case 'Close Stage': { + node.payload.parentNode.closeStage = undefined + completeDetachment(node, rootNodes) + return + } + case 'Trigger On Event': { + node.payload.parentNode.triggerOn = undefined + completeDetachment(node, rootNodes) + return + } + case 'Trigger Off Event': { + node.payload.parentNode.triggerOff = undefined + completeDetachment(node, rootNodes) + return + } + case 'Take Position Event': { + node.payload.parentNode.takePosition = undefined + completeDetachment(node, rootNodes) + return + } + case 'Initial Definition': { + node.payload.parentNode.initialDefinition = undefined + completeDetachment(node, rootNodes) + return + } + case 'Stop': { + node.payload.parentNode.stopLoss = undefined + completeDetachment(node, rootNodes) + return + } + case 'Take Profit': { + node.payload.parentNode.takeProfit = undefined + completeDetachment(node, rootNodes) + return + } + case 'Formula': { + node.payload.parentNode.formula = undefined + completeDetachment(node, rootNodes) + return + } + case 'Next Phase Event': { + node.payload.parentNode.nextPhaseEvent = undefined + completeDetachment(node, rootNodes) + return + } + case 'Code': { + node.payload.parentNode.code = undefined + completeDetachment(node, rootNodes) + return + } + case 'Condition': { + let payload = node.payload + 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) + } + } + completeDetachment(node, rootNodes) + } + break + case 'Situation': { + let payload = node.payload + for (let i = 0; i < payload.parentNode.situations.length; i++) { + let situation = payload.parentNode.situations[i] + if (situation.id === node.id) { + payload.parentNode.situations.splice(i, 1) + } + } + completeDetachment(node, rootNodes) + } + break + case 'Phase': { + let payload = node.payload + for (let i = 0; i < payload.parentNode.phases.length; i++) { + let phase = payload.parentNode.phases[i] + if (phase.id === node.id) { + if (i < payload.parentNode.phases.length - 1) { + let nextPhase = payload.parentNode.phases[i + 1] + if (i > 0) { + let previousPhase = payload.parentNode.phases[i - 1] + nextPhase.payload.chainParent = previousPhase + } else { + nextPhase.payload.chainParent = payload.parentNode + } + } + payload.parentNode.phases.splice(i, 1) + completeDetachment(node, rootNodes) + return + } + } + } + } + } + + function attachNode (node, attachToNode, rootNodes) { + switch (node.type) { + case 'Strategy': { + node.payload.parentNode = attachToNode + node.payload.chainParent = attachToNode + node.payload.parentNode.strategies.push(node) + completeAttachment(node, rootNodes) + } + break + case 'Trigger Stage': { + node.payload.parentNode = attachToNode + node.payload.chainParent = attachToNode + node.payload.parentNode.triggerStage = node + completeAttachment(node, rootNodes) + } + break + case 'Open Stage': { + node.payload.parentNode = attachToNode + node.payload.chainParent = attachToNode + node.payload.parentNode.openStage = node + completeAttachment(node, rootNodes) + } + break + case 'Manage Stage': { + node.payload.parentNode = attachToNode + node.payload.chainParent = attachToNode + node.payload.parentNode.manageStage = node + completeAttachment(node, rootNodes) + } + break + case 'Close Stage': { + node.payload.parentNode = attachToNode + node.payload.chainParent = attachToNode + node.payload.parentNode.closeStage = node + completeAttachment(node, rootNodes) + } + break + case 'Initial Definition': { + node.payload.parentNode = attachToNode + node.payload.chainParent = attachToNode + node.payload.parentNode.initialDefinition = node + completeAttachment(node, rootNodes) + } + break + case 'Trigger On Event': { + node.payload.parentNode = attachToNode + node.payload.chainParent = attachToNode + node.payload.parentNode.triggerOn = node + completeAttachment(node, rootNodes) + } + break + case 'Trigger Off Event': { + node.payload.parentNode = attachToNode + node.payload.chainParent = attachToNode + node.payload.parentNode.triggerOff = node + completeAttachment(node, rootNodes) + } + break + case 'Take Position Event': { + node.payload.parentNode = attachToNode + node.payload.chainParent = attachToNode + node.payload.parentNode.takePosition = node + completeAttachment(node, rootNodes) + } + break + case 'Stop': { + node.payload.parentNode = attachToNode + node.payload.chainParent = attachToNode + node.payload.parentNode.stopLoss = node + completeAttachment(node, rootNodes) + } + break + case 'Take Profit': { + node.payload.parentNode = attachToNode + node.payload.chainParent = attachToNode + node.payload.parentNode.takeProfit = node + completeAttachment(node, rootNodes) + } + break + case 'Formula': { + node.payload.parentNode = attachToNode + node.payload.chainParent = attachToNode + node.payload.parentNode.formula = node + completeAttachment(node, rootNodes) + } + break + case 'Next Phase Event': { + node.payload.parentNode = attachToNode + node.payload.chainParent = attachToNode + node.payload.parentNode.nextPhaseEvent = node + completeAttachment(node, rootNodes) + } + break + case 'Phase': { + switch (attachToNode.type) { + case 'Stop': { + if (attachToNode.maxPhases !== undefined) { + if (attachToNode.phases.length >= attachToNode.maxPhases) { + return + } + } + node.payload.parentNode = attachToNode + if (attachToNode.phases.length > 0) { + let phase = attachToNode.phases[attachToNode.phases.length - 1] + node.payload.chainParent = phase + } else { + node.payload.chainParent = attachToNode + } + attachToNode.phases.push(node) + completeAttachment(node, rootNodes) + } + break + case 'Take Profit': { + if (attachToNode.maxPhases !== undefined) { + if (attachToNode.phases.length >= attachToNode.maxPhases) { + return + } + } + node.payload.parentNode = attachToNode + if (attachToNode.phases.length > 0) { + let phase = attachToNode.phases[attachToNode.phases.length - 1] + node.payload.chainParent = phase + } else { + node.payload.chainParent = attachToNode + } + attachToNode.phases.push(node) + completeAttachment(node, rootNodes) + } + break + case 'Phase': { + node.payload.parentNode = attachToNode.payload.parentNode + for (let i = 0; i < node.payload.parentNode.phases.length; i++) { + let phase = node.payload.parentNode.phases[i] + if (attachToNode.id === phase.id) { + if (i === node.payload.parentNode.phases.length - 1) { + node.payload.chainParent = attachToNode + node.payload.parentNode.phases.push(node) + completeAttachment(node, rootNodes) + } else { + node.payload.chainParent = attachToNode + let nextPhase = node.payload.parentNode.phases[i + 1] + nextPhase.payload.chainParent = node + node.payload.parentNode.phases.splice(i + 1, 0, node) + completeAttachment(node, rootNodes) + return + } + } + } + } + } + } + break + case 'Situation': { + node.payload.parentNode = attachToNode + node.payload.chainParent = attachToNode + node.payload.parentNode.situations.push(node) + completeAttachment(node, rootNodes) + } + break + case 'Condition': { + node.payload.parentNode = attachToNode + node.payload.chainParent = attachToNode + node.payload.parentNode.conditions.push(node) + completeAttachment(node, rootNodes) + } + break + case 'Code': { + node.payload.parentNode = attachToNode + node.payload.chainParent = attachToNode + node.payload.parentNode.code = node + completeAttachment(node, rootNodes) + } + break + } + } + + function completeDetachment (node, rootNodes) { + node.payload.parentNode = undefined + node.payload.chainParent = undefined + rootNodes.push(node) + } + + function completeAttachment (node, rootNodes) { + for (let i = 0; i < rootNodes.length; i++) { + let rootNode = rootNodes[i] + if (rootNode.id === node.id) { + rootNodes.splice(i, 1) + return + } + } + } +} diff --git a/StrategySpace/Workspace/FunctionLibraries/NodeDeleter.js b/StrategySpace/Workspace/FunctionLibraries/NodeDeleter.js new file mode 100644 index 000000000..9ed435656 --- /dev/null +++ b/StrategySpace/Workspace/FunctionLibraries/NodeDeleter.js @@ -0,0 +1,337 @@ +function newNodeDeleter () { + thisObject = { + deleteTradingSystem: deleteTradingSystem, + deleteStrategy: deleteStrategy, + deleteTriggerStage: deleteTriggerStage, + deleteOpenStage: deleteOpenStage, + deleteManageStage: deleteManageStage, + deleteCloseStage: deleteCloseStage, + deleteInitialDefinition: deleteInitialDefinition, + deleteEvent: deleteEvent, + deleteManagedItem: deleteManagedItem, + deletePhase: deletePhase, + deleteFormula: deleteFormula, + deleteSituation: deleteSituation, + deleteCondition: deleteCondition, + deleteCode: deleteCode + } + + return thisObject + + function destroyPart (node) { + canvas.floatingSpace.strategyPartConstructor.destroyStrategyPart(node.payload) + } + + function deleteTradingSystem (node, rootNodes) { +/* Can not delete if it is the last one */ + let counter = 0 + for (let i = 0; i < rootNodes.length; i++) { + let rootNode = rootNodes[i] + if (rootNode.type === node.type) { + counter++ + } + } + if (counter <= 1) { return } + + if (node.payload.uiObject.isRunning === true) { + strategyPart.setNotRunningStatus() + } + + while (node.strategies.length > 0) { + deleteStrategy(node.strategies[0]) + } + + completeDeletion(node, rootNodes) + destroyPart(node) + cleanNode(node) + } + + function deleteStrategy (node, rootNodes) { + 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) + } + } + } else { + completeDeletion(node, rootNodes) + } + if (node.triggerStage !== undefined) { + deleteTriggerStage(node.triggerStage) + } + if (node.openStage !== undefined) { + deleteOpenStage(node.openStage) + } + if (node.manageStage !== undefined) { + deleteManageStage(node.manageStage) + } + if (node.closeStage !== undefined) { + deleteCloseStage(node.closeStage) + } + destroyPart(node) + cleanNode(node) + } + + function deleteTriggerStage (node, rootNodes) { + let payload = node.payload + if (payload.parentNode !== undefined) { + payload.parentNode.triggerStage = undefined + } else { + completeDeletion(node, rootNodes) + } + if (node.triggerOn !== undefined) { + deleteEvent(node.triggerOn) + } + if (node.triggerOff !== undefined) { + deleteEvent(node.triggerOff) + } + if (node.takePosition !== undefined) { + deleteEvent(node.takePosition) + } + destroyPart(node) + cleanNode(node) + } + + function deleteOpenStage (node, rootNodes) { + let payload = node.payload + if (payload.parentNode !== undefined) { + payload.parentNode.openStage = undefined + } else { + completeDeletion(node, rootNodes) + } + if (node.initialDefinition !== undefined) { + deleteInitialDefinition(node.initialDefinition) + } + destroyPart(node) + cleanNode(node) + } + + function deleteManageStage (node, rootNodes) { + let payload = node.payload + if (payload.parentNode !== undefined) { + payload.parentNode.manageStage = undefined + } else { + completeDeletion(node, rootNodes) + } + if (node.stopLoss !== undefined) { + deleteManagedItem(node.stopLoss) + } + if (node.takeProfit !== undefined) { + deleteManagedItem(node.takeProfit) + } + destroyPart(node) + cleanNode(node) + } + + function deleteCloseStage (node, rootNodes) { + let payload = node.payload + if (payload.parentNode !== undefined) { + payload.parentNode.closeStage = undefined + } else { + completeDeletion(node, rootNodes) + } + destroyPart(node) + cleanNode(node) + } + + function deleteInitialDefinition (node, rootNodes) { + let payload = node.payload + if (payload.parentNode !== undefined) { + payload.parentNode.initialDefinition = undefined + } else { + completeDeletion(node, rootNodes) + } + if (node.stopLoss !== undefined) { + deleteManagedItem(node.stopLoss) + } + if (node.takeProfit !== undefined) { + deleteManagedItem(node.takeProfit) + } + destroyPart(node) + cleanNode(node) + } + + function deleteEvent (node, rootNodes) { + let payload = node.payload + if (payload.parentNode !== undefined) { + switch (node.type) { + case 'Trigger On Event': { + payload.parentNode.triggerOn = undefined + break + } + case 'Trigger Off Event': { + payload.parentNode.triggerOff = undefined + break + } + case 'Take Position Event': { + payload.parentNode.takePosition = undefined + break + } + case 'Next Phase Event': { + payload.parentNode.nextPhaseEvent = undefined + break + } + } + } else { + completeDeletion(node, rootNodes) + } + + while (node.situations.length > 0) { + deleteSituation(node.situations[0]) + } + destroyPart(node) + cleanNode(node) + } + + function deleteManagedItem (node, rootNodes) { + let payload = node.payload + if (payload.parentNode !== undefined) { + switch (node.type) { + case 'Stop': { + payload.parentNode.stopLoss = undefined + break + } + case 'Take Profit': { + payload.parentNode.takeProfit = undefined + break + } + } + } else { + completeDeletion(node, rootNodes) + } + + while (node.phases.length > 0) { + deletePhase(node.phases[0]) + } + destroyPart(node) + cleanNode(node) + } + + function deletePhase (node, rootNodes) { + 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) { + /* 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) + } + } + } else { + completeDeletion(node, rootNodes) + } + + if (node.formula !== undefined) { + deleteFormula(node.formula, rootNodes) + } + + if (node.nextPhaseEvent !== undefined) { + deleteEvent(node.nextPhaseEvent, rootNodes) + } + destroyPart(node) + cleanNode(node) + } + + function deleteFormula (node, rootNodes) { + let payload = node.payload + if (payload.parentNode !== undefined) { + payload.parentNode.formula = undefined + } else { + completeDeletion(node, rootNodes) + } + + destroyPart(node) + cleanNode(node) + } + + function deleteSituation (node, rootNodes) { + 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 = [] + completeDeletion(node, rootNodes) + destroyPart(node) + cleanNode(node) + } + } + + function deleteCondition (node, rootNodes) { + 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) + } + } + } else { + completeDeletion(node, rootNodes) + } + if (node.code !== undefined) { + deleteCode(node.code, rootNodes) + } + destroyPart(node) + cleanNode(node) + } + + function deleteCode (node, rootNodes) { + let payload = node.payload + if (payload.parentNode !== undefined) { + payload.parentNode.code = undefined + } else { + completeDeletion(node, rootNodes) + } + + destroyPart(node) + cleanNode(node) + } + + function completeDeletion (node, rootNodes) { + for (let i = 0; i < rootNodes.length; i++) { + let rootNode = rootNodes[i] + if (rootNode.id === node.id) { + rootNodes.splice(i, 1) + return + } + } + } + + 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 + } +} diff --git a/StrategySpace/Workspace/FunctionLibraries/PartsFromNodes.js b/StrategySpace/Workspace/FunctionLibraries/PartsFromNodes.js new file mode 100644 index 000000000..b623c2b17 --- /dev/null +++ b/StrategySpace/Workspace/FunctionLibraries/PartsFromNodes.js @@ -0,0 +1,516 @@ +function newPartsFromNodes () { + thisObject = { + createPartFromNode: createPartFromNode, + newStrategy: newStrategy, + addMissingStages: addMissingStages, + addMissingEvents: addMissingEvents, + addMissingItems: addMissingItems, + addInitialDefinition: addInitialDefinition, + addPhase: addPhase, + addFormula: addFormula, + addNextPhaseEvent: addNextPhaseEvent, + addSituation: addSituation, + addCondition: addCondition, + addCode: addCode + } + + return thisObject + + function createPartFromNode (node, parentNode, chainParent) { + switch (node.type) { + case 'Code': + { + createPart('Code', node.name, node, parentNode, chainParent, 'Code') + return + } + case 'Condition': + { + createPart('Condition', node.name, node, parentNode, chainParent, 'Condition') + if (node.code !== undefined) { + createPartFromNode(node.code, node, node) + } + 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 'Formula': + { + createPart('Formula', node.name, node, parentNode, chainParent, 'Formula') + return + } + case 'Next Phase Event': + { + createPart('Next Phase Event', node.name, node, parentNode, chainParent, 'Next Phase Event') + for (let m = 0; m < node.situations.length; m++) { + let situation = node.situations[m] + createPartFromNode(situation, node, node) + } + return + } + case 'Phase': { + let phase = node + createPart('Phase', phase.name, phase, parentNode, chainParent, phase.subType) + + if (node.formula !== undefined) { + createPartFromNode(node.formula, phase, phase) + } + if (node.nextPhaseEvent !== undefined) { + createPartFromNode(node.nextPhaseEvent, 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') + + if (node.stopLoss !== undefined) { + createPartFromNode(node.stopLoss, node, node) + } + if (node.takeProfit !== undefined) { + createPartFromNode(node.takeProfit, node, node) + } + 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.triggerOn !== undefined) { + createPartFromNode(node.triggerOn, stage, stage) + } + if (node.triggerOff !== undefined) { + createPartFromNode(node.triggerOff, stage, stage) + } + if (node.takePosition !== undefined) { + createPartFromNode(node.takePosition, 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.takeProfit !== undefined) { + createPartFromNode(node.takeProfit, 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 newStrategy (parentNode) { + let strategyParent = parentNode + let strategy = { + name: 'New Strategy', + active: true, + triggerStage: { + triggerOn: { + situations: [] + }, + triggerOff: { + situations: [] + }, + takePosition: { + situations: [] + } + }, + openStage: { + initialDefinition: { + stopLoss: { + phases: [], + maxPhases: 1 + }, + takeProfit: { + phases: [], + maxPhases: 1 + } + } + }, + manageStage: { + stopLoss: { + phases: [] + }, + takeProfit: { + phases: [] + } + }, + closeStage: { + } + } + + strategyParent.strategies.push(strategy) + createPart('Strategy', strategy.name, strategy, strategyParent, strategyParent, '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.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.takeProfit, strategy.manageStage, strategy.manageStage) + createPart('Stop', 'Initial Stop', strategy.openStage.initialDefinition.stopLoss, strategy.openStage.initialDefinition, strategy.openStage.initialDefinition) + createPart('Take Profit', 'Initial Take Profit', strategy.openStage.initialDefinition.takeProfit, strategy.openStage.initialDefinition, strategy.openStage.initialDefinition) + } + + function addMissingStages (node) { + if (node.triggerStage === undefined) { + node.triggerStage = { + triggerOn: { + situations: [] + }, + triggerOff: { + situations: [] + }, + takePosition: { + situations: [] + } + } + createPart('Trigger Stage', '', node.triggerStage, node, node, 'Trigger Stage') + 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 = { + initialDefinition: { + stopLoss: { + phases: [], + maxPhases: 1 + }, + takeProfit: { + phases: [], + maxPhases: 1 + } + } + } + createPart('Open Stage', '', node.openStage, node, node, 'Open Stage') + createPart('Initial Definition', '', node.openStage.initialDefinition, node.openStage, node.openStage) + createPart('Stop', 'Initial Stop', node.openStage.initialDefinition.stopLoss, node.openStage.initialDefinition, node.openStage.initialDefinition) + createPart('Take Profit', 'Initial Take Profit', node.openStage.initialDefinition.takeProfit, node.openStage.initialDefinition, node.openStage.initialDefinition) + } + if (node.manageStage === undefined) { + node.manageStage = { + stopLoss: { + phases: [] + }, + 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.takeProfit, node.manageStage, node.manageStage) + } + if (node.triggerStage === undefined) { + createPart('Close Stage', '', node.closeStage, node, node, 'Close Stage') + } + } + + function addMissingEvents (node) { + if (node.triggerOn === undefined) { + node.triggerOn = { + situations: [] + } + createPart('Trigger On Event', '', node.triggerOn, node, node) + } + if (node.triggerOff === undefined) { + node.triggerOff = { + situations: [] + } + createPart('Trigger Off Event', '', node.triggerOff, node, node) + } + if (node.takePosition === undefined) { + node.takePosition = { + situations: [] + } + createPart('Take Position Event', '', node.takePosition, node, node) + } + } + + function addMissingItems (node) { + if (node.type === 'Initial Definition') { + if (node.stopLoss === undefined) { + node.stopLoss = { + phases: [], + maxPhases: 1 + } + createPart('Stop', 'Initial Stop', node.stopLoss, node, node) + } + if (node.takeProfit === undefined) { + node.takeProfit = { + phases: [], + maxPhases: 1 + } + createPart('Take Profit', 'Initial Take Profit', node.takeProfit, node, node) + } + } else { + if (node.stopLoss === undefined) { + node.stopLoss = { + phases: [] + } + createPart('Stop', '', node.stopLoss, node, node) + } + if (node.takeProfit === undefined) { + node.takeProfit = { + phases: [] + } + createPart('Take Profit', '', node.takeProfit, node, node) + } + } + } + + function addInitialDefinition (node) { + if (node.initialDefinition === undefined) { + node.initialDefinition = { + stopLoss: { + phases: [], + maxPhases: 1 + }, + takeProfit: { + phases: [], + maxPhases: 1 + } + } + createPart('Initial Definition', '', node.initialDefinition, node, node) + createPart('Stop', 'Initial Stop', node.initialDefinition.stopLoss, node.initialDefinition, node.initialDefinition) + createPart('Take Profit', 'Initial Take Profit', node.initialDefinition.takeProfit, node.initialDefinition, node.initialDefinition) + } + } + + function addFormula (node) { + if (node.formula === undefined) { + node.formula = { + code: DEFAULT_FORMULA_TEXT + } + createPart('Formula', '', node.formula, node, node) + } + } + + function addNextPhaseEvent (node) { + if (node.nextPhaseEvent === undefined) { + node.nextPhaseEvent = { + situations: [] + } + createPart('Next Phase Event', '', node.nextPhaseEvent, node, node) + } + } + + function addCode (node) { + if (node.code === undefined) { + node.code = { + code: DEFAULT_CODE_TEXT + } + createPart('Code', '', node.code, node, node) + } + } + + function addPhase (parentNode) { + if (parentNode.maxPhases !== undefined) { + if (parentNode.phases.length >= parentNode.maxPhases) { + return + } + } + let phaseParent = parentNode + let m = phaseParent.phases.length + let phase = { + name: 'New Phase', + formula: { + code: DEFAULT_FORMULA_TEXT + }, + nextPhaseEvent: { + situations: [] + } + } + phaseParent.phases.push(phase) + let phaseChainParent + if (m > 0) { + phaseChainParent = phaseParent.phases[m - 1] + } else { + phaseChainParent = phaseParent + } + createPart('Phase', phase.name, phase, phaseParent, phaseChainParent, 'Phase') + createPart('Formula', '', phase.formula, phase, phase, 'Formula') + createPart('Next Phase Event', '', phase.nextPhaseEvent, phase, phase) + } + + function addSituation (parentNode) { + let m = parentNode.situations.length + let situation = { + name: 'New Situation', + conditions: [] + } + parentNode.situations.push(situation) + createPart('Situation', situation.name, situation, parentNode, parentNode, 'Situation') + } + + function addCondition (parentNode) { + let situation = parentNode + let m = situation.conditions.length + let condition = { + name: 'New Condition', + code: { + code: DEFAULT_CODE_TEXT + } + } + situation.conditions.push(condition) + createPart('Condition', condition.name, condition, situation, situation, 'Condition') + createPart('Code', '', condition.code, condition, condition, 'Code') + } + + 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 = canvas.strategySpace.workspace.onMenuItemClick + + if (node.id === undefined) { + node.id = newUniqueId() + } + node.payload = payload + node.type = partType + canvas.floatingSpace.strategyPartConstructor.createStrategyPart(payload) + } +} diff --git a/StrategySpace/Workspace/FunctionLibraries/ProtocolNode.js b/StrategySpace/Workspace/FunctionLibraries/ProtocolNode.js new file mode 100644 index 000000000..5ff9f18cd --- /dev/null +++ b/StrategySpace/Workspace/FunctionLibraries/ProtocolNode.js @@ -0,0 +1,224 @@ +function newProtocolNode () { + thisObject = { + getProtocolNode: getProtocolNode + } + return thisObject + + function getProtocolNode (node) { + if (node === undefined) { return } + switch (node.type) { + case 'Code': + { + let code = { + type: node.type, + subType: node.subType, + name: node.name, + code: node.code + } + return code + } + case 'Condition': + { + let condition = { + type: node.type, + subType: node.subType, + name: node.name, + code: getProtocolNode(node.code) + } + 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 'Formula': + { + let formula = { + type: node.type, + subType: node.subType, + name: node.name, + code: node.code + } + return formula + } + case 'Next Phase Event': + { + 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 'Phase': { + let phase = { + type: node.type, + subType: node.subType, + name: node.name, + formula: getProtocolNode(node.formula), + nextPhaseEvent: getProtocolNode(node.nextPhaseEvent) + } + return phase + } + case 'Stop': { + 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': { + 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': { + 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': { + 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': { + 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 'Initial Definition': { + let object = { + type: node.type, + subType: node.subType, + name: node.name, + stopLoss: getProtocolNode(node.stopLoss), + takeProfit: getProtocolNode(node.takeProfit) + } + return object + } + case 'Trigger Stage': { + let stage = { + type: node.type, + subType: node.subType, + name: node.name, + triggerOn: getProtocolNode(node.triggerOn), + triggerOff: getProtocolNode(node.triggerOff), + takePosition: getProtocolNode(node.takePosition) + } + 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), + takeProfit: getProtocolNode(node.takeProfit) + } + 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': { + 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) + } + return tradingSystem + } + } + } +} diff --git a/StrategySpace/Workspace/FunctionLibraries/WorkspaceNode.js b/StrategySpace/Workspace/FunctionLibraries/WorkspaceNode.js new file mode 100644 index 000000000..b11aba2e4 --- /dev/null +++ b/StrategySpace/Workspace/FunctionLibraries/WorkspaceNode.js @@ -0,0 +1,286 @@ +function newWorkspaceNode () { + thisObject = { + getWorkspaceNode: getWorkspaceNode + } + return thisObject + + function getWorkspaceNode (node) { + if (node === undefined) { return } + switch (node.type) { + case 'Code': + { + let code = { + id: node.id, + type: node.type, + subType: node.subType, + name: node.name, + code: node.code, + savedPayload: getSavedPayload(node) + } + return code + } + case 'Condition': + { + let condition = { + id: node.id, + type: node.type, + subType: node.subType, + name: node.name, + code: getWorkspaceNode(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 'Formula': + { + let formula = { + id: node.id, + type: node.type, + subType: node.subType, + name: node.name, + code: node.code, + savedPayload: getSavedPayload(node) + } + return formula + } + case 'Next Phase Event': + { + 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 'Phase': { + let phase = { + id: node.id, + type: node.type, + subType: node.subType, + name: node.name, + formula: getWorkspaceNode(node.formula), + nextPhaseEvent: getWorkspaceNode(node.nextPhaseEvent), + savedPayload: getSavedPayload(node) + } + return phase + } + case 'Stop': { + let stop = { + id: node.id, + type: node.type, + subType: node.subType, + name: node.name, + phases: [], + maxPhases: node.maxPhases, + 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': { + let takeProfit = { + id: node.id, + type: node.type, + subType: node.subType, + name: node.name, + phases: [], + maxPhases: node.maxPhases, + 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': { + 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': { + 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': { + 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 'Initial Definition': { + let object = { + id: node.id, + type: node.type, + subType: node.subType, + name: node.name, + stopLoss: getWorkspaceNode(node.stopLoss), + takeProfit: getWorkspaceNode(node.takeProfit), + savedPayload: getSavedPayload(node) + } + return object + } + case 'Trigger Stage': { + let stage = { + id: node.id, + type: node.type, + subType: node.subType, + name: node.name, + triggerOn: getWorkspaceNode(node.triggerOn), + triggerOff: getWorkspaceNode(node.triggerOff), + takePosition: getWorkspaceNode(node.takePosition), + 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), + takeProfit: getWorkspaceNode(node.takeProfit), + 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, + type: node.type, + subType: node.subType, + name: node.name, + triggerStage: getWorkspaceNode(node.triggerStage), + openStage: getWorkspaceNode(node.openStage), + manageStage: getWorkspaceNode(node.manageStage), + closeStage: getWorkspaceNode(node.closeStage), + 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) { + if (node.payload === undefined) { + console.log(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, + isFrozen: (node.payload.floatingObject.isFrozen && node.payload.floatingObject.frozenManually) + }, + uiObject: { + isRunning: node.payload.uiObject.isRunning + } + } + return savedPayload + } +} diff --git a/StrategySpace/Workspace/Workspace.js b/StrategySpace/Workspace/Workspace.js new file mode 100644 index 000000000..54b9bf21a --- /dev/null +++ b/StrategySpace/Workspace/Workspace.js @@ -0,0 +1,282 @@ + +function newWorkspace () { + const MODULE_NAME = 'Workspace' + + let thisObject = { + tradingSystem: undefined, + container: undefined, + idAtStrategizer: undefined, + onMenuItemClick: onMenuItemClick, + physics: physics, + spawn: spawn, + detachNode: detachNode, + attachNode: attachNode, + getContainer: getContainer, + initialize: initialize, + finalize: finalize + } + + thisObject.container = newContainer() + thisObject.container.initialize(MODULE_NAME) + thisObject.container.isClickeable = false + thisObject.container.isDraggeable = false + thisObject.container.isWheelable = false + thisObject.container.detectMouseOver = false + thisObject.container.frame.radius = 0 + thisObject.container.frame.position.x = 0 + thisObject.container.frame.position.y = 0 + thisObject.container.frame.width = 0 + thisObject.container.frame.height = 0 + + spawnPosition = { + x: canvas.floatingSpace.container.frame.width / 2, + y: canvas.floatingSpace.container.frame.height / 2 + } + + let rootNodes = [] + + functionLibraryAttachDetach = newAttachDetach() + functionLibraryNodeDeleter = newNodeDeleter() + functionLibraryPartsFromNodes = newPartsFromNodes() + functionLibraryProtocolNode = newProtocolNode() + functionLibraryWorkspaceNodes = newWorkspaceNode() + + return thisObject + + function finalize () { + thisObject.tradingSystem = undefined + thisObject.container.finalize() + thisObject.container = undefined + } + + async function initialize () { + functionLibraryAttachDetach = newAttachDetach() + functionLibraryNodeDeleter = newNodeDeleter() + functionLibraryPartsFromNodes = newPartsFromNodes() + functionLibraryProtocolNode = newProtocolNode() + functionLibraryWorkspaceNodes = newWorkspaceNode() + + let savedWorkspace = window.localStorage.getItem('workspace') + if (savedWorkspace === null) { + initializeLoadingFromStrategizer() + } else { + workspace = JSON.parse(savedWorkspace) + rootNodes = workspace.rootNodes + thisObject.idAtStrategizer = workspace.idAtStrategizer + if (thisObject.idAtStrategizer === undefined) { + initializeLoadingFromStrategizer() + } else { + for (let i = 0; i < rootNodes.length; i++) { + let rootNode = rootNodes[i] + functionLibraryPartsFromNodes.createPartFromNode(rootNode, undefined, undefined) + } + } + } + } + + async function initializeLoadingFromStrategizer () { + await canvas.strategySpace.strategizerGateway.loadFromStrategyzer() + let tradingSystem = canvas.strategySpace.strategizerGateway.strategizerData + if (tradingSystem !== undefined) { + let adaptedTradingSystem = { + strategies: tradingSystem.subStrategies + } + thisObject.idAtStrategizer = tradingSystem.id + rootNodes.push(adaptedTradingSystem) + functionLibraryPartsFromNodes.createPartFromNode(adaptedTradingSystem, undefined, undefined) + thisObject.tradingSystem = adaptedTradingSystem + thisObject.tradingSystem.payload.uiObject.setRunningStatus() + } + } + + function getContainer (point) { + + } + + function detachNode (node) { + functionLibraryAttachDetach.detachNode(node, rootNodes) + } + + function attachNode (node, attachToNode) { + functionLibraryAttachDetach.attachNode(node, attachToNode, rootNodes) + } + + function physics () { + /* Here we will save all the workspace related objects into the local storage */ + let stringifyReadyNodes = [] + for (let i = 0; i < rootNodes.length; i++) { + let rootNode = rootNodes[i] + let workspaceNode = functionLibraryWorkspaceNodes.getWorkspaceNode(rootNode) + stringifyReadyNodes.push(workspaceNode) + } + let workspace = { + idAtStrategizer: thisObject.idAtStrategizer, + rootNodes: stringifyReadyNodes + } + let textToSave = JSON.stringify(workspace) + window.localStorage.setItem('workspace', textToSave) + } + + function spawn (nodeText, point) { + point = canvas.floatingSpace.container.frame.unframeThisPoint(point) + spawnPosition.x = point.x + spawnPosition.y = point.y + + let dirtyNode = JSON.parse(nodeText) + let rootNode = functionLibraryProtocolNode.getProtocolNode(dirtyNode) + rootNodes.push(rootNode) + functionLibraryPartsFromNodes.createPartFromNode(rootNode, undefined, undefined) + } + + async function onMenuItemClick (payload, action) { + switch (action) { + case 'Save Trading System': + { + let result = await canvas.strategySpace.strategizerGateway.saveToStrategyzer() + return result + break + } + + case 'Edit Code': + + break + case 'Download': + + let text = JSON.stringify(functionLibraryProtocolNode.getProtocolNode(payload.node)) + let nodeName = payload.node.name + if (nodeName === undefined) { + nodeName = '' + } else { + nodeName = '.' + nodeName + } + let fileName = payload.node.type + nodeName + '.json' + download(fileName, text) + + break + + case 'New Strategy': + { + functionLibraryPartsFromNodes.newStrategy(payload.node) + } + break + case 'Add Missing Stages': + { + functionLibraryPartsFromNodes.addMissingStages(payload.node) + } + break + case 'Add Missing Events': + { + functionLibraryPartsFromNodes.addMissingEvents(payload.node) + } + break + case 'Add Missing Items': + { + functionLibraryPartsFromNodes.addMissingItems(payload.node) + } + break + case 'Add Initial Definition': + { + functionLibraryPartsFromNodes.addInitialDefinition(payload.node) + } + break + case 'Add Phase': + { + functionLibraryPartsFromNodes.addPhase(payload.node) + } + break + case 'Add Formula': + { + functionLibraryPartsFromNodes.addFormula(payload.node) + } + break + case 'Add Next Phase Event': + { + functionLibraryPartsFromNodes.addNextPhaseEvent(payload.node) + } + break + case 'Add Situation': + { + functionLibraryPartsFromNodes.addSituation(payload.node) + } + break + case 'Add Condition': + { + functionLibraryPartsFromNodes.addCondition(payload.node) + } + break + case 'Add Code': + { + functionLibraryPartsFromNodes.addCode(payload.node) + } + break + case 'Delete Trading System': { + functionLibraryNodeDeleter.deleteTradingSystem(payload.node, rootNodes) + break + } + case 'Delete Strategy': { + functionLibraryNodeDeleter.deleteStrategy(payload.node, rootNodes) + break + } + case 'Delete Trigger Stage': { + functionLibraryNodeDeleter.deleteTriggerStage(payload.node, rootNodes) + break + } + case 'Delete Open Stage': { + functionLibraryNodeDeleter.deleteOpenStage(payload.node, rootNodes) + break + } + case 'Delete Manage Stage': { + functionLibraryNodeDeleter.deleteManageStage(payload.node, rootNodes) + break + } + case 'Delete Close Stage': { + functionLibraryNodeDeleter.deleteCloseStage(payload.node, rootNodes) + break + } + case 'Delete Initial Definition': { + functionLibraryNodeDeleter.deleteInitialDefinition(payload.node, rootNodes) + break + } + case 'Delete Event': { + functionLibraryNodeDeleter.deleteEvent(payload.node, rootNodes) + break + } + case 'Delete Managed Item': { + functionLibraryNodeDeleter.deleteManagedItem(payload.node, rootNodes) + break + } + case 'Delete Phase': { + functionLibraryNodeDeleter.deletePhase(payload.node, rootNodes) + break + } + case 'Delete Formula': { + functionLibraryNodeDeleter.deleteFormula(payload.node, rootNodes) + break + } + case 'Delete Situation': { + functionLibraryNodeDeleter.deleteSituation(payload.node, rootNodes) + break + } + case 'Delete Condition': { + functionLibraryNodeDeleter.deleteCondition(payload.node, rootNodes) + break + } + case 'Delete Code': { + functionLibraryNodeDeleter.deleteCode(payload.node, rootNodes) + break + } + default: + + } + } + + function download (filename, text) { + let element = document.createElement('a') + element.setAttribute('href', 'data:text/plain;charset=utf-8,' + encodeURIComponent(text)) + element.setAttribute('download', filename) + element.style.display = 'none' + document.body.appendChild(element) + element.click() + document.body.removeChild(element) + } +}