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

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

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

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

@@ -0,0 +1,132 @@
+import { Logger, XMLConstants, XmlParser } from "@magic-xpa/utils";
+import { ApplicationException, Debug } from "@magic-xpa/mscorelib";
+import { OpenURLCommand } from "./OpenURLCommand";
+import { ClientTargetedCommandType } from "../../enums";
+import { AbortCommand } from "./AbortCommand";
+import { ClientRefreshCommand } from "./ClientRefreshCommand";
+import { EnhancedVerifyCommand } from "./EnhancedVerifyCommand";
+import { ResetRangeCommand } from "./ResetRangeCommand";
+import { AddLocateCommand } from "./AddLocateCommand";
+import { ResetLocateCommand } from "./ResetLocateCommand";
+import { AddRangeCommand } from "./AddRangeCommand";
+import { ResultCommand } from "./ResultCommand";
+import { AddSortCommand } from "./AddSortCommand";
+import { ResetSortCommand } from "./ResetSortCommand";
+import { VerifyCommand } from "./VerifyCommand";
+import { ConstInterface } from "../../ConstInterface";
+export class XMLBasedCommandBuilder {
+    newTaskXML = null;
+    constructor() {
+    }
+    fillData(parser) {
+        let endContext = parser.getXMLdata().indexOf(XMLConstants.TAG_TERM, parser.getCurrIndex());
+        if (endContext !== -1 && endContext < parser.getXMLdata().length) {
+            let tag = parser.getXMLsubstring(endContext);
+            parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_COMMAND) + ConstInterface.MG_TAG_COMMAND.length);
+            let tokensVector = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);
+            let command = this.initElements(tokensVector);
+            parser.setCurrIndex(endContext + XMLConstants.TAG_TERM.length);
+            let openUrlCommand = command instanceof OpenURLCommand ? command : null;
+            if (openUrlCommand != null) {
+                this.getTaskXML(parser);
+                openUrlCommand.NewTaskXML = this.newTaskXML;
+            }
+            return command;
+        }
+        Logger.Instance.WriteDevToLog("in Command.FillData() out of string bounds");
+        return null;
+    }
+    initElements(tokensVector) {
+        Debug.Assert(tokensVector.get_Item(0) === XMLConstants.MG_ATTR_TYPE, "The first attribute of a <command> element must be the command type.");
+        let commandType = this.getType(tokensVector.get_Item(1).toLowerCase());
+        let clientTargetedCommand = this.CreateCommand(commandType);
+        for (let i = 2; i < tokensVector.length; i = i + 2) {
+            let attribute = tokensVector.get_Item(i);
+            let value = tokensVector.get_Item(i + 1);
+            clientTargetedCommand.HandleAttribute(attribute, value);
+        }
+        return clientTargetedCommand;
+    }
+    CreateCommand(commandType) {
+        switch (commandType) {
+            case ClientTargetedCommandType.Abort:
+                return new AbortCommand();
+            case ClientTargetedCommandType.Verify:
+                return new VerifyCommand();
+            case ClientTargetedCommandType.EnhancedVerify:
+                return new EnhancedVerifyCommand();
+            case ClientTargetedCommandType.OpenURL:
+                return new OpenURLCommand();
+            case ClientTargetedCommandType.Result:
+                return new ResultCommand();
+            case ClientTargetedCommandType.AddRange:
+                return new AddRangeCommand();
+            case ClientTargetedCommandType.AddLocate:
+                return new AddLocateCommand();
+            case ClientTargetedCommandType.AddSort:
+                return new AddSortCommand();
+            case ClientTargetedCommandType.ResetRange:
+                return new ResetRangeCommand();
+            case ClientTargetedCommandType.ResetLocate:
+                return new ResetLocateCommand();
+            case ClientTargetedCommandType.ResetSort:
+                return new ResetSortCommand();
+            case ClientTargetedCommandType.ClientRefresh:
+                return new ClientRefreshCommand();
+            default:
+                throw new ApplicationException("Unknown client targeted command type " + commandType);
+        }
+    }
+    getTaskXML(parser) {
+        if (parser.getNextTag() !== ConstInterface.MG_TAG_TASK_XML)
+            throw new ApplicationException("Task's XML is missing");
+        this.newTaskXML = parser.ReadContentOfCurrentElement();
+    }
+    getType(valueAttr) {
+        let type;
+        switch (valueAttr) {
+            case ConstInterface.MG_ATTR_VAL_ABORT:
+                type = ClientTargetedCommandType.Abort;
+                break;
+            case ConstInterface.MG_ATTR_VAL_VERIFY:
+                type = ClientTargetedCommandType.Verify;
+                break;
+            case ConstInterface.MG_ATTR_VAL_ENHANCED_VERIFY:
+                type = ClientTargetedCommandType.EnhancedVerify;
+                break;
+            case ConstInterface.MG_ATTR_VAL_RESULT:
+                type = ClientTargetedCommandType.Result;
+                break;
+            case ConstInterface.MG_ATTR_VAL_OPENURL:
+                type = ClientTargetedCommandType.OpenURL;
+                break;
+            case ConstInterface.MG_ATTR_VAL_ADD_RANGE:
+                type = ClientTargetedCommandType.AddRange;
+                break;
+            case ConstInterface.MG_ATTR_VAL_ADD_LOCATE:
+                type = ClientTargetedCommandType.AddLocate;
+                break;
+            case ConstInterface.MG_ATTR_VAL_ADD_SORT:
+                type = ClientTargetedCommandType.AddSort;
+                break;
+            case ConstInterface.MG_ATTR_VAL_RESET_RANGE:
+                type = ClientTargetedCommandType.ResetRange;
+                break;
+            case ConstInterface.MG_ATTR_VAL_RESET_LOCATE:
+                type = ClientTargetedCommandType.ResetLocate;
+                break;
+            case ConstInterface.MG_ATTR_VAL_RESET_SORT:
+                type = ClientTargetedCommandType.ResetSort;
+                break;
+            case ConstInterface.MG_ATTR_VAL_CLIENT_REFRESH:
+                type = ClientTargetedCommandType.ClientRefresh;
+                break;
+            default:
+                type = valueAttr[0];
+                Logger.Instance.WriteExceptionToLogWithMsg("Command.getType there is no such SERVER to CLIENT command : " + valueAttr);
+                break;
+        }
+        return type;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"XMLBasedCommandBuilder.js","sourceRoot":"","sources":["../../../../../../../projects/engine/src/commands/ServerToClient/XMLBasedCommandBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import {IClientCommand} from \"../IClientCommand\";\r\nimport {Logger, XMLConstants, XmlParser} from \"@magic-xpa/utils\";\r\nimport {ApplicationException, Debug, List} from \"@magic-xpa/mscorelib\";\r\nimport {IClientTargetedCommand} from \"../IClientTargetedCommand\";\r\nimport {OpenURLCommand} from \"./OpenURLCommand\";\r\nimport {ClientTargetedCommandType} from \"../../enums\";\r\nimport {AbortCommand} from \"./AbortCommand\";\r\nimport {ClientRefreshCommand} from \"./ClientRefreshCommand\";\r\nimport {EnhancedVerifyCommand} from \"./EnhancedVerifyCommand\";\r\nimport {ResetRangeCommand} from \"./ResetRangeCommand\";\r\nimport {AddLocateCommand} from \"./AddLocateCommand\";\r\nimport {ResetLocateCommand} from \"./ResetLocateCommand\";\r\nimport {AddRangeCommand} from \"./AddRangeCommand\";\r\nimport {ResultCommand} from \"./ResultCommand\";\r\nimport {AddSortCommand} from \"./AddSortCommand\";\r\nimport {ResetSortCommand} from \"./ResetSortCommand\";\r\nimport {VerifyCommand} from \"./VerifyCommand\";\r\nimport {ConstInterface} from \"../../ConstInterface\";\r\n\r\nexport class XMLBasedCommandBuilder {\r\n  private newTaskXML: string = null;\r\n\r\n  constructor() {\r\n  }\r\n  /// <summary>\r\n  ///   Need part input String to relevant for the class data\r\n  /// </summary>\r\n  public fillData(parser: XmlParser): IClientCommand {\r\n    let endContext: number = parser.getXMLdata().indexOf(XMLConstants.TAG_TERM, parser.getCurrIndex());\r\n\r\n    if (endContext !== -1 && endContext < parser.getXMLdata().length) {\r\n      // last position of its tag\r\n      let tag: String = parser.getXMLsubstring(endContext);\r\n      parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_COMMAND) + ConstInterface.MG_TAG_COMMAND.length);\r\n\r\n      let tokensVector: List<string> = XmlParser.getTokens(parser.getXMLsubstring(endContext),\r\n                                                           XMLConstants.XML_ATTR_DELIM);\r\n      let command: IClientTargetedCommand = this.initElements(tokensVector);\r\n      parser.setCurrIndex(endContext + XMLConstants.TAG_TERM.length); // to delete \">\" too\r\n\r\n      let openUrlCommand = command instanceof OpenURLCommand ? <OpenURLCommand> command : null;\r\n      if (openUrlCommand != null) {\r\n        this.getTaskXML(parser);\r\n        openUrlCommand.NewTaskXML = this.newTaskXML;\r\n      }\r\n      return command;\r\n    }\r\n    Logger.Instance.WriteDevToLog(\"in Command.FillData() out of string bounds\");\r\n    return null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parse elements\r\n  /// </summary>\r\n  /// <param name = \"tokensVector\">the tokens vector</param>\r\n  private initElements(tokensVector: List<string>): IClientTargetedCommand {\r\n    Debug.Assert(tokensVector.get_Item(0) === XMLConstants.MG_ATTR_TYPE, \"The first attribute of a <command> element must be the command type.\");\r\n\r\n    let commandType: ClientTargetedCommandType = this.getType(tokensVector.get_Item(1).toLowerCase());\r\n    let clientTargetedCommand: IClientTargetedCommand = this.CreateCommand(commandType);\r\n\r\n    for (let i: number = 2; i < tokensVector.length; i = i + 2) {\r\n      let attribute: string = tokensVector.get_Item(i);\r\n      let value: string = tokensVector.get_Item(i + 1);\r\n      clientTargetedCommand.HandleAttribute(attribute, value);\r\n    }\r\n    return clientTargetedCommand;\r\n  }\r\n\r\n  private CreateCommand(commandType: ClientTargetedCommandType): IClientTargetedCommand {\r\n    switch (commandType) {\r\n      case ClientTargetedCommandType.Abort:\r\n        return new AbortCommand();\r\n\r\n      case ClientTargetedCommandType.Verify:\r\n        return new VerifyCommand();\r\n\r\n      case ClientTargetedCommandType.EnhancedVerify:\r\n        return new EnhancedVerifyCommand();\r\n\r\n      case ClientTargetedCommandType.OpenURL:\r\n        return new OpenURLCommand();\r\n\r\n      case ClientTargetedCommandType.Result:\r\n        return new ResultCommand();\r\n\r\n      case ClientTargetedCommandType.AddRange:\r\n        return new AddRangeCommand();\r\n\r\n      case ClientTargetedCommandType.AddLocate:\r\n        return new AddLocateCommand();\r\n\r\n      case ClientTargetedCommandType.AddSort:\r\n        return new AddSortCommand();\r\n\r\n      case ClientTargetedCommandType.ResetRange:\r\n        return new ResetRangeCommand();\r\n\r\n      case ClientTargetedCommandType.ResetLocate:\r\n        return new ResetLocateCommand();\r\n\r\n      case ClientTargetedCommandType.ResetSort:\r\n        return new ResetSortCommand();\r\n\r\n      case ClientTargetedCommandType.ClientRefresh:\r\n        return new ClientRefreshCommand();\r\n\r\n      default:\r\n        throw new ApplicationException(\"Unknown client targeted command type \" + commandType);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Get XML for if new task\r\n  /// </summary>\r\n  /// <param name = \"foundTagName\">XML tag</param>\r\n  private getTaskXML(parser: XmlParser): void {\r\n    if (parser.getNextTag() !== ConstInterface.MG_TAG_TASK_XML)\r\n      throw new ApplicationException(\"Task's XML is missing\");\r\n    this.newTaskXML = parser.ReadContentOfCurrentElement();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get type of command by value of 'type' attribute\r\n  ///   ONLY Server to Client commands\r\n  /// </summary>\r\n  private getType(valueAttr: String): ClientTargetedCommandType {\r\n    let type: ClientTargetedCommandType;\r\n\r\n    switch (valueAttr) {\r\n      case ConstInterface.MG_ATTR_VAL_ABORT:\r\n        type = ClientTargetedCommandType.Abort;\r\n        break;\r\n\r\n      case ConstInterface.MG_ATTR_VAL_VERIFY:\r\n        type = ClientTargetedCommandType.Verify;\r\n        break;\r\n\r\n      case ConstInterface.MG_ATTR_VAL_ENHANCED_VERIFY:\r\n        type = ClientTargetedCommandType.EnhancedVerify;\r\n        break;\r\n\r\n      case ConstInterface.MG_ATTR_VAL_RESULT:\r\n        type = ClientTargetedCommandType.Result;\r\n        break;\r\n\r\n      case ConstInterface.MG_ATTR_VAL_OPENURL:\r\n        type = ClientTargetedCommandType.OpenURL;\r\n        break;\r\n\r\n      case ConstInterface.MG_ATTR_VAL_ADD_RANGE:\r\n        type = ClientTargetedCommandType.AddRange;\r\n        break;\r\n\r\n      case ConstInterface.MG_ATTR_VAL_ADD_LOCATE:\r\n        type = ClientTargetedCommandType.AddLocate;\r\n        break;\r\n\r\n      case ConstInterface.MG_ATTR_VAL_ADD_SORT:\r\n        type = ClientTargetedCommandType.AddSort;\r\n        break;\r\n\r\n      case ConstInterface.MG_ATTR_VAL_RESET_RANGE:\r\n        type = ClientTargetedCommandType.ResetRange;\r\n        break;\r\n\r\n      case ConstInterface.MG_ATTR_VAL_RESET_LOCATE:\r\n        type = ClientTargetedCommandType.ResetLocate;\r\n        break;\r\n\r\n      case ConstInterface.MG_ATTR_VAL_RESET_SORT:\r\n        type = ClientTargetedCommandType.ResetSort;\r\n        break;\r\n\r\n      case ConstInterface.MG_ATTR_VAL_CLIENT_REFRESH:\r\n        type = ClientTargetedCommandType.ClientRefresh;\r\n        break;\r\n\r\n      default:\r\n        type = <ClientTargetedCommandType>valueAttr[0];\r\n        Logger.Instance.WriteExceptionToLogWithMsg(\"Command.getType there is no such SERVER to CLIENT command : \" + valueAttr);\r\n        break;\r\n    }\r\n    return type;\r\n  }\r\n}\r\n"]}

