fez5587/Superalgos
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Stages Concept Implemented

Browse Source
This commit is contained in:
Luis Fernando Molina committed 2019-05-26 20:17:38 +02:00
1 parent b40019068e
commit 7efa2b2a02
5 files changed
+606 -43
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

FloatingSpace/StrategyPart.js
+40 -1
View File
@@ -185,6 +185,46 @@ function newStrategyPart () {
compatibleType = 'Trading System'
compatibleSubType = undefined
break
case 'Trigger Stage':
compatibleType = 'Strategy'
compatibleSubType = undefined
break
case 'Open Stage':
compatibleType = 'Strategy'
compatibleSubType = undefined
break
case 'Manage Stage':
compatibleType = 'Strategy'
compatibleSubType = undefined
break
case 'Close Stage':
compatibleType = 'Strategy'
compatibleSubType = undefined
break
case 'Take Position Event':
compatibleType = 'Trigger Stage'
compatibleSubType = undefined
break
case 'Trigger Off Event':
compatibleType = 'Trigger Stage'
compatibleSubType = undefined
break
case 'Trigger On Event':
compatibleType = 'Trigger Stage'
compatibleSubType = undefined
break
case 'Initial Information':
compatibleType = 'Open Stage'
compatibleSubType = undefined
break
case 'Stop':
compatibleType = 'Manage Stage'
compatibleSubType = undefined
break
case 'Take Profit':
compatibleType = 'Manage Stage'
compatibleSubType = undefined
break
case 'Phase':
compatibleType = 'Stop' + '.' + 'Take Profit' + '.' + 'Phase'
compatibleSubType = undefined
@@ -674,4 +714,3 @@ function newStrategyPart () {
}
}
}
FloatingSpace/StrategyPartConstructor.js
+227 -1
View File
@@ -186,6 +186,174 @@ function newStrategyPartConstructor () {
}]
break
}
case 'Trigger Stage': {
menuItemsInitialValues = [
{
action: 'Pin / Unpin',
actionFunction: floatingObject.pinToggle,
actionStatus: floatingObject.getPinStatus,
currentStatus: false,
label: undefined,
visible: false,
iconPathOn: 'target',
iconPathOff: 'security',
rawRadius: 8,
targetRadius: 0,
currentRadius: 0,
angle: -135
},
{
action: 'Delete Trigger Stage',
actionFunction: payload.onMenuItemClick,
label: 'Delete This Stage',
visible: false,
iconPathOn: 'trash',
iconPathOff: 'trash',
rawRadius: 8,
targetRadius: 0,
currentRadius: 0,
angle: -20
},
{
action: 'Download',
actionFunction: payload.onMenuItemClick,
label: 'Download',
visible: false,
iconPathOn: 'upload',
iconPathOff: 'upload',
rawRadius: 8,
targetRadius: 0,
currentRadius: 0,
angle: 20
}]
break
}
case 'Open Stage': {
menuItemsInitialValues = [
{
action: 'Pin / Unpin',
actionFunction: floatingObject.pinToggle,
actionStatus: floatingObject.getPinStatus,
currentStatus: false,
label: undefined,
visible: false,
iconPathOn: 'target',
iconPathOff: 'security',
rawRadius: 8,
targetRadius: 0,
currentRadius: 0,
angle: -135
},
{
action: 'Delete Open Stage',
actionFunction: payload.onMenuItemClick,
label: 'Delete This Stage',
visible: false,
iconPathOn: 'trash',
iconPathOff: 'trash',
rawRadius: 8,
targetRadius: 0,
currentRadius: 0,
angle: -20
},
{
action: 'Download',
actionFunction: payload.onMenuItemClick,
label: 'Download',
visible: false,
iconPathOn: 'upload',
iconPathOff: 'upload',
rawRadius: 8,
targetRadius: 0,
currentRadius: 0,
angle: 20
}]
break
}
case 'Manage Stage': {
menuItemsInitialValues = [
{
action: 'Pin / Unpin',
actionFunction: floatingObject.pinToggle,
actionStatus: floatingObject.getPinStatus,
currentStatus: false,
label: undefined,
visible: false,
iconPathOn: 'target',
iconPathOff: 'security',
rawRadius: 8,
targetRadius: 0,
currentRadius: 0,
angle: -135
},
{
action: 'Delete Manage Stage',
actionFunction: payload.onMenuItemClick,
label: 'Delete This Stage',
visible: false,
iconPathOn: 'trash',
iconPathOff: 'trash',
rawRadius: 8,
targetRadius: 0,
currentRadius: 0,
angle: -20
},
{
action: 'Download',
actionFunction: payload.onMenuItemClick,
label: 'Download',
visible: false,
iconPathOn: 'upload',
iconPathOff: 'upload',
rawRadius: 8,
targetRadius: 0,
currentRadius: 0,
angle: 20
}]
break
}
case 'Close Stage': {
menuItemsInitialValues = [
{
action: 'Pin / Unpin',
actionFunction: floatingObject.pinToggle,
actionStatus: floatingObject.getPinStatus,
currentStatus: false,
label: undefined,
visible: false,
iconPathOn: 'target',
iconPathOff: 'security',
rawRadius: 8,
targetRadius: 0,
currentRadius: 0,
angle: -135
},
{
action: 'Delete Close Stage',
actionFunction: payload.onMenuItemClick,
label: 'Delete This Stage',
visible: false,
iconPathOn: 'trash',
iconPathOff: 'trash',
rawRadius: 8,
targetRadius: 0,
currentRadius: 0,
angle: -20
},
{
action: 'Download',
actionFunction: payload.onMenuItemClick,
label: 'Download',
visible: false,
iconPathOn: 'upload',
iconPathOff: 'upload',
rawRadius: 8,
targetRadius: 0,
currentRadius: 0,
angle: 20
}]
break
}
case 'Trigger On Event': {
menuItemsInitialValues = [
{
@@ -315,6 +483,48 @@ function newStrategyPartConstructor () {
}]
break
}
case 'Initial Information': {
menuItemsInitialValues = [
{
action: 'Pin / Unpin',
actionFunction: floatingObject.pinToggle,
actionStatus: floatingObject.getPinStatus,
currentStatus: false,
label: undefined,
visible: false,
iconPathOn: 'target',
iconPathOff: 'security',
rawRadius: 8,
targetRadius: 0,
currentRadius: 0,
angle: -135
},
{
action: 'Delete Initial Information',
actionFunction: payload.onMenuItemClick,
label: 'Delete This Stage',
visible: false,
iconPathOn: 'trash',
iconPathOff: 'trash',
rawRadius: 8,
targetRadius: 0,
currentRadius: 0,
angle: -20
},
{
action: 'Download',
actionFunction: payload.onMenuItemClick,
label: 'Download',
visible: false,
iconPathOn: 'upload',
iconPathOff: 'upload',
rawRadius: 8,
targetRadius: 0,
currentRadius: 0,
angle: 20
}]
break
}
case 'Stop': {
menuItemsInitialValues = [
{
@@ -609,6 +819,22 @@ function newStrategyPartConstructor () {
level_1()
break
}
case 'Trigger Stage': {
level_1()
break
}
case 'Open Stage': {
level_1()
break
}
case 'Manage Stage': {
level_1()
break
}
case 'Close Stage': {
level_1()
break
}
case 'Trigger On Event': {
level_2()
break
@@ -621,7 +847,7 @@ function newStrategyPartConstructor () {
level_2()
break
}
case 'Trade Exit Event': {
case 'Initial Information': {
level_2()
break
}
FloatingSpace/StrategyPartTitle.js
+15
View File
@@ -56,6 +56,18 @@ function newStrategyPartTitle () {
thisObject.allwaysVisible = true
break
}
case 'Trigger Stage': {
break
}
case 'Open Stage': {
break
}
case 'Manage Stage': {
break
}
case 'Close Stage': {
break
}
case 'Trigger On Event': {
break
}
@@ -65,6 +77,9 @@ function newStrategyPartTitle () {
case 'Take Position Event': {
break
}
case 'Initial Information': {
break
}
case 'Stop': {
break
}
Spaces/StrategySpace.js
+5
View File
@@ -42,9 +42,14 @@ function newStrategySpace () {
const relationshipArray = [
['Trading System', 'analysis'],
['Strategy', 'quality'],
['Trigger Stage', 'chronometer'],
['Open Stage', 'photo-camera'],
['Manage Stage', 'video-player'],
['Close Stage', 'timeline'],
['Trigger On Event', 'startup'],
['Trigger Off Event', 'support'],
['Take Position Event', 'compass'],
['Initial Information', 'task'],
['Stop', 'pixel'],
['Take Profit', 'competition'],
['Phase', 'placeholder'],
StrategySpace/Workspace.js
+319 -41
View File
@@ -93,7 +93,7 @@ function newWorkspace () {
rootNodes: stringifyReadyNodes
}
let textToSave = JSON.stringify(workspace)
window.localStorage.setItem('workspace', textToSave)
// window.localStorage.setItem('workspace', textToSave)
}
function spawn (nodeText, point) {
@@ -167,6 +167,10 @@ function newWorkspace () {
}
return
}
case 'Initial Definition': {
createPart('Initial Definition', node.name, node, parentNode, chainParent, 'Initial Definition')
return
}
case 'Take Position Event': {
let event = node
createPart('Take Position Event', event.name, event, parentNode, chainParent, 'Take Position Event')
@@ -194,14 +198,62 @@ function newWorkspace () {
}
return
}
case 'Trigger Stage': {
let stage = node
createPart('Trigger Stage', stage.name, stage, parentNode, chainParent, 'Trigger Stage')
if (node.entryPoint !== undefined) {
createPartFromNode(node.entryPoint, stage, stage)
}
if (node.exitPoint !== undefined) {
createPartFromNode(node.exitPoint, stage, stage)
}
if (node.sellPoint !== undefined) {
createPartFromNode(node.sellPoint, stage, stage)
}
return
}
case 'Open Stage': {
let stage = node
createPart('Open Stage', stage.name, stage, parentNode, chainParent, 'Open Stage')
if (node.initialDefinition !== undefined) {
createPartFromNode(node.initialDefinition, stage, stage)
}
return
}
case 'Manage Stage': {
let stage = node
createPart('Manage Stage', stage.name, stage, parentNode, chainParent, 'Manage Stage')
if (node.stopLoss !== undefined) {
createPartFromNode(node.stopLoss, stage, stage)
}
if (node.buyOrder !== undefined) {
createPartFromNode(node.buyOrder, stage, stage)
}
return
}
case 'Close Stage': {
let stage = node
createPart('Close Stage', stage.name, stage, parentNode, chainParent, 'Close Stage')
return
}
case 'Strategy': {
let strategy = node
createPart('Strategy', strategy.name, strategy, parentNode, chainParent, 'Strategy')
createPartFromNode(node.entryPoint, strategy, strategy)
createPartFromNode(node.exitPoint, strategy, strategy)
createPartFromNode(node.sellPoint, strategy, strategy)
createPartFromNode(node.stopLoss, strategy, strategy)
createPartFromNode(node.buyOrder, strategy, strategy)
if (node.triggerStage !== undefined) {
createPartFromNode(node.triggerStage, strategy, strategy)
}
if (node.openStage !== undefined) {
createPartFromNode(node.openStage, strategy, strategy)
}
if (node.manageStage !== undefined) {
createPartFromNode(node.manageStage, strategy, strategy)
}
if (node.closeStage !== undefined) {
createPartFromNode(node.closeStage, strategy, strategy)
}
return
}
case 'Trading System': {
@@ -232,6 +284,18 @@ function newWorkspace () {
}
}
break
case 'Trigger Stage': {
return
}
case 'Open Stage': {
return
}
case 'Manage Stage': {
return
}
case 'Close Stage': {
return
}
case 'Trigger On Event': {
return
}
@@ -242,6 +306,9 @@ function newWorkspace () {
break
case 'Take Position Event': {
return
}
case 'Initial Definition': {
return
}
break
case 'Stop': {
@@ -562,30 +629,47 @@ function newWorkspace () {
let strategy = {
name: 'New Strategy',
active: true,
entryPoint: {
situations: []
triggerStage: {
entryPoint: {
situations: []
},
exitPoint: {
situations: []
},
sellPoint: {
situations: []
}
},
exitPoint: {
situations: []
openStage: {
initialDefinition: {}
},
sellPoint: {
situations: []
manageStage: {
stopLoss: {
phases: []
},
buyOrder: {
phases: []
}
},
stopLoss: {
phases: []
},
buyOrder: {
phases: []
closeStage: {
}
}
strategyParent.strategies.push(strategy)
createPart('Strategy', strategy.name, strategy, strategyParent, strategyParent, 'Strategy')
createPart('Trigger On Event', '', strategy.entryPoint, strategy, strategy)
createPart('Trigger Off Event', '', strategy.exitPoint, strategy, strategy)
createPart('Take Position Event', '', strategy.sellPoint, strategy, strategy)
createPart('Stop', '', strategy.stopLoss, strategy, strategy)
createPart('Take Profit', '', strategy.buyOrder, strategy, strategy)
createPart('Trigger Stage', '', strategy.triggerStage, strategy, strategy, 'Trigger Stage')
createPart('Open Stage', '', strategy.openStage, strategy, strategy, 'Open Stage')
createPart('Manage Stage', '', strategy.manageStage, strategy, strategy, 'Manage Stage')
createPart('Close Stage', '', strategy.closeStage, strategy, strategy, 'Close Stage')
createPart('Trigger On Event', '', strategy.triggerStage.entryPoint, strategy.triggerStage, strategy.triggerStage)
createPart('Trigger Off Event', '', strategy.triggerStage.exitPoint, strategy.triggerStage, strategy.triggerStage)
createPart('Take Position Event', '', strategy.triggerStage.sellPoint, strategy.triggerStage, strategy.triggerStage)
createPart('Initial Definition', '', strategy.openStage.initialDefinition, strategy.openStage, strategy.openStage)
createPart('Stop', '', strategy.manageStage.stopLoss, strategy.manageStage, strategy.manageStage)
createPart('Take Profit', '', strategy.manageStage.buyOrder, strategy.manageStage, strategy.manageStage)
}
break
case 'Add Phase':
@@ -635,6 +719,22 @@ function newWorkspace () {
deleteStrategy(payload.node)
break
}
case 'Delete Trigger Stage': {
deleteTriggerStage(payload.node)
break
}
case 'Delete Open Stage': {
deleteOpenStage(payload.node)
break
}
case 'Delete Manage Stage': {
deleteManageStage(payload.node)
break
}
case 'Delete Close Stage': {
deleteClose(payload.node)
break
}
case 'Delete Phase': {
deletePhase(payload.node)
break
@@ -658,29 +758,92 @@ function newWorkspace () {
for (let j = 0; j < payload.parentNode.strategies.length; j++) {
let strategy = payload.parentNode.strategies[j]
if (strategy.id === node.id) {
deleteEvent(strategy.entryPoint)
deleteEvent(strategy.exitPoint)
deleteEvent(strategy.sellPoint)
deleteManagedItem(strategy.stopLoss)
deleteManagedItem(strategy.buyOrder)
payload.parentNode.strategies.splice(j, 1)
destroyPart(strategy)
cleanNode(strategy)
return
}
}
} else {
deleteEvent(node.entryPoint)
deleteEvent(node.exitPoint)
deleteEvent(node.sellPoint)
deleteManagedItem(node.stopLoss)
deleteManagedItem(node.buyOrder)
destroyPart(node)
cleanNode(node)
}
deleteTriggerStage(node.triggerStage)
deleteOpenStage(node.openStage)
deleteManageStage(node.manageStage)
deleteCloseStage(node.closeStage)
destroyPart(node)
cleanNode(node)
}
function deleteTriggerStage (node) {
let payload = node.payload
if (payload.parentNode !== undefined) {
payload.parentNode.triggerStage = undefined
}
deleteEvent(node.entryPoint)
deleteEvent(node.exitPoint)
deleteEvent(node.sellPoint)
destroyPart(node)
cleanNode(node)
}
function deleteOpenStage (node) {
let payload = node.payload
if (payload.parentNode !== undefined) {
payload.parentNode.openStage = undefined
}
deleteInitialDefinition(node.initialDefinition)
destroyPart(node)
cleanNode(node)
}
function deleteManageStage (node) {
let payload = node.payload
if (payload.parentNode !== undefined) {
payload.parentNode.manageStage = undefined
}
deleteManagedItem(node.stopLoss)
deleteManagedItem(node.buyOrder)
destroyPart(node)
cleanNode(node)
}
function deleteCloseStage (node) {
let payload = node.payload
if (payload.parentNode !== undefined) {
payload.parentNode.closeStage = undefined
}
destroyPart(node)
cleanNode(node)
}
function deleteInitialDefinition (node) {
let payload = node.payload
if (payload.parentNode !== undefined) {
payload.parentNode.initialDefinition = undefined
}
destroyPart(node)
cleanNode(node)
}
function deleteEvent (node) {
let payload = node.payload
if (payload.parentNode !== undefined) {
switch (node.type) {
case 'Trigger On Event': {
payload.parentNode.entryPoint = undefined
break
}
case 'Trigger Off Event': {
payload.parentNode.exitPoint = undefined
break
}
case 'Take Position Event': {
payload.parentNode.sellPoint = undefined
break
}
}
}
while (node.situations.length > 0) {
deleteSituation(node.situations[0])
}
@@ -689,6 +852,20 @@ function newWorkspace () {
}
function deleteManagedItem (node) {
let payload = node.payload
if (payload.parentNode !== undefined) {
switch (node.type) {
case 'Stop Loss': {
payload.parentNode.stopLoss = undefined
break
}
case 'Take Profit': {
payload.parentNode.buyOrder = undefined
break
}
}
}
while (node.phases.length > 0) {
deletePhase(node.phases[0])
}
@@ -911,17 +1088,62 @@ function newWorkspace () {
}
return event
}
case 'Strategy': {
let strategy = {
case 'Initial Definition': {
let object = {
type: node.type,
subType: node.subType,
name: node.name
}
return object
}
case 'Trigger Stage': {
let stage = {
type: node.type,
subType: node.subType,
name: node.name,
entryPoint: getProtocolNode(node.entryPoint),
exitPoint: getProtocolNode(node.exitPoint),
sellPoint: getProtocolNode(node.sellPoint),
sellPoint: getProtocolNode(node.sellPoint)
}
return stage
}
case 'Open Stage': {
let stage = {
type: node.type,
subType: node.subType,
name: node.name,
initialDefinition: getProtocolNode(node.initialDefinition)
}
return stage
}
case 'Manage Stage': {
let stage = {
type: node.type,
subType: node.subType,
name: node.name,
stopLoss: getProtocolNode(node.stopLoss),
buyOrder: getProtocolNode(node.buyOrder)
}
return stage
}
case 'Close Stage': {
let stage = {
type: node.type,
subType: node.subType,
name: node.name
}
return stage
}
case 'Strategy': {
let strategy = {
type: node.type,
subType: node.subType,
name: node.name,
triggerStage: getProtocolNode(node.triggerStage),
openStage: getProtocolNode(node.openStage),
manageStage: getProtocolNode(node.manageStage),
closeStage: getProtocolNode(node.closeStage)
}
return strategy
}
case 'Trading System': {
@@ -1068,6 +1290,62 @@ function newWorkspace () {
}
return event
}
case 'Initial Definition': {
let object = {
id: node.id,
type: node.type,
subType: node.subType,
name: node.name,
savedPayload: getSavedPayload(node)
}
return object
}
case 'Trigger Stage': {
let stage = {
id: node.id,
type: node.type,
subType: node.subType,
name: node.name,
entryPoint: getWorkspaceNode(node.entryPoint),
exitPoint: getWorkspaceNode(node.exitPoint),
sellPoint: getWorkspaceNode(node.sellPoint),
savedPayload: getSavedPayload(node)
}
return stage
}
case 'Open Stage': {
let stage = {
id: node.id,
type: node.type,
subType: node.subType,
name: node.name,
initialDefinition: getWorkspaceNode(node.initialDefinition),
savedPayload: getSavedPayload(node)
}
return stage
}
case 'Manage Stage': {
let stage = {
id: node.id,
type: node.type,
subType: node.subType,
name: node.name,
stopLoss: getWorkspaceNode(node.stopLoss),
buyOrder: getWorkspaceNode(node.buyOrder),
savedPayload: getSavedPayload(node)
}
return stage
}
case 'Close Stage': {
let stage = {
id: node.id,
type: node.type,
subType: node.subType,
name: node.name,
savedPayload: getSavedPayload(node)
}
return stage
}
case 'Strategy': {
let strategy = {
id: node.id,