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

package/esm2022/src/event/EventHandler.mjs

@@ -0,0 +1,766 @@
+import { ApplicationException, Exception, NString, RefParam, StringBuilder, isNullOrUndefined } from "@magic-xpa/mscorelib";
+import { BrkScope, Constants, InternalInterface, Logger, Logger_LogLevels, StorageAttributeCheck, XMLConstants, XmlParser } from "@magic-xpa/utils";
+import { Event } from "./Event";
+import { FieldBase } from "../data/FieldBase";
+import { OperationTable } from "../rt/OperationTable";
+import { FlowMonitorQueue } from "../util/FlowMonitorQueue";
+import { ServerError } from "../remote/ServerError";
+import { YesNoExp } from "../exp/YesNoExp";
+import { ConstInterface } from "../ConstInterface";
+import { FlowMonitorInterface } from "../FlowMonitorInterface";
+import { LastFocusedManager } from "../rt/LastFocusedManager";
+import { AccessHelper } from "../AccessHelper";
+import { RemoteCommandsProcessor } from "../remote/RemoteCommandsProcessor";
+import { Environment } from "../env/Environment";
+export class EventHandler {
+    _enabledExp = new YesNoExp(true);
+    _operationTab = null;
+    _propagateExp = new YesNoExp(true);
+    _isHandlerOnForm = false;
+    _ctrl = null;
+    _ctrlName = null;
+    _dvLen = 0;
+    _dvPos = 0;
+    _evt = null;
+    _handledByClient = false;
+    _handlerFld = null;
+    _hasParameters = false;
+    _id = 0;
+    _level = '\0';
+    _scope = null;
+    _task = null;
+    _taskMgdID = -1;
+    constructor() {
+        this._operationTab = new OperationTable();
+    }
+    getCtrlName() {
+        return this._ctrlName;
+    }
+    fillData(taskRef, parser) {
+        if (this._task === null) {
+            this._task = taskRef;
+            this._taskMgdID = this._task.getMgdID();
+        }
+        while (this.initInnerObjects(parser, parser.getNextTag())) {
+        }
+        let dataView = this._task.DataView;
+        this._hasParameters = dataView.ParametersExist(this._dvPos, this._dvLen);
+    }
+    initInnerObjects(parser, foundTagName) {
+        if (foundTagName === null)
+            return false;
+        if (foundTagName === ConstInterface.MG_TAG_HANDLER)
+            this.initInnerElements(parser, this._task);
+        else if (foundTagName === ConstInterface.MG_TAG_OPER)
+            this._operationTab.fillData(this._task, this, parser);
+        else if (foundTagName === ConstInterface.MG_TAG_EVENT && this._evt === null) {
+            this._evt = new Event();
+            this._evt.fillData(parser, this._task);
+            if (this._evt.getType() === ConstInterface.EVENT_TYPE_TIMER ||
+                (this._evt.getType() === ConstInterface.EVENT_TYPE_USER && this._evt.getUserEventType() === ConstInterface.EVENT_TYPE_TIMER))
+                this._task.getMGData().addTimerHandler(this);
+            if (((this._evt.getType() === ConstInterface.EVENT_TYPE_INTERNAL && this._evt.getInternalCode() === InternalInterface.MG_ACT_ZOOM) || (this._evt.getType() === ConstInterface.EVENT_TYPE_USER && this._evt.getUserEvent() !== null && this._evt.getUserEventType() === ConstInterface.EVENT_TYPE_INTERNAL && this._evt.getUserEvent().getInternalCode() === InternalInterface.MG_ACT_ZOOM)) && !this._task.getEnableZoomHandler()) {
+                if (this._handlerFld !== null)
+                    this._handlerFld.setHasZoomHandler();
+                else if (this._ctrl !== null)
+                    this._ctrl.HasZoomHandler = true;
+                else
+                    this._task.setEnableZoomHandler();
+            }
+        }
+        else if (foundTagName === '/' + ConstInterface.MG_TAG_HANDLER) {
+            parser.setCurrIndex2EndOfTag();
+            return false;
+        }
+        else {
+            Logger.Instance.WriteExceptionToLogWithMsg("there is no such tag in EventHandler.initInnerObjects() " + foundTagName);
+            return false;
+        }
+        return true;
+    }
+    initInnerElements(parser, taskRef) {
+        let endContext = parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex());
+        if (endContext !== -1 && endContext < parser.getXMLdata().length) {
+            let tag = parser.getXMLsubstring(endContext);
+            parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_HANDLER) + ConstInterface.MG_TAG_HANDLER.length);
+            let tokensVector = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);
+            this.initElements(tokensVector, taskRef);
+            parser.setCurrIndex(++endContext);
+            return;
+        }
+        Logger.Instance.WriteExceptionToLogWithMsg("in Handler.FillData() out of string bounds");
+    }
+    initElements(tokensVector, taskRef) {
+        for (let j = 0; j < tokensVector.length; j += 2) {
+            let attribute = (tokensVector.get_Item(j));
+            let valueStr = (tokensVector.get_Item(j + 1));
+            switch (attribute) {
+                case ConstInterface.MG_ATTR_HANDLEDBY:
+                    this._handledByClient = (valueStr.toUpperCase() === "C".toUpperCase());
+                    break;
+                case XMLConstants.MG_ATTR_ID:
+                    this._id = XmlParser.getInt(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_LEVEL:
+                    this._level = valueStr[0];
+                    break;
+                case ConstInterface.MG_ATTR_OBJECT:
+                    let valueStringCtrlName = XmlParser.unescape(valueStr);
+                    this._ctrlName = XmlParser.unescape(valueStringCtrlName).toUpperCase();
+                    this.calculateCtrlFromControlName(taskRef);
+                    break;
+                case ConstInterface.MG_ATTR_VARIABLE:
+                    this._handlerFld = this._task.DataView.getField(XmlParser.getInt(valueStr));
+                    this._handlerFld.setHasChangeEvent();
+                    break;
+                case ConstInterface.MG_ATTR_SCOPE:
+                    this._scope = valueStr[0];
+                    break;
+                case ConstInterface.MG_ATTR_PROPAGATE:
+                    this._propagateExp.setVal(taskRef, valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_ENABLED:
+                    this._enabledExp.setVal(taskRef, valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_DVPOS:
+                    let i = valueStr.indexOf(",");
+                    if (i > -1) {
+                        this._dvLen = XmlParser.getInt(valueStr.substr(0, i));
+                        this._dvPos = XmlParser.getInt(valueStr.substr(i + 1));
+                        for (let fldIdx = this._dvPos; fldIdx < this._dvPos + this._dvLen; fldIdx++) {
+                            let field = this._task.DataView.getField(fldIdx);
+                            field.IsEventHandlerField = true;
+                        }
+                    }
+                    break;
+                case ConstInterface.MG_ATTR_HANDLER_ONFORM:
+                    this._isHandlerOnForm = XmlParser.getBoolean(valueStr);
+                    break;
+                default:
+                    Logger.Instance.WriteExceptionToLogWithMsg("There is no such tag in EventHandler class. Insert case to EventHandler.initElements for " + attribute);
+                    break;
+            }
+        }
+    }
+    calculateCtrlFromControlName(taskRef) {
+        if (!NString.IsNullOrEmpty(this._ctrlName)) {
+            this._ctrl = ((taskRef.getForm() !== null) ? taskRef.getForm().getCtrlByCtrlName(this._ctrlName) : null);
+        }
+    }
+    isSpecificHandlerOf(rtEvt) {
+        if (this._ctrl === null && this._ctrlName === null && this._handlerFld === null && !this._isHandlerOnForm)
+            return false;
+        if (this._scope === BrkScope.Task && this._task !== rtEvt.getTask())
+            return false;
+        if (this._evt.equals(rtEvt)) {
+            if (this._handlerFld !== null) {
+                return (this._handlerFld === rtEvt.getFld());
+            }
+            if (rtEvt.Control !== null && !this._isHandlerOnForm) {
+                let eventCtrlName = rtEvt.Control.getControlNameForHandlerSearch();
+                if (eventCtrlName !== null && this._ctrlName.toLowerCase() === eventCtrlName.toLowerCase())
+                    return true;
+            }
+            else if (rtEvt.Control === null && this._isHandlerOnForm)
+                return true;
+        }
+        return false;
+    }
+    isNonSpecificHandlerOf(rtEvt) {
+        if (this._ctrl !== null || this._ctrlName !== null || this._handlerFld !== null || this._isHandlerOnForm)
+            return false;
+        if (this._scope === BrkScope.Task && this._task !== rtEvt.getTask() && rtEvt.getType() !== ConstInterface.EVENT_TYPE_TIMER)
+            return false;
+        if (this._scope === BrkScope.Global && this._task !== rtEvt.getTask())
+            return false;
+        if (this._evt.getType() === ConstInterface.EVENT_TYPE_USER && this._evt.getUserEventType() === ConstInterface.EVENT_TYPE_NOTINITED) {
+            try {
+                this._evt.findUserEvent();
+            }
+            catch (applicationException) {
+                if (applicationException instanceof ApplicationException) {
+                }
+                else
+                    throw applicationException;
+            }
+        }
+        return this._evt.equals(rtEvt);
+    }
+    isGlobalHandlerOf(rtEvt) {
+        if (this._scope !== BrkScope.Global)
+            return false;
+        if (this._ctrl != null || this._ctrlName != null || this._handlerFld != null || this._isHandlerOnForm)
+            return false;
+        return this._evt.equals(rtEvt);
+    }
+    isGlobalSpecificHandlerOf(rtEvt) {
+        if (this._scope !== BrkScope.Global)
+            return false;
+        if (this._ctrl == null && this._ctrlName == null && this._handlerFld == null)
+            return false;
+        return (this._ctrlName != null && this._evt.equals(rtEvt) &&
+            NString.Equals(this._ctrlName, rtEvt.Control.Name, true));
+    }
+    async execute(rtEvt, returnedFromServer, enabledCndCheckedAndTrue) {
+        let ctrl = null;
+        let retVal;
+        let depth = 0;
+        let taskEnd = false;
+        let brkLevel = this._task.getBrkLevel();
+        let brkLevelIndex = this._task.getBrkLevelIndex();
+        let initialLoopStackSize = 0;
+        if (taskEnd !== null && this._evt.getType() !== ConstInterface.EVENT_TYPE_EXPRESSION && (this._evt.getType() !== ConstInterface.EVENT_TYPE_USER || (this._evt.getUserEvent().getType() !== ConstInterface.EVENT_TYPE_EXPRESSION && this._evt.getUserEvent().getType() !== ConstInterface.EVENT_TYPE_TIMER))) {
+            if (this._evt.getType() !== ConstInterface.EVENT_TYPE_USER_FUNC)
+                this._task.setBrkLevel(rtEvt.getBrkLevel(), this._id);
+        }
+        else
+            this._task.setBrkLevel(this._evt.getBrkLevel(), this._id);
+        let args = rtEvt.getArgList();
+        try {
+            let flowMonitor = FlowMonitorQueue.Instance;
+            if (rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL && rtEvt.getInternalCode() === InternalInterface.MG_ACT_WEBCLIENT_ROUTE) {
+                if (!this._task.IsRoute() && this._task !== AccessHelper.mgDataTable.StartupMgData.getFirstTask()) {
+                    return new RetVals(true, true);
+                }
+            }
+            let nextOperIdx = -1;
+            if (returnedFromServer) {
+                nextOperIdx = AccessHelper.eventsManager.getNextOperIdx(this._operationTab.getOperation(0), false);
+            }
+            if (nextOperIdx === -1 && !enabledCndCheckedAndTrue && !await this.isEnabled())
+                return new RetVals(true, false);
+            if (this._scope === BrkScope.Task && (rtEvt.getType() === ConstInterface.EVENT_TYPE_TIMER || rtEvt.getType() === ConstInterface.EVENT_TYPE_EXPRESSION)) {
+                let currTask = LastFocusedManager.Instance.getLastFocusedTask();
+                if (this._task !== currTask)
+                    return new RetVals(true, true);
+            }
+            if (!this._handledByClient) {
+                return new RetVals(false, true);
+            }
+            if (rtEvt.getType() !== ConstInterface.EVENT_TYPE_USER && !await this._evt.dataEventIsTrue())
+                return new RetVals(false, true);
+            if (rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL && rtEvt.getInternalCode() === InternalInterface.MG_ACT_TASK_SUFFIX)
+                taskEnd = true;
+            if (rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL) {
+                switch (rtEvt.getInternalCode()) {
+                    case InternalInterface.MG_ACT_REC_PREFIX:
+                        flowMonitor.addTaskFlowRec(InternalInterface.MG_ACT_REC_PREFIX, FlowMonitorInterface.FLWMTR_START, this._task.GetTaskDetails());
+                        break;
+                    case InternalInterface.MG_ACT_REC_SUFFIX:
+                        flowMonitor.addTaskFlowRec(InternalInterface.MG_ACT_REC_SUFFIX, FlowMonitorInterface.FLWMTR_START, this._task.GetTaskDetails());
+                        break;
+                    case InternalInterface.MG_ACT_CTRL_SUFFIX:
+                        flowMonitor.addTaskFlowCtrl(InternalInterface.MG_ACT_CTRL_SUFFIX, rtEvt.Control.Name, FlowMonitorInterface.FLWMTR_START, this._task.GetTaskDetails());
+                        break;
+                    case InternalInterface.MG_ACT_CTRL_PREFIX:
+                        flowMonitor.addTaskFlowCtrl(InternalInterface.MG_ACT_CTRL_PREFIX, rtEvt.Control.Name, FlowMonitorInterface.FLWMTR_START, this._task.GetTaskDetails());
+                        break;
+                    case InternalInterface.MG_ACT_VARIABLE:
+                        flowMonitor.addTaskFlowFld(InternalInterface.MG_ACT_VARIABLE, rtEvt.getFld().getName(), FlowMonitorInterface.FLWMTR_START, this._task.GetTaskDetails());
+                        break;
+                    case InternalInterface.MG_ACT_CTRL_VERIFICATION:
+                        flowMonitor.addTaskFlowCtrl(InternalInterface.MG_ACT_CTRL_VERIFICATION, rtEvt.Control.Name, FlowMonitorInterface.FLWMTR_START, this._task.GetTaskDetails());
+                        break;
+                    case InternalInterface.MG_ACT_TASK_PREFIX:
+                        flowMonitor.addTaskFlowRec(InternalInterface.MG_ACT_TASK_PREFIX, FlowMonitorInterface.FLWMTR_START, this._task.GetTaskDetails());
+                        break;
+                    case InternalInterface.MG_ACT_TASK_SUFFIX:
+                        flowMonitor.addTaskFlowRec(InternalInterface.MG_ACT_TASK_SUFFIX, FlowMonitorInterface.FLWMTR_START, this._task.GetTaskDetails());
+                        break;
+                    default:
+                        flowMonitor.addTaskFlowHandler(this._evt.getBrkLevel(true), FlowMonitorInterface.FLWMTR_START, this._task.GetTaskDetails());
+                        break;
+                }
+            }
+            else
+                flowMonitor.addTaskFlowHandler(this._evt.getBrkLevel(true), FlowMonitorInterface.FLWMTR_START, this._task.GetTaskDetails());
+            try {
+                if (taskEnd !== null)
+                    ctrl = rtEvt.Control;
+                let mgdID = AccessHelper.mgDataTable.currMgdID;
+                let isChangedCurrWnd = false;
+                let isChangedCurrWndRef = new RefParam(isChangedCurrWnd);
+                if (this._evt.getType() === ConstInterface.EVENT_TYPE_TIMER && mgdID !== rtEvt.getMgdID()) {
+                    AccessHelper.mgDataTable.currMgdID = rtEvt.getMgdID();
+                    isChangedCurrWndRef.value = true;
+                }
+                await this.resetLocalVariables(args);
+                initialLoopStackSize = this._task.getLoopStackSize();
+                let retVals = null;
+                if (this._operationTab.getSize() > 0)
+                    retVals = await this.executeOperations(0, this._operationTab.getSize() - 1, taskEnd, mgdID, depth, isChangedCurrWndRef, false, false, -1);
+                isChangedCurrWnd = isChangedCurrWndRef.value;
+                if (retVals !== null)
+                    return retVals;
+                if (!taskEnd)
+                    await this._task.evalEndCond(ConstInterface.END_COND_EVAL_IMMIDIATE);
+                if (isChangedCurrWnd) {
+                    let oldMgd = AccessHelper.mgDataTable.getMGData(mgdID);
+                    if (oldMgd !== null && !oldMgd.IsAborting)
+                        AccessHelper.mgDataTable.currMgdID = mgdID;
+                }
+            }
+            catch (ex) {
+                if (ex instanceof ServerError) {
+                    if (Logger.Instance.LogLevel !== Logger_LogLevels.Basic)
+                        Logger.Instance.WriteExceptionToLog(ex);
+                    throw ex;
+                }
+                else if (ex instanceof Exception) {
+                    Logger.Instance.WriteExceptionToLog(ex);
+                    return new RetVals(false, true);
+                }
+                else
+                    throw ex;
+            }
+            finally {
+                retVal = await this._propagateExp.getVal();
+                let currLoopStackSize = this._task.getLoopStackSize();
+                for (; currLoopStackSize > initialLoopStackSize; currLoopStackSize = currLoopStackSize--)
+                    this._task.popLoopCounter();
+            }
+            if (args !== null)
+                await this.getArgValsFromFlds(args);
+            if (rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL) {
+                switch (rtEvt.getInternalCode()) {
+                    case InternalInterface.MG_ACT_REC_PREFIX:
+                        flowMonitor.addTaskFlowRec(InternalInterface.MG_ACT_REC_PREFIX, FlowMonitorInterface.FLWMTR_END, this._task.GetTaskDetails());
+                        break;
+                    case InternalInterface.MG_ACT_REC_SUFFIX:
+                        flowMonitor.addTaskFlowRec(InternalInterface.MG_ACT_REC_SUFFIX, FlowMonitorInterface.FLWMTR_END, this._task.GetTaskDetails());
+                        break;
+                    case InternalInterface.MG_ACT_TASK_PREFIX:
+                        flowMonitor.addTaskFlowRec(InternalInterface.MG_ACT_TASK_PREFIX, FlowMonitorInterface.FLWMTR_END, this._task.GetTaskDetails());
+                        break;
+                    case InternalInterface.MG_ACT_TASK_SUFFIX:
+                        flowMonitor.addTaskFlowRec(InternalInterface.MG_ACT_TASK_SUFFIX, FlowMonitorInterface.FLWMTR_END, this._task.GetTaskDetails());
+                        break;
+                    case InternalInterface.MG_ACT_CTRL_SUFFIX:
+                        flowMonitor.addTaskFlowCtrl(InternalInterface.MG_ACT_CTRL_SUFFIX, ctrl.Name, FlowMonitorInterface.FLWMTR_END, this._task.GetTaskDetails());
+                        break;
+                    case InternalInterface.MG_ACT_CTRL_PREFIX:
+                        flowMonitor.addTaskFlowCtrl(InternalInterface.MG_ACT_CTRL_PREFIX, ctrl.Name, FlowMonitorInterface.FLWMTR_END, this._task.GetTaskDetails());
+                        break;
+                    case InternalInterface.MG_ACT_VARIABLE:
+                        flowMonitor.addTaskFlowFld(InternalInterface.MG_ACT_VARIABLE, rtEvt.getFld().getName(), FlowMonitorInterface.FLWMTR_END, this._task.GetTaskDetails());
+                        break;
+                    case InternalInterface.MG_ACT_CTRL_VERIFICATION:
+                        flowMonitor.addTaskFlowCtrl(InternalInterface.MG_ACT_CTRL_VERIFICATION, ctrl.Name, FlowMonitorInterface.FLWMTR_END, this._task.GetTaskDetails());
+                        break;
+                    default:
+                        flowMonitor.addTaskFlowHandler(this._evt.getBrkLevel(true), FlowMonitorInterface.FLWMTR_END, this._task.GetTaskDetails());
+                        break;
+                }
+            }
+            else
+                flowMonitor.addTaskFlowHandler(this._evt.getBrkLevel(true), 1, this._task.GetTaskDetails());
+        }
+        finally {
+            this._task.setBrkLevel(brkLevel, brkLevelIndex);
+        }
+        return new RetVals(retVal, true);
+    }
+    async executeOperations(fromIdx, toIdx, taskEnd, mgdID, depth, isChangedCurrWndRef, inBlockIf, inReturnedFromServer, inNextOperIdx) {
+        let oper;
+        let operType;
+        let nextOperIdx = -1;
+        let returnedFromServer = false;
+        let mgd = this._task.getMGData();
+        let execFlowIdx = fromIdx;
+        let retvals;
+        let blockIfReturnedFromServer = false;
+        let executeBlock;
+        let blockLoopExeconServer;
+        let flowMonitor = FlowMonitorQueue.Instance;
+        let routeOperationExecuted = false;
+        if (!inReturnedFromServer) {
+            oper = this._operationTab.getOperation(execFlowIdx);
+            nextOperIdx = AccessHelper.eventsManager.getNextOperIdx(oper, true);
+            if (nextOperIdx > -1) {
+                returnedFromServer = true;
+                if (inBlockIf)
+                    blockIfReturnedFromServer = true;
+            }
+            else
+                returnedFromServer = false;
+        }
+        else {
+            returnedFromServer = inReturnedFromServer;
+            nextOperIdx = inNextOperIdx;
+        }
+        for (; execFlowIdx <= toIdx &&
+            (!AccessHelper.eventsManager.GetStopExecutionFlag()) &&
+            !mgd.IsAborting && !routeOperationExecuted; execFlowIdx += 1) {
+            if (inBlockIf && blockIfReturnedFromServer && this._operationTab.getOperation(toIdx).getServerId() < nextOperIdx)
+                break;
+            oper = this._operationTab.getOperation(execFlowIdx);
+            operType = oper.getType();
+            blockIfReturnedFromServer = false;
+            if (RemoteCommandsProcessor.GetInstance().DelayCommandExecution) {
+                this._task.setUseLoopStack(depth > 0);
+                await oper.operServer(null);
+                break;
+            }
+            if (returnedFromServer && oper.getServerId() < nextOperIdx)
+                if (operType !== ConstInterface.MG_OPER_BLOCK)
+                    continue;
+                else if (this._operationTab.getOperation(oper.getBlockEnd()).getServerId() < nextOperIdx)
+                    continue;
+            if (!taskEnd) {
+                let mainLevel = this._task.getMainLevel().toLowerCase();
+                if (await this._task.evalEndCond(ConstInterface.END_COND_EVAL_IMMIDIATE) && Environment.Instance.getSpecialImmediateHandlerEnd() &&
+                    mainLevel != "RP".toLowerCase() && mainLevel != "TP".toLowerCase() && mainLevel != "RS".toLowerCase() && mainLevel != "TS".toLowerCase())
+                    break;
+            }
+            if (this._taskMgdID !== mgdID)
+                isChangedCurrWndRef.value = true;
+            if (!this._task.isMainProg() && this._task.isOpenWin())
+                AccessHelper.mgDataTable.currMgdID = this._taskMgdID;
+            await AccessHelper.eventsManager.CheckAndShowSpinner(true);
+            switch (operType) {
+                case ConstInterface.MG_OPER_VERIFY:
+                    if (await oper.execute(returnedFromServer)) {
+                        if (!(this._task.getBrkLevel() === "TS")) {
+                            AccessHelper.eventsManager.setStopExecution(true);
+                        }
+                        if (this._task.getInRecordSuffix() && this._task.getLevel() === Constants.TASK_LEVEL_TASK)
+                            this._task.setLevel(Constants.TASK_LEVEL_RECORD);
+                        return new RetVals(false, true);
+                    }
+                    break;
+                case ConstInterface.MG_OPER_LOOP:
+                    this._task.enterLoop();
+                    this._task.increaseLoopCounter();
+                    this._task.setUseLoopStack(true);
+                    await flowMonitor.addFlowFieldOperation(oper, true, this._task.GetTaskDetails());
+                    blockLoopExeconServer = false;
+                    if (!oper.getExecOnServer()) {
+                        while (await oper.execute(false)) {
+                            retvals = await this.executeOperations(execFlowIdx + 1, oper.getBlockClose() - 1, taskEnd, mgdID, depth + 1, isChangedCurrWndRef, false, false, -1);
+                            if (retvals !== null)
+                                return retvals;
+                            if ((mgd.IsAborting || AccessHelper.eventsManager.GetStopExecutionFlag()))
+                                break;
+                            this._task.increaseLoopCounter();
+                            this._task.setUseLoopStack(true);
+                        }
+                    }
+                    else {
+                        if (await oper.execute(false))
+                            blockLoopExeconServer = true;
+                    }
+                    if (!blockLoopExeconServer)
+                        execFlowIdx = oper.getBlockEnd() - 1;
+                    this._task.leaveLoop();
+                    break;
+                case ConstInterface.MG_OPER_BLOCK:
+                    if (!oper.getExecOnServer() || (returnedFromServer && oper.getServerId() < nextOperIdx)) {
+                        this._task.setUseLoopStack(true);
+                        if (!returnedFromServer || oper.getServerId() >= nextOperIdx)
+                            execFlowIdx = await this.getSignificantBlock(execFlowIdx, oper.getBlockEnd());
+                        else
+                            execFlowIdx = this.getStartBlockIfIdxByOper(execFlowIdx, nextOperIdx);
+                    }
+                    else {
+                        this._task.setUseLoopStack(depth > 0);
+                        await oper.operServer(null);
+                        nextOperIdx = AccessHelper.eventsManager.getNextOperIdx(oper, true);
+                        if (nextOperIdx > -1) {
+                            returnedFromServer = true;
+                            if (inBlockIf)
+                                blockIfReturnedFromServer = true;
+                            if (nextOperIdx < this._operationTab.getOperation(oper.getBlockEnd()).getServerId()) {
+                                while (this._operationTab.getOperation(oper.getBlockClose()).getServerId() < nextOperIdx) {
+                                    execFlowIdx = oper.getBlockClose();
+                                    oper = this._operationTab.getOperation(execFlowIdx);
+                                }
+                            }
+                        }
+                        else {
+                            returnedFromServer = false;
+                            execFlowIdx = -1;
+                        }
+                    }
+                    if (execFlowIdx !== -1) {
+                        executeBlock = true;
+                        oper = this._operationTab.getOperation(execFlowIdx);
+                        if (returnedFromServer) {
+                            if (this._operationTab.getOperation(oper.getBlockClose()).getServerId() <= nextOperIdx) {
+                                executeBlock = false;
+                                blockIfReturnedFromServer = true;
+                            }
+                        }
+                        if (executeBlock) {
+                            retvals = await this.executeOperations(execFlowIdx + 1, oper.getBlockClose() - 1, taskEnd, mgdID, depth + 1, isChangedCurrWndRef, true, returnedFromServer, nextOperIdx);
+                            if (retvals !== null)
+                                if (!retvals.ReturnedFromServer)
+                                    return retvals;
+                                else {
+                                    returnedFromServer = retvals.ReturnedFromServer;
+                                    nextOperIdx = retvals.NextOperIdx;
+                                    blockIfReturnedFromServer = retvals.BlockIfReturnedFromServer;
+                                    execFlowIdx = oper.getBlockEnd() - 1;
+                                    continue;
+                                }
+                        }
+                    }
+                    execFlowIdx = oper.getBlockEnd() - 1;
+                    break;
+                case ConstInterface.MG_OPER_ENDBLOCK:
+                    await flowMonitor.addFlowFieldOperation(oper, true, this._task.GetTaskDetails());
+                    break;
+                case ConstInterface.MG_OPER_CALL:
+                    this._task.setUseLoopStack(depth > 0);
+                    routeOperationExecuted = await oper.execute(returnedFromServer);
+                    break;
+                default:
+                    this._task.setUseLoopStack(depth > 0);
+                    await oper.execute(returnedFromServer);
+                    break;
+            }
+            if (!blockIfReturnedFromServer) {
+                nextOperIdx = AccessHelper.eventsManager.getNextOperIdx(oper, true);
+                if (nextOperIdx > -1) {
+                    returnedFromServer = true;
+                    if (inBlockIf)
+                        blockIfReturnedFromServer = true;
+                }
+                else
+                    returnedFromServer = false;
+            }
+        }
+        if (routeOperationExecuted)
+            retvals = new RetVals(false, true);
+        else if (blockIfReturnedFromServer)
+            retvals = new RetVals(nextOperIdx, returnedFromServer, blockIfReturnedFromServer);
+        else
+            retvals = null;
+        return retvals;
+    }
+    async getSignificantBlock(startBlockIdx, endIdx) {
+        let retIdx = -1;
+        while (startBlockIdx < endIdx) {
+            let oper = this._operationTab.getOperation(startBlockIdx);
+            let operType = oper.getType();
+            if (operType !== ConstInterface.MG_OPER_BLOCK && operType !== ConstInterface.MG_OPER_ELSE && operType !== ConstInterface.MG_OPER_SERVER)
+                break;
+            if (await oper.execute(false)) {
+                retIdx = startBlockIdx;
+                break;
+            }
+            else
+                startBlockIdx = oper.getBlockClose();
+        }
+        return retIdx;
+    }
+    getStartBlockIdxByEnd(endIdx) {
+        let retIdx = -1;
+        let found = false;
+        let j;
+        for (j = endIdx - 1; j >= 0 && !found; j--) {
+            let oper = this._operationTab.getOperation(j);
+            let operType = oper.getType();
+            if (operType === ConstInterface.MG_OPER_BLOCK || operType === ConstInterface.MG_OPER_LOOP) {
+                if (oper.getBlockEnd() === endIdx) {
+                    retIdx = j;
+                    found = true;
+                }
+            }
+        }
+        return retIdx;
+    }
+    getStartBlockIdxByElse(elseIdx) {
+        let retIdx = -1;
+        let found = false;
+        let elseBlockEnd = this._operationTab.getOperation(elseIdx).getBlockEnd();
+        let j;
+        for (j = elseIdx - 1; j >= 0 && !found; j--) {
+            let oper = this._operationTab.getOperation(j);
+            let operType = oper.getType();
+            if (operType === ConstInterface.MG_OPER_BLOCK) {
+                if (oper.getBlockEnd() === elseBlockEnd) {
+                    retIdx = j;
+                    found = true;
+                }
+            }
+        }
+        return retIdx;
+    }
+    getStartBlockIfIdxByOper(blockOperIdx, srvrOperIdx) {
+        let retIdx = -1;
+        let found = false;
+        let j = this._operationTab.serverId2operIdx(srvrOperIdx, blockOperIdx) - 1;
+        if (j === -2) {
+            j = this._operationTab.serverId2FollowingOperIdx(srvrOperIdx, blockOperIdx) - 1;
+        }
+        while (j >= 0 && !found) {
+            let oper = this._operationTab.getOperation(j);
+            let operType = oper.getType();
+            if (operType === ConstInterface.MG_OPER_BLOCK) {
+                if (j === blockOperIdx) {
+                    retIdx = j;
+                    found = true;
+                }
+                else
+                    j--;
+            }
+            else if (operType === ConstInterface.MG_OPER_ELSE) {
+                let blockStrt = this.getStartBlockIdxByElse(j);
+                if (blockStrt === blockOperIdx) {
+                    retIdx = j;
+                    found = true;
+                }
+                else
+                    j = blockStrt - 1;
+            }
+            else if (operType === ConstInterface.MG_OPER_ENDBLOCK)
+                j = this.getStartBlockIdxByEnd(j) - 1;
+            else
+                j--;
+        }
+        return retIdx;
+    }
+    getLevel() {
+        return this._level;
+    }
+    getEvent() {
+        return this._evt;
+    }
+    getId() {
+        return this._id;
+    }
+    async isEnabled() {
+        return await this._enabledExp.getVal();
+    }
+    async resetLocalVariables(args) {
+        let dv = this._task.DataView;
+        let argIdx = 0;
+        try {
+            for (let fieldIdx = this._dvPos; fieldIdx < this._dvPos + this._dvLen; fieldIdx++) {
+                let aField = dv.getField(fieldIdx);
+                let varIsParm = !this._hasParameters || aField.isParam();
+                if ((args !== null && argIdx < args.getSize()) && varIsParm) {
+                    if (!args.getArg(argIdx).skipArg()) {
+                        await args.getArg(argIdx).setValueToField(aField);
+                    }
+                    else {
+                        aField.invalidate(true, FieldBase.CLEAR_FLAGS);
+                        await aField.compute(false);
+                    }
+                    argIdx++;
+                }
+                else {
+                    aField.invalidate(true, FieldBase.CLEAR_FLAGS);
+                    await aField.compute(false);
+                }
+                await aField.updateDisplay();
+            }
+        }
+        catch (exception) {
+            throw exception;
+        }
+    }
+    async getArgValsFromFlds(args) {
+        let dv = this._task.DataView;
+        let k = 0;
+        let j;
+        for (j = this._dvPos; j < this._dvPos + this._dvLen && k < args.getSize(); j++) {
+            let aField = dv.getField(j);
+            if (!this._hasParameters || aField.isParam()) {
+                let arg = args.getArg(k);
+                if (arg.getType() === ConstInterface.ARG_TYPE_FIELD) {
+                    let argFld = arg.getField();
+                    if (argFld.getTask() !== null && !argFld.getTask().isAborting()) {
+                        let val = aField.getValue(false);
+                        await argFld.setValueAndStartRecompute(val, aField.isNull(), true, aField.isModified(), false);
+                        await argFld.updateDisplay();
+                    }
+                }
+                k++;
+            }
+        }
+    }
+    getTask() {
+        return this._task;
+    }
+    argsMatch(Exp_params) {
+        let argsMatched = true;
+        let dv = this._task.DataView;
+        let j = 0;
+        let paramCount = 0;
+        for (let i = this._dvPos; i < this._dvPos + this._dvLen; i++) {
+            let field = dv.getField(i);
+            if (field.isParam()) {
+                paramCount++;
+                if (j < Exp_params.length) {
+                    let fieldAttr = field.getType();
+                    let argAttr = Exp_params[j].Attr;
+                    if (!Exp_params[j].IsNull && !StorageAttributeCheck.isTheSameType(fieldAttr, argAttr) && !StorageAttributeCheck.StorageFldAlphaUnicodeOrBlob(fieldAttr, argAttr)) {
+                        argsMatched = false;
+                        break;
+                    }
+                    j++;
+                }
+            }
+        }
+        if (paramCount !== Exp_params.length) {
+            argsMatched = false;
+        }
+        return argsMatched;
+    }
+    getOperationTab() {
+        return this._operationTab;
+    }
+    getControlNameForControlHeader() {
+        if (this.getEvent().getType() == ConstInterface.EVENT_TYPE_INTERNAL) {
+            if (this.getEvent().isControlHeader() && !isNullOrUndefined(this._ctrl))
+                return this.getCtrlName();
+        }
+        return NString.Empty;
+    }
+    getVarNameForVariableHeader() {
+        if (this.getEvent().isVariableHeader() && !isNullOrUndefined(this._handlerFld))
+            return this._handlerFld.getVarName().toUpperCase();
+        return NString.Empty;
+    }
+    getEventHandlerInfo() {
+        let eventDescription = new StringBuilder();
+        this.getEvent().AppendDescription(eventDescription);
+        let headerAdditionalInfo = this.getControlNameForControlHeader() + this.getVarNameForVariableHeader();
+        eventDescription.Append(headerAdditionalInfo);
+        if (!NString.IsNullOrEmpty(eventDescription.toString()))
+            eventDescription = new StringBuilder(' ' + eventDescription.toString(), eventDescription.toString().length + 1);
+        return NString.Format("Handler {0}{1}", this.getEvent().getEventType(), eventDescription);
+    }
+    toString() {
+        return NString.Format("(Handler for {0} on task {1}, scope {2})", this._evt, this._task, this._scope);
+    }
+}
+export class RetVals {
+    BlockIfReturnedFromServer = false;
+    Enabled = false;
+    NextOperIdx = 0;
+    Propagate = false;
+    ReturnedFromServer = false;
+    constructor(pOrOperIdx, eOrInReturnedFromServer, inBlockIfReturnedFromServer) {
+        if (arguments.length === 2)
+            this.constructor_0(pOrOperIdx, eOrInReturnedFromServer);
+        else
+            this.constructor_1(pOrOperIdx, eOrInReturnedFromServer, inBlockIfReturnedFromServer);
+    }
+    constructor_0(p, e) {
+        this.Propagate = p;
+        this.Enabled = e;
+        this.NextOperIdx = 0;
+        this.ReturnedFromServer = false;
+        this.BlockIfReturnedFromServer = false;
+    }
+    constructor_1(operIdx, inReturnedFromServer, inBlockIfReturnedFromServer) {
+        this.Propagate = false;
+        this.Enabled = true;
+        this.NextOperIdx = operIdx;
+        this.ReturnedFromServer = inReturnedFromServer;
+        this.BlockIfReturnedFromServer = inBlockIfReturnedFromServer;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"EventHandler.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/event/EventHandler.ts"],"names":[],"mappings":"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","sourcesContent":["import {ApplicationException, Exception, List, NString, RefParam, StringBuilder, isNullOrUndefined} from \"@magic-xpa/mscorelib\";\r\nimport {\r\n  BrkScope,\r\n  Constants,\r\n  InternalInterface,\r\n  Logger,\r\n  Logger_LogLevels,\r\n  StorageAttribute,\r\n  StorageAttributeCheck,\r\n  XMLConstants,\r\n  XmlParser\r\n} from \"@magic-xpa/utils\";\r\nimport {ExpVal} from \"@magic-xpa/gui\";\r\nimport {Event} from \"./Event\";\r\nimport {FieldBase} from \"../data/FieldBase\";\r\nimport {OperationTable} from \"../rt/OperationTable\";\r\nimport {Argument} from \"../rt/Argument\";\r\nimport {ArgumentsList} from \"../rt/ArgumentsList\";\r\nimport {MgControl} from \"../gui/MgControl\";\r\nimport {Operation} from \"../rt/Operation\";\r\nimport {FlowMonitorQueue} from \"../util/FlowMonitorQueue\";\r\nimport {MGData} from \"../tasks/MGData\";\r\nimport {ServerError} from \"../remote/ServerError\";\r\nimport {RunTimeEvent} from \"./RunTimeEvent\";\r\nimport {MgForm} from \"../gui/MgForm\";\r\nimport {YesNoExp} from \"../exp/YesNoExp\";\r\nimport {Task} from \"../tasks/Task\";\r\nimport {DataView} from \"../data/DataView\";\r\nimport {ConstInterface} from \"../ConstInterface\";\r\nimport {FlowMonitorInterface} from \"../FlowMonitorInterface\";\r\nimport { LastFocusedManager } from \"../rt/LastFocusedManager\";\r\nimport { AccessHelper } from \"../AccessHelper\";\r\nimport {RemoteCommandsProcessor} from \"../remote/RemoteCommandsProcessor\";\r\nimport { Environment } from \"../env/Environment\";\r\n\r\nexport class EventHandler {\r\n  private _enabledExp: YesNoExp = new YesNoExp(true); // default is true always\r\n  private _operationTab: OperationTable = null;\r\n  private _propagateExp: YesNoExp = new YesNoExp(true);\r\n  private _isHandlerOnForm: boolean = false;\r\n  private _ctrl: MgControl = null;\r\n  private _ctrlName: string = null;\r\n  private _dvLen: number = 0; // The “dvposEcontains the number of fields selected in the handler\r\n  private _dvPos: number = 0; // and the index of the first field of it in the Dataview.\r\n  private _evt: Event = null;\r\n  private _handledByClient: boolean = false;\r\n  private _handlerFld: FieldBase = null;\r\n  private _hasParameters: boolean = false;\r\n  private _id: number = 0;\r\n  private _level: string = '\\0'; // Control | Handler | Record | Task | Variable\r\n  private _scope: BrkScope = null; // Task|Subtask|Global\r\n  private _task: Task = null;\r\n  private _taskMgdID: number = -1;\r\n\r\n  /// <summary>\r\n  ///   CTOR\r\n  /// </summary>\r\n  constructor() {\r\n    this._operationTab = new OperationTable();\r\n  }\r\n\r\n  getCtrlName() : string{\r\n    return this._ctrlName;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parse the event handler and its sub-structures\r\n  /// </summary>\r\n  fillData(taskRef: Task, parser: XmlParser): void {\r\n    if (this._task === null) {\r\n      this._task = taskRef;\r\n      this._taskMgdID = this._task.getMgdID();\r\n    }\r\n\r\n    while (this.initInnerObjects(parser, parser.getNextTag())) {\r\n    }\r\n    let dataView: DataView = <DataView>this._task.DataView;\r\n    this._hasParameters = dataView.ParametersExist(this._dvPos, this._dvLen);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   initializing of inner objects\r\n  /// </summary>\r\n  private initInnerObjects(parser: XmlParser, foundTagName: string): boolean {\r\n\r\n    if (foundTagName === null)\r\n      return false;\r\n\r\n    if (foundTagName === ConstInterface.MG_TAG_HANDLER)\r\n      this.initInnerElements(parser, this._task);\r\n\r\n    else if (foundTagName === ConstInterface.MG_TAG_OPER)\r\n      this._operationTab.fillData(this._task, this, parser);\r\n\r\n    else if (foundTagName === ConstInterface.MG_TAG_EVENT && this._evt === null) {\r\n      this._evt = new Event();\r\n      this._evt.fillData(parser, this._task);\r\n      if (this._evt.getType() === ConstInterface.EVENT_TYPE_TIMER ||\r\n        (this._evt.getType() === ConstInterface.EVENT_TYPE_USER && this._evt.getUserEventType() === ConstInterface.EVENT_TYPE_TIMER))\r\n        this._task.getMGData().addTimerHandler(this);\r\n\r\n      // for enable MG_ACT_ZOOM action\r\n      // 1. handler on zoom action.\r\n      // 2. handler on a user defined handler with a trigger of zoom action.\r\n      if (((this._evt.getType() === ConstInterface.EVENT_TYPE_INTERNAL && this._evt.getInternalCode() === InternalInterface.MG_ACT_ZOOM) || (this._evt.getType() === ConstInterface.EVENT_TYPE_USER && this._evt.getUserEvent() !== null && this._evt.getUserEventType() === ConstInterface.EVENT_TYPE_INTERNAL && this._evt.getUserEvent().getInternalCode() === InternalInterface.MG_ACT_ZOOM)) && !this._task.getEnableZoomHandler()) {\r\n\r\n        if (this._handlerFld !== null)\r\n          this._handlerFld.setHasZoomHandler();\r\n\r\n        else if (this._ctrl !== null)\r\n          this._ctrl.HasZoomHandler = true;\r\n\r\n        else\r\n          this._task.setEnableZoomHandler();\r\n      }\r\n    }\r\n    else if (foundTagName === '/' + ConstInterface.MG_TAG_HANDLER) {\r\n      parser.setCurrIndex2EndOfTag();\r\n      return false;\r\n\r\n    }\r\n    else {\r\n      Logger.Instance.WriteExceptionToLogWithMsg(\"there is no such tag in EventHandler.initInnerObjects() \" + foundTagName);\r\n      return false;\r\n    }\r\n    return true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Initializing of inner attributes of <handler> tag\r\n  /// </summary>\r\n  /// <param name = \"taskRef\"></param>\r\n  private initInnerElements(parser: XmlParser, taskRef: Task): void {\r\n    let endContext: number = parser.getXMLdata().indexOf( XMLConstants.TAG_CLOSE, parser.getCurrIndex());\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_HANDLER) + ConstInterface.MG_TAG_HANDLER.length);\r\n\r\n      let tokensVector: List<string> = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);\r\n      this.initElements(tokensVector, taskRef);\r\n      parser.setCurrIndex(++endContext); // to delete \">\" too\r\n      return;\r\n    }\r\n    Logger.Instance.WriteExceptionToLogWithMsg(\"in Handler.FillData() out of string bounds\");\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Make initialization of private elements by found tokens\r\n  /// </summary>\r\n  /// <param name = \"tokensVector\">found tokens, which consist attribute/value of every found\telement </param>\r\n  /// <param name = \"taskRef\"> </param>\r\n  private initElements(tokensVector: List<string>, taskRef: Task): void {\r\n    for (let j: number = 0; j < tokensVector.length; j += 2) {\r\n      let attribute: string = (tokensVector.get_Item(j));\r\n      let valueStr: string = (tokensVector.get_Item(j + 1));\r\n\r\n      switch (attribute) {\r\n        case ConstInterface.MG_ATTR_HANDLEDBY:\r\n          this._handledByClient = (valueStr.toUpperCase() === \"C\".toUpperCase());\r\n          break;\r\n\r\n        case XMLConstants.MG_ATTR_ID:\r\n          this._id = XmlParser.getInt(valueStr);\r\n          break;\r\n\r\n        case ConstInterface.MG_ATTR_LEVEL:\r\n          this._level = valueStr[0];\r\n          break;\r\n\r\n        case ConstInterface.MG_ATTR_OBJECT:\r\n          let valueStringCtrlName: string = XmlParser.unescape(valueStr);\r\n          this._ctrlName = XmlParser.unescape(valueStringCtrlName).toUpperCase(); // relevant for user handlers only\r\n          this.calculateCtrlFromControlName(taskRef);\r\n          break;\r\n\r\n        case ConstInterface.MG_ATTR_VARIABLE:\r\n          this._handlerFld = <FieldBase>this._task.DataView.getField(XmlParser.getInt(valueStr));\r\n          this._handlerFld.setHasChangeEvent();\r\n          break;\r\n\r\n        case ConstInterface.MG_ATTR_SCOPE:\r\n          this._scope = <BrkScope>valueStr[0];\r\n          break;\r\n\r\n        case ConstInterface.MG_ATTR_PROPAGATE:\r\n          this._propagateExp.setVal(taskRef, valueStr);\r\n          break;\r\n\r\n        case ConstInterface.MG_ATTR_ENABLED:\r\n          this._enabledExp.setVal(taskRef, valueStr);\r\n          break;\r\n\r\n        case ConstInterface.MG_ATTR_DVPOS:\r\n          let i: number = valueStr.indexOf(\",\");\r\n          if (i > -1) {\r\n            this._dvLen = XmlParser.getInt(valueStr.substr(0, i));\r\n            this._dvPos = XmlParser.getInt(valueStr.substr(i + 1));\r\n            for (let fldIdx: number = this._dvPos; fldIdx < this._dvPos + this._dvLen; fldIdx++) {\r\n              let field: FieldBase = (<FieldBase>this._task.DataView.getField(fldIdx));\r\n              field.IsEventHandlerField = true;\r\n            }\r\n          }\r\n          break;\r\n\r\n        case ConstInterface.MG_ATTR_HANDLER_ONFORM:\r\n          this._isHandlerOnForm = XmlParser.getBoolean(valueStr);\r\n          break;\r\n\r\n        default:\r\n          Logger.Instance.WriteExceptionToLogWithMsg(\"There is no such tag in EventHandler class. Insert case to EventHandler.initElements for \" + attribute);\r\n          break;\r\n      }\r\n    }\r\n  }\r\n\r\n/// <summary>\r\n  /// calculate the ctrl property from ctrl name property\r\n  /// </summary>\r\n  /// <param name=\"taskRef\"></param>\r\n  /// <param name=\"valueStringCtrlName\"></param>\r\n\r\n  calculateCtrlFromControlName(taskRef: Task): void {\r\n    if (!NString.IsNullOrEmpty(this._ctrlName)) {\r\n      this._ctrl = ((taskRef.getForm() !== null) ? (<MgForm>taskRef.getForm()).getCtrlByCtrlName(this._ctrlName) : null);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   check if this event handler is a specific handler of an event\r\n  /// </summary>\r\n  /// <param name = \"rtEvt\">the event to check</param>\r\n  /// <returns> boolean true if the events match</returns>\r\n  isSpecificHandlerOf(rtEvt: RunTimeEvent): boolean {\r\n\r\n    if (this._ctrl === null && this._ctrlName === null && this._handlerFld === null && !this._isHandlerOnForm)\r\n      return false;\r\n\r\n    // check the validity of the scope\r\n    if (this._scope === BrkScope.Task && this._task !== rtEvt.getTask())\r\n      return false;\r\n\r\n    // if the handlers event and the checked event are equal and\r\n    // the handler handles the control attached to the checked event, return true\r\n    // compare control name with the name of the control in the event\r\n    if (this._evt.equals(rtEvt)) {\r\n      // Variable change handlers do not have control names. Only fields need to be compared\r\n      if (this._handlerFld !== null) {\r\n        return (this._handlerFld === rtEvt.getFld());\r\n      }\r\n      if (rtEvt.Control !== null && !this._isHandlerOnForm) {\r\n        let eventCtrlName: string = rtEvt.Control.getControlNameForHandlerSearch();\r\n        if (eventCtrlName !== null && this._ctrlName.toLowerCase() === eventCtrlName.toLowerCase())\r\n          return true;\r\n      }\r\n      else if (rtEvt.Control === null && this._isHandlerOnForm)\r\n        return true;\r\n    }\r\n\r\n    return false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   check if this event handler is a non-specific or global handler of an event\r\n  /// </summary>\r\n  /// <param name = \"rtEvt\">the event to check\r\n  /// </param>\r\n  /// <returns> boolean true if the events match\r\n  /// </returns>\r\n  isNonSpecificHandlerOf(rtEvt: RunTimeEvent): boolean {\r\n\r\n    // if the handler handles a control return false\r\n    if (this._ctrl !== null || this._ctrlName !== null || this._handlerFld !== null || this._isHandlerOnForm)\r\n      return false;\r\n    // check the validity of the scope\r\n    if (this._scope === BrkScope.Task &&  this._task !== rtEvt.getTask() && rtEvt.getType() !== ConstInterface.EVENT_TYPE_TIMER)\r\n  return false;\r\n\r\n    if (this._scope === BrkScope.Global && this._task !== rtEvt.getTask())\r\n      return false;\r\n\r\n    // if the handlers event and the checked event are equal return true\r\n    if (this._evt.getType() === ConstInterface.EVENT_TYPE_USER && this._evt.getUserEventType() === ConstInterface.EVENT_TYPE_NOTINITED) {\r\n      try {\r\n        this._evt.findUserEvent();\r\n      }\r\n      catch (applicationException) {\r\n        if (applicationException instanceof ApplicationException) {\r\n        }\r\n        else\r\n          throw applicationException;\r\n      }\r\n    }\r\n    return this._evt.equals(rtEvt);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   check if this event handler is a global handler of an event\r\n  /// </summary>\r\n  /// <param name = \"rtEvt\">the event to check\r\n  /// </param>\r\n  /// <returns> boolean true if the events match\r\n  /// </returns>\r\n  isGlobalHandlerOf(rtEvt: RunTimeEvent): boolean {\r\n    // check the validity of the scope\r\n    if (this._scope !== BrkScope.Global)\r\n      return false;\r\n\r\n    // if the handler handles a control return false\r\n    if (this._ctrl != null || this._ctrlName != null || this._handlerFld != null || this._isHandlerOnForm)\r\n      return false;\r\n\r\n    // if the handlers event and the checked event are equal, return true\r\n    return this._evt.equals(rtEvt);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   check if this event handler is a specific global handler of an event\r\n  /// </summary>\r\n  /// <param name = \"rtEvt\">the event to check\r\n  /// </param>\r\n  /// <returns> boolean true if the events match\r\n  /// </returns>\r\n  isGlobalSpecificHandlerOf(rtEvt: RunTimeEvent): boolean {\r\n    // check the validity of the scope\r\n    if (this._scope !== BrkScope.Global)\r\n      return false;\r\n\r\n    if (this._ctrl == null && this._ctrlName == null && this._handlerFld == null)\r\n      return false;\r\n\r\n    // if the handlers event and the checked event are equal, return true\r\n    return (this._ctrlName != null && this._evt.equals(rtEvt) &&\r\n      NString.Equals(this._ctrlName, rtEvt.Control.Name, true));\r\n  }\r\n\r\n  /// <summary>\r\n  ///   execute the event handler\r\n  /// </summary>\r\n  /// <param name = \"rtEvt\">the event on which the handler is executed\r\n  /// </param>\r\n  /// <param name = \"returnedFromServer\">indicates whether we returned from the server and\r\n  ///   therefore might not need to check the enabled condition\r\n  /// </param>\r\n  /// <param name = \"enabledCndCheckedAndTrue\">indicates that the enabled condition was already checked and there's no\r\n  ///   need to re-check it (because it might be false now, but we still need to\r\n  ///   execute the handler)\r\n  /// </param>\r\n  /// <returns> boolean this is the return code of the handler, if true then the events\r\n  ///   manager must continue searching for the next event handler for the event\r\n  /// </returns>\r\n async execute(rtEvt: RunTimeEvent, returnedFromServer: boolean, enabledCndCheckedAndTrue: boolean): Promise<RetVals> {\r\n\r\n    let ctrl: MgControl = null;\r\n    let retVal: boolean;\r\n    let depth: number = 0;\r\n    let taskEnd: boolean = false;\r\n    let brkLevel: string = this._task.getBrkLevel();\r\n    let brkLevelIndex: number = this._task.getBrkLevelIndex();\r\n    let initialLoopStackSize: number = 0;\r\n\r\n    // set level for LEVEL function\r\n    if (taskEnd !== null && this._evt.getType() !== ConstInterface.EVENT_TYPE_EXPRESSION && (this._evt.getType() !== ConstInterface.EVENT_TYPE_USER || (this._evt.getUserEvent().getType() !== ConstInterface.EVENT_TYPE_EXPRESSION && this._evt.getUserEvent().getType() !== ConstInterface.EVENT_TYPE_TIMER))) {\r\n      // Unlike a handler, the user function should not change the level of the task.\r\n      if (this._evt.getType() !== ConstInterface.EVENT_TYPE_USER_FUNC)\r\n        this._task.setBrkLevel(rtEvt.getBrkLevel(), this._id);\r\n\r\n    }\r\n    else\r\n      this._task.setBrkLevel(this._evt.getBrkLevel(), this._id);\r\n\r\n    let args: ArgumentsList = rtEvt.getArgList();\r\n\r\n    try {\r\n      let flowMonitor: FlowMonitorQueue = FlowMonitorQueue.Instance;\r\n\r\n      // Route event can only be handled in a task which is opened as router link or the root task.\r\n      if (rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL && rtEvt.getInternalCode() === InternalInterface.MG_ACT_WEBCLIENT_ROUTE) {\r\n        if (!this._task.IsRoute() && this._task !== AccessHelper.mgDataTable.StartupMgData.getFirstTask()) {\r\n          return new RetVals(true, true);\r\n        }\r\n      }\r\n\r\n      // check if the handler is enabled. if not, return true to continue searching\r\n      // for the next event handler\r\n      let nextOperIdx: number = -1;\r\n      if (returnedFromServer) {\r\n        // if we returned from the server - we need to check if the next operation is on the current\r\n        // handler (using a call to getNextOperIdx() with false in the clearWhenFound parameter)\r\n        // and if it is - do not check the enabled condition, because it might have changed\r\n        // since it was evaluated on the server. we need to go into this handler even if it is not\r\n        // currently enabled\r\n        nextOperIdx = AccessHelper.eventsManager.getNextOperIdx(this._operationTab.getOperation(0), false);\r\n      }\r\n      if (nextOperIdx === -1 && !enabledCndCheckedAndTrue && !await this.isEnabled())\r\n        return new RetVals(true, false);\r\n\r\n      // check the scope for Expression and Timer handlers\r\n      if (this._scope === BrkScope.Task && (rtEvt.getType() === ConstInterface.EVENT_TYPE_TIMER || rtEvt.getType() === ConstInterface.EVENT_TYPE_EXPRESSION)) {\r\n        let currTask: Task = LastFocusedManager.Instance.getLastFocusedTask();\r\n        if (this._task !== currTask)\r\n          return new RetVals(true, true);\r\n      }\r\n\r\n      if (!this._handledByClient) {\r\n        // return false to stop searching for the more handlers because\r\n        // the server had taken care of all of them\r\n        return new RetVals(false, true);\r\n      }\r\n\r\n      if (rtEvt.getType() !== ConstInterface.EVENT_TYPE_USER && !await this._evt.dataEventIsTrue())\r\n        return new RetVals(false, true);\r\n\r\n      if (rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL && rtEvt.getInternalCode() === InternalInterface.MG_ACT_TASK_SUFFIX)\r\n        taskEnd = true;\r\n\r\n      if (rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL) {\r\n        switch (rtEvt.getInternalCode()) {\r\n          case InternalInterface.MG_ACT_REC_PREFIX:\r\n            flowMonitor.addTaskFlowRec(InternalInterface.MG_ACT_REC_PREFIX, FlowMonitorInterface.FLWMTR_START,  this._task.GetTaskDetails());\r\n            break;\r\n          case InternalInterface.MG_ACT_REC_SUFFIX:\r\n            flowMonitor.addTaskFlowRec(InternalInterface.MG_ACT_REC_SUFFIX, FlowMonitorInterface.FLWMTR_START,  this._task.GetTaskDetails());\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_CTRL_SUFFIX:\r\n            flowMonitor.addTaskFlowCtrl(InternalInterface.MG_ACT_CTRL_SUFFIX, rtEvt.Control.Name,\r\n                                        FlowMonitorInterface.FLWMTR_START,  this._task.GetTaskDetails());\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_CTRL_PREFIX:\r\n            flowMonitor.addTaskFlowCtrl(InternalInterface.MG_ACT_CTRL_PREFIX, rtEvt.Control.Name,\r\n                                        FlowMonitorInterface.FLWMTR_START,  this._task.GetTaskDetails());\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_VARIABLE:\r\n            flowMonitor.addTaskFlowFld(InternalInterface.MG_ACT_VARIABLE, rtEvt.getFld().getName(),\r\n                                       FlowMonitorInterface.FLWMTR_START,  this._task.GetTaskDetails());\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_CTRL_VERIFICATION:\r\n            flowMonitor.addTaskFlowCtrl(InternalInterface.MG_ACT_CTRL_VERIFICATION,\r\n              rtEvt.Control.Name, FlowMonitorInterface.FLWMTR_START, this._task.GetTaskDetails());\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_TASK_PREFIX:\r\n            flowMonitor.addTaskFlowRec(InternalInterface.MG_ACT_TASK_PREFIX, FlowMonitorInterface.FLWMTR_START,  this._task.GetTaskDetails());\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_TASK_SUFFIX:\r\n            flowMonitor.addTaskFlowRec(InternalInterface.MG_ACT_TASK_SUFFIX, FlowMonitorInterface.FLWMTR_START, this._task.GetTaskDetails());\r\n            break;\r\n\r\n          default:\r\n            flowMonitor.addTaskFlowHandler(this._evt.getBrkLevel(true), FlowMonitorInterface.FLWMTR_START, this._task.GetTaskDetails());\r\n            break;\r\n        }\r\n      }\r\n      else\r\n        flowMonitor.addTaskFlowHandler(this._evt.getBrkLevel(true), FlowMonitorInterface.FLWMTR_START, this._task.GetTaskDetails());\r\n\r\n      try {\r\n\r\n        if (taskEnd !== null)\r\n          ctrl = <MgControl>rtEvt.Control;\r\n\r\n        let mgdID: number = AccessHelper.mgDataTable.currMgdID;\r\n        let isChangedCurrWnd: boolean = false;\r\n        let isChangedCurrWndRef: RefParam<boolean> = new RefParam(isChangedCurrWnd);\r\n\r\n\r\n        // for timer events check if the task of the event is in the\r\n        // current window and if not then change the current window\r\n        // temporarily till the handler finishes\r\n        if (this._evt.getType() === ConstInterface.EVENT_TYPE_TIMER && mgdID !== rtEvt.getMgdID()) {\r\n          // set number of window for timer event\r\n          AccessHelper.mgDataTable.currMgdID = rtEvt.getMgdID();\r\n          isChangedCurrWndRef.value = true;\r\n        }\r\n\r\n        // put initial values to the local variables\r\n        await this.resetLocalVariables(args);\r\n\r\n        initialLoopStackSize = this._task.getLoopStackSize();\r\n        let retVals: RetVals = null;\r\n        if (this._operationTab.getSize() > 0)\r\n          retVals = await this.executeOperations(0, this._operationTab.getSize() - 1, taskEnd, mgdID, depth, isChangedCurrWndRef, false, false, -1);\r\n\r\n        isChangedCurrWnd = isChangedCurrWndRef.value;\r\n\r\n        if (retVals !== null)\r\n          return retVals;\r\n\r\n        // check the endtask condition once again at the end of the handler\r\n        if (!taskEnd)\r\n          await this._task.evalEndCond(ConstInterface.END_COND_EVAL_IMMIDIATE);\r\n\r\n        // change current window back if it was changed for Timer\r\n        if (isChangedCurrWnd) {\r\n          let oldMgd: MGData = AccessHelper.mgDataTable.getMGData(mgdID);\r\n          if (oldMgd !== null && !oldMgd.IsAborting)\r\n            AccessHelper.mgDataTable.currMgdID = mgdID;\r\n        }\r\n      }\r\n      // end while operation block\r\n      catch (ex) {\r\n        if (ex instanceof ServerError) {\r\n          if (Logger.Instance.LogLevel !== Logger_LogLevels.Basic)\r\n            Logger.Instance.WriteExceptionToLog(ex);\r\n          throw ex;\r\n        }\r\n        else if (ex instanceof Exception) {\r\n          Logger.Instance.WriteExceptionToLog(ex);\r\n          return new RetVals(false, true);\r\n        }\r\n        else\r\n          throw ex;\r\n      }\r\n\r\n      finally {\r\n        // get the propagate value\r\n        retVal = await this._propagateExp.getVal();\r\n\r\n        // remove loop counters that were left unused in the stack due to leaving\r\n        // the handler on \"stopExecution() == true\"\r\n        let currLoopStackSize: number = this._task.getLoopStackSize();\r\n        for (; currLoopStackSize > initialLoopStackSize; currLoopStackSize = currLoopStackSize--)\r\n          this._task.popLoopCounter();\r\n      }\r\n\r\n      // after executing the operations update the arguments back and recompute\r\n      if (args !== null)\r\n        await this.getArgValsFromFlds(args);\r\n\r\n      if (rtEvt.getType() === ConstInterface.EVENT_TYPE_INTERNAL) {\r\n        switch (rtEvt.getInternalCode()) {\r\n          case InternalInterface.MG_ACT_REC_PREFIX:\r\n            flowMonitor.addTaskFlowRec(InternalInterface.MG_ACT_REC_PREFIX, FlowMonitorInterface.FLWMTR_END, this._task.GetTaskDetails());\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_REC_SUFFIX:\r\n            flowMonitor.addTaskFlowRec(InternalInterface.MG_ACT_REC_SUFFIX, FlowMonitorInterface.FLWMTR_END, this._task.GetTaskDetails());\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_TASK_PREFIX:\r\n            flowMonitor.addTaskFlowRec(InternalInterface.MG_ACT_TASK_PREFIX, FlowMonitorInterface.FLWMTR_END, this._task.GetTaskDetails());\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_TASK_SUFFIX:\r\n            flowMonitor.addTaskFlowRec(InternalInterface.MG_ACT_TASK_SUFFIX, FlowMonitorInterface.FLWMTR_END, this._task.GetTaskDetails());\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_CTRL_SUFFIX:\r\n            flowMonitor.addTaskFlowCtrl(InternalInterface.MG_ACT_CTRL_SUFFIX, ctrl.Name, FlowMonitorInterface.FLWMTR_END, this._task.GetTaskDetails());\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_CTRL_PREFIX:\r\n            flowMonitor.addTaskFlowCtrl(InternalInterface.MG_ACT_CTRL_PREFIX, ctrl.Name, FlowMonitorInterface.FLWMTR_END, this._task.GetTaskDetails());\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_VARIABLE:\r\n            flowMonitor.addTaskFlowFld(InternalInterface.MG_ACT_VARIABLE, rtEvt.getFld().getName(), FlowMonitorInterface.FLWMTR_END, this._task.GetTaskDetails());\r\n            break;\r\n\r\n          case InternalInterface.MG_ACT_CTRL_VERIFICATION:\r\n            flowMonitor.addTaskFlowCtrl(InternalInterface.MG_ACT_CTRL_VERIFICATION, ctrl.Name, FlowMonitorInterface.FLWMTR_END, this._task.GetTaskDetails());\r\n            break;\r\n\r\n          default:\r\n            flowMonitor.addTaskFlowHandler(this._evt.getBrkLevel(true), FlowMonitorInterface.FLWMTR_END, this._task.GetTaskDetails());\r\n            break;\r\n        }\r\n      }\r\n      else\r\n        flowMonitor.addTaskFlowHandler(this._evt.getBrkLevel(true), 1, this._task.GetTaskDetails());\r\n    }\r\n    finally {\r\n      // restoring  the original break level state and current executing control index\r\n      this._task.setBrkLevel(brkLevel, brkLevelIndex);\r\n    }\r\n    return new RetVals(retVal, true);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   execute the operations starting from fromIdx and ending at endIdx.\r\n  /// </summary>\r\n  private async executeOperations(fromIdx: number, toIdx: number, taskEnd: boolean, mgdID: number, depth: number,\r\n                            isChangedCurrWndRef: RefParam<boolean>, inBlockIf: boolean, inReturnedFromServer: boolean,\r\n                            inNextOperIdx: number): Promise <RetVals> {\r\n    let oper: Operation;\r\n    let operType: number;\r\n    let nextOperIdx: number = -1;\r\n    let returnedFromServer: boolean = false;\r\n    let mgd: MGData = this._task.getMGData();\r\n    let execFlowIdx: number = fromIdx;\r\n    let retvals: RetVals;\r\n    let blockIfReturnedFromServer: boolean = false;\r\n    let executeBlock: boolean;\r\n    let blockLoopExeconServer: boolean;\r\n    let flowMonitor: FlowMonitorQueue = FlowMonitorQueue.Instance;\r\n    let routeOperationExecuted: boolean = false;\r\n\r\n    if (!inReturnedFromServer) {\r\n      // we need to check if the server already started running this handler\r\n      oper = this._operationTab.getOperation(execFlowIdx);\r\n      nextOperIdx = AccessHelper.eventsManager.getNextOperIdx(oper, true);\r\n      if (nextOperIdx > -1) {\r\n        returnedFromServer = true;\r\n        if (inBlockIf)\r\n          blockIfReturnedFromServer = true;\r\n      }\r\n      else returnedFromServer = false;\r\n    }\r\n    else {\r\n      returnedFromServer = inReturnedFromServer;\r\n      nextOperIdx = inNextOperIdx;\r\n    }\r\n\r\n    for (; execFlowIdx <= toIdx &&\r\n           (!AccessHelper.eventsManager.GetStopExecutionFlag()) &&\r\n           !mgd.IsAborting && !routeOperationExecuted;\r\n           execFlowIdx += 1) {\r\n      if (inBlockIf && blockIfReturnedFromServer && this._operationTab.getOperation(toIdx).getServerId() < nextOperIdx)\r\n        break;\r\n\r\n      oper = this._operationTab.getOperation(execFlowIdx);\r\n\r\n      operType = oper.getType();\r\n\r\n      blockIfReturnedFromServer = false;\r\n\r\n      // If DelayCommandExecution = true, it means we are here TS of closing task.\r\n      // So, set first operation of handler as server. return back.\r\n      if (RemoteCommandsProcessor.GetInstance().DelayCommandExecution) {\r\n        this._task.setUseLoopStack(depth > 0);\r\n        await oper.operServer(null);\r\n        break;\r\n      }\r\n\r\n      // skip to the correct operation after returning from the server\r\n      if (returnedFromServer && oper.getServerId() < nextOperIdx)\r\n        if (operType !== ConstInterface.MG_OPER_BLOCK)\r\n          continue;\r\n        else if (this._operationTab.getOperation(oper.getBlockEnd()).getServerId() < nextOperIdx)\r\n          continue;\r\n\r\n      if (!taskEnd)\r\n      {\r\n        let mainLevel: string  = this._task.getMainLevel().toLowerCase();\r\n        if(await this._task.evalEndCond(ConstInterface.END_COND_EVAL_IMMIDIATE) && Environment.Instance.getSpecialImmediateHandlerEnd() &&\r\n           mainLevel != \"RP\".toLowerCase()  && mainLevel != \"TP\".toLowerCase() && mainLevel != \"RS\".toLowerCase() && mainLevel != \"TS\".toLowerCase())\r\n            break;\r\n     }\r\n\r\n      if (this._taskMgdID !== mgdID)\r\n        isChangedCurrWndRef.value = true;\r\n\r\n      if (!this._task.isMainProg() && this._task.isOpenWin())\r\n        AccessHelper.mgDataTable.currMgdID = this._taskMgdID;\r\n\r\n      await AccessHelper.eventsManager.CheckAndShowSpinner(true);\r\n\r\n      switch (operType) {\r\n        case ConstInterface.MG_OPER_VERIFY:\r\n          // if true returned then the verify condition was true and the mode is Error\r\n          if (await oper.execute(returnedFromServer)) {\r\n            if (!(this._task.getBrkLevel() === \"TS\")) {\r\n              AccessHelper.eventsManager.setStopExecution(true);\r\n\r\n            }\r\n\r\n            if (this._task.getInRecordSuffix() && this._task.getLevel() === Constants.TASK_LEVEL_TASK)\r\n              this._task.setLevel(Constants.TASK_LEVEL_RECORD);\r\n            // QCR #995108 - verify error in RS shouldn't trigger RP\r\n            /*\r\n             * if we are in the revert mode, dont stop immediately.\r\n             * execute the operations of the handler in the reverse order and then stop.\r\n             */\r\n            return new RetVals(false, true);\r\n          }\r\n          break;\r\n\r\n        case ConstInterface.MG_OPER_LOOP:\r\n          // on getting a BlockLoop, execute the loop for the number of times intended,\r\n          // and then move to BlockEnd.\r\n          this._task.enterLoop();\r\n          this._task.increaseLoopCounter();\r\n          this._task.setUseLoopStack(true);\r\n\r\n          await flowMonitor.addFlowFieldOperation(oper, true, this._task.GetTaskDetails());\r\n\r\n          blockLoopExeconServer = false;\r\n          if (!oper.getExecOnServer()) {\r\n            // execute the loop for the number of times intended\r\n            while (await oper.execute(false)) {\r\n              // call executeOperations() to execute the operations within a BlockLoop\r\n              retvals = await this.executeOperations(execFlowIdx + 1, oper.getBlockClose() - 1, taskEnd, mgdID, depth + 1,\r\n                isChangedCurrWndRef, false, false, -1);\r\n              if (retvals !== null)\r\n                return retvals;\r\n\r\n              // if we get a revert inside a loop, break the loop\r\n              if ((mgd.IsAborting || AccessHelper.eventsManager.GetStopExecutionFlag()))\r\n                break;\r\n\r\n              this._task.increaseLoopCounter();\r\n              this._task.setUseLoopStack(true);\r\n            }\r\n          }\r\n          else {\r\n            if (await oper.execute(false))\r\n              blockLoopExeconServer = true;\r\n          }\r\n          if (!blockLoopExeconServer)\r\n          /*\r\n           * Once we finish executing the loop,\r\n           * if we are moving in the forward direction, move to BlockEnd.\r\n           */\r\n            execFlowIdx = oper.getBlockEnd() - 1;\r\n          this._task.leaveLoop();\r\n          break;\r\n\r\n        case ConstInterface.MG_OPER_BLOCK:\r\n          // on getting a Block IF, execute the executable block (if or else)\r\n          // and then move to BlockEnd.\r\n          if (!oper.getExecOnServer() || (returnedFromServer && oper.getServerId() < nextOperIdx)) {\r\n            this._task.setUseLoopStack(true);\r\n            if (!returnedFromServer || oper.getServerId() >= nextOperIdx)\r\n            // get the executable block between Block IF and Block END\r\n              execFlowIdx = await this.getSignificantBlock(execFlowIdx, oper.getBlockEnd());\r\n            else\r\n              execFlowIdx = this.getStartBlockIfIdxByOper(execFlowIdx, nextOperIdx);\r\n          }\r\n          else {\r\n            this._task.setUseLoopStack(depth > 0);\r\n            await oper.operServer(null);\r\n            nextOperIdx = AccessHelper.eventsManager.getNextOperIdx(oper, true);\r\n            if (nextOperIdx > -1) {\r\n              returnedFromServer = true;\r\n              if (inBlockIf)\r\n                blockIfReturnedFromServer = true;\r\n\r\n              if (nextOperIdx < this._operationTab.getOperation(oper.getBlockEnd()).getServerId()) {\r\n                // find the significant block in which the next operation is\r\n                while (this._operationTab.getOperation(oper.getBlockClose()).getServerId() < nextOperIdx) {\r\n                  execFlowIdx = oper.getBlockClose();\r\n                  oper = this._operationTab.getOperation(execFlowIdx);\r\n                }\r\n              }\r\n            }\r\n            else {\r\n              returnedFromServer = false;\r\n              execFlowIdx = -1;\r\n            }\r\n          }\r\n          if (execFlowIdx !== -1) {\r\n            executeBlock = true;\r\n            oper = this._operationTab.getOperation(execFlowIdx);\r\n\r\n            if (returnedFromServer) {\r\n              if (this._operationTab.getOperation(oper.getBlockClose()).getServerId() <= nextOperIdx) {\r\n                executeBlock = false;\r\n                blockIfReturnedFromServer = true;\r\n              }\r\n            }\r\n\r\n            if (executeBlock) {\r\n              // call executeOperations() to execute the operations in the executable block\r\n              retvals = await this.executeOperations(execFlowIdx + 1, oper.getBlockClose() - 1, taskEnd, mgdID, depth + 1,\r\n                isChangedCurrWndRef, true, returnedFromServer, nextOperIdx);\r\n              if (retvals !== null)\r\n                if (!retvals.ReturnedFromServer)\r\n                  return retvals;\r\n                else {\r\n                  returnedFromServer = retvals.ReturnedFromServer;\r\n                  nextOperIdx = retvals.NextOperIdx;\r\n                  blockIfReturnedFromServer = retvals.BlockIfReturnedFromServer;\r\n                  execFlowIdx = oper.getBlockEnd() - 1;\r\n                  continue;\r\n                }\r\n            }\r\n          }\r\n\r\n          /*\r\n           * Once we finish executing the block,\r\n           * if we are moving in the forward direction, move to BlockEnd.\r\n           * otherwise, move to Block IF\r\n           */\r\n          execFlowIdx = oper.getBlockEnd() - 1;\r\n          break;\r\n\r\n        case ConstInterface.MG_OPER_ENDBLOCK:\r\n          await flowMonitor.addFlowFieldOperation(oper, true, this._task.GetTaskDetails());\r\n          break;\r\n\r\n        case ConstInterface.MG_OPER_CALL:\r\n          this._task.setUseLoopStack(depth > 0);\r\n          // if false is returned, it means that a route operation was executed.\r\n          routeOperationExecuted = await oper.execute(returnedFromServer);\r\n          break;\r\n\r\n        default:\r\n          // the rest of the operations (those that do not affect the flow)\r\n          this._task.setUseLoopStack(depth > 0);\r\n          await oper.execute(returnedFromServer);\r\n          break;\r\n      }\r\n\r\n      // if the server have executed a block of operations then get the next\r\n      // operation index\r\n      if (!blockIfReturnedFromServer) {\r\n        nextOperIdx = AccessHelper.eventsManager.getNextOperIdx(oper, true);\r\n        if (nextOperIdx > -1) {\r\n          returnedFromServer = true;\r\n          if (inBlockIf)\r\n            blockIfReturnedFromServer = true;\r\n        }\r\n        else returnedFromServer = false;\r\n      }\r\n\r\n    }\r\n\r\n    if (routeOperationExecuted)\r\n      retvals = new RetVals(false, true);\r\n    else if (blockIfReturnedFromServer)\r\n      retvals = new RetVals(nextOperIdx, returnedFromServer, blockIfReturnedFromServer);\r\n    else\r\n      retvals = null;\r\n    return retvals;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the executable Block (IF or ELSE)\r\n  /// </summary>\r\n  /// <param name = \"startBlockIdx\">the index of the Block IF</param>\r\n  /// <param name = \"endIdx\">the Block End Index of the Block IF</param>\r\n  /// <returns>The index of the block (IF or ELSE or next ELSE ...)that can be executed.\r\n  ///   If no blocks can be executed, return -1\r\n  /// </returns>\r\n  private async getSignificantBlock(startBlockIdx: number, endIdx: number): Promise<number> {\r\n    let retIdx: number = -1;\r\n\r\n    while (startBlockIdx < endIdx) {\r\n      let oper: Operation = this._operationTab.getOperation(startBlockIdx);\r\n      let operType: number = oper.getType();\r\n\r\n      if (operType !== ConstInterface.MG_OPER_BLOCK && operType !== ConstInterface.MG_OPER_ELSE && operType !== ConstInterface.MG_OPER_SERVER)\r\n        break;\r\n\r\n      if (await oper.execute(false)) {\r\n        retIdx = startBlockIdx;\r\n        break;\r\n      }\r\n      else\r\n        startBlockIdx = oper.getBlockClose();\r\n    }\r\n    return retIdx;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the idx of the Block IF\r\n  /// </summary>\r\n  /// <param name = \"endIdx\">--- the index of the Block End\r\n  /// </param>\r\n  /// <returns> --- The index of the block IF whose BlockEnd Idx matches with the endIdx\r\n  /// </returns>\r\n  private getStartBlockIdxByEnd(endIdx: number): number {\r\n    let retIdx: number = -1;\r\n    let found: boolean = false;\r\n    let j: number;\r\n    for (j = endIdx - 1; j >= 0 && !found; j--) {\r\n      let oper: Operation = this._operationTab.getOperation(j);\r\n      let operType: number = oper.getType();\r\n\r\n      if (operType === ConstInterface.MG_OPER_BLOCK || operType === ConstInterface.MG_OPER_LOOP) {\r\n        if (oper.getBlockEnd() === endIdx) {\r\n          retIdx = j;\r\n          found = true;\r\n        }\r\n      }\r\n    }\r\n    return retIdx;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   get the idx of the Block IF\r\n  /// </summary>\r\n  /// <param name = \"elseIdx\">--- the index of the Block Else\r\n  /// </param>\r\n  /// <returns> --- The index of the block IF whose BlockEnd Idx matches with the endIdx\r\n  /// </returns>\r\n  private getStartBlockIdxByElse(elseIdx: number): number {\r\n    let retIdx: number = -1;\r\n    let found: boolean = false;\r\n    let elseBlockEnd: number = this._operationTab.getOperation(elseIdx).getBlockEnd();\r\n    let j: number;\r\n    for (j = elseIdx - 1; j >= 0 && !found; j--) {\r\n      let oper: Operation = this._operationTab.getOperation(j);\r\n      let operType: number = oper.getType();\r\n\r\n      if (operType === ConstInterface.MG_OPER_BLOCK) {\r\n        if (oper.getBlockEnd() === elseBlockEnd) {\r\n          retIdx = j;\r\n          found = true;\r\n        }\r\n      }\r\n    }\r\n    return retIdx;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the index of the Block IF or Else according to the index of one of the of operations in it\r\n  /// </summary>\r\n  /// <param name = \"blockOperIdx\">--- index of the if block for which we have to find the appropriate block to execute\r\n  /// </param>\r\n  /// <param name = \"srvrOperIdx\">--- the server id of the next operation which the client should execute\r\n  /// </param>\r\n  /// <returns> --- The index of the block IF or Else which hold the operation which operIdx is its index\r\n  /// </returns>\r\n  private getStartBlockIfIdxByOper(blockOperIdx: number, srvrOperIdx: number): number {\r\n    let retIdx: number = -1;\r\n    let found: boolean = false;\r\n    let j: number = this._operationTab.serverId2operIdx(srvrOperIdx, blockOperIdx) - 1;\r\n\r\n    if (j === -2) {\r\n      j = this._operationTab.serverId2FollowingOperIdx(srvrOperIdx, blockOperIdx) - 1;\r\n    }\r\n\r\n    while (j >= 0 && !found) {\r\n      let oper: Operation = this._operationTab.getOperation(j);\r\n      let operType: number = oper.getType();\r\n      if (operType === ConstInterface.MG_OPER_BLOCK) {\r\n        if (j === blockOperIdx) {\r\n          retIdx = j;\r\n          found = true;\r\n        }\r\n        else\r\n          j--;\r\n      }\r\n      else if (operType === ConstInterface.MG_OPER_ELSE) {\r\n        let blockStrt: number = this.getStartBlockIdxByElse(j);\r\n        if (blockStrt === blockOperIdx) {\r\n          retIdx = j;\r\n          found = true;\r\n        }\r\n        else\r\n          j = blockStrt - 1;\r\n      }\r\n      else if (operType === ConstInterface.MG_OPER_ENDBLOCK)\r\n        j = this.getStartBlockIdxByEnd(j) - 1;\r\n      else\r\n        j--;\r\n    }\r\n    return retIdx;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   get the level\r\n  /// </summary>\r\n  getLevel(): string {\r\n    return this._level;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the event of this handler\r\n  /// </summary>\r\n  getEvent(): Event {\r\n    return this._evt;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the Id of the event handler\r\n  /// </summary>\r\n  getId(): number {\r\n    return this._id;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if the handler is enabled\r\n  /// </summary>\r\n  async isEnabled(): Promise<boolean> {\r\n    return await this._enabledExp.getVal();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   reset the values of the local variables using the argument values or the default\r\n  ///   values or the init expression\r\n  /// </summary>\r\n  /// <param name = \"args\">the arguments list </param>\r\n  private async resetLocalVariables(args: ArgumentsList): Promise<void> {\r\n    let dv: DataView = <DataView>this._task.DataView;\r\n    let argIdx: number = 0;\r\n\r\n    try {\r\n      for (let fieldIdx: number = this._dvPos; fieldIdx < this._dvPos + this._dvLen; fieldIdx++) {\r\n        let aField: FieldBase = <FieldBase>dv.getField(fieldIdx);\r\n        let varIsParm: boolean = !this._hasParameters || aField.isParam();\r\n\r\n        // check if the field should get its value from an argument\r\n        if ((args !== null && argIdx < args.getSize()) && varIsParm) {\r\n          if (!args.getArg(argIdx).skipArg()) {\r\n            await args.getArg(argIdx).setValueToField(aField);\r\n          }\r\n          else {\r\n            aField.invalidate(true, FieldBase.CLEAR_FLAGS);\r\n            await aField.compute(false);\r\n          }\r\n          argIdx++;\r\n        }\r\n        else {\r\n          aField.invalidate(true, FieldBase.CLEAR_FLAGS);\r\n          await aField.compute(false);\r\n        }\r\n        await aField.updateDisplay();\r\n      }\r\n    }\r\n    catch (exception) {\r\n      throw exception;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the result values to the field arguments\r\n  /// </summary>\r\n  /// <param name = \"args\">the arguments list </param>\r\n  private async getArgValsFromFlds(args: ArgumentsList): Promise<void> {\r\n    let dv: DataView = <DataView>this._task.DataView;\r\n    let k: number = 0;\r\n    let j: number;\r\n\r\n    for (j = this._dvPos; j < this._dvPos + this._dvLen && k < args.getSize(); j++) {\r\n      let aField: FieldBase = <FieldBase>dv.getField(j);\r\n      if (!this._hasParameters || aField.isParam()) {\r\n        let arg: Argument = args.getArg(k);\r\n        if (arg.getType() === ConstInterface.ARG_TYPE_FIELD) {\r\n          // update the field value from the the Param\r\n          let argFld: FieldBase = <FieldBase>arg.getField();\r\n\r\n          // A handler can be called either from the same task (of the handler) or from a\r\n          // task lower down in the hierarchy.\r\n          // Here we are copying value from the handler task to the invoker task.\r\n          // Copying should not be done if any one of the task is aborting.\r\n          // But checking only the invoker task's isAborting is sufficient here because,\r\n          // it will be true even if the handler task is aborting.\r\n          if (argFld.getTask() !== null && !(<Task>argFld.getTask()).isAborting()) {\r\n            let val: string = aField.getValue(false);\r\n            await argFld.setValueAndStartRecompute(val, aField.isNull(), true, aField.isModified(), false);\r\n            await argFld.updateDisplay();\r\n          }\r\n        }\r\n        k++;\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the handler's task\r\n  /// </summary>\r\n  getTask(): Task {\r\n    return this._task;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the number of parameters expected by the handler\r\n  /// </summary>\r\n  argsMatch(Exp_params: ExpVal[]): boolean {\r\n    let argsMatched: boolean = true;\r\n    let dv: DataView = <DataView>this._task.DataView;\r\n    let j: number = 0;\r\n    let paramCount: number = 0;\r\n\r\n    for (let i: number = this._dvPos; i < this._dvPos + this._dvLen; i++) {\r\n      let field: FieldBase = <FieldBase>dv.getField(i);\r\n      if (field.isParam()) {\r\n        paramCount++;\r\n        if (j < Exp_params.length) {\r\n          let fieldAttr: StorageAttribute = field.getType();\r\n          let argAttr: StorageAttribute = Exp_params[j].Attr;\r\n\r\n\r\n          // argument and parameter will not match if :\r\n          // 1. They are not of the same type\r\n          // 2. They Cannot be cast (alpha can be cast to unicode)\r\n          // 3. All those apply if the parameter is not null. if the param val is null it can go into any type of parameter.\r\n          if (!Exp_params[j].IsNull && !StorageAttributeCheck.isTheSameType(fieldAttr, argAttr) && !StorageAttributeCheck.StorageFldAlphaUnicodeOrBlob(fieldAttr, argAttr)) {\r\n            argsMatched = false;\r\n            break;\r\n          }\r\n          j++;\r\n        }\r\n      }\r\n    }\r\n\r\n    if (paramCount !== Exp_params.length) {\r\n      argsMatched = false;\r\n    }\r\n    return argsMatched;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the OperationTable\r\n  /// </summary>\r\n  getOperationTab(): OperationTable {\r\n    return this._operationTab;\r\n  }\r\n\r\n  /// <summary>\r\n  /// In case of Control headers, return control name\r\n  /// </summary>\r\n  getControlNameForControlHeader(): string {\r\n    if(this.getEvent().getType() == ConstInterface.EVENT_TYPE_INTERNAL) {\r\n\r\n      // Return the control name for Control Headers\r\n      if (this.getEvent().isControlHeader() && !isNullOrUndefined(this._ctrl))\r\n        return this.getCtrlName();\r\n    }\r\n    return NString.Empty;\r\n  }\r\n\r\n  /// <summary>\r\n  /// In case of Variable headers, return field name\r\n  /// </summary>\r\n  getVarNameForVariableHeader(): string {\r\n    // Return the Field name for Variable Headers\r\n   if (this.getEvent().isVariableHeader() && !isNullOrUndefined(this._handlerFld))\r\n      return this._handlerFld.getVarName().toUpperCase();\r\n\r\n   return NString.Empty;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Return the event handler information to be displayed in case of 'RequestInfo' log level\r\n  /// </summary>\r\n  getEventHandlerInfo(): string {\r\n    let eventDescription: StringBuilder = new StringBuilder();\r\n\r\n    this.getEvent().AppendDescription(eventDescription);\r\n\r\n    // Append control/variable name in Control/Variable headers\r\n    let headerAdditionalInfo: string = this.getControlNameForControlHeader() + this.getVarNameForVariableHeader();\r\n\r\n    eventDescription.Append(headerAdditionalInfo);\r\n\r\n    // For some headers like RP/TP, the event description is empty.\r\n    // For others empty space should be added between event type and description.\r\n    // This is done to avoid unnecessary blank space at the end of the event handler type\r\n    if(!NString.IsNullOrEmpty(eventDescription.toString()))\r\n      eventDescription = new StringBuilder(' ' + eventDescription.toString(), eventDescription.toString().length + 1);\r\n\r\n    return NString.Format(\"Handler {0}{1}\", this.getEvent().getEventType(), eventDescription);\r\n  }\r\n\r\n\r\n  toString(): string {\r\n    return NString.Format(\"(Handler for {0} on task {1}, scope {2})\", this._evt, this._task, this._scope);\r\n  }\r\n}\r\n\r\n/// <summary>\r\n///   used to return the results of the execute() method\r\n/// </summary>\r\nexport class RetVals  {\r\n  BlockIfReturnedFromServer: boolean = false;\r\n  Enabled: boolean = false;\r\n  NextOperIdx: number = 0;\r\n  Propagate: boolean = false;\r\n  ReturnedFromServer: boolean = false;\r\n\r\n  constructor(p: boolean, e: boolean);\r\n  constructor(operIdx: number, inReturnedFromServer: boolean, inBlockIfReturnedFromServer: boolean);\r\n  constructor(pOrOperIdx: any, eOrInReturnedFromServer: boolean, inBlockIfReturnedFromServer?: boolean) {\r\n    if (arguments.length === 2)\r\n      this.constructor_0(pOrOperIdx, eOrInReturnedFromServer);\r\n    else\r\n      this.constructor_1(pOrOperIdx, eOrInReturnedFromServer, inBlockIfReturnedFromServer);\r\n  }\r\n\r\n\r\n  /// <param name = \"p\">propagate </param>\r\n  /// <param name = \"e\">enabled </param>\r\n  private constructor_0(p: boolean, e: boolean): void {\r\n    this.Propagate = p;\r\n    this.Enabled = e;\r\n    this.NextOperIdx = 0;\r\n    this.ReturnedFromServer = false;\r\n    this.BlockIfReturnedFromServer = false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"operIdx\"></param>\r\n  /// <param name=\"inReturnedFromServer\"></param>\r\n  /// <param name=\"inBlockIfReturnedFromServer\"></param>\r\n  private constructor_1(operIdx: number, inReturnedFromServer: boolean, inBlockIfReturnedFromServer: boolean): void {\r\n    this.Propagate = false;\r\n    this.Enabled = true;\r\n    this.NextOperIdx = operIdx;\r\n    this.ReturnedFromServer = inReturnedFromServer;\r\n    this.BlockIfReturnedFromServer = inBlockIfReturnedFromServer;\r\n  }\r\n}\r\n\r\n"]}