@magic-xpa/engine 4.1100.0-dev4110.25 → 4.1100.0-dev4110.250

package/esm2022/src/tasks/MGDataCollection.mjs

@@ -0,0 +1,252 @@
+import { ApplicationException, Debug, List } from "@magic-xpa/mscorelib";
+import { InternalInterface, XMLConstants } from "@magic-xpa/utils";
+import { Commands } from "@magic-xpa/gui";
+import { FlowMonitorQueue } from "../util/FlowMonitorQueue";
+import { LastFocusedManager } from "../rt/LastFocusedManager";
+import { CommandsProcessorBase_SendingInstruction, CommandsProcessorBase_SessionStage } from "../CommandsProcessorBase";
+import { CommandsProcessorManager } from "../CommandsProcessorManager";
+import { AccessHelper } from "../AccessHelper";
+import { ConstInterface } from "../ConstInterface";
+export class MGDataCollection {
+    static _instance = null;
+    _mgDataTab = new List();
+    _iteratorMgdIdx = 0;
+    _iteratorTaskIdx = 0;
+    currMgdID = 0;
+    StartupMgData = null;
+    _lastRouteSentToServer = "";
+    constructor() {
+    }
+    GetTaskByID(id) {
+        let task = null;
+        for (let i = 0; i < this.getSize() && task == null; i++) {
+            let mgd = this.getMGData(i);
+            if (mgd == null)
+                continue;
+            task = mgd.getTask(id);
+        }
+        return task;
+    }
+    static get Instance() {
+        if (MGDataCollection._instance == null) {
+            if (MGDataCollection._instance == null)
+                MGDataCollection._instance = new MGDataCollection();
+        }
+        return MGDataCollection._instance;
+    }
+    async addMGData(mgd, idx, isStartup) {
+        if (idx < 0 || idx > this.getSize())
+            throw new ApplicationException("Illegal MGData requested");
+        if (isStartup)
+            this.StartupMgData = mgd;
+        if (idx === this.getSize())
+            this._mgDataTab.push(mgd);
+        else {
+            let oldMgd = this.getMGData(idx);
+            if (oldMgd != null && !oldMgd.IsAborting) {
+                await oldMgd.getFirstTask().stop();
+                oldMgd.abort();
+            }
+            this._mgDataTab.set_Item(idx, mgd);
+        }
+    }
+    getMGData(idx) {
+        let mgd = null;
+        if (idx >= 0 && idx < this.getSize()) {
+            mgd = this._mgDataTab.get_Item(idx);
+        }
+        return mgd;
+    }
+    getAvailableIdx() {
+        let i;
+        for (i = 0; i < this._mgDataTab.length; i = i + 1) {
+            if (this._mgDataTab.get_Item(i) === null)
+                break;
+        }
+        return i;
+    }
+    getMgDataIdx(mgd) {
+        return this._mgDataTab.indexOf(mgd);
+    }
+    deleteMGDataTree(index) {
+        let mgd, childMgd;
+        let i;
+        if (index < 0 || index >= this.getSize())
+            throw new ApplicationException("in deleteMGData() illegal index: " + index);
+        mgd = this.getMGData(index);
+        if (mgd != null) {
+            if (index > 0 && mgd.getParentMGdata() != null) {
+                this._mgDataTab.set_Item(index, null);
+            }
+            LastFocusedManager.Instance.clean(index);
+            for (i = 0; i < this.getSize(); i++) {
+                childMgd = this.getMGData(i);
+                if (childMgd != null && childMgd.getParentMGdata() === mgd)
+                    this.deleteMGDataTree(i);
+            }
+        }
+    }
+    getCurrMGData() {
+        return this.getMGData(this.currMgdID);
+    }
+    GetMainProgByCtlIdx(contextIDOrCtlIdx, ctlIdx) {
+        if (arguments.length === 2)
+            return this.GetMainProgByCtlIdx_0(ctlIdx);
+        else
+            return this.GetMainProgByCtlIdx_1(contextIDOrCtlIdx);
+    }
+    GetMainProgByCtlIdx_0(ctlIdx) {
+        let task = null;
+        for (let i = 0; i < this.getSize() && task == null; i++) {
+            let mgd = this.getMGData(i);
+            if (mgd == null)
+                continue;
+            task = mgd.getMainProg(ctlIdx);
+        }
+        return task;
+    }
+    GetMainProgByCtlIdx_1(ctlIdx) {
+        return this.GetMainProgByCtlIdx(-1, ctlIdx);
+    }
+    startTasksIteration() {
+        this._iteratorMgdIdx = 0;
+        this._iteratorTaskIdx = 0;
+    }
+    getNextTask() {
+        let task;
+        let mgd = this.getMGData(this._iteratorMgdIdx);
+        if (mgd == null)
+            return null;
+        task = mgd.getTask(this._iteratorTaskIdx);
+        if (task == null) {
+            do {
+                this._iteratorMgdIdx++;
+            } while (this._iteratorMgdIdx < this.getSize() && this.getMGData(this._iteratorMgdIdx) == null);
+            this._iteratorTaskIdx = 0;
+            return this.getNextTask();
+        }
+        this._iteratorTaskIdx++;
+        return task;
+    }
+    async buildXML(message, serializeTasks) {
+        let lastRoute = Commands.getLastRoute();
+        if (lastRoute !== this._lastRouteSentToServer) {
+            message.Append(XMLConstants.START_TAG + ConstInterface.MG_TAG_LAST_ROUTE);
+            message.Append(" " + ConstInterface.MG_ATTR_ENV_VALUE + "=\"" + lastRoute + "\"");
+            message.Append(XMLConstants.TAG_TERM);
+            this._lastRouteSentToServer = lastRoute;
+        }
+        for (let i = 0; i < this.getSize(); i = i + 1) {
+            let mgd = this.getMGData(i);
+            if (mgd !== null && !mgd.IsAborting) {
+                await mgd.buildXML(message, serializeTasks);
+            }
+        }
+        FlowMonitorQueue.Instance.buildXML(message);
+    }
+    getSize() {
+        return this._mgDataTab.length;
+    }
+    async processRecovery() {
+        for (let i = 0; i < this.getSize(); i = i + 1) {
+            let mgd = this.getMGData(i);
+            if (mgd !== null) {
+                for (let j = 0; j < mgd.getTasksCount(); j = j + 1) {
+                    let task = mgd.getTask(j);
+                    if (task !== null)
+                        await task.DataView.processRecovery();
+                }
+            }
+        }
+    }
+    getTriggeredTasks(triggeringTask) {
+        let list = new List();
+        let task;
+        let tag = triggeringTask.getTaskTag();
+        this.startTasksIteration();
+        while ((task = this.getNextTask()) !== null) {
+            if (tag === task.PreviouslyActiveTaskId)
+                list.push(task);
+        }
+        return list;
+    }
+    GetTasks(p) {
+        let taskList = new List();
+        this._mgDataTab.forEach(mgd => {
+            if (mgd !== null && !mgd.IsAborting) {
+                for (let i = 0; i < mgd.getTasksCount(); i = i + 1) {
+                    let task = mgd.getTask(i);
+                    if (task !== null && p(task)) {
+                        taskList.push(task);
+                    }
+                }
+            }
+        });
+        return taskList;
+    }
+    getTaskIdById(taskId) {
+        let task = this.GetTaskByID(taskId);
+        let tag = taskId;
+        if (task != null)
+            tag = task.getTaskTag();
+        return tag;
+    }
+    GetTopMostForms() {
+        let task;
+        let forms = new List();
+        this.startTasksIteration();
+        while ((task = this.getNextTask()) != null) {
+            let form = task.getForm();
+            if (!task.isAborting() && form != null && !form.isSubForm())
+                forms.push(form);
+        }
+        return forms;
+    }
+    GetMGDataForStartupProgram() {
+        Debug.Assert(this._mgDataTab.length > 0, "The main program must be processed before invoking this method.");
+        let mainProgByCtlIdx = this.GetMainProgByCtlIdx(0);
+        Debug.Assert(mainProgByCtlIdx !== null, "The main program must be processed before invoking this method.");
+        Debug.Assert(mainProgByCtlIdx.getMgdID() === 0, "Main program is expected to be on MGData 0. Is this an error?");
+        return this._mgDataTab.get_Item(0);
+    }
+    async execRequestWithSubformRecordCycle(cmdsToServer, cmdToServer, exp) {
+        this.cleanDoSubformPrefixSuffix();
+        cmdsToServer.Add(cmdToServer);
+        if (!(MGDataCollection.Instance.StartupMgData.getFirstTask().InEndTask && MGDataCollection.Instance.StartupMgData.getFirstTask().ClosingFormUI))
+            await CommandsProcessorManager.GetCommandsProcessor().Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS, CommandsProcessorBase_SessionStage.NORMAL, exp);
+        await this.execAllSubformRecordCycle();
+    }
+    cleanDoSubformPrefixSuffix() {
+        for (let i = 0; i < this.getSize(); i++) {
+            let mgd = this.getMGData(i);
+            if (mgd === null || mgd.IsAborting)
+                continue;
+            let tasksCount = mgd.getTasksCount();
+            for (let j = 0; j < tasksCount; j++) {
+                let task = mgd.getTask(j);
+                task.DoSubformPrefixSuffix = false;
+            }
+        }
+    }
+    async execAllSubformRecordCycle() {
+        for (let i = 0; i < this.getSize(); i = i + 1) {
+            let mgd = this.getMGData(i);
+            if (mgd === null || mgd.IsAborting)
+                continue;
+            let tasksCount = mgd.getTasksCount();
+            for (let j = 0; j < tasksCount; j = j + 1) {
+                let task = mgd.getTask(j);
+                if (task.IsSubForm && task.DoSubformPrefixSuffix) {
+                    task.PerformParentRecordPrefix = false;
+                    AccessHelper.eventsManager.pushNewExecStacks();
+                    await AccessHelper.eventsManager.handleInternalEventWithTaskAndSubformRefresh(task, InternalInterface.MG_ACT_REC_PREFIX, true);
+                    if (!AccessHelper.eventsManager.GetStopExecutionFlag())
+                        await AccessHelper.eventsManager.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);
+                    AccessHelper.eventsManager.popNewExecStacks();
+                    task.PerformParentRecordPrefix = true;
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MGDataCollection.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/tasks/MGDataCollection.ts"],"names":[],"mappings":"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","sourcesContent":["import {ApplicationException, Debug, List, StringBuilder} from \"@magic-xpa/mscorelib\";\r\nimport {InternalInterface, XMLConstants} from \"@magic-xpa/utils\";\r\nimport {Commands, ITask, MgFormBase} from \"@magic-xpa/gui\";\r\nimport {MGData} from \"./MGData\";\r\nimport {FlowMonitorQueue} from \"../util/FlowMonitorQueue\";\r\nimport {Task} from \"./Task\"\r\nimport {DataView} from \"../data/DataView\"\r\nimport {IMGDataCollection} from \"./IMGDataCollection\";\r\nimport {CommandsTable} from \"../CommandsTable\";\r\nimport {LastFocusedManager} from \"../rt/LastFocusedManager\";\r\nimport {CommandsProcessorBase_SendingInstruction, CommandsProcessorBase_SessionStage} from \"../CommandsProcessorBase\";\r\nimport {IClientCommand} from \"../commands/IClientCommand\";\r\nimport {Expression} from \"../exp/Expression\";\r\nimport {CommandsProcessorManager} from \"../CommandsProcessorManager\";\r\nimport {AccessHelper} from \"../AccessHelper\";\r\nimport {ConstInterface} from \"../ConstInterface\";\r\n\r\n/// <summary>\r\n///   this class handles a table of MGData objects\r\n/// </summary>\r\n// @dynamic\r\nexport class MGDataCollection implements IMGDataCollection {\r\n  private static _instance: MGDataCollection = null;      // singleton\r\n  private _mgDataTab: List<MGData> = new List<MGData>();\r\n\r\n  // the current MGDATA\r\n  private _iteratorMgdIdx: number = 0;\r\n  private _iteratorTaskIdx: number = 0;\r\n  currMgdID: number = 0;\r\n  StartupMgData: MGData = null;\r\n\r\n  private _lastRouteSentToServer: string = \"\";\r\n\r\n  /// <summary>\r\n  /// singleton\r\n  /// </summary>\r\n  constructor() {\r\n  }\r\n\r\n  /// <summary>\r\n  ///   searches all the MGData objects till it finds the task with the given id\r\n  /// </summary>\r\n  /// <param name = \"id\">the id of the requested task</param>\r\n  GetTaskByID(id: string): ITask {\r\n    let task: Task = null;\r\n\r\n    for (let i: number = 0; i < this.getSize() && task == null; i++) {\r\n      let mgd: MGData = this.getMGData(i);\r\n\r\n      if (mgd == null)\r\n      // the window connected to the MGData was closed\r\n        continue;\r\n\r\n      task = mgd.getTask(id);\r\n    }\r\n\r\n    return task;\r\n  }\r\n\r\n  /// <summary>\r\n  /// singleton\r\n  /// </summary>\r\n  static get Instance(): MGDataCollection {\r\n    if (MGDataCollection._instance == null) {\r\n        if (MGDataCollection._instance == null)\r\n          MGDataCollection._instance = new MGDataCollection();\r\n    }\r\n\r\n    return MGDataCollection._instance;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   add MGData object to the table\r\n  /// </summary>\r\n  /// <param name = \"mgd\">the MGData object to add</param>\r\n  /// <param name = \"idx\">the index within the table for the new MGData</param>\r\n  async addMGData(mgd: MGData, idx: number, isStartup: boolean): Promise<void> {\r\n    if (idx < 0 || idx > this.getSize())\r\n      throw new ApplicationException(\"Illegal MGData requested\");\r\n\r\n    if (isStartup)\r\n      this.StartupMgData = mgd;\r\n\r\n    if (idx === this.getSize())\r\n      this._mgDataTab.push(mgd);\r\n    else {\r\n      let oldMgd: MGData = this.getMGData(idx);\r\n\r\n      if (oldMgd != null && !oldMgd.IsAborting) {\r\n        await oldMgd.getFirstTask().stop();\r\n        oldMgd.abort();\r\n      }\r\n\r\n      this._mgDataTab.set_Item(idx, mgd);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns MGData object by its index\r\n  /// </summary>\r\n  getMGData(idx: number): MGData {\r\n    let mgd: MGData = null;\r\n\r\n    if (idx >= 0 && idx < this.getSize()) {\r\n      mgd = this._mgDataTab.get_Item(idx);\r\n    }\r\n\r\n    return mgd;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns available index\r\n  /// </summary>\r\n  getAvailableIdx(): number {\r\n    let i: number;\r\n\r\n    for (i = 0; i < this._mgDataTab.length; i = i + 1) {\r\n      if (this._mgDataTab.get_Item(i) === null)\r\n        break;\r\n    }\r\n\r\n    return i;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the index of MGData in MGDataTable\r\n  /// </summary>\r\n  /// <param name = \"mgd\">to find into table</param>\r\n  getMgDataIdx(mgd: MGData): number {\r\n    return this._mgDataTab.indexOf(mgd);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   free memory from unneeded MGData and its descendant MGDs\r\n  /// </summary>\r\n  /// <param name = \"index\">number of MGData/window to be deleted</param>\r\n  /// <returns></returns>\r\n  deleteMGDataTree(index: number): void {\r\n    let mgd: MGData, childMgd;\r\n    let i: number;\r\n\r\n    if (index < 0 || index >= this.getSize())\r\n      throw new ApplicationException(\"in deleteMGData() illegal index: \" + index);\r\n\r\n    mgd = this.getMGData(index);\r\n    if (mgd != null) {\r\n      // TODO: when closing a frameset we should clear the MGDs of the frames\r\n      // from the MGDTab\r\n      if (index > 0 && mgd.getParentMGdata() != null) {\r\n        this._mgDataTab.set_Item(index, null);\r\n      }\r\n      LastFocusedManager.Instance.clean(index);\r\n\r\n      for (i = 0; i < this.getSize(); i++) {\r\n        childMgd = this.getMGData(i);\r\n        if (childMgd != null && childMgd.getParentMGdata() === mgd)\r\n          this.deleteMGDataTree(i);\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the current MGData\r\n  /// </summary>\r\n  /// <returns> MGData object</returns>\r\n  getCurrMGData(): MGData {\r\n    return this.getMGData(this.currMgdID);\r\n  }\r\n\r\n  GetMainProgByCtlIdx(contextIDOrCtlIdx: any, ctlIdx?: number): Task {\r\n    if (arguments.length === 2)\r\n      return this.GetMainProgByCtlIdx_0(ctlIdx);\r\n    else\r\n      return this.GetMainProgByCtlIdx_1(contextIDOrCtlIdx);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   searches all the MGData objects till it finds a main program with the given ctl idx\r\n  /// </summary>\r\n  /// <param name = \"contextID\"></param>\r\n  /// <param name = \"ctlIdx\">the idx of the requested component</param>\r\n  private GetMainProgByCtlIdx_0( ctlIdx: number): Task {\r\n    let task: Task = null;\r\n\r\n    for (let i: number = 0; i < this.getSize() && task == null; i++) {\r\n      let mgd: MGData = this.getMGData(i);\r\n\r\n      if (mgd == null)\r\n        // the window connected to the MGData was closed\r\n        continue;\r\n\r\n      task = mgd.getMainProg(ctlIdx);\r\n    }\r\n\r\n    return task;\r\n  }\r\n\r\n  private GetMainProgByCtlIdx_1(ctlIdx: number): Task {\r\n    return this.GetMainProgByCtlIdx(-1, ctlIdx);    // TODO (-1): RC is unaware to context ids at the moment\r\n  }\r\n\r\n  /// <summary>\r\n  ///   start the tasks iterator\r\n  /// </summary>\r\n  startTasksIteration(): void {\r\n    this._iteratorMgdIdx = 0;\r\n    this._iteratorTaskIdx = 0;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the next task using the tasks iterator\r\n  /// </summary>\r\n  getNextTask(): ITask {\r\n    let task: Task;\r\n\r\n    let mgd: MGData = this.getMGData(this._iteratorMgdIdx);\r\n    if (mgd == null)\r\n      return null;\r\n\r\n    task = mgd.getTask(this._iteratorTaskIdx);\r\n\r\n    if (task == null) {\r\n      do {\r\n        this._iteratorMgdIdx++;\r\n      }\r\n      while (this._iteratorMgdIdx < this.getSize() && this.getMGData(this._iteratorMgdIdx) == null);\r\n      this._iteratorTaskIdx = 0;\r\n      return this.getNextTask();\r\n    }\r\n\r\n    this._iteratorTaskIdx++;\r\n    return task;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   build XML string of the MGDataTABLE object,\r\n  ///   ALL MGData in the table\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    let lastRoute: string = Commands.getLastRoute();\r\n    // optimization: Do not send the lastRoute, if it is the same which was last sent to the server\r\n    if (lastRoute !== this._lastRouteSentToServer) {\r\n      message.Append(XMLConstants.START_TAG + ConstInterface.MG_TAG_LAST_ROUTE);\r\n      message.Append(\" \" + ConstInterface.MG_ATTR_ENV_VALUE + \"=\\\"\" + lastRoute + \"\\\"\");\r\n      message.Append(XMLConstants.TAG_TERM);\r\n\r\n      this._lastRouteSentToServer = lastRoute;\r\n    }\r\n\r\n    for (let i: number = 0; i < this.getSize(); i = i + 1) {\r\n      let mgd: MGData = this.getMGData(i);\r\n\r\n      if (mgd !== null && !mgd.IsAborting) {\r\n        await mgd.buildXML(message, serializeTasks);\r\n      }\r\n    }\r\n\r\n    FlowMonitorQueue.Instance.buildXML(message);\r\n  }\r\n\r\n\r\n\r\n  /// <summary>\r\n  ///   get size of MGData table\r\n  /// </summary>\r\n  /// <returns> size of table</returns>\r\n  getSize(): number {\r\n    return this._mgDataTab.length;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   perform any data error recovery action on all dataviews\r\n  /// </summary>\r\n  async processRecovery(): Promise<void> {\r\n    for (let i: number = 0; i < this.getSize(); i = i + 1) {\r\n      let mgd: MGData = this.getMGData(i);\r\n\r\n      if (mgd !== null) {\r\n        for (let j: number = 0; j < mgd.getTasksCount(); j = j + 1) {\r\n          let task: Task = mgd.getTask(j);\r\n          if (task !== null)\r\n            await (<DataView>task.DataView).processRecovery();\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   find all tasks which were triggered by a specific task\r\n  /// </summary>\r\n  /// <param name = \"triggeringTask\">the task who triggered all other tasks.</param>\r\n  /// <returns> vector containing all tasks which were triggered by the parameter task</returns>\r\n  getTriggeredTasks(triggeringTask: Task): List<Task> {\r\n    let list: List<Task> = new List<Task>();\r\n    let task: Task;\r\n    let tag: string = triggeringTask.getTaskTag();\r\n\r\n    this.startTasksIteration();\r\n\r\n    while ((task = <Task>this.getNextTask()) !== null) {\r\n      if (tag === task.PreviouslyActiveTaskId)\r\n        list.push(task);\r\n    }\r\n\r\n    return list;\r\n  }\r\n\r\n  /// <summary>\r\n  /// returns task list according to the predicate\r\n  /// </summary>\r\n  /// <param name=\"p\"></param>\r\n  /// <returns></returns>\r\n  GetTasks(p: (obj: Task) => boolean): List<Task> {\r\n    let taskList: List<Task> = new List<Task>();\r\n\r\n    this._mgDataTab.forEach(mgd => {\r\n      if (mgd !== null && !mgd.IsAborting) {\r\n        for (let i: number = 0; i < mgd.getTasksCount(); i = i + 1) {\r\n          let task: Task = mgd.getTask(i);\r\n          if (task !== null && p(task)) {\r\n            taskList.push(task);\r\n          }\r\n        }\r\n      }\r\n    });\r\n\r\n    return taskList;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   this method returns the current id of a task according to its original id\r\n  ///   it will usually return the same id as sent to it, but for subform after error and retry it will\r\n  ///   convert the original id to the current.\r\n  /// </summary>\r\n  /// <param name = \"taskId\">- original task id</param>\r\n  /// <returns> the current taskid for this task</returns>\r\n  getTaskIdById(taskId: string): string {\r\n    // QCR #980454 - the task id may change during the task's lifetime, so taskId might\r\n    // be holding the old one - find the task and refetch its current ID.\r\n    let task: ITask = this.GetTaskByID(taskId);\r\n    let tag: string = taskId;\r\n\r\n    if (task != null)\r\n      tag = task.getTaskTag();\r\n\r\n    return tag;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return all top level forms that exist\r\n  /// </summary>\r\n  GetTopMostForms(): List<MgFormBase> {\r\n    let task: Task;\r\n    let forms = new List<MgFormBase>();\r\n\r\n    // move on the tasks and add the forms to the arrayList\r\n    this.startTasksIteration();\r\n\r\n    while ((task = <Task>this.getNextTask()) != null) {\r\n      let form: MgFormBase = task.getForm();\r\n\r\n      if (!task.isAborting() && form != null && !form.isSubForm())\r\n        forms.push(form);\r\n    }\r\n    return forms;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Gets the MGData that holds/should hold the startup program.\r\n  /// The method takes into consideration whether the application uses MDI or not.\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  GetMGDataForStartupProgram(): MGData {\r\n    Debug.Assert(this._mgDataTab.length > 0, \"The main program must be processed before invoking this method.\");\r\n\r\n    let mainProgByCtlIdx: Task = this.GetMainProgByCtlIdx(0);\r\n    Debug.Assert(mainProgByCtlIdx !== null, \"The main program must be processed before invoking this method.\");\r\n\r\n    Debug.Assert(mainProgByCtlIdx.getMgdID() === 0, \"Main program is expected to be on MGData 0. Is this an error?\");\r\n\r\n    // if the main program does not have MDI frame, the startup MGData index is 0.\r\n    return this._mgDataTab.get_Item(0);\r\n  }\r\n\r\n\r\n\r\n  /// <summary>\r\n  /// Add command, execute request and do record cycle for subforms that the server sent their new dataview\r\n  /// </summary>\r\n  /// <param name=\"cmdsToServer\"></param>\r\n  /// <param name=\"cmdToServer\">additional command to the Server</param>\r\n  async execRequestWithSubformRecordCycle(cmdsToServer: CommandsTable, cmdToServer: IClientCommand, exp: Expression): Promise<void> {\r\n    this.cleanDoSubformPrefixSuffix();\r\n    cmdsToServer.Add(cmdToServer);\r\n\r\n    // Avoid immediate execution of server operation during browser close to allow closing of context later by sending BrowserEsc command to server.\r\n    if(!(MGDataCollection.Instance.StartupMgData.getFirstTask().InEndTask && MGDataCollection.Instance.StartupMgData.getFirstTask().ClosingFormUI))\r\n      await CommandsProcessorManager.GetCommandsProcessor().Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS, CommandsProcessorBase_SessionStage.NORMAL, exp);\r\n\r\n    await this.execAllSubformRecordCycle();\r\n  }\r\n\r\n  /// <summary> Clean flag for Subform record cycle </summary>\r\n  cleanDoSubformPrefixSuffix(): void {\r\n    for (let i: number = 0; i < this.getSize(); i++) {\r\n      let mgd: MGData = this.getMGData(i);\r\n\r\n      if (mgd === null || mgd.IsAborting)\r\n        continue;\r\n\r\n      let tasksCount: number = mgd.getTasksCount();\r\n      for (let j: number = 0; j < tasksCount; j++) {\r\n        let task: Task = mgd.getTask(j);\r\n        task.DoSubformPrefixSuffix = false;\r\n      }\r\n    }\r\n  }\r\n\r\n\r\n  /// <summary> Execute Record cycle for all subforms that their flag is on </summary>\r\n  async execAllSubformRecordCycle(): Promise<void> {\r\n\r\n    for (let i: number = 0; i < this.getSize(); i = i + 1) {\r\n      let mgd: MGData = this.getMGData(i);\r\n\r\n      if (mgd === null || mgd.IsAborting)\r\n        continue;\r\n\r\n      let tasksCount: number = mgd.getTasksCount();\r\n      for (let j: number = 0; j < tasksCount; j = j + 1) {\r\n        let task: Task = mgd.getTask(j);\r\n        if (task.IsSubForm && task.DoSubformPrefixSuffix) {\r\n          // In the record prefix of the current task (commonHandlerBefore) we execute record prefix of all fathers.\r\n          // But when we return from the server we do not need it. So we prevent father record prefix execution.\r\n          task.PerformParentRecordPrefix = false;\r\n          AccessHelper.eventsManager.pushNewExecStacks();\r\n          await AccessHelper.eventsManager.handleInternalEventWithTaskAndSubformRefresh(task, InternalInterface.MG_ACT_REC_PREFIX, true);\r\n\r\n          if (!AccessHelper.eventsManager.GetStopExecutionFlag())\r\n            await AccessHelper.eventsManager.handleInternalEventWithTask(task, InternalInterface.MG_ACT_REC_SUFFIX);\r\n\r\n          AccessHelper.eventsManager.popNewExecStacks();\r\n          task.PerformParentRecordPrefix = true;\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n}\r\n"]}

package/esm2022/src/tasks/RCTimer.mjs

@@ -0,0 +1,63 @@
+import { Dictionary, List } from '@magic-xpa/mscorelib';
+import { MgTimer } from '@magic-xpa/gui';
+class TimerObjectCollection {
+    static MgDataToTimerObjList = new Dictionary();
+}
+export class RCTimer extends MgTimer {
+    _mgData = null;
+    _isIdle = false;
+    get TimerIntervalMiliSeconds() {
+        return this._timerIntervalMilliSeconds;
+    }
+    set IsIdleTimer(value) {
+        this._isIdle = value;
+    }
+    get IsIdleTimer() {
+        return this._isIdle;
+    }
+    constructor(mgData, milliseconds, isIdle) {
+        super(milliseconds);
+        this._mgData = mgData;
+        this.IsIdleTimer = isIdle;
+        let mgDataId = this._mgData.GetId().toString();
+        if (!TimerObjectCollection.MgDataToTimerObjList.ContainsKey(mgDataId))
+            TimerObjectCollection.MgDataToTimerObjList.Add(mgDataId, new List());
+        TimerObjectCollection.MgDataToTimerObjList.get_Item(mgDataId).push(this);
+    }
+    GetMgdata() {
+        return this._mgData;
+    }
+    static StopTimer(mgData, milliseconds, isIdle) {
+        let timers = null;
+        let timer = null;
+        let mgDataId = mgData.GetId().toString();
+        if (TimerObjectCollection.MgDataToTimerObjList.ContainsKey(mgDataId)) {
+            timers = TimerObjectCollection.MgDataToTimerObjList.get_Item(mgDataId);
+            timer = timers.find(rcTimer => {
+                return (rcTimer !== null) && (rcTimer._timerIntervalMilliSeconds === milliseconds && rcTimer._isIdle === isIdle);
+            });
+            if (timer != null) {
+                timer.Stop();
+                timers.Remove(timer);
+            }
+            if (timers.length === 0)
+                TimerObjectCollection.MgDataToTimerObjList.Remove(mgDataId);
+        }
+    }
+    static StopAll(mgData) {
+        let timers = null;
+        let mgDataId = mgData.GetId().toString();
+        if (TimerObjectCollection.MgDataToTimerObjList.ContainsKey(mgDataId))
+            timers = TimerObjectCollection.MgDataToTimerObjList.get_Item(mgDataId);
+        if (timers !== null) {
+            timers.forEach(rcTimer => {
+                if (rcTimer !== null) {
+                    rcTimer.Stop();
+                }
+            });
+            timers.Clear();
+            TimerObjectCollection.MgDataToTimerObjList.Remove(mgDataId);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/tasks/RemoteTaskService.mjs

@@ -0,0 +1,45 @@
+import { TaskServiceBase } from './TaskServiceBase';
+import { ReturnResult } from '../util/ReturnResult';
+import { MsgInterface, WindowType } from '@magic-xpa/utils';
+export class RemoteTaskService extends TaskServiceBase {
+    constructor() {
+        super();
+    }
+    GetTaskTag(defaultValue) {
+        return defaultValue;
+    }
+    GetDataviewManagerForVirtuals(task) {
+        return task.DataviewManager.RemoteDataviewManager;
+    }
+    PrepareTask(task) {
+        task.DataViewWasRetrieved = true;
+        let result = super.PrepareTask(task);
+        if (task.getMGData().IsModal && task.getForm() !== null) {
+            task.getForm().ConcreteWindowType = WindowType.Overlay;
+        }
+        return result;
+    }
+    GetEventTaskId(originalTaskId) {
+        return originalTaskId;
+    }
+    ShouldEvaluatePropertyLocally(propId) {
+        return false;
+    }
+    InitTaskPrefixExecutedFlag(task) {
+        task.TaskPrefixExecuted = true;
+    }
+    RemoveRecomputes(parentTask) {
+        parentTask.DataView.GetFieldsTab().resetRecomp();
+    }
+    GetOwnerTransactionTask(task) {
+        let OwnerTransactionTask = task;
+        if (task.DataviewManager.RemoteDataviewManager.Transaction !== null)
+            OwnerTransactionTask = task.DataviewManager.RemoteDataviewManager.Transaction.OwnerTask;
+        return OwnerTransactionTask;
+    }
+    static async PreparePropMainDisplay(task) {
+        await task.ComputeMainDisplay();
+        return task.FormIsLegal() ? ReturnResult.SuccessfulResult : new ReturnResult(MsgInterface.BRKTAB_STR_ERR_FORM);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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