function installInDataTasks(lanNetworkNode) {
                    let dataTasks = UI.projects.visualScripting.utilities.branches.findInBranch(lanNetworkNode, 'Data Tasks', product, true)

                    // Install in each existing Project Data Task
                    for (let j = 0; j < dataTasks.projectDataTasks.length; j++) {
                        let projectDataTask = dataTasks.projectDataTasks[j]

                        // Install in each existing Exchange
                        for (let k = 0; k < projectDataTask.exchangeDataTasks.length; k++) {
                            let exchangeDataTask = projectDataTask.exchangeDataTasks[k]

                            // Install in each existing Market Data
                            for (let l = 0; l < exchangeDataTask.marketDataTasks.length; l++) {
                                let marketDataTask = exchangeDataTask.marketDataTasks[l]

                                // If Data Mine is not installed we are going to create it, otherwise we use the existing one
                                let dataMineDependency = UI.projects.visualScripting.utilities.nodeChildren.findOrCreateChildWithReference(marketDataTask, 'Data Mine Tasks', productDataMineParent)

                                if (dataMineDependency.taskManagers.length > 0) {
                                    //We will add the task and indicator bot into first task manager we find
                                    let task = ceateTaskIfNotPresent(dataMineDependency.taskManagers[0])

                                    switch(productParentBot.type) {
                                        case 'Indicator Bot': {
                                            let indicatorBot = createIndicatorBotIfNotPresent(task)
                                            createIndicatorProcessInstanceIfNotPresent(indicatorBot)
                                            break
                                        }
                                        case 'API Data Fetcher Bot': {
                                            let apiFetcherBot = createApiBotIfNotPresent(task)
                                            createApiProcessInstanceIfNotPresent(apiFetcherBot)
                                            break
                                        }
                                        case 'Study Bot': {
                                            let studyBot = createStudyBotIfNotPresent(task)
                                            createStudyProcessInstanceIfNotPresent(studyBot)
                                            break
                                        }
                                    }

                                } else {
                                    //Let's create a new task manager as none exists
                                    let newTaskManager = UI.projects.visualScripting.nodeActionFunctions.uiObjectsFromNodes.addUIObject(dataMineDependency, 'Task Manager')
                                    newTaskManager.name = productDataMineParent.name

                                    switch(productParentBot.type) {
                                        case 'Indicator Bot': {
                                            let task = ceateTaskIfNotPresent(newTaskManager)
                                            let indicatorBot = createIndicatorBotIfNotPresent(task)        
                                            createIndicatorProcessInstanceIfNotPresent(indicatorBot)
                                            break
                                        }
                                        case 'API Data Fetcher Bot': {
                                            let task = ceateTaskIfNotPresent(newTaskManager)
                                            let apiFetcherBot = createApiBotIfNotPresent(task)
                                            createApiProcessInstanceIfNotPresent(apiFetcherBot)
                                            break
                                        }
                                        case 'Study Bot': {
                                            let task = ceateTaskIfNotPresent(newTaskManager)
                                            let studyBot = createStudyBotIfNotPresent(task)        
                                            createStudyProcessInstanceIfNotPresent(studyBot)
                                            break
                                        }
                                    }
                                }
                            }
                        }
                    }

                    function ceateTaskIfNotPresent(taskManager) {
                        let task = UI.projects.visualScripting.utilities.meshes.findNodeInNodeMesh(taskManager, undefined, productParentBot.name, false, true, false, false)
                        if (task === undefined) {
                            let newTask = UI.projects.visualScripting.nodeActionFunctions.uiObjectsFromNodes.addUIObject(taskManager, 'Task')
                            newTask.name = productParentBot.name

                            return newTask
                        }
                        return task;
                    }

                    function createIndicatorBotIfNotPresent(task) {
                        let botInstance = UI.projects.visualScripting.utilities.meshes.findNodeInNodeMesh(task, 'Indicator Bot Instance', undefined, false, true, false, false)
                        if (botInstance === undefined) {
                            let newBotInstance = UI.projects.visualScripting.nodeActionFunctions.uiObjectsFromNodes.addUIObject(task, 'Indicator Bot Instance')
                            newBotInstance.name = productParentBot.name

                            return newBotInstance
                        }
                        return botInstance
                    }

                    function createIndicatorProcessInstanceIfNotPresent(indicatorBot) {
                        for (let m = 0; m < productParentBot.processes.length; m++) {
                            let processDefinition = productParentBot.processes[m]
                            UI.projects.visualScripting.utilities.nodeChildren.findOrCreateChildWithReference(indicatorBot, 'Indicator Process Instance', processDefinition)
                        }
                    }
                    
                    function createApiBotIfNotPresent(task) {
                        let botInstance = UI.projects.visualScripting.utilities.meshes.findNodeInNodeMesh(task, 'API Data Fetcher Bot Instance', undefined, false, true, false, false)
                        if (botInstance === undefined) {
                            let newBotInstance = UI.projects.visualScripting.nodeActionFunctions.uiObjectsFromNodes.addUIObject(task, 'API Data Fetcher Bot Instance')
                            newBotInstance.name = productParentBot.name

                            return newBotInstance
                        }
                        return botInstance
                    }

                    function createApiProcessInstanceIfNotPresent(apiBot) {
                        for (let m = 0; m < productParentBot.processes.length; m++) {
                            let processDefinition = productParentBot.processes[m]
                            let processInstance = UI.projects.visualScripting.utilities.nodeChildren.findOrCreateChildWithReference(apiBot, 'API Data Fetcher Process Instance', processDefinition)
                            console.log('this is the product parent bot', productParentBot)

                            // Attach reference to API Map
                            for (let i = 0; i < rootNodes.length; i++) {
                                if (rootNodes[i].type === 'API Map' && rootNodes[i].name === productParentBot.payload.chainParent.name) {
                                    UI.projects.visualScripting.nodeActionFunctions.attachDetach.referenceAttachNode(processInstance.payload.node.apiMapReference, rootNodes[i])
                                }
                            }
                        }
                    }

                    function createStudyBotIfNotPresent(task) {
                        let botInstance = UI.projects.visualScripting.utilities.meshes.findNodeInNodeMesh(task, 'Study Bot Instance', undefined, false, true, false, false)
                        if (botInstance === undefined) {
                            let newBotInstance = UI.projects.visualScripting.nodeActionFunctions.uiObjectsFromNodes.addUIObject(task, 'Study Bot Instance')
                            newBotInstance.name = productParentBot.name

                            return newBotInstance
                        }
                        return botInstance
                    }

                    function createStudyProcessInstanceIfNotPresent(studyBot) {
                        for (let m = 0; m < productParentBot.processes.length; m++) {
                            let processDefinition = productParentBot.processes[m]
                            UI.projects.visualScripting.utilities.nodeChildren.findOrCreateChildWithReference(studyBot, 'Study Process Instance', processDefinition)
                        }
                    }

                }
We will add data mine tasks of the product only to existing Market Data Tasks
If no Market Data Tasks are available, product task will not be installed into this branch
Market Data can be installed by using Install Market script.