@magic-xpa/engine 4.1100.0-dev4110.98 → 4.1100.0

package/esm2022/src/tasks/MGData.mjs

@@ -0,0 +1,552 @@
+import { HandlersTable } from "../rt/HandlersTable";
+import { TasksTable } from "./TasksTable";
+import { CompMainPrgTable } from "../rt/CompMainPrgTable";
+import { Task } from "./Task";
+import { Logger, XMLConstants, XmlParser } from "@magic-xpa/utils";
+import { RecomputeTable } from "../rt/RecomputeTable";
+import { Debug, NNumber } from "@magic-xpa/mscorelib";
+import { RuntimeContextBase } from "@magic-xpa/gui";
+import { GUIManager } from "../GUIManager";
+import { HttpManager } from "../http/HttpManager";
+import { FlowMonitorQueue } from "../util/FlowMonitorQueue";
+import { RunTimeEvent } from "../event/RunTimeEvent";
+import { ConstInterface } from "../ConstInterface";
+import { LanguageData } from "../env/LanguageData";
+import { EnvParamsTable } from "../env/EnvVariablesTable";
+import { GlobalParams } from "../exp/GlobalParamsTable";
+import { Environment } from "../env/Environment";
+import { GlobalCommandsManager } from "../GlobalCommandsManager";
+import { ServerConfig } from "../ServerConfig";
+import { AccessHelper } from "../AccessHelper";
+import { UserDetails } from "../security/UserDetails";
+import { RemoteCommandsProcessor } from "../remote/RemoteCommandsProcessor";
+export class MGData {
+    _expHandlers = null;
+    _id = 0;
+    _parent = null;
+    _mprgTab = null;
+    _tasksTab = null;
+    _timerHandlers = null;
+    _timersStarted = false;
+    forceModal = false;
+    CmdsToClient = null;
+    CmdsToServer = null;
+    IsModal = false;
+    IsAborting = false;
+    get ForceModal() {
+        return this.forceModal;
+    }
+    constructor(toClient, toServer, id, parent, isModal, forceModal) {
+        this.CmdsToServer = toClient;
+        this.CmdsToClient = toServer;
+        if (arguments.length === 5)
+            this.constructor_0(id, parent, isModal);
+        else
+            this.constructor_1(id, parent, isModal, forceModal);
+    }
+    constructor_0(id, parent, isModal) {
+        this._timerHandlers = new HandlersTable();
+        this._expHandlers = new HandlersTable();
+        this._mprgTab = new TasksTable();
+        this._tasksTab = new TasksTable();
+        this._id = id;
+        this._parent = parent;
+        if (AccessHelper.eventsManager.getCompMainPrgTab() === null) {
+            let compMainPrgTab = new CompMainPrgTable();
+            AccessHelper.eventsManager.setCompMainPrgTab(compMainPrgTab);
+        }
+        this.IsModal = isModal;
+    }
+    constructor_1(id, parent, isModal, forceModal) {
+        this.constructor_0(id, parent, isModal);
+        this.forceModal = forceModal;
+    }
+    GetId() {
+        return this._id;
+    }
+    AlreadyMovedToFirstControl() {
+        let alreadyMoved = false;
+        let tasksCount = this.getTasksCount();
+        for (let i = 0; i < tasksCount; i = i + 1) {
+            let mgForm = this.getTask(i).getForm();
+            if (mgForm !== null && mgForm.MovedToFirstControl) {
+                alreadyMoved = true;
+                break;
+            }
+        }
+        return alreadyMoved;
+    }
+    StartTimers() {
+        if (this._timerHandlers !== null && !this._timersStarted) {
+            this._timerHandlers.startTimers(this);
+            this._timersStarted = true;
+        }
+    }
+    async fillData(openingTaskDetails, parser) {
+        let canContinue;
+        do {
+            let nextTag = parser.getNextTag();
+            canContinue = await this.initInnerObjects(parser, nextTag, openingTaskDetails);
+        } while (canContinue);
+        Logger.Instance.WriteDevToLog("MGData.FillData(): THE END of the parsing " + parser.getCurrIndex() + " characters");
+    }
+    async initInnerObjects(parser, foundTagName, openingTaskDetails) {
+        if (foundTagName == null)
+            return false;
+        switch (foundTagName) {
+            case XMLConstants.MG_TAG_XML:
+                parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);
+                break;
+            case ConstInterface.MG_TAG_DATAVIEW:
+                if (!await this.insertDataView(parser)) {
+                    let endContext = parser.getXMLdata().indexOf('/' + ConstInterface.MG_TAG_DATAVIEW, parser.getCurrIndex());
+                    parser.setCurrIndex(endContext);
+                    parser.setCurrIndex2EndOfTag();
+                }
+                break;
+            case ConstInterface.MG_TAG_COMPLETE_DV:
+                {
+                    let task = null;
+                    let endContext = parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex());
+                    let index = parser.getXMLdata().indexOf(ConstInterface.MG_TAG_COMPLETE_DV, parser.getCurrIndex()) + ConstInterface.MG_TAG_COMPLETE_DV.length;
+                    let tokensVector = XmlParser.getTokens(parser.getXMLdata().substr(index, endContext - index), '"');
+                    let attribute = (tokensVector.get_Item(0));
+                    let valueStr;
+                    if (attribute === XMLConstants.MG_ATTR_TASKID) {
+                        valueStr = (tokensVector.get_Item(1));
+                        let taskId = valueStr;
+                        if (this.getTask(taskId) === null)
+                            task = AccessHelper.mgDataTable.GetTaskByID(taskId);
+                        else
+                            task = this.getTask(taskId);
+                    }
+                    let start = endContext + 1;
+                    endContext = parser.getXMLdata().indexOf(XMLConstants.END_TAG + ConstInterface.MG_TAG_COMPLETE_DV, parser.getCurrIndex());
+                    let dataViewContent = parser.getXMLdata().substr(start, endContext - start);
+                    task.dataViewContent = dataViewContent;
+                    parser.setCurrIndex(endContext);
+                    parser.setCurrIndex2EndOfTag();
+                }
+                break;
+            case ConstInterface.MG_TAG_CONTEXT: {
+                let endContext = parser.getXMLdata().indexOf(XMLConstants.TAG_TERM, parser.getCurrIndex());
+                if (endContext !== -1 && endContext < parser.getXMLdata().length) {
+                    let tag = parser.getXMLsubstring(endContext);
+                    parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_CONTEXT) + ConstInterface.MG_TAG_CONTEXT.length);
+                    parser.setCurrIndex(endContext + XMLConstants.TAG_TERM.length);
+                }
+                break;
+            }
+            case XMLConstants.MG_TAG_RECOMPUTE:
+                let recompTab = new RecomputeTable();
+                recompTab.fillData(parser);
+                break;
+            case ConstInterface.MG_TAG_COMMAND:
+                Logger.Instance.WriteDevToLog("goes to command");
+                this.CmdsToClient.fillData(parser);
+                break;
+            case ConstInterface.MG_TAG_LANGUAGE:
+                Logger.Instance.WriteDevToLog("goes to language data");
+                await LanguageData.Instance.fillData(parser);
+                break;
+            case ConstInterface.MG_TAG_KBDMAP_URL:
+                Logger.Instance.WriteDevToLog("goes to keyBoard");
+                await Environment.Instance.fillFromUrl(foundTagName, parser);
+                break;
+            case ConstInterface.MG_TAG_KBDMAP:
+                break;
+            case ConstInterface.MG_TAG_COMPMAINPRG:
+                Logger.Instance.WriteDevToLog("goes to compmainprg");
+                AccessHelper.eventsManager.getCompMainPrgTab().fillData(parser);
+                break;
+            case ConstInterface.MG_TAG_EVENTS_QUEUE:
+                Logger.Instance.WriteDevToLog("goes to eventsqueue");
+                this.fillEventsQueue(parser);
+                break;
+            case ConstInterface.MG_TAG_TASKURL:
+                await Task.ProcessTaskURL();
+                break;
+            case XMLConstants.MG_TAG_TASK:
+                Logger.Instance.WriteDevToLog("goes to task");
+                let taskCountBefore = this._mprgTab.getSize();
+                await this._mprgTab.fillData(this, openingTaskDetails, parser);
+                if (this._id !== 0) {
+                    let taskCountAfter = this._mprgTab.getSize();
+                    let mgd0 = AccessHelper.mgDataTable.getMGData(0);
+                    for (let taskIndex = taskCountBefore; taskIndex < taskCountAfter; taskIndex++) {
+                        let newTask = this._mprgTab.getTask(taskIndex);
+                        if (newTask.isMainProg() && mgd0._mprgTab.getTask(newTask.getTaskTag()) == null) {
+                            mgd0._mprgTab.addTask(newTask);
+                            mgd0.addTask(newTask);
+                        }
+                    }
+                }
+                break;
+            case ConstInterface.MG_TAG_ENV:
+                Logger.Instance.WriteDevToLog("goes to environment");
+                Environment.Instance.fillData(parser);
+                break;
+            case ConstInterface.MG_TAG_FLWMTR_CONFIG:
+                FlowMonitorQueue.Instance.fillData(parser);
+                break;
+            case XMLConstants.MG_TAG_XML_END:
+                parser.setCurrIndex2EndOfTag();
+                return false;
+            case ConstInterface.MG_TAG_USER_DETAILS:
+                UserDetails.Instance.fillData(parser);
+                break;
+            case ConstInterface.MG_TAG_DBH_REAL_IDXS:
+                parser.SkipXMLElement();
+                break;
+            case ConstInterface.MG_TAG_GLOBALPARAMSCHANGES:
+                Logger.Instance.WriteDevToLog("applying global params changes from the server (Set/GetParams)");
+                GlobalParams.Instance.fillData(parser);
+                break;
+            case ConstInterface.MG_TAG_GLOBALPARAMS:
+                Logger.Instance.WriteDevToLog("processing base64 encoded image of all global params from the server");
+                this.fillGlobalParams(parser);
+                break;
+            case ConstInterface.MG_TAG_ENV_PARAM_URL:
+                Logger.Instance.WriteDevToLog("goes to env params name ");
+                await Environment.Instance.fillFromUrl(foundTagName, parser);
+                break;
+            case ConstInterface.MG_TAG_ENV_PARAM:
+                Logger.Instance.WriteDevToLog("goes to env params name ");
+                EnvParamsTable.Instance.fillData(parser);
+                break;
+            case ConstInterface.MG_TAG_CONTEXT_ID:
+                {
+                    let ctxId;
+                    let ctxEndIdx;
+                    parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);
+                    ctxEndIdx = parser.getXMLdata().indexOf(XMLConstants.TAG_OPEN, parser.getCurrIndex());
+                    ctxId = parser.getXMLsubstring(ctxEndIdx).trim();
+                    parser.setCurrIndex(ctxEndIdx);
+                    parser.setCurrIndex2EndOfTag();
+                    RuntimeContextBase.Instance.ContextID = ctxId;
+                }
+                break;
+            case ConstInterface.MG_TAG_SESSION_ID:
+                let sessionIdEndIdx;
+                parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);
+                sessionIdEndIdx = parser.getXMLdata().indexOf(XMLConstants.TAG_OPEN, parser.getCurrIndex());
+                RemoteCommandsProcessor.GetInstance().SessionId = parser.getXMLsubstring(sessionIdEndIdx).trim();
+                parser.setCurrIndex(sessionIdEndIdx);
+                parser.setCurrIndex2EndOfTag();
+                break;
+            case ConstInterface.MG_TAG_HTTP_COMMUNICATION_TIMEOUT:
+                {
+                    let httpCommunicationTimeout;
+                    let httpCommunicationTimeoutIdx;
+                    parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);
+                    httpCommunicationTimeoutIdx = parser.getXMLdata().indexOf(XMLConstants.TAG_OPEN, parser.getCurrIndex());
+                    httpCommunicationTimeout = NNumber.Parse(parser.getXMLsubstring(httpCommunicationTimeoutIdx));
+                    parser.setCurrIndex(httpCommunicationTimeoutIdx);
+                    parser.setCurrIndex2EndOfTag();
+                    HttpManager.GetInstance().HttpCommunicationTimeoutMS = httpCommunicationTimeout * 1000;
+                }
+                break;
+            case ConstInterface.MG_TAG_DATABASE_URL:
+            case ConstInterface.MG_TAG_DATABASES_HEADER:
+            case ConstInterface.MG_TAG_TASKDEFINITION_IDS_URL:
+            case ConstInterface.MG_TAG_DBH_DATA_IDS_URL:
+            case ConstInterface.MG_TAG_DBHS_END:
+            case ConstInterface.MG_TAG_OFFLINE_SNIPPETS_URL:
+                parser.SkipXMLElement();
+                break;
+            case ConstInterface.MG_TAG_DBHS:
+            case ConstInterface.MG_TAG_STARTUP_PROGRAM:
+                parser.ReadContentOfCurrentElement();
+                break;
+            case XMLConstants.MG_TAG_MENUS_OPEN:
+                break;
+            default:
+                Logger.Instance.WriteExceptionToLogWithMsg("There is no such tag name in MGData, add case to MGData.initInnerObjects and case to while of MGData.FillData  " + foundTagName);
+                return false;
+        }
+        return true;
+    }
+    async insertDataView(parser) {
+        let task = null;
+        let endContext = parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex());
+        let index = parser.getXMLdata().indexOf(ConstInterface.MG_TAG_DATAVIEW, parser.getCurrIndex()) + ConstInterface.MG_TAG_DATAVIEW.length;
+        let tokensVector = XmlParser.getTokens(parser.getXMLdata().substr(index, endContext - index), '"');
+        let invalidate = false;
+        for (let i = 0; i < tokensVector.length; i = i + 2) {
+            let attribute = tokensVector.get_Item(i);
+            if (attribute === XMLConstants.MG_ATTR_TASKID) {
+                let valueStr = tokensVector.get_Item(i + 1);
+                let taskId = valueStr;
+                task = (this.getTask(taskId) || AccessHelper.mgDataTable.GetTaskByID(taskId));
+            }
+            if (attribute === ConstInterface.MG_ATTR_INVALIDATE) {
+                let valueStr = tokensVector.get_Item(i + 1);
+                invalidate = XmlParser.getBoolean(valueStr);
+                break;
+            }
+        }
+        let result;
+        if (task !== null) {
+            await task.insertRecordTable(invalidate, parser);
+            result = true;
+        }
+        else {
+            result = false;
+        }
+        return result;
+    }
+    addTask(newTask) {
+        this._tasksTab.addTask(newTask);
+    }
+    removeTask(task) {
+        this._tasksTab.removeTask(task);
+        this._mprgTab.removeTask(task);
+    }
+    getTasksCount() {
+        let result;
+        if (this._tasksTab !== null) {
+            result = this._tasksTab.getSize();
+        }
+        else {
+            result = 0;
+        }
+        return result;
+    }
+    getTask(taskIdOrIdx) {
+        if (arguments.length === 1 && (taskIdOrIdx === null || typeof taskIdOrIdx === "undefined" || taskIdOrIdx.constructor === String)) {
+            return this.getTask_0(taskIdOrIdx);
+        }
+        return this.getTask_1(taskIdOrIdx);
+    }
+    getTask_0(taskId) {
+        let result;
+        if (this._tasksTab !== null && typeof this._tasksTab !== "undefined") {
+            result = this._tasksTab.getTask(taskId);
+        }
+        else {
+            result = null;
+        }
+        return result;
+    }
+    getTask_1(idx) {
+        return this._tasksTab.getTask(idx);
+    }
+    async buildXML(message, serializeTasks) {
+        if (this.CmdsToServer !== null) {
+            this.CmdsToServer.buildXML(message);
+        }
+        if (serializeTasks && this._tasksTab !== null) {
+            await this._tasksTab.buildXML(message);
+        }
+    }
+    getFirstTask() {
+        let task = null;
+        let MDIFrameTask = null;
+        for (let i = 0; i < this._tasksTab.getSize(); i = i + 1) {
+            task = this._tasksTab.getTask(i);
+            if (!task.isMainProg()) {
+                break;
+            }
+            task = null;
+        }
+        if (task === null && this._id === 0) {
+            task = MDIFrameTask;
+        }
+        return task;
+    }
+    getMainProg(ctlIdx) {
+        for (let i = 0; i < this._mprgTab.getSize(); i = i + 1) {
+            let task = this._mprgTab.getTask(i);
+            if (task.getCtlIdx() === ctlIdx && task.isMainProg()) {
+                return task;
+            }
+        }
+        return null;
+    }
+    getNextMainProg(ctlIdx) {
+        let compMainPrgTab = AccessHelper.eventsManager.getCompMainPrgTab();
+        let currSearchIndex = compMainPrgTab.getIndexOf(ctlIdx);
+        let nextCtlIdx = compMainPrgTab.getCtlIdx(currSearchIndex + 1);
+        let result;
+        if (nextCtlIdx === -1) {
+            result = null;
+        }
+        else {
+            result = this.getMainProg(nextCtlIdx);
+        }
+        return result;
+    }
+    clientTransactionCacheExists() {
+        let task;
+        for (let i = 0; i < this._tasksTab.getSize(); i = i + 1) {
+            task = this._tasksTab.getTask(i);
+            if (!task.isMainProg() && task.DataView.modifiedRecordsNumber() > 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    serverTransactionCacheExists() {
+        let task;
+        for (let i = 0; i < this._tasksTab.getSize(); i = i + 1) {
+            task = this._tasksTab.getTask(i);
+            if (!task.isMainProg() && !task.DataView.ServerTransactionCacheEmpty) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getTaskByTaskDefinitionID(taskDefinitionID) {
+        let task;
+        for (let i = 0; i < this._tasksTab.getSize(); i = i + 1) {
+            task = this._tasksTab.getTask(i);
+            if (task.TaskDefinitionId.Equals(taskDefinitionID)) {
+                return task;
+            }
+        }
+        return null;
+    }
+    getTimerHandlers() {
+        return this._timerHandlers;
+    }
+    addTimerHandler(handler) {
+        this._timerHandlers.add(handler);
+    }
+    removeTimerHandler(task) {
+        for (let i = 0; i < this._timerHandlers.getSize();) {
+            let timerTask = this._timerHandlers.getHandler(i).getTask();
+            if (timerTask.isDescendentOf(task) && timerTask.getMGData() === this)
+                this._timerHandlers.remove(i);
+            else
+                i++;
+        }
+    }
+    removeExpressionHandler(task) {
+        for (let i = 0; i < this._expHandlers.getSize();) {
+            let timerTask = this._expHandlers.getHandler(i).getTask();
+            if (timerTask.isDescendentOf(task) && timerTask.getMGData() === this)
+                this._expHandlers.remove(i);
+            else
+                i++;
+        }
+    }
+    getExpHandlers() {
+        return this._expHandlers;
+    }
+    addExpHandler(handler, idx) {
+        this._expHandlers.insertAfter(handler, idx);
+    }
+    changeTimers(oldTimers, newTimers) {
+        let i = 0;
+        let j = 0;
+        let guiManager = GUIManager.Instance;
+        oldTimers.sort();
+        newTimers.sort();
+        while (i < oldTimers.length && j < newTimers.length) {
+            if (oldTimers.get_Item(i) > newTimers.get_Item(j)) {
+                guiManager.startTimer(this, newTimers.get_Item(j), false);
+                j = j + 1;
+            }
+            else {
+                if (oldTimers.get_Item(i) < newTimers.get_Item(j)) {
+                    guiManager.stopTimer(this, oldTimers.get_Item(i), false);
+                    i = i + 1;
+                }
+                else {
+                    i = i + 1;
+                    j = j + 1;
+                }
+            }
+        }
+        while (i < oldTimers.length) {
+            guiManager.stopTimer(this, oldTimers.get_Item(i), false);
+            i = i + 1;
+        }
+        while (j < newTimers.length) {
+            guiManager.startTimer(this, newTimers.get_Item(j), false);
+            j = j + 1;
+        }
+    }
+    fillEventsQueue(parser) {
+        while (this.initEvents(parser, parser.getNextTag())) {
+        }
+    }
+    initEvents(parser, foundTagName) {
+        let result;
+        if (foundTagName === null) {
+            result = false;
+        }
+        else {
+            if (foundTagName === ConstInterface.MG_TAG_EVENT) {
+                let evt = new RunTimeEvent(null);
+                evt.fillData(parser, null);
+                evt.convertParamsToArgs();
+                evt.setTask(null);
+                evt.setFromServer();
+                AccessHelper.eventsManager.addToTail(evt);
+            }
+            else {
+                if (foundTagName === ConstInterface.MG_TAG_EVENTS_QUEUE) {
+                    parser.setCurrIndex(parser.getXMLdata().indexOf(">", parser.getCurrIndex()) + 1);
+                }
+                else {
+                    if (foundTagName === "/" + ConstInterface.MG_TAG_EVENTS_QUEUE) {
+                        parser.setCurrIndex2EndOfTag();
+                        result = false;
+                        return result;
+                    }
+                    Logger.Instance.WriteExceptionToLogWithMsg("There is no such tag in EventsQueue: " + foundTagName);
+                    result = false;
+                    return result;
+                }
+            }
+            result = true;
+        }
+        return result;
+    }
+    isMainWindow() {
+        return this._parent === null;
+    }
+    getParentMGdata() {
+        return this._parent;
+    }
+    abort() {
+        this.IsAborting = true;
+    }
+    copyUnframedCmds() {
+        let unframedCmds = GlobalCommandsManager.Instance.getUnframedCmds();
+        for (let i = 0; i < unframedCmds.length; i = i + 1) {
+            this.CmdsToClient.Add(unframedCmds.get_Item(i));
+        }
+        unframedCmds.SetSize(0);
+    }
+    getValidAncestor() {
+        return this._parent;
+    }
+    getMaxCtlIdx() {
+        let rc = 0;
+        for (let i = 0; i < this._tasksTab.getSize(); i = i + 1) {
+            let task = this._tasksTab.getTask(i);
+            if (task !== null) {
+                rc = Math.max(rc, task.getCtlIdx());
+            }
+        }
+        return rc;
+    }
+    fillGlobalParams(parser) {
+        let XMLdata = parser.getXMLdata();
+        let endContext = parser.getXMLdata().indexOf(XMLConstants.TAG_TERM, parser.getCurrIndex());
+        if (endContext !== -1 && endContext < XMLdata.length) {
+            let tag = parser.getXMLsubstring(endContext);
+            parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_GLOBALPARAMS) + ConstInterface.MG_TAG_GLOBALPARAMS.length);
+            let tokens = XmlParser.getTokens(RuntimeContextBase.Instance.Parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);
+            Debug.Assert(tokens.get_Item(0) === XMLConstants.MG_ATTR_VALUE);
+            ServerConfig.Instance.setGlobalParams(tokens.get_Item(1));
+            endContext = XMLdata.indexOf(XMLConstants.TAG_OPEN, endContext);
+            if (endContext === -1)
+                endContext = XMLdata.length;
+            parser.setCurrIndex(endContext);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MGData.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/tasks/MGData.ts"],"names":[],"mappings":"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","sourcesContent":["import {HandlersTable} from \"../rt/HandlersTable\";\r\nimport {TasksTable} from \"./TasksTable\";\r\nimport {ICommandsTable} from \"../ICommandsTable\";\r\nimport {CompMainPrgTable} from \"../rt/CompMainPrgTable\";\r\nimport {MgForm} from \"../gui/MgForm\";\r\nimport {Task} from \"./Task\";\r\nimport {OpeningTaskDetails} from \"./TaskBase\";\r\nimport {Logger, XMLConstants, XmlParser} from \"@magic-xpa/utils\";\r\nimport {RecomputeTable} from \"../rt/RecomputeTable\";\r\nimport {Debug, List, NNumber, StringBuilder} from \"@magic-xpa/mscorelib\";\r\nimport {RuntimeContextBase, TaskDefinitionId} from \"@magic-xpa/gui\";\r\nimport {EventHandler} from \"../event/EventHandler\";\r\nimport {GUIManager} from \"../GUIManager\";\r\nimport {IClientCommand} from \"../commands/IClientCommand\";\r\nimport {HttpManager} from \"../http/HttpManager\";\r\nimport {FlowMonitorQueue} from \"../util/FlowMonitorQueue\";\r\nimport {RunTimeEvent} from \"../event/RunTimeEvent\";\r\nimport {ConstInterface} from \"../ConstInterface\";\r\nimport {LanguageData} from \"../env/LanguageData\";\r\nimport {EnvParamsTable} from \"../env/EnvVariablesTable\";\r\nimport {GlobalParams} from \"../exp/GlobalParamsTable\";\r\nimport {Environment} from \"../env/Environment\";\r\nimport {GlobalCommandsManager} from \"../GlobalCommandsManager\";\r\nimport {ServerConfig} from \"../ServerConfig\";\r\nimport {AccessHelper} from \"../AccessHelper\";\r\nimport {UserDetails} from \"../security/UserDetails\";\r\nimport {RemoteCommandsProcessor} from \"../remote/RemoteCommandsProcessor\";\r\nimport {DataView} from \"../..\";\r\n\r\n/// <summary>\r\n///   Represents all details relevant to a specific task - related tasks, commands, handlers, etc..\r\n/// </summary>\r\nexport class MGData {\r\n  private _expHandlers: HandlersTable = null;\r\n  private _id: number = 0;\r\n  private _parent: MGData = null;\r\n  private _mprgTab: TasksTable = null;\r\n  private _tasksTab: TasksTable = null;\r\n  private _timerHandlers: HandlersTable = null;\r\n  private _timersStarted: boolean = false;\r\n  private forceModal: boolean = false;\r\n  CmdsToClient: ICommandsTable = null;\r\n  CmdsToServer: ICommandsTable = null;\r\n  IsModal: boolean = false;\r\n  IsAborting: boolean = false;\r\n\r\n  get ForceModal(): boolean {\r\n    return this.forceModal;\r\n  }\r\n\r\n\r\n  constructor(toClient: ICommandsTable, toServer: ICommandsTable, id: number, parent: MGData, isModal: boolean);\r\n  constructor(toClient: ICommandsTable, toServer: ICommandsTable, id: number, parent: MGData, isModal: boolean, forceModal: boolean);\r\n  constructor(toClient: ICommandsTable, toServer: ICommandsTable, id: number, parent: MGData, isModal: boolean, forceModal?: boolean) {\r\n    this.CmdsToServer = toClient;\r\n    this.CmdsToClient = toServer;\r\n\r\n    if (arguments.length === 5)\r\n      this.constructor_0(id, parent, isModal);\r\n    else\r\n      this.constructor_1(id, parent, isModal, forceModal);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   CTOR\r\n  /// </summary>\r\n  /// <param name = \"id\">the id of this mgdata object</param>\r\n  /// <param name = \"parent\">the parent MGData</param>\r\n  /// <param name = \"isModal\">true for modal windows</param>\r\n  private constructor_0(id: number, parent: MGData, isModal: boolean): void {\r\n\r\n    this._timerHandlers = new HandlersTable();\r\n    this._expHandlers = new HandlersTable();\r\n    this._mprgTab = new TasksTable();\r\n    this._tasksTab = new TasksTable();\r\n    this._id = id;\r\n    this._parent = parent;\r\n    if (AccessHelper.eventsManager.getCompMainPrgTab() === null) {\r\n      let compMainPrgTab: CompMainPrgTable = new CompMainPrgTable();\r\n      AccessHelper.eventsManager.setCompMainPrgTab(compMainPrgTab);\r\n    }\r\n    this.IsModal = isModal;\r\n  }\r\n\r\n  /// <summary>\r\n  /// CTOR to be used when running offline tasks - hold the command to enable right setting of modality\r\n  /// </summary>\r\n  /// <param name=\"id\"></param>\r\n  /// <param name=\"parent\"></param>\r\n  /// <param name=\"isModal\"></param>\r\n  /// <param name=\"forceModal\"></param>\r\n  private constructor_1(id: number, parent: MGData, isModal: boolean, forceModal: boolean): void {\r\n    this.constructor_0(id, parent, isModal);\r\n    this.forceModal = forceModal;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the id of this MGData object\r\n  /// </summary>\r\n  GetId(): number {\r\n    return this._id;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Returns true if already moved to the first control on one of the MgData\r\n  /// </summary>\r\n  AlreadyMovedToFirstControl(): boolean {\r\n    let alreadyMoved: boolean = false;\r\n    let tasksCount: number = this.getTasksCount();\r\n    for (let i: number = 0; i < tasksCount; i = i + 1) {\r\n      let mgForm: MgForm = <MgForm>this.getTask(i).getForm();\r\n      if (mgForm !== null && mgForm.MovedToFirstControl) {\r\n        alreadyMoved = true;\r\n        break;\r\n      }\r\n    }\r\n    return alreadyMoved;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   start the timers\r\n  /// </summary>\r\n  StartTimers(): void {\r\n    if (this._timerHandlers !== null && !this._timersStarted) {\r\n      this._timerHandlers.startTimers(this);\r\n      this._timersStarted = true;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Function for filling own fields, allocate memory for inner objects. Parsing the input String.\r\n  /// </summary>\r\n  async fillData(openingTaskDetails: OpeningTaskDetails, parser: XmlParser): Promise<void> {\r\n    // To avoid the need to send data that sets default values, we'll assume we want the default values\r\n    // unless different info was sent. i.e. if the relevant tags are not in the XML, set the default values.\r\n    let canContinue: boolean;\r\n    do {\r\n      let nextTag: string = parser.getNextTag();\r\n      canContinue = await this.initInnerObjects(parser, nextTag, openingTaskDetails);\r\n    }\r\n    while (canContinue);\r\n    Logger.Instance.WriteDevToLog(\"MGData.FillData(): THE END of the parsing \" + parser.getCurrIndex() + \" characters\");\r\n  }\r\n\r\n  /// <summary>\r\n  ///   To allocate and fill inner objects of the class\r\n  /// </summary>\r\n  /// <param name = \"foundTagName\">possible tag name, name of object, which need be allocated</param>\r\n  /// <param name=\"openingTaskDetails\">additional information of opening task</param>\r\n  /// <returns> xmlParser.getCurrIndex(), the found object tag and ALL its subtags finish</returns>\r\n  private async initInnerObjects(parser: XmlParser, foundTagName: string, openingTaskDetails: OpeningTaskDetails): Promise<boolean> {\r\n    if (foundTagName == null)\r\n      return false;\r\n    switch (foundTagName) {\r\n      case XMLConstants.MG_TAG_XML:\r\n        parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1); // do\r\n        // nothing\r\n        break;\r\n      case ConstInterface.MG_TAG_DATAVIEW:\r\n        if (! await this.insertDataView(parser)) {\r\n          // the task of insert data view not found -> set parsers counter to the\r\n          // end of the data view\r\n          // the data view, got from server and there is no task to the data view , yet.\r\n          let endContext: number = parser.getXMLdata().indexOf('/' + ConstInterface.MG_TAG_DATAVIEW,\r\n            parser.getCurrIndex());\r\n          parser.setCurrIndex(endContext);\r\n          parser.setCurrIndex2EndOfTag();\r\n        }\r\n        break;\r\n      case ConstInterface.MG_TAG_COMPLETE_DV: {\r\n        let task: Task = null;\r\n        let endContext: number = parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex());\r\n        let index: number = parser.getXMLdata().indexOf(ConstInterface.MG_TAG_COMPLETE_DV, parser.getCurrIndex()) + ConstInterface.MG_TAG_COMPLETE_DV.length;\r\n        let tokensVector: List<string> = XmlParser.getTokens(parser.getXMLdata().substr(index, endContext - index), '\"');\r\n        let attribute: string = (tokensVector.get_Item(0));\r\n        let valueStr: string;\r\n        if (attribute === XMLConstants.MG_ATTR_TASKID) {\r\n          valueStr = (tokensVector.get_Item(1));\r\n          let taskId: string = valueStr;\r\n          if (this.getTask(taskId) === null)\r\n            task = <Task>AccessHelper.mgDataTable.GetTaskByID(taskId);\r\n          else\r\n            task = this.getTask(taskId);\r\n        }\r\n        let start: number = endContext + 1;\r\n        endContext = parser.getXMLdata().indexOf(XMLConstants.END_TAG + ConstInterface.MG_TAG_COMPLETE_DV,\r\n          parser.getCurrIndex());\r\n        let dataViewContent: string = parser.getXMLdata().substr(start, endContext - start);\r\n        task.dataViewContent = dataViewContent;\r\n        parser.setCurrIndex(endContext);\r\n        parser.setCurrIndex2EndOfTag();\r\n      }\r\n        break;\r\n      case ConstInterface.MG_TAG_CONTEXT: {\r\n        let endContext: number = parser.getXMLdata().indexOf(XMLConstants.TAG_TERM, parser.getCurrIndex());\r\n        if (endContext !== -1 && endContext < parser.getXMLdata().length) {\r\n          let tag: string = parser.getXMLsubstring(endContext);\r\n          parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_CONTEXT) + ConstInterface.MG_TAG_CONTEXT.length);\r\n          parser.setCurrIndex(endContext + XMLConstants.TAG_TERM.length);\r\n        }\r\n        break;\r\n      }\r\n      case XMLConstants.MG_TAG_RECOMPUTE:\r\n        let recompTab = new RecomputeTable();\r\n        recompTab.fillData(parser);\r\n        break;\r\n      case ConstInterface.MG_TAG_COMMAND:\r\n        Logger.Instance.WriteDevToLog(\"goes to command\");\r\n        this.CmdsToClient.fillData(parser);\r\n        break;\r\n      case ConstInterface.MG_TAG_LANGUAGE:\r\n        Logger.Instance.WriteDevToLog(\"goes to language data\");\r\n        await LanguageData.Instance.fillData(parser);\r\n        break;\r\n      case ConstInterface.MG_TAG_KBDMAP_URL:\r\n        Logger.Instance.WriteDevToLog(\"goes to keyBoard\");\r\n        await Environment.Instance.fillFromUrl(foundTagName, parser);\r\n        break;\r\n      case ConstInterface.MG_TAG_KBDMAP:\r\n        break;\r\n      case ConstInterface.MG_TAG_COMPMAINPRG:\r\n        Logger.Instance.WriteDevToLog(\"goes to compmainprg\");\r\n        AccessHelper.eventsManager.getCompMainPrgTab().fillData(parser);\r\n        break;\r\n      case ConstInterface.MG_TAG_EVENTS_QUEUE:\r\n        Logger.Instance.WriteDevToLog(\"goes to eventsqueue\");\r\n        this.fillEventsQueue(parser);\r\n        break;\r\n      case ConstInterface.MG_TAG_TASKURL:\r\n        await Task.ProcessTaskURL();\r\n        break;\r\n      case XMLConstants.MG_TAG_TASK:\r\n        Logger.Instance.WriteDevToLog(\"goes to task\");\r\n        let taskCountBefore: number = this._mprgTab.getSize();\r\n        await this._mprgTab.fillData(this, openingTaskDetails, parser);\r\n        // QCR #759911: mprg must belong to the main application's MGData.\r\n        // This ensures it will not be discarded until the end of execution.\r\n        // There could be more then 1 mprgs that are added (Qcr #168549)\r\n        if (this._id !== 0) {\r\n          let taskCountAfter: number = this._mprgTab.getSize();\r\n          let mgd0: MGData = AccessHelper.mgDataTable.getMGData(0);\r\n          // check all the new main prgs.\r\n          for (let taskIndex: number = taskCountBefore; taskIndex < taskCountAfter; taskIndex++) {\r\n            let newTask: Task = <Task>this._mprgTab.getTask(taskIndex);\r\n            if (newTask.isMainProg() && mgd0._mprgTab.getTask(newTask.getTaskTag()) == null) {\r\n              mgd0._mprgTab.addTask(newTask);\r\n              mgd0.addTask(newTask);\r\n            }\r\n          }\r\n        }\r\n        break;\r\n      case ConstInterface.MG_TAG_ENV:\r\n        Logger.Instance.WriteDevToLog(\"goes to environment\");\r\n        Environment.Instance.fillData(parser);\r\n        break;\r\n      case ConstInterface.MG_TAG_FLWMTR_CONFIG:\r\n        FlowMonitorQueue.Instance.fillData(parser);\r\n        break;\r\n      case XMLConstants.MG_TAG_XML_END:\r\n        parser.setCurrIndex2EndOfTag();\r\n        return false;\r\n\r\n      case ConstInterface.MG_TAG_USER_DETAILS:\r\n        UserDetails.Instance.fillData(parser);\r\n        break;\r\n\r\n      case ConstInterface.MG_TAG_DBH_REAL_IDXS:\r\n        // Webclient TODO : remove serialization of this from server\r\n        parser.SkipXMLElement();\r\n        break;\r\n      case ConstInterface.MG_TAG_GLOBALPARAMSCHANGES:\r\n        Logger.Instance.WriteDevToLog(\"applying global params changes from the server (Set/GetParams)\");\r\n        GlobalParams.Instance.fillData(parser);\r\n        break;\r\n      case ConstInterface.MG_TAG_GLOBALPARAMS:\r\n        Logger.Instance.WriteDevToLog(\"processing base64 encoded image of all global params from the server\");\r\n        this.fillGlobalParams(parser);\r\n        break;\r\n      case ConstInterface.MG_TAG_ENV_PARAM_URL:\r\n        Logger.Instance.WriteDevToLog(\"goes to env params name \");\r\n        await Environment.Instance.fillFromUrl(foundTagName, parser);\r\n        break;\r\n      case ConstInterface.MG_TAG_ENV_PARAM:\r\n        Logger.Instance.WriteDevToLog(\"goes to env params name \");\r\n        EnvParamsTable.Instance.fillData(parser);\r\n        break;\r\n      case ConstInterface.MG_TAG_CONTEXT_ID: {\r\n        let ctxId: string;\r\n        let ctxEndIdx: number;\r\n        parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);\r\n        ctxEndIdx = parser.getXMLdata().indexOf(XMLConstants.TAG_OPEN, parser.getCurrIndex());\r\n        ctxId = parser.getXMLsubstring(ctxEndIdx).trim();\r\n        parser.setCurrIndex(ctxEndIdx);\r\n        parser.setCurrIndex2EndOfTag();\r\n        RuntimeContextBase.Instance.ContextID = ctxId;\r\n      }\r\n        break;\r\n      case ConstInterface.MG_TAG_SESSION_ID:\r\n        // parse session id received in 1st response from server for offline client\r\n        // and save sessionid on client.\r\n        let sessionIdEndIdx: number;\r\n        parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);\r\n        sessionIdEndIdx = parser.getXMLdata().indexOf(XMLConstants.TAG_OPEN, parser.getCurrIndex());\r\n        RemoteCommandsProcessor.GetInstance().SessionId = parser.getXMLsubstring(sessionIdEndIdx).trim();\r\n        parser.setCurrIndex(sessionIdEndIdx);\r\n        parser.setCurrIndex2EndOfTag();\r\n        break;\r\n      case ConstInterface.MG_TAG_HTTP_COMMUNICATION_TIMEOUT: {\r\n        let httpCommunicationTimeout: number; // communication-level timeout (i.e. the access to the web server, NOT the entire request/response round-trip), in seconds.\r\n        let httpCommunicationTimeoutIdx: number;\r\n        parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);\r\n        httpCommunicationTimeoutIdx = parser.getXMLdata().indexOf(XMLConstants.TAG_OPEN, parser.getCurrIndex());\r\n        httpCommunicationTimeout = NNumber.Parse(parser.getXMLsubstring(httpCommunicationTimeoutIdx));\r\n        parser.setCurrIndex(httpCommunicationTimeoutIdx);\r\n        parser.setCurrIndex2EndOfTag();\r\n        HttpManager.GetInstance().HttpCommunicationTimeoutMS = httpCommunicationTimeout * 1000;\r\n      }\r\n        break;\r\n      case ConstInterface.MG_TAG_DATABASE_URL:\r\n      case ConstInterface.MG_TAG_DATABASES_HEADER:\r\n      case ConstInterface.MG_TAG_TASKDEFINITION_IDS_URL:\r\n      case ConstInterface.MG_TAG_DBH_DATA_IDS_URL:\r\n      case ConstInterface.MG_TAG_DBHS_END:\r\n      case ConstInterface.MG_TAG_OFFLINE_SNIPPETS_URL:\r\n        // TODO: server should not serialize these elements.\r\n        parser.SkipXMLElement();\r\n        break;\r\n\r\n      case ConstInterface.MG_TAG_DBHS:\r\n      case ConstInterface.MG_TAG_STARTUP_PROGRAM:\r\n        // TODO: server should not serialize these elements.\r\n        parser.ReadContentOfCurrentElement();\r\n        break;\r\n\r\n      case XMLConstants.MG_TAG_MENUS_OPEN:\r\n        // TODO - not to serialize [Story 154547]\r\n        break;\r\n\r\n      default:\r\n        Logger.Instance.WriteExceptionToLogWithMsg(\"There is no such tag name in MGData, add case to MGData.initInnerObjects and case to while of MGData.FillData  \" + foundTagName);\r\n        return false;\r\n    }\r\n    return true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Insert Records Table to DataView of the task\r\n  /// </summary>\r\n  /// <returns> if the task of dataview found</returns>\r\n  private async insertDataView(parser: XmlParser): Promise<boolean> {\r\n    let task: Task = null;\r\n    let endContext: number = parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex());\r\n    let index: number = parser.getXMLdata().indexOf(ConstInterface.MG_TAG_DATAVIEW, parser.getCurrIndex()) + ConstInterface.MG_TAG_DATAVIEW.length;\r\n    let tokensVector: List<string> = XmlParser.getTokens(parser.getXMLdata().substr(index, endContext - index), '\"')/*'\"'*/;\r\n    let invalidate: boolean = false;\r\n    // look for the task id\r\n    for (let i: number = 0; i < tokensVector.length; i = i + 2) {\r\n      let attribute: string = tokensVector.get_Item(i);\r\n      if (attribute === XMLConstants.MG_ATTR_TASKID) {\r\n        let valueStr: string = tokensVector.get_Item(i + 1);\r\n        let taskId: string = valueStr;\r\n        task = (this.getTask(taskId) || (<Task>AccessHelper.mgDataTable.GetTaskByID(taskId)));\r\n      }\r\n      if (attribute === ConstInterface.MG_ATTR_INVALIDATE) {\r\n        let valueStr: string = tokensVector.get_Item(i + 1);\r\n        invalidate = XmlParser.getBoolean(valueStr);\r\n        break;\r\n      }\r\n    }\r\n    let result: boolean;\r\n    if (task !== null) {\r\n      // add the records and update the current record in the dataview\r\n      await task.insertRecordTable(invalidate, parser);\r\n      result = true;\r\n    }\r\n    else {\r\n      result = false; // the task not found\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   add task to taskTab\r\n  /// </summary>\r\n  /// <param name = \"newTask\">to be added</param>\r\n  addTask(newTask: Task): void {\r\n    this._tasksTab.addTask(newTask);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   remove a task from the tasks table\r\n  /// </summary>\r\n  /// <param name = \"task\"></param>\r\n  removeTask(task: Task): void {\r\n    this._tasksTab.removeTask(task);\r\n    this._mprgTab.removeTask(task);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the number of tasks in the tasks table\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  getTasksCount(): number {\r\n    let result: number;\r\n    if (this._tasksTab !== null) {\r\n      result = this._tasksTab.getSize();\r\n    }\r\n    else {\r\n      result = 0;\r\n    }\r\n    return result;\r\n  }\r\n\r\n  getTask(taskId: string): Task;\r\n  getTask(idx: number): Task;\r\n  getTask(taskIdOrIdx: any): Task {\r\n    if (arguments.length === 1 && (taskIdOrIdx === null || typeof taskIdOrIdx === \"undefined\" || taskIdOrIdx.constructor === String)) {\r\n      return this.getTask_0(taskIdOrIdx);\r\n    }\r\n    return this.getTask_1(taskIdOrIdx);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns a task by its id\r\n  /// </summary>\r\n  /// <param name = \"taskId\">task ID</param>\r\n  private getTask_0(taskId: string): Task {\r\n    let result: Task;\r\n    if (this._tasksTab !== null && typeof this._tasksTab !== \"undefined\") {\r\n      result = <Task>this._tasksTab.getTask(taskId);\r\n    }\r\n    else {\r\n      result = null;\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns a task by its index in the tasks table\r\n  /// </summary>\r\n  /// <param name = \"idx\">index of the task in the tasks table</param>\r\n  private getTask_1(idx: number): Task {\r\n    return <Task>this._tasksTab.getTask(idx);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   build XML string of the MGData object\r\n  /// </summary>\r\n  /// <param name=\"message\">a message being prepared.</param>\r\n  /// <param name=\"serializeTasks\">if true, tasks in the current execution will also be serialized.</param>\r\n  async buildXML(message: StringBuilder, serializeTasks: boolean): Promise<void> {\r\n    if (this.CmdsToServer !== null) {\r\n      this.CmdsToServer.buildXML(message);\r\n    }\r\n    if (serializeTasks && this._tasksTab !== null) {\r\n      await this._tasksTab.buildXML(message);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the first task which is not a main program in the task table\r\n  /// </summary>\r\n  getFirstTask(): Task {\r\n    let task: Task = null;\r\n    let MDIFrameTask: Task = null;\r\n    for (let i: number = 0; i < this._tasksTab.getSize(); i = i + 1) {\r\n      task = <Task>this._tasksTab.getTask(i);\r\n      if (!task.isMainProg()) {\r\n        break;\r\n      }\r\n\r\n      task = null;\r\n    }\r\n    if (task === null && this._id === 0) {\r\n      task = MDIFrameTask; // return MDI frame program\r\n    }\r\n    return task;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get a main program of a component by its ctl idx\r\n  /// </summary>\r\n  /// <param name = \"ctlIdx\">the ctl idx</param>\r\n  getMainProg(ctlIdx: number): Task {\r\n    for (let i: number = 0; i < this._mprgTab.getSize(); i = i + 1) {\r\n      let task: Task = <Task>this._mprgTab.getTask(i);\r\n      if (task.getCtlIdx() === ctlIdx && task.isMainProg()) {\r\n        return task;\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the next main program in the search order AFTER the ctlIdx\r\n  /// </summary>\r\n  /// <param name = \"ctlIdx\">the current ctl idx</param>\r\n  getNextMainProg(ctlIdx: number): Task {\r\n    let compMainPrgTab: CompMainPrgTable = AccessHelper.eventsManager.getCompMainPrgTab();\r\n    let currSearchIndex: number = compMainPrgTab.getIndexOf(ctlIdx);\r\n    let nextCtlIdx: number = compMainPrgTab.getCtlIdx(currSearchIndex + 1);\r\n    let result: Task;\r\n    if (nextCtlIdx === -1) {\r\n      result = null;\r\n    }\r\n    else {\r\n      result = this.getMainProg(nextCtlIdx);\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns whether any of the task has pending client side transaction cache\r\n  /// </summary>\r\n  clientTransactionCacheExists(): boolean {\r\n    let task: Task;\r\n    for (let i: number = 0; i < this._tasksTab.getSize(); i = i + 1) {\r\n      task = <Task>this._tasksTab.getTask(i);\r\n      if (!task.isMainProg() && (<DataView>task.DataView).modifiedRecordsNumber() > 0) {\r\n        return true;\r\n      }\r\n    }\r\n      return false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns whether any of the task has pending server side\r\n  ///   transaction cache which is not yet committed to DB\r\n  /// </summary>\r\n  serverTransactionCacheExists(): boolean {\r\n    let task: Task;\r\n    for (let i: number = 0; i < this._tasksTab.getSize(); i = i + 1) {\r\n      task = <Task>this._tasksTab.getTask(i);\r\n      if (!task.isMainProg() && !(<DataView>task.DataView).ServerTransactionCacheEmpty) {\r\n        return true;\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   search task that matches by TaskDefinitionId.\r\n  /// </summary>\r\n  getTaskByTaskDefinitionID(taskDefinitionID: TaskDefinitionId): Task {\r\n    let task: Task;\r\n    for (let i: number = 0; i < this._tasksTab.getSize(); i = i + 1) {\r\n      task = <Task>this._tasksTab.getTask(i);\r\n      if (task.TaskDefinitionId.Equals(taskDefinitionID)) {\r\n        return task;\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the timer event handlers\r\n  getTimerHandlers(): HandlersTable {\r\n    return this._timerHandlers;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   add a timer event handler to the timer event handlers table\r\n  /// </summary>\r\n  /// <param name = \"handler\">a reference to a timer event handler</param>\r\n  addTimerHandler(handler: EventHandler): void {\r\n    this._timerHandlers.add(handler);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   removes timer handlers for the specific task\r\n  ///   it is needed for destination call for exit from the previous subform\r\n  /// </summary>\r\n  removeTimerHandler(task: Task): void {\r\n    for (let i = 0; i < this._timerHandlers.getSize();) {\r\n      let timerTask: Task = this._timerHandlers.getHandler(i).getTask();\r\n      if (timerTask.isDescendentOf(task) && timerTask.getMGData() === this)\r\n        this._timerHandlers.remove(i);\r\n      else\r\n        i++;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   removes expression handlers for the specific task\r\n  ///   it is needed for destination call for exit from the previous subform\r\n  /// </summary>\r\n  removeExpressionHandler(task: Task): void {\r\n    for (let i = 0; i < this._expHandlers.getSize();) {\r\n      let timerTask: Task = this._expHandlers.getHandler(i).getTask();\r\n      if (timerTask.isDescendentOf(task) && timerTask.getMGData() === this)\r\n        this._expHandlers.remove(i);\r\n      else\r\n        i++;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the expression event handlers\r\n  /// </summary>\r\n  getExpHandlers(): HandlersTable {\r\n    return this._expHandlers;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   add a expression event handler to the expression event handlers table\r\n  /// </summary>\r\n  /// <param name = \"handler\">a reference to an expression event handler</param>\r\n  addExpHandler(handler: EventHandler, idx: number): void {\r\n    this._expHandlers.insertAfter(handler, idx);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   stops timers that already no needed and start new timers\r\n  /// </summary>\r\n  /// <param name = \"oldTimers\"></param>\r\n  /// <param name = \"newTimers\"></param>\r\n  changeTimers(oldTimers: List<number>, newTimers: List<number>): void {\r\n    let i: number = 0;\r\n    let j: number = 0;\r\n    let guiManager: GUIManager = GUIManager.Instance;\r\n    oldTimers.sort();\r\n    newTimers.sort();\r\n    while (i < oldTimers.length && j < newTimers.length) {\r\n      if (oldTimers.get_Item(i) > newTimers.get_Item(j)) {\r\n        guiManager.startTimer(this, newTimers.get_Item(j), false);\r\n        j = j + 1;\r\n      }\r\n      else {\r\n        if (oldTimers.get_Item(i) < newTimers.get_Item(j)) {\r\n          guiManager.stopTimer(this, oldTimers.get_Item(i), false);\r\n          i = i + 1;\r\n        }\r\n        else {\r\n          i = i + 1;\r\n          j = j + 1;\r\n        }\r\n      }\r\n    }\r\n    while (i < oldTimers.length) {\r\n      guiManager.stopTimer(this, oldTimers.get_Item(i), false);\r\n      i = i + 1;\r\n    }\r\n    while (j < newTimers.length) {\r\n      guiManager.startTimer(this, newTimers.get_Item(j), false);\r\n      j = j + 1;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   add data from <eventsqueue> tag to the events queue\r\n  /// </summary>\r\n  private fillEventsQueue(parser: XmlParser): void {\r\n    while (this.initEvents(parser, parser.getNextTag())) {\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   add Run Time Events to the events queue\r\n  /// </summary>\r\n  /// <param name = \"foundTagName\">possible tag name, name of object, which need be allocated</param>\r\n  private initEvents(parser: XmlParser, foundTagName: string): boolean {\r\n    let result: boolean;\r\n    if (foundTagName === null) {\r\n      result = false;\r\n    }\r\n    else {\r\n      if (foundTagName === ConstInterface.MG_TAG_EVENT) {\r\n        let evt: RunTimeEvent = new RunTimeEvent(null);\r\n        evt.fillData(parser, null);\r\n        evt.convertParamsToArgs();\r\n        evt.setTask(null);\r\n        evt.setFromServer();\r\n        AccessHelper.eventsManager.addToTail(evt);\r\n      }\r\n      else {\r\n        if (foundTagName === ConstInterface.MG_TAG_EVENTS_QUEUE) {\r\n          parser.setCurrIndex(parser.getXMLdata().indexOf(\">\", parser.getCurrIndex()) + 1);\r\n        }\r\n        else {\r\n          if (foundTagName === \"/\" + ConstInterface.MG_TAG_EVENTS_QUEUE) {\r\n            parser.setCurrIndex2EndOfTag();\r\n            result = false;\r\n            return result;\r\n          }\r\n          Logger.Instance.WriteExceptionToLogWithMsg(\"There is no such tag in EventsQueue: \" + foundTagName);\r\n          result = false;\r\n          return result;\r\n        }\r\n      }\r\n      result = true;\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true for the main windows MGData\r\n  /// </summary>\r\n  isMainWindow(): boolean {\r\n    return this._parent === null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the parent MGDdata of this MGData (might be null)\r\n  /// </summary>\r\n  getParentMGdata(): MGData {\r\n    return this._parent;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the aborting flag\r\n  /// </summary>\r\n  abort(): void {\r\n    this.IsAborting = true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   add all commands which are not attached to any window into the current window\r\n  /// </summary>\r\n  copyUnframedCmds(): void {\r\n    let unframedCmds: List<IClientCommand> = GlobalCommandsManager.Instance.getUnframedCmds();\r\n    for (let i: number = 0; i < unframedCmds.length; i = i + 1) {\r\n      this.CmdsToClient.Add(unframedCmds.get_Item(i));\r\n    }\r\n    unframedCmds.SetSize(0);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns an ancestor of this MGData object which is not pending unload\r\n  /// </summary>\r\n  getValidAncestor(): MGData {\r\n    return this._parent;\r\n  }\r\n\r\n  getMaxCtlIdx(): number {\r\n    let rc: number = 0;\r\n    for (let i: number = 0; i < this._tasksTab.getSize(); i = i + 1) {\r\n      let task: Task = <Task>this._tasksTab.getTask(i);\r\n      if (task !== null) {\r\n        rc = Math.max(rc, task.getCtlIdx());\r\n      }\r\n    }\r\n    return rc;\r\n  }\r\n\r\n  /// <summary> save the global params (one base64 encoded value) that was passed from the runtime-engine to the rich-client</summary>\r\n  fillGlobalParams(parser: XmlParser): void {\r\n    let XMLdata: string = parser.getXMLdata();\r\n    let endContext: number = parser.getXMLdata().indexOf(XMLConstants.TAG_TERM, parser.getCurrIndex());\r\n\r\n    if (endContext !== -1 && endContext < XMLdata.length) {\r\n      // find last position of its tag\r\n      let tag: string = parser.getXMLsubstring(endContext);\r\n      parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_GLOBALPARAMS) + ConstInterface.MG_TAG_GLOBALPARAMS.length);\r\n\r\n      let tokens: List<string> = XmlParser.getTokens(RuntimeContextBase.Instance.Parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);\r\n\r\n      Debug.Assert(tokens.get_Item(0) === XMLConstants.MG_ATTR_VALUE);\r\n      ServerConfig.Instance.setGlobalParams(tokens.get_Item(1));\r\n\r\n      endContext = XMLdata.indexOf(XMLConstants.TAG_OPEN, endContext);\r\n      if (endContext === -1)\r\n        endContext = XMLdata.length;\r\n\r\n      parser.setCurrIndex(endContext);\r\n    }\r\n  }\r\n}\r\n"]}