@magic-xpa/engine 4.1100.0-dev4110.20 → 4.1100.0-dev4110.202

package/esm2022/src/remote/RemoteCommandsProcessor.mjs

@@ -0,0 +1,882 @@
+import { Base64, JSON_Utils, Logger, Logger_LogLevels, Misc, MsgInterface, OSEnvironment, RequestInfo, StrUtil, XMLConstants } from "@magic-xpa/utils";
+import { Debug, Encoding, Exception, List, NString, RefParam, StringBuilder, isNullOrUndefined, isUndefined } from "@magic-xpa/mscorelib";
+import { Commands, RuntimeContextBase, Styles, UsernamePasswordCredentials } from "@magic-xpa/gui";
+import { ExecOperCommand } from '../commands/ClientToServer/ExecOperCommand';
+import { CommandsProcessorBase, CommandsProcessorBase_SendingInstruction, CommandsProcessorBase_SessionStage } from "../CommandsProcessorBase";
+import { HttpManager } from "../http/HttpManager";
+import { ConstInterface } from "../ConstInterface";
+import { Scrambler } from "../util/Scrambler";
+import { ServerError } from "./ServerError";
+import { FlowMonitorQueue } from "../util/FlowMonitorQueue";
+import { OpeningTaskDetails } from "../tasks/TaskBase";
+import { HttpUtility } from "../http/client/HttpUtility";
+import { HttpClientEvents } from "../http/client/HttpClientEvents";
+import { ServerConfig } from "../ServerConfig";
+import { AccessHelper } from "../AccessHelper";
+import { Environment, Event, EventCommand, EventsManager, GUIManager } from "../../";
+import { MGDataCollection } from "../tasks/MGDataCollection";
+import { timer } from "rxjs";
+var RequestStatus;
+(function (RequestStatus) {
+    RequestStatus[RequestStatus["Handled"] = 0] = "Handled";
+    RequestStatus[RequestStatus["Retry"] = 1] = "Retry";
+    RequestStatus[RequestStatus["Abort"] = 2] = "Abort";
+})(RequestStatus || (RequestStatus = {}));
+export class RemoteCommandsProcessor extends CommandsProcessorBase {
+    static RC_NO_CONTEXT_ID = '-1';
+    static _instance = null;
+    static IsSessionReInitializing = false;
+    static lastExceptionMessage = null;
+    static InitialUrl = null;
+    static WEB_COMMUNICATION_PROTOCOL_VERSION = "14002";
+    _lastRequestTime = 0;
+    ServerUrl = null;
+    static _shouldScrambleAndUnscrambleMessages = false;
+    SessionId;
+    DelayCommandExecution = false;
+    _requestInfo = new RequestInfo();
+    static GetInstance() {
+        if (RemoteCommandsProcessor._instance === null) {
+            RemoteCommandsProcessor._instance = new RemoteCommandsProcessor();
+        }
+        return RemoteCommandsProcessor._instance;
+    }
+    constructor() {
+        super();
+        this.ServerUrl = ServerConfig.Instance.getServerURL();
+        HttpManager.GetInstance();
+        this.RegisterDelegates();
+    }
+    CheckAndSetSessionCounter(newSessionCounter) {
+        if (newSessionCounter === ConstInterface.SESSION_COUNTER_CLOSE_CTX_INDICATION) {
+            Debug.Assert(this.GetSessionCounter() === ConstInterface.SESSION_COUNTER_CLOSE_CTX_INDICATION);
+        }
+        else {
+            Debug.Assert(newSessionCounter === this.GetSessionCounter() + 1);
+            this.SetSessionCounter(newSessionCounter);
+            Logger.Instance.WriteServerToLog(NString.Format("Session Counter --> {0}", this._sessionCounter));
+        }
+    }
+    ClearSessionCounter() {
+        this._sessionCounter = 0;
+        Logger.Instance.WriteServerToLog(NString.Format("Session Counter --> {0}", this._sessionCounter));
+    }
+    SetSessionCounter(newSessionCounter) {
+        this._sessionCounter = newSessionCounter;
+    }
+    get GetLastRequestTime() {
+        return this._lastRequestTime;
+    }
+    async ReStartSession() {
+        RemoteCommandsProcessor.IsSessionReInitializing = true;
+        await this.StoreSessionReInitializingDataOnLocalStorage();
+        let navigateRootRoute = false;
+        if (!RuntimeContextBase.Instance.RemovedContextFromServer)
+            navigateRootRoute = Environment.Instance.getSpecialRouteToRootProgOnContextRecreation() ? true : false;
+        Commands.addRefreshPage(navigateRootRoute, RemoteCommandsProcessor.InitialUrl);
+        throw new Exception('');
+    }
+    async StoreSessionReInitializingDataOnLocalStorage() {
+        let mainPrgViewStringForServer = await this.BuildXMLForMainProgramDataView();
+        let globalParamsString = AccessHelper.globalParams.mirrorAllToXML();
+        let changedEnvVarList = AccessHelper.envParamsTable.mirrorAllToXML();
+        let dataStorage = window.localStorage;
+        dataStorage.setItem(ConstInterface.IS_SESSION_REINITIALIZING, "true");
+        dataStorage.setItem(ConstInterface.MAIN_PROG_VIEW, mainPrgViewStringForServer.toString());
+        dataStorage.setItem(ConstInterface.GLOBAL_PARAM_LIST, globalParamsString);
+        dataStorage.setItem(ConstInterface.ENV_VAR_LIST, changedEnvVarList);
+        dataStorage.setItem(ConstInterface.LAST_EXCEPTION, RemoteCommandsProcessor.lastExceptionMessage);
+        if (RuntimeContextBase.Instance.RemovedContextFromServer)
+            dataStorage.setItem(ConstInterface.CTX_REMOVED_FROM_SRVR, "1");
+        EventsManager.Instance.storeLastSavedRouteEventOnLocalStorage();
+    }
+    RestoreSessionReInitializingDataFromLocalStorage(key) {
+        let dataStorage = window.localStorage;
+        let val = dataStorage.getItem(key);
+        return val;
+    }
+    async StartSession() {
+        let authenticationCancelled = false;
+        let handshakeResponse = null;
+        try {
+            let lastTypedUserId = null;
+            let handshakeInitialTokens = new StringBuilder();
+            handshakeInitialTokens.Append(ConstInterface.UTF8TRANS +
+                ConstInterface.REQ_APP_NAME + "=" +
+                HttpUtility.UrlEncode(ServerConfig.Instance.getAppName(), Encoding.UTF8));
+            handshakeInitialTokens.Append("&" + ConstInterface.REQ_ARGS + "=" + ConstInterface.REQ_ARG_ALPHA +
+                "<Richclient><Requires EncryptionKey=\"False\"/><RIAProtocolVersion=\"" + RemoteCommandsProcessor.WEB_COMMUNICATION_PROTOCOL_VERSION + "\"/></Richclient>");
+            Logger.Instance.WriteDevToLog(NString.Format("Handshake request #1 (not scrambled) : {0}", this.ServerUrl + ConstInterface.REQ_ARG_START +
+                ConstInterface.RC_INDICATION_INITIAL + handshakeInitialTokens));
+            let handshakeInitialUrl = this.ServerUrl + ConstInterface.REQ_ARG_START +
+                ConstInterface.RC_INDICATION_INITIAL +
+                ConstInterface.RC_TOKEN_DATA +
+                HttpUtility.UrlEncode(Scrambler.Scramble(handshakeInitialTokens.ToString()), Encoding.UTF8);
+            Logger.Instance.WriteServerMessagesToLog("");
+            Logger.Instance.WriteServerMessagesToLog(NString.Format("Handshake request #1: {0}", handshakeInitialUrl));
+            let ctxGroup = ServerConfig.Instance.getCtxGroup();
+            while (!authenticationCancelled) {
+                let requestStatus = new RefParam(RequestStatus.Handled);
+                let responseStr = await this.DispatchRequest(handshakeInitialUrl, null, CommandsProcessorBase_SessionStage.HANDSHAKE, requestStatus);
+                if (NString.IsNullOrEmpty(responseStr)) {
+                    throw new ServerError("Client failed to initialize a session." + OSEnvironment.EolSeq +
+                        "Empty response was received from the web server." + OSEnvironment.EolSeq + OSEnvironment.EolSeq + this.ServerUrl);
+                }
+                Logger.Instance.WriteServerMessagesToLog(NString.Format("Handshake response #1: {0}", responseStr));
+                Logger.Instance.WriteServerMessagesToLog("");
+                handshakeResponse = new HandshakeResponse(responseStr);
+                RuntimeContextBase.Instance.ContextID = handshakeResponse.ContextId;
+                this.SessionId = handshakeResponse.GetSessionId;
+                HttpManager.GetInstance().HttpCommunicationTimeoutMS = handshakeResponse.HttpTimeout * 1000;
+                if (NString.IsNullOrEmpty(ServerConfig.Instance.getCtxGroup())) {
+                    ctxGroup = handshakeResponse.ContextId;
+                }
+                let credentials = null;
+                if (ServerConfig.Instance.getSkipAuthenticationDialog()) {
+                    if (ServerConfig.Instance.getUsername() !== null) {
+                        credentials = new UsernamePasswordCredentials(ServerConfig.Instance.getUsername(), ServerConfig.Instance.getPassword());
+                        ServerConfig.Instance.setUsername("");
+                        ServerConfig.Instance.setPassword("");
+                    }
+                }
+                else if (handshakeResponse.InputPassword && handshakeResponse.SystemLogin !== HandshakeResponse.SYSTEM_LOGIN_AD) {
+                    if (lastTypedUserId !== null) {
+                        let title = AccessHelper.languageData.getConstMessage(MsgInterface.BRKTAB_STR_ERROR);
+                        let error = AccessHelper.languageData.getConstMessage(MsgInterface.USRINP_STR_BADPASSW);
+                        await GUIManager.Instance.MessageBox(title, error, Styles.MSGBOX_ICON_ERROR | Styles.MSGBOX_BUTTON_OK);
+                    }
+                }
+                if (authenticationCancelled) {
+                    this.SetSessionCounter(ConstInterface.SESSION_COUNTER_CLOSE_CTX_INDICATION);
+                }
+                let handshakeAuthUrl = this.PrepareAuthenticationUrl(handshakeResponse.ContextId, ctxGroup, this.GetSessionCounter());
+                try {
+                    if (credentials !== null) {
+                        let credentialsStr = credentials.Username + ":";
+                        if (!NString.IsNullOrEmpty(credentials.Password)) {
+                            credentialsStr = credentialsStr + credentials.Password + ":";
+                        }
+                        credentialsStr += handshakeResponse.ContextId;
+                        credentialsStr = Scrambler.Scramble(credentialsStr);
+                        credentialsStr = Base64.encode(credentialsStr, true, Encoding.UTF8);
+                        handshakeAuthUrl += ("&USERNAME=" + HttpUtility.UrlEncode(credentialsStr, Encoding.UTF8));
+                        Logger.Instance.WriteServerMessagesToLog(NString.Format("Handshake request #2: {0}", handshakeAuthUrl));
+                        let statusRequest = new RefParam(RequestStatus.Handled);
+                        responseStr = await this.DispatchRequest(handshakeAuthUrl, null, CommandsProcessorBase_SessionStage.HANDSHAKE, statusRequest);
+                        if (responseStr.indexOf(handshakeResponse.ContextId) === -1) {
+                            throw new ServerError(AccessHelper.languageData.getConstMessage(MsgInterface.USRINP_STR_BADPASSW));
+                        }
+                        ServerConfig.Instance.setUsername(credentials.Username);
+                        ServerConfig.Instance.setPassword(credentials.Password);
+                    }
+                    else {
+                        let requestStatus = new RefParam(RequestStatus.Handled);
+                        Logger.Instance.WriteServerMessagesToLog(NString.Format("Handshake request #2: {0}", handshakeAuthUrl));
+                        responseStr = await this.DispatchRequest(handshakeAuthUrl, null, CommandsProcessorBase_SessionStage.HANDSHAKE, requestStatus);
+                    }
+                    Logger.Instance.WriteServerMessagesToLog(NString.Format("Handshake response #2: {0}", responseStr));
+                    Logger.Instance.WriteServerMessagesToLog("");
+                    break;
+                }
+                catch (ex) {
+                    if (ex instanceof ServerError) {
+                        let serverError = ex;
+                        if (ServerConfig.Instance.getSkipAuthenticationDialog()) {
+                            switch (serverError.GetCode()) {
+                                case ServerError.ERR_ACCESS_DENIED:
+                                case ServerError.ERR_AUTHENTICATION:
+                                    ServerConfig.Instance.setSkipAuthenticationDialog(false);
+                                    throw serverError;
+                            }
+                        }
+                        if (!handshakeResponse.InputPassword)
+                            throw serverError;
+                        if (serverError.GetCode() !== ServerError.ERR_AUTHENTICATION &&
+                            (!authenticationCancelled || serverError.GetCode() !== ServerError.INF_NO_RESULT)) {
+                            throw serverError;
+                        }
+                    }
+                    else
+                        throw ex;
+                }
+            }
+            ServerConfig.Instance.setSkipAuthenticationDialog(true);
+            ServerConfig.Instance.setCtxGroup(ctxGroup);
+            RemoteCommandsProcessor.ShouldScrambleAndUnscrambleMessages = handshakeResponse.ScrambleMessages;
+            if (Logger.Instance.LogLevel !== Logger_LogLevels.Basic) {
+                let maxInternalLogLevel = handshakeResponse.MaxInternalLogLevel;
+                if (maxInternalLogLevel !== null) {
+                    let maxLogLevel = this.parseLogLevel(maxInternalLogLevel);
+                    if (maxLogLevel < Logger.Instance.LogLevel) {
+                        ServerConfig.Instance.setInternalLogLevel(maxInternalLogLevel);
+                        Logger.Instance.WriteToLog(NString.Format("Internal log level was restricted to '{0}' by the Magic xpa server.", maxInternalLogLevel), false);
+                        Logger.Instance.LogLevel = maxLogLevel;
+                    }
+                }
+            }
+            if (!authenticationCancelled) {
+                await this.ExecuteInitialRequest();
+            }
+        }
+        catch (ex) {
+            if (ex instanceof ServerError)
+                throw ex;
+            if (isNullOrUndefined(ex.InnerException))
+                throw new ServerError(ex.message, new Exception(ex));
+            else
+                throw new ServerError(ex.message, ex.InnerException);
+        }
+        return !authenticationCancelled;
+    }
+    PrepareAuthenticationUrl(contextId, ctxGroup, sessionCount) {
+        let handshakeAuthUrl = this.ServerUrl + ConstInterface.REQ_ARG_START +
+            ConstInterface.RC_INDICATION + ConstInterface.UTF8TRANS +
+            ConstInterface.RC_TOKEN_CTX_ID + contextId;
+        if (!isNullOrUndefined(this.SessionId))
+            handshakeAuthUrl += (ConstInterface.REQ_ARG_SEPARATOR + ConstInterface.RC_TOKEN_SESSION_ID + this.SessionId);
+        handshakeAuthUrl += (ConstInterface.REQ_ARG_SEPARATOR +
+            ConstInterface.RC_TOKEN_SESSION_COUNT + sessionCount +
+            ConstInterface.REQ_ARG_SEPARATOR +
+            ConstInterface.RC_TOKEN_CTX_GROUP + ctxGroup +
+            ConstInterface.REQ_ARG_SEPARATOR +
+            ConstInterface.RC_AUTHENTICATION_REQUEST);
+        return handshakeAuthUrl;
+    }
+    async ExecuteInitialRequest() {
+        await this.Execute_1(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS, CommandsProcessorBase_SessionStage.INITIAL, null);
+    }
+    GetTaskTree(task) {
+        let taskTree = new List();
+        while (!isNullOrUndefined(task)) {
+            taskTree.push(task.getTaskInfo());
+            task = task.getParent();
+        }
+        return taskTree;
+    }
+    async UpdateRequestInfo() {
+        let currMGData = AccessHelper.mgDataTable.getCurrMGData();
+        let eventsManager = AccessHelper.eventsManager;
+        let operExecution = false;
+        let cmdsToServer = currMGData.CmdsToServer;
+        for (let i = 0; i < cmdsToServer.getSize(); i++) {
+            if (cmdsToServer.getCmd(i) instanceof ExecOperCommand) {
+                let operCmd = currMGData.CmdsToServer.getCmd(i);
+                this._requestInfo.serverCallAt = operCmd.getCommandInfo();
+                this._requestInfo.runtimeTaskTree = this.GetTaskTree(operCmd.getTask());
+                operExecution = true;
+                break;
+            }
+        }
+        this._requestInfo.extraInfo.contextID = RuntimeContextBase.Instance.ContextID;
+        this._requestInfo.extraInfo.sessionCounter = this.GetSessionCounter();
+        if (!operExecution) {
+            if (eventsManager.getLastRtEvent() != null && eventsManager.getLastRtEvent().InternalEvent != 0) {
+                let rtEvt = eventsManager.getLastRtEvent();
+                this._requestInfo.runtimeTaskTree = this.GetTaskTree(rtEvt.getTask());
+                let eventDescription = rtEvt.isNewInternalEvent()
+                    ? NString.TrimEnd(rtEvt.getNewInternalEventDescription())
+                    : Event.getInternalEvtDescription(rtEvt.InternalEvent);
+                let cmd = cmdsToServer.getCmd(cmdsToServer.getSize() - 1);
+                if (cmd) {
+                    let commandInfo = NString.IsNullOrEmpty(cmd.getCommandInfo())
+                        ? NString.Empty
+                        : cmd.getCommandInfo();
+                    if (cmd instanceof EventCommand && rtEvt.InternalEvent == cmd.MagicEvent)
+                        eventDescription = NString.Empty;
+                    this._requestInfo.serverCallAt = 'Event ' + commandInfo +
+                        (!NString.IsNullOrEmpty(eventDescription)
+                            ? NString.Format(' while executing [{0}]', eventDescription)
+                            : NString.Empty);
+                }
+            }
+        }
+    }
+    async BuildXMLForMainProgramDataView() {
+        let message = new StringBuilder();
+        let firstMgData = MGDataCollection.Instance.getMGData(0);
+        let mainPrg = firstMgData.getMainProg(0);
+        while (mainPrg != null) {
+            await mainPrg.buildXML(message);
+            mainPrg = firstMgData.getNextMainProg(mainPrg.getCtlIdx());
+        }
+        if (RemoteCommandsProcessor.ShouldScrambleAndUnscrambleMessages) {
+            let scrambledChanges = Scrambler.Scramble(message.ToString());
+            message = new StringBuilder(scrambledChanges);
+        }
+        message.Insert(0, XMLConstants.MG_TAG_OPEN);
+        message.Append(XMLConstants.MG_TAG_XML_END_TAGGED);
+        return message.ToString();
+    }
+    async Execute_1(sendingInstruction, sessionStage, res) {
+        let reqBuf;
+        let isInitialCall = sessionStage === CommandsProcessorBase_SessionStage.INITIAL;
+        let globalParamsString = null;
+        let envVarsString = null;
+        if (this.DelayCommandExecution)
+            return;
+        if (Logger.Instance.LogLevel == Logger_LogLevels.RequestInfo && !isInitialCall)
+            await this.UpdateRequestInfo();
+        if (isInitialCall) {
+            let val = this.RestoreSessionReInitializingDataFromLocalStorage(ConstInterface.IS_SESSION_REINITIALIZING);
+            if (val === 'true') {
+                RemoteCommandsProcessor.IsSessionReInitializing = (val === "true") ? true : false;
+                RemoteCommandsProcessor.lastExceptionMessage = this.RestoreSessionReInitializingDataFromLocalStorage(ConstInterface.LAST_EXCEPTION);
+                let ctxRemoved = this.RestoreSessionReInitializingDataFromLocalStorage(ConstInterface.CTX_REMOVED_FROM_SRVR);
+                if (ctxRemoved !== '1') {
+                    Logger.Instance.WriteErrorToLog(RemoteCommandsProcessor.lastExceptionMessage);
+                    Logger.Instance.WriteToLog("Session is reinitializing...", true);
+                }
+            }
+        }
+        if (sendingInstruction === CommandsProcessorBase_SendingInstruction.NO_TASKS_OR_COMMANDS)
+            reqBuf = null;
+        else {
+            reqBuf = await this.PrepareRequest(sendingInstruction === CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);
+            if (RemoteCommandsProcessor.IsSessionReInitializing || !isInitialCall) {
+                let changes = new StringBuilder();
+                let buffer = new StringBuilder();
+                if (!RemoteCommandsProcessor.IsSessionReInitializing)
+                    buffer.Append(reqBuf);
+                if (RemoteCommandsProcessor.IsSessionReInitializing) {
+                    globalParamsString = this.RestoreSessionReInitializingDataFromLocalStorage(ConstInterface.GLOBAL_PARAM_LIST);
+                    envVarsString = this.RestoreSessionReInitializingDataFromLocalStorage(ConstInterface.ENV_VAR_LIST);
+                }
+                else {
+                    globalParamsString = AccessHelper.globalParams.mirrorToXML();
+                    envVarsString = AccessHelper.envParamsTable.mirrorToXML();
+                }
+                changes.Append(globalParamsString);
+                changes.Append(envVarsString);
+                if (changes.Length > 0) {
+                    changes.Insert(0, "<" + ConstInterface.MG_TAG_ENV_CHANGES + ">");
+                    changes.Append("</" + ConstInterface.MG_TAG_ENV_CHANGES + ">");
+                    if (RemoteCommandsProcessor.ShouldScrambleAndUnscrambleMessages) {
+                        let scrambledChanges = Scrambler.Scramble(changes.ToString());
+                        changes = new StringBuilder(scrambledChanges);
+                    }
+                    changes.Insert(0, XMLConstants.MG_TAG_OPEN);
+                    changes.Append(XMLConstants.MG_TAG_XML_END_TAGGED);
+                    buffer.Append(changes.ToString());
+                }
+                reqBuf = buffer.ToString();
+            }
+        }
+        let requestStatus = new RefParam(RequestStatus.Handled);
+        let respBuf = null;
+        if (RemoteCommandsProcessor.IsSessionReInitializing) {
+            reqBuf = reqBuf + this.RestoreSessionReInitializingDataFromLocalStorage(ConstInterface.MAIN_PROG_VIEW);
+        }
+        if (RuntimeContextBase.Instance.RemovedContextFromServer)
+            requestStatus.value = RequestStatus.Retry;
+        else {
+            if (RuntimeContextBase.Instance.RemovingContextFromServer)
+                RuntimeContextBase.Instance.RemovedContextFromServer = true;
+            respBuf = await this.DispatchRequest(this.ServerUrl, reqBuf, sessionStage, requestStatus);
+        }
+        if (requestStatus.value == RequestStatus.Retry) {
+            await this.ReStartSession();
+        }
+        if (respBuf == null)
+            return;
+        if (isInitialCall) {
+            RemoteCommandsProcessor.InitialUrl = window.location.href;
+            if (RemoteCommandsProcessor.IsSessionReInitializing) {
+                let dataStorage = window.localStorage;
+                dataStorage.removeItem(ConstInterface.IS_SESSION_REINITIALIZING);
+                dataStorage.removeItem(ConstInterface.MAIN_PROG_VIEW);
+                dataStorage.removeItem(ConstInterface.GLOBAL_PARAM_LIST);
+                dataStorage.removeItem(ConstInterface.ENV_VAR_LIST);
+                dataStorage.removeItem(ConstInterface.LAST_EXCEPTION);
+            }
+        }
+        FlowMonitorQueue.Instance.enable(false);
+        await this.ProcessResponse(respBuf, AccessHelper.mgDataTable.currMgdID, null, res);
+        if (RemoteCommandsProcessor.IsSessionReInitializing) {
+            AccessHelper.globalParams.RestoreParams(globalParamsString);
+            AccessHelper.envParamsTable.RestoreParams(envVarsString);
+            let dataStorage = window.localStorage;
+            let ctxRemoved = dataStorage.getItem(ConstInterface.CTX_REMOVED_FROM_SRVR);
+            if (ctxRemoved === "1") {
+                EventsManager.Instance.restoreLastSavedRouteEventFromLocalStorage();
+                dataStorage.removeItem(ConstInterface.CTX_REMOVED_FROM_SRVR);
+                dataStorage.removeItem(ConstInterface.LAST_ROUTE_EVENT);
+                dataStorage.removeItem(ConstInterface.LAST_ROUTE_EVENT_SRC_TSK);
+                dataStorage.removeItem(ConstInterface.LAST_ROUTE_EVENT_ARG_LIST);
+            }
+            RemoteCommandsProcessor.IsSessionReInitializing = false;
+        }
+        if (sendingInstruction === CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS) {
+            AccessHelper.mgDataTable.startTasksIteration();
+            let task;
+            while ((task = AccessHelper.mgDataTable.getNextTask()) !== null) {
+                let dataViewWasRetrieved = task.DataViewWasRetrieved;
+                if (dataViewWasRetrieved) {
+                    await task.RefreshDisplay();
+                }
+            }
+        }
+        if (isInitialCall)
+            ServerConfig.Instance.setGlobalParams(null);
+    }
+    async DispatchRequest(url, reqBuf, sessionStage, requestStatus) {
+        let response = null;
+        let encodedBody = null;
+        requestStatus.value = RequestStatus.Handled;
+        if (url === null) {
+            Logger.Instance.WriteExceptionToLogWithMsg("in sendMsgToSrvr() unknown server");
+            return response;
+        }
+        if (sessionStage !== CommandsProcessorBase_SessionStage.HANDSHAKE) {
+            let urlSuffix = this.BuildUrlSuffix(reqBuf !== null, sessionStage === CommandsProcessorBase_SessionStage.INITIAL);
+            let reqBufEncoded = HttpUtility.UrlEncode(reqBuf, Encoding.UTF8);
+            encodedBody = urlSuffix + reqBufEncoded;
+        }
+        try {
+            if (Logger.Instance.ShouldLogExtendedServerRelatedMessages())
+                Logger.Instance.WriteServerMessagesToLog(NString.Format("MESSAGE TO SERVER:\n URL: {0}\n BODY: {1}", url, encodedBody));
+            response = await this.ExecuteRequest(url, encodedBody);
+            if (!response.toUpperCase().startsWith("<HTML")) {
+                let startIdx = response.indexOf("<xml id=\"MGDATA\">");
+                if (startIdx > 0)
+                    response = response.substr(startIdx);
+            }
+            Logger.Instance.WriteServerMessagesToLog("MESSAGE FROM SERVER: " + response);
+            if (sessionStage === CommandsProcessorBase_SessionStage.HANDSHAKE ||
+                (response.length > 0 &&
+                    RemoteCommandsProcessor.ShouldScrambleAndUnscrambleMessages && response !== "<xml id=\"MGDATA\">\n</xml>")) {
+                if (sessionStage === CommandsProcessorBase_SessionStage.HANDSHAKE) {
+                    Debug.Assert(response.length > 0 && response[0] !== '<');
+                }
+                response = CommandsProcessorBase.UnScramble(response);
+            }
+            Logger.Instance.WriteDevToLog("MESSAGE FROM SERVER: (size = " + response.length + ")" + OSEnvironment.EolSeq + response);
+            this._lastRequestTime = Misc.getSystemMilliseconds();
+        }
+        catch (ex) {
+            if (ex instanceof ServerError) {
+                requestStatus.value = RequestStatus.Abort;
+                if (sessionStage == CommandsProcessorBase_SessionStage.NORMAL) {
+                    if (ex.GetCode() == ServerError.ERR_CTX_NOT_FOUND || ex.GetCode() == ServerError.ERR_THREAD_ABORTED) {
+                        if (RuntimeContextBase.Instance.RemovedContextFromServer) {
+                            requestStatus.value = RequestStatus.Retry;
+                        }
+                        else {
+                            switch (Environment.Instance.getWebClientReinitSession()) {
+                                case 'Y':
+                                    requestStatus.value = RequestStatus.Retry;
+                                    break;
+                                case 'A':
+                                    let retval = await GUIManager.Instance.MessageBox("Error", "Unknown error occurred at server-side." +
+                                        " Would you like to reinitialize the session?", Styles.MSGBOX_BUTTON_YES_NO);
+                                    requestStatus.value = (retval == Styles.MSGBOX_RESULT_YES) ? RequestStatus.Retry : RequestStatus.Abort;
+                                    break;
+                                case 'N':
+                                default:
+                                    requestStatus.value = RequestStatus.Abort;
+                                    break;
+                            }
+                        }
+                        if (requestStatus.value == RequestStatus.Abort) {
+                            Environment.Instance.setWebClientReinitSession('N');
+                            throw ex;
+                        }
+                        else {
+                            let errForConsole = StrUtil.getConsoleErorString(ex.GetMessage());
+                            RemoteCommandsProcessor.lastExceptionMessage = "Exception Occured at server side : " + ex.GetCode().toString() + " : " + errForConsole;
+                            console.log(RemoteCommandsProcessor.lastExceptionMessage);
+                        }
+                        return null;
+                    }
+                }
+            }
+            this.clearLocalStorage();
+            throw ex;
+        }
+        return response;
+    }
+    clearLocalStorage() {
+        window.localStorage.removeItem(ConstInterface.LAST_ROUTE_EVENT);
+        window.localStorage.removeItem(ConstInterface.LAST_ROUTE_EVENT_SRC_TSK);
+        window.localStorage.removeItem(ConstInterface.LAST_ROUTE_EVENT_ARG_LIST);
+        window.localStorage.removeItem(ConstInterface.IS_SESSION_REINITIALIZING);
+        window.localStorage.removeItem(ConstInterface.MAIN_PROG_VIEW);
+        window.localStorage.removeItem(ConstInterface.GLOBAL_PARAM_LIST);
+        window.localStorage.removeItem(ConstInterface.ENV_VAR_LIST);
+        window.localStorage.removeItem(ConstInterface.LAST_EXCEPTION);
+        window.localStorage.removeItem(ConstInterface.CTX_REMOVED_FROM_SRVR);
+    }
+    HandleErrorResponse(response) {
+        try {
+            Logger.Instance.WriteServerMessagesToLog("MESSAGE FROM SERVER: " + response);
+            response = CommandsProcessorBase.UnScramble(response);
+            Logger.Instance.WriteServerMessagesToLog("MESSAGE FROM SERVER: " + StrUtil.getConsoleErorString(response));
+        }
+        catch (ex) {
+        }
+        if (response.startsWith("<xmlerr")) {
+            let errorMessageXml = new ErrorMessageXml(response, this._lastRequestTime, AccessHelper.environment.getContextInactivityTimeout());
+            throw new ServerError(errorMessageXml.GetMessage(), errorMessageXml.GetCode());
+        }
+        else if (response.toUpperCase().startsWith("<HTML")) {
+            throw new ServerError(response);
+        }
+    }
+    async ExecuteRequest(url, encodedBody) {
+        return await this.GetContent(url, false, encodedBody);
+    }
+    async GetContent(requestedURL, useCache, requestContent) {
+        if (isUndefined(requestContent))
+            requestContent = null;
+        let responseStr;
+        try {
+            if (requestedURL.startsWith("/"))
+                requestedURL = ServerConfig.Instance.getProtocol() + "://" + ServerConfig.Instance.getServer() + requestedURL;
+            var spinnerTimer = timer(50, 50);
+            var spinnerTimerSubscription = spinnerTimer.subscribe(() => {
+                AccessHelper.eventsManager.CheckAndShowSpinner(true);
+            });
+            let isError = new RefParam(false);
+            responseStr = await HttpManager.GetInstance().GetContent(requestedURL, requestContent, useCache, isError);
+            spinnerTimerSubscription.unsubscribe();
+            spinnerTimerSubscription = null;
+            if (isError.value) {
+                this.HandleErrorResponse(responseStr);
+            }
+        }
+        catch (ex) {
+            if (!(ex instanceof ServerError) || Logger.Instance.LogLevel !== Logger_LogLevels.Basic) {
+                Logger.Instance.WriteExceptionToLog(ex, NString.Format("requested URL = \"{0}\"", requestedURL));
+            }
+            if (!(ex instanceof ServerError)) {
+                ex = new ServerError(ex.Message, ex.InnerException ? ex.InnerException : ex);
+            }
+            throw ex;
+        }
+        finally {
+            if (spinnerTimerSubscription != null)
+                spinnerTimerSubscription.unsubscribe();
+        }
+        return responseStr;
+    }
+    ClientActivated() {
+    }
+    BuildUrlSuffix(hasContent, isInitialCall) {
+        let prefix = ConstInterface.RC_INDICATION + ConstInterface.RC_TOKEN_CTX_ID + RuntimeContextBase.Instance.ContextID;
+        if (!isNullOrUndefined(this.SessionId))
+            prefix += (ConstInterface.REQ_ARG_SEPARATOR + ConstInterface.RC_TOKEN_SESSION_ID + this.SessionId);
+        if (isInitialCall) {
+            if (RemoteCommandsProcessor.IsSessionReInitializing)
+                prefix += (ConstInterface.REQ_ARG_SEPARATOR + ConstInterface.WEBCLIENT_REINITIALIZE_REQUEST);
+            let globalParams = ServerConfig.Instance.getGlobalParams();
+            if (globalParams !== null) {
+                globalParams = NString.Replace(globalParams, "+", "%2B");
+                prefix += ("&" + ConstInterface.MG_TAG_GLOBALPARAMS + "=" + globalParams);
+            }
+        }
+        if (hasContent) {
+            prefix += ("&" + ConstInterface.RC_TOKEN_SESSION_COUNT + this.GetSessionCounter() +
+                ConstInterface.REQ_ARG_SEPARATOR + ConstInterface.RC_TOKEN_DATA);
+        }
+        return prefix;
+    }
+    async SendMonitorOnly() {
+        let flowMonitor = FlowMonitorQueue.Instance;
+        if (AccessHelper.mgDataTable == null || AccessHelper.mgDataTable.getMGData(0) == null || AccessHelper.mgDataTable.getMGData(0).IsAborting)
+            return;
+        if (!flowMonitor.isEmpty()) {
+            let buffer = this.BuildMonitorMessage();
+            let shouldAccumulateClientLog = false;
+            if (shouldAccumulateClientLog) {
+            }
+            else {
+                try {
+                    let requestStatus = new RefParam(RequestStatus.Handled);
+                    await this.DispatchRequest(this.ServerUrl, buffer.ToString(), CommandsProcessorBase_SessionStage.NORMAL, requestStatus);
+                }
+                catch (err) {
+                }
+            }
+        }
+    }
+    BuildMonitorMessage() {
+        let buffer = new StringBuilder(1000);
+        let flowMonitor = FlowMonitorQueue.Instance;
+        if (!RemoteCommandsProcessor.ShouldScrambleAndUnscrambleMessages) {
+            buffer.Append(XMLConstants.MG_TAG_OPEN);
+            flowMonitor.buildXML(buffer);
+        }
+        else {
+            flowMonitor.buildXML(buffer);
+            let scrambledOut = Scrambler.Scramble(buffer.ToString());
+            buffer = new StringBuilder(1000);
+            buffer.Append(XMLConstants.MG_TAG_OPEN + scrambledOut);
+        }
+        buffer.Append("</" + XMLConstants.MG_TAG_XML + XMLConstants.TAG_CLOSE);
+        return buffer;
+    }
+    RegisterDelegates() {
+        HttpClientEvents.GetSessionCounter_Event = this.GetSessionCounter.bind(this);
+        HttpClientEvents.CheckAndSetSessionCounter_Event = this.CheckAndSetSessionCounter.bind(this);
+        HttpClientEvents.ComputeAndLogRequestInfo_Event = this.ComputeAndLogRequestInfo.bind(this);
+        AccessHelper.eventsManager.SpinnerStopped.subscribe(clientBusyTime => this.ClientActivated());
+    }
+    ComputeAndLogRequestInfo(contentLength, roundTrip, isLoggingResponse) {
+        if (!isNullOrUndefined(this._requestInfo.serverCallAt)) {
+            this._requestInfo.extraInfo.contentLength = contentLength;
+            this._requestInfo.extraInfo.timeStamp = new Date().toString();
+            let extraMessageStr = isLoggingResponse ? 'Response ⤵' : 'Request ⤵';
+            if (isLoggingResponse) {
+                this._requestInfo.roundtripTime = roundTrip;
+            }
+            Logger.Instance.WriteRequestInfoToLog(this._requestInfo, extraMessageStr);
+            if (isLoggingResponse)
+                this._requestInfo.clear();
+        }
+    }
+    static set ShouldScrambleAndUnscrambleMessages(value) {
+        RemoteCommandsProcessor._shouldScrambleAndUnscrambleMessages = value;
+        Logger.Instance.WriteServerMessagesToLog(NString.Format("ShouldScrambleAndUnscrambleMessages.Set: {0}", this._shouldScrambleAndUnscrambleMessages));
+    }
+    static get ShouldScrambleAndUnscrambleMessages() {
+        Logger.Instance.WriteServerMessagesToLog(NString.Format("ShouldScrambleAndUnscrambleMessages.Get: {0}", this._shouldScrambleAndUnscrambleMessages));
+        return RemoteCommandsProcessor._shouldScrambleAndUnscrambleMessages;
+    }
+    parseLogLevel(strLogLevel) {
+        let logLevel = Logger_LogLevels.None;
+        if (!NString.IsNullOrEmpty(strLogLevel)) {
+            if (strLogLevel.toUpperCase().startsWith("SERVER"))
+                logLevel = strLogLevel.endsWith("#") ? Logger_LogLevels.ServerMessages : Logger_LogLevels.Server;
+            else if (strLogLevel.toUpperCase().startsWith("S") || strLogLevel.toUpperCase().startsWith("Q"))
+                logLevel = Logger_LogLevels.Support;
+            else if (strLogLevel.toUpperCase().startsWith("G"))
+                logLevel = Logger_LogLevels.Gui;
+            else if (strLogLevel.toUpperCase().startsWith("D"))
+                logLevel = Logger_LogLevels.Development;
+            else if (strLogLevel.toUpperCase().startsWith("B"))
+                logLevel = Logger_LogLevels.Basic;
+            else if (strLogLevel.toUpperCase().startsWith("R"))
+                logLevel = Logger_LogLevels.RequestInfo;
+        }
+        return logLevel;
+    }
+    async PrepareRequest(serializeTasks) {
+        let xmlBuf = new StringBuilder();
+        xmlBuf.Append(XMLConstants.MG_TAG_OPEN);
+        if (AccessHelper.mgDataTable.getCurrMGData() !== null) {
+            let xmlUnscrambled = new StringBuilder();
+            await AccessHelper.mgDataTable.buildXML(xmlUnscrambled, serializeTasks);
+            if (RemoteCommandsProcessor.ShouldScrambleAndUnscrambleMessages)
+                xmlBuf.Append(Scrambler.Scramble(xmlUnscrambled.ToString()));
+            else
+                xmlBuf.Append(xmlUnscrambled.ToString());
+        }
+        xmlBuf.Append("</" + XMLConstants.MG_TAG_XML + XMLConstants.TAG_CLOSE);
+        return xmlBuf.ToString();
+    }
+    async ProcessResponse(response, currMgdID, openingTaskDetails, res) {
+        Logger.Instance.WriteDevToLog("<-- ProcessResponse started -->");
+        if (openingTaskDetails === null)
+            openingTaskDetails = new OpeningTaskDetails();
+        let systemMilliseconds = Misc.getSystemMilliseconds();
+        if (response === null || response.trim().length === 0)
+            return;
+        AccessHelper.mgDataTable.currMgdID = currMgdID;
+        RuntimeContextBase.Instance.Parser.push();
+        RuntimeContextBase.Instance.Parser.setXMLdata(response);
+        RuntimeContextBase.Instance.Parser.setCurrIndex(0);
+        let currMGData = AccessHelper.mgDataTable.getCurrMGData();
+        await currMGData.fillData(openingTaskDetails, RuntimeContextBase.Instance.Parser);
+        RuntimeContextBase.Instance.Parser.setXMLdata(null);
+        RuntimeContextBase.Instance.Parser.pop();
+        Logger.Instance.WriteDevToLog("<-- ProcessResponse finished --> (" + (Misc.getSystemMilliseconds() - systemMilliseconds) + ")");
+        await currMGData.CmdsToClient.Execute(res);
+        await this.ProcessRecovery();
+    }
+    async ProcessRecovery() {
+        AccessHelper.eventsManager.pushNewExecStacks();
+        await AccessHelper.mgDataTable.processRecovery();
+        AccessHelper.eventsManager.popNewExecStacks();
+    }
+}
+class HandshakeResponse {
+    static SYSTEM_LOGIN_AD = 'D';
+    _scrambleMessages = true;
+    get ScrambleMessages() {
+        return this._scrambleMessages;
+    }
+    _contextId = null;
+    get ContextId() {
+        return this._contextId;
+    }
+    _privateSessionId = null;
+    get GetSessionId() {
+        return this._privateSessionId;
+    }
+    _inputPassword = false;
+    get InputPassword() {
+        return this._inputPassword;
+    }
+    _httpTimeout = 0;
+    get HttpTimeout() {
+        return this._httpTimeout;
+    }
+    _systemLogin = null;
+    get SystemLogin() {
+        return this._systemLogin;
+    }
+    _maxInternalLogLevel = null;
+    get MaxInternalLogLevel() {
+        return this._maxInternalLogLevel;
+    }
+    constructor(responseXML) {
+        try {
+            JSON_Utils.JSONFromXML(responseXML, this.FillFromJSON.bind(this));
+        }
+        catch (ex) {
+            Logger.Instance.WriteExceptionToLog(ex, responseXML);
+        }
+    }
+    FillFromJSON(error, result) {
+        if (error != null) {
+            throw error;
+        }
+        let response = result['Richclientresponse'];
+        for (let elementName in response) {
+            if (response.hasOwnProperty(elementName)) {
+                switch (elementName) {
+                    case "ContextID":
+                        this._contextId = response[elementName][0];
+                        break;
+                    case "SessionID":
+                        this._privateSessionId = response[elementName][0];
+                        break;
+                    case "Environment":
+                        let envAttributes = response["Environment"][0]['$'];
+                        if (!isNullOrUndefined(envAttributes["ScrambleMessages"])) {
+                            Debug.Assert(envAttributes["ScrambleMessages"] === "N");
+                            this._scrambleMessages = false;
+                        }
+                        if (!isNullOrUndefined(envAttributes["MaxInternalLogLevel"]))
+                            this._maxInternalLogLevel = envAttributes["MaxInternalLogLevel"];
+                        if (!isNullOrUndefined(envAttributes["InputPassword"]) && envAttributes["InputPassword"].toLocaleLowerCase() === "y")
+                            this._inputPassword = true;
+                        if (!isNullOrUndefined(envAttributes["SystemLogin"]))
+                            this._systemLogin = envAttributes["SystemLogin"];
+                        if (!isNullOrUndefined(envAttributes[ConstInterface.MG_TAG_HTTP_COMMUNICATION_TIMEOUT]))
+                            this._httpTimeout = +envAttributes[ConstInterface.MG_TAG_HTTP_COMMUNICATION_TIMEOUT];
+                        if (!isNullOrUndefined(envAttributes["ForwardSlash"]))
+                            AccessHelper.environment.ForwardSlashUsage = envAttributes["ForwardSlash"];
+                        break;
+                }
+            }
+        }
+    }
+}
+class ErrorMessageXml {
+    _lastRequestTime = 0;
+    contextInactivityTimeout;
+    _errorMessage = null;
+    _errorCode = 0;
+    _middlewareAddress = null;
+    _parsingFailed = false;
+    constructor(xmlContent, lastRequestTime, contextInactivityTimeout) {
+        this._lastRequestTime = lastRequestTime;
+        this.contextInactivityTimeout = contextInactivityTimeout;
+        try {
+            JSON_Utils.JSONFromXML(xmlContent, this.FillFromJSON.bind(this));
+        }
+        catch (ex) {
+            Logger.Instance.WriteExceptionToLog(ex);
+            Misc.WriteStackTrace(ex);
+            this._parsingFailed = true;
+        }
+    }
+    FillFromJSON(error, result) {
+        if (error != null) {
+            throw error;
+        }
+        let xmlerr = result['xmlerr'];
+        for (let elementName in xmlerr) {
+            if (xmlerr.hasOwnProperty(elementName)) {
+                switch (elementName) {
+                    case "errmsg":
+                        this._errorMessage = xmlerr[elementName][0];
+                        break;
+                    case "errcode":
+                        this._errorCode = +(xmlerr[elementName]);
+                        break;
+                    case "server":
+                        this._middlewareAddress = xmlerr[elementName][0];
+                        break;
+                    case "appname":
+                    case "prgname":
+                    case "arguments":
+                    case "username":
+                    case "xmlerr":
+                        break;
+                    default:
+                        Logger.Instance.WriteExceptionToLogWithMsg(NString.Format("Unknown element: '{0}'", elementName));
+                        break;
+                }
+            }
+        }
+    }
+    GetCode() {
+        return this._errorCode;
+    }
+    GetMessage() {
+        let sb = new StringBuilder();
+        if (this._parsingFailed) {
+            sb.Append(AccessHelper.languageData.getConstMessage(MsgInterface.RC_STR_F7_UNEXPECTED_ERR));
+        }
+        else {
+            switch (this._errorCode) {
+                case ServerError.ERR_CTX_NOT_FOUND:
+                    if (this.InactivityTimeoutExpired())
+                        sb.Append(NString.Format("{0} ({1} {2})", AccessHelper.languageData.getConstMessage(MsgInterface.STR_ERR_SESSION_CLOSED_INACTIVITY), Math.floor(this.contextInactivityTimeout / 600), AccessHelper.languageData.getConstMessage(MsgInterface.STR_MINUTES)));
+                    else
+                        sb.Append(NString.Format("{0} ({1}).", AccessHelper.languageData.getConstMessage(MsgInterface.STR_ERR_SESSION_CLOSED), this._errorCode));
+                    break;
+                case ServerError.ERR_WEBCLIENT_PROGRAM_RELOADED:
+                    sb.Append(AccessHelper.languageData.getConstMessage(MsgInterface.STR_ERR_WEBCLIENT_PROGRAM_RELOADED));
+                    break;
+                case ServerError.ERR_EXECUTED_PROGRAM_CHANGED:
+                    sb.Append(AccessHelper.languageData.getConstMessage(MsgInterface.STR_ERR_EXECUTED_PROGRAM_CHANGED));
+                    break;
+                case ServerError.ERR_AUTHENTICATION:
+                    sb.Append(AccessHelper.languageData.getConstMessage(MsgInterface.USRINP_STR_BADPASSW));
+                    break;
+                case ServerError.ERR_ACCESS_DENIED:
+                    sb.Append(AccessHelper.languageData.getConstMessage(MsgInterface.STR_ERR_AUTHORIZATION_FAILURE));
+                    break;
+                default:
+                    sb.Append(this._errorMessage);
+                    break;
+            }
+            sb.Append(OSEnvironment.EolSeq + OSEnvironment.EolSeq);
+            if (!ServerConfig.Instance.ShouldDisplayGenericError()) {
+                sb.Append(AccessHelper.languageData.getConstMessage(MsgInterface.BROWSER_OPT_INFO_SERVER_STR) + ":   ");
+                sb.Append(ServerConfig.Instance.getServer());
+                if (!NString.IsNullOrEmpty(this._middlewareAddress)) {
+                    sb.Append(" --> ");
+                    sb.Append(this._middlewareAddress);
+                }
+                sb.Append(OSEnvironment.EolSeq);
+            }
+            sb.Append(AccessHelper.languageData.getConstMessage(MsgInterface.TASKRULE_STR_APPLICATION) + ":   \"");
+            sb.Append(ServerConfig.Instance.getAppName());
+            sb.Append("\" (\"");
+            sb.Append("\")");
+        }
+        return sb.ToString();
+    }
+    InactivityTimeoutExpired() {
+        let expired = false;
+        if (this.contextInactivityTimeout > 0) {
+            let currTimeMilli = Misc.getSystemMilliseconds();
+            expired = ((currTimeMilli - this._lastRequestTime) > (this.contextInactivityTimeout * 100));
+        }
+        return expired;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RemoteCommandsProcessor.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/remote/RemoteCommandsProcessor.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Base64,\r\n  JSON_Utils,\r\n  Logger,\r\n  Logger_LogLevels,\r\n  Misc,\r\n  MsgInterface,\r\n  OSEnvironment,\r\n  RequestInfo,\r\n  StrUtil,\r\n  XMLConstants\r\n} from \"@magic-xpa/utils\";\r\nimport {\r\n  Debug,\r\n  Encoding,\r\n  Exception,\r\n  List,\r\n  NString,\r\n  RefParam,\r\n  StringBuilder,\r\n  isNullOrUndefined,\r\n  isUndefined\r\n} from \"@magic-xpa/mscorelib\";\r\nimport {\r\n  Commands,\r\n  RuntimeContextBase,\r\n  Styles,\r\n  UsernamePasswordCredentials\r\n} from \"@magic-xpa/gui\";\r\nimport { ExecOperCommand } from '../commands/ClientToServer/ExecOperCommand';\r\nimport { Task } from '../tasks/Task';\r\nimport {\r\n  CommandsProcessorBase,\r\n  CommandsProcessorBase_SendingInstruction,\r\n  CommandsProcessorBase_SessionStage\r\n} from \"../CommandsProcessorBase\";\r\nimport { HttpManager } from \"../http/HttpManager\";\r\nimport { ConstInterface } from \"../ConstInterface\";\r\nimport { Scrambler } from \"../util/Scrambler\";\r\nimport { ServerError } from \"./ServerError\";\r\nimport { IResultValue } from \"../rt/IResultValue\";\r\nimport { FlowMonitorQueue } from \"../util/FlowMonitorQueue\";\r\nimport { OpeningTaskDetails, TaskBase } from \"../tasks/TaskBase\";\r\nimport { HttpUtility } from \"../http/client/HttpUtility\";\r\nimport { HttpClientEvents } from \"../http/client/HttpClientEvents\";\r\nimport { ServerConfig } from \"../ServerConfig\";\r\nimport { MGData } from \"../tasks/MGData\";\r\nimport { CommandsTable } from \"../CommandsTable\";\r\nimport { AccessHelper } from \"../AccessHelper\";\r\nimport { Environment, Event, EventCommand, EventsManager, GUIManager, IClientCommand, RunTimeEvent } from \"../../\";\r\nimport { IClientToServerCommandInfo } from \"../commands/IClientToServerCommandInfo\";\r\nimport { MGDataCollection } from \"../tasks/MGDataCollection\";\r\nimport { Subscription, timer } from \"rxjs\";\r\n\r\n/// <summary> Represents the status of a request </summary>\r\nenum RequestStatus {\r\n  Handled, //the request was successfully handled.\r\n  Retry,   //the request should be re-sent.\r\n  Abort   //the request could not be handled and should be aborted.\r\n}\r\n\r\n// @dynamic\r\nexport class RemoteCommandsProcessor extends CommandsProcessorBase {\r\n  static readonly RC_NO_CONTEXT_ID: string = '-1';\r\n  private static _instance: RemoteCommandsProcessor = null;\r\n  public static IsSessionReInitializing = false;\r\n  private static lastExceptionMessage = null;\r\n  private static InitialUrl: string = null;\r\n\r\n\r\n  // *****************************************************************************************************\r\n  // *****************************************************************************************************\r\n  // ******** When changing WEB_COMMUNICATION_PROTOCOL_VERSION, please change on mobile platforms as well:\r\n  // ******** W10M: RemoteCommandsProcessor.cs\r\n  private static readonly WEB_COMMUNICATION_PROTOCOL_VERSION: string = \"14002\";\r\n  // *****************************************************************************************************\r\n  // *****************************************************************************************************\r\n\r\n  // TODO: Check if we need _logAccumulator.\r\n  // private _logAccumulator: ClientLogAccumulator = null;\r\n\r\n  private _lastRequestTime: number = 0; // the time of the last request to the server\r\n\r\n  ServerUrl: string = null;\r\n  private static _shouldScrambleAndUnscrambleMessages: boolean = false; // static because it is initialized before the execution props are available\r\n\r\n  public SessionId: string;\r\n\r\n  public DelayCommandExecution: boolean = false;\r\n  private _requestInfo = new RequestInfo();\r\n\r\n  static GetInstance(): RemoteCommandsProcessor {\r\n    if (RemoteCommandsProcessor._instance === null) {\r\n      RemoteCommandsProcessor._instance = new RemoteCommandsProcessor();\r\n    }\r\n\r\n    return RemoteCommandsProcessor._instance;\r\n  }\r\n\r\n  private constructor() {\r\n    super();\r\n    this.ServerUrl = ServerConfig.Instance.getServerURL();\r\n\r\n    HttpManager.GetInstance();\r\n\r\n    this.RegisterDelegates();\r\n  }\r\n\r\n  /// <summary>\r\n  /// Checks that session counter is consecutive during the session and sets new value.\r\n  /// The only exception is in case the client sent to the server ConstInterface.SESSION_COUNTER_CLOSE_CTX_INDICATION,\r\n  ///    the server is expected to return ConstInterface.SESSION_COUNTER_CLOSE_CTX_INDICATION in response (RequestsServerBase::ProcessRequest), to acknowledge the request to close the context.\r\n  /// </summary>\r\n  /// <param name=\"newSessionCounter\">!!.</param>\r\n  CheckAndSetSessionCounter(newSessionCounter: number): void {\r\n    if (newSessionCounter === ConstInterface.SESSION_COUNTER_CLOSE_CTX_INDICATION) {\r\n      Debug.Assert(this.GetSessionCounter() === ConstInterface.SESSION_COUNTER_CLOSE_CTX_INDICATION);\r\n    } else {\r\n      Debug.Assert(newSessionCounter === this.GetSessionCounter() + 1);\r\n      this.SetSessionCounter(newSessionCounter);\r\n      Logger.Instance.WriteServerToLog(NString.Format(\"Session Counter --> {0}\", this._sessionCounter));\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Zero session counter when reinitializing server communication details\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  ClearSessionCounter(): void {\r\n    this._sessionCounter = 0;\r\n    Logger.Instance.WriteServerToLog(NString.Format(\"Session Counter --> {0}\", this._sessionCounter));\r\n  }\r\n\r\n  /// <summary>\r\n  /// </summary>\r\n  /// <param name=\"newSessionCounter\"></param>\r\n  private SetSessionCounter(newSessionCounter: number): void {\r\n    this._sessionCounter = newSessionCounter;\r\n  }\r\n\r\n  public get GetLastRequestTime() {\r\n    return this._lastRequestTime;\r\n  }\r\n\r\n  /// <summary>\r\n  /// ReStartSession\r\n  /// </summary>\r\n  async ReStartSession(): Promise<void> {\r\n\r\n    RemoteCommandsProcessor.IsSessionReInitializing = true;\r\n\r\n    await this.StoreSessionReInitializingDataOnLocalStorage();\r\n    let navigateRootRoute = false;\r\n    if (!RuntimeContextBase.Instance.RemovedContextFromServer)\r\n      navigateRootRoute = Environment.Instance.getSpecialRouteToRootProgOnContextRecreation() ? true : false;\r\n    Commands.addRefreshPage(navigateRootRoute, RemoteCommandsProcessor.InitialUrl);\r\n    //stop the execution by throwing exception.\r\n    throw new Exception('');\r\n\r\n  }\r\n\r\n  /// <summary>\r\n  /// StoreSessionReInitializingDataOnLocalStorage\r\n  /// </summary>\r\n  async StoreSessionReInitializingDataOnLocalStorage(): Promise<void> {\r\n\r\n    let mainPrgViewStringForServer = await this.BuildXMLForMainProgramDataView();\r\n    let globalParamsString = AccessHelper.globalParams.mirrorAllToXML();\r\n    let changedEnvVarList = AccessHelper.envParamsTable.mirrorAllToXML();\r\n    // store mainPrgViewStringForServer, IsSessionReInitializing and globalParamsString on local\r\n    // storage in order to use it for next session.\r\n    let dataStorage = window.localStorage;\r\n    dataStorage.setItem(ConstInterface.IS_SESSION_REINITIALIZING, \"true\");\r\n    dataStorage.setItem(ConstInterface.MAIN_PROG_VIEW, mainPrgViewStringForServer.toString());\r\n    dataStorage.setItem(ConstInterface.GLOBAL_PARAM_LIST, globalParamsString);\r\n    dataStorage.setItem(ConstInterface.ENV_VAR_LIST, changedEnvVarList);\r\n    dataStorage.setItem(ConstInterface.LAST_EXCEPTION, RemoteCommandsProcessor.lastExceptionMessage);\r\n    if (RuntimeContextBase.Instance.RemovedContextFromServer)\r\n      dataStorage.setItem(ConstInterface.CTX_REMOVED_FROM_SRVR, \"1\");\r\n    EventsManager.Instance.storeLastSavedRouteEventOnLocalStorage();\r\n  }\r\n\r\n  /// <summary>\r\n  /// RestoreSessionReInitializingDataFromLocalStorage\r\n  /// </summary>\r\n  RestoreSessionReInitializingDataFromLocalStorage(key: string): string {\r\n\r\n    let dataStorage = window.localStorage;\r\n    let val = dataStorage.getItem(key);\r\n    return val;\r\n  }\r\n\r\n  /// <summary>Prepare and execute the 1st & 2nd handshake requests:\r\n  /// 1st request:  UTF8TRANS=..&appname=..&prgname=..&arguments=-A<Richclient><RequestingVersionDetails=\"..\"/></Richclient>\r\n  ///     response: instructions to the client - whether to display authentication dialog, the server's version, and more ..\r\n  ///               e.g. <Richclientresponse><ContextID>120308789726371200</ContextID><Environment InputPassword=\"N\" SystemLogin=\"N\" ScrambleMessages=\"N\" MaxInternalLogLevel=\"Server#\" HttpTimeout=\"10\" ClientNetworkRecoveryInterval=\"0\" ForwardSlash=\"web\"/></Richclientresponse>\r\n  /// 2nd request: authentication (optional, depending on the 1st request).\r\n  /// </summary>\r\n  /// <returns>true only if the client should continue to start the actual program (i.e. after handshake).</returns>\r\n  async StartSession(): Promise<boolean> {\r\n    let authenticationCancelled: boolean = false;\r\n    let handshakeResponse: HandshakeResponse = null;\r\n\r\n    try {\r\n      let lastTypedUserId: string = null;\r\n\r\n      // ----------------------------------------------------------------------\r\n      // 1st handshake request: prepare 1st handshake request and scramble it\r\n      // ----------------------------------------------------------------------\r\n      let handshakeInitialTokens: StringBuilder = new StringBuilder();\r\n      handshakeInitialTokens.Append(ConstInterface.UTF8TRANS +\r\n        ConstInterface.REQ_APP_NAME + \"=\" +\r\n        HttpUtility.UrlEncode(ServerConfig.Instance.getAppName(), Encoding.UTF8));\r\n\r\n      handshakeInitialTokens.Append(\"&\" + ConstInterface.REQ_ARGS + \"=\" + ConstInterface.REQ_ARG_ALPHA +\r\n        \"<Richclient><Requires EncryptionKey=\\\"False\\\"/><RIAProtocolVersion=\\\"\" + RemoteCommandsProcessor.WEB_COMMUNICATION_PROTOCOL_VERSION + \"\\\"/></Richclient>\");\r\n\r\n      Logger.Instance.WriteDevToLog(NString.Format(\"Handshake request #1 (not scrambled) : {0}\",\r\n        this.ServerUrl + ConstInterface.REQ_ARG_START +\r\n        ConstInterface.RC_INDICATION_INITIAL + handshakeInitialTokens));\r\n\r\n      let handshakeInitialUrl: string = this.ServerUrl + ConstInterface.REQ_ARG_START +\r\n        ConstInterface.RC_INDICATION_INITIAL +\r\n        ConstInterface.RC_TOKEN_DATA +\r\n        HttpUtility.UrlEncode(Scrambler.Scramble(handshakeInitialTokens.ToString()), Encoding.UTF8);\r\n\r\n      Logger.Instance.WriteServerMessagesToLog(\"\");\r\n      Logger.Instance.WriteServerMessagesToLog(NString.Format(\"Handshake request #1: {0}\", handshakeInitialUrl));\r\n\r\n      // Initialize temp ctxGroup with CtxGroup from execution.properties\r\n      let ctxGroup: string = ServerConfig.Instance.getCtxGroup();\r\n\r\n      while (!authenticationCancelled) {\r\n        let requestStatus: RefParam<RequestStatus> = new RefParam(RequestStatus.Handled);\r\n        // execute the 1st request\r\n        let responseStr: string = await this.DispatchRequest(handshakeInitialUrl, null, CommandsProcessorBase_SessionStage.HANDSHAKE, requestStatus);\r\n\r\n        // process the 1st response - check if the response is error, unscramble and parse it\r\n        if (NString.IsNullOrEmpty(responseStr)) {\r\n          throw new ServerError(\"Client failed to initialize a session.\" + OSEnvironment.EolSeq +\r\n            \"Empty response was received from the web server.\" + OSEnvironment.EolSeq + OSEnvironment.EolSeq + this.ServerUrl);\r\n        }\r\n\r\n        Logger.Instance.WriteServerMessagesToLog(NString.Format(\"Handshake response #1: {0}\", responseStr));\r\n        Logger.Instance.WriteServerMessagesToLog(\"\");\r\n\r\n        handshakeResponse = new HandshakeResponse(responseStr);\r\n\r\n        RuntimeContextBase.Instance.ContextID = handshakeResponse.ContextId;\r\n\r\n        // save session id on client which is received in 1st response.\r\n        this.SessionId = handshakeResponse.GetSessionId;\r\n\r\n        HttpManager.GetInstance().HttpCommunicationTimeoutMS = handshakeResponse.HttpTimeout * 1000;\r\n\r\n        // During authentication, if authentication failed then server unloads ctx and creates new ctx for next authentication request.\r\n        // So every time after authentication fails we receive new ctxid for next authentication request.\r\n        // Hence take ctxgroup in local variable and update ClientManager only after authentication is done.\r\n        if (NString.IsNullOrEmpty(ServerConfig.Instance.getCtxGroup())) {\r\n          ctxGroup = handshakeResponse.ContextId;\r\n        }\r\n\r\n        // -----------------------\r\n        // 2nd handshake request\r\n        // -----------------------\r\n        let credentials: UsernamePasswordCredentials = null;\r\n        if (ServerConfig.Instance.getSkipAuthenticationDialog()) {\r\n          // skip authentication (to the runtime-engine) dialog\r\n          if (ServerConfig.Instance.getUsername() !== null) {\r\n            // user the userId & password that were passed, and reset them (they'll be set below, if authenticated by the runtime-engine)\r\n            credentials = new UsernamePasswordCredentials(ServerConfig.Instance.getUsername(), ServerConfig.Instance.getPassword());\r\n            ServerConfig.Instance.setUsername(\"\");\r\n            ServerConfig.Instance.setPassword(\"\");\r\n          }\r\n        } else if (handshakeResponse.InputPassword && handshakeResponse.SystemLogin !== HandshakeResponse.SYSTEM_LOGIN_AD) {\r\n          // authentication (to the runtime-engine) dialog\r\n          if (lastTypedUserId !== null) {\r\n            let title: string = AccessHelper.languageData.getConstMessage(MsgInterface.BRKTAB_STR_ERROR);\r\n            let error: string = AccessHelper.languageData.getConstMessage(MsgInterface.USRINP_STR_BADPASSW);\r\n            await GUIManager.Instance.MessageBox(title, error, Styles.MSGBOX_ICON_ERROR | Styles.MSGBOX_BUTTON_OK);\r\n          }\r\n\r\n          // TODO: implement authentication dialog\r\n          // let userId: string = lastTypedUserId;\r\n          //\r\n          // if (dialog === null) {\r\n          //   dialog = new AuthenticationDialogHandler(userId, GetLogonDialogExecProps());\r\n          // }\r\n          // dialog.openDialog();\r\n\r\n          // credentials = dialog.getCredentials();\r\n          // if (credentials !== null)\r\n          //   lastTypedUserId = credentials.Username;\r\n          // else\r\n          //   authenticationCancelled = true;\r\n        }\r\n\r\n        // ConstInterface.SESSION_COUNTER_CLOSE_CTX_INDICATION instructs the server to close the context.\r\n        // (note: unloading a context post handshake should be done using Command.createUnloadCommand).\r\n        if (authenticationCancelled) {\r\n          this.SetSessionCounter(ConstInterface.SESSION_COUNTER_CLOSE_CTX_INDICATION);\r\n        }\r\n\r\n        let handshakeAuthUrl: string = this.PrepareAuthenticationUrl(handshakeResponse.ContextId, ctxGroup, this.GetSessionCounter());\r\n\r\n        try {\r\n          if (credentials !== null) {\r\n            let credentialsStr: string = credentials.Username + \":\";\r\n            if (!NString.IsNullOrEmpty(credentials.Password)) {\r\n              credentialsStr = credentialsStr + credentials.Password + \":\";\r\n            }\r\n            credentialsStr += handshakeResponse.ContextId;\r\n            credentialsStr = Scrambler.Scramble(credentialsStr);\r\n            credentialsStr = Base64.encode(credentialsStr, true, Encoding.UTF8);\r\n            handshakeAuthUrl += (\"&USERNAME=\" + HttpUtility.UrlEncode(credentialsStr, Encoding.UTF8));\r\n\r\n            // send 2nd handshake request - with authentication\r\n            Logger.Instance.WriteServerMessagesToLog(NString.Format(\"Handshake request #2: {0}\", handshakeAuthUrl));\r\n            let statusRequest: RefParam<RequestStatus> = new RefParam(RequestStatus.Handled);\r\n            responseStr = await this.DispatchRequest(handshakeAuthUrl, null, CommandsProcessorBase_SessionStage.HANDSHAKE, statusRequest);\r\n\r\n            // verify that the response wasn't replayed\r\n            if (responseStr.indexOf(handshakeResponse.ContextId) === -1) {\r\n              throw new ServerError(AccessHelper.languageData.getConstMessage(MsgInterface.USRINP_STR_BADPASSW));\r\n            }\r\n\r\n            ServerConfig.Instance.setUsername(credentials.Username);\r\n            ServerConfig.Instance.setPassword(credentials.Password);\r\n          } else {\r\n            let requestStatus: RefParam<RequestStatus> = new RefParam(RequestStatus.Handled);\r\n            // send 2nd handshake request - without authentication\r\n            Logger.Instance.WriteServerMessagesToLog(NString.Format(\"Handshake request #2: {0}\", handshakeAuthUrl));\r\n            responseStr = await this.DispatchRequest(handshakeAuthUrl, null, CommandsProcessorBase_SessionStage.HANDSHAKE, requestStatus);\r\n          }\r\n          Logger.Instance.WriteServerMessagesToLog(NString.Format(\"Handshake response #2: {0}\", responseStr));\r\n          Logger.Instance.WriteServerMessagesToLog(\"\");\r\n          break;\r\n        } catch (ex) {\r\n          if (ex instanceof ServerError) {\r\n            let serverError: ServerError = <ServerError>ex;\r\n            if (ServerConfig.Instance.getSkipAuthenticationDialog()) {\r\n              switch (serverError.GetCode()) {\r\n                case ServerError.ERR_ACCESS_DENIED:\r\n                // External Authenticator authenticated the user, access to the application wasn't authorized.\r\n                case ServerError.ERR_AUTHENTICATION:\r\n                  // External Authenticator authenticated the user but application authentication failed\r\n                  ServerConfig.Instance.setSkipAuthenticationDialog(false);\r\n                  throw serverError;\r\n              }\r\n            }\r\n\r\n            // the session will never provide a way to change the credentials, therefore abort\r\n            if (!handshakeResponse.InputPassword)\r\n              throw serverError;\r\n\r\n            // Error.INF_NO_RESULT:\r\n            //    if authentication dialog was canceled, the request was sent only to close the context,\r\n            //    and the server isn't expected to return a response\r\n            if (serverError.GetCode() !== ServerError.ERR_AUTHENTICATION &&\r\n              (!authenticationCancelled || serverError.GetCode() !== ServerError.INF_NO_RESULT)) {\r\n              throw serverError;\r\n            }\r\n          } else\r\n            throw ex;\r\n        }\r\n      }\r\n\r\n      // store an indication to skip future authentication (session restart, parallel program)\r\n      ServerConfig.Instance.setSkipAuthenticationDialog(true);\r\n\r\n      // save context group\r\n      ServerConfig.Instance.setCtxGroup(ctxGroup);\r\n\r\n      // ------------------------\r\n      // set session properties\r\n      // ------------------------\r\n      RemoteCommandsProcessor.ShouldScrambleAndUnscrambleMessages = handshakeResponse.ScrambleMessages;\r\n      if (Logger.Instance.LogLevel !== Logger_LogLevels.Basic) {\r\n        // maximal value of the InternalLogLevel that can be set by the client.\r\n        // if set, it controls the maximal value; otherwise, any log level is allowed.\r\n        let maxInternalLogLevel: string = handshakeResponse.MaxInternalLogLevel;\r\n        if (maxInternalLogLevel !== null) {\r\n          let maxLogLevel: Logger_LogLevels = this.parseLogLevel(maxInternalLogLevel);\r\n          if (maxLogLevel < Logger.Instance.LogLevel) {\r\n            // textual value (as loaded from the execution properties)\r\n            ServerConfig.Instance.setInternalLogLevel(maxInternalLogLevel);\r\n\r\n            // set the actual log level to the level allowed by the server\r\n            Logger.Instance.WriteToLog(NString.Format(\"Internal log level was restricted to '{0}' by the Magic xpa server.\", maxInternalLogLevel), false);\r\n            Logger.Instance.LogLevel = maxLogLevel;\r\n          }\r\n        }\r\n      }\r\n\r\n      // ----------------------------------------------------------------------\r\n      // 3rd request: Executes the initial program in the server.\r\n      // ----------------------------------------------------------------------\r\n      if (!authenticationCancelled) {\r\n        await this.ExecuteInitialRequest();\r\n      }\r\n    } catch (ex) {\r\n      if (ex instanceof ServerError)\r\n        throw ex;\r\n\r\n      if (isNullOrUndefined(ex.InnerException))\r\n        throw  new ServerError(ex.message, new Exception(ex));\r\n      else\r\n        throw new ServerError(ex.message, ex.InnerException);\r\n    }\r\n\r\n    return !authenticationCancelled;\r\n  }\r\n\r\n  /// <summary>\r\n  /// prepares handshake request url for authentication\r\n  /// </summary>\r\n  /// <param name=\"contextId\"></param>\r\n  /// <param name=\"ctxGroup\"></param>\r\n  /// <param name=\"sessionCount\"></param>\r\n  /// <returns></returns>\r\n  private PrepareAuthenticationUrl(contextId: string, ctxGroup: string, sessionCount: number): string {\r\n    let handshakeAuthUrl: string = this.ServerUrl + ConstInterface.REQ_ARG_START +\r\n      ConstInterface.RC_INDICATION + ConstInterface.UTF8TRANS +\r\n      ConstInterface.RC_TOKEN_CTX_ID + contextId;\r\n\r\n    if (!isNullOrUndefined(this.SessionId))\r\n      handshakeAuthUrl += (ConstInterface.REQ_ARG_SEPARATOR + ConstInterface.RC_TOKEN_SESSION_ID + this.SessionId);\r\n\r\n    handshakeAuthUrl += (ConstInterface.REQ_ARG_SEPARATOR +\r\n      ConstInterface.RC_TOKEN_SESSION_COUNT + sessionCount +\r\n      ConstInterface.REQ_ARG_SEPARATOR +\r\n      ConstInterface.RC_TOKEN_CTX_GROUP + ctxGroup +\r\n      ConstInterface.REQ_ARG_SEPARATOR +\r\n      ConstInterface.RC_AUTHENTICATION_REQUEST);\r\n\r\n    return handshakeAuthUrl;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Executes the initial program in the server:\r\n  /// </summary>\r\n  private async ExecuteInitialRequest(): Promise<void> {\r\n    // send the INITIAL request to the server.\r\n    await this.Execute_1(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS, CommandsProcessorBase_SessionStage.INITIAL, null);\r\n  }\r\n\r\n  // private static GetLogonDialogExecProps(): Dictionary<string, string> {\r\n  //   let dictionary: Dictionary<string, string> = new Dictionary<string, string>();\r\n  //   let value: string = ClientManager.Instance.getLogonWindowTitle();\r\n  //   let flag: boolean = NString.IsNullOrEmpty(value);\r\n  //   if (flag) {\r\n  //     value = \"Logon - \" + ClientManager.Instance.getAppName();\r\n  //   }\r\n  //   dictionary.Add(\"LogonWindowTitle\", value);\r\n  //   let text: string = ClientManager.Instance.getLogonGroupTitle();\r\n  //   let flag2: boolean = !NString.IsNullOrEmpty(text);\r\n  //   if (flag2) {\r\n  //     text = ((text.length > 62) ? NString.Substring(text, 0, 62) : text);\r\n  //   }\r\n  //   else {\r\n  //     text = \"Logon Parameters\";\r\n  //   }\r\n  //   dictionary.Add(\"LogonGroupTitle\", text);\r\n  //   let text2: string = ClientManager.Instance.getLogonMsgCaption();\r\n  //   let flag3: boolean = !NString.IsNullOrEmpty(text2);\r\n  //   if (flag3) {\r\n  //     text2 = ((text2.length > 56) ? NString.Substring(text2, 0, 56) : text2);\r\n  //     dictionary.Add(\"LogonMessageCaption\", text2);\r\n  //   }\r\n  //   let logonWindowIconURL: Uri = ClientManager.Instance.getLogonWindowIconURL();\r\n  //   let flag4: boolean = Uri.op_Inequality(logonWindowIconURL, null) && !NString.IsNullOrEmpty(logonWindowIconURL.ToString());\r\n  //   if (flag4) {\r\n  //     dictionary.Add(\"LogonWindowIconURL\", logonWindowIconURL.ToString());\r\n  //   }\r\n  //   let logonWindowImageURL: Uri = ClientManager.Instance.getLogonWindowImageURL();\r\n  //   let flag5: boolean = Uri.op_Inequality(logonWindowImageURL, null) && !NString.IsNullOrEmpty(logonWindowImageURL.ToString());\r\n  //   if (flag5) {\r\n  //     dictionary.Add(\"LogonImageURL\", logonWindowImageURL.ToString());\r\n  //   }\r\n  //   let text3: string = ClientManager.Instance.getLogonUserIdCaption();\r\n  //   let flag6: boolean = !NString.IsNullOrEmpty(text3);\r\n  //   if (flag6) {\r\n  //     text3 = ((text3.length > 9) ? NString.Substring(text3, 0, 9) : text3);\r\n  //     dictionary.Add(\"LogonUserIDCaption\", text3);\r\n  //   }\r\n  //   let text4: string = ClientManager.Instance.getLogonPasswordCaption();\r\n  //   let flag7: boolean = !NString.IsNullOrEmpty(text4);\r\n  //   if (flag7) {\r\n  //     text4 = ((text4.length > 9) ? NString.Substring(text4, 0, 9) : text4);\r\n  //     dictionary.Add(\"LogonPasswordCaption\", text4);\r\n  //   }\r\n  //   let logonOKCaption: string = ClientManager.Instance.getLogonOKCaption();\r\n  //   let flag8: boolean = !NString.IsNullOrEmpty(logonOKCaption);\r\n  //   if (flag8) {\r\n  //     dictionary.Add(\"LogonOKCaption\", logonOKCaption);\r\n  //   }\r\n  //   let logonCancelCaption: string = ClientManager.Instance.getLogonCancelCaption();\r\n  //   let flag9: boolean = !NString.IsNullOrEmpty(logonCancelCaption);\r\n  //   if (flag9) {\r\n  //     dictionary.Add(\"LogonCancelCaption\", logonCancelCaption);\r\n  //   }\r\n  //   return dictionary;\r\n  // }\r\n\r\n\r\n  /// <summary>\r\n  /// Return the string representation of runtime task tree structure by going up from the current task\r\n  /// </summary>\r\n  private GetTaskTree(task: Task): List<string> {\r\n    let taskTree: List<string> = new List<string>();\r\n\r\n    while (!isNullOrUndefined(task)) {\r\n      taskTree.push(task.getTaskInfo());\r\n      task = <Task>task.getParent();\r\n    }\r\n\r\n    return taskTree;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Update the request info object using information obtained from current operation being executed.\r\n  /// </summary>\r\n  private async UpdateRequestInfo(): Promise<void> {\r\n    let currMGData: MGData = AccessHelper.mgDataTable.getCurrMGData();\r\n    let eventsManager: EventsManager = <EventsManager>AccessHelper.eventsManager;\r\n    let operExecution: boolean = false;\r\n    let cmdsToServer: CommandsTable = <CommandsTable>currMGData.CmdsToServer;\r\n\r\n    for (let i = 0; i < cmdsToServer.getSize(); i++) {\r\n      // When the request is being sent to server due to an operation execution, get the information of current operation from CmdsToServer\r\n      if (cmdsToServer.getCmd(i) instanceof ExecOperCommand) {\r\n        let operCmd: ExecOperCommand = <ExecOperCommand>(<CommandsTable>currMGData.CmdsToServer).getCmd(i);\r\n\r\n        this._requestInfo.serverCallAt = operCmd.getCommandInfo();\r\n\r\n        this._requestInfo.runtimeTaskTree = this.GetTaskTree(operCmd.getTask());\r\n        operExecution = true;\r\n        break;\r\n      }\r\n    }\r\n\r\n    this._requestInfo.extraInfo.contextID = RuntimeContextBase.Instance.ContextID;\r\n    this._requestInfo.extraInfo.sessionCounter = this.GetSessionCounter();\r\n\r\n    // Log information about magic internal events causing requests to server\r\n    if (!operExecution) {\r\n      if (eventsManager.getLastRtEvent() != null && eventsManager.getLastRtEvent().InternalEvent != 0) {\r\n        let rtEvt: RunTimeEvent = eventsManager.getLastRtEvent();\r\n        this._requestInfo.runtimeTaskTree = this.GetTaskTree(<Task>rtEvt.getTask());\r\n\r\n        // return description as per new/old internal event desc\r\n        let eventDescription: string = rtEvt.isNewInternalEvent()\r\n          ? NString.TrimEnd(rtEvt.getNewInternalEventDescription())\r\n          : Event.getInternalEvtDescription(rtEvt.InternalEvent);\r\n\r\n\r\n        // e.g. Event [<Next Chunk>] while executing [<View Refresh>]\r\n        let cmd: IClientCommand = cmdsToServer.getCmd(cmdsToServer.getSize() - 1);\r\n        if (cmd as IClientToServerCommandInfo) {\r\n          let commandInfo: string = NString.IsNullOrEmpty((<IClientToServerCommandInfo>cmd).getCommandInfo())\r\n            ? NString.Empty\r\n            : (<IClientToServerCommandInfo>cmd).getCommandInfo();\r\n\r\n          // In case the runtime event and Event command are same, no need to log the extra information\r\n          if (cmd instanceof EventCommand && rtEvt.InternalEvent == (<EventCommand>cmd).MagicEvent)\r\n            eventDescription = NString.Empty;\r\n\r\n          this._requestInfo.serverCallAt = 'Event ' + commandInfo +\r\n            (!NString.IsNullOrEmpty(eventDescription)\r\n              ? NString.Format(' while executing [{0}]', eventDescription)\r\n              : NString.Empty);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Build xml for main prog dataview. required for re-initializing session.\r\n  /// </summary>\r\n  private async BuildXMLForMainProgramDataView(): Promise<String> {\r\n    let message: StringBuilder = new StringBuilder();\r\n    let firstMgData: MGData = MGDataCollection.Instance.getMGData(0);\r\n    let mainPrg: Task = firstMgData.getMainProg(0);\r\n\r\n    while (mainPrg != null) {\r\n      await mainPrg.buildXML(message);\r\n      mainPrg = firstMgData.getNextMainProg(mainPrg.getCtlIdx());\r\n    }\r\n\r\n    if (RemoteCommandsProcessor.ShouldScrambleAndUnscrambleMessages) {\r\n      let scrambledChanges: string = Scrambler.Scramble(message.ToString());\r\n      message = new StringBuilder(scrambledChanges);\r\n    }\r\n\r\n    message.Insert(0, XMLConstants.MG_TAG_OPEN);\r\n    message.Append(XMLConstants.MG_TAG_XML_END_TAGGED);\r\n\r\n    return message.ToString();\r\n  }\r\n\r\n\r\n  async Execute_1(sendingInstruction: CommandsProcessorBase_SendingInstruction, sessionStage: CommandsProcessorBase_SessionStage, res: IResultValue): Promise<void> {\r\n    let reqBuf: string;\r\n    let isInitialCall: boolean = sessionStage === CommandsProcessorBase_SessionStage.INITIAL;\r\n    let globalParamsString: string = null;\r\n    let envVarsString: string = null;\r\n\r\n    if (this.DelayCommandExecution)\r\n      return;\r\n\r\n    if (Logger.Instance.LogLevel == Logger_LogLevels.RequestInfo && !isInitialCall)\r\n      await this.UpdateRequestInfo();\r\n\r\n    if (isInitialCall) {\r\n      let val = this.RestoreSessionReInitializingDataFromLocalStorage(ConstInterface.IS_SESSION_REINITIALIZING);\r\n      if (val === 'true') {\r\n        RemoteCommandsProcessor.IsSessionReInitializing = (val === \"true\") ? true : false;\r\n        RemoteCommandsProcessor.lastExceptionMessage = this.RestoreSessionReInitializingDataFromLocalStorage(ConstInterface.LAST_EXCEPTION);\r\n        let ctxRemoved = this.RestoreSessionReInitializingDataFromLocalStorage(ConstInterface.CTX_REMOVED_FROM_SRVR);\r\n\r\n        if (ctxRemoved !== '1') {\r\n          Logger.Instance.WriteErrorToLog(RemoteCommandsProcessor.lastExceptionMessage);\r\n          Logger.Instance.WriteToLog(\"Session is reinitializing...\", true);\r\n        }\r\n      }\r\n    }\r\n\r\n    if (sendingInstruction === CommandsProcessorBase_SendingInstruction.NO_TASKS_OR_COMMANDS)\r\n      reqBuf = null;\r\n    else {\r\n      reqBuf = await this.PrepareRequest(sendingInstruction === CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);\r\n\r\n      if (RemoteCommandsProcessor.IsSessionReInitializing || !isInitialCall) {\r\n        let changes: StringBuilder = new StringBuilder();\r\n        let buffer: StringBuilder = new StringBuilder();\r\n        if (!RemoteCommandsProcessor.IsSessionReInitializing)\r\n          buffer.Append(reqBuf);\r\n\r\n        // send activity monitor logs to the server\r\n        // if (this._logAccumulator !== null && !this._logAccumulator.Empty())\r\n        //   buffer.Append(this._logAccumulator.Read());\r\n\r\n        // synchronize client-side SetParams and INIPut data to the server\r\n        if (RemoteCommandsProcessor.IsSessionReInitializing)\r\n        {\r\n          globalParamsString = this.RestoreSessionReInitializingDataFromLocalStorage(ConstInterface.GLOBAL_PARAM_LIST);\r\n          envVarsString = this.RestoreSessionReInitializingDataFromLocalStorage(ConstInterface.ENV_VAR_LIST);\r\n        }\r\n        else\r\n        {\r\n          globalParamsString = AccessHelper.globalParams.mirrorToXML();\r\n          envVarsString = AccessHelper.envParamsTable.mirrorToXML();\r\n        }\r\n        changes.Append(globalParamsString);\r\n        changes.Append(envVarsString);\r\n\r\n        // If there is stuff to synchronize, wrap it, scramble it and add the MGDATA flag\r\n        if (changes.Length > 0) {\r\n          changes.Insert(0, \"<\" + ConstInterface.MG_TAG_ENV_CHANGES + \">\");\r\n          changes.Append(\"</\" + ConstInterface.MG_TAG_ENV_CHANGES + \">\");\r\n\r\n          if (RemoteCommandsProcessor.ShouldScrambleAndUnscrambleMessages) {\r\n            let scrambledChanges: string = Scrambler.Scramble(changes.ToString());\r\n            changes = new StringBuilder(scrambledChanges);\r\n          }\r\n          changes.Insert(0, XMLConstants.MG_TAG_OPEN);\r\n          changes.Append(XMLConstants.MG_TAG_XML_END_TAGGED);\r\n\r\n          buffer.Append(changes.ToString());\r\n        }\r\n\r\n        reqBuf = buffer.ToString();\r\n      }\r\n    }\r\n\r\n    let requestStatus: RefParam<RequestStatus> = new RefParam(RequestStatus.Handled);\r\n    let respBuf: string = null;\r\n\r\n    if (RemoteCommandsProcessor.IsSessionReInitializing) {\r\n      reqBuf = reqBuf + this.RestoreSessionReInitializingDataFromLocalStorage(ConstInterface.MAIN_PROG_VIEW);\r\n    }\r\n\r\n    if (RuntimeContextBase.Instance.RemovedContextFromServer)\r\n      requestStatus.value = RequestStatus.Retry; //try to re-start session first\r\n    else {\r\n      if (RuntimeContextBase.Instance.RemovingContextFromServer)\r\n        RuntimeContextBase.Instance.RemovedContextFromServer = true;\r\n\r\n      respBuf = await this.DispatchRequest(this.ServerUrl, reqBuf, sessionStage, requestStatus);\r\n    }\r\n\r\n    if (requestStatus.value == RequestStatus.Retry) {\r\n      await this.ReStartSession();\r\n    }\r\n    if (respBuf == null)\r\n      return;\r\n\r\n    if (isInitialCall) {\r\n      RemoteCommandsProcessor.InitialUrl = window.location.href;\r\n      if (RemoteCommandsProcessor.IsSessionReInitializing) {\r\n        let dataStorage = window.localStorage;\r\n        dataStorage.removeItem(ConstInterface.IS_SESSION_REINITIALIZING);\r\n        dataStorage.removeItem(ConstInterface.MAIN_PROG_VIEW);\r\n        dataStorage.removeItem(ConstInterface.GLOBAL_PARAM_LIST);\r\n        dataStorage.removeItem(ConstInterface.ENV_VAR_LIST);\r\n        dataStorage.removeItem(ConstInterface.LAST_EXCEPTION);\r\n      }\r\n    }\r\n\r\n    FlowMonitorQueue.Instance.enable(false);\r\n    await this.ProcessResponse(respBuf, AccessHelper.mgDataTable.currMgdID, null, res);\r\n\r\n    if (RemoteCommandsProcessor.IsSessionReInitializing) {\r\n        AccessHelper.globalParams.RestoreParams(globalParamsString);\r\n        AccessHelper.envParamsTable.RestoreParams(envVarsString);\r\n\r\n      let dataStorage = window.localStorage;\r\n      let ctxRemoved = dataStorage.getItem(ConstInterface.CTX_REMOVED_FROM_SRVR);\r\n\r\n      if (ctxRemoved === \"1\") {\r\n\r\n        EventsManager.Instance.restoreLastSavedRouteEventFromLocalStorage();\r\n\r\n        dataStorage.removeItem(ConstInterface.CTX_REMOVED_FROM_SRVR);\r\n        dataStorage.removeItem(ConstInterface.LAST_ROUTE_EVENT);\r\n        dataStorage.removeItem(ConstInterface.LAST_ROUTE_EVENT_SRC_TSK);\r\n        dataStorage.removeItem(ConstInterface.LAST_ROUTE_EVENT_ARG_LIST);\r\n      }\r\n\r\n      RemoteCommandsProcessor.IsSessionReInitializing = false;\r\n    }\r\n    // if (isInitialCall) {\r\n    //   // If it was initial call, we will send all pending logs (Failed earlier execution scenario)\r\n    //   // They will be sent here, after first request is served.\r\n    //   if (ClientManager.Instance.getLogClientSequenceForActivityMonitor() && ClientLogAccumulator.ExistingLogsFound()) {\r\n    //     let success: boolean = this.SendPendingLogsToServer();\r\n    //\r\n    //     // if we have successfully sent the pending logs delete them\r\n    //     if (success) {\r\n    //       RemoteCommandsProcessor.DeletePendingLogs();\r\n    //     }\r\n    //   }\r\n    // }\r\n    // else if (this._logAccumulator !== null && !this._logAccumulator.Empty()) {\r\n    //   // Accumulated logs were sent, so reset (delete) them now\r\n    //   this._logAccumulator.Reset();\r\n    // }\r\n\r\n    // refresh the displays\r\n    if (sendingInstruction === CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS) {\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\r\n    if (isInitialCall)\r\n      ServerConfig.Instance.setGlobalParams(null);\r\n  }\r\n\r\n  /// <summary>send 'reqBuf' to 'url'; receive a response.\r\n  /// For Normal/InitialCall requests, the url points to the web-requester.\r\n  /// The other parameters and data goes as the encoded body.\r\n  /// This means that it is a POST request.\r\n  /// On the other hand, HandShake request is a GET request and so the parameters are\r\n  /// sent in the URL itself. In this case, encodedBody has to be null.\r\n  /// </summary>\r\n  /// <param name=\"url\">URL to be accessed.</param>\r\n  /// <param name=\"reqBuf\">data to be sent to the url</param>\r\n  /// <param name=\"sessionStage\">HANDSHAKE / INITIAL / NORMAL.</param>\r\n  /// <returns>response</returns>\r\n  private async DispatchRequest(url: string, reqBuf: string, sessionStage: CommandsProcessorBase_SessionStage, requestStatus: RefParam<RequestStatus>): Promise<string> {\r\n    let response: string = null;\r\n    let encodedBody: string = null;\r\n    requestStatus.value = RequestStatus.Handled;\r\n\r\n    if (url === null) {\r\n      Logger.Instance.WriteExceptionToLogWithMsg(\"in sendMsgToSrvr() unknown server\");\r\n      return response;\r\n    }\r\n\r\n    if (sessionStage !== CommandsProcessorBase_SessionStage.HANDSHAKE) {\r\n      let urlSuffix: string = this.BuildUrlSuffix(reqBuf !== null, sessionStage === CommandsProcessorBase_SessionStage.INITIAL);\r\n      let reqBufEncoded: string = HttpUtility.UrlEncode(reqBuf, Encoding.UTF8);\r\n      encodedBody = urlSuffix + reqBufEncoded;\r\n    }\r\n\r\n\r\n    try {\r\n      if (Logger.Instance.ShouldLogExtendedServerRelatedMessages())\r\n        Logger.Instance.WriteServerMessagesToLog(NString.Format(\"MESSAGE TO SERVER:\\n URL: {0}\\n BODY: {1}\", url, encodedBody));\r\n\r\n      response = await this.ExecuteRequest(url, encodedBody);\r\n\r\n      /* remove the unwanted data before the MGDATA tag */\r\n      if (!response.toUpperCase().startsWith(\"<HTML\")) {\r\n        let startIdx: number = response.indexOf(\"<xml id=\\\"MGDATA\\\">\");\r\n        if (startIdx > 0)\r\n          response = response.substr(startIdx);\r\n      }\r\n\r\n      Logger.Instance.WriteServerMessagesToLog(\"MESSAGE FROM SERVER: \" + response);\r\n\r\n      // handshake requests are always scrambled (the scrambling can be disabled starting from the 3rd request).\r\n      if (sessionStage === CommandsProcessorBase_SessionStage.HANDSHAKE ||\r\n        (response.length > 0 &&\r\n          RemoteCommandsProcessor.ShouldScrambleAndUnscrambleMessages && response !== \"<xml id=\\\"MGDATA\\\">\\n</xml>\")) {\r\n        if (sessionStage === CommandsProcessorBase_SessionStage.HANDSHAKE) {\r\n          // handshake requests are always scrambled.\r\n          Debug.Assert(response.length > 0 && response[0] !== '<');\r\n        }\r\n        response = CommandsProcessorBase.UnScramble(response);\r\n      }\r\n\r\n      Logger.Instance.WriteDevToLog(\"MESSAGE FROM SERVER: (size = \" + response.length + \")\" + OSEnvironment.EolSeq + response);\r\n\r\n      this._lastRequestTime = Misc.getSystemMilliseconds();\r\n    } catch (ex) {\r\n      if (ex instanceof ServerError) {\r\n        requestStatus.value = RequestStatus.Abort;\r\n\r\n\r\n        if (sessionStage == CommandsProcessorBase_SessionStage.NORMAL) {\r\n          // If context is not found at server due to crash or thread is aborted due to crash,\r\n          // check WebClientReinitSession. based on the flag, re-initializing request should be sent to create\r\n          // a new context and it should be executed in this new context.\r\n          // so, set the RequestStatus to Retry so that the client will resend request.\r\n          if (ex.GetCode() == ServerError.ERR_CTX_NOT_FOUND || ex.GetCode() == ServerError.ERR_THREAD_ABORTED) {\r\n            if (RuntimeContextBase.Instance.RemovedContextFromServer) {\r\n              requestStatus.value = RequestStatus.Retry;\r\n            } else {\r\n              switch (Environment.Instance.getWebClientReinitSession()) {\r\n                case 'Y' :\r\n                  requestStatus.value = RequestStatus.Retry;\r\n                  break;\r\n                case 'A':\r\n                  let retval = await GUIManager.Instance.MessageBox(\"Error\", \"Unknown error occurred at server-side.\" +\r\n                    \" Would you like to reinitialize the session?\", Styles.MSGBOX_BUTTON_YES_NO);\r\n                  requestStatus.value = (retval == Styles.MSGBOX_RESULT_YES) ? RequestStatus.Retry : RequestStatus.Abort;\r\n                  break;\r\n                case 'N':\r\n                default:\r\n                  requestStatus.value = RequestStatus.Abort;\r\n                  break;\r\n              }\r\n            }\r\n            if (requestStatus.value == RequestStatus.Abort) {\r\n              Environment.Instance.setWebClientReinitSession('N');\r\n              throw  ex;\r\n            } else {\r\n              let errForConsole = StrUtil.getConsoleErorString(ex.GetMessage());\r\n              RemoteCommandsProcessor.lastExceptionMessage = \"Exception Occured at server side : \" + ex.GetCode().toString() + \" : \" + errForConsole;\r\n              console.log(RemoteCommandsProcessor.lastExceptionMessage);\r\n            }\r\n            return null;\r\n          }\r\n        }\r\n      }\r\n      this.clearLocalStorage();\r\n      throw ex;\r\n    }\r\n    return response;\r\n  }\r\n\r\n  // <summary> If any items are stored on local storage clear it now as session cannot continued.\r\n  // Clearing only the local storage items which are stored by magic library.\r\n  clearLocalStorage(){\r\n    window.localStorage.removeItem(ConstInterface.LAST_ROUTE_EVENT);\r\n    window.localStorage.removeItem(ConstInterface.LAST_ROUTE_EVENT_SRC_TSK);\r\n    window.localStorage.removeItem(ConstInterface.LAST_ROUTE_EVENT_ARG_LIST);\r\n    window.localStorage.removeItem(ConstInterface.IS_SESSION_REINITIALIZING);\r\n    window.localStorage.removeItem(ConstInterface.MAIN_PROG_VIEW);\r\n    window.localStorage.removeItem(ConstInterface.GLOBAL_PARAM_LIST);\r\n    window.localStorage.removeItem(ConstInterface.ENV_VAR_LIST);\r\n    window.localStorage.removeItem(ConstInterface.LAST_EXCEPTION);\r\n    window.localStorage.removeItem(ConstInterface.CTX_REMOVED_FROM_SRVR);\r\n  }\r\n\r\n  /// <summary> Checks the response string, throws an error if the response string contains\r\n  /// an xml/html error</summary>\r\n  /// <param name=\"response\"></param>\r\n  private HandleErrorResponse(response: string): void {\r\n    try {\r\n      // error responses are always scrambled by the web server.\r\n      Logger.Instance.WriteServerMessagesToLog(\"MESSAGE FROM SERVER: \" + response);\r\n      response = CommandsProcessorBase.UnScramble(response);\r\n      Logger.Instance.WriteServerMessagesToLog(\"MESSAGE FROM SERVER: \" + StrUtil.getConsoleErorString(response));\r\n    } catch (ex) {\r\n    }\r\n\r\n    if (response.startsWith(\"<xmlerr\")) {\r\n      let errorMessageXml: ErrorMessageXml = new ErrorMessageXml(response, this._lastRequestTime, AccessHelper.environment.getContextInactivityTimeout());\r\n      throw new ServerError(errorMessageXml.GetMessage(), errorMessageXml.GetCode());\r\n    } else if (response.toUpperCase().startsWith(\"<HTML\")) {\r\n      throw new ServerError(response);\r\n    }\r\n  }\r\n\r\n  /// <summary>send 'encodedBody' to 'url' and receive a response.\r\n  /// </summary>\r\n  /// <param name=\"url\">URL to be accessed.</param>\r\n  /// <param name=\"encodedBody\">In case of POST, content to be sent to server. For other methods, null.</param>\r\n  /// <returns>the response from the server</returns>\r\n  private async ExecuteRequest(url: string, encodedBody: string): Promise<string> {\r\n    return await this.GetContent(url, false, encodedBody);\r\n  }\r\n\r\n  async GetContent(requestedURL: string, useCache: boolean, requestContent?: string): Promise<string> {\r\n    if (isUndefined(requestContent))\r\n      requestContent = null;\r\n\r\n    let responseStr: string;\r\n\r\n    try {\r\n      // if relative, prefix with the 'protocol://server/' from which the rich-client was activated\r\n      if (requestedURL.startsWith(\"/\"))\r\n        requestedURL = ServerConfig.Instance.getProtocol() + \"://\" + ServerConfig.Instance.getServer() + requestedURL;\r\n\r\n      var spinnerTimer = timer(50, 50);\r\n      var spinnerTimerSubscription: Subscription = spinnerTimer.subscribe(() => {\r\n        AccessHelper.eventsManager.CheckAndShowSpinner(true);\r\n      });\r\n\r\n      let isError: RefParam<boolean> = new RefParam(false);\r\n\r\n      responseStr = await HttpManager.GetInstance().GetContent(requestedURL, requestContent, useCache, isError);\r\n\r\n      spinnerTimerSubscription.unsubscribe();\r\n      spinnerTimerSubscription = null;\r\n\r\n      if (isError.value) {\r\n        this.HandleErrorResponse(responseStr);\r\n      }\r\n    } catch (ex) {\r\n      // don't write server error to log when the log level is basic\r\n      if (!(ex instanceof ServerError) || Logger.Instance.LogLevel !== Logger_LogLevels.Basic) {\r\n        Logger.Instance.WriteExceptionToLog(ex, NString.Format(\"requested URL = \\\"{0}\\\"\", requestedURL));\r\n      }\r\n\r\n      // the exception should be thrown and the callers should handle it.\r\n      if (!(ex instanceof ServerError)) {\r\n        ex = new ServerError(ex.Message, ex.InnerException ? ex.InnerException : ex);\r\n      }\r\n\r\n      throw ex;\r\n    } finally {\r\n      if (spinnerTimerSubscription != null)\r\n        spinnerTimerSubscription.unsubscribe();\r\n    }\r\n\r\n    return responseStr;\r\n  }\r\n\r\n\r\n  ClientActivated() {\r\n\r\n    // log the values as client is active again\r\n    // TODO - formatting\r\n    // console.log('Logging Summary ' + '\\n' +\r\n    //   'Total number requests : ' + RemoteCommandsProcessor.requestNumber + '\\n' +\r\n    //   'Total time needed for http requests : ' + RemoteCommandsProcessor.totalTimeForHTTPRequests + ' ms ' + '\\n' +\r\n    //   'Total time needed for client to get active : ' + executionTime + ' ms ' + '\\n'\r\n    // );\r\n    //\r\n    // // TODO - move it to method\r\n    // RemoteCommandsProcessor.requestNumber = 0;\r\n    // RemoteCommandsProcessor.totalTimeForHTTPRequests = 0;\r\n    // RemoteCommandsProcessor.totalRequestDataLength = 0;\r\n    // RemoteCommandsProcessor.totalResponseDataLength = 0;\r\n  }\r\n\r\n  /// <summary> When LogClientSequenceForActivityMonitor = Y we will be keeping the logs in file and send the file with next\r\n  /// server access. If client is abnormally terminated then there can be 1 or more files containing logs since\r\n  /// last server access.Now these logs will be sent to server, when next time RC program is executed,.</summary>\r\n  /// <returns> If sending was successful</returns>\r\n  //   TODO: Handle pending logs.\r\n  // private SendPendingLogsToServer(): boolean {\r\n  //   let success: boolean = true;\r\n  //\r\n  //   The pending logs cannot be read from the file system since WebClient doesn't have access to that.\r\n  //   Maybe, the logs should be written into LocalStorage ad read from there.\r\n  //\r\n  //   let stringBuilder: StringBuilder = new StringBuilder(1000);\r\n  //   let flowMonitor: FlowMonitorQueue = FlowMonitorQueue.Instance;\r\n  //\r\n  //   // Get iterator to names of log files.\r\n  //   let enumerator: IEnumerator<string> = ClientLogAccumulator.ExistingLogIterator();\r\n  //\r\n  //   // while there are more files\r\n  //   while (enumerator.MoveNext()) {\r\n  //     // Take next file name\r\n  //     let logName: string = enumerator.Current;\r\n  //     // Prepare the header line (Client log file : <Context : XXXXXX>) and add it to\r\n  //     // flow monitor build monitor message\r\n  //     let headerLine: string = ClientLogAccumulator.BuildLogHeaderLine(logName);\r\n  //     flowMonitor.addFlowVerifyInfo(headerLine);\r\n  //     let logCtxBuf: StringBuilder = RemoteCommandsProcessor.BuildMonitorMessage();\r\n  //\r\n  //     let fileContents: string = HandleFiles.readToString(logName);\r\n  //     logCtxBuf.Append(fileContents);\r\n  //     stringBuilder.Append(logCtxBuf.ToString());\r\n  //   }\r\n  //\r\n  //   let respBuf: string = null;\r\n  //\r\n  //   try {\r\n  //     respBuf = this.DispatchRequest(this.ServerUrl, stringBuilder.ToString(), CommandsProcessorBase_SessionStage.NORMAL);\r\n  //   }\r\n  //   catch (ex) {\r\n  //     // do nothing. if sending log fails, there is no harm.\r\n  //   }\r\n  //\r\n  //   if (respBuf === null) {\r\n  //     success = false;\r\n  //   }\r\n  //\r\n  //   return success;\r\n  // }\r\n\r\n  // TODO: Handle pending logs.\r\n  // private static DeletePendingLogs(): void {\r\n  //   let enumerator: IEnumerator = ClientLogAccumulator.ExistingLogIterator();\r\n  //   while (enumerator.MoveNext()) {\r\n  //     let filename: string = <string>enumerator.Current;\r\n  //     HandleFiles.deleteFile(filename);\r\n  //   }\r\n  // }\r\n\r\n  /// <summary> get the suffix of the URL to be sent to the server. This includes the CTX, SESSION and DATA parameters.</summary>\r\n  /// <param name=\"hasContent\">if true, the HTTP DATA parameter contains something.</param>\r\n  /// <param name=\"isInitialCall\">if true then the generated suffix has no specific context data</param>\r\n  /// <returns> the URL suffix (i.e. \"CTX=...&SESSION=...&DATA=\"</returns>\r\n  private BuildUrlSuffix(hasContent: boolean, isInitialCall: boolean): string {\r\n    let prefix: string = ConstInterface.RC_INDICATION + ConstInterface.RC_TOKEN_CTX_ID + RuntimeContextBase.Instance.ContextID;\r\n\r\n    // Append session id in url only when it is not null or empty\r\n    // NOTE: session id will be send by server only for GS as middleware\r\n    //       and when sepecial flag (SpecialRIAGenerateAndValidateSessionID) is on\r\n    //       so session id will be null for broker middleware and when special flag is OFF.\r\n    if (!isNullOrUndefined(this.SessionId))\r\n      prefix += (ConstInterface.REQ_ARG_SEPARATOR + ConstInterface.RC_TOKEN_SESSION_ID + this.SessionId);\r\n\r\n    if (isInitialCall) {\r\n      // TODO: How to get environment variables?\r\n      // let envVars: string = ClientManager.Instance.getEnvVars();\r\n      // if (!NString.IsNullOrEmpty(envVars)) {\r\n      //   // environment variables: ENV1,ENV2,.. --> &ENV1=val1&ENV2=val2...\r\n      //   let envVarsVec: string[] = envVars.split(\",\");\r\n      //   for (let i: number = 0; i < envVarsVec.length; i = i + 1) {\r\n      //     prefix += (\"&\" + envVarsVec[i] + \"=\" + OSEnvironment.get(envVarsVec[i]));\r\n      //   }\r\n      // }\r\n      if (RemoteCommandsProcessor.IsSessionReInitializing)\r\n        prefix += (ConstInterface.REQ_ARG_SEPARATOR + ConstInterface.WEBCLIENT_REINITIALIZE_REQUEST);\r\n\r\n      let globalParams: string = ServerConfig.Instance.getGlobalParams();\r\n      if (globalParams !== null) {\r\n        globalParams = NString.Replace(globalParams, \"+\", \"%2B\");\r\n        prefix += (\"&\" + ConstInterface.MG_TAG_GLOBALPARAMS + \"=\" + globalParams);\r\n      }\r\n    } // isInitialCall\r\n\r\n    if (hasContent) {\r\n      prefix += (\"&\" + ConstInterface.RC_TOKEN_SESSION_COUNT + this.GetSessionCounter() +\r\n        ConstInterface.REQ_ARG_SEPARATOR + ConstInterface.RC_TOKEN_DATA);\r\n    }\r\n\r\n    return prefix;\r\n  }\r\n\r\n  /// <summary>send Monitor messaging to the server</summary>\r\n  public async SendMonitorOnly(): Promise<void> {\r\n    let flowMonitor: FlowMonitorQueue = FlowMonitorQueue.Instance;\r\n\r\n    if (AccessHelper.mgDataTable == null || AccessHelper.mgDataTable.getMGData(0) == null || AccessHelper.mgDataTable.getMGData(0).IsAborting)\r\n      return;\r\n\r\n    if (!flowMonitor.isEmpty()) {\r\n      // build out message\r\n      let buffer: StringBuilder = this.BuildMonitorMessage();\r\n\r\n      // If client sequence is to be accumulated until next server access.\r\n      let shouldAccumulateClientLog: boolean = false;\r\n      // shouldAccumulateClientLog = ClientManager.Instance.getLogClientSequenceForActivityMonitor();\r\n      // if (shouldAccumulateClientLog) {\r\n      //   if (this._logAccumulator == null)\r\n      //     this._logAccumulator = new ClientLogAccumulator(ClientManagerRuntime.Instance.RuntimeCtx.ContextID);\r\n      //\r\n      //   // If we're unable to open the file, deactivate logging accumulation,\r\n      //   //    and let the message be sent to the server as done without accumulated logging\r\n      //   if (this._logAccumulator.IsFailed())\r\n      //     shouldAccumulateClientLog = false;\r\n      // }\r\n\r\n      if (shouldAccumulateClientLog) {\r\n        // Write message to file.\r\n        // this._logAccumulator.Write(buffer.ToString());\r\n      } else {\r\n        try {\r\n          let requestStatus: RefParam<RequestStatus> = new RefParam(RequestStatus.Handled);\r\n          await this.DispatchRequest(this.ServerUrl, buffer.ToString(), CommandsProcessorBase_SessionStage.NORMAL, requestStatus);\r\n        } catch (err) {\r\n          // do nothing. if sending log fails, there is no harm.\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>build Flow Monitor message</summary>\r\n  private BuildMonitorMessage(): StringBuilder {\r\n    let buffer: StringBuilder = new StringBuilder(1000);\r\n    let flowMonitor: FlowMonitorQueue = FlowMonitorQueue.Instance;\r\n\r\n    if (!RemoteCommandsProcessor.ShouldScrambleAndUnscrambleMessages) {\r\n      buffer.Append(XMLConstants.MG_TAG_OPEN);\r\n      flowMonitor.buildXML(buffer);\r\n    } else {\r\n      flowMonitor.buildXML(buffer);\r\n      let scrambledOut: string = Scrambler.Scramble(buffer.ToString());\r\n      buffer = new StringBuilder(1000);\r\n      buffer.Append(XMLConstants.MG_TAG_OPEN + scrambledOut);\r\n    }\r\n    buffer.Append(\"</\" + XMLConstants.MG_TAG_XML + XMLConstants.TAG_CLOSE);\r\n\r\n    return buffer;\r\n  }\r\n\r\n  RegisterDelegates(): void {\r\n    HttpClientEvents.GetSessionCounter_Event = this.GetSessionCounter.bind(this);\r\n    HttpClientEvents.CheckAndSetSessionCounter_Event = this.CheckAndSetSessionCounter.bind(this);\r\n    HttpClientEvents.ComputeAndLogRequestInfo_Event = this.ComputeAndLogRequestInfo.bind(this);\r\n    AccessHelper.eventsManager.SpinnerStopped.subscribe(clientBusyTime => this.ClientActivated());\r\n  }\r\n\r\n  /// <summary>\r\n  /// Log the current request information in console\r\n  /// </summary>\r\n  ComputeAndLogRequestInfo(contentLength: number, roundTrip: number, isLoggingResponse: boolean): void {\r\n    if (!isNullOrUndefined(this._requestInfo.serverCallAt)) {\r\n\r\n      this._requestInfo.extraInfo.contentLength = contentLength;\r\n      this._requestInfo.extraInfo.timeStamp = new Date().toString();\r\n      let extraMessageStr: string = isLoggingResponse ? 'Response ⤵' : 'Request ⤵';\r\n\r\n      if (isLoggingResponse) {\r\n        this._requestInfo.roundtripTime = roundTrip;\r\n      }\r\n\r\n\r\n      Logger.Instance.WriteRequestInfoToLog(this._requestInfo, extraMessageStr);\r\n\r\n      // Clear the client session after logging the response\r\n      if (isLoggingResponse)\r\n        this._requestInfo.clear();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// When true, requests are scrambled and responses are unscrambled.\r\n  /// </summary>\r\n  static set ShouldScrambleAndUnscrambleMessages(value: boolean) {\r\n    RemoteCommandsProcessor._shouldScrambleAndUnscrambleMessages = value;\r\n    Logger.Instance.WriteServerMessagesToLog(NString.Format(\"ShouldScrambleAndUnscrambleMessages.Set: {0}\", this._shouldScrambleAndUnscrambleMessages));\r\n  }\r\n\r\n  static get ShouldScrambleAndUnscrambleMessages(): boolean {\r\n    Logger.Instance.WriteServerMessagesToLog(NString.Format(\"ShouldScrambleAndUnscrambleMessages.Get: {0}\", this._shouldScrambleAndUnscrambleMessages));\r\n    return RemoteCommandsProcessor._shouldScrambleAndUnscrambleMessages;\r\n  }\r\n\r\n\r\n  /// <summary>parse the log level from a string value</summary>\r\n  /// <param name=\"strLogLevel\">string value of the log level</param>\r\n  /// <returns>log level</returns>\r\n  parseLogLevel(strLogLevel: string): Logger_LogLevels {\r\n    let logLevel: Logger_LogLevels = Logger_LogLevels.None;\r\n\r\n    if (!NString.IsNullOrEmpty(strLogLevel)) {\r\n      if (strLogLevel.toUpperCase().startsWith(\"SERVER\"))\r\n        logLevel = strLogLevel.endsWith(\"#\") ? Logger_LogLevels.ServerMessages : Logger_LogLevels.Server; // only requests to the server\r\n      else if (strLogLevel.toUpperCase().startsWith(\"S\") || strLogLevel.toUpperCase().startsWith(\"Q\"))\r\n        logLevel = Logger_LogLevels.Support;\r\n      else if (strLogLevel.toUpperCase().startsWith(\"G\"))\r\n        logLevel = Logger_LogLevels.Gui;\r\n      else if (strLogLevel.toUpperCase().startsWith(\"D\"))\r\n        logLevel = Logger_LogLevels.Development;\r\n      else if (strLogLevel.toUpperCase().startsWith(\"B\"))\r\n        logLevel = Logger_LogLevels.Basic;\r\n      else if (strLogLevel.toUpperCase().startsWith(\"R\"))\r\n        logLevel = Logger_LogLevels.RequestInfo;\r\n    }\r\n\r\n    return logLevel;\r\n  }\r\n\r\n\r\n  /// <summary> build the XML string of the data that should be sent to the server</summary>\r\n  /// <param name=\"serializeTasks\">if true, tasks in the current execution will also be serialized.</param>\r\n  async PrepareRequest(serializeTasks: boolean): Promise<string> {\r\n    let xmlBuf: StringBuilder = new StringBuilder();\r\n    xmlBuf.Append(XMLConstants.MG_TAG_OPEN);\r\n\r\n    // the client no longer sends (and empties) the event queue to the server\r\n    // since the server has nothing useful to do with the client pending events\r\n    if (AccessHelper.mgDataTable.getCurrMGData() !== null) {\r\n      let xmlUnscrambled: StringBuilder = new StringBuilder();\r\n      await AccessHelper.mgDataTable.buildXML(xmlUnscrambled, serializeTasks);\r\n\r\n      if (RemoteCommandsProcessor.ShouldScrambleAndUnscrambleMessages)\r\n        xmlBuf.Append(Scrambler.Scramble(xmlUnscrambled.ToString()));\r\n      else\r\n        xmlBuf.Append(xmlUnscrambled.ToString());\r\n    }\r\n    xmlBuf.Append(\"</\" + XMLConstants.MG_TAG_XML + XMLConstants.TAG_CLOSE);\r\n\r\n    return xmlBuf.ToString();\r\n  }\r\n\r\n\r\n  /// <summary>parse a response (from the Server) and execute commands if returned within the response.</summary>\r\n  /// <param name=\"response\">(XML formatted) response.</param>\r\n  /// <param name=\"currMgdID\">number of window in global array</param>\r\n  /// <param name=\"openingTaskDetails\">additional information of opening task</param>\r\n  /// <param name=\"res\">result to be read from command returned witin the response.</param>\r\n  async ProcessResponse(response: string, currMgdID: number, openingTaskDetails: OpeningTaskDetails, res: IResultValue): Promise<void> {\r\n    Logger.Instance.WriteDevToLog(\"<-- ProcessResponse started -->\");\r\n    if (openingTaskDetails === null)\r\n      openingTaskDetails = new OpeningTaskDetails();\r\n\r\n    let systemMilliseconds: number = Misc.getSystemMilliseconds();\r\n    if (response === null || response.trim().length === 0)\r\n      return;\r\n\r\n    AccessHelper.mgDataTable.currMgdID = currMgdID;\r\n\r\n    RuntimeContextBase.Instance.Parser.push(); // allow recursive parsing\r\n    RuntimeContextBase.Instance.Parser.setXMLdata(response);\r\n    RuntimeContextBase.Instance.Parser.setCurrIndex(0);\r\n\r\n    let currMGData: MGData = AccessHelper.mgDataTable.getCurrMGData();\r\n    await currMGData.fillData(openingTaskDetails, RuntimeContextBase.Instance.Parser);\r\n\r\n    // free memory\r\n    RuntimeContextBase.Instance.Parser.setXMLdata(null);\r\n    RuntimeContextBase.Instance.Parser.pop();\r\n\r\n    Logger.Instance.WriteDevToLog(\"<-- ProcessResponse finished --> (\" + (Misc.getSystemMilliseconds() - systemMilliseconds) + \")\");\r\n    // execute the commands that were returned in the response\r\n    await (<CommandsTable>currMGData.CmdsToClient).Execute(res);\r\n    await this.ProcessRecovery();\r\n  }\r\n\r\n  /// <summary>\r\n  /// processRecovery\r\n  /// </summary>\r\n  async ProcessRecovery(): Promise<void> {\r\n\r\n    // QCR #771012 - process data error recovery only after the parsing process is over.\r\n    AccessHelper.eventsManager.pushNewExecStacks();\r\n    await AccessHelper.mgDataTable.processRecovery();\r\n    AccessHelper.eventsManager.popNewExecStacks();\r\n  }\r\n}\r\n\r\n/// <summary>helper class: details from the runtime-engine - environment values.\r\n/// Handshake response: <Richclientresponse> <ContextID>...</ContextID> <Environment InputPassword=\"Y|N\"\r\n/// SystemLogin=\"F|N|D|L\" /> </Richclientresponse>\r\n/// </summary>\r\nclass HandshakeResponse {\r\n  static readonly SYSTEM_LOGIN_AD: string = 'D';\r\n\r\n  private _scrambleMessages: boolean = true; // true if messages should be scrambled/unscrambled by the client and server\r\n  get ScrambleMessages(): boolean {\r\n    return this._scrambleMessages;\r\n  }\r\n\r\n  private _contextId: string = null;\r\n\r\n  get ContextId(): string {\r\n    return this._contextId;\r\n  }\r\n\r\n  private _privateSessionId: string = null;\r\n\r\n  get GetSessionId(): string {\r\n    return this._privateSessionId;\r\n  }\r\n\r\n  private _inputPassword: boolean = false;\r\n\r\n  get InputPassword(): boolean {\r\n    return this._inputPassword;\r\n  }\r\n\r\n  private _httpTimeout: number = 0;\r\n\r\n  get HttpTimeout(): number {\r\n    return this._httpTimeout;\r\n  }\r\n\r\n  private _systemLogin: string = null;\r\n\r\n  get SystemLogin(): string {\r\n    return this._systemLogin;\r\n  }\r\n\r\n  private _maxInternalLogLevel: string = null;\r\n\r\n  get MaxInternalLogLevel(): string {\r\n    return this._maxInternalLogLevel;\r\n  }\r\n\r\n  constructor(responseXML: string) {\r\n    try {\r\n      JSON_Utils.JSONFromXML(responseXML, this.FillFromJSON.bind(this));\r\n    } catch (ex) {\r\n      Logger.Instance.WriteExceptionToLog(ex, responseXML);\r\n    }\r\n  }\r\n\r\n  private FillFromJSON(error, result): void {\r\n\r\n    // If there was an error in parsing the XML,\r\n    if (error != null) {\r\n      throw error;\r\n    }\r\n\r\n    let response = result['Richclientresponse'];\r\n\r\n    for (let elementName in response) {\r\n      if (response.hasOwnProperty(elementName)) {\r\n\r\n        switch (elementName) {\r\n          case \"ContextID\":\r\n            this._contextId = response[elementName][0];\r\n            break;\r\n          case \"SessionID\":\r\n            this._privateSessionId = response[elementName][0];\r\n            break;\r\n          case \"Environment\":\r\n            let envAttributes = response[\"Environment\"][0]['$'];\r\n\r\n            if (!isNullOrUndefined(envAttributes[\"ScrambleMessages\"])) {\r\n              Debug.Assert(envAttributes[\"ScrambleMessages\"] === \"N\");\r\n              this._scrambleMessages = false;\r\n            }\r\n            if (!isNullOrUndefined(envAttributes[\"MaxInternalLogLevel\"]))\r\n              this._maxInternalLogLevel = envAttributes[\"MaxInternalLogLevel\"];\r\n            if (!isNullOrUndefined(envAttributes[\"InputPassword\"]) && envAttributes[\"InputPassword\"].toLocaleLowerCase() === \"y\")\r\n              this._inputPassword = true;\r\n            if (!isNullOrUndefined(envAttributes[\"SystemLogin\"]))\r\n              this._systemLogin = envAttributes[\"SystemLogin\"];\r\n            if (!isNullOrUndefined(envAttributes[ConstInterface.MG_TAG_HTTP_COMMUNICATION_TIMEOUT]))\r\n              this._httpTimeout = +envAttributes[ConstInterface.MG_TAG_HTTP_COMMUNICATION_TIMEOUT];\r\n            if (!isNullOrUndefined(envAttributes[\"ForwardSlash\"]))\r\n              AccessHelper.environment.ForwardSlashUsage = envAttributes[\"ForwardSlash\"];\r\n            break;\r\n        }\r\n      }\r\n    }\r\n  }\r\n}\r\n\r\n/// <summary>This class implements MgSAXHandlerInterface, which means that it defines all the \"callback\"\r\n/// methods that the SAX parser will invoke to notify the application. In this example we override the\r\n/// methods that we require.</summary>\r\nclass ErrorMessageXml {\r\n  private _lastRequestTime: number = 0;\r\n  contextInactivityTimeout: number;\r\n\r\n  private _errorMessage: string = null;\r\n  private _errorCode: number = 0;\r\n  private _middlewareAddress: string = null;\r\n  private readonly _parsingFailed: boolean = false;\r\n\r\n  constructor(xmlContent: string, lastRequestTime: number, contextInactivityTimeout: number) {\r\n    this._lastRequestTime = lastRequestTime;\r\n    this.contextInactivityTimeout = contextInactivityTimeout;\r\n    try {\r\n      JSON_Utils.JSONFromXML(xmlContent, this.FillFromJSON.bind(this));\r\n    } catch (ex) {\r\n      Logger.Instance.WriteExceptionToLog(ex);\r\n      Misc.WriteStackTrace(ex);\r\n      this._parsingFailed = true;\r\n    }\r\n  }\r\n\r\n  private FillFromJSON(error, result): void {\r\n\r\n    // If there was an error in parsing the XML,\r\n    if (error != null) {\r\n      throw error;\r\n    }\r\n\r\n    let xmlerr = result['xmlerr'];\r\n\r\n    for (let elementName in xmlerr) {\r\n      if (xmlerr.hasOwnProperty(elementName)) {\r\n        switch (elementName) {\r\n          case \"errmsg\":\r\n            this._errorMessage = xmlerr[elementName][0];\r\n            break;\r\n          case \"errcode\":\r\n            this._errorCode = +(xmlerr[elementName]);\r\n            break;\r\n          case \"server\":\r\n            this._middlewareAddress = xmlerr[elementName][0];\r\n            break;\r\n          case \"appname\": // ignored - the client lists this value from the execution properties\r\n          case \"prgname\": // ignored - the client lists this value from the execution properties\r\n          case \"arguments\": // ignored\r\n          case \"username\":  // ignored\r\n          case \"xmlerr\": // end of the error message\r\n            break;\r\n          default:\r\n            Logger.Instance.WriteExceptionToLogWithMsg(NString.Format(\"Unknown element: '{0}'\", elementName));\r\n            break;\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  GetCode(): number {\r\n    return this._errorCode;\r\n  }\r\n\r\n  // build & return a formatted error message\r\n  GetMessage(): string {\r\n    let sb: StringBuilder = new StringBuilder();\r\n\r\n    if (this._parsingFailed) {\r\n      sb.Append(AccessHelper.languageData.getConstMessage(MsgInterface.RC_STR_F7_UNEXPECTED_ERR));\r\n    } else {\r\n      switch (this._errorCode) {\r\n        case ServerError.ERR_CTX_NOT_FOUND:\r\n          if (this.InactivityTimeoutExpired())\r\n            sb.Append(NString.Format(\"{0} ({1} {2})\",\r\n              AccessHelper.languageData.getConstMessage(MsgInterface.STR_ERR_SESSION_CLOSED_INACTIVITY),\r\n              Math.floor(this.contextInactivityTimeout / 600), // conversion from 1/10 of seconds to minutes\r\n              AccessHelper.languageData.getConstMessage(MsgInterface.STR_MINUTES)));\r\n          else\r\n            sb.Append(NString.Format(\"{0} ({1}).\", AccessHelper.languageData.getConstMessage(MsgInterface.STR_ERR_SESSION_CLOSED), this._errorCode));\r\n          break;\r\n\r\n        case ServerError.ERR_WEBCLIENT_PROGRAM_RELOADED:\r\n          sb.Append(AccessHelper.languageData.getConstMessage(MsgInterface.STR_ERR_WEBCLIENT_PROGRAM_RELOADED));\r\n          break;\r\n\r\n        case ServerError.ERR_EXECUTED_PROGRAM_CHANGED:\r\n          sb.Append(AccessHelper.languageData.getConstMessage(MsgInterface.STR_ERR_EXECUTED_PROGRAM_CHANGED));\r\n          break;\r\n\r\n        case ServerError.ERR_AUTHENTICATION:\r\n          sb.Append(AccessHelper.languageData.getConstMessage(MsgInterface.USRINP_STR_BADPASSW));\r\n          break;\r\n\r\n        case ServerError.ERR_ACCESS_DENIED:\r\n          sb.Append(AccessHelper.languageData.getConstMessage(MsgInterface.STR_ERR_AUTHORIZATION_FAILURE));\r\n          break;\r\n\r\n        default:\r\n          sb.Append(this._errorMessage);\r\n          break;\r\n      }\r\n\r\n      sb.Append(OSEnvironment.EolSeq + OSEnvironment.EolSeq);\r\n\r\n      if (!ServerConfig.Instance.ShouldDisplayGenericError()) {\r\n        sb.Append(AccessHelper.languageData.getConstMessage(MsgInterface.BROWSER_OPT_INFO_SERVER_STR) + \":   \");\r\n        sb.Append(ServerConfig.Instance.getServer());\r\n        if (!NString.IsNullOrEmpty(this._middlewareAddress)) {\r\n          sb.Append(\" --> \");\r\n          sb.Append(this._middlewareAddress);\r\n        }\r\n        sb.Append(OSEnvironment.EolSeq);\r\n      }\r\n\r\n      sb.Append(AccessHelper.languageData.getConstMessage(MsgInterface.TASKRULE_STR_APPLICATION) + \":   \\\"\");\r\n      sb.Append(ServerConfig.Instance.getAppName());\r\n      sb.Append(\"\\\" (\\\"\");\r\n      sb.Append(\"\\\")\");\r\n    }\r\n\r\n    return sb.ToString();\r\n  }\r\n\r\n  private InactivityTimeoutExpired(): boolean {\r\n    let expired: boolean = false;\r\n    if (this.contextInactivityTimeout > 0) {\r\n      let currTimeMilli: number = Misc.getSystemMilliseconds();\r\n      expired = ((currTimeMilli - this._lastRequestTime) > (this.contextInactivityTimeout * 100));\r\n    }\r\n    return expired;\r\n  }\r\n}\r\n\r\n// TODO: Implement this class\r\n// class ClientLogAccumulator {\r\n//\r\n//   private static CLIENT_LOG_HDR_MSG: string = \"Client log file\";\r\n//   private static _existingLogNames: List<string> = new List<string>();\r\n//   private _clientLogOs: StreamWriter = null;\r\n//   private _contextId: number = 0;\r\n//   private _failed: boolean = false;\r\n//   private _fileName: string = null;\r\n//\r\n//   constructor(contextID: number) {\r\n//     this._contextId = contextID;\r\n//     this._fileName = this.BuildFileName();\r\n//     this.OpenForWrite();\r\n//   }\r\n//\r\n//   Write(buffer: string): void {\r\n//     try {\r\n//       let flag: boolean = !this._failed;\r\n//       if (!flag) {\r\n//         throw new IOException(\"ClientLogSequence : Loging client sequence is deactivated\");\r\n//       }\r\n//       let flag2: boolean = this.OpenForWrite();\r\n//       if (flag2) {\r\n//         this._clientLogOs.Write(buffer);\r\n//         this._clientLogOs.Close();\r\n//         this._clientLogOs = null;\r\n//         this.OpenForWrite();\r\n//       }\r\n//     }\r\n//     catch (ex) {\r\n//       if (ex instanceof IOException) {\r\n//         Logger.Instance.WriteDevToLog(ex.Message);\r\n//         Misc.WriteStackTrace(ex, NConsole.Error);\r\n//       }\r\n//       else\r\n//         throw ex;\r\n//     }\r\n//   }\r\n//\r\n//   Read(): string {\r\n//     let result: string = null;\r\n//     try {\r\n//       let flag: boolean = !this._failed;\r\n//       if (!flag) {\r\n//         throw new IOException(\"ClientLogSequence : Loging client sequence is deactivated\");\r\n//       }\r\n//       this._clientLogOs.Close();\r\n//       this._clientLogOs = null;\r\n//       result = HandleFiles.readToString(this._fileName, Encoding.Default);\r\n//       this.OpenForWrite();\r\n//     }\r\n//     catch (ex) {\r\n//       if (ex instanceof IOException) {\r\n//         Logger.Instance.WriteDevToLog(ex.Message);\r\n//         Misc.WriteStackTrace(ex, NConsole.Error);\r\n//       }\r\n//       else\r\n//         throw ex;\r\n//     }\r\n//     return result;\r\n//   }\r\n//\r\n//   Reset(): void {\r\n//     try {\r\n//       let flag: boolean = !this._failed;\r\n//       if (!flag) {\r\n//         throw new IOException(\"ClientLogSequence : Loging client sequence is deactivated\");\r\n//       }\r\n//       this._clientLogOs.Close();\r\n//       this._clientLogOs = null;\r\n//       HandleFiles.deleteFile(this._fileName);\r\n//     }\r\n//     catch (ex) {\r\n//       if (ex instanceof IOException) {\r\n//         Logger.Instance.WriteExceptionToLog(ex);\r\n//       }\r\n//       else\r\n//         throw ex;\r\n//     }\r\n//   }\r\n//\r\n//   static ExistingLogsFound(): boolean {\r\n//     let result: boolean = false;\r\n//     ClientLogAccumulator.BuildexistingLogList();\r\n//     let flag: boolean = ClientLogAccumulator._existingLogNames !== null && ClientLogAccumulator._existingLogNames.Count > 0;\r\n//     if (flag) {\r\n//       result = true;\r\n//     }\r\n//     return result;\r\n//   }\r\n//\r\n//   static ExistingLogIterator(): IEnumerator<string> {\r\n//     return ClientLogAccumulator._existingLogNames.GetEnumerator();\r\n//   }\r\n//\r\n//   static BuildLogHeaderLine(logName: string): string {\r\n//     let stringBuilder: StringBuilder = new StringBuilder(\"Client log file\");\r\n//     let str: string = NString.Substring(logName, logName.LastIndexOf(NNumber.ToString(Path.DirectorySeparatorChar) + \"CS\") + 3, logName.LastIndexOf(\".log\") - (logName.LastIndexOf(NNumber.ToString(Path.DirectorySeparatorChar) + \"CS\") + 3));\r\n//     stringBuilder.Append(\" (Context : \");\r\n//     stringBuilder.Append(str + \" ) \");\r\n//     return stringBuilder.ToString();\r\n//   }\r\n//\r\n//   Empty(): boolean {\r\n//     return this._failed || !HandleFiles.isExists(this._fileName) || HandleFiles.getFileSize(this._fileName) === 0;\r\n//   }\r\n//\r\n//   IsFailed(): boolean {\r\n//     return this._failed;\r\n//   }\r\n//\r\n//   private static BuildexistingLogList(): void {\r\n//     let flag: boolean = ClientLogAccumulator._existingLogNames !== null && ClientLogAccumulator._existingLogNames.Count === 0;\r\n//     if (flag) {\r\n//       let path: string = \"\";\r\n//       ClientLogAccumulator._existingLogNames.AddRange(NArray.ToEnumerable(Directory.GetFiles(path, \"CS*.LOG\")));\r\n//     }\r\n//   }\r\n//\r\n//   private OpenForWrite(): boolean {\r\n//     let flag: boolean = this._clientLogOs === null;\r\n//     if (flag) {\r\n//       try {\r\n//         this._clientLogOs = new StreamWriter(this._fileName, true, Encoding.Default);\r\n//         this._failed = false;\r\n//       }\r\n//       catch (ex) {\r\n//         if (ex instanceof IOException) {\r\n//           Logger.Instance.WriteDevToLog(\"ClientLogSequences : \" + ex.Message);\r\n//           this._failed = true;\r\n//           this._clientLogOs = null;\r\n//           this._contextId = -1;\r\n//           this._fileName = null;\r\n//         }\r\n//         else\r\n//           throw ex;\r\n//       }\r\n//     }\r\n//     return !this._failed;\r\n//   }\r\n//\r\n//   private BuildFileName(): string {\r\n//     return \"\";\r\n//   }\r\n// }\r\n"]}