package/{esm2020 → esm2022}/src/communications/IConnectionStateManager.mjs

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSUNvbm5lY3Rpb25TdGF0ZU1hbmFnZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9lbmdpbmUvc3JjL2NvbW11bmljYXRpb25zL0lDb25uZWN0aW9uU3RhdGVNYW5hZ2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvLy8gPHN1bW1hcnk+XHJcbi8vLyBJbnRlcmZhY2Ugb2YgYSBjbGFzcyB0aGF0IGhhcyBrbm93bGVkZ2Ugb2YgdGhlIGN1cnJlbnRcclxuLy8vIGNvbm5lY3Rpb24gc3RhdGUuPGJyLz5cclxuLy8vIFRoZSBzcGVjaWZpY3Mgb2YgZGV0ZWN0aW5nIGRpc2Nvbm5lY3Rpb24gaXMgbGVmdCB0byB0aGUgaW1wbGVtZW50aW5nXHJcbi8vLyBjbGFzcy5cclxuLy8vIDwvc3VtbWFyeT5cclxuZXhwb3J0IGludGVyZmFjZSBJQ29ubmVjdGlvblN0YXRlTWFuYWdlciB7XHJcbiAgQ29ubmVjdGlvbkVzdGFibGlzaGVkKCk6IHZvaWQ7XHJcblxyXG4gIENvbm5lY3Rpb25Ecm9wcGVkKCk6IHZvaWQ7XHJcbn1cclxuIl19

