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

package/{esm2020 → esm2022}/src/CommandsProcessorManager.mjs

@@ -1,26 +1,26 @@
-import { Logger, StrUtil } from "@magic-xpa/utils";
-import { RemoteCommandsProcessor } from "./remote/RemoteCommandsProcessor";
-import { HttpManager } from "./http/HttpManager";
-import { InteractiveCommunicationsFailureHandler } from "./communications/InteractiveCommunicationsFailureHandler";
-export class CommandsProcessorManager {
-    static GetCommandsProcessor() {
-        return RemoteCommandsProcessor.GetInstance();
-    }
-    static async GetContent(requestedURL, useCache) {
-        let ret = await (CommandsProcessorManager.GetCommandsProcessor().GetContent(requestedURL, useCache));
-        return ret;
-    }
-    static async StartSession() {
-        let succeeded = false;
-        try {
-            HttpManager.GetInstance().SetCommunicationsFailureHandler(new InteractiveCommunicationsFailureHandler());
-            succeeded = await RemoteCommandsProcessor.GetInstance().StartSession();
-        }
-        catch (ex) {
-            Logger.Instance.WriteServerToLog("Failed connecting to the server: " + StrUtil.getConsoleErorString(ex.Message));
-            throw ex;
-        }
-        return succeeded;
-    }
-}
+import { Logger, StrUtil } from "@magic-xpa/utils";
+import { RemoteCommandsProcessor } from "./remote/RemoteCommandsProcessor";
+import { HttpManager } from "./http/HttpManager";
+import { InteractiveCommunicationsFailureHandler } from "./communications/InteractiveCommunicationsFailureHandler";
+export class CommandsProcessorManager {
+    static GetCommandsProcessor() {
+        return RemoteCommandsProcessor.GetInstance();
+    }
+    static async GetContent(requestedURL, useCache) {
+        let ret = await (CommandsProcessorManager.GetCommandsProcessor().GetContent(requestedURL, useCache));
+        return ret;
+    }
+    static async StartSession() {
+        let succeeded = false;
+        try {
+            HttpManager.GetInstance().SetCommunicationsFailureHandler(new InteractiveCommunicationsFailureHandler());
+            succeeded = await RemoteCommandsProcessor.GetInstance().StartSession();
+        }
+        catch (ex) {
+            Logger.Instance.WriteServerToLog("Failed connecting to the server: " + StrUtil.getConsoleErorString(ex.Message));
+            throw ex;
+        }
+        return succeeded;
+    }
+}
 //# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/CommandsTable.mjs

