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

package/esm2022/src/commands/ServerToClient/OpenURLCommand.mjs

@@ -0,0 +1,221 @@
+import { Debug, Int32, List, NString } from "@magic-xpa/mscorelib";
+import { InternalInterface, XMLConstants, XmlParser } from "@magic-xpa/utils";
+import { ClientTargetedCommandBase } from "./ClientTargetedCommandBase";
+import { ArgumentsList } from "../../rt/ArgumentsList";
+import { MGData } from "../../tasks/MGData";
+import { MgControl } from "../../gui/MgControl";
+import { OpeningTaskDetails } from "../../tasks/TaskBase";
+import { ConstInterface } from "../../ConstInterface";
+import { LastFocusedManager } from "../../rt/LastFocusedManager";
+import { RemoteCommandsProcessor } from "../../remote/RemoteCommandsProcessor";
+import { Task } from "../../tasks/Task";
+import { AccessHelper } from "../../AccessHelper";
+import { MgControlType } from "@magic-xpa/utils";
+import { RunTimeEvent } from '../../event/RunTimeEvent';
+export class OpenURLCommand extends ClientTargetedCommandBase {
+    _callingTaskTag = null;
+    _pathParentTaskTag = null;
+    _subformCtrlName = null;
+    _ditIdx = Int32.MinValue;
+    _isModal = true;
+    _transOwner = null;
+    _newId = null;
+    _forceModal = false;
+    _key = null;
+    _varList = null;
+    _isRoute = false;
+    NewTaskXML = null;
+    static createNewCommandsTable = null;
+    constructor() {
+        super();
+    }
+    get IsBlocking() {
+        return this._isModal && this._subformCtrlName === null;
+    }
+    async Execute(res) {
+        let mgd = null;
+        let destinationSubformSucceeded = false;
+        let refreshWhenHidden = true;
+        let mgdID = 0;
+        let subformCtrl = null;
+        let oldTimers = new List(), newTimers = new List();
+        let moveToFirstControl = true;
+        let guiParentTask;
+        let guiParentMgData = null;
+        let callingTask = (this._callingTaskTag != null ? AccessHelper.mgDataTable.GetTaskByID(this._callingTaskTag) : null);
+        let pathParentTask = (this._pathParentTaskTag != null ? AccessHelper.mgDataTable.GetTaskByID(this._pathParentTaskTag) : null);
+        guiParentTask = callingTask = AccessHelper.mgDataTable.GetTaskByID(this._callingTaskTag);
+        if ((!NString.IsNullOrEmpty(this._subformCtrlName)) || (this._ditIdx !== Int32.MinValue) || this._isRoute) {
+            if (this._isRoute && NString.IsNullOrEmpty(this._subformCtrlName.trim())) {
+                subformCtrl = callingTask.getForm().DefaultRouterOutlet;
+            }
+            else {
+                if (!callingTask.IsInteractive) {
+                    for (let parentTask = callingTask; parentTask.getForm() != null; parentTask = parentTask.getParent()) {
+                        subformCtrl = parentTask.getForm().getCtrlByName(this._subformCtrlName, MgControlType.CTRL_TYPE_SUBFORM);
+                        if (subformCtrl != null) {
+                            callingTask = guiParentTask = parentTask;
+                            break;
+                        }
+                    }
+                }
+                else
+                    subformCtrl = (this._ditIdx !== Int32.MinValue ? callingTask.getForm().getCtrl(this._ditIdx) : callingTask.getForm().getSubFormCtrlByName(this._subformCtrlName));
+            }
+        }
+        if (callingTask != null)
+            mgd = callingTask.getMGData();
+        if (subformCtrl != null) {
+            let subformTask = subformCtrl.getSubformTask();
+            guiParentTask = subformCtrl.getForm().getTask();
+            mgdID = guiParentTask.getMgdID();
+            guiParentMgData = guiParentTask.getMGData();
+            if (guiParentMgData.getTimerHandlers() != null)
+                oldTimers = guiParentMgData.getTimerHandlers().getTimersVector();
+            if (this._ditIdx !== Int32.MinValue) {
+                refreshWhenHidden = false;
+                moveToFirstControl = false;
+            }
+            else {
+                destinationSubformSucceeded = true;
+                if (this._transOwner != null) {
+                    let newTransOwnerTask = AccessHelper.mgDataTable.GetTaskByID(this._transOwner);
+                    if (newTransOwnerTask != null)
+                        newTransOwnerTask.setTransOwnerTask();
+                }
+                if (subformTask != null) {
+                    subformTask.setDestinationSubform(true);
+                    await subformTask.stop();
+                }
+                if (!MgControl.validReturnToCtrl())
+                    MgControl.ReturnToCtrl = LastFocusedManager.getLastFocusedControl();
+            }
+            subformCtrl.setSubformTaskId(this._newId);
+        }
+        let parentMgData;
+        if (callingTask == null)
+            parentMgData = AccessHelper.mgDataTable.getMGData(0);
+        else
+            parentMgData = callingTask.getMGData();
+        if (!destinationSubformSucceeded && refreshWhenHidden) {
+            mgdID = AccessHelper.mgDataTable.getAvailableIdx();
+            Debug.Assert(mgdID > 0);
+            mgd = new MGData(OpenURLCommand.createNewCommandsTable(), OpenURLCommand.createNewCommandsTable(), mgdID, parentMgData, this._isModal, this._forceModal);
+            mgd.copyUnframedCmds();
+            await AccessHelper.mgDataTable.addMGData(mgd, mgdID, false);
+            AccessHelper.mgDataTable.currMgdID = mgdID;
+        }
+        this.Obj = this._key;
+        this._key = null;
+        try {
+            await RemoteCommandsProcessor.GetInstance().ProcessResponse(this.NewTaskXML, mgdID, new OpeningTaskDetails(callingTask, pathParentTask), null);
+        }
+        finally {
+            AccessHelper.eventsManager.setIgnoreUnknownAbort(false);
+        }
+        if (destinationSubformSucceeded || !refreshWhenHidden) {
+            subformCtrl.initSubformTask();
+            if (destinationSubformSucceeded) {
+                let subformTask = subformCtrl.getSubformTask();
+                moveToFirstControl = !callingTask.RetainFocus;
+                subformTask.setIsDestinationCall(true);
+            }
+        }
+        let isSubformModal = false;
+        let prevMgDataIsModal = mgd.IsModal;
+        if (subformCtrl != null) {
+            if (guiParentMgData.getTimerHandlers() != null)
+                newTimers = guiParentMgData.getTimerHandlers().getTimersVector();
+            guiParentMgData.changeTimers(oldTimers, newTimers);
+            if (subformCtrl.IsModal())
+                this._isModal = isSubformModal = mgd.IsModal = true;
+        }
+        let nonInteractiveTask = await Task.StartProgram(destinationSubformSucceeded, moveToFirstControl);
+        if (!isSubformModal)
+            this._isModal = mgd.IsModal;
+        if (nonInteractiveTask == null) {
+            if (callingTask != null && ((this._isModal && (isSubformModal || !destinationSubformSucceeded) && refreshWhenHidden) || (!callingTask.IsInteractive && (!callingTask.isMainProg() || callingTask.getForm() == null)))) {
+                if (this._isModal) {
+                    AccessHelper.mgDataTable.startTasksIteration();
+                    let task;
+                    while ((task = AccessHelper.mgDataTable.getNextTask()) !== null) {
+                        let dataViewWasRetrieved = task.DataViewWasRetrieved;
+                        if (dataViewWasRetrieved) {
+                            await task.RefreshDisplay();
+                        }
+                    }
+                }
+                await AccessHelper.eventsManager.EventsLoop(mgd);
+                if (isSubformModal) {
+                    mgd.IsAborting = false;
+                    mgd.IsModal = prevMgDataIsModal;
+                }
+            }
+        }
+        else
+            await AccessHelper.eventsManager.NonInteractiveEventsLoop(mgd, nonInteractiveTask);
+        if (AccessHelper.eventsManager.getPendingGuiEvent() != null && (isSubformModal || nonInteractiveTask != null)) {
+            let guiEvent = AccessHelper.eventsManager.getPendingGuiEvent();
+            if (guiEvent.getTask() != callingTask || this._callingTaskTag !== callingTask.getTaskTag()) {
+                callingTask = AccessHelper.mgDataTable.GetTaskByID(this._callingTaskTag);
+                if (callingTask.getIsDestinationCall()) {
+                    let subformCtrl = callingTask.getForm().getSubFormCtrl();
+                    await AccessHelper.eventsManager.performSubformClose(subformCtrl);
+                }
+                else {
+                    let rtEvt = new RunTimeEvent(callingTask);
+                    rtEvt.setInternal(InternalInterface.MG_ACT_CLOSE);
+                    rtEvt.setCtrl(null);
+                    rtEvt.setArgList(null);
+                    AccessHelper.eventsManager.addToTail(rtEvt);
+                }
+            }
+            else {
+                AccessHelper.eventsManager.addToTail(guiEvent);
+                AccessHelper.eventsManager.setPendingGuiEvent(null);
+            }
+        }
+    }
+    HandleAttribute(attribute, value) {
+        switch (attribute) {
+            case ConstInterface.MG_ATTR_CALLINGTASK:
+                this._callingTaskTag = value;
+                break;
+            case ConstInterface.MG_ATTR_PATH_PARENT_TASK:
+                this._pathParentTaskTag = value;
+                break;
+            case ConstInterface.MG_ATTR_SUBFORM_CTRL:
+                this._subformCtrlName = value;
+                break;
+            case XMLConstants.MG_ATTR_DITIDX:
+                this._ditIdx = XmlParser.getInt(value);
+                break;
+            case ConstInterface.MG_ATTR_MODAL:
+                this._isModal = (value[0] === '1');
+                break;
+            case ConstInterface.MG_ATTR_TRANS_OWNER:
+                this._transOwner = value;
+                break;
+            case ConstInterface.MG_ATTR_NEWID:
+                this._newId = NString.TrimEnd(value);
+                break;
+            case ConstInterface.MG_ATTR_KEY:
+                this._key = value;
+                break;
+            case ConstInterface.MG_ATTR_ARGLIST:
+                this._varList = new ArgumentsList();
+                this._varList.fillList(value, AccessHelper.mgDataTable.GetTaskByID(this.TaskTag));
+                break;
+            case ConstInterface.MG_ATTR_OBJECT:
+                this.Obj = value;
+                break;
+            case ConstInterface.MG_ATTR_IS_ROUTE:
+                this._isRoute = (value[0] === '1');
+                break;
+            default:
+                super.HandleAttribute(attribute, value);
+                break;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"OpenURLCommand.js","sourceRoot":"","sources":["../../../../../../../projects/engine/src/commands/ServerToClient/OpenURLCommand.ts"],"names":[],"mappings":"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","sourcesContent":["import {Debug, Int32, List, NString} from \"@magic-xpa/mscorelib\";\r\nimport {InternalInterface, XMLConstants, XmlParser} from \"@magic-xpa/utils\";\r\nimport {ClientTargetedCommandBase} from \"./ClientTargetedCommandBase\";\r\nimport {ArgumentsList} from \"../../rt/ArgumentsList\";\r\nimport {MGData} from \"../../tasks/MGData\";\r\nimport {MgControl} from \"../../gui/MgControl\";\r\nimport {MgForm} from \"../../gui/MgForm\";\r\nimport {OpeningTaskDetails} from \"../../tasks/TaskBase\";\r\nimport { TaskBase} from \"../../tasks/TaskBase\";\r\nimport {ConstInterface} from \"../../ConstInterface\";\r\nimport {IResultValue} from \"../../rt/IResultValue\";\r\nimport { LastFocusedManager } from \"../../rt/LastFocusedManager\";\r\nimport { RemoteCommandsProcessor } from \"../../remote/RemoteCommandsProcessor\";\r\nimport { Task } from \"../../tasks/Task\";\r\nimport { AccessHelper } from \"../../AccessHelper\";\r\nimport {MgControlType} from \"@magic-xpa/utils\";\r\nimport {RunTimeEvent} from '../../event/RunTimeEvent';\r\n\r\n\r\nexport class OpenURLCommand extends ClientTargetedCommandBase {\r\n  private _callingTaskTag: string = null;  // is the id of the task that called the new window\r\n  private _pathParentTaskTag: string = null; // is the id of path parent task tag\r\n  private _subformCtrlName: string = null; // Subform control name for Destination Subform\r\n  private _ditIdx: number = Int32.MinValue;\r\n  private _isModal: boolean = true; // Y|N\r\n  private _transOwner: string = null;\r\n  private _newId: string = null;\r\n  private _forceModal: boolean = false;\r\n  private _key: string = null;\r\n  private _varList: ArgumentsList = null;\r\n  private _isRoute: boolean = false; // Y|N\r\n  NewTaskXML: string = null;\r\n  static createNewCommandsTable = null;\r\n\r\n  constructor() {\r\n    super();\r\n  }\r\n\r\n  get IsBlocking(): boolean {\r\n    return this._isModal && this._subformCtrlName === null;\r\n  }\r\n\r\n  async Execute(res: IResultValue): Promise<void> {\r\n    let mgd: MGData = null;\r\n    let destinationSubformSucceeded: boolean = false;\r\n    let refreshWhenHidden: boolean = true;\r\n    let mgdID: number = 0;\r\n    let subformCtrl: MgControl = null;\r\n    let oldTimers: List<number> = new List<number>(), newTimers = new List<number>();\r\n    let moveToFirstControl: boolean = true;\r\n    let guiParentTask: TaskBase;\r\n    let guiParentMgData: MGData = null;\r\n    let callingTask: TaskBase = (this._callingTaskTag != null ? <TaskBase>AccessHelper.mgDataTable.GetTaskByID(this._callingTaskTag) : null);\r\n    let pathParentTask: TaskBase = (this._pathParentTaskTag != null ? <TaskBase>AccessHelper.mgDataTable.GetTaskByID(this._pathParentTaskTag) : null);\r\n\r\n    // When a nonOffline task was called from an Offline task (of course via MP event),\r\n    // the calling task id was not sent to the server because the server is unaware of the\r\n    // offline task. So, when coming back from the server, assign the correct calling task.\r\n    // TaskBase lastFocusedTask = ClientManager.Instance.getLastFocusedTask();\r\n    // if (lastFocusedTask != null && lastFocusedTask.IsOffline)\r\n    //   _callingTaskTag = lastFocusedTask.getTaskTag();\r\n\r\n    guiParentTask = callingTask = <TaskBase>AccessHelper.mgDataTable.GetTaskByID(this._callingTaskTag);\r\n\r\n    // ditIdx is send by server only for subform opening for refreshWhenHidden\r\n    if ((!NString.IsNullOrEmpty(this._subformCtrlName)) || (this._ditIdx !== Int32.MinValue) || this._isRoute) {\r\n      if (this._isRoute && NString.IsNullOrEmpty(this._subformCtrlName.trim())) {\r\n        subformCtrl = <MgControl>callingTask.getForm().DefaultRouterOutlet;\r\n      }\r\n      else {\r\n        if (!callingTask.IsInteractive) {\r\n          for (let parentTask: TaskBase = callingTask; parentTask.getForm() != null; parentTask = parentTask.getParent()) {\r\n            subformCtrl = <MgControl>parentTask.getForm().getCtrlByName(this._subformCtrlName, MgControlType.CTRL_TYPE_SUBFORM);\r\n            if (subformCtrl != null) {\r\n                callingTask = guiParentTask = parentTask;\r\n              break;\r\n            }\r\n          }\r\n        }\r\n        else\r\n          subformCtrl = (this._ditIdx !== Int32.MinValue ? <MgControl>callingTask.getForm().getCtrl(this._ditIdx) : (<MgForm>callingTask.getForm()).getSubFormCtrlByName(this._subformCtrlName));\r\n      }\r\n    }\r\n\r\n    if (callingTask != null)\r\n      mgd = callingTask.getMGData();\r\n\r\n    if (subformCtrl != null) {\r\n      let subformTask: TaskBase = <TaskBase>subformCtrl.getSubformTask();\r\n      guiParentTask = <TaskBase>subformCtrl.getForm().getTask();\r\n      mgdID = guiParentTask.getMgdID();\r\n      guiParentMgData = guiParentTask.getMGData();\r\n      if (guiParentMgData.getTimerHandlers() != null)\r\n        oldTimers = guiParentMgData.getTimerHandlers().getTimersVector();\r\n\r\n      if (this._ditIdx !== Int32.MinValue) { // for refresh when hidden\r\n        refreshWhenHidden = false;\r\n        moveToFirstControl = false;\r\n      }\r\n      else { // for destination\r\n        destinationSubformSucceeded = true;\r\n        // Pass transaction ownership\r\n        if (this._transOwner != null) {\r\n          let newTransOwnerTask = <TaskBase>AccessHelper.mgDataTable.GetTaskByID(this._transOwner);\r\n          if (newTransOwnerTask != null)\r\n            newTransOwnerTask.setTransOwnerTask();\r\n        }\r\n        if (subformTask != null) {\r\n          subformTask.setDestinationSubform(true);\r\n          await subformTask.stop();\r\n        }\r\n        if (!MgControl.validReturnToCtrl())\r\n           MgControl.ReturnToCtrl = LastFocusedManager.getLastFocusedControl();\r\n      }\r\n      subformCtrl.setSubformTaskId(this._newId);\r\n    }\r\n\r\n    let parentMgData: MGData;\r\n    if (callingTask == null)\r\n      parentMgData = AccessHelper.mgDataTable.getMGData(0);\r\n    else\r\n      parentMgData = callingTask.getMGData();\r\n\r\n    if (!destinationSubformSucceeded && refreshWhenHidden) {\r\n      mgdID = AccessHelper.mgDataTable.getAvailableIdx();\r\n      Debug.Assert(mgdID > 0);\r\n      mgd = new MGData( OpenURLCommand.createNewCommandsTable(),\r\n                        OpenURLCommand.createNewCommandsTable(),\r\n                        mgdID, parentMgData, this._isModal, this._forceModal);\r\n      mgd.copyUnframedCmds();\r\n      await AccessHelper.mgDataTable.addMGData(mgd, mgdID, false);\r\n\r\n      AccessHelper.mgDataTable.currMgdID = mgdID;\r\n    }\r\n    this.Obj = this._key;\r\n    this._key = null;\r\n    try {\r\n\r\n      // TODO : check if we need to force GarbageCollection\r\n      // TODO : check this out :  https://stackoverflow.com/questions/27321997/how-to-request-the-garbage-collector-in-node-js-to-run\r\n      // if (GC.GetTotalMemory(false) > 30000000)\r\n      //   GC.Collect();\r\n      await RemoteCommandsProcessor.GetInstance().ProcessResponse(this.NewTaskXML, mgdID, new OpeningTaskDetails(callingTask, pathParentTask), null);\r\n    }\r\n\r\n    finally {\r\n      AccessHelper.eventsManager.setIgnoreUnknownAbort(false);\r\n    }\r\n\r\n    if (destinationSubformSucceeded || !refreshWhenHidden) {\r\n      subformCtrl.initSubformTask();\r\n\r\n      if (destinationSubformSucceeded) {\r\n        let subformTask: TaskBase = <TaskBase>subformCtrl.getSubformTask();\r\n        moveToFirstControl = !callingTask.RetainFocus;\r\n        subformTask.setIsDestinationCall(true);\r\n      }\r\n    }\r\n\r\n    let isSubformModal: boolean = false;\r\n\t  let prevMgDataIsModal = mgd.IsModal;\r\n\r\n    if (subformCtrl != null) {\r\n      if (guiParentMgData.getTimerHandlers() != null)\r\n        newTimers = guiParentMgData.getTimerHandlers().getTimersVector();\r\n      guiParentMgData.changeTimers(oldTimers, newTimers);\r\n\t  if (subformCtrl.IsModal())\r\n\t\tthis._isModal = isSubformModal = mgd.IsModal = true;\r\n    }\r\n    let nonInteractiveTask: TaskBase = await Task.StartProgram(destinationSubformSucceeded, moveToFirstControl);\r\n    // in local tasks, ismodal is calculated after the main display, so we need to update the command member\r\n    if (!isSubformModal)\r\n      this._isModal = mgd.IsModal;\r\n\r\n    // This is because we cannot allow the tasks above it to catch events.\r\n    if (nonInteractiveTask == null) {\r\n      // a non interactive parent will cause the called task to behave like modal by having its own events loop.\r\n      // In case of main program caller (which is flagged as non interactive) we will have a new events loop for the called program\r\n      // if the main program is without a form. If the main prog has a form , then the callee can be included in the main prog loop.\r\n      // if subform is Modal, enter in separate eventloop to get Modality behavior\r\n      if (callingTask != null && ((this._isModal && (isSubformModal || !destinationSubformSucceeded) && refreshWhenHidden) || (!callingTask.IsInteractive && (!callingTask.isMainProg() || callingTask.getForm() == null)))) {\r\n        if (this._isModal) {\r\n          // refresh all tasks data before opening modal window. Because once the window is opened, parent task's\r\n          // data will not be refreshed until the modal window is closed and modal window task will not get the latest\r\n          // parent data.\r\n\r\n          AccessHelper.mgDataTable.startTasksIteration();\r\n            let task: TaskBase;\r\n            while ((task = <TaskBase>AccessHelper.mgDataTable.getNextTask()) !== null) {\r\n              let dataViewWasRetrieved: boolean = task.DataViewWasRetrieved;\r\n              if (dataViewWasRetrieved) {\r\n                await task.RefreshDisplay();\r\n              }\r\n            }\r\n          }\r\n          await AccessHelper.eventsManager.EventsLoop(mgd);\r\n\r\n          //after closing modal subform atsk, it comes out of event loop , set mgd.IsAborting= false.\r\n          //re-store mgd.IsModal back to it's original value.\r\n          if (isSubformModal)\r\n          {\r\n            mgd.IsAborting = false;\r\n            mgd.IsModal = prevMgDataIsModal;\r\n          }\r\n      }\r\n    }\r\n    else\r\n      await AccessHelper.eventsManager.NonInteractiveEventsLoop(mgd, nonInteractiveTask);\r\n\r\n    // if there is pending event which caused closure of modal subform, add it in queue now.\r\n    if (AccessHelper.eventsManager.getPendingGuiEvent()!= null && (isSubformModal || nonInteractiveTask != null))\r\n    {\r\n      let guiEvent = AccessHelper.eventsManager.getPendingGuiEvent();\r\n      // check if true caller is non-interactive task ? if so ...MG_ACT_CLOSE should be added\r\n      if (guiEvent.getTask() != callingTask || this._callingTaskTag !== callingTask.getTaskTag()) {\r\n\r\n        callingTask = <Task>AccessHelper.mgDataTable.GetTaskByID(this._callingTaskTag);\r\n        // If calling task is called by call destination then close it by performSubformClose().\r\n        if ((<Task>callingTask).getIsDestinationCall()) {\r\n          let subformCtrl: MgControl = <MgControl>callingTask.getForm().getSubFormCtrl();\r\n          await AccessHelper.eventsManager.performSubformClose(<MgControl>subformCtrl);\r\n        }\r\n        else {\r\n          let rtEvt = new RunTimeEvent(callingTask);\r\n          rtEvt.setInternal(InternalInterface.MG_ACT_CLOSE);\r\n          rtEvt.setCtrl(null);\r\n          rtEvt.setArgList(null);\r\n          AccessHelper.eventsManager.addToTail(rtEvt);\r\n        }\r\n      }\r\n      else {\r\n        AccessHelper.eventsManager.addToTail(guiEvent);\r\n        AccessHelper.eventsManager.setPendingGuiEvent(null);\r\n      }\r\n    }\r\n  }\r\n\r\n  public HandleAttribute(attribute: string, value: string): void {\r\n    switch (attribute) {\r\n      case ConstInterface.MG_ATTR_CALLINGTASK:\r\n        this._callingTaskTag = value;\r\n        break;\r\n      case ConstInterface.MG_ATTR_PATH_PARENT_TASK:\r\n        this._pathParentTaskTag = value;\r\n        break;\r\n      case ConstInterface.MG_ATTR_SUBFORM_CTRL:\r\n        this._subformCtrlName = value;\r\n        break;\r\n      case XMLConstants.MG_ATTR_DITIDX:\r\n        this._ditIdx = XmlParser.getInt(value);\r\n        break;\r\n      case ConstInterface.MG_ATTR_MODAL:\r\n        this._isModal = (value[0] === '1');\r\n        break;\r\n      case ConstInterface.MG_ATTR_TRANS_OWNER:\r\n        this._transOwner = value;\r\n        break;\r\n      case ConstInterface.MG_ATTR_NEWID:\r\n        this._newId = NString.TrimEnd(value);\r\n        break;\r\n      case ConstInterface.MG_ATTR_KEY:\r\n        this._key = value;\r\n        break;\r\n      case ConstInterface.MG_ATTR_ARGLIST:\r\n        this._varList = new ArgumentsList();\r\n        this._varList.fillList(value, <TaskBase>AccessHelper.mgDataTable.GetTaskByID(this.TaskTag));\r\n        break;\r\n      case ConstInterface.MG_ATTR_OBJECT:\r\n        this.Obj = value;\r\n        break;\r\n      case ConstInterface.MG_ATTR_IS_ROUTE:\r\n        this._isRoute = (value[0] === '1');\r\n        break;\r\n      default:\r\n        super.HandleAttribute(attribute, value);\r\n        break;\r\n    }\r\n  }\r\n}\r\n"]}

package/{esm2020 → esm2022}/src/commands/ServerToClient/ResetLocateCommand.mjs

@@ -1,15 +1,15 @@
-import { ClientTargetedCommandBase } from './ClientTargetedCommandBase';
-import { DataViewCommandType } from '../ClientToServer/DataviewCommand';
-import { CommandFactory } from '../ClientToServer/CommandFactory';
-import { AccessHelper } from '../../AccessHelper';
-export class ResetLocateCommand extends ClientTargetedCommandBase {
-    constructor() {
-        super();
-    }
-    async Execute(res) {
-        let task = AccessHelper.mgDataTable.GetTaskByID(this.TaskTag);
-        let command = CommandFactory.CreateDataViewCommand(this.TaskTag, DataViewCommandType.ResetUserLocate);
-        await task.DataviewManager.Execute(command);
-    }
-}
+import { ClientTargetedCommandBase } from './ClientTargetedCommandBase';
+import { DataViewCommandType } from '../ClientToServer/DataviewCommand';
+import { CommandFactory } from '../ClientToServer/CommandFactory';
+import { AccessHelper } from '../../AccessHelper';
+export class ResetLocateCommand extends ClientTargetedCommandBase {
+    constructor() {
+        super();
+    }
+    async Execute(res) {
+        let task = AccessHelper.mgDataTable.GetTaskByID(this.TaskTag);
+        let command = CommandFactory.CreateDataViewCommand(this.TaskTag, DataViewCommandType.ResetUserLocate);
+        await task.DataviewManager.Execute(command);
+    }
+}
 //# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/src/commands/ServerToClient/ResetRangeCommand.mjs

@@ -1,15 +1,15 @@
-import { ClientTargetedCommandBase } from './ClientTargetedCommandBase';
-import { CommandFactory } from '../ClientToServer/CommandFactory';
-import { DataViewCommandType } from '../ClientToServer/DataviewCommand';
-import { AccessHelper } from '../../AccessHelper';
-export class ResetRangeCommand extends ClientTargetedCommandBase {
-    constructor() {
-        super();
-    }
-    async Execute(res) {
-        let task = AccessHelper.mgDataTable.GetTaskByID(this.TaskTag);
-        let command = CommandFactory.CreateDataViewCommand(this.TaskTag, DataViewCommandType.ResetUserRange);
-        await task.DataviewManager.Execute(command);
-    }
-}
+import { ClientTargetedCommandBase } from './ClientTargetedCommandBase';
+import { CommandFactory } from '../ClientToServer/CommandFactory';
+import { DataViewCommandType } from '../ClientToServer/DataviewCommand';
+import { AccessHelper } from '../../AccessHelper';
+export class ResetRangeCommand extends ClientTargetedCommandBase {
+    constructor() {
+        super();
+    }
+    async Execute(res) {
+        let task = AccessHelper.mgDataTable.GetTaskByID(this.TaskTag);
+        let command = CommandFactory.CreateDataViewCommand(this.TaskTag, DataViewCommandType.ResetUserRange);
+        await task.DataviewManager.Execute(command);
+    }
+}
 //# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/src/commands/ServerToClient/ResetSortCommand.mjs

@@ -1,15 +1,15 @@
-import { ClientTargetedCommandBase } from './ClientTargetedCommandBase';
-import { CommandFactory } from '../ClientToServer/CommandFactory';
-import { DataViewCommandType } from '../ClientToServer/DataviewCommand';
-import { AccessHelper } from '../../AccessHelper';
-export class ResetSortCommand extends ClientTargetedCommandBase {
-    constructor() {
-        super();
-    }
-    async Execute(res) {
-        let task = AccessHelper.mgDataTable.GetTaskByID(this.TaskTag);
-        let command = CommandFactory.CreateDataViewCommand(this.TaskTag, DataViewCommandType.ResetUserSort);
-        await task.DataviewManager.Execute(command);
-    }
-}
+import { ClientTargetedCommandBase } from './ClientTargetedCommandBase';
+import { CommandFactory } from '../ClientToServer/CommandFactory';
+import { DataViewCommandType } from '../ClientToServer/DataviewCommand';
+import { AccessHelper } from '../../AccessHelper';
+export class ResetSortCommand extends ClientTargetedCommandBase {
+    constructor() {
+        super();
+    }
+    async Execute(res) {
+        let task = AccessHelper.mgDataTable.GetTaskByID(this.TaskTag);
+        let command = CommandFactory.CreateDataViewCommand(this.TaskTag, DataViewCommandType.ResetUserSort);
+        await task.DataviewManager.Execute(command);
+    }
+}
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVzZXRTb3J0Q29tbWFuZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2VuZ2luZS9zcmMvY29tbWFuZHMvU2VydmVyVG9DbGllbnQvUmVzZXRTb3J0Q29tbWFuZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUd4RSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFDbEUsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFFeEUsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRWxELE1BQU0sT0FBTyxnQkFBaUIsU0FBUSx5QkFBeUI7SUFFN0Q7UUFDRSxLQUFLLEVBQUUsQ0FBQztJQUNWLENBQUM7SUFFRCxLQUFLLENBQUMsT0FBTyxDQUFDLEdBQWlCO1FBQzdCLElBQUksSUFBSSxHQUFlLFlBQVksQ0FBQyxXQUFXLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUUxRSxJQUFJLE9BQU8sR0FBbUIsY0FBYyxDQUFDLHFCQUFxQixDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsbUJBQW1CLENBQUMsYUFBYSxDQUFDLENBQUM7UUFDcEgsTUFBTSxJQUFJLENBQUMsZUFBZSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUM5QyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDbGllbnRUYXJnZXRlZENvbW1hbmRCYXNlIH0gZnJvbSAnLi9DbGllbnRUYXJnZXRlZENvbW1hbmRCYXNlJztcclxuaW1wb3J0IHsgSVJlc3VsdFZhbHVlIH0gZnJvbSAnLi4vLi4vcnQvSVJlc3VsdFZhbHVlJztcclxuaW1wb3J0IHsgSUNsaWVudENvbW1hbmQgfSBmcm9tICcuLi9JQ2xpZW50Q29tbWFuZCc7XHJcbmltcG9ydCB7IENvbW1hbmRGYWN0b3J5IH0gZnJvbSAnLi4vQ2xpZW50VG9TZXJ2ZXIvQ29tbWFuZEZhY3RvcnknO1xyXG5pbXBvcnQgeyBEYXRhVmlld0NvbW1hbmRUeXBlIH0gZnJvbSAnLi4vQ2xpZW50VG9TZXJ2ZXIvRGF0YXZpZXdDb21tYW5kJztcclxuaW1wb3J0IHsgVGFzayB9IGZyb20gJy4uLy4uL3Rhc2tzL1Rhc2snO1xyXG5pbXBvcnQgeyBBY2Nlc3NIZWxwZXIgfSBmcm9tICcuLi8uLi9BY2Nlc3NIZWxwZXInO1xyXG5cclxuZXhwb3J0IGNsYXNzIFJlc2V0U29ydENvbW1hbmQgZXh0ZW5kcyBDbGllbnRUYXJnZXRlZENvbW1hbmRCYXNlIHtcclxuXHJcbiAgY29uc3RydWN0b3IoKSB7XHJcbiAgICBzdXBlcigpO1xyXG4gIH1cclxuXHJcbiAgYXN5bmMgRXhlY3V0ZShyZXM6IElSZXN1bHRWYWx1ZSk6IFByb21pc2U8dm9pZD4ge1xyXG4gICAgbGV0IHRhc2s6IFRhc2sgPSA8VGFzaz5BY2Nlc3NIZWxwZXIubWdEYXRhVGFibGUuR2V0VGFza0J5SUQodGhpcy5UYXNrVGFnKTtcclxuXHJcbiAgICBsZXQgY29tbWFuZDogSUNsaWVudENvbW1hbmQgPSBDb21tYW5kRmFjdG9yeS5DcmVhdGVEYXRhVmlld0NvbW1hbmQodGhpcy5UYXNrVGFnLCBEYXRhVmlld0NvbW1hbmRUeXBlLlJlc2V0VXNlclNvcnQpO1xyXG4gICAgYXdhaXQgdGFzay5EYXRhdmlld01hbmFnZXIuRXhlY3V0ZShjb21tYW5kKTtcclxuICB9XHJcbn1cclxuIl19

package/esm2022/src/commands/ServerToClient/ResultCommand.mjs

@@ -0,0 +1,37 @@
+import { ClientTargetedCommandBase } from "./ClientTargetedCommandBase";
+import { StorageAttribute, XMLConstants, XmlParser } from "@magic-xpa/utils";
+import { ConstInterface } from "../../ConstInterface";
+export class ResultCommand extends ClientTargetedCommandBase {
+    _isNull = false;
+    _attr = StorageAttribute.NONE;
+    _val = null;
+    async Execute(res) {
+        if (this._isNull)
+            res.SetResultValue(null, StorageAttribute.NONE);
+        else {
+            if (this._val == null)
+                this._val = "";
+            res.SetResultValue(this._val, this._attr);
+        }
+    }
+    HandleAttribute(attribute, value) {
+        switch (attribute) {
+            case ConstInterface.MG_ATTR_NULL:
+                this._isNull = (XmlParser.getInt(value) === 1);
+                break;
+            case ConstInterface.MG_ATTR_PAR_ATTRS:
+                this._attr = value[0];
+                break;
+            case XMLConstants.MG_ATTR_VALUE:
+                this._val = XmlParser.unescape(value);
+                break;
+            default:
+                super.HandleAttribute(attribute, value);
+                break;
+        }
+    }
+    constructor() {
+        super();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/commands/ServerToClient/VerifyCommand.mjs

@@ -0,0 +1,83 @@
+import { ClientTargetedCommandBase } from './ClientTargetedCommandBase';
+import { NString, RefParam } from '@magic-xpa/mscorelib';
+import { Styles } from '@magic-xpa/gui';
+import { Logger, MsgInterface, StrUtil, XmlParser } from '@magic-xpa/utils';
+import { ConstUtils } from '../../util/ConstUtils';
+import { ConstInterface } from '../../ConstInterface';
+import { LanguageData } from '../../env/LanguageData';
+import { LastFocusedManager } from '../../rt/LastFocusedManager';
+import { AccessHelper } from '../../AccessHelper';
+import { GUIManager } from "../../GUIManager";
+export class VerifyCommand extends ClientTargetedCommandBase {
+    _callingTaskTag = null;
+    _title = null;
+    _errLogAppend = false;
+    _text = null;
+    _display = '\0';
+    _mode = '\0';
+    constructor() {
+        super();
+    }
+    async Execute(res) {
+        let errForConsole = StrUtil.getConsoleErorString(this._text);
+        let task = (AccessHelper.mgDataTable.GetTaskByID(this.TaskTag) || AccessHelper.mgDataTable.GetTaskByID(this._callingTaskTag));
+        if (task === null)
+            task = LastFocusedManager.Instance.getLastFocusedTask();
+        let errLogAppend = this._errLogAppend;
+        if (errLogAppend)
+            Logger.Instance.WriteExceptionToLogWithMsg(errForConsole);
+        if (!NString.IsNullOrEmpty(this._text)) {
+            if (this._display === ConstInterface.DISPLAY_BOX) {
+                let style = new RefParam(0);
+                let errForMsgBox = StrUtil.getMsgBoxErorString(this._text);
+                let mlsTransText = LanguageData.Instance.translate(errForMsgBox);
+                let mlsTransTitle = new RefParam(NString.Empty);
+                this.PrepareMessageBoxForDisplay(task, mlsTransTitle, style);
+                let returnValue = await GUIManager.Instance.MessageBox(mlsTransTitle.value, mlsTransText, style.value);
+                await this.ProcessMessageBoxResponse(task, returnValue);
+            }
+            else if (this._display === ConstInterface.DISPLAY_STATUS && task != null) {
+                task.DisplayMessageToStatusBar(errForConsole);
+            }
+        }
+    }
+    PrepareMessageBoxForDisplay(task, mlsTransTitle, style) {
+        let options = LanguageData.Instance.getConstMessage(MsgInterface.BRKTAB_STOP_MODE_TITLE);
+        this._title = ConstUtils.getStringOfOption(options, "EW", this._mode);
+        mlsTransTitle.value = LanguageData.Instance.translate(this._title);
+        style.value = Styles.MSGBOX_BUTTON_OK |
+            ((this._mode === 'E')
+                ? Styles.MSGBOX_ICON_ERROR
+                : Styles.MSGBOX_ICON_WARNING);
+    }
+    ProcessMessageBoxResponse(task, returnValue) {
+    }
+    HandleAttribute(attribute, value) {
+        switch (attribute) {
+            case ConstInterface.MG_ATTR_TITLE:
+                this._title = value;
+                break;
+            case ConstInterface.MG_ATTR_CALLINGTASK:
+                this._callingTaskTag = value;
+                break;
+            case ConstInterface.MG_ATTR_ERR_LOG_APPEND:
+                this._errLogAppend = XmlParser.getBoolean(value);
+                break;
+            case ConstInterface.MG_ATTR_TEXT:
+                this._text = XmlParser.unescape(value);
+                break;
+            case ConstInterface.MG_ATTR_DISPLAY:
+                this._display = value[0];
+                break;
+            case ConstInterface.MG_ATTR_MODE:
+                this._mode = value[0];
+                break;
+            case ConstInterface.MG_ATTR_ACK:
+                break;
+            default:
+                super.HandleAttribute(attribute, value);
+                break;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"VerifyCommand.js","sourceRoot":"","sources":["../../../../../../../projects/engine/src/commands/ServerToClient/VerifyCommand.ts"],"names":[],"mappings":"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","sourcesContent":["import { ClientTargetedCommandBase } from './ClientTargetedCommandBase';\r\nimport { IResultValue } from '../../rt/IResultValue';\r\nimport { NString, RefParam } from '@magic-xpa/mscorelib';\r\nimport { Task } from '../../tasks/Task';\r\nimport { Styles } from '@magic-xpa/gui';\r\nimport { Logger, MsgInterface, StrUtil, XmlParser } from '@magic-xpa/utils';\r\nimport { ConstUtils } from '../../util/ConstUtils';\r\nimport { ConstInterface } from '../../ConstInterface';\r\nimport { LanguageData } from '../../env/LanguageData';\r\nimport { LastFocusedManager } from '../../rt/LastFocusedManager';\r\nimport { AccessHelper } from '../../AccessHelper';\r\nimport {GUIManager} from \"../../GUIManager\";\r\n\r\nexport class VerifyCommand extends ClientTargetedCommandBase {\r\n  private _callingTaskTag: string = null; // is the id of the task that called the new window\r\n  _title: string = null; // title of verify opr\r\n  private _errLogAppend: boolean = false; // append to error log for verify opr\r\n  private _text: string = null; // the verify message\r\n  private _display: string = '\\0';\r\n  private _mode: string = '\\0';\r\n\r\n\r\n  constructor() {\r\n    super();\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"exp\"></param>\r\n  async Execute(res: IResultValue): Promise<void> {\r\n    let errForConsole = StrUtil.getConsoleErorString(this._text);\r\n    let task: Task = <Task>(AccessHelper.mgDataTable.GetTaskByID(this.TaskTag) || AccessHelper.mgDataTable.GetTaskByID(this._callingTaskTag));\r\n    if (task === null)\r\n      task = LastFocusedManager.Instance.getLastFocusedTask();\r\n\r\n    // In order to keep the behavior same as in Online, verify operation warning messages\r\n    // will be written as error messages in Client log (QCR #915122)\r\n    let errLogAppend: boolean = this._errLogAppend;\r\n    if (errLogAppend)\r\n      Logger.Instance.WriteExceptionToLogWithMsg(errForConsole);\r\n\r\n    // Blank Message will not be shown, same as in Online\r\n    if (!NString.IsNullOrEmpty(this._text)) {\r\n      if (this._display === ConstInterface.DISPLAY_BOX) {\r\n        let style: RefParam<number> = new RefParam(0);\r\n\r\n        // on verify box, show translated value. (status is handled in property).\r\n        let errForMsgBox: string = StrUtil.getMsgBoxErorString(this._text);\r\n        let mlsTransText: string = LanguageData.Instance.translate(errForMsgBox);\r\n        let mlsTransTitle: RefParam<string> = new RefParam(NString.Empty);\r\n\r\n        this.PrepareMessageBoxForDisplay(task, mlsTransTitle, style);\r\n        let returnValue: number = await GUIManager.Instance.MessageBox(mlsTransTitle.value, mlsTransText, style.value);\r\n        await this.ProcessMessageBoxResponse(task, returnValue);\r\n      }\r\n      // display message on status only if we have a task\r\n      // Blank Message will not be shown, same as in Online\r\n      else if (this._display === ConstInterface.DISPLAY_STATUS && task != null) {\r\n        task.DisplayMessageToStatusBar(errForConsole);\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Prepares the message box's style and title for display.\r\n  /// </summary>\r\n  /// <param name=\"task\"></param>\r\n  /// <param name=\"mlsTransTitle\"></param>\r\n  /// <param name=\"style\"></param>\r\n  PrepareMessageBoxForDisplay(task: Task, mlsTransTitle: RefParam<string>, style: RefParam<number>): void {\r\n    let options: string = LanguageData.Instance.getConstMessage(MsgInterface.BRKTAB_STOP_MODE_TITLE);\r\n    this._title = ConstUtils.getStringOfOption(options, \"EW\", this._mode);\r\n    mlsTransTitle.value = LanguageData.Instance.translate(this._title);\r\n\r\n    // add the icon according to the mode :is Error \\ Warning\r\n    style.value = Styles.MSGBOX_BUTTON_OK |\r\n      ((this._mode === 'E')\r\n        ? Styles.MSGBOX_ICON_ERROR\r\n        : Styles.MSGBOX_ICON_WARNING);\r\n  }\r\n\r\n  /// <summary>\r\n  /// Handles the response received from the message box.\r\n  /// </summary>\r\n  /// <param name=\"task\"></param>\r\n  /// <param name=\"returnValue\"></param>\r\n  ProcessMessageBoxResponse(task: Task, returnValue: number): void {\r\n    // intentionally left empty.\r\n  }\r\n\r\n  public HandleAttribute(attribute: string, value: string): void {\r\n    switch (attribute) {\r\n      case ConstInterface.MG_ATTR_TITLE:\r\n        this._title = value;\r\n        break;\r\n\r\n      case ConstInterface.MG_ATTR_CALLINGTASK:\r\n        this._callingTaskTag = value;\r\n        break;\r\n\r\n      case ConstInterface.MG_ATTR_ERR_LOG_APPEND:\r\n        this._errLogAppend = XmlParser.getBoolean(value);\r\n        break;\r\n\r\n      case ConstInterface.MG_ATTR_TEXT:\r\n        this._text = XmlParser.unescape(value);\r\n        break;\r\n\r\n      case ConstInterface.MG_ATTR_DISPLAY:\r\n        this._display = value[0];\r\n        break;\r\n\r\n      case ConstInterface.MG_ATTR_MODE:\r\n        this._mode = value[0];\r\n        break;\r\n\r\n      case ConstInterface.MG_ATTR_ACK:\r\n        break;\r\n\r\n      default:\r\n        super.HandleAttribute(attribute, value);\r\n        break;\r\n    }\r\n  }\r\n}\r\n"]}