@magic-xpa/engine 4.1100.0-dev4110.99 → 4.1101.0-dev4111.271

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/{esm2020 → esm2022}/src/tasks/RemoteTaskService.mjs

@@ -1,45 +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);
-    }
-}
+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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