package/esm2022/src/communications/InteractiveCommunicationsFailureHandler.mjs

@@ -0,0 +1,15 @@
+import { OSEnvironment } from "@magic-xpa/utils";
+import { Styles } from "@magic-xpa/gui";
+import { GUIManager } from "../GUIManager";
+export class InteractiveCommunicationsFailureHandler {
+    ShouldRetryLastRequest = false;
+    get ShowCommunicationErrors() {
+        return true;
+    }
+    async CommunicationFailed(url, ex) {
+        let exceptionCaption = "";
+        let exceptionMessage = url.split('?')[0] + OSEnvironment.EolSeq + OSEnvironment.EolSeq + ex.message + OSEnvironment.EolSeq + OSEnvironment.EolSeq;
+        this.ShouldRetryLastRequest = (await GUIManager.Instance.MessageBox(exceptionCaption, exceptionMessage + "Do you wish to retry connecting?", Styles.MSGBOX_BUTTON_YES_NO) === Styles.MSGBOX_RESULT_YES);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/src/data/DataSourceIdKey.mjs

@@ -1,3 +1,3 @@
-export class DataSourceIdKey {
-}
+export class DataSourceIdKey {
+}
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGF0YVNvdXJjZUlkS2V5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZW5naW5lL3NyYy9kYXRhL0RhdGFTb3VyY2VJZEtleS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sZUFBZTtDQUUzQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBEYXRhU291cmNlSWRLZXkge1xyXG5cclxufVxyXG4iXX0=