961 lines
46 KiB
JavaScript
961 lines
46 KiB
JavaScript
function newVisualScritingFunctionLibraryUiObjectsFromNodes() {
|
|
let thisObject = {
|
|
syncronizeTasksFoundAtWorkspaceWithBackEnd: syncronizeTasksFoundAtWorkspaceWithBackEnd,
|
|
syncronizeTradingSessionsFoundAtWorkspaceWithBackEnd: syncronizeTradingSessionsFoundAtWorkspaceWithBackEnd,
|
|
syncronizeLearningSessionsFoundAtWorkspaceWithBackEnd: syncronizeLearningSessionsFoundAtWorkspaceWithBackEnd,
|
|
playTutorials: playTutorials,
|
|
recreateWorkspace: recreateWorkspace,
|
|
getNodeById: getNodeById,
|
|
tryToConnectChildrenWithReferenceParents: tryToConnectChildrenWithReferenceParents,
|
|
createUiObjectFromNode: createUiObjectFromNode,
|
|
addUIObject: addUIObject,
|
|
addMissingChildren: addMissingChildren
|
|
}
|
|
|
|
let mapOfReferenceChildren = new Map()
|
|
let mapOfNodes
|
|
let tasksFoundAtWorkspace
|
|
let tradingSessionsFoundAtWorkspace
|
|
let learningSessionsFoundAtWorkspace
|
|
let tutorialsToPlay
|
|
|
|
return thisObject
|
|
|
|
function getNodeById(nodeId) {
|
|
return mapOfNodes.get(nodeId)
|
|
}
|
|
|
|
function recreateWorkspace(node, callBackFunction) {
|
|
mapOfNodes = new Map()
|
|
tasksFoundAtWorkspace = []
|
|
tradingSessionsFoundAtWorkspace = []
|
|
learningSessionsFoundAtWorkspace = []
|
|
tutorialsToPlay = []
|
|
|
|
/* Initializing the workspace config */
|
|
if (node.config === undefined || node.config === 'undefined') { node.config = '{}' }
|
|
|
|
removeNullRootNodes()
|
|
|
|
function removeNullRootNodes() {
|
|
for (let i = 0; i < node.rootNodes.length; i++) {
|
|
let rootNode = node.rootNodes[i]
|
|
if (rootNode === null) {
|
|
node.rootNodes.splice(i, 1)
|
|
removeNullRootNodes()
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
addPluginNodes()
|
|
|
|
function addPluginNodes(pluginNames) {
|
|
UI.projects.foundations.utilities.statusBar.changeStatus("Loading Plugins...")
|
|
|
|
let blobService = newFileStorage()
|
|
let totalPlugin = 0
|
|
let totalRead = 0
|
|
|
|
for (let i = 0; i < node.rootNodes.length; i++) {
|
|
let rootNode = node.rootNodes[i]
|
|
if (rootNode.type === 'Plugins') {
|
|
let plugins = rootNode
|
|
|
|
if (plugins.pluginProjects === undefined) { continue }
|
|
for (let j = 0; j < plugins.pluginProjects.length; j++) {
|
|
let project = plugins.pluginProjects[j]
|
|
/*
|
|
Miscellaneous Plugin Types
|
|
*/
|
|
if (project.pluginDataMines !== undefined) {
|
|
totalPlugin = totalPlugin + project.pluginDataMines.pluginFiles.length
|
|
pluginAllTheseFiles(project.pluginDataMines.pluginFiles, 'Data-Mines')
|
|
}
|
|
if (project.pluginTradingMines !== undefined) {
|
|
totalPlugin = totalPlugin + project.pluginTradingMines.pluginFiles.length
|
|
pluginAllTheseFiles(project.pluginTradingMines.pluginFiles, 'Trading-Mines')
|
|
}
|
|
if (project.pluginTradingSystems !== undefined) {
|
|
totalPlugin = totalPlugin + project.pluginTradingSystems.pluginFiles.length
|
|
pluginAllTheseFiles(project.pluginTradingSystems.pluginFiles, 'Trading-Systems')
|
|
}
|
|
if (project.pluginTradingEngines !== undefined) {
|
|
totalPlugin = totalPlugin + project.pluginTradingEngines.pluginFiles.length
|
|
pluginAllTheseFiles(project.pluginTradingEngines.pluginFiles, 'Trading-Engines')
|
|
}
|
|
if (project.pluginLearningMines !== undefined) {
|
|
totalPlugin = totalPlugin + project.pluginLearningMines.pluginFiles.length
|
|
pluginAllTheseFiles(project.pluginLearningMines.pluginFiles, 'Learning-Mines')
|
|
}
|
|
if (project.pluginLearningSystems !== undefined) {
|
|
totalPlugin = totalPlugin + project.pluginLearningSystems.pluginFiles.length
|
|
pluginAllTheseFiles(project.pluginLearningSystems.pluginFiles, 'Learning-Systems')
|
|
}
|
|
if (project.pluginLearningEngines !== undefined) {
|
|
totalPlugin = totalPlugin + project.pluginLearningEngines.pluginFiles.length
|
|
pluginAllTheseFiles(project.pluginLearningEngines.pluginFiles, 'Learning-Engines')
|
|
}
|
|
/*
|
|
Foundations Plugin Types
|
|
*/
|
|
if (project.pluginTutorials !== undefined) {
|
|
totalPlugin = totalPlugin + project.pluginTutorials.pluginFiles.length
|
|
pluginAllTheseFiles(project.pluginTutorials.pluginFiles, 'Tutorials')
|
|
}
|
|
if (project.pluginApiMaps !== undefined) {
|
|
totalPlugin = totalPlugin + project.pluginApiMaps.pluginFiles.length
|
|
pluginAllTheseFiles(project.pluginApiMaps.pluginFiles, 'API-Maps')
|
|
}
|
|
/*
|
|
Governance Plugin Types
|
|
*/
|
|
if (project.pluginUserProfiles !== undefined) {
|
|
totalPlugin = totalPlugin + project.pluginUserProfiles.pluginFiles.length
|
|
pluginAllTheseFiles(project.pluginUserProfiles.pluginFiles, 'User-Profiles')
|
|
}
|
|
if (project.pluginPools !== undefined) {
|
|
totalPlugin = totalPlugin + project.pluginPools.pluginFiles.length
|
|
pluginAllTheseFiles(project.pluginPools.pluginFiles, 'Pools')
|
|
}
|
|
if (project.pluginFeatures !== undefined) {
|
|
totalPlugin = totalPlugin + project.pluginFeatures.pluginFiles.length
|
|
pluginAllTheseFiles(project.pluginFeatures.pluginFiles, 'Features')
|
|
}
|
|
if (project.pluginAssets !== undefined) {
|
|
totalPlugin = totalPlugin + project.pluginAssets.pluginFiles.length
|
|
pluginAllTheseFiles(project.pluginAssets.pluginFiles, 'Assets')
|
|
}
|
|
if (project.pluginPositions !== undefined) {
|
|
totalPlugin = totalPlugin + project.pluginPositions.pluginFiles.length
|
|
pluginAllTheseFiles(project.pluginPositions.pluginFiles, 'Positions')
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
If there is no Plugins node at the workspace, we load it anyways here.
|
|
*/
|
|
if (totalPlugin === 0) {
|
|
addUserDefinedNodes()
|
|
}
|
|
|
|
function pluginAllTheseFiles(pluginFiles, pluginFolder) {
|
|
for (let i = 0; i < pluginFiles.length; i++) {
|
|
let pluginFile = pluginFiles[i]
|
|
let name = pluginFile.name
|
|
let folder = pluginFolder
|
|
let project = "Foundations"
|
|
try {
|
|
let config = JSON.parse(pluginFile.config)
|
|
if (config.project !== undefined) {
|
|
project = config.project
|
|
}
|
|
if (config.fileName !== undefined) {
|
|
name = config.fileName
|
|
}
|
|
if (config.folderName !== undefined) {
|
|
folder = config.folderName
|
|
}
|
|
} catch (err) { }
|
|
|
|
httpRequest(undefined, 'LoadPlugin' + '/' + project + '/' + folder + '/' + name + '.json', onFileReceived)
|
|
|
|
function onFileReceived(err, text, response) {
|
|
|
|
if (err && err.result !== GLOBAL.DEFAULT_OK_RESPONSE.result) {
|
|
console.log('[WARN] Cannot load plugin ' + pluginFolder + ' ' + name + '. The Workspace will be loaded with this plugin file missing.')
|
|
} else {
|
|
|
|
let receivedNode
|
|
|
|
try {
|
|
receivedNode = JSON.parse(text)
|
|
} catch (err) {
|
|
console.log('[ERROR] pluginAllTheseFiles -> Cannot load plugin ' + pluginFolder + ' ' + name + '. Received an invalid JSON object from the client.')
|
|
console.log('[ERROR] pluginAllTheseFiles -> text = ' + text)
|
|
console.log('[ERROR] pluginAllTheseFiles -> err.stack = ' + err.stack)
|
|
return
|
|
}
|
|
|
|
/*
|
|
If the workspace already contains a root node with the id of the head of the hierarchy
|
|
we are loading, we remove it because the plugin file has precedence.
|
|
*/
|
|
for (let i = 0; i < node.rootNodes.length; i++) {
|
|
let rootNode = node.rootNodes[i]
|
|
if (rootNode.id === receivedNode.id) {
|
|
console.log('[WARN] The node with name "' + rootNode.name + '" and type "' + rootNode.type + '" will be replaced by the node with name "' + receivedNode.name + '" and type "' + receivedNode.type + '" because they both have the same node.id')
|
|
node.rootNodes.splice(i, 1)
|
|
break
|
|
}
|
|
}
|
|
receivedNode.isPlugin = true
|
|
/*
|
|
We will force the Plugin codeName to the same to the fileName.
|
|
*/
|
|
let config
|
|
try {
|
|
config = JSON.parse(receivedNode.config)
|
|
} catch (err) {
|
|
config = {}
|
|
}
|
|
|
|
config.codeName = name
|
|
receivedNode.config = JSON.stringify(config)
|
|
|
|
if (pluginFile.pluginFilePosition !== undefined && receivedNode.savedPayload !== undefined) {
|
|
let positionOffset = {
|
|
x: pluginFile.pluginFilePosition.savedPayload.position.x - receivedNode.savedPayload.position.x,
|
|
y: pluginFile.pluginFilePosition.savedPayload.position.y - receivedNode.savedPayload.position.y
|
|
}
|
|
receivedNode.positionOffset = positionOffset
|
|
}
|
|
|
|
node.rootNodes.unshift(receivedNode)
|
|
}
|
|
|
|
totalRead++
|
|
if (totalPlugin === totalRead) {
|
|
addUserDefinedNodes()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function addUserDefinedNodes() {
|
|
/* Create the workspace UI OObject and then continue with the root nodes. */
|
|
createUiObject(false, 'Workspace', node.name, node, undefined, undefined, 'Workspace')
|
|
if (node.rootNodes !== undefined) {
|
|
UI.projects.foundations.utilities.statusBar.changeStatus("Setting up Rootnodes...")
|
|
|
|
let rootNode
|
|
let i = -1
|
|
controlLoop()
|
|
|
|
function loopBody() {
|
|
createUiObjectFromNode(rootNode, undefined, undefined)
|
|
controlLoop()
|
|
}
|
|
|
|
function controlLoop() {
|
|
i++
|
|
if (i < node.rootNodes.length) {
|
|
rootNode = node.rootNodes[i]
|
|
UI.projects.foundations.utilities.statusBar.changeStatus("Connecting children nodes from " + rootNode.name + " - " + rootNode.type + "...")
|
|
setTimeout(loopBody, 100)
|
|
} else {
|
|
UI.projects.foundations.utilities.statusBar.changeStatus("Finished connecting all nodes.")
|
|
setTimeout(endLoop, 100)
|
|
}
|
|
}
|
|
}
|
|
function endLoop() {
|
|
tryToConnectChildrenWithReferenceParents()
|
|
|
|
if (callBackFunction !== undefined) {
|
|
callBackFunction() // The recreation of the workspace is complete
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function syncronizeTasksFoundAtWorkspaceWithBackEnd() {
|
|
for (let i = 0; i < tasksFoundAtWorkspace.length; i++) {
|
|
let node = tasksFoundAtWorkspace[i]
|
|
UI.projects.foundations.functionLibraries.taskFunctions.syncronizeTaskWithBackEnd(node)
|
|
}
|
|
tasksFoundAtWorkspace = undefined
|
|
}
|
|
|
|
function syncronizeTradingSessionsFoundAtWorkspaceWithBackEnd() {
|
|
for (let i = 0; i < tradingSessionsFoundAtWorkspace.length; i++) {
|
|
let node = tradingSessionsFoundAtWorkspace[i]
|
|
UI.projects.algorithmicTrading.functionLibraries.tradingSessionFunctions.syncronizeSessionWithBackEnd(node)
|
|
}
|
|
tradingSessionsFoundAtWorkspace = undefined
|
|
}
|
|
|
|
function syncronizeLearningSessionsFoundAtWorkspaceWithBackEnd() {
|
|
for (let i = 0; i < learningSessionsFoundAtWorkspace.length; i++) {
|
|
let node = learningSessionsFoundAtWorkspace[i]
|
|
UI.projects.machineLearning.functionLibraries.learningSessionFunctions.syncronizeSessionWithBackEnd(node)
|
|
}
|
|
learningSessionsFoundAtWorkspace = undefined
|
|
}
|
|
|
|
function playTutorials() {
|
|
for (let i = 0; i < tutorialsToPlay.length; i++) {
|
|
let node = tutorialsToPlay[i]
|
|
node.payload.uiObject.menu.internalClick('Play Tutorial')
|
|
}
|
|
tutorialsToPlay = undefined
|
|
}
|
|
|
|
function tryToConnectChildrenWithReferenceParents() {
|
|
/* We reconstruct here the reference relationships. */
|
|
for (const [key, node] of mapOfNodes) {
|
|
|
|
if (node.payload === undefined) { continue }
|
|
|
|
if (node.payload.referenceParent !== undefined) {
|
|
if (node.payload.referenceParent.cleaned === true) {
|
|
node.payload.referenceParent = mapOfNodes.get(node.payload.referenceParent.id)
|
|
if (node.payload.referenceParent === undefined) {
|
|
//console.log('[WARN]' + node.type + ' ' + node.name + ' reference parent lost during re-binding phase.')
|
|
}
|
|
continue // We were referencing a deleted node, so we replace it potentially with a newly created one.
|
|
} else {
|
|
continue // In this case the reference is already good.
|
|
}
|
|
}
|
|
|
|
if (node.savedPayload !== undefined) {
|
|
if (node.savedPayload.referenceParent !== undefined) { // these are children recreated
|
|
// Reestablish based on Id
|
|
node.payload.referenceParent = mapOfNodes.get(node.savedPayload.referenceParent.id)
|
|
|
|
// if Reestablishment failed now reestablish reference based on saved path
|
|
if (node.payload.referenceParent === undefined) {
|
|
// Gather saved path
|
|
let rawPath = node.savedPayload.referenceParentCombinedNodePath
|
|
if (rawPath !== undefined) {
|
|
// Step down node hierarchy to find missing referenceParent
|
|
let pathNode
|
|
let pathName
|
|
let pathType
|
|
for (let i = 0; i < rawPath.length; i++) {
|
|
|
|
// Get Hierarchy head node
|
|
if (i === 0) {
|
|
pathName = rawPath[i][0]
|
|
pathType = rawPath[i][1]
|
|
pathNode = UI.projects.foundations.spaces.designSpace.workspace.getHierarchyHeadsByCodeNameAndNodeType(pathName, pathType)
|
|
|
|
// If reference parent is workspace node grab node
|
|
if (pathType === "Workspace") {
|
|
pathNode = UI.projects.foundations.spaces.designSpace.workspace.workspaceNode
|
|
}
|
|
// If Hierarchy Head is not located within the workspace abort reconnection
|
|
if (pathNode === undefined) {
|
|
// LUIS : console.log("[WARN] Abort reconnection saved path head node not found in current workspace", node)
|
|
// I removed this warning because at the Governance System is common to reference nodes that are not present at the workspace.
|
|
}
|
|
continue
|
|
} else { // Walk through children nodes and find the next node from saved path
|
|
if (pathNode !== undefined) { // LUIS: I added this check because it was blowing up further down the line. See why sometimes this is undefined.
|
|
pathName = rawPath[i][0]
|
|
pathType = rawPath[i][1]
|
|
pathNode = getNextNodeFromPath(pathNode, pathName, pathType)
|
|
}
|
|
}
|
|
}
|
|
if (pathNode !== undefined) {
|
|
UI.projects.visualScripting.functionLibraries.attachDetach.referenceAttachNode(node, pathNode)
|
|
} else {
|
|
//console.log("[WARN] ", node.name, ' ', node.type, "failed to fix reference. Unable to find reference parent ", pathName, ' ', pathType )
|
|
}
|
|
|
|
function getNextNodeFromPath(node, pathName, pathType) {
|
|
let schemaDocument = getSchemaDocument(node)
|
|
if (schemaDocument === undefined) { return }
|
|
let nextNode = undefined
|
|
for (let i = 0; i < schemaDocument.childrenNodesProperties.length; i++) {
|
|
|
|
let property = schemaDocument.childrenNodesProperties[i]
|
|
switch (property.type) {
|
|
// If child node is directly withing parent node look for it
|
|
case 'node': {
|
|
if (node[property.name] !== undefined) {
|
|
if (node[property.name].name === pathName && node[property.name].type === pathType) {
|
|
nextNode = node[property.name]
|
|
return nextNode
|
|
}
|
|
}
|
|
break
|
|
}
|
|
// If child node is in an array look for it
|
|
case 'array': {
|
|
if (node[property.name] !== undefined) {
|
|
let nodePropertyArray = node[property.name]
|
|
for (let m = 0; m < nodePropertyArray.length; m++) {
|
|
if (nodePropertyArray[m].name === pathName && nodePropertyArray[m].type === pathType) {
|
|
|
|
nextNode = nodePropertyArray[m]
|
|
return nextNode
|
|
}
|
|
}
|
|
}
|
|
break
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function migrateCodeToConfig(node, schemaDocument) {
|
|
/* Code needed to Migrate from Beta 5 to Beta a Workspace */
|
|
if (schemaDocument.editors !== undefined) {
|
|
if (schemaDocument.editors.config === true) {
|
|
if (node.code !== undefined) {
|
|
node.config = node.code
|
|
node.code = undefined
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function createUiObjectFromNode(node, parentNode, chainParent, positionOffset) {
|
|
|
|
/* Migration code from beta 10 to beta 11 */
|
|
if (
|
|
node.type === 'Tutorial' ||
|
|
node.type === 'Tutorial Topic' ||
|
|
node.type === 'Tutorial Step'
|
|
) {
|
|
node.project = "Education"
|
|
}
|
|
|
|
if (
|
|
node.project === undefined ||
|
|
node.project === 'Superalgos'
|
|
) {
|
|
node.project = 'Foundations'
|
|
}
|
|
/* Migration code from beta 11 to beta 12 */
|
|
if (
|
|
node.type === 'Network'
|
|
) {
|
|
node.type = "LAN Network"
|
|
if (node.lanNetworkNodes === undefined && node.networkNodes !== undefined) {
|
|
node.lanNetworkNodes = node.networkNodes
|
|
}
|
|
}
|
|
|
|
if (
|
|
node.type === 'Network Node'
|
|
) {
|
|
node.type = "LAN Network Node"
|
|
}
|
|
|
|
if (
|
|
node.type === 'Data Mine' ||
|
|
node.type === 'API Data Fetcher Bot' ||
|
|
node.type === 'Indicator Bot' ||
|
|
node.type === 'Sensor Bot'
|
|
) {
|
|
node.project = "Data-Mining"
|
|
}
|
|
|
|
if (
|
|
node.type === 'Trading Engine' ||
|
|
node.type === 'Trading Mine' ||
|
|
node.type === 'Trading System' ||
|
|
node.type === 'Trading Bot'
|
|
) {
|
|
node.project = "Algorithmic-Trading"
|
|
}
|
|
|
|
if (
|
|
node.type === 'Learning Engine' ||
|
|
node.type === 'Learning Mine' ||
|
|
node.type === 'Learning System' ||
|
|
node.type === 'Learning Bot'
|
|
) {
|
|
node.project = "Machine-Learning"
|
|
}
|
|
|
|
if (
|
|
node.type === 'Plugins' ||
|
|
node.type === 'Plugin Tutorials' ||
|
|
node.type === 'Plugin Trading Systems' ||
|
|
node.type === 'Plugin Trading Mines' ||
|
|
node.type === 'Plugin Trading Engines' ||
|
|
node.type === 'Plugin Project' ||
|
|
node.type === 'Plugin Learning Systems' ||
|
|
node.type === 'Plugin Learning Mines' ||
|
|
node.type === 'Plugin Learning Engines' ||
|
|
node.type === 'Plugin File' ||
|
|
node.type === 'Plugin File Position' ||
|
|
node.type === 'Plugin Data Mines' ||
|
|
node.type === 'Plugin API Maps'
|
|
) {
|
|
node.project = "Community-Plugins"
|
|
}
|
|
|
|
/*
|
|
This function can be called with a positionOffset to change the node
|
|
saved position and all of its descendants positions as well with an
|
|
offset. It can also happen that the positionOffset is defined as a property
|
|
of the node, in which case it will produce exactly the same effect.
|
|
*/
|
|
if (node.positionOffset !== undefined) {
|
|
positionOffset = node.positionOffset
|
|
}
|
|
|
|
|
|
/* Get schema document */
|
|
let schemaDocument = getSchemaDocument(node)
|
|
if (schemaDocument !== undefined) {
|
|
migrateCodeToConfig(node, schemaDocument)
|
|
|
|
/* Resolve Initial Values */
|
|
if (schemaDocument.initialValues !== undefined) {
|
|
if (schemaDocument.initialValues.code !== undefined) {
|
|
if (node.code === undefined) {
|
|
node.code = schemaDocument.initialValues.code
|
|
}
|
|
}
|
|
if (schemaDocument.initialValues.config !== undefined) {
|
|
if (node.config === undefined) {
|
|
node.config = schemaDocument.initialValues.config
|
|
}
|
|
}
|
|
}
|
|
|
|
/* For the cases where an node is not chained to its parent but to the one at the parent before it at its collection */
|
|
if (schemaDocument.chainedToSameType === true) {
|
|
if (parentNode !== undefined) {
|
|
let parentSchemaDocument = getSchemaDocument(parentNode)
|
|
if (parentSchemaDocument !== undefined) {
|
|
if (parentSchemaDocument.childrenNodesProperties !== undefined) {
|
|
for (let i = 0; i < parentSchemaDocument.childrenNodesProperties.length; i++) {
|
|
let property = parentSchemaDocument.childrenNodesProperties[i]
|
|
if (property.childType === node.type) {
|
|
if (property.type === 'array') {
|
|
if (parentNode[property.name] !== undefined) {
|
|
if (parentNode[property.name].length > 1) {
|
|
let nodeChildren = parentNode[property.name]
|
|
for (let j = 0; j < nodeChildren.length; j++) {
|
|
if (node.id === nodeChildren[j].id) {
|
|
if (j > 0) {
|
|
chainParent = nodeChildren[j - 1]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/* Create Self */
|
|
createUiObject(false, node.type, node.name, node, parentNode, chainParent, node.type, positionOffset)
|
|
|
|
/* Create Children */
|
|
if (schemaDocument.childrenNodesProperties !== undefined) {
|
|
let previousPropertyName // Since there are cases where there are many properties with the same name,because they can hold nodes of different types but only one at the time, we have to avoid counting each property of those as individual children.
|
|
for (let i = 0; i < schemaDocument.childrenNodesProperties.length; i++) {
|
|
let property = schemaDocument.childrenNodesProperties[i]
|
|
if (node[property.name] !== undefined) {
|
|
switch (property.type) {
|
|
case 'node': {
|
|
if (property.name !== previousPropertyName) {
|
|
createUiObjectFromNode(node[property.name], node, node, positionOffset)
|
|
previousPropertyName = property.name
|
|
}
|
|
}
|
|
break
|
|
case 'array': {
|
|
let nodePropertyArray = node[property.name]
|
|
for (let m = 0; m < nodePropertyArray.length; m++) {
|
|
let arrayItem = nodePropertyArray[m]
|
|
createUiObjectFromNode(arrayItem, node, node, positionOffset)
|
|
}
|
|
}
|
|
break
|
|
}
|
|
} else {
|
|
if (property.type === 'array') {
|
|
node[property.name] = []
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function addUIObject(parentNode, type, rootNodes, project) {
|
|
if (project === undefined) { project = parentNode.project }
|
|
|
|
let object = {
|
|
name: 'New ' + type,
|
|
type: type,
|
|
project: project
|
|
}
|
|
|
|
let parentSchemaDocument
|
|
/* Resolve Initial Values */
|
|
let schemaDocument = getSchemaDocument(object, project)
|
|
|
|
if (schemaDocument === undefined) {
|
|
schemaDocument = getSchemaDocument(object, 'Foundations') // TODO: This is provisional until all actions can have the relatedUiObject project explicitly set.
|
|
if (schemaDocument === undefined) {
|
|
console.log('Cannot addUIOBject of type "' + type + '" and project "' + project + '" because that type it is not defined at the APP_SCHEMA.')
|
|
return
|
|
}
|
|
}
|
|
|
|
if (schemaDocument.initialValues !== undefined) {
|
|
if (schemaDocument.initialValues.code !== undefined) {
|
|
object.code = schemaDocument.initialValues.code
|
|
}
|
|
}
|
|
if (schemaDocument.initialValues !== undefined) {
|
|
if (schemaDocument.initialValues.config !== undefined) {
|
|
object.config = schemaDocument.initialValues.config
|
|
}
|
|
}
|
|
|
|
let chainParent = parentNode
|
|
if (schemaDocument.isHierarchyHead === true || schemaDocument.isProjectHead) {
|
|
rootNodes.push(object)
|
|
initializeArrayProperties()
|
|
applyInitialValues()
|
|
createUiObject(true, object.type, object.name, object, parentNode, undefined)
|
|
autoAddChildren()
|
|
return object
|
|
|
|
} else {
|
|
|
|
parentSchemaDocument = getSchemaDocument(parentNode, parentNode.project)
|
|
if (parentSchemaDocument === undefined) {
|
|
console.log('Cannot addUIOBject from parent of type "' + type + '" and project "' + parentNode.project + '" because that type it is not defined at the APP_SCHEMA.')
|
|
return
|
|
}
|
|
checkChainToSelfTypeCollection()
|
|
initializeArrayProperties()
|
|
applyInitialValues()
|
|
connectToParent()
|
|
createUiObject(true, object.type, object.name, object, parentNode, chainParent)
|
|
autoAddChildren()
|
|
return object
|
|
}
|
|
|
|
function checkChainToSelfTypeCollection() {
|
|
/* For the cases where a node is not chained to its parent but to the one at the parent before it at its own collection */
|
|
|
|
if (schemaDocument.chainedToSameType === true) {
|
|
if (parentSchemaDocument.childrenNodesProperties !== undefined) {
|
|
for (let i = 0; i < parentSchemaDocument.childrenNodesProperties.length; i++) {
|
|
let property = parentSchemaDocument.childrenNodesProperties[i]
|
|
if (property.childType === type) {
|
|
if (property.type === 'array') {
|
|
if (parentNode[property.name] !== undefined) {
|
|
if (parentNode[property.name].length > 0) {
|
|
let nodeChildren = parentNode[property.name]
|
|
chainParent = nodeChildren[nodeChildren.length - 1]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function initializeArrayProperties() {
|
|
/* Create Empty Arrays for properties of type Array */
|
|
if (schemaDocument.childrenNodesProperties !== undefined) {
|
|
for (let i = 0; i < schemaDocument.childrenNodesProperties.length; i++) {
|
|
let property = schemaDocument.childrenNodesProperties[i]
|
|
if (property.type === 'array') {
|
|
object[property.name] = []
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function applyInitialValues() {
|
|
if (schemaDocument.initialValues !== undefined) {
|
|
if (schemaDocument.initialValues.code !== undefined) {
|
|
object.code = schemaDocument.initialValues.code
|
|
}
|
|
if (schemaDocument.initialValues.config !== undefined) {
|
|
object.config = schemaDocument.initialValues.config
|
|
}
|
|
}
|
|
}
|
|
|
|
function connectToParent() {
|
|
/* Connect to Parent */
|
|
if (parentSchemaDocument.childrenNodesProperties !== undefined) {
|
|
let previousPropertyName // Since there are cases where there are many properties with the same name,because they can hold nodes of different types but only one at the time, we have to avoid counting each property of those as individual children.
|
|
for (let i = 0; i < parentSchemaDocument.childrenNodesProperties.length; i++) {
|
|
let property = parentSchemaDocument.childrenNodesProperties[i]
|
|
if (property.childType === type) {
|
|
switch (property.type) {
|
|
case 'node': {
|
|
if (property.name !== previousPropertyName) {
|
|
parentNode[property.name] = object
|
|
previousPropertyName = property.name
|
|
}
|
|
}
|
|
break
|
|
case 'array': {
|
|
if (parentNode[property.name] === undefined) {
|
|
parentNode[property.name] = []
|
|
}
|
|
if (property.maxItems !== undefined) {
|
|
if (parentNode[property.name].length < property.maxItems) {
|
|
parentNode[property.name].push(object)
|
|
} else {
|
|
return // Object can not be created.
|
|
}
|
|
} else {
|
|
parentNode[property.name].push(object)
|
|
}
|
|
}
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function autoAddChildren() {
|
|
/* Auto Add more Children */
|
|
if (schemaDocument.childrenNodesProperties !== undefined) {
|
|
let previousPropertyName // Since there are cases where there are many properties with the same name,because they can hold nodes of different types but only one at the time, we have to avoid counting each property of those as individual children.
|
|
for (let i = 0; i < schemaDocument.childrenNodesProperties.length; i++) {
|
|
let property = schemaDocument.childrenNodesProperties[i]
|
|
|
|
switch (property.type) {
|
|
case 'node': {
|
|
if (property.name !== previousPropertyName) {
|
|
if (property.autoAdd === true) {
|
|
let project = property.project
|
|
addUIObject(object, property.childType, undefined, project)
|
|
previousPropertyName = property.name
|
|
}
|
|
}
|
|
}
|
|
break
|
|
case 'array': {
|
|
if (property.autoAdd === true) {
|
|
if (object[property.name] === undefined) {
|
|
object[property.name] = []
|
|
}
|
|
let project = property.project
|
|
addUIObject(object, property.childType, undefined, project)
|
|
}
|
|
}
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function addMissingChildren(node, rootNodes) {
|
|
let schemaDocument = getSchemaDocument(node)
|
|
|
|
/* Connect to Parent */
|
|
if (schemaDocument.childrenNodesProperties !== undefined) {
|
|
let previousPropertyName // Since there are cases where there are many properties with the same name,because they can hold nodes of different types but only one at the time, we have to avoid counting each property of those as individual children.
|
|
for (let i = 0; i < schemaDocument.childrenNodesProperties.length; i++) {
|
|
let property = schemaDocument.childrenNodesProperties[i]
|
|
if (property.type === 'node') {
|
|
if (property.name !== previousPropertyName) {
|
|
if (node[property.name] === undefined) {
|
|
let currenAngleToParent = node.payload.floatingObject.angleToParent
|
|
node.payload.floatingObject.angleToParent = ANGLE_TO_PARENT.RANGE_180
|
|
let uiObject = addUIObject(node, property.childType, rootNodes, property.project)
|
|
node.payload.floatingObject.angleToParent = currenAngleToParent
|
|
//uiObject.payload.floatingObject.angleToParent = currenAngleToParent
|
|
previousPropertyName = property.name
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function createUiObject(userAddingNew, uiObjectType, name, node, parentNode, chainParent, title, positionOffset) {
|
|
let payload = {}
|
|
|
|
/* Mechanism related to keeping references when cloning */
|
|
if (node.id === undefined) {
|
|
node.id = newUniqueId()
|
|
} else {
|
|
/*
|
|
We need to avoid nodes having the same id. If we add nodes to a workspace that already exist with the same Id,
|
|
the nodes being added will get a new id at this moment.
|
|
*/
|
|
let testNode = mapOfNodes.get(node.id)
|
|
if (testNode !== undefined && testNode.cleaned !== true) {
|
|
node.id = newUniqueId()
|
|
console.log(testNode.name + ' already have the id of the node ' + node.name + ' being added. Creating a new id for it: ' + node.id)
|
|
}
|
|
}
|
|
|
|
/* Default Naming */
|
|
if (name === '' || name === undefined) { name = 'My ' + uiObjectType }
|
|
|
|
/* If we are creating this object as the result of restoring a backup, share or clone, we will bring some of the saved properties to the new running instance. */
|
|
if (userAddingNew === false && uiObjectType !== 'Workspace') {
|
|
/* This following info can not be missing. */
|
|
if (node.savedPayload === undefined) {
|
|
console.log('Node ' + node.type + ' without savedPayload.', node)
|
|
return
|
|
}
|
|
if (node.savedPayload.position === undefined) {
|
|
console.log('Node ' + node.type + ' without savedPayload.position.', node)
|
|
return
|
|
}
|
|
if (node.savedPayload.targetPosition === undefined) {
|
|
console.log('Node ' + node.type + ' without savedPayload.targetPosition.', node)
|
|
return
|
|
}
|
|
|
|
/* If there is not a position offset, which happens when we are dropping a node into the designer, we create a zero vector then. */
|
|
if (positionOffset === undefined) {
|
|
positionOffset = {
|
|
x: 0,
|
|
y: 0
|
|
}
|
|
}
|
|
|
|
/* Adding the offset to the saved positions. */
|
|
node.savedPayload.targetPosition.x = node.savedPayload.targetPosition.x + positionOffset.x
|
|
node.savedPayload.targetPosition.y = node.savedPayload.targetPosition.y + positionOffset.y
|
|
node.savedPayload.position.x = node.savedPayload.position.x + positionOffset.x
|
|
node.savedPayload.position.y = node.savedPayload.position.y + positionOffset.y
|
|
|
|
/* Transferring the saved payload properties into the running instance being created. */
|
|
payload.targetPosition = {
|
|
x: node.savedPayload.targetPosition.x,
|
|
y: node.savedPayload.targetPosition.y
|
|
}
|
|
node.savedPayload.targetPosition = undefined
|
|
|
|
/* Reference children connection to parents */
|
|
if (node.savedPayload.referenceParent !== undefined) {
|
|
payload.referenceParent = mapOfNodes.get(node.savedPayload.referenceParent.id)
|
|
|
|
if (payload.referenceParent !== undefined) {
|
|
mapOfReferenceChildren.set(node.id, node)
|
|
}
|
|
}
|
|
}
|
|
|
|
/* If we are adding a new object, then we set the initial values for position and targetPosition */
|
|
if (userAddingNew === true || uiObjectType === 'Workspace') {
|
|
/* Workspace always to the spawn position */
|
|
if (uiObjectType === 'Workspace') {
|
|
payload.position = {
|
|
x: spawnPosition.x,
|
|
y: spawnPosition.y
|
|
}
|
|
}
|
|
|
|
/* Chain parent pointing to the position of the chain parent if defined. */
|
|
if (chainParent === undefined) {
|
|
if (parentNode !== undefined) {
|
|
payload.targetPosition = {
|
|
x: parentNode.payload.position.x,
|
|
y: parentNode.payload.position.y
|
|
}
|
|
} else {
|
|
payload.targetPosition = {
|
|
x: spawnPosition.x,
|
|
y: spawnPosition.y
|
|
}
|
|
}
|
|
} else {
|
|
payload.targetPosition = {
|
|
x: chainParent.payload.position.x,
|
|
y: chainParent.payload.position.y
|
|
}
|
|
}
|
|
}
|
|
|
|
payload.visible = true
|
|
payload.title = name
|
|
payload.node = node
|
|
payload.parentNode = parentNode
|
|
payload.chainParent = chainParent
|
|
payload.executeAction = UI.projects.foundations.spaces.designSpace.workspace.executeAction
|
|
|
|
node.payload = payload
|
|
node.type = uiObjectType
|
|
|
|
/*
|
|
Now we copy the possible frame saved to the payload where it can be used. A saved frame stores the position of a a chartingSpace object related to a node.
|
|
This will prevent that if those charting space objects never get activated, that the frame information is lost when the workspace is saved.
|
|
*/
|
|
if (node.savedPayload !== undefined) {
|
|
if (node.savedPayload.frame !== undefined) {
|
|
let frame = {
|
|
position: {
|
|
x: 0,
|
|
y: 0
|
|
}
|
|
}
|
|
frame.position.x = node.savedPayload.frame.position.x
|
|
frame.position.y = node.savedPayload.frame.position.y
|
|
frame.width = node.savedPayload.frame.width
|
|
frame.height = node.savedPayload.frame.height
|
|
frame.radius = node.savedPayload.frame.radius
|
|
UI.projects.visualScripting.utilities.loadSaveFrame.saveFrame(payload, frame)
|
|
}
|
|
if (node.savedPayload.tutorial !== undefined) {
|
|
let tutorial = {
|
|
status: node.savedPayload.tutorial.status
|
|
}
|
|
UI.projects.foundations.utilities.tutorial.saveTutorial(payload, tutorial)
|
|
}
|
|
}
|
|
|
|
/* Now we mount the floating object where the UIOBject will be laying on top of */
|
|
UI.projects.foundations.spaces.floatingSpace.uiObjectConstructor.createUiObject(userAddingNew, payload)
|
|
|
|
/* This is the point where we build a map with all nodes present at the workspace */
|
|
mapOfNodes.set(node.id, node)
|
|
|
|
/* We will collect all tasks at the workspace in order to later synchronize them with the client */
|
|
if (userAddingNew === false && uiObjectType === 'Task' && node.savedPayload !== undefined) {
|
|
if (tasksFoundAtWorkspace !== undefined) { // it might be undefined when you are spawning a task that was backed up
|
|
tasksFoundAtWorkspace.push(node)
|
|
}
|
|
}
|
|
|
|
/* Check if there are sessions to run */
|
|
if (userAddingNew === false && node.savedPayload !== undefined) {
|
|
if (uiObjectType === 'Live Trading Session' || uiObjectType === 'Forward Testing Session' || uiObjectType === 'Backtesting Session' || uiObjectType === 'Paper Trading Session') {
|
|
if (tradingSessionsFoundAtWorkspace !== undefined) { // it might be undefined when you are spawning a session that was running while backed up
|
|
tradingSessionsFoundAtWorkspace.push(node)
|
|
}
|
|
}
|
|
if (uiObjectType === 'Learning Session') {
|
|
if (learningSessionsFoundAtWorkspace !== undefined) { // it might be undefined when you are spawning a session that was running while backed up
|
|
learningSessionsFoundAtWorkspace.push(node)
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Check if there are tutorials to play */
|
|
if (userAddingNew === false && node.savedPayload !== undefined) {
|
|
if (uiObjectType === 'Tutorial') {
|
|
if (node.savedPayload.uiObject.isPlaying === true) {
|
|
if (tutorialsToPlay !== undefined) { // it might be undefined when you are spawning a tutorial that was playing while backed up
|
|
tutorialsToPlay.push(node)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|