@magic-xpa/engine 4.801.0-dev481.245 → 4.801.0-dev481.253

package/esm2020/src/ClientManager.mjs

@@ -0,0 +1,403 @@
+import { ApplicationException, DateTime, Debug, Exception, NString, RefParam } from '@magic-xpa/mscorelib';
+import { DateTimeUtils, InternalInterface, Logger, Misc, OSEnvironment, StorageAttribute, XMLConstants } from '@magic-xpa/utils';
+import { Commands, CommandType, DisplayConvertor, Events, GuiConstants, GuiDataCollection, GuiEnvironment, Manager, RuntimeContextBase, Styles } from '@magic-xpa/gui';
+import { EventsManager } from './event/EventsManager';
+import { GuiEventsProcessor } from './GuiEventsProcessor';
+import { Environment } from './env/Environment';
+import { LanguageData } from './env/LanguageData';
+import { TasksTable } from './tasks/TasksTable';
+import { Task } from './tasks/Task';
+import { MGDataCollection } from './tasks/MGDataCollection';
+import { UniqueIDUtils } from './util/UniqueIDUtils';
+import { HttpManager } from './http/HttpManager';
+import { CommandsTable } from './CommandsTable';
+import { RemoteCommandsProcessor } from './remote/RemoteCommandsProcessor';
+import { ConstInterface } from './ConstInterface';
+import { CommandsProcessorBase_SendingInstruction } from './CommandsProcessorBase';
+import { CommandsProcessorManager } from './CommandsProcessorManager';
+import { MGData } from './tasks/MGData';
+import { ServerError } from './remote/ServerError';
+import { HttpClientEvents } from './http/client/HttpClientEvents';
+import { CommandFactory } from './commands/ClientToServer/CommandFactory';
+import { CurrentClientVersion } from './CurrentClientVersion';
+import { LastFocusedManager } from './rt/LastFocusedManager';
+import { EnvParamsTable } from './env/EnvVariablesTable';
+import { GlobalParams } from './exp/GlobalParamsTable';
+import { OpenURLCommand } from './commands/ServerToClient/OpenURLCommand';
+import { ServerConfig } from './ServerConfig';
+import { AccessHelper } from './AccessHelper';
+import { GUIManager } from "./GUIManager";
+export class ClientManager {
+    constructor() {
+        this._guiEventsProcessor = null;
+        this._tableCacheManager = null;
+        this._delayInProgress = false;
+        this._debugClient = null;
+        this._globalUniqueSessionId = null;
+        this._buttonIsClicked = false;
+        RuntimeContextBase.Instance.Init(RemoteCommandsProcessor.RC_NO_CONTEXT_ID);
+        LastFocusedManager.Instance.Init(MGDataCollection.Instance);
+        LastFocusedManager.Instance.LastActionTime = Misc.getSystemMilliseconds();
+        RemoteCommandsProcessor.ShouldScrambleAndUnscrambleMessages = true;
+        this._globalUniqueSessionId = UniqueIDUtils.GetUniqueMachineID() + "_";
+        this.RegisterDelegates();
+    }
+    static get Instance() {
+        if (ClientManager._instance === null)
+            ClientManager._instance = new ClientManager();
+        return ClientManager._instance;
+    }
+    AddEvent(guiEvent) {
+        let task = MGDataCollection.Instance.GetTaskByID(guiEvent.TaskID);
+        let lineIdx = +guiEvent.Line;
+        let clickDblClickSucceeded = false;
+        let dvRowIdx = 0;
+        if (task != null) {
+            let control = null;
+            if (guiEvent.ControlName !== null)
+                control = task.getForm().GetCtrl(guiEvent.ControlName);
+            if (control != null) {
+                let dv = task.DataView;
+                if (control.IsTableChild) {
+                    lineIdx -= dv.RecordsBeforeCurrentView;
+                }
+                switch (guiEvent.EventType) {
+                    case "columnSort":
+                        if (control.isColumnSortable()) {
+                            Events.OnColumnClick(control, guiEvent.Line, guiEvent.ControlName);
+                        }
+                        break;
+                    case "mousedown":
+                        if (control.isButton()) {
+                            this._buttonIsClicked = true;
+                        }
+                        else if (!control.isSubform())
+                            Events.GetRuntimeContext(Manager.GetCurrentContextID()).LastClickedCtrlName = control.getName();
+                        break;
+                    case "click":
+                        if (control.isButton() || (control.ConnectedControl && guiEvent.fromButton)) {
+                            Events.OnSelection("", control, lineIdx, true);
+                            Events.GetRuntimeContext(Manager.GetCurrentContextID()).LastClickedCtrlName = control.getName();
+                            this._buttonIsClicked = false;
+                        }
+                        else {
+                            Events.OnFocus(control, lineIdx, true, false);
+                            let produceClick = control.isButton() || control.isTextControl() || control.isLabel() || control.isTabControl() || control.isTableControl() || control.isComboBox() || control.isImageControl();
+                            Events.OnMouseDown(control.getForm(), control, null, true, lineIdx, false, produceClick);
+                        }
+                        break;
+                    case "focus":
+                        if (this._buttonIsClicked)
+                            return;
+                        Events.OnFocus(control, lineIdx, true, false);
+                        break;
+                    case "dblclick":
+                        Events.OnDblClick(control, lineIdx);
+                        break;
+                    case "selectionchanged":
+                        Events.OnSelection(guiEvent.Value, control, lineIdx, true);
+                        break;
+                    case "keydown":
+                        Events.OnKeyDown(task.getForm(), control, guiEvent.modifiers, guiEvent.keyCode, 0, 0, '', false, '', true);
+                        break;
+                    case "setexternalvalue":
+                        EventsManager.Instance.AddExternalValueEvent(control, guiEvent.externalValue, guiEvent.param);
+                        break;
+                    default:
+                        break;
+                }
+            }
+            else {
+                switch (guiEvent.EventType) {
+                    case "focusOnNonMagicControl":
+                        control = LastFocusedManager.getLastFocusedControl();
+                        if (control !== null) {
+                            Events.OnFocusOnNonMagicControl(control);
+                        }
+                        break;
+                    case "click":
+                        if (guiEvent.ControlName === "magicRow") {
+                            dvRowIdx = guiEvent.Line - task.DataView.RecordsBeforeCurrentView;
+                            EventsManager.Instance.addGuiTriggeredEventWithTaskAndCodeAndLine(task, InternalInterface.MG_ACT_REC_PREFIX, dvRowIdx);
+                        }
+                        break;
+                    case "close":
+                        if (task.IsRoute())
+                            EventsManager.Instance.AddRouterClosedEvent(task);
+                        else
+                            Events.CloseFormEvent(task.getForm());
+                        break;
+                    case "dispose":
+                        MGDataCollection.Instance.deleteMGDataTree(task.getMgdID());
+                        break;
+                    case "resize":
+                        Events.TableResizeEvent(task.getForm().getTableCtrl(), guiEvent.PageSize);
+                    case "getRows":
+                        dvRowIdx = lineIdx - task.DataView.RecordsBeforeCurrentView;
+                        let lastFocusedVal = { guiMgControl: task.getForm().getTableCtrl(), Line: dvRowIdx, Val: "" };
+                        Events.OnGetRowsData(task.getForm().getTableCtrl(), dvRowIdx, true, lastFocusedVal);
+                        break;
+                    case "RouterNavigate":
+                        EventsManager.Instance.AddRouteEvent(task, InternalInterface.MG_ACT_WEBCLIENT_ROUTE, guiEvent.RouterPath, guiEvent.RouterOutletName, guiEvent.RouterParams);
+                        break;
+                    case "setexternalvalue":
+                        Logger.Instance.WriteErrorToLog(NString.Format("Unable to find {0}: Trying to set value for a non-existing control.", guiEvent.ControlName));
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+        else
+            switch (guiEvent.EventType) {
+                case "confirmationClosed":
+                    this.ConfirmationClosed(guiEvent.keyCode);
+                    break;
+            }
+    }
+    ConfirmationClosed(res) {
+        Commands.ResolvePromise(res);
+    }
+    async WorkThreadExecution() {
+        if (Logger.Instance.ShouldLog()) {
+            Logger.Instance.WriteToLog("", true);
+            Logger.Instance.WriteToLog("Started on " + DateTimeUtils.ToString(DateTime.Now, XMLConstants.ERROR_LOG_DATE_FORMAT, Logger.Instance), true);
+            this.WriteExecutionPropertiesToLog();
+        }
+        try {
+            if (await CommandsProcessorManager.StartSession()) {
+                let mgDataTab = MGDataCollection.Instance;
+                let startupMgData = mgDataTab.StartupMgData;
+                mgDataTab.currMgdID = startupMgData.GetId();
+                let nonInteractiveTask = null;
+                if (!startupMgData.IsAborting)
+                    nonInteractiveTask = await Task.StartProgram(false, false);
+                if (nonInteractiveTask === null)
+                    await EventsManager.Instance.EventsLoop(startupMgData);
+                else
+                    await EventsManager.Instance.NonInteractiveEventsLoop(startupMgData, nonInteractiveTask);
+                EventsManager.Instance.setEndOfWork(true);
+            }
+        }
+        catch (ex) {
+            if (ex instanceof ApplicationException) {
+                let isNoResultError = false;
+                if (ex instanceof ServerError && ex.GetCode() === ServerError.INF_NO_RESULT)
+                    isNoResultError = true;
+                if (!isNoResultError)
+                    await EventsManager.Instance.ProcessAbortingError(ex);
+                EventsManager.Instance.setEndOfWork(true);
+            }
+            else
+                throw ex;
+        }
+        finally {
+            await EventsManager.Instance.CheckAndShowSpinner(false);
+            Commands.addGlobalCommand(CommandType.EXIT_MAGIC);
+            Commands.beginInvoke();
+        }
+    }
+    WriteExecutionPropertiesToLog() {
+        if (Logger.Instance.ShouldLogServerRelatedMessages()) {
+            Logger.Instance.WriteToLog("-----------------------------------------------------------------------------", true);
+            Logger.Instance.WriteToLog("Execution Properties:", true);
+            let propsString = JSON.stringify(ServerConfig.Instance);
+            Logger.Instance.WriteToLog(propsString, true);
+            Logger.Instance.WriteToLog("-----------------------------------------------------------------------------", true);
+        }
+    }
+    InitGuiManager() {
+        Manager.EventsManager = EventsManager.Instance;
+        Manager.DefaultServerName = ServerConfig.Instance.getServer();
+        Manager.DefaultProtocol = ServerConfig.Instance.getProtocol();
+        GuiEnvironment.Environment = Environment.Instance;
+        GuiDataCollection.MGDataTable = MGDataCollection.Instance;
+        RuntimeContextBase.noContextId = RemoteCommandsProcessor.RC_NO_CONTEXT_ID;
+    }
+    InitCircularReferencesBypasses() {
+        TasksTable.createNewtask = Task.CreateTask;
+        OpenURLCommand.createNewCommandsTable = CommandsTable.createCommandsTable;
+        AccessHelper.eventsManager = EventsManager.Instance;
+        AccessHelper.mgDataTable = MGDataCollection.Instance;
+        AccessHelper.envParamsTable = EnvParamsTable.Instance;
+        AccessHelper.globalParams = GlobalParams.Instance;
+        AccessHelper.languageData = LanguageData.Instance;
+        AccessHelper.environment = Environment.Instance;
+    }
+    static Main(httpClient) {
+        ClientManager.StartExecution(httpClient);
+        Logger.Instance.Flush();
+    }
+    static async StopExecution() {
+        try {
+            HttpManager.GetInstance().IsAbortingMagicEngine = true;
+            MGDataCollection.Instance.StartupMgData.getFirstTask().ClosingFormUI = true;
+            await MGDataCollection.Instance.StartupMgData.getFirstTask().endTask(true, false, false);
+        }
+        catch (ex3) {
+            if (ex3 instanceof ApplicationException) {
+                Logger.Instance.WriteExceptionToLog(ex3);
+            }
+            else
+                throw ex3;
+        }
+    }
+    static async StartExecution(httpClient) {
+        HttpManager.setNativeHttpClient(httpClient);
+        let loaded = await ClientManager.Instance.LoadExecutionProps();
+        if (loaded) {
+            ClientManager.Instance._guiEventsProcessor = new GuiEventsProcessor();
+            ClientManager.Instance.InitGuiManager();
+            ClientManager.Instance.InitCircularReferencesBypasses();
+            let versionString = CurrentClientVersion === '0.0.0.0' ? "Development mode" : "Version : " + CurrentClientVersion;
+            console.log("Magic Web Client. " + versionString);
+            HttpManager.GetInstance().HttpCommunicationTimeoutMS = ServerConfig.Instance.GetFirstHttpRequestTimeout();
+            EventsManager.Instance.Init();
+            Logger.Instance.Initialize(RemoteCommandsProcessor.GetInstance().parseLogLevel(ServerConfig.Instance.getInternalLogLevel()), false);
+            let mgd = new MGData(new CommandsTable(), new CommandsTable(), 0, null, false);
+            await MGDataCollection.Instance.addMGData(mgd, 0, true);
+            await ClientManager.Instance.WorkThreadExecution();
+            if (Logger.Instance.ShouldLog()) {
+                Logger.Instance.WriteToLog(OSEnvironment.EolSeq + "Ended on " + DateTimeUtils.ToString(DateTime.Now, "dd/MM/yyyy", Logger.Instance) + OSEnvironment.EolSeq + OSEnvironment.EolSeq, false);
+            }
+        }
+        else {
+            await GUIManager.Instance.MessageBox("Error", "Failed to load server configuration file (" + this._executionPropertiesFileName + ")", Styles.MSGBOX_ICON_ERROR | Styles.MSGBOX_BUTTON_OK);
+        }
+    }
+    async LoadExecutionProps() {
+        let response = "";
+        let succeeded = true;
+        try {
+            let isError = new RefParam(false);
+            response = await HttpManager.GetInstance().GetContent(ClientManager._executionPropertiesFileName, null, false, isError);
+            ServerConfig.Instance.Init(JSON.parse(response));
+        }
+        catch (ex) {
+            succeeded = false;
+        }
+        return succeeded;
+    }
+    copyExecutionProps() {
+        throw new Exception("copyExecutionProps not implemented");
+    }
+    getDebugClient() {
+        return this._debugClient;
+    }
+    getURLFromExecutionProperties(executionPropName) {
+        let url = null;
+        let urlStr = ServerConfig.Instance.GetExecutionProperty[executionPropName];
+        if (urlStr !== null && typeof urlStr !== "undefined") {
+            if (urlStr.startsWith("/"))
+                urlStr = ServerConfig.Instance.getProtocol() + "://" + ServerConfig.Instance.getServer() + urlStr;
+            try {
+                url = new URL(urlStr);
+                Debug.Assert(url.protocol === "http:" || url.protocol === "https:");
+            }
+            catch (ex) {
+                Logger.Instance.WriteExceptionToLog(ex);
+            }
+        }
+        return url;
+    }
+    getLogonWindowIconURL() {
+        return this.getURLFromExecutionProperties(GuiConstants.STR_LOGO_WIN_ICON_URL);
+    }
+    getLogonWindowImageURL() {
+        return this.getURLFromExecutionProperties(GuiConstants.STR_LOGON_IMAGE_URL);
+    }
+    isDelayInProgress() {
+        return this._delayInProgress;
+    }
+    setDelayInProgress(delayInProgress) {
+        this._delayInProgress = delayInProgress;
+    }
+    GetGlobalUniqueSessionID() {
+        return this._globalUniqueSessionId;
+    }
+    static getExecutionPropertiesFileName() {
+        let fullyQualifiedName = null;
+        let lastPathSeparator = fullyQualifiedName.lastIndexOf('\\');
+        return NString.Remove(fullyQualifiedName, lastPathSeparator + 1, fullyQualifiedName.length - lastPathSeparator - 1) + ConstInterface.EXECUTION_PROPERTIES_FILE_NAME;
+    }
+    static GetControlPictureMask(taskId, controlName) {
+        let pic = null;
+        let task = MGDataCollection.Instance.GetTaskByID(taskId);
+        let control = null;
+        if (controlName !== null) {
+            control = task.getForm().GetCtrl(controlName);
+            pic = control.getPIC();
+        }
+        return pic;
+    }
+    static GetFormattedValue(taskId, controlName, value) {
+        let pic = null;
+        let task = MGDataCollection.Instance.GetTaskByID(taskId);
+        let control = null;
+        let newValue = value;
+        if (controlName !== null)
+            control = task.getForm().GetCtrl(controlName);
+        if (control != null && control.DataType == StorageAttribute.NUMERIC) {
+            pic = control.getPIC();
+            let dispValue = String(value);
+            let newPic = pic.getUnformattedNumericPic();
+            let num = DisplayConvertor.Instance.toNum(dispValue, newPic, 0);
+            newValue = DisplayConvertor.Instance.fromNum(num, pic);
+        }
+        return newValue;
+    }
+    static GetRangedValue(taskId, controlName, value) {
+        let task = MGDataCollection.Instance.GetTaskByID(taskId);
+        let control = null;
+        if (controlName !== null) {
+            control = task.getForm().GetCtrl(controlName);
+            return control.getRangedValue(value);
+        }
+        return null;
+    }
+    static ValidateControlValue(taskId, controlName, value) {
+        let task = MGDataCollection.Instance.GetTaskByID(taskId);
+        let control = null;
+        if (controlName !== null) {
+            control = task.getForm().GetCtrl(controlName);
+            return control.validate(value);
+        }
+        return null;
+    }
+    static GetFldRanges(taskId, controlName) {
+        let task = MGDataCollection.Instance.GetTaskByID(taskId);
+        let control = null;
+        if (controlName !== null) {
+            control = task.getForm().GetCtrl(controlName);
+            return control.getRanges();
+        }
+        return null;
+    }
+    static TransCacheExists() {
+        let clientTransCacheExists = AccessHelper.mgDataTable.getCurrMGData().clientTransactionCacheExists();
+        let serverTransactionCacheExists = AccessHelper.mgDataTable.getCurrMGData().serverTransactionCacheExists();
+        return clientTransCacheExists || serverTransactionCacheExists;
+    }
+    RegisterDelegates() {
+        HttpClientEvents.GetExecutionProperty_Event = ServerConfig.Instance.GetExecutionProperty.bind(ServerConfig.Instance);
+        HttpClientEvents.GetRuntimeCtxID_Event = this.GetRuntimeCtxID.bind(this);
+        HttpClientEvents.GetGlobalUniqueSessionID_Event = this.GetGlobalUniqueSessionID.bind(this);
+        HttpClientEvents.ShouldDisplayGenericError_Event = ServerConfig.Instance.ShouldDisplayGenericError.bind(ServerConfig.Instance);
+    }
+    GetRuntimeCtxID() {
+        return RuntimeContextBase.Instance.ContextID;
+    }
+    static TerminateContextUsingFetchAPI() {
+        if (RemoteCommandsProcessor.IsSessionReInitializing)
+            return;
+        HttpManager.GetInstance().IsAbortingMagicEngine = true;
+        MGDataCollection.Instance.getCurrMGData().CmdsToServer.Clear();
+        let contextTerminationEventCommand = CommandFactory.
+            CreateContextTerminationEventCommand(MGDataCollection.Instance.StartupMgData.getFirstTask().getTaskTag());
+        MGDataCollection.Instance.getCurrMGData().CmdsToServer.Add(contextTerminationEventCommand);
+        RemoteCommandsProcessor.GetInstance().Execute(CommandsProcessorBase_SendingInstruction.ONLY_COMMANDS);
+    }
+}
+ClientManager._instance = null;
+ClientManager._executionPropertiesFileName = "./assets/server-config.json";
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ClientManager.js","sourceRoot":"","sources":["../../../../../projects/engine/src/ClientManager.ts"],"names":[],"mappings":"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","sourcesContent":["import {ApplicationException, DateTime, Debug, Exception, NString, RefParam} from '@magic-xpa/mscorelib';\r\n\r\nimport {\r\n  DateTimeUtils,\r\n  InternalInterface,\r\n  Logger,\r\n  Misc,\r\n  OSEnvironment,\r\n  StorageAttribute,\r\n  XMLConstants\r\n} from '@magic-xpa/utils';\r\nimport {\r\n  Commands,\r\n  CommandType,\r\n  DisplayConvertor,\r\n  Events,\r\n  GuiConstants,\r\n  GuiDataCollection,\r\n  GuiEnvironment,\r\n  LastFocusedVal,\r\n  Manager,\r\n  MgControlBase,\r\n  PIC,\r\n  RuntimeContextBase,\r\n  Styles\r\n} from '@magic-xpa/gui';\r\nimport {EventsManager} from './event/EventsManager';\r\nimport {GuiEventsProcessor} from './GuiEventsProcessor';\r\nimport {Environment} from './env/Environment';\r\nimport {LanguageData} from './env/LanguageData';\r\nimport {TasksTable} from './tasks/TasksTable';\r\nimport {TableCacheManager} from './rt/TableCacheManager';\r\nimport {MgControl} from './gui/MgControl';\r\nimport {IClientCommand} from './commands/IClientCommand';\r\nimport {Task} from './tasks/Task';\r\nimport {MGDataCollection} from './tasks/MGDataCollection';\r\nimport {UniqueIDUtils} from './util/UniqueIDUtils';\r\nimport {HttpManager} from './http/HttpManager';\r\nimport {CommandsTable} from './CommandsTable';\r\nimport {RemoteCommandsProcessor} from './remote/RemoteCommandsProcessor';\r\nimport {ConstInterface} from './ConstInterface';\r\nimport {CommandsProcessorBase_SendingInstruction} from './CommandsProcessorBase';\r\nimport {CommandsProcessorManager} from './CommandsProcessorManager';\r\nimport {MGData} from './tasks/MGData';\r\nimport {ServerError} from './remote/ServerError';\r\nimport {HttpClientEvents} from './http/client/HttpClientEvents';\r\nimport {IGuiEvent} from './bridge/IGuiEvent';\r\nimport {CommandFactory} from './commands/ClientToServer/CommandFactory';\r\nimport {CurrentClientVersion} from './CurrentClientVersion';\r\nimport {IServerConfig} from './util/IServerConfig';\r\nimport {DataView} from './data/DataView';\r\nimport {LastFocusedManager} from './rt/LastFocusedManager';\r\nimport {EnvParamsTable} from './env/EnvVariablesTable';\r\nimport {GlobalParams} from './exp/GlobalParamsTable';\r\nimport {OpenURLCommand} from './commands/ServerToClient/OpenURLCommand';\r\nimport {ServerConfig} from './ServerConfig';\r\nimport {AccessHelper} from './AccessHelper';\r\nimport {HttpClient} from '@angular/common/http';\r\nimport {ContextTerminationEventCommand} from './commands/ClientToServer/ContextTerminationEventCommand';\r\nimport {GUIManager} from \"./GUIManager\";\r\n\r\n// @dynamic\r\nexport class ClientManager {\r\n  private _guiEventsProcessor: GuiEventsProcessor = null;\r\n\r\n\r\n\r\n  private _tableCacheManager: TableCacheManager = null;\r\n  private _delayInProgress: boolean = false;  // true if delay is in progress\r\n\r\n  private static _instance: ClientManager = null;\r\n\r\n  private _debugClient: string = null;\r\n  private _globalUniqueSessionId: string = null;\r\n//  private _lastFailedFocusedControl: MgControlBase = null; // control where last parking was attempted but we did not park on it\r\n  private _buttonIsClicked = false;\r\n\r\n\r\n  private static readonly _executionPropertiesFileName: string = \"./assets/server-config.json\"; // path of the execution properties file from assets folder\r\n\r\n  static get Instance(): ClientManager {\r\n    if (ClientManager._instance === null)\r\n      ClientManager._instance = new ClientManager();\r\n\r\n    return ClientManager._instance;\r\n  }\r\n\r\n\r\n\r\n\r\n  public AddEvent(guiEvent: IGuiEvent): void {\r\n    let task: Task = <Task>MGDataCollection.Instance.GetTaskByID(guiEvent.TaskID);\r\n    let lineIdx: number = +guiEvent.Line;\r\n    let clickDblClickSucceeded:boolean = false;\r\n    let dvRowIdx: number = 0;\r\n\r\n    if (task != null) {\r\n      let control: MgControlBase = null;\r\n\r\n      if (guiEvent.ControlName !== null)\r\n        control = task.getForm().GetCtrl(guiEvent.ControlName);\r\n\r\n      if (control != null) {\r\n        let dv: DataView = <DataView>task.DataView;\r\n        if (control.IsTableChild) {\r\n          lineIdx -= dv.RecordsBeforeCurrentView;\r\n        }\r\n        switch (guiEvent.EventType) {\r\n\r\n          case \"columnSort\":\r\n            if (control.isColumnSortable()) {\r\n              Events.OnColumnClick(control, guiEvent.Line, guiEvent.ControlName);\r\n            }\r\n            break;\r\n          case \"mousedown\":\r\n            // Defect 152288 & Defect 152268: Problem: When button is clicked, we get focus event first and if messageBox is opened here like verify, etc.\r\n            // we do not receive click event. Hence events are not processed. Solution: We do need click handling for button as it is called when we park\r\n            // on button and press space key. We need focus event handling for executing CP & CS when parked on button by tab key. So we need to manage\r\n            // how click is handled. We do not need focus event handling when we click on button, so on mousedown, set a flag which will be used in focus\r\n            // event handling to skip its handling. Then we will receive click event where this will be actually handled and hence work.\r\n            if (control.isButton()) {\r\n              this._buttonIsClicked = true;\r\n            }\r\n            else if (!control.isSubform())\r\n              Events.GetRuntimeContext(Manager.GetCurrentContextID()).LastClickedCtrlName = control.getName();\r\n            break;\r\n\r\n          case \"click\":\r\n            if (control.isButton() || (control.ConnectedControl && guiEvent.fromButton)){\r\n              Events.OnSelection(\"\", control, lineIdx, true);\r\n              Events.GetRuntimeContext(Manager.GetCurrentContextID()).LastClickedCtrlName = control.getName();\r\n              this._buttonIsClicked = false;\r\n            }\r\n            // sorting should be handled only on column click and not on rowData\r\n            // else if (control.Type === MgControlType.CTRL_TYPE_COLUMN) {\r\n            //   Events.OnColumnClick(control, guiEvent.Line, guiEvent.ControlName);\r\n            // }\r\n            else {\r\n              Events.OnFocus(control, lineIdx, true, false);\r\n              let produceClick: boolean = control.isButton() || control.isTextControl() || control.isLabel() || control.isTabControl() || control.isTableControl() || control.isComboBox() || control.isImageControl();\r\n              Events.OnMouseDown(control.getForm(), control, null, true, lineIdx, false, produceClick);\r\n            }\r\n            break;\r\n          case \"focus\":\r\n\r\n            if (this._buttonIsClicked)\r\n              return;\r\n\r\n            // // If we attempt to park on control where we do not want to allow to park like if control has expression or parent task field, do not allow to focus on it.\r\n            // // Set Focus back to lastFocusedControl. We need _lastFailedFocusedControl as we get focus event on a control twice. So to avoid to show error multiple times,\r\n            // // maintain _lastFailedFocusedControl.\r\n            // if (control !== this._lastFailedFocusedControl && control.HasExpOrParentTaskField()) {\r\n            //   // Show error only for controls having Data property and parkable\r\n            //   if(control.isListBox() || control.isCheckBox() || control.isComboBox() || control.isTextControl() || control.isRadio() || control.isTabControl()) {\r\n            //     Commands.messageBox(null, \"Error\", \"Control either has expression or has parent task variable attached to it. Failed to park on control with name: \" + control.Name, Styles.MSGBOX_ICON_ERROR | Styles.MSGBOX_BUTTON_OK);\r\n            //     // Defect 152728: Use last focused task instead control task as control can be from subform.\r\n            //     FocusManager.SetFocus(LastFocusedManager.Instance.getLastFocusedTask(), LastFocusedManager.getLastFocusedControl(), 0,\r\n            //               LastFocusedManager.getLastFocusedControl() === null ? true : false);\r\n            //     this._lastFailedFocusedControl = control;\r\n            //     return;\r\n            //   }\r\n            // }\r\n            //\r\n            // this._lastFailedFocusedControl = null;\r\n\r\n            Events.OnFocus(control, lineIdx, true, false);\r\n\r\n            break;\r\n          case \"dblclick\":\r\n            Events.OnDblClick(control, lineIdx);\r\n            break;\r\n\r\n          case \"selectionchanged\":\r\n            Events.OnSelection(guiEvent.Value, control, lineIdx, true);\r\n            break;\r\n          case \"keydown\":\r\n            Events.OnKeyDown( task.getForm(), control, guiEvent.modifiers, guiEvent.keyCode, 0,0, '',false,'',true );\r\n            break;\r\n          case \"setexternalvalue\":\r\n            EventsManager.Instance.AddExternalValueEvent((<MgControl>control), guiEvent.externalValue, guiEvent.param);\r\n            break;\r\n          default:\r\n            // console.log(\"unhandled event: \\\"\" + guiEvent.EventType + \"\\\"\");\r\n            break;\r\n        }\r\n      }\r\n      else {\r\n        switch (guiEvent.EventType) {\r\n          case \"focusOnNonMagicControl\":\r\n            control = LastFocusedManager.getLastFocusedControl();\r\n            if (control !== null) {\r\n              Events.OnFocusOnNonMagicControl(control);\r\n            }\r\n            break;\r\n          case \"click\":\r\n            if(guiEvent.ControlName === \"magicRow\") {\r\n              dvRowIdx = guiEvent.Line - (<DataView>task.DataView).RecordsBeforeCurrentView;\r\n              EventsManager.Instance.addGuiTriggeredEventWithTaskAndCodeAndLine(task, InternalInterface.MG_ACT_REC_PREFIX, dvRowIdx);\r\n            }\r\n            break;\r\n          case \"close\":\r\n            if (task.IsRoute())\r\n              EventsManager.Instance.AddRouterClosedEvent(task);\r\n            else\r\n              Events.CloseFormEvent(task.getForm());\r\n            break;\r\n          case \"dispose\":\r\n            MGDataCollection.Instance.deleteMGDataTree(task.getMgdID());\r\n            break;\r\n          case \"resize\":\r\n            Events.TableResizeEvent(task.getForm().getTableCtrl(), guiEvent.PageSize);\r\n          //case 'break' is missing for 'resize' with intention to execute getRows with the desired dataview row index.\r\n          case \"getRows\":\r\n            dvRowIdx = lineIdx - (<DataView>task.DataView).RecordsBeforeCurrentView;\r\n            let lastFocusedVal: LastFocusedVal = {guiMgControl: task.getForm().getTableCtrl(), Line: dvRowIdx, Val: \"\"};\r\n            Events.OnGetRowsData(task.getForm().getTableCtrl(), dvRowIdx, true, lastFocusedVal);\r\n            break;\r\n          case \"RouterNavigate\":\r\n            EventsManager.Instance.AddRouteEvent(task, InternalInterface.MG_ACT_WEBCLIENT_ROUTE, guiEvent.RouterPath, guiEvent.RouterOutletName,\r\n              guiEvent.RouterParams);\r\n            break;\r\n          case \"setexternalvalue\":\r\n            Logger.Instance.WriteErrorToLog(NString.Format(\"Unable to find {0}: Trying to set value for a non-existing control.\", guiEvent.ControlName));\r\n            break;\r\n          default:\r\n            // console.log( \"unhandled event: \\\"\" + guiEvent.EventType + \"\\\"\");\r\n            break;\r\n        }\r\n      }\r\n    }\r\n    else //task == null\r\n      switch (guiEvent.EventType) {\r\n        case \"confirmationClosed\":\r\n          this.ConfirmationClosed(guiEvent.keyCode);\r\n          break;\r\n      }\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  /// raise callback on closing confirmation\r\n  /// </summary>\r\n  ConfirmationClosed(res: number): void\r\n  {\r\n    Commands.ResolvePromise(res);\r\n  }\r\n\r\n  /// <summary>\r\n  /// the work thread's entry method\r\n  /// </summary>\r\n  async WorkThreadExecution(): Promise<void> {\r\n    if (Logger.Instance.ShouldLog()) {\r\n      Logger.Instance.WriteToLog(\"\", true);\r\n      Logger.Instance.WriteToLog(\"Started on \" + DateTimeUtils.ToString(DateTime.Now, XMLConstants.ERROR_LOG_DATE_FORMAT, Logger.Instance), true);\r\n      this.WriteExecutionPropertiesToLog();\r\n    }\r\n\r\n    try {\r\n      if (await CommandsProcessorManager.StartSession()) {\r\n        let mgDataTab: MGDataCollection = MGDataCollection.Instance;\r\n        let startupMgData: MGData = mgDataTab.StartupMgData;\r\n        mgDataTab.currMgdID = startupMgData.GetId();\r\n\r\n        let nonInteractiveTask: Task = null;\r\n        if (!startupMgData.IsAborting)\r\n          nonInteractiveTask = await Task.StartProgram(false, false);\r\n\r\n        if (nonInteractiveTask === null)\r\n          await EventsManager.Instance.EventsLoop(startupMgData);\r\n        else\r\n          await EventsManager.Instance.NonInteractiveEventsLoop(startupMgData, nonInteractiveTask);\r\n\r\n        // set the \"end of work\" flag only for the main window\r\n        EventsManager.Instance.setEndOfWork(true);\r\n      }\r\n    }\r\n    catch (ex) {\r\n      if (ex instanceof ApplicationException) {\r\n        let isNoResultError: boolean = false;\r\n        if (ex instanceof ServerError && (<ServerError>ex).GetCode() === ServerError.INF_NO_RESULT)\r\n          isNoResultError = true;\r\n\r\n        if (!isNoResultError)\r\n          await EventsManager.Instance.ProcessAbortingError(ex);\r\n\r\n        EventsManager.Instance.setEndOfWork(true);\r\n      }\r\n      else\r\n        throw ex;\r\n    }\r\n    finally {\r\n      await EventsManager.Instance.CheckAndShowSpinner(false);\r\n\r\n      Commands.addGlobalCommand(CommandType.EXIT_MAGIC);\r\n      Commands.beginInvoke();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Write Execution properties to log.\r\n  /// </summary>\r\n  WriteExecutionPropertiesToLog(): void {\r\n    if (Logger.Instance.ShouldLogServerRelatedMessages()) {\r\n      Logger.Instance.WriteToLog(\"-----------------------------------------------------------------------------\", true);\r\n      // Write heading\r\n      Logger.Instance.WriteToLog(\"Execution Properties:\", true);\r\n\r\n      let propsString = JSON.stringify(ServerConfig.Instance);\r\n      Logger.Instance.WriteToLog(propsString, true);\r\n\r\n      Logger.Instance.WriteToLog(\"-----------------------------------------------------------------------------\", true);\r\n    }\r\n  }\r\n\r\n\r\n  constructor() {\r\n    RuntimeContextBase.Instance.Init(RemoteCommandsProcessor.RC_NO_CONTEXT_ID);\r\n    LastFocusedManager.Instance.Init(MGDataCollection.Instance);\r\n    LastFocusedManager.Instance.LastActionTime = Misc.getSystemMilliseconds();\r\n\r\n\r\n    RemoteCommandsProcessor.ShouldScrambleAndUnscrambleMessages = true;\r\n\r\n\r\n    // TODO: How to get Process.GetCurrentProcess().Id?\r\n    this._globalUniqueSessionId = UniqueIDUtils.GetUniqueMachineID() + \"_\"; // + Process.GetCurrentProcess().Id;\r\n\r\n    this.RegisterDelegates();\r\n  }\r\n\r\n  /// <summary> Initialize the data needed by the gui library\r\n  /// </summary>\r\n  /// <returns> ClientManager instance</returns>\r\n  private InitGuiManager(): void {\r\n    Manager.EventsManager = EventsManager.Instance;\r\n    Manager.DefaultServerName = ServerConfig.Instance.getServer();\r\n    Manager.DefaultProtocol = ServerConfig.Instance.getProtocol();\r\n    GuiEnvironment.Environment = Environment.Instance;\r\n    GuiDataCollection.MGDataTable = MGDataCollection.Instance;\r\n    RuntimeContextBase.noContextId = RemoteCommandsProcessor.RC_NO_CONTEXT_ID;\r\n  }\r\n\r\n  /// Initialize global data in objects used to overcome the circular references issue\r\n  private InitCircularReferencesBypasses() {\r\n    TasksTable.createNewtask = Task.CreateTask;\r\n    OpenURLCommand.createNewCommandsTable = CommandsTable.createCommandsTable;\r\n\r\n    AccessHelper.eventsManager = EventsManager.Instance;\r\n    AccessHelper.mgDataTable = MGDataCollection.Instance;\r\n    AccessHelper.envParamsTable = EnvParamsTable.Instance;\r\n    AccessHelper.globalParams = GlobalParams.Instance;\r\n    AccessHelper.languageData = LanguageData.Instance;\r\n    AccessHelper.environment = Environment.Instance;\r\n  }\r\n\r\n  /// <summary> Entry point to the Web Client </summary>\r\n  /// <param name=\"args\">array of command line arguments</param>\r\n  static Main(httpClient: HttpClient): void {\r\n    // TODO : Check how to load from Studio i.e. F7\r\n    // if (args.length !== 0 && NString.StartsWith(args[0], \"/spawnahead\")) {\r\n    //   ClientManager._startedFromStudio = true;\r\n    //   StudioLauncher.Init(args);\r\n    // }\r\n    // else\r\n    ClientManager.StartExecution(httpClient);\r\n\r\n    Logger.Instance.Flush();\r\n  }\r\n\r\n  /// <summary> Terminate the client and terminate the context </summary>\r\n  static async StopExecution(): Promise <void> {\r\n    try {\r\n      HttpManager.GetInstance().IsAbortingMagicEngine = true;\r\n      MGDataCollection.Instance.StartupMgData.getFirstTask().ClosingFormUI = true;\r\n\r\n      await MGDataCollection.Instance.StartupMgData.getFirstTask().endTask(true, false,\r\n        false);\r\n    }\r\n    catch (ex3) {\r\n      if (ex3 instanceof ApplicationException) {\r\n        Logger.Instance.WriteExceptionToLog(ex3);\r\n      }\r\n      else\r\n        throw ex3;\r\n    }\r\n  }\r\n\r\n  static async StartExecution(httpClient:HttpClient): Promise<void> {\r\n    HttpManager.setNativeHttpClient(httpClient);\r\n    let loaded: boolean = await ClientManager.Instance.LoadExecutionProps();\r\n\r\n    if (loaded) {\r\n      ClientManager.Instance._guiEventsProcessor = new GuiEventsProcessor();\r\n      ClientManager.Instance.InitGuiManager();\r\n      ClientManager.Instance.InitCircularReferencesBypasses();\r\n      let versionString = CurrentClientVersion ===  '0.0.0.0' ? \"Development mode\" : \"Version : \" + CurrentClientVersion ;\r\n\r\n      console.log(\"Magic Web Client. \" + versionString);\r\n\r\n      HttpManager.GetInstance().HttpCommunicationTimeoutMS = ServerConfig.Instance.GetFirstHttpRequestTimeout();\r\n\r\n      EventsManager.Instance.Init();\r\n\r\n      Logger.Instance.Initialize(RemoteCommandsProcessor.GetInstance().parseLogLevel(ServerConfig.Instance.getInternalLogLevel()),false);\r\n\r\n      let mgd: MGData = new MGData(\r\n        new CommandsTable(),\r\n        new CommandsTable(),\r\n        0, null, false);\r\n      await MGDataCollection.Instance.addMGData(mgd, 0, true);\r\n\r\n      await ClientManager.Instance.WorkThreadExecution();\r\n\r\n      if (Logger.Instance.ShouldLog()) {\r\n        Logger.Instance.WriteToLog(OSEnvironment.EolSeq + \"Ended on \" + DateTimeUtils.ToString(DateTime.Now, \"dd/MM/yyyy\", Logger.Instance) + OSEnvironment.EolSeq + OSEnvironment.EolSeq, false);\r\n      }\r\n    }\r\n    else\r\n    {\r\n      await GUIManager.Instance.MessageBox(\"Error\", \"Failed to load server configuration file (\" + this._executionPropertiesFileName + \")\", Styles.MSGBOX_ICON_ERROR | Styles.MSGBOX_BUTTON_OK);\r\n    }\r\n  }\r\n\r\n  /// <summary> Loads the execution properties file that contains information about the server,\r\n  /// application and program to execute\r\n  /// </summary>\r\n  async LoadExecutionProps(): Promise<boolean> {\r\n    // return true, if successfully loaded.\r\n    let response: string = \"\";\r\n    let succeeded: boolean = true;\r\n\r\n    try {\r\n      // isError cannot be true here, because it is returned by runtime engine and to read execution properties, we do not reach the engine.\r\n      let isError: RefParam<boolean> = new RefParam(false);\r\n      response = await HttpManager.GetInstance().GetContent(ClientManager._executionPropertiesFileName, null, false, isError);\r\n      ServerConfig.Instance.Init(JSON.parse(response));\r\n    }\r\n    catch (ex) {\r\n      succeeded = false;\r\n      // TODO: should we write the error message to log?\r\n      // TODO: should we display an error message on the browser?\r\n    }\r\n\r\n    return succeeded;\r\n  }\r\n\r\n  /// <summary>\r\n  /// return a copy of the current execution properties\r\n  /// </summary>\r\n  /// <returns>a copy of the current execution properties</returns>\r\n  copyExecutionProps(): IServerConfig {\r\n    //return this._executionProps.Clone();\r\n    throw new Exception(\"copyExecutionProps not implemented\");\r\n  }\r\n\r\n  getDebugClient(): string {\r\n    return this._debugClient;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  /// GET URL value of the execution property\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  getURLFromExecutionProperties(executionPropName: string): URL {\r\n    let url: URL = null;\r\n    let urlStr: string = ServerConfig.Instance.GetExecutionProperty[executionPropName];\r\n\r\n    if (urlStr !== null && typeof urlStr !== \"undefined\") {\r\n      // if relative, prefix with the 'protocol://server/' from which the rich-client was activated\r\n      if (urlStr.startsWith(\"/\"))\r\n        urlStr = ServerConfig.Instance.getProtocol() + \"://\" + ServerConfig.Instance.getServer() + urlStr;\r\n\r\n      try {\r\n        url = new URL(urlStr);\r\n        Debug.Assert(url.protocol === \"http:\" || url.protocol === \"https:\");\r\n      }\r\n      catch (ex) {\r\n        Logger.Instance.WriteExceptionToLog(ex);\r\n      }\r\n    }\r\n    return url;\r\n  }\r\n\r\n\r\n  getLogonWindowIconURL(): URL {\r\n    return this.getURLFromExecutionProperties(GuiConstants.STR_LOGO_WIN_ICON_URL);\r\n  }\r\n\r\n  getLogonWindowImageURL(): URL {\r\n    return this.getURLFromExecutionProperties(GuiConstants.STR_LOGON_IMAGE_URL);\r\n  }\r\n\r\n\r\n\r\n\r\n\r\n  /// <summary> true if delay is in progress</summary>\r\n  isDelayInProgress(): boolean {\r\n    return this._delayInProgress;\r\n  }\r\n\r\n  setDelayInProgress(delayInProgress: boolean): void {\r\n    this._delayInProgress = delayInProgress;\r\n  }\r\n\r\n\r\n  /// <summary>global unique ID of the session = 'machine unique ID' + 'process ID'</summary>\r\n  /// <returns></returns>\r\n  GetGlobalUniqueSessionID(): string {\r\n    return this._globalUniqueSessionId;\r\n  }\r\n\r\n  /// <summary>return the absolute file name of the execution properties file being used by the client</summary>\r\n  /// <returns></returns>\r\n  private static getExecutionPropertiesFileName(): string {\r\n    let fullyQualifiedName: string = null;\r\n    let lastPathSeparator: number = fullyQualifiedName.lastIndexOf('\\\\');\r\n    return NString.Remove(fullyQualifiedName, lastPathSeparator + 1, fullyQualifiedName.length - lastPathSeparator - 1) + ConstInterface.EXECUTION_PROPERTIES_FILE_NAME;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   Get control's picture\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  static  GetControlPictureMask(taskId: string, controlName: string): PIC\r\n  {\r\n    let pic: PIC = null;\r\n    let task: Task = <Task>MGDataCollection.Instance.GetTaskByID(taskId);\r\n\r\n    let control: MgControlBase = null;\r\n\r\n    if (controlName !== null) {\r\n      control = task.getForm().GetCtrl(controlName);\r\n      pic = control.getPIC();\r\n    }\r\n\r\n    return pic;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Get formatted value\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  static  GetFormattedValue(taskId: string, controlName: string, value: any): string\r\n  {\r\n    let pic: PIC = null;\r\n    let task: Task = <Task>MGDataCollection.Instance.GetTaskByID(taskId);\r\n\r\n    let control: MgControlBase = null;\r\n    let newValue: any = value;\r\n\r\n    if (controlName !== null)\r\n      control = task.getForm().GetCtrl(controlName);\r\n    if (control != null && control.DataType == StorageAttribute.NUMERIC) {\r\n      pic = control.getPIC();\r\n\r\n      let dispValue = String(value);\r\n      let  newPic = pic.getUnformattedNumericPic();\r\n\r\n      let num = DisplayConvertor.Instance.toNum(dispValue, newPic, 0);\r\n      newValue = DisplayConvertor.Instance.fromNum(num, pic);\r\n    }\r\n    return newValue;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get ranged value for input value\r\n  /// </summary>\r\n  static  GetRangedValue(taskId: string, controlName: string, value: string): string\r\n  {\r\n    let task: Task = <Task>MGDataCollection.Instance.GetTaskByID(taskId);\r\n\r\n    let control: MgControlBase = null;\r\n\r\n    if (controlName !== null)\r\n    {\r\n      control =  task.getForm().GetCtrl(controlName);\r\n      return control.getRangedValue(value);\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   validate user input value\r\n  /// </summary>\r\n  static  ValidateControlValue(taskId: string, controlName: string, value: any): string\r\n  {\r\n    let task: Task = <Task>MGDataCollection.Instance.GetTaskByID(taskId);\r\n\r\n    let control: MgControl = null;\r\n\r\n    if (controlName !== null)\r\n    {\r\n      control =  task.getForm().GetCtrl(controlName) as MgControl;\r\n      return control.validate(value);\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Get fld ranges\r\n  /// </summary>\r\n  static GetFldRanges(taskId: string, controlName: string): string {\r\n    let task: Task = <Task>MGDataCollection.Instance.GetTaskByID(taskId);\r\n\r\n    let control: MgControl = null;\r\n\r\n    if (controlName !== null)\r\n    {\r\n      control =  task.getForm().GetCtrl(controlName) as MgControl;\r\n      return control.getRanges();\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Returns whether client/server cache exists\r\n  /// </summary>\r\n  static TransCacheExists(): boolean {\r\n    let clientTransCacheExists: boolean = AccessHelper.mgDataTable.getCurrMGData().clientTransactionCacheExists();\r\n    let serverTransactionCacheExists: boolean = AccessHelper.mgDataTable.getCurrMGData().serverTransactionCacheExists();\r\n\r\n    return clientTransCacheExists || serverTransactionCacheExists;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Subscribe for events defined at HttpClientEvents and\r\n  /// attach appropriate event handlers\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  RegisterDelegates(): void {\r\n    HttpClientEvents.GetExecutionProperty_Event = ServerConfig.Instance.GetExecutionProperty.bind(ServerConfig.Instance);\r\n    HttpClientEvents.GetRuntimeCtxID_Event = this.GetRuntimeCtxID.bind(this);\r\n    HttpClientEvents.GetGlobalUniqueSessionID_Event = this.GetGlobalUniqueSessionID.bind(this);\r\n    HttpClientEvents.ShouldDisplayGenericError_Event = ServerConfig.Instance.ShouldDisplayGenericError.bind(ServerConfig.Instance);\r\n  }\r\n\r\n  /// <summary>\r\n  /// Retrieves runtime context ID\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  GetRuntimeCtxID(): string {\r\n    return RuntimeContextBase.Instance.ContextID;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Send a request to server to terminate the context using fetch API with keep-alive\r\n  /// </summary>\r\n  static TerminateContextUsingFetchAPI(): void {\r\n\r\n    // If Session is re-initializing means the context is not found at server.\r\n    // then there is no point in terminating context.\r\n    if (RemoteCommandsProcessor.IsSessionReInitializing)\r\n      return;\r\n    HttpManager.GetInstance().IsAbortingMagicEngine = true;\r\n\r\n    // Due to payload limit of fetch API, send only the context termination command to server\r\n    MGDataCollection.Instance.getCurrMGData().CmdsToServer.Clear();\r\n\r\n    let contextTerminationEventCommand: ContextTerminationEventCommand = CommandFactory.\r\n    CreateContextTerminationEventCommand(MGDataCollection.Instance.StartupMgData.getFirstTask().getTaskTag());\r\n\r\n    MGDataCollection.Instance.getCurrMGData().CmdsToServer.Add(<IClientCommand>contextTerminationEventCommand);\r\n\r\n    // response need not to be handled as the browser unload cannot be stopped, so no need to wait\r\n    RemoteCommandsProcessor.GetInstance().Execute(CommandsProcessorBase_SendingInstruction.ONLY_COMMANDS);\r\n  }\r\n}\r\n"]}

package/esm2020/src/CommandsProcessorBase.mjs

@@ -0,0 +1,58 @@
+import { XMLConstants } from '@magic-xpa/utils';
+import { Scrambler } from './util/Scrambler';
+import { isNullOrUndefined } from '@magic-xpa/mscorelib';
+export var CommandsProcessorBase_SessionStage;
+(function (CommandsProcessorBase_SessionStage) {
+    CommandsProcessorBase_SessionStage[CommandsProcessorBase_SessionStage["HANDSHAKE"] = 1] = "HANDSHAKE";
+    CommandsProcessorBase_SessionStage[CommandsProcessorBase_SessionStage["INITIAL"] = 2] = "INITIAL";
+    CommandsProcessorBase_SessionStage[CommandsProcessorBase_SessionStage["NORMAL"] = 3] = "NORMAL";
+})(CommandsProcessorBase_SessionStage || (CommandsProcessorBase_SessionStage = {}));
+export var CommandsProcessorBase_SendingInstruction;
+(function (CommandsProcessorBase_SendingInstruction) {
+    CommandsProcessorBase_SendingInstruction[CommandsProcessorBase_SendingInstruction["NO_TASKS_OR_COMMANDS"] = 0] = "NO_TASKS_OR_COMMANDS";
+    CommandsProcessorBase_SendingInstruction[CommandsProcessorBase_SendingInstruction["ONLY_COMMANDS"] = 1] = "ONLY_COMMANDS";
+    CommandsProcessorBase_SendingInstruction[CommandsProcessorBase_SendingInstruction["TASKS_AND_COMMANDS"] = 2] = "TASKS_AND_COMMANDS";
+})(CommandsProcessorBase_SendingInstruction || (CommandsProcessorBase_SendingInstruction = {}));
+export class CommandsProcessorBase {
+    constructor() {
+        this._sessionCounter = 0;
+    }
+    GetSessionCounter() {
+        return this._sessionCounter;
+    }
+    async StartSession() {
+        return Promise.resolve(true);
+    }
+    async Execute(sendingInstruction, sessionStage, res) {
+        if (isNullOrUndefined(sessionStage)) {
+            await this.Execute_0(sendingInstruction);
+            return;
+        }
+        await this.Execute_1(sendingInstruction, sessionStage, res);
+    }
+    async Execute_0(sendingInstruction) {
+        await this.Execute_1(sendingInstruction, CommandsProcessorBase_SessionStage.NORMAL, null);
+    }
+    async Execute_1(sendingInstruction, sessionStage, res) {
+        return Promise.resolve();
+    }
+    async GetContent(requestedURL, useCache) {
+        return Promise.resolve('');
+    }
+    static UnScramble(respBuf) {
+        let openTagLocation = respBuf.indexOf(XMLConstants.MG_TAG_OPEN);
+        let core;
+        if (openTagLocation !== -1) {
+            let start = openTagLocation + XMLConstants.MG_TAG_OPEN.length;
+            let openTag = respBuf.substr(0, start);
+            let finish = respBuf.lastIndexOf(XMLConstants.TAG_OPEN);
+            let closeTag = respBuf.substr(finish);
+            core = openTag + Scrambler.UnScramble(respBuf, start, finish - 1) + closeTag;
+        }
+        else {
+            core = Scrambler.UnScramble(respBuf, 0, respBuf.length - 1);
+        }
+        return core;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CommandsProcessorBase.js","sourceRoot":"","sources":["../../../../../projects/engine/src/CommandsProcessorBase.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEhD,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAGzD,MAAM,CAAN,IAAY,kCAKX;AALD,WAAY,kCAAkC;IAE5C,qGAAa,CAAA;IACb,iGAAO,CAAA;IACP,+FAAM,CAAA;AACR,CAAC,EALW,kCAAkC,KAAlC,kCAAkC,QAK7C;AAGD,MAAM,CAAN,IAAY,wCAIX;AAJD,WAAY,wCAAwC;IAClD,uIAAoB,CAAA;IACpB,yHAAa,CAAA;IACb,mIAAkB,CAAA;AACpB,CAAC,EAJW,wCAAwC,KAAxC,wCAAwC,QAInD;AAGD,MAAM,OAAgB,qBAAqB;IAA3C;QACE,oBAAe,GAAW,CAAC,CAAC;IAyE9B,CAAC;IAvEC,iBAAiB;QACf,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IAMD,KAAK,CAAC,YAAY;QAChB,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAQD,KAAK,CAAC,OAAO,CAAC,kBAA4D,EAAE,YAAiD,EAAE,GAAkB;QAC/I,IAAI,iBAAiB,CAAC,YAAY,CAAC,EAAE;YACnC,MAAM,IAAI,CAAC,SAAS,CAAC,kBAAkB,CAAC,CAAC;YACzC,OAAO;SACR;QACD,MAAM,IAAI,CAAC,SAAS,CAAC,kBAAkB,EAAE,YAAY,EAAE,GAAG,CAAC,CAAC;IAC9D,CAAC;IAIO,KAAK,CAAC,SAAS,CAAC,kBAA4D;QAClF,MAAM,IAAI,CAAC,SAAS,CAAC,kBAAkB,EAAE,kCAAkC,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC5F,CAAC;IAMD,KAAK,CAAC,SAAS,CAAC,kBAA4D,EAAE,YAAgD,EAAE,GAAiB;QAC/I,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;IAKD,KAAK,CAAC,UAAU,CAAC,YAAoB,EAAE,QAAiB;QACtD,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IAC7B,CAAC;IAOD,MAAM,CAAC,UAAU,CAAC,OAAe;QAC/B,IAAI,eAAe,GAAW,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;QACxE,IAAI,IAAY,CAAC;QAEjB,IAAI,eAAe,KAAK,CAAC,CAAC,EAAE;YAC1B,IAAI,KAAK,GAAW,eAAe,GAAG,YAAY,CAAC,WAAW,CAAC,MAAM,CAAC;YACtE,IAAI,OAAO,GAAW,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;YAE/C,IAAI,MAAM,GAAW,OAAO,CAAC,WAAW,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;YAChE,IAAI,QAAQ,GAAW,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YAE9C,IAAI,GAAG,OAAO,GAAG,SAAS,CAAC,UAAU,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,CAAC,GAAG,QAAQ,CAAC;SAC9E;aACI;YAEH,IAAI,GAAG,SAAS,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,EAAE,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;SAC7D;QACD,OAAO,IAAI,CAAC;IACd,CAAC;CACF","sourcesContent":["import { XMLConstants } from '@magic-xpa/utils';\r\nimport { IResultValue } from './rt/IResultValue';\r\nimport { Scrambler } from './util/Scrambler';\r\nimport { isNullOrUndefined } from '@magic-xpa/mscorelib';\r\n\r\n// The stage in the session this execution belongs to\r\nexport enum CommandsProcessorBase_SessionStage\r\n{\r\n  HANDSHAKE = 1,\r\n  INITIAL,\r\n  NORMAL\r\n}\r\n\r\n// instruction what to send during execution\r\nexport enum CommandsProcessorBase_SendingInstruction {\r\n  NO_TASKS_OR_COMMANDS,\r\n  ONLY_COMMANDS,\r\n  TASKS_AND_COMMANDS\r\n}\r\n\r\n/// <summary> this class is responsible for the communication with the server and handling the server messages</summary>\r\nexport abstract class CommandsProcessorBase {\r\n  _sessionCounter: number = 0; // the session counter that should be used on the next access to the server.\r\n\r\n  GetSessionCounter(): number {\r\n    return this._sessionCounter;\r\n  }\r\n\r\n  /// <summary>\r\n  /// start the session - e.g. exchange handshake requests with the Server, if connected.\r\n  /// </summary>\r\n  /// <returns>true only if the Client should continue to start the actual requested program.</returns>\r\n  async StartSession(): Promise<boolean>{\r\n    return Promise.resolve(true);\r\n  }\r\n\r\n  /// <summary>build the xml request; send it to the runtime-engine; receive a response</summary>\r\n  /// <param name=\"sendingInstruction\">instruction what to send during execution - NO_TASKS_OR_COMMANDS / ONLY_COMMANDS / TASKS_AND_COMMANDS.</param>\r\n  /// <param name=\"sessionStage\">HANDSHAKE / INITIAL / NORMAL.</param>\r\n  /// <param name=\"res\">result ot be  read after parsing the response from the server.</param>\r\n  async Execute(sendingInstruction: CommandsProcessorBase_SendingInstruction): Promise<void>;\r\n  async Execute(sendingInstruction: CommandsProcessorBase_SendingInstruction, sessionStage: CommandsProcessorBase_SessionStage, res: IResultValue): Promise<void>;\r\n  async Execute(sendingInstruction: CommandsProcessorBase_SendingInstruction, sessionStage?: CommandsProcessorBase_SessionStage, res?: IResultValue): Promise<void> {\r\n    if (isNullOrUndefined(sessionStage)) {\r\n      await this.Execute_0(sendingInstruction);\r\n      return;\r\n    }\r\n    await this.Execute_1(sendingInstruction, sessionStage, res);\r\n  }\r\n\r\n  /// <summary>build the xml request; send it to the runtime-engine</summary>\r\n  /// <param name=\"sendingInstruction\">instruction what to send during execution - NO_TASKS_OR_COMMANDS / ONLY_COMMANDS / TASKS_AND_COMMANDS.</param>\r\n  private async Execute_0(sendingInstruction: CommandsProcessorBase_SendingInstruction): Promise<void> {\r\n    await this.Execute_1(sendingInstruction, CommandsProcessorBase_SessionStage.NORMAL, null);\r\n  }\r\n\r\n  /// <summary>build the xml request; send it to the runtime-engine; receive a response</summary>\r\n  /// <param name=\"sendingInstruction\">instruction what to send during execution - NO_TASKS_OR_COMMANDS / ONLY_COMMANDS / TASKS_AND_COMMANDS.</param>\r\n  /// <param name=\"sessionStage\">HANDSHAKE / INITIAL / NORMAL.</param>\r\n  /// <param name=\"res\">result ot be  read after parsing the response from the server.</param>\r\n  async Execute_1(sendingInstruction: CommandsProcessorBase_SendingInstruction, sessionStage: CommandsProcessorBase_SessionStage, res: IResultValue): Promise<void>{\r\n    return Promise.resolve();\r\n  }\r\n\r\n  /// <summary> Invoke the request URL & return the response.</summary>\r\n  /// <param name=\"requestedURL\">URL to be accessed.</param>\r\n  /// <returns>response (from the server).</returns>\r\n  async GetContent(requestedURL: string, useCache: boolean): Promise<string>{\r\n    return Promise.resolve('');\r\n  }\r\n\r\n  /// <summary>send Monitor messaging to the server</summary>\r\n  abstract SendMonitorOnly(): void ;\r\n\r\n  /// <summary> unscramble servers response</summary>\r\n  /// <returns>unscrambled content</returns>\r\n  static UnScramble(respBuf: string): string {\r\n    let openTagLocation: number = respBuf.indexOf(XMLConstants.MG_TAG_OPEN);\r\n    let core: string;\r\n\r\n    if (openTagLocation !== -1) {\r\n      let start: number = openTagLocation + XMLConstants.MG_TAG_OPEN.length;\r\n      let openTag: string = respBuf.substr(0, start);\r\n\r\n      let finish: number = respBuf.lastIndexOf(XMLConstants.TAG_OPEN);\r\n      let closeTag: string = respBuf.substr(finish);\r\n\r\n      core = openTag + Scrambler.UnScramble(respBuf, start, finish - 1) + closeTag;\r\n    }\r\n    else {\r\n      // We got a scrambled error message, there is no open tag\r\n      core = Scrambler.UnScramble(respBuf, 0, respBuf.length - 1);\r\n    }\r\n    return core;\r\n  }\r\n}\r\n"]}