@@ -0,0 +1,162 @@
+import { IClientTargetedCommand } from './commands/IClientTargetedCommand';
+import { XMLBasedCommandBuilder } from './commands/ServerToClient/XMLBasedCommandBuilder';
+import { ResultCommand } from './commands/ServerToClient/ResultCommand';
+import { AbortCommand } from './commands/ServerToClient/AbortCommand';
+import { List } from '@magic-xpa/mscorelib';
+import { VerifyCommand } from './commands/ServerToClient/VerifyCommand';
+import { ConstInterface } from './ConstInterface';
+import { ClientOriginatedCommandSerializer } from './commands/ClientToServer/ClientOriginatedCommandSerializer';
+import { GlobalCommandsManager } from './GlobalCommandsManager';
+import { AccessHelper } from './AccessHelper';
+export class CommandsTable {
+    _cmds = null;
+    _iterationIdx = 0;
+    constructor() {
+        this._cmds = new List();
+    }
+    static createCommandsTable() {
+        return new CommandsTable();
+    }
+    fillData(parser) {
+        while (this.initInnerObjects(parser.getNextTag(), parser)) {
+        }
+    }
+    initInnerObjects(foundTagName, parser) {
+        if (foundTagName == null)
+            return false;
+        if (foundTagName === ConstInterface.MG_TAG_COMMAND) {
+            let cmd = new XMLBasedCommandBuilder().fillData(parser);
+            this._cmds.push(cmd);
+        }
+        else
+            return false;
+        return true;
+    }
+    async Execute(res) {
+        let currFrame = GlobalCommandsManager.Instance.getCmdFrame();
+        GlobalCommandsManager.Instance.add1toCmdFrame();
+        let firstBlocking = -1;
+        let i, j;
+        let cmd;
+        for (i = 0; i < this.getSize(); i = i + 1) {
+            cmd = this.getCmd(i);
+            if (cmd.IsBlocking && firstBlocking === -1)
+                firstBlocking = i;
+            else if (cmd instanceof ResultCommand && firstBlocking !== -1) {
+                this._cmds.Insert(firstBlocking, cmd);
+                this._cmds.RemoveAt(i + 1);
+            }
+        }
+        for (i = 0; i < this.getSize(); i = i + 1) {
+            cmd = this.getCmd(i);
+            cmd.Frame = currFrame;
+            if (cmd.IsBlocking) {
+                for (j = i + 1; j < this.getSize(); j = j + 1)
+                    GlobalCommandsManager.Instance.addUnframedCmd(this.getCmd(j));
+                this._cmds.SetSize(i + 1);
+                break;
+            }
+        }
+        while (this.getSize() > 0) {
+            const tmpCmd = this.extractCmd(currFrame);
+            if (tmpCmd instanceof IClientTargetedCommand)
+                cmd = tmpCmd;
+            if (cmd != null) {
+                if (cmd.ShouldExecute) {
+                    await cmd.Execute(res);
+                }
+                else {
+                    GlobalCommandsManager.Instance.addCommandsExecutedAfterTaskStarted(cmd);
+                }
+            }
+            else
+                break;
+        }
+    }
+    extractCmd(frame) {
+        let size = this.getSize();
+        let cmd = null;
+        let verifyCmd = null;
+        let verifyIndex;
+        let verifyTask = null;
+        let abortTask = null;
+        let startIterationIdx;
+        let tid;
+        if (size === 0)
+            return null;
+        if (this._iterationIdx >= size)
+            this._iterationIdx = 0;
+        startIterationIdx = this._iterationIdx;
+        for (; this._iterationIdx < size; this._iterationIdx++) {
+            cmd = ((this.getCmd(this._iterationIdx) instanceof AbortCommand) ? this.getCmd(this._iterationIdx) : null);
+            if (cmd != null && !cmd.TaskTag.startsWith('-') && cmd.Frame === frame) {
+                for (verifyIndex = 0; verifyIndex < this._iterationIdx; verifyIndex++) {
+                    verifyCmd = ((this.getCmd(verifyIndex) instanceof VerifyCommand) ? this.getCmd(verifyIndex) : null);
+                    if (verifyCmd != null && verifyCmd.Frame === frame) {
+                        verifyTask = AccessHelper.mgDataTable.GetTaskByID(verifyCmd.TaskTag);
+                        abortTask = AccessHelper.mgDataTable.GetTaskByID(cmd.TaskTag);
+                        if (verifyTask != null && verifyTask.isDescendentOf(abortTask)) {
+                            this._cmds.RemoveAt(verifyIndex);
+                            this._iterationIdx--;
+                            return verifyCmd;
+                        }
+                    }
+                }
+                this._cmds.RemoveAt(this._iterationIdx);
+                size = this.getSize();
+                for (startIterationIdx = 0; startIterationIdx < size; startIterationIdx++) {
+                    tid = this.getCmd(startIterationIdx).TaskTag;
+                    if (tid != null && tid.substr(1) === cmd.TaskTag) {
+                        this._cmds.RemoveAt(startIterationIdx);
+                        break;
+                    }
+                }
+                return cmd;
+            }
+        }
+        for (verifyIndex = 0; verifyIndex < size; verifyIndex++) {
+            verifyCmd = ((this.getCmd(verifyIndex) instanceof VerifyCommand) ? this.getCmd(verifyIndex) : null);
+            if (verifyCmd != null && verifyCmd.Frame === frame &&
+                AccessHelper.mgDataTable.GetTaskByID(verifyCmd.TaskTag) != null) {
+                this._cmds.RemoveAt(verifyIndex);
+                return verifyCmd;
+            }
+        }
+        for (this._iterationIdx = 0; this._iterationIdx < size; this._iterationIdx++) {
+            cmd = this.getCmd(this._iterationIdx);
+            if (cmd.Frame === frame) {
+                this._cmds.RemoveAt(this._iterationIdx);
+                return cmd;
+            }
+        }
+        return null;
+    }
+    getCmd(idx) {
+        return this._cmds.get_Item(idx);
+    }
+    buildXML(message) {
+        for (let i = 0; i < this._cmds.length; i = i + 1) {
+            let cmd = this._cmds.get_Item(i);
+            message.Append(ClientOriginatedCommandSerializer.Serialize(cmd, AccessHelper.mgDataTable.getCurrMGData()));
+        }
+        this.clear();
+    }
+    Add(cmd) {
+        this._cmds.push(cmd);
+    }
+    Clear() {
+        this._cmds.Clear();
+    }
+    ExtractCommand(commandIndex) {
+        let command = this.getCmd(commandIndex);
+        this._cmds.RemoveAt(commandIndex);
+        return command;
+    }
+    clear() {
+        this._cmds.Clear();
+    }
+    getSize() {
+        return this._cmds.length;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CommandsTable.js","sourceRoot":"","sources":["../../../../../projects/engine/src/CommandsTable.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,sBAAsB,EAAC,MAAM,mCAAmC,CAAC;AACzE,OAAO,EAAC,sBAAsB,EAAC,MAAM,kDAAkD,CAAC;AAExF,OAAO,EAAC,aAAa,EAAC,MAAM,yCAAyC,CAAC;AAEtE,OAAO,EAAC,YAAY,EAAC,MAAM,wCAAwC,CAAC;AACpE,OAAO,EAAgB,IAAI,EAAC,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAC,aAAa,EAAC,MAAM,yCAAyC,CAAC;AAEtE,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAC;AAEhD,OAAO,EAAC,iCAAiC,EAAC,MAAM,6DAA6D,CAAC;AAE9G,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,MAAM,OAAO,aAAa;IAChB,KAAK,GAAyB,IAAI,CAAC;IACnC,aAAa,GAAW,CAAC,CAAC;IAElC;QACE,IAAI,CAAC,KAAK,GAAG,IAAI,IAAI,EAAE,CAAC;IAC1B,CAAC;IAED,MAAM,CAAC,mBAAmB;QACxB,OAAO,IAAI,aAAa,EAAE,CAAC;IAC7B,CAAC;IAMD,QAAQ,CAAC,MAAiB;QACxB,OAAO,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,UAAU,EAAE,EAAE,MAAM,CAAC,EAAE;SAC1D;IACH,CAAC;IAMO,gBAAgB,CAAC,YAAoB,EAAE,MAAiB;QAC9D,IAAI,YAAY,IAAI,IAAI;YACtB,OAAO,KAAK,CAAC;QAEf,IAAI,YAAY,KAAK,cAAc,CAAC,cAAc,EAAE;YAClD,IAAI,GAAG,GAA2B,IAAI,sBAAsB,EAAE,CAAC,QAAQ,CAAC,MAAM,CAA2B,CAAC;YAC1G,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;SACtB;;YAEC,OAAO,KAAK,CAAC;QACf,OAAO,IAAI,CAAC;IACd,CAAC;IAMD,KAAK,CAAC,OAAO,CAAC,GAAiB;QAC7B,IAAI,SAAS,GAAW,qBAAqB,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;QACrE,qBAAqB,CAAC,QAAQ,CAAC,cAAc,EAAE,CAAC;QAChD,IAAI,aAAa,GAAW,CAAC,CAAC,CAAC;QAC/B,IAAI,CAAS,EAAE,CAAS,CAAC;QACzB,IAAI,GAA2B,CAAC;QAQhC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;YAEzC,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAA2B,CAAC;YAC/C,IAAI,GAAG,CAAC,UAAU,IAAI,aAAa,KAAK,CAAC,CAAC;gBACxC,aAAa,GAAG,CAAC,CAAC;iBACf,IAAI,GAAG,YAAY,aAAa,IAAI,aAAa,KAAK,CAAC,CAAC,EAAE;gBAC7D,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,aAAa,EAAE,GAAG,CAAC,CAAC;gBACtC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;aAC5B;SACF;QAED,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;YAEzC,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAA2B,CAAC;YAC/C,GAAG,CAAC,KAAK,GAAG,SAAS,CAAC;YAItB,IAAI,GAAG,CAAC,UAAU,EAAE;gBAClB,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC;oBAC3C,qBAAqB,CAAC,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;gBAEhE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;gBAC1B,MAAM;aACP;SACF;QAED,OAAO,IAAI,CAAC,OAAO,EAAE,GAAG,CAAC,EAAE;YAEzB,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;YAC1C,IAAI,MAAM,YAAY,sBAAsB;gBAC1C,GAAG,GAAG,MAAM,CAAC;YAEf,IAAI,GAAG,IAAI,IAAI,EAAE;gBACf,IAAI,GAAG,CAAC,aAAa,EAAE;oBACrB,MAAM,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;iBACxB;qBACI;oBACH,qBAAqB,CAAC,QAAQ,CAAC,mCAAmC,CAAC,GAAG,CAAC,CAAC;iBACzE;aACF;;gBAEC,MAAM;SACT;IACH,CAAC;IAOO,UAAU,CAAC,KAAa;QAC9B,IAAI,IAAI,GAAW,IAAI,CAAC,OAAO,EAAE,CAAC;QAClC,IAAI,GAAG,GAA2B,IAAI,CAAC;QACvC,IAAI,SAAS,GAA2B,IAAI,CAAC;QAC7C,IAAI,WAAmB,CAAC;QACxB,IAAI,UAAU,GAAS,IAAI,CAAC;QAC5B,IAAI,SAAS,GAAS,IAAI,CAAC;QAC3B,IAAI,iBAAyB,CAAC;QAC9B,IAAI,GAAW,CAAC;QAEhB,IAAI,IAAI,KAAK,CAAC;YACZ,OAAO,IAAI,CAAC;QAEd,IAAI,IAAI,CAAC,aAAa,IAAI,IAAI;YAC5B,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC;QAEzB,iBAAiB,GAAG,IAAI,CAAC,aAAa,CAAC;QAGvC,OAAO,IAAI,CAAC,aAAa,GAAG,IAAI,EAAE,IAAI,CAAC,aAAa,EAAE,EAAE;YACtD,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,YAAY,YAAY,CAAC,CAAC,CAAC,CAAe,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YACzH,IAAI,GAAG,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,KAAK,KAAK,KAAK,EAAE;gBAEtE,KAAK,WAAW,GAAG,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC,aAAa,EAAE,WAAW,EAAE,EAAE;oBACrE,SAAS,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,YAAY,aAAa,CAAC,CAAC,CAAC,CAAgB,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;oBACnH,IAAI,SAAS,IAAI,IAAI,IAAI,SAAS,CAAC,KAAK,KAAK,KAAK,EAAE;wBAClD,UAAU,GAAS,YAAY,CAAC,WAAW,CAAC,WAAW,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;wBAC3E,SAAS,GAAS,YAAY,CAAC,WAAW,CAAC,WAAW,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;wBAGpE,IAAI,UAAU,IAAI,IAAI,IAAI,UAAU,CAAC,cAAc,CAAC,SAAS,CAAC,EAAE;4BAC9D,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;4BACjC,IAAI,CAAC,aAAa,EAAE,CAAC;4BACrB,OAAO,SAAS,CAAC;yBAClB;qBACF;iBACF;gBACD,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;gBAIxC,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;gBACtB,KAAK,iBAAiB,GAAG,CAAC,EAAE,iBAAiB,GAAG,IAAI,EAAE,iBAAiB,EAAE,EAAE;oBACzE,GAAG,GAA4B,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAE,CAAC,OAAO,CAAC;oBACvE,IAAI,GAAG,IAAI,IAAI,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC,OAAO,EAAE;wBAChD,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAC;wBACvC,MAAM;qBACP;iBACF;gBAED,OAAO,GAAG,CAAC;aACZ;SACF;QAID,KAAK,WAAW,GAAG,CAAC,EAAE,WAAW,GAAG,IAAI,EAAE,WAAW,EAAE,EAAE;YACvD,SAAS,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,YAAY,aAAa,CAAC,CAAC,CAAC,CAAgB,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YACnH,IAAI,SAAS,IAAI,IAAI,IAAI,SAAS,CAAC,KAAK,KAAK,KAAK;gBAChD,YAAY,CAAC,WAAW,CAAC,WAAW,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,IAAI,EAAE;gBACjE,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;gBACjC,OAAO,SAAS,CAAC;aAClB;SACF;QAID,KAAK,IAAI,CAAC,aAAa,GAAG,CAAC,EAAE,IAAI,CAAC,aAAa,GAAG,IAAI,EAAE,IAAI,CAAC,aAAa,EAAE,EAAE;YAC5E,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAA2B,CAAC;YAChE,IAAI,GAAG,CAAC,KAAK,KAAK,KAAK,EAAE;gBACvB,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;gBACxC,OAAO,GAAG,CAAC;aACZ;SACF;QACD,OAAO,IAAI,CAAC;IAEd,CAAC;IAMD,MAAM,CAAC,GAAW;QAChB,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;IAClC,CAAC;IAKD,QAAQ,CAAC,OAAsB;QAC7B,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;YACxD,IAAI,GAAG,GAAqD,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;YACnF,OAAO,CAAC,MAAM,CAAC,iCAAiC,CAAC,SAAS,CAAC,GAAG,EAAE,YAAY,CAAC,WAAW,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;SAC5G;QAED,IAAI,CAAC,KAAK,EAAE,CAAC;IACf,CAAC;IAMD,GAAG,CAAC,GAAmB;QACrB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACvB,CAAC;IAKD,KAAK;QACH,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;IACrB,CAAC;IAOD,cAAc,CAAC,YAAoB;QACjC,IAAI,OAAO,GAAmB,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QACxD,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;QAClC,OAAO,OAAO,CAAC;IACjB,CAAC;IAKD,KAAK;QACH,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;IACrB,CAAC;IAKD,OAAO;QACL,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC;IAC3B,CAAC;CACF","sourcesContent":["import { XmlParser } from '@magic-xpa/utils';\r\nimport {IClientTargetedCommand} from './commands/IClientTargetedCommand';\r\nimport {XMLBasedCommandBuilder} from './commands/ServerToClient/XMLBasedCommandBuilder';\r\nimport {IResultValue} from './rt/IResultValue';\r\nimport {ResultCommand} from './commands/ServerToClient/ResultCommand';\r\nimport {IClientCommand} from './commands/IClientCommand';\r\nimport {AbortCommand} from './commands/ServerToClient/AbortCommand';\r\nimport {StringBuilder, List} from '@magic-xpa/mscorelib';\r\nimport {VerifyCommand} from './commands/ServerToClient/VerifyCommand';\r\nimport {ClientOriginatedCommand} from './commands/ClientToServer/ClientOriginatedCommand';\r\nimport {ConstInterface} from './ConstInterface';\r\nimport {Task} from './tasks/Task';\r\nimport {ClientOriginatedCommandSerializer} from './commands/ClientToServer/ClientOriginatedCommandSerializer';\r\nimport { ICommandsTable } from './ICommandsTable';\r\nimport { GlobalCommandsManager } from './GlobalCommandsManager';\r\nimport { AccessHelper } from './AccessHelper';\r\n\r\nexport class CommandsTable implements ICommandsTable{\r\n  private _cmds: List<IClientCommand> = null;\r\n  private _iterationIdx: number = 0;\r\n\r\n  constructor() {\r\n    this._cmds = new List();\r\n  }\r\n\r\n  static createCommandsTable():ICommandsTable {\r\n    return new CommandsTable();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   To parse input string and fill  _cmds\r\n  /// </summary>\r\n  /// <returns> index of end last  <command ...> tag</returns>\r\n  fillData(parser: XmlParser): void {\r\n    while (this.initInnerObjects(parser.getNextTag(), parser)) {\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   To allocate and fill inner objects of the class\r\n  /// </summary>\r\n  /// <param name = \"foundTagName\">  name of inner tag </param>\r\n  private initInnerObjects(foundTagName: string, parser: XmlParser): boolean {\r\n    if (foundTagName == null)\r\n      return false;\r\n\r\n    if (foundTagName === ConstInterface.MG_TAG_COMMAND) {\r\n      let cmd: IClientTargetedCommand = new XMLBasedCommandBuilder().fillData(parser) as IClientTargetedCommand;\r\n      this._cmds.push(cmd);\r\n    }\r\n    else\r\n      return false;\r\n    return true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Execute all commands in command table and delete them\r\n  /// </summary>\r\n  /// <param name=\"res\">result.</param>\r\n  async Execute(res: IResultValue): Promise<void> {\r\n    let currFrame: number = GlobalCommandsManager.Instance.getCmdFrame(); // cmdFrame++;  save a local value of the frame\r\n    GlobalCommandsManager.Instance.add1toCmdFrame();\r\n    let firstBlocking: number = -1;\r\n    let i: number, j: number;\r\n    let cmd: IClientTargetedCommand;\r\n\r\n    // frames are used here to make sure that when this method is called recursively\r\n    // the inner call will not execute commands that should be executed by some outer\r\n    // call to the method\r\n\r\n    // First step - move all result commands before any blocking commands (QCR #693428)\r\n    // it can't be that they belong to the blocking task.\r\n    for (i = 0; i < this.getSize(); i = i + 1) {\r\n\r\n      cmd = this.getCmd(i) as IClientTargetedCommand;\r\n      if (cmd.IsBlocking && firstBlocking === -1)\r\n        firstBlocking = i;\r\n      else if (cmd instanceof ResultCommand && firstBlocking !== -1) {\r\n        this._cmds.Insert(firstBlocking, cmd);\r\n        this._cmds.RemoveAt(i + 1);\r\n      }\r\n    }\r\n    // set the frame for commands which has no frame yet\r\n    for (i = 0; i < this.getSize(); i = i + 1) {\r\n\r\n      cmd = this.getCmd(i) as IClientTargetedCommand;\r\n      cmd.Frame = currFrame;\r\n\r\n      // If a command blocks the caller, following commands are moved to\r\n      // the next active MGdata, so they will be executed (QCR #438387)\r\n      if (cmd.IsBlocking) {\r\n        for (j = i + 1; j < this.getSize(); j = j + 1)\r\n          GlobalCommandsManager.Instance.addUnframedCmd(this.getCmd(j));\r\n\r\n        this._cmds.SetSize(i + 1);\r\n        break;\r\n      }\r\n    }\r\n\r\n    while (this.getSize() > 0) {\r\n      // TODO: Check 'as' for Interface in typescript\r\n      const tmpCmd = this.extractCmd(currFrame);\r\n      if (tmpCmd instanceof IClientTargetedCommand)\r\n        cmd = tmpCmd;\r\n\r\n      if (cmd != null) {\r\n        if (cmd.ShouldExecute) {\r\n          await cmd.Execute(res);\r\n        }\r\n        else {\r\n          GlobalCommandsManager.Instance.addCommandsExecutedAfterTaskStarted(cmd);\r\n        }\r\n      }\r\n      else\r\n        break;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the next command to execute or null if there is no such command\r\n  ///   the abort commands are returned first\r\n  /// </summary>\r\n  /// <param name = \"frame\">the frame from which to extract a command </param>\r\n  private extractCmd(frame: number): IClientCommand {\r\n    let size: number = this.getSize();\r\n    let cmd: IClientTargetedCommand = null;\r\n    let verifyCmd: IClientTargetedCommand = null;\r\n    let verifyIndex: number;\r\n    let verifyTask: Task = null;\r\n    let abortTask: Task = null;\r\n    let startIterationIdx: number;\r\n    let tid: string;\r\n\r\n    if (size === 0)\r\n      return null;\r\n\r\n    if (this._iterationIdx >= size)\r\n      this._iterationIdx = 0;\r\n\r\n    startIterationIdx = this._iterationIdx;\r\n\r\n    // try to find an ABORT command and return it\r\n    for (; this._iterationIdx < size; this._iterationIdx++) {\r\n      cmd = ((this.getCmd(this._iterationIdx) instanceof AbortCommand) ? <AbortCommand>this.getCmd(this._iterationIdx) : null);\r\n      if (cmd != null && !cmd.TaskTag.startsWith('-') && cmd.Frame === frame) {\r\n        // if an abort command was found, execute all previous verify commands of the task or its' sub-tasks\r\n        for (verifyIndex = 0; verifyIndex < this._iterationIdx; verifyIndex++) {\r\n          verifyCmd = ((this.getCmd(verifyIndex) instanceof VerifyCommand) ? <VerifyCommand>this.getCmd(verifyIndex) : null);\r\n          if (verifyCmd != null && verifyCmd.Frame === frame) {\r\n            verifyTask = <Task>AccessHelper.mgDataTable.GetTaskByID(verifyCmd.TaskTag);\r\n            abortTask = <Task>AccessHelper.mgDataTable.GetTaskByID(cmd.TaskTag);\r\n\r\n            // Sometimes the task which issued the verify is not known to the client (e.g. a batch task).\r\n            if (verifyTask != null && verifyTask.isDescendentOf(abortTask)) {\r\n              this._cmds.RemoveAt(verifyIndex);\r\n              this._iterationIdx--;\r\n              return verifyCmd;\r\n            }\r\n          }\r\n        }\r\n        this._cmds.RemoveAt(this._iterationIdx);\r\n\r\n        // for an abort CMD of task \"tid\", the server might send another abort CMD for task\r\n        // \"-tid\". We should combine them and get rid of the second CMD.\r\n        size = this.getSize();\r\n        for (startIterationIdx = 0; startIterationIdx < size; startIterationIdx++) {\r\n          tid = (<IClientTargetedCommand>this.getCmd(startIterationIdx)).TaskTag;\r\n          if (tid != null && tid.substr(1) === cmd.TaskTag) {\r\n            this._cmds.RemoveAt(startIterationIdx);\r\n            break;\r\n          }\r\n        }\r\n\r\n        return cmd;\r\n      }\r\n    }\r\n\r\n    // at this stage no ABORT command was found in the table\r\n\r\n    for (verifyIndex = 0; verifyIndex < size; verifyIndex++) {\r\n      verifyCmd = ((this.getCmd(verifyIndex) instanceof VerifyCommand) ? <VerifyCommand>this.getCmd(verifyIndex) : null);\r\n      if (verifyCmd != null && verifyCmd.Frame === frame &&\r\n        AccessHelper.mgDataTable.GetTaskByID(verifyCmd.TaskTag) != null) {\r\n        this._cmds.RemoveAt(verifyIndex);\r\n        return verifyCmd;\r\n      }\r\n    }\r\n\r\n    // at this stage no VERIFY command was found in the table\r\n\r\n    for (this._iterationIdx = 0; this._iterationIdx < size; this._iterationIdx++) {\r\n      cmd = this.getCmd(this._iterationIdx) as IClientTargetedCommand;\r\n      if (cmd.Frame === frame) {\r\n        this._cmds.RemoveAt(this._iterationIdx);\r\n        return cmd;\r\n      }\r\n    }\r\n    return null;\r\n\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the command by its index in the table\r\n  /// </summary>\r\n  /// <param name = \"idx\">the index of the requested command</param>\r\n  getCmd(idx: number): IClientCommand {\r\n    return this._cmds.get_Item(idx);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   build the XML structure of the commands and CLEAR the table\r\n  /// </summary>\r\n  buildXML(message: StringBuilder): void {\r\n    for (let i: number = 0; i < this._cmds.length; i = i + 1) {\r\n      let cmd: ClientOriginatedCommand = <ClientOriginatedCommand>this._cmds.get_Item(i);\r\n      message.Append(ClientOriginatedCommandSerializer.Serialize(cmd, AccessHelper.mgDataTable.getCurrMGData()));\r\n    }\r\n\r\n    this.clear();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   add a command to the table\r\n  /// </summary>\r\n  /// <param name = \"cmd\">a command to to add to the table</param>\r\n  Add(cmd: IClientCommand): void {\r\n    this._cmds.push(cmd);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Clear out the command table\r\n  /// </summary>\r\n  Clear(): void {\r\n    this._cmds.Clear();\r\n  }\r\n\r\n  /// <summary>\r\n  /// extract and remove a command from the table\r\n  /// </summary>\r\n  /// <param name=\"commandIndex\"> index of command in the table</param>\r\n  /// <returns></returns>\r\n  ExtractCommand(commandIndex: number): IClientCommand {\r\n    let command: IClientCommand = this.getCmd(commandIndex);\r\n    this._cmds.RemoveAt(commandIndex);\r\n    return command;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   clear all the commands from the table\r\n  /// </summary>\r\n  clear(): void {\r\n    this._cmds.Clear();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the number of commands in the table\r\n  /// </summary>\r\n  getSize(): number {\r\n    return this._cmds.length;\r\n  }\r\n}\r\n"]}