Merge pull request #65 from AAMasters/develop
Adapting Canvas App for protocol v0.1
This commit is contained in:
70 files changed
+3134
-1345
No files matched your search
+86
-128
@@ -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 () {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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 () {
|
||||
|
||||
@@ -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()
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -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
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 78 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 65 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 18 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 26 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 16 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 11 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 15 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 8.9 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 6.8 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 10 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 6.2 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 10 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 61 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 923 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 29 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 29 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 94 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 7.4 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 91 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 37 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 36 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 20 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 53 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 51 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 343 B |
Binary file not shown.
|
Before Width: | Height: | Size: 669 B |
Binary file not shown.
|
Before Width: | Height: | Size: 723 B |
Binary file not shown.
|
Before Width: | Height: | Size: 475 B |
Binary file not shown.
|
Before Width: | Height: | Size: 26 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 72 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 9.5 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 49 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 23 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 84 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 5.4 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 801 B |
Binary file not shown.
|
Before Width: | Height: | Size: 4.4 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 4.7 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 17 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 86 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 15 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 10 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 9.8 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 9.4 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 9.5 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 10 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 9.8 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 9.4 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 9.5 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 10 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 18 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 13 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 122 KiB |
@@ -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()
|
||||
}
|
||||
|
||||
|
||||
@@ -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++) {
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -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
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user