@magic-xpa/engine 4.801.0-dev481.243 → 4.801.0-dev481.249

package/esm2020/src/rt/Operation.mjs

@@ -0,0 +1,745 @@
+import { ApplicationException, Debug, Int32, NNumber, NString, Thread } from '@magic-xpa/mscorelib';
+import { CallOsShow, Constants, Logger, StorageAttribute, StorageAttributeCheck, StrUtil, UtilStrByteMode, XMLConstants, XmlParser } from '@magic-xpa/utils';
+import { Commands, NUM_TYPE, PropInterface, Styles, TaskDefinitionIdTableSaxHandler, VectorType } from '@magic-xpa/gui';
+import { YesNoExp } from '../exp/YesNoExp';
+import { ArgumentsList } from './ArgumentsList';
+import { RunTimeEvent } from '../event/RunTimeEvent';
+import { CommandFactory } from '../commands/ClientToServer/CommandFactory';
+import { FlowMonitorQueue } from '../util/FlowMonitorQueue';
+import { ExecOperCommand } from '../commands/ClientToServer/ExecOperCommand';
+import { ConstInterface } from '../ConstInterface';
+import { FlowMonitorInterface } from '../FlowMonitorInterface';
+import { LanguageData } from '../env/LanguageData';
+import { LastFocusedManager } from './LastFocusedManager';
+import { AccessHelper } from '../AccessHelper';
+import { GUIManager } from "../GUIManager";
+export class Operation {
+    constructor() {
+        this._condExp = new YesNoExp(true);
+        this._retainFocus = new YesNoExp(false);
+        this._waitExp = new YesNoExp(false);
+        this._syncData = new YesNoExp(false);
+        this._argList = null;
+        this._blockClose = 0;
+        this._blockEnd = 0;
+        this._buttons = '\0';
+        this._checkByServer = false;
+        this._cmdToServer = null;
+        this._display = 'S';
+        this._errLogAppend = false;
+        this._evtHandler = null;
+        this._execOnServer = false;
+        this._execOnClient = false;
+        this._exp = null;
+        this._field = null;
+        this._globalParamsShouldBeCopied = false;
+        this._image = '\0';
+        this._incremental = false;
+        this._methodNameSnippet = null;
+        this._mode = '\0';
+        this._prgDescription = null;
+        this._publicName = null;
+        this._returnVal = null;
+        this._rtEvt = null;
+        this._serverId = -1;
+        this.calledTaskDefinitionId = null;
+        this._show = CallOsShow.Normal;
+        this._subformCtrlName = null;
+        this._subtype = '\0';
+        this._task = null;
+        this._text = null;
+        this._title = null;
+        this._titleExp = null;
+        this._type = 0;
+        this._undo = true;
+        this._isRoute = false;
+        this._routerPath = null;
+        this._originalRouterOutletName = null;
+        this._routeParams = null;
+        this.OperCallMode = 0;
+    }
+    get CalledTaskDefinitionId() {
+        return this.calledTaskDefinitionId;
+    }
+    set Task(value) {
+        this._task = value;
+    }
+    get Task() {
+        return this._task;
+    }
+    async Immediate() {
+        return await this._waitExp.getVal();
+    }
+    fillData(taskRef, evtHandler, parser) {
+        this._task = taskRef;
+        this._evtHandler = evtHandler;
+        while (this.initInnerObjects(parser, parser.getNextTag(), taskRef)) {
+        }
+    }
+    initInnerObjects(parser, foundTagName, taskRef) {
+        if (foundTagName === null)
+            return false;
+        if (foundTagName === ConstInterface.MG_TAG_EVENT) {
+            this._rtEvt = new RunTimeEvent(taskRef);
+            this._rtEvt.fillData(parser, taskRef);
+        }
+        else if (foundTagName === ConstInterface.MG_TAG_OPER) {
+            this.fillAttributes(parser, taskRef);
+        }
+        else if (foundTagName === "/" + ConstInterface.MG_TAG_OPER) {
+            parser.setCurrIndex2EndOfTag();
+            return false;
+        }
+        else if (foundTagName === XMLConstants.MG_TAG_TASKDEFINITIONID_ENTRY) {
+            this.InitTaskDefinitionID(parser);
+        }
+        else {
+            Logger.Instance.WriteExceptionToLogWithMsg("There is no such tag in Operation. Insert else if to Operation.initInnerObjects for " + foundTagName);
+            return false;
+        }
+        return true;
+    }
+    fillAttributes(parser, taskRef) {
+        let tokensVector;
+        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_OPER) + ConstInterface.MG_TAG_OPER.length);
+            tokensVector = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);
+            this.initElements(tokensVector, taskRef);
+            parser.setCurrIndex(endContext + XMLConstants.TAG_CLOSE.length);
+            return;
+        }
+        Logger.Instance.WriteExceptionToLogWithMsg("in Command.FillData() out of string bounds");
+    }
+    initElements(tokensVector, taskRef) {
+        let attribute, valueStr;
+        let expId;
+        let isGuiThreadExecution = false;
+        for (let j = 0; j < tokensVector.length; j += 2) {
+            attribute = (tokensVector.get_Item(j));
+            valueStr = (tokensVector.get_Item(j + 1));
+            switch (attribute) {
+                case XMLConstants.MG_ATTR_TYPE:
+                    this._type = XmlParser.getInt(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_FLD:
+                    this._field = Operation.InitField(valueStr, this._task);
+                    break;
+                case XMLConstants.MG_ATTR_EXP:
+                    expId = XmlParser.getInt(valueStr);
+                    this._exp = taskRef.getExpById(expId);
+                    break;
+                case ConstInterface.MG_ATTR_TEXT:
+                    this._text = XmlParser.unescape(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_MODE:
+                    this._mode = valueStr[0];
+                    break;
+                case ConstInterface.MG_ATTR_SUBTYPE:
+                    this._subtype = valueStr[0];
+                    if (this._type === ConstInterface.MG_OPER_BLOCK) {
+                        if (this._subtype === 'E')
+                            this._type = ConstInterface.MG_OPER_ELSE;
+                        else if (this._subtype === 'L')
+                            this._type = ConstInterface.MG_OPER_LOOP;
+                    }
+                    break;
+                case ConstInterface.MG_ATTR_CLOSE:
+                    this._blockClose = XmlParser.getInt(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_END:
+                    this._blockEnd = XmlParser.getInt(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_HOW:
+                    this._incremental = (valueStr === "I");
+                    break;
+                case ConstInterface.MG_ATTR_UNDO:
+                    if (valueStr[0] === 'N')
+                        this._undo = false;
+                    else if (valueStr[0] === 'Y')
+                        this._undo = true;
+                    else
+                        Logger.Instance.WriteExceptionToLogWithMsg("in Operation.initElements(): No such value to the MG_ATTR_UNDO for " + valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_DISPLAY:
+                    this._display = valueStr[0];
+                    break;
+                case ConstInterface.MG_ATTR_WAIT:
+                    this._waitExp.setVal(taskRef, valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_RETAIN_FOCUS:
+                    this._retainFocus.setVal(taskRef, valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_SYNC_DATA:
+                    this._syncData.setVal(taskRef, valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_SHOW:
+                    this._show = XmlParser.getInt(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_CND:
+                    this._condExp.setVal(taskRef, valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_ARGLIST:
+                    this._argList = new ArgumentsList();
+                    this._argList.fillList(valueStr, this._task);
+                    break;
+                case ConstInterface.MG_ATTR_REFRESHON:
+                    this._argList.RefreshOnString = valueStr.Trim();
+                    break;
+                case ConstInterface.MG_ATTR_SERVER_ID:
+                    this._serverId = XmlParser.getInt(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_OPER_CALLMODE:
+                    this.OperCallMode = valueStr[0];
+                    break;
+                case ConstInterface.MG_ATTR_SUBFORM_CTRL:
+                    this._subformCtrlName = XmlParser.unescape(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_CHECK_BY_SERVER:
+                    this._checkByServer = XmlParser.getBoolean(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_PUBLIC:
+                    this._publicName = valueStr;
+                    break;
+                case ConstInterface.MG_ATTR_PRG_DESCRIPTION:
+                    this._prgDescription = valueStr;
+                    break;
+                case ConstInterface.MG_ATTR_CPY_GLB_PRMS:
+                    this._globalParamsShouldBeCopied = XmlParser.getBoolean(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_EXEC_ON_SERVER:
+                    this._execOnServer = XmlParser.getBoolean(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_EXEC_ON_CLIENT:
+                    this._execOnClient = XmlParser.getBoolean(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_TITLE:
+                    this._title = XmlParser.unescape(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_TITLE_EXP:
+                    expId = XmlParser.getInt(valueStr);
+                    this._titleExp = taskRef.getExpById(expId);
+                    break;
+                case ConstInterface.MG_ATTR_IMAGE:
+                    this._image = valueStr[0];
+                    break;
+                case ConstInterface.MG_ATTR_BUTTONS:
+                    this._buttons = valueStr[0];
+                    break;
+                case ConstInterface.MG_ATTR_RETURN_VAL:
+                    this._returnVal = Operation.InitField(valueStr, this._task);
+                    break;
+                case ConstInterface.MG_ATTR_ERR_LOG_APPEND:
+                    this._errLogAppend = XmlParser.getBoolean(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_OPER_METHODNAME:
+                    this._methodNameSnippet = valueStr;
+                    break;
+                case ConstInterface.MG_ATTR_IS_GUI_THREAD_EXECUTION:
+                    isGuiThreadExecution = XmlParser.getBoolean(valueStr);
+                    break;
+                case ConstInterface.MG_ATTR_IS_ROUTE:
+                    this._isRoute = XmlParser.getBoolean(valueStr);
+                    break;
+                case XMLConstants.MG_ATTR_ROUTER_PATH:
+                    this._routerPath = XmlParser.unescape(valueStr);
+                    break;
+                default:
+                    Logger.Instance.WriteExceptionToLogWithMsg("There is no such tag in Operation class. Insert case to Operation.initElements for " + attribute);
+                    break;
+            }
+        }
+        if (this._serverId > -1)
+            this._cmdToServer = CommandFactory.CreateExecOperCommand(this._task.getTaskTag(), "" + this._evtHandler.getId(), this._serverId, Int32.MinValue, null);
+        if (this._isRoute) {
+            this._originalRouterOutletName = this._subformCtrlName !== null ? this._subformCtrlName : "";
+            if (this._subformCtrlName == null) {
+                let defaultRouterOutlet = this._task.getForm().DefaultRouterOutlet;
+                this._subformCtrlName = defaultRouterOutlet !== null ? defaultRouterOutlet.Name : "";
+            }
+        }
+    }
+    InitTaskDefinitionID(parser) {
+        let xmlBuffer = parser.ReadToEndOfCurrentElement();
+        let taskDefinitionIdTableSaxHandler = new TaskDefinitionIdTableSaxHandler(this.SetTaskDefinitionId);
+        taskDefinitionIdTableSaxHandler.parse(xmlBuffer);
+    }
+    SetTaskDefinitionId(taskDefinitionId) {
+        this.calledTaskDefinitionId = taskDefinitionId;
+    }
+    static InitField(valueStr, task) {
+        let TaskField = XmlParser.getTokens(valueStr, ',');
+        if (TaskField.length === 2) {
+            let parent = NNumber.Parse(TaskField.get_Item(0));
+            let fldID = NNumber.Parse(TaskField.get_Item(1));
+            let field = task.getFieldDef(parent, fldID);
+            return field;
+        }
+        Logger.Instance.WriteExceptionToLogWithMsg(NString.Format("Unknown field: '{0}'", valueStr));
+        return null;
+    }
+    async execute(returnedFromServer) {
+        let lastRtEvent = AccessHelper.eventsManager.getLastRtEvent();
+        let mprgCreator = null;
+        let flowMonitor = FlowMonitorQueue.Instance;
+        if (lastRtEvent !== null)
+            mprgCreator = lastRtEvent.getMainPrgCreator();
+        if (returnedFromServer ||
+            (!returnedFromServer && (this._type !== ConstInterface.MG_OPER_SERVER || !this._condExp.isServerExp()))) {
+            if (!await this.canExecute()) {
+                if (this._type !== ConstInterface.MG_OPER_LOOP)
+                    await flowMonitor.addFlowFieldOperation(this, false, this._task.GetTaskDetails());
+                return false;
+            }
+        }
+        if (this._type !== ConstInterface.MG_OPER_LOOP && this._type !== ConstInterface.MG_OPER_ENDBLOCK)
+            await flowMonitor.addFlowFieldOperation(this, true, this._task.GetTaskDetails());
+        try {
+            switch (this._type) {
+                case ConstInterface.MG_OPER_VERIFY:
+                    return await this.operVerify();
+                case ConstInterface.MG_OPER_BLOCK:
+                    return this.operBlock();
+                case ConstInterface.MG_OPER_LOOP:
+                    if (!this.getExecOnServer())
+                        return this.operBlock();
+                    else {
+                        await this.operServer(mprgCreator);
+                        break;
+                    }
+                case ConstInterface.MG_OPER_ELSE:
+                    return this.operElse();
+                case ConstInterface.MG_OPER_EVALUATE:
+                    await this.operEvaluate();
+                    break;
+                case ConstInterface.MG_OPER_UPDATE:
+                    await this.operUpdate(mprgCreator);
+                    break;
+                case ConstInterface.MG_OPER_RAISE_EVENT:
+                    await this.operRaiseEvent(mprgCreator, returnedFromServer);
+                    break;
+                case ConstInterface.MG_OPER_SERVER:
+                    await this.operServer(mprgCreator);
+                    break;
+                case ConstInterface.MG_OPER_CALL:
+                    if (this._publicName != null) {
+                        this.operCallParallel();
+                    }
+                    else if (this._subformCtrlName == null)
+                        await this.operCall(mprgCreator);
+                    else {
+                        let subformTask;
+                        let isEndProg = true;
+                        if (this._checkByServer) {
+                            if (!(this._cmdToServer instanceof ExecOperCommand))
+                                Debug.Assert(false);
+                            let command = this._cmdToServer;
+                            command.CheckOnly = true;
+                            await this.operCall(mprgCreator);
+                            command.CheckOnly = false;
+                            if (AccessHelper.eventsManager.getNextOperIdx(this, true) > -1)
+                                isEndProg = false;
+                        }
+                        if (isEndProg) {
+                            let destSubForm = this._task.getForm().getSubFormCtrlByName(this._subformCtrlName);
+                            if (this._isRoute && (destSubForm === null || !destSubForm.IsRouterOutlet()))
+                                return false;
+                            if (destSubForm != null) {
+                                if (this._isRoute) {
+                                    let canRoute = false;
+                                    let rtEvnt = AccessHelper.eventsManager.getLastRtEvent();
+                                    if (rtEvnt !== null) {
+                                        this._routeParams = rtEvnt.getRouteParamList();
+                                        if ((await rtEvnt.getArgList().getArg(0).getValue(StorageAttribute.ALPHA, 0)).trim() === this._routerPath &&
+                                            ((rtEvnt.getArgList().getArg(1).skipArg()) ||
+                                                (await rtEvnt.getArgList().getArg(1).getValue(StorageAttribute.ALPHA, 0)).trim() === this._originalRouterOutletName))
+                                            canRoute = true;
+                                        if (!canRoute)
+                                            return false;
+                                    }
+                                }
+                                subformTask = destSubForm.getSubformTask();
+                                if (subformTask != null) {
+                                    let terminateTaskGracefully = true;
+                                    let rtEvnt = AccessHelper.eventsManager.getLastRtEvent();
+                                    if (this._isRoute && rtEvnt !== null && rtEvnt.isGuiTriggeredEvent()) {
+                                        terminateTaskGracefully = false;
+                                        AccessHelper.eventsManager.setStopExecution(true);
+                                    }
+                                    if (await subformTask.endTask(true, false, !terminateTaskGracefully, true)) {
+                                        let parentTask = destSubForm.getForm().getTask();
+                                        parentTask.TaskService.RemoveRecomputes(parentTask);
+                                    }
+                                    else
+                                        break;
+                                }
+                                if (LastFocusedManager.getLastFocusedControl() != null &&
+                                    LastFocusedManager.getLastFocusedControl().isDescendentOfControl(destSubForm))
+                                    this._task.RetainFocus = false;
+                                else
+                                    this._task.RetainFocus = await this._retainFocus.getVal();
+                            }
+                            await this.operCall(mprgCreator);
+                        }
+                    }
+                    return this._isRoute;
+                default:
+                    Logger.Instance.WriteExceptionToLogWithMsg("There is no such type of operation " + this._type);
+                    break;
+            }
+        }
+        catch (ex) {
+            throw ex;
+        }
+        return true;
+    }
+    operCallParallel() {
+        Operation.callParallel();
+    }
+    static callParallel() {
+    }
+    async getCondVal() {
+        return await this._condExp.getVal();
+    }
+    getType() {
+        return this._type;
+    }
+    getRouteParams() {
+        return this._routeParams;
+    }
+    getServerId() {
+        return this._serverId;
+    }
+    async operVerify() {
+        let isError = (this._mode === ConstInterface.FLW_VERIFY_MODE_ERROR);
+        let textToDisplay = this._exp === null ? this._text : await this._exp.evaluateWithResultTypeAndLength(StorageAttribute.UNICODE, 255);
+        let titleToDisplay = this._titleExp === null ? this._title : await this._titleExp.evaluateWithResultTypeAndLength(StorageAttribute.UNICODE, 255);
+        textToDisplay = textToDisplay === null ? "" : StrUtil.rtrim(textToDisplay);
+        titleToDisplay = titleToDisplay === null ? "" : StrUtil.rtrim(titleToDisplay);
+        if (this._errLogAppend) {
+            let prgDescription = this._task.GetContextTask().GetComputedProperty(PropInterface.PROP_TYPE_NAME).GetComputedValue();
+            Logger.Instance.WriteExceptionToLogWithMsg(textToDisplay + ", program : " + prgDescription);
+        }
+        if (this._display === ConstInterface.DISPLAY_STATUS) {
+            if (!NString.IsNullOrEmpty(textToDisplay)) {
+                FlowMonitorQueue.Instance.addFlowVerifyInfo(textToDisplay, this._task.GetTaskDetails());
+                this._task.GetContextTask().WriteToMessagePane(textToDisplay);
+            }
+        }
+        else {
+            if (!NString.IsNullOrEmpty(textToDisplay)) {
+                let mlsTransTextToDisplay = LanguageData.Instance.translate(textToDisplay);
+                let mlsTransTitleToDisplay = LanguageData.Instance.translate(titleToDisplay);
+                let verifyMode = Operation.getButtons(this._buttons);
+                verifyMode = verifyMode || Operation.getImage(this._image);
+                verifyMode = verifyMode;
+                if (UtilStrByteMode.isLocaleDefLangJPN()) {
+                    let delimPos = mlsTransTextToDisplay.indexOf('|');
+                    if (0 <= delimPos && delimPos < mlsTransTextToDisplay.length) {
+                        mlsTransTitleToDisplay = mlsTransTextToDisplay.substr(delimPos + 1);
+                        mlsTransTextToDisplay = mlsTransTextToDisplay.substr(0, delimPos);
+                    }
+                }
+                let mgForm = null;
+                if (!this._task.GetContextTask().getMGData().IsAborting)
+                    mgForm = this._task.GetContextTask().getTopMostForm();
+                if (mgForm == null && LastFocusedManager.Instance.getLastFocusedTask() != null)
+                    mgForm = LastFocusedManager.Instance.getLastFocusedTask().getTopMostForm();
+                if (mgForm != null) {
+                    mgForm.RefreshUI();
+                    Commands.invoke();
+                    await Thread.Sleep(10);
+                }
+                let returnValue = await GUIManager.Instance.MessageBox(mlsTransTitleToDisplay, mlsTransTextToDisplay, verifyMode);
+                await Operation.setoperVerifyReturnValue(returnValue, this._returnVal);
+            }
+        }
+        return isError;
+    }
+    static getButtons(buttonsID) {
+        let tmpbuttons = 0;
+        switch (buttonsID) {
+            case ConstInterface.BUTTONS_OK:
+                tmpbuttons = Styles.MSGBOX_BUTTON_OK;
+                break;
+            case ConstInterface.BUTTONS_OK_CANCEL:
+                tmpbuttons = Styles.MSGBOX_BUTTON_OK_CANCEL;
+                break;
+            case ConstInterface.BUTTONS_ABORT_RETRY_IGNORE:
+                tmpbuttons = Styles.MSGBOX_BUTTON_ABORT_RETRY_IGNORE;
+                break;
+            case ConstInterface.BUTTONS_YES_NO_CANCEL:
+                tmpbuttons = Styles.MSGBOX_BUTTON_YES_NO_CANCEL;
+                break;
+            case ConstInterface.BUTTONS_YES_NO:
+                tmpbuttons = Styles.MSGBOX_BUTTON_YES_NO;
+                break;
+            case ConstInterface.BUTTONS_RETRY_CANCEL:
+                tmpbuttons = Styles.MSGBOX_BUTTON_RETRY_CANCEL;
+                break;
+            default:
+                break;
+        }
+        return tmpbuttons;
+    }
+    static getImage(imageID) {
+        let tmpImage = 0;
+        switch (imageID) {
+            case ConstInterface.IMAGE_EXCLAMATION:
+                tmpImage = Styles.MSGBOX_ICON_EXCLAMATION;
+                break;
+            case ConstInterface.IMAGE_CRITICAL:
+                tmpImage = Styles.MSGBOX_ICON_ERROR;
+                break;
+            case ConstInterface.IMAGE_QUESTION:
+                tmpImage = Styles.MSGBOX_ICON_QUESTION;
+                break;
+            case ConstInterface.IMAGE_INFORMATION:
+                tmpImage = Styles.MSGBOX_ICON_INFORMATION;
+                break;
+            default:
+                break;
+        }
+        return tmpImage;
+    }
+    static async setoperVerifyReturnValue(returnValue, returnVal) {
+        if (returnVal !== null) {
+            let retValueNum = new NUM_TYPE();
+            retValueNum.NUM_4_LONG(returnValue);
+            let returnValueStr = retValueNum.toXMLrecord();
+            await returnVal.setValueAndStartRecompute(returnValueStr, false, true, true, false);
+            await returnVal.updateDisplay();
+        }
+    }
+    operBlock() {
+        return true;
+    }
+    operElse() {
+        return true;
+    }
+    async operEvaluate() {
+        let result = '\0';
+        if (this._field !== null) {
+            result = await this._exp.evaluateWithResultTypeAndLength(this._field.getType(), this._field.getSize());
+            await this._field.setValueAndStartRecompute(result, result === null, true, true, false);
+            await this._field.updateDisplay();
+        }
+        else
+            result = await this._exp.evaluateWithResultTypeAndLength(StorageAttribute.BOOLEAN, 0);
+    }
+    async operUpdate(mprgCreator) {
+        let result, oldVal, newVal, fieldVal;
+        let setRecordUpdated;
+        let recompute;
+        let nOld, nNew, nResult;
+        let flowMonitor = FlowMonitorQueue.Instance;
+        flowMonitor.addFlowOperationUpdate(FlowMonitorInterface.FLWMTR_START, this._task.GetTaskDetails());
+        if (!this._field.DbModifiable && (this._task.getMode() !== Constants.TASK_MODE_CREATE)) {
+            if (!await this.CanModify(mprgCreator))
+                return;
+        }
+        let fieldType = this._field.getType();
+        if (this._incremental) {
+            if (!this._field.IsLinkField) {
+                fieldVal = this._field.getValue(true);
+                nResult = (fieldVal != null
+                    ? new NUM_TYPE(fieldVal)
+                    : null);
+                if (this._task.getMode() !== Constants.TASK_MODE_CREATE) {
+                    this._task.setEvalOldValues(true);
+                    oldVal = (this._field.isNull()
+                        ? this._field.getMagicDefaultValue()
+                        : await this._exp.evaluateWithResultTypeAndLength(fieldType, this._field.getSize()));
+                    this._task.setEvalOldValues(false);
+                    nOld = new NUM_TYPE(oldVal);
+                    nResult = NUM_TYPE.sub(nResult, nOld);
+                }
+                if (this._task.getMode() !== Constants.TASK_MODE_DELETE) {
+                    newVal = await this._exp.evaluateWithResultTypeAndLength(fieldType, this._field.getSize());
+                    if (newVal != null) {
+                        nNew = new NUM_TYPE(newVal);
+                        nResult = NUM_TYPE.add(nResult, nNew);
+                    }
+                    else
+                        nNew = nResult = null;
+                }
+                if (nResult != null)
+                    result = nResult.toXMLrecord();
+                else
+                    result = this._field.getMagicDefaultValue();
+            }
+            else {
+                await this.operServer(mprgCreator);
+                return;
+            }
+        }
+        else
+            result = await this._exp.evaluateWithResultTypeAndLength(fieldType, this._field.getSize());
+        if (fieldType === StorageAttribute.BLOB_VECTOR)
+            if (result != null)
+                result = Operation.operUpdateVectors(this._field, result);
+        recompute = (this._field.getTask() === this._task);
+        setRecordUpdated = (!recompute || !this._undo);
+        await this._field.setValueAndStartRecompute(result, result == null, true, setRecordUpdated, false);
+        if (!this._undo)
+            this._field.setUpdated();
+        this._field.setModified();
+        await this._field.updateDisplay();
+        flowMonitor.addFlowOperationUpdate(FlowMonitorInterface.FLWMTR_END, this._task.GetTaskDetails());
+    }
+    async CanModify(mprgCreator) {
+        let execOperCommand = ((this._cmdToServer instanceof ExecOperCommand) ? this._cmdToServer : null);
+        execOperCommand.Operation = this;
+        execOperCommand.MprgCreator = mprgCreator;
+        return (await this.Task.DataviewManager.Execute(this._cmdToServer)).Success;
+    }
+    static operUpdateVectors(field, vec) {
+        let result = null;
+        if (field.getType() === StorageAttribute.BLOB_VECTOR) {
+            let cellsAttr = VectorType.getCellsAttr(vec);
+            let cellsType = field.getCellsType();
+            if (StorageAttributeCheck.isTheSameType(cellsAttr, cellsType)) {
+                let newVec = new VectorType(vec);
+                newVec.adjustToFit(field);
+                return newVec.toString();
+            }
+            return result;
+        }
+        throw new ApplicationException("in operUpdateVectors " + field.getName() + " is not of type vector");
+    }
+    async operRaiseEvent(mprgCreator, returnedFromServer) {
+        let immediate = await this.Immediate();
+        let aRtEvt = this._rtEvt.replicate();
+        await aRtEvt.setPublicName();
+        aRtEvt.setImmediate(immediate);
+        aRtEvt.setMainPrgCreator(null);
+        if (immediate) {
+            aRtEvt.setCtrl(this._task.getLastParkedCtrl());
+            aRtEvt.setArgList(this._argList);
+            if (aRtEvt.getTask().isMainProg())
+                aRtEvt.setMainPrgCreator(mprgCreator);
+            AccessHelper.eventsManager.checkAndSaveRouteEventIfCtxRemovedFromSrvr(aRtEvt);
+            AccessHelper.eventsManager.pushExecStack(this._task.getTaskTag(), this._evtHandler.getId().toString(), this._serverId);
+            await AccessHelper.eventsManager.handleEvent(aRtEvt, returnedFromServer);
+            AccessHelper.eventsManager.popExecStack();
+        }
+        else {
+            let arglist = new ArgumentsList();
+            await arglist.Initialize(this._argList);
+            aRtEvt.setArgList(arglist);
+            aRtEvt.setTask(null);
+            AccessHelper.eventsManager.addToTail(aRtEvt);
+            AccessHelper.eventsManager.checkAndSaveRouteEventIfCtxRemovedFromSrvr(aRtEvt);
+        }
+    }
+    async operCall(mprgCreator) {
+        await this.operServer(mprgCreator);
+    }
+    async operServer(mprgCreator) {
+        let command = ((this._cmdToServer instanceof ExecOperCommand) ? this._cmdToServer : null);
+        Debug.Assert(command !== null);
+        if (this._task.isMainProg())
+            command.MprgCreator = mprgCreator;
+        else
+            command.MprgCreator = null;
+        command.SetExecutionStack(AccessHelper.eventsManager.getExecStack());
+        command.Operation = this;
+        await AccessHelper.mgDataTable.execRequestWithSubformRecordCycle(this._task.getMGData().CmdsToServer, this._cmdToServer, null);
+    }
+    getBlockEnd() {
+        return this._blockEnd;
+    }
+    setBlockEnd(val) {
+        this._blockEnd = val;
+    }
+    getBlockClose() {
+        return this._blockClose;
+    }
+    setBlockClose(val) {
+        this._blockClose = val;
+    }
+    getTaskTag() {
+        return this._task.getTaskTag();
+    }
+    getHandlerId() {
+        return this._evtHandler.getId().toString();
+    }
+    getEventHandler() {
+        return this._evtHandler;
+    }
+    getExecOnServer() {
+        return this._execOnServer;
+    }
+    setExecOnServer(val) {
+        this._execOnServer = val;
+    }
+    getExecOnClient() {
+        return this._execOnClient;
+    }
+    async canExecute() {
+        return await this.getCondVal();
+    }
+    async AddFlowDescription(buffer) {
+        switch (this._type) {
+            case ConstInterface.MG_OPER_VERIFY:
+                buffer.Append("Verify: ");
+                if (this._exp == null)
+                    buffer.Append(this._text);
+                else
+                    buffer.Append("Exp #").Append(this._exp.getId());
+                break;
+            case ConstInterface.MG_OPER_BLOCK:
+                buffer.Append("Block If");
+                break;
+            case ConstInterface.MG_OPER_LOOP:
+                buffer.Append("Block Loop");
+                break;
+            case ConstInterface.MG_OPER_ELSE:
+                buffer.Append("Block Else");
+                break;
+            case ConstInterface.MG_OPER_EVALUATE:
+                buffer.Append("Evaluate Exp #").Append(this._exp.getId());
+                break;
+            case ConstInterface.MG_OPER_UPDATE:
+                buffer.AppendFormat("Update {0} with Exp #{1}", this._field.getVarName(), this._exp.getId());
+                break;
+            case ConstInterface.MG_OPER_ENDBLOCK:
+                buffer.Append("End Block");
+                break;
+            case ConstInterface.MG_OPER_USR_EXIT:
+                buffer.Append("Invoke OS");
+                break;
+            case ConstInterface.MG_OPER_RAISE_EVENT:
+                buffer.Append("Raise Event:");
+                this._rtEvt.AppendDescription(buffer);
+                buffer.AppendFormat(" (Wait={0})", (await this.Immediate() ? 'Y' : 'N'));
+                break;
+            case ConstInterface.MG_OPER_SERVER:
+                buffer.Append("Run server-side operation");
+                break;
+            case ConstInterface.MG_OPER_CALL:
+                buffer.Append("Call program");
+                break;
+            default:
+                buffer.AppendFormat("<<Unknown Operation Code {0}>>", this._type);
+                break;
+        }
+    }
+    GetArgList() {
+        return this._argList;
+    }
+    GetReturnValueField() {
+        return this._field;
+    }
+    GetSubformControlName() {
+        return this._subformCtrlName;
+    }
+    toString() {
+        return NString.Format("Executing operation number {0}", this._serverId + 1);
+    }
+    GetRuntimeEvent() {
+        return this._rtEvt;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Operation.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/rt/Operation.ts"],"names":[],"mappings":"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","sourcesContent":["import {ApplicationException, Debug, Int32, List, NNumber, NString, StringBuilder, Thread} from '@magic-xpa/mscorelib';\r\n\r\nimport {\r\n  CallOperationMode,\r\n  CallOsShow,\r\n  Constants,\r\n  Logger,\r\n  StorageAttribute,\r\n  StorageAttributeCheck,\r\n  StrUtil,\r\n  UtilStrByteMode,\r\n  XMLConstants,\r\n  XmlParser\r\n} from '@magic-xpa/utils';\r\n\r\nimport {\r\n  Commands,\r\n  MgControlBase,\r\n  NUM_TYPE,\r\n  PropInterface,\r\n  Styles,\r\n  TaskDefinitionId,\r\n  TaskDefinitionIdTableSaxHandler,\r\n  VectorType\r\n} from '@magic-xpa/gui';\r\n\r\nimport {YesNoExp} from '../exp/YesNoExp';\r\nimport {ArgumentsList} from './ArgumentsList';\r\nimport {IClientCommand} from '../commands/IClientCommand';\r\nimport {Expression} from '../exp/Expression';\r\nimport {EventHandler} from '../event/EventHandler';\r\nimport {Field} from '../data/Field';\r\nimport {RunTimeEvent} from '../event/RunTimeEvent';\r\nimport {MgForm} from '../gui/MgForm';\r\nimport {CommandFactory} from '../commands/ClientToServer/CommandFactory';\r\nimport {FlowMonitorQueue} from '../util/FlowMonitorQueue';\r\nimport {ExecOperCommand} from '../commands/ClientToServer/ExecOperCommand';\r\nimport {MgControl} from '../gui/MgControl';\r\nimport {ConstInterface} from '../ConstInterface';\r\nimport {Task} from '../tasks/Task';\r\nimport {FlowMonitorInterface} from '../FlowMonitorInterface';\r\nimport {LanguageData} from '../env/LanguageData';\r\nimport {LastFocusedManager} from './LastFocusedManager';\r\nimport {CommandsTable} from '../CommandsTable';\r\nimport {AccessHelper} from '../AccessHelper';\r\nimport {GUIManager} from \"../GUIManager\";\r\n\r\n\r\n/// <summary>\r\n///   data for <oper> tag\r\n/// </summary>\r\nexport class Operation {\r\n  private _condExp: YesNoExp = new YesNoExp(true);\r\n  private _retainFocus: YesNoExp = new YesNoExp(false);\r\n  private _waitExp: YesNoExp = new YesNoExp(false);\r\n  private _syncData: YesNoExp = new YesNoExp(false); // call operation: Sync data\r\n  private _argList: ArgumentsList = null;\r\n  private _blockClose: number = 0;\r\n  // in Block Begin/Else/Loop operation: the operation id which is the end of the execution block (else/end)\r\n  private _blockEnd: number = 0;  // in Block Begin/Else/Loop operation: the Block End operation that ends the nesting level\r\n  private _buttons: string = '\\0'; // buttons of verify opr\r\n  private _checkByServer: boolean = false; // for Call operation with subform destination\r\n  private _cmdToServer: IClientCommand = null; // default button of verify opr\r\n  private _display: string = 'S'; // Status line | message Box\r\n  private _errLogAppend: boolean = false; // append to error log for verify opr\r\n  private _evtHandler: EventHandler = null;\r\n  private _execOnServer: boolean = false; // for block if which should be executed on the server\r\n  private _execOnClient: boolean = false; // for block if which must be executed on the client\r\n  private _exp: Expression = null;\r\n  private _field: Field = null; // reference to the field\r\n  private _globalParamsShouldBeCopied: boolean = false;\r\n  private _image: string = '\\0'; // image of verify opr\r\n  private _incremental: boolean = false;  // INCR->true, NORMAL->false (how attribute)\r\n  private _methodNameSnippet: string = null; // Entry point methodName for snippet\r\n  private _mode: string = '\\0'; // Error|Warning\r\n  // but we still need to skip the block operations in the client\r\n  private _prgDescription: string = null;\r\n  private _publicName: string = null;\r\n  private _returnVal: Field = null; // return value of verify opr\r\n  private _rtEvt: RunTimeEvent = null; // for Raise event\r\n  private _serverId: number = -1;\r\n  // the index of this operation in the server's flow (0 means it's the first operation in the handler, 1 for the second etc.). Valid for: Server\r\n  private calledTaskDefinitionId: TaskDefinitionId = null;\r\n\r\n  private _show: CallOsShow = CallOsShow.Normal;\r\n  private _subformCtrlName: string = null; // for Call operation with subform destination\r\n  private _subtype: string = '\\0'; // If|Else|Loop\r\n  private _task: Task = null; // the task of the operation\r\n  private _text: string = null; // the verify message\r\n  private _title: string = null; // title of verify opr\r\n  private _titleExp: Expression = null; // expression attached to title of verify opr\r\n  private _type: number = 0; // operation number (like in Magic)\r\n  private _undo: boolean = true;\r\n\r\n  private _isRoute: boolean = false;\r\n  private _routerPath: string = null;\r\n  private _originalRouterOutletName: string = null;\r\n  private _routeParams: List<any> = null;\r\n\r\n  constructor(){\r\n  }\r\n\r\n  get CalledTaskDefinitionId(): TaskDefinitionId {\r\n    return this.calledTaskDefinitionId;\r\n  }\r\n\r\n  OperCallMode: CallOperationMode = 0;\r\n\r\n  set Task(value: Task) {\r\n    this._task = value;\r\n  }\r\n\r\n  get Task(): Task {\r\n    return this._task;\r\n  }\r\n\r\n  private async Immediate():  Promise<boolean>  {\r\n    return await this._waitExp.getVal();\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   parse an operation\r\n  /// </summary>\r\n  fillData(taskRef: Task, evtHandler: EventHandler, parser: XmlParser): void {\r\n    this._task = taskRef;\r\n    this._evtHandler = evtHandler;\r\n\r\n    while (this.initInnerObjects(parser, parser.getNextTag(), taskRef)) {\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   init inner attributes of Operation object on parsing time\r\n  /// </summary>\r\n  private initInnerObjects(parser: XmlParser, foundTagName: string, taskRef: Task): boolean {\r\n    if (foundTagName === null)\r\n      return false;\r\n\r\n    if (foundTagName === ConstInterface.MG_TAG_EVENT) {\r\n      this._rtEvt = new RunTimeEvent(taskRef);\r\n      this._rtEvt.fillData(parser, taskRef);\r\n    }\r\n    else if (foundTagName === ConstInterface.MG_TAG_OPER) {\r\n      this.fillAttributes(parser, taskRef);\r\n    }\r\n    else if (foundTagName === \"/\" + ConstInterface.MG_TAG_OPER) {\r\n      parser.setCurrIndex2EndOfTag(); // setCurrIndex(XmlParser.isNextTagClosed(MG_TAG_CONTROL));\r\n      return false;\r\n    }\r\n    else if (foundTagName === XMLConstants.MG_TAG_TASKDEFINITIONID_ENTRY) {\r\n      this.InitTaskDefinitionID(parser);\r\n    }\r\n    else {\r\n      Logger.Instance.WriteExceptionToLogWithMsg(\"There is no such tag in Operation. Insert else if to Operation.initInnerObjects for \" + foundTagName);\r\n      return false;\r\n    }\r\n    return true;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   get the attributes of the operation\r\n  /// </summary>\r\n  /// <param name = \"taskRef\">the task of the handler current</param>\r\n  private fillAttributes(parser: XmlParser, taskRef: Task): void {\r\n    let tokensVector: List<string>;\r\n    let endContext: number = parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex());\r\n\r\n    if (endContext !== -1 && endContext < parser.getXMLdata().length) {\r\n\r\n      // last position of its tag\r\n      let tag: String = parser.getXMLsubstring(endContext);\r\n      parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_OPER) + ConstInterface.MG_TAG_OPER.length);\r\n\r\n      tokensVector = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);\r\n      this.initElements(tokensVector, taskRef);\r\n\r\n      // init inner reference:\r\n      parser.setCurrIndex(endContext + XMLConstants.TAG_CLOSE.length);\r\n      return;\r\n    }\r\n    Logger.Instance.WriteExceptionToLogWithMsg(\"in Command.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\">current</param>\r\n  private initElements(tokensVector: List<String>, taskRef: Task): void {\r\n    let attribute: String, valueStr;\r\n    let expId: number;\r\n    let isGuiThreadExecution: boolean = false;\r\n\r\n    for (let j: number = 0; j < tokensVector.length; j += 2) {\r\n      attribute = (tokensVector.get_Item(j));\r\n      valueStr = (tokensVector.get_Item(j + 1));\r\n\r\n      switch (attribute) {\r\n        case XMLConstants.MG_ATTR_TYPE:\r\n          this._type = XmlParser.getInt(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_FLD:\r\n          this._field = Operation.InitField(valueStr, this._task);\r\n          break;\r\n        case XMLConstants.MG_ATTR_EXP:\r\n          expId = XmlParser.getInt(valueStr);\r\n          this._exp = taskRef.getExpById(expId);\r\n          break;\r\n        case ConstInterface.MG_ATTR_TEXT:\r\n          this._text = XmlParser.unescape(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_MODE:\r\n          this._mode = valueStr[0];\r\n          break;\r\n        case ConstInterface.MG_ATTR_SUBTYPE:\r\n          this._subtype = valueStr[0];\r\n          if (this._type === ConstInterface.MG_OPER_BLOCK) {\r\n            if (this._subtype === 'E')\r\n              this._type = ConstInterface.MG_OPER_ELSE;\r\n            else if (this._subtype === 'L')\r\n              this._type = ConstInterface.MG_OPER_LOOP;\r\n          }\r\n          break;\r\n        case ConstInterface.MG_ATTR_CLOSE:\r\n          this._blockClose = XmlParser.getInt(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_END:\r\n          this._blockEnd = XmlParser.getInt(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_HOW:\r\n          this._incremental = (valueStr === \"I\");\r\n          break;\r\n        case ConstInterface.MG_ATTR_UNDO:\r\n          if (valueStr[0] === 'N')\r\n            this._undo = false;\r\n          else if (valueStr[0] === 'Y')\r\n            this._undo = true;\r\n          else Logger.Instance.WriteExceptionToLogWithMsg(\"in Operation.initElements(): No such value to the MG_ATTR_UNDO for \" + valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_DISPLAY:\r\n          this._display = valueStr[0];\r\n          break;\r\n        case ConstInterface.MG_ATTR_WAIT:\r\n          this._waitExp.setVal(taskRef, valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_RETAIN_FOCUS:\r\n          this._retainFocus.setVal(taskRef, valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_SYNC_DATA:\r\n          this._syncData.setVal(taskRef, valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_SHOW:\r\n          this._show = <CallOsShow>XmlParser.getInt(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_CND:\r\n          this._condExp.setVal(taskRef, valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_ARGLIST:\r\n          this._argList = new ArgumentsList();\r\n          this._argList.fillList(valueStr, this._task);\r\n          break;\r\n        case ConstInterface.MG_ATTR_REFRESHON:\r\n          this._argList.RefreshOnString = valueStr.Trim();\r\n          break;\r\n        case ConstInterface.MG_ATTR_SERVER_ID:\r\n          this._serverId = XmlParser.getInt(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_OPER_CALLMODE:\r\n          this.OperCallMode = <CallOperationMode>valueStr[0];\r\n          break;\r\n\r\n        case ConstInterface.MG_ATTR_SUBFORM_CTRL:\r\n          this._subformCtrlName = XmlParser.unescape(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_CHECK_BY_SERVER:\r\n          this._checkByServer = XmlParser.getBoolean(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_PUBLIC:\r\n          this._publicName = valueStr;\r\n          break;\r\n        case ConstInterface.MG_ATTR_PRG_DESCRIPTION:\r\n          this._prgDescription = valueStr;\r\n          break;\r\n        case ConstInterface.MG_ATTR_CPY_GLB_PRMS:\r\n          this._globalParamsShouldBeCopied = XmlParser.getBoolean(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_EXEC_ON_SERVER:\r\n          this._execOnServer = XmlParser.getBoolean(valueStr);\r\n          break;\r\n\t\tcase ConstInterface.MG_ATTR_EXEC_ON_CLIENT:\r\n          this._execOnClient = XmlParser.getBoolean(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_TITLE:\r\n          this._title = XmlParser.unescape(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_TITLE_EXP:\r\n          expId = XmlParser.getInt(valueStr);\r\n          this._titleExp = taskRef.getExpById(expId);\r\n          break;\r\n        case ConstInterface.MG_ATTR_IMAGE:\r\n          this._image = valueStr[0];\r\n          break;\r\n        case ConstInterface.MG_ATTR_BUTTONS:\r\n          this._buttons = valueStr[0];\r\n          break;\r\n        case ConstInterface.MG_ATTR_RETURN_VAL:\r\n          this._returnVal = Operation.InitField(valueStr, this._task);\r\n          break;\r\n        case ConstInterface.MG_ATTR_ERR_LOG_APPEND:\r\n          this._errLogAppend = XmlParser.getBoolean(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_OPER_METHODNAME:\r\n          this._methodNameSnippet = valueStr;\r\n          break;\r\n        case ConstInterface.MG_ATTR_IS_GUI_THREAD_EXECUTION:\r\n          isGuiThreadExecution = XmlParser.getBoolean(valueStr);\r\n          break;\r\n        case ConstInterface.MG_ATTR_IS_ROUTE:\r\n          this._isRoute = XmlParser.getBoolean(valueStr);\r\n          break;\r\n        case XMLConstants.MG_ATTR_ROUTER_PATH:\r\n          this._routerPath = XmlParser.unescape(valueStr);\r\n          break;\r\n        default:\r\n          Logger.Instance.WriteExceptionToLogWithMsg(\"There is no such tag in Operation class. Insert case to Operation.initElements for \" + attribute);\r\n          break;\r\n      }\r\n    }\r\n    if (this._serverId > -1)\r\n      this._cmdToServer = CommandFactory.CreateExecOperCommand(this._task.getTaskTag(), \"\" + this._evtHandler.getId(), this._serverId, Int32.MinValue, null);\r\n\r\n    if (this._isRoute) {\r\n      this._originalRouterOutletName = this._subformCtrlName !== null ? this._subformCtrlName : \"\";\r\n\r\n      if (this._subformCtrlName == null) {\r\n        let defaultRouterOutlet: MgControlBase = this._task.getForm().DefaultRouterOutlet;\r\n        this._subformCtrlName = defaultRouterOutlet !== null ? defaultRouterOutlet.Name : \"\";\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"parser\"></param>\r\n  InitTaskDefinitionID(parser: XmlParser): void {\r\n    let xmlBuffer: string = parser.ReadToEndOfCurrentElement();\r\n    let taskDefinitionIdTableSaxHandler: TaskDefinitionIdTableSaxHandler = new TaskDefinitionIdTableSaxHandler(this.SetTaskDefinitionId);\r\n    taskDefinitionIdTableSaxHandler.parse(xmlBuffer);\r\n  }\r\n\r\n  /// <summary>\r\n  /// callback for the sax parser\r\n  /// </summary>\r\n  /// <param name=\"taskDefinitionId\"></param>\r\n  /// <param name=\"xmlId\"></param>\r\n  /// <param name=\"defaultTagList\"></param>\r\n  private SetTaskDefinitionId(taskDefinitionId: TaskDefinitionId): void {\r\n    this.calledTaskDefinitionId = taskDefinitionId;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Initialize the field\r\n  /// </summary>\r\n  /// <param name = \"valueStr\">a reference to the field</param>\r\n  /// <param name = \"task\"></param>\r\n  static InitField(valueStr: string, task: Task): Field {\r\n    let TaskField: List<string> = XmlParser.getTokens(valueStr, ',')/*','*/;\r\n    if (TaskField.length === 2) {\r\n      let parent: number = NNumber.Parse(TaskField.get_Item(0));\r\n      let fldID: number = NNumber.Parse(TaskField.get_Item(1));\r\n      let field: Field = <Field>task.getFieldDef(parent, fldID);\r\n      return field;\r\n    }\r\n    Logger.Instance.WriteExceptionToLogWithMsg(NString.Format(\"Unknown field: '{0}'\", valueStr));\r\n    return null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   execute the operation\r\n  /// </summary>\r\n  /// <param name = \"mprgCreator\">relevant only when the operation belongs to a main program.\r\n  ///   It identifies the task which caused this main program to participate in the runtime\r\n  ///   flow (i.e. when running a task from a different component, we instantiate his main program\r\n  ///   right above it.\r\n  /// </param>\r\n  /// <param name = \"ctrl\">the focus need to be returned after the VERIFY operation in Message Box needs only\r\n  ///   all another operations can use null\r\n  /// </param>\r\n  /// <param name = \"returnedFromServer\">true if the server returned the execution to this operation</param>\r\n  /// <returns> boolean for verify and block operations</returns>\r\n  async execute(returnedFromServer: boolean): Promise<boolean> {\r\n    let lastRtEvent: RunTimeEvent = AccessHelper.eventsManager.getLastRtEvent();\r\n    let mprgCreator: Task = null;\r\n    let flowMonitor: FlowMonitorQueue = FlowMonitorQueue.Instance;\r\n\r\n    if (lastRtEvent !== null)\r\n      mprgCreator = <Task>lastRtEvent.getMainPrgCreator();\r\n\r\n    if (returnedFromServer ||\r\n      (!returnedFromServer && (this._type !== ConstInterface.MG_OPER_SERVER || !this._condExp.isServerExp()))) {\r\n      if (! await this.canExecute()) {\r\n        if (this._type !== ConstInterface.MG_OPER_LOOP)\r\n          await flowMonitor.addFlowFieldOperation(this, false, this._task.GetTaskDetails());\r\n        return false;\r\n      }\r\n    }\r\n    if (this._type !== ConstInterface.MG_OPER_LOOP && this._type !== ConstInterface.MG_OPER_ENDBLOCK)\r\n    // We call addFlowOperationSelect only at the begining and end of the loop at EventHandler::execute\r\n      await flowMonitor.addFlowFieldOperation(this, true, this._task.GetTaskDetails());\r\n\r\n    try {\r\n      switch (this._type) {\r\n        case ConstInterface.MG_OPER_VERIFY:\r\n          return await this.operVerify();\r\n        case ConstInterface.MG_OPER_BLOCK:\r\n          return this.operBlock();\r\n        case ConstInterface.MG_OPER_LOOP:\r\n          if (!this.getExecOnServer())\r\n            return this.operBlock();\r\n          else {\r\n            await this.operServer(mprgCreator);\r\n            break;\r\n          }\r\n        case ConstInterface.MG_OPER_ELSE:\r\n          return this.operElse();\r\n        case ConstInterface.MG_OPER_EVALUATE:\r\n          await this.operEvaluate();\r\n          break;\r\n        case ConstInterface.MG_OPER_UPDATE:\r\n          await this.operUpdate(mprgCreator);\r\n          break;\r\n        case ConstInterface.MG_OPER_RAISE_EVENT:\r\n          await this.operRaiseEvent(mprgCreator, returnedFromServer);\r\n          break;\r\n        case ConstInterface.MG_OPER_SERVER:\r\n          await this.operServer(mprgCreator);\r\n          break;\r\n        case ConstInterface.MG_OPER_CALL:\r\n          if (this._publicName != null) {\r\n            this.operCallParallel();\r\n          }\r\n          else if (this._subformCtrlName == null)\r\n            await this.operCall(mprgCreator);\r\n          // Subform Destination Call oR Call Route\r\n          else {\r\n            let subformTask: Task;\r\n            let isEndProg: boolean = true;\r\n\r\n            if (this._checkByServer) {\r\n              if (!(this._cmdToServer instanceof ExecOperCommand))\r\n                Debug.Assert(false);\r\n\r\n              let command: ExecOperCommand = <ExecOperCommand>this._cmdToServer;\r\n              command.CheckOnly = true;\r\n              await this.operCall(mprgCreator);\r\n              command.CheckOnly = false;\r\n              if (AccessHelper.eventsManager.getNextOperIdx(this, true) > -1)\r\n                isEndProg = false;\r\n            }\r\n            if (isEndProg) {\r\n              let destSubForm: MgControl = (<MgForm>this._task.getForm()).getSubFormCtrlByName(this._subformCtrlName);\r\n\r\n              // A call route operation needs an outlet. If a matching outlet is not found, Call route cannot execute.\r\n              if (this._isRoute && (destSubForm === null || !destSubForm.IsRouterOutlet()))\r\n                return false;\r\n\r\n              if (destSubForm != null) {\r\n\r\n                if (this._isRoute) {\r\n                  let canRoute: boolean = false;\r\n                  let rtEvnt = AccessHelper.eventsManager.getLastRtEvent();\r\n                  if (rtEvnt !== null) {\r\n                    this._routeParams = rtEvnt.getRouteParamList();\r\n\r\n                    if ((await rtEvnt.getArgList().getArg(0).getValue(StorageAttribute.ALPHA, 0)).trim() === this._routerPath &&\r\n                      ((rtEvnt.getArgList().getArg(1).skipArg()) ||\r\n                        (await rtEvnt.getArgList().getArg(1).getValue(StorageAttribute.ALPHA, 0)).trim() === this._originalRouterOutletName))\r\n                      canRoute = true;\r\n\r\n                    if (!canRoute)\r\n                      return false;\r\n                  }\r\n                }\r\n\r\n                subformTask = <Task>destSubForm.getSubformTask();\r\n\r\n                if (subformTask != null) {\r\n                  let terminateTaskGracefully = true;\r\n                  let rtEvnt = AccessHelper.eventsManager.getLastRtEvent();\r\n                  if (this._isRoute && rtEvnt !== null && rtEvnt.isGuiTriggeredEvent()) {\r\n                    terminateTaskGracefully = false;\r\n                    AccessHelper.eventsManager.setStopExecution(true);\r\n                  }\r\n                  if (await subformTask.endTask(true, false, !terminateTaskGracefully, true)) {\r\n                    let parentTask: Task = <Task>destSubForm.getForm().getTask();\r\n                    parentTask.TaskService.RemoveRecomputes(parentTask);\r\n                  }\r\n                  else\r\n                  // if the task failed to terminate, do no proceed to call the new task.\r\n                    break;\r\n                }\r\n                if (LastFocusedManager.getLastFocusedControl() != null &&\r\n                  LastFocusedManager.getLastFocusedControl().isDescendentOfControl(destSubForm))\r\n                  this._task.RetainFocus = false;\r\n                else this._task.RetainFocus = await this._retainFocus.getVal();\r\n              }\r\n\r\n              await this.operCall(mprgCreator);\r\n\r\n            }\r\n          }\r\n          // Call operation should return whether it executed a Call Route or not.\r\n          // This is needed by the caller because, it has to stop executing subsequent\r\n          // operations in case a call route gets executed.\r\n          return this._isRoute;\r\n        default:\r\n          Logger.Instance.WriteExceptionToLogWithMsg(\"There is no such type of operation \" + this._type);\r\n          break;\r\n      }\r\n    }\r\n    catch (ex) {\r\n      throw ex;\r\n    }\r\n    return true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   call a parallel rich-client program\r\n  /// </summary>\r\n  private operCallParallel(): void {\r\n    Operation.callParallel();\r\n  }\r\n\r\n  static callParallel(): void {\r\n  //   if (task.IsOffline) {\r\n  //     Logger.Instance.WriteExceptionToLogWithMsg(\"Can't run a parallel program from an offline task\");\r\n  //     return;\r\n  //   }\r\n  //\r\n  //   //  The rich-client will query the runtime-engine for the up-to-date list of global params\r\n  //   //  of the current context only if the callED (parallel) program requests copying of global params,\r\n  //   //  the callER program should query them from the runtime-engine\r\n  //   if (globalParamsShouldBeCopied) {\r\n  //     let mgData: MGData = task.getMGData();\r\n  //     let cmd: IClientCommand = CommandFactory.CreateQueryGlobalParamsCommand();\r\n  //     mgData.CmdsToServer.Add(cmd);\r\n  //     CommandsProcessorManager.GetCommandsProcessor().Execute(CommandsProcessorBase_SendingInstruction.ONLY_COMMANDS);\r\n  //   }\r\n  //   // clone the execution properties of the current client\r\n  //   Logger.instance.WriteErrorToLog(\"callParallel called\");\r\n  //   let calledProgramProps: any = ClientManager.Instance.copyExecutionProps();\r\n  //   ServerConfig.Instance.setGlobalParams(null);\r\n  //\r\n  //   // set the called program's internal name\r\n  //   calledProgramProps.set_Item(ConstInterface.REQ_PRG_NAME, publicName);\r\n  //\r\n  //   // Server sends prgDesciprtion only when PublicName is not specified.\r\n  //   // Otherwise server sends a fictive prgDescription like : _Program_Id_<ISN>.\r\n  //   // When public name is specified prgDescription is not used and it will be null.\r\n  //   if (!NString.IsNullOrEmpty(prgDescription)) {\r\n  //     calledProgramProps.set_Item(ConstInterface.REQ_PRG_DESCRIPTION, prgDescription);\r\n  //   }\r\n  //   calledProgramProps.set_Item(ConstInterface.PARALLEL_EXECUTION, \"Y\");\r\n  //\r\n  //   // arguments to the parallel program\r\n  //   if (argList !== null) {\r\n  //     let prgArgs: string = argList.toURL(true);\r\n  //     calledProgramProps.set_Item(ConstInterface.REQ_ARGS, prgArgs);\r\n  //   }\r\n  //   let XMLdata: StringBuilder = new StringBuilder();\r\n  //   try {\r\n  //     calledProgramProps.storeToXML(XMLdata);\r\n  //\r\n  //     // If encoding was disabled, enable it to create the right command line for the parallel program\r\n  //     let encodingEnabled: boolean = HttpUtility.EncodingEnabled;\r\n  //     if (!encodingEnabled)\r\n  //       HttpUtility.EncodingEnabled = true;\r\n  //\r\n  //     let spawningArguments: string = HttpUtility.UrlEncode(XMLdata.ToString(), Encoding.UTF8);\r\n  //     if (!encodingEnabled)\r\n  //       HttpUtility.EncodingEnabled = false;\r\n  //\r\n  //     // spawn a new instance of the assembly inside the current process\r\n  //     Process.StartCurrentExecutable(spawningArguments);\r\n  //   }\r\n  //   catch (ex) {\r\n  //     if (ex instanceof Exception) {\r\n  //       Operation.callOprShowError(task, ex.toString());\r\n  //     }\r\n  //     else\r\n  //       throw ex;\r\n  //   }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the condition value\r\n  /// </summary>\r\n  private async getCondVal(): Promise<boolean> {\r\n    return await this._condExp.getVal();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the operation type\r\n  /// </summary>\r\n  getType(): number {\r\n    return this._type;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the operation type\r\n  /// </summary>\r\n  getRouteParams(): List<any> {\r\n    return this._routeParams;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the server ID of this operation\r\n  /// </summary>\r\n  getServerId(): number {\r\n    return this._serverId;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   execute Verify\r\n  /// </summary>\r\n  /// <returns> boolean is true if and only if mode==error</returns>\r\n\r\n  private async operVerify(): Promise<boolean> {\r\n    let isError: boolean = (this._mode === ConstInterface.FLW_VERIFY_MODE_ERROR);\r\n\r\n    let textToDisplay: string = this._exp === null ? this._text : await this._exp.evaluateWithResultTypeAndLength(StorageAttribute.UNICODE, 255);\r\n\r\n    let titleToDisplay: string = this._titleExp === null ? this._title : await this._titleExp.evaluateWithResultTypeAndLength(StorageAttribute.UNICODE, 255);\r\n\r\n    textToDisplay = textToDisplay === null ? \"\" : StrUtil.rtrim(textToDisplay);\r\n    titleToDisplay = titleToDisplay === null ? \"\" : StrUtil.rtrim(titleToDisplay);\r\n\r\n    // InOrder to keep the behavior same as in Online, Verify Operation Warning messages will be written\r\n    // as Error messages in Client log (QCR #915122)\r\n    if (this._errLogAppend) {\r\n      let prgDescription = (<Task> this._task.GetContextTask()).GetComputedProperty(PropInterface.PROP_TYPE_NAME).GetComputedValue();\r\n      Logger.Instance.WriteExceptionToLogWithMsg(textToDisplay + \", program : \" + prgDescription);\r\n    }\r\n    // Status line\r\n    if (this._display === ConstInterface.DISPLAY_STATUS) {\r\n      // Blank Message will not be shown, same as in Online\r\n      if (!NString.IsNullOrEmpty(textToDisplay)) {\r\n\r\n        FlowMonitorQueue.Instance.addFlowVerifyInfo(textToDisplay, this._task.GetTaskDetails());\r\n        // Product #178, Topic #61: beep on the client side only upon user errors (e.g. duplicate record),\r\n        // otherwise only if started from the studio (F7)\r\n        (<Task> this._task.GetContextTask()).WriteToMessagePane(textToDisplay);\r\n      }\r\n    }\r\n    // Message Box\r\n    else {\r\n      // Blank Message will not be shown, same as in Online\r\n      if (!NString.IsNullOrEmpty(textToDisplay)) {\r\n        // mls translation when displaying to box. for status the rans is i the control property.\r\n        let mlsTransTextToDisplay: string = LanguageData.Instance.translate(textToDisplay);\r\n        let mlsTransTitleToDisplay: string = LanguageData.Instance.translate(titleToDisplay);\r\n\r\n\r\n        let verifyMode: number = Operation.getButtons(this._buttons);\r\n        verifyMode = verifyMode || Operation.getImage(this._image);\r\n        verifyMode = verifyMode ;\r\n\r\n        if (UtilStrByteMode.isLocaleDefLangJPN()) {\r\n          let delimPos: number = mlsTransTextToDisplay.indexOf('|');\r\n          if (0 <= delimPos && delimPos < mlsTransTextToDisplay.length) {\r\n            mlsTransTitleToDisplay = mlsTransTextToDisplay.substr(delimPos + 1);\r\n            mlsTransTextToDisplay = mlsTransTextToDisplay.substr(0, delimPos);\r\n          }\r\n        }\r\n\r\n        let mgForm: MgForm = null;\r\n        // get the object for which the messagebox will be displayed\r\n        if (!(<Task> this._task.GetContextTask()).getMGData().IsAborting)\r\n          mgForm = <MgForm>(<Task> this._task.GetContextTask()).getTopMostForm();\r\n\r\n        // if the form of the current task is null (main program) then use the form\r\n        // of last focused task\r\n        if (mgForm == null && LastFocusedManager.Instance.getLastFocusedTask() != null)\r\n          mgForm = <MgForm>LastFocusedManager.Instance.getLastFocusedTask().getTopMostForm();\r\n        if (mgForm != null) {\r\n          mgForm.RefreshUI();\r\n          Commands.invoke();\r\n          await Thread.Sleep(10);\r\n        }\r\n        let returnValue: number = await GUIManager.Instance.MessageBox(mlsTransTitleToDisplay, mlsTransTextToDisplay, verifyMode);\r\n        await Operation.setoperVerifyReturnValue(returnValue, this._returnVal);\r\n\r\n      }\r\n    }\r\n\r\n    return isError;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns code assigned to corresponding buttonsID\r\n  /// </summary>\r\n\r\n  public static getButtons(buttonsID: string): number {\r\n    let tmpbuttons: number = 0;\r\n\r\n    switch (buttonsID) {\r\n      case ConstInterface.BUTTONS_OK:\r\n        tmpbuttons = Styles.MSGBOX_BUTTON_OK;\r\n        break;\r\n      case ConstInterface.BUTTONS_OK_CANCEL:\r\n        tmpbuttons = Styles.MSGBOX_BUTTON_OK_CANCEL;\r\n        break;\r\n      case ConstInterface.BUTTONS_ABORT_RETRY_IGNORE:\r\n        tmpbuttons = Styles.MSGBOX_BUTTON_ABORT_RETRY_IGNORE;\r\n        break;\r\n      case ConstInterface.BUTTONS_YES_NO_CANCEL:\r\n        tmpbuttons = Styles.MSGBOX_BUTTON_YES_NO_CANCEL;\r\n        break;\r\n      case ConstInterface.BUTTONS_YES_NO:\r\n        tmpbuttons = Styles.MSGBOX_BUTTON_YES_NO;\r\n        break;\r\n      case ConstInterface.BUTTONS_RETRY_CANCEL:\r\n        tmpbuttons = Styles.MSGBOX_BUTTON_RETRY_CANCEL;\r\n        break;\r\n      default:\r\n        break;\r\n    }\r\n    return tmpbuttons;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns code assigned to corresponding imageID\r\n  /// </summary>\r\n  public static getImage(imageID: string): number {\r\n    let tmpImage: number = 0;\r\n    switch (imageID) {\r\n      case ConstInterface.IMAGE_EXCLAMATION:\r\n        tmpImage = Styles.MSGBOX_ICON_EXCLAMATION;\r\n        break;\r\n      case ConstInterface.IMAGE_CRITICAL:\r\n        tmpImage = Styles.MSGBOX_ICON_ERROR;\r\n        break;\r\n      case ConstInterface.IMAGE_QUESTION:\r\n        tmpImage = Styles.MSGBOX_ICON_QUESTION;\r\n        break;\r\n      case ConstInterface.IMAGE_INFORMATION:\r\n        tmpImage = Styles.MSGBOX_ICON_INFORMATION;\r\n        break;\r\n      default:\r\n        break;\r\n    }\r\n    return tmpImage;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   Set Verify Operation Return Value\r\n  /// </summary>\r\n  static async setoperVerifyReturnValue(returnValue: number, returnVal: Field): Promise<void> {\r\n    if (returnVal !== null) {\r\n      let retValueNum: NUM_TYPE = new NUM_TYPE();\r\n\r\n      retValueNum.NUM_4_LONG(returnValue);\r\n      let returnValueStr: string = retValueNum.toXMLrecord();\r\n\r\n      await returnVal.setValueAndStartRecompute(returnValueStr, false, true, true, false);\r\n      await returnVal.updateDisplay();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   execute Block\r\n  /// </summary>\r\n  /// <returns> boolean true\r\n  /// </returns>\r\n  private operBlock(): boolean {\r\n    return true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   execute else / elseif\r\n  /// </summary>\r\n  /// <returns> boolean true\r\n  /// </returns>\r\n  private operElse(): boolean {\r\n    return true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   execute Evaluate\r\n  /// </summary>\r\n  private async operEvaluate(): Promise<void> {\r\n    let result: string = '\\0';\r\n\r\n    if (this._field !== null) {\r\n      result = await this._exp.evaluateWithResultTypeAndLength(this._field.getType(), this._field.getSize());\r\n      await this._field.setValueAndStartRecompute(result, result === null, true, true, false);\r\n      await this._field.updateDisplay();\r\n    }\r\n    else\r\n      result = await this._exp.evaluateWithResultTypeAndLength(StorageAttribute.BOOLEAN, 0);\r\n    }\r\n\r\n  /// <summary>\r\n  ///   execute Update\r\n  /// </summary>\r\n  private async operUpdate(mprgCreator: Task): Promise<void> {\r\n    let result: string, oldVal, newVal, fieldVal;\r\n    let setRecordUpdated: boolean;\r\n    let recompute: boolean;\r\n    let nOld: NUM_TYPE, nNew, nResult;\r\n\r\n    let flowMonitor: FlowMonitorQueue = FlowMonitorQueue.Instance;\r\n    flowMonitor.addFlowOperationUpdate(FlowMonitorInterface.FLWMTR_START, this._task.GetTaskDetails());\r\n\r\n    // for non-modifiable field go to the server, i.e. server can abort the task\r\n    if (!this._field.DbModifiable && (this._task.getMode() !== Constants.TASK_MODE_CREATE)) {\r\n      if (!await this.CanModify(mprgCreator))\r\n        return;\r\n    }\r\n    let fieldType: StorageAttribute = this._field.getType();\r\n\r\n    // if this is an incremental update\r\n    if (this._incremental) {\r\n      if (!this._field.IsLinkField) {\r\n        fieldVal = this._field.getValue(true);\r\n        nResult = (fieldVal != null\r\n          ? new NUM_TYPE(fieldVal)\r\n          : null);\r\n\r\n        // subtract the old value if not in create mode\r\n        if (this._task.getMode() !== Constants.TASK_MODE_CREATE) {\r\n\r\n          // indicate we are evaluating the old value of the fields\r\n          this._task.setEvalOldValues(true);\r\n          oldVal = (this._field.isNull()\r\n            ? this._field.getMagicDefaultValue()\r\n            : await this._exp.evaluateWithResultTypeAndLength(fieldType, this._field.getSize()));\r\n          this._task.setEvalOldValues(false);\r\n          nOld = new NUM_TYPE(oldVal);\r\n          nResult = NUM_TYPE.sub(nResult, nOld);\r\n        }\r\n\r\n        if (this._task.getMode() !== Constants.TASK_MODE_DELETE) {\r\n          newVal = await this._exp.evaluateWithResultTypeAndLength(fieldType, this._field.getSize());\r\n          if (newVal != null) {\r\n            nNew = new NUM_TYPE(newVal);\r\n            nResult = NUM_TYPE.add(nResult, nNew);\r\n          }\r\n          else\r\n            nNew = nResult = null;\r\n        }\r\n        if (nResult != null)\r\n          result = nResult.toXMLrecord();\r\n        else\r\n          result = this._field.getMagicDefaultValue();\r\n      }\r\n      else {\r\n        /* If the incremental update is for a link field, go to server. */\r\n        /* This is required to be done on server because on client, we do */\r\n        /* not have the reference to the old link record. */\r\n        /* And for incremental update, we need to work on 2 records as in */\r\n        /* case of QCR# 900738.                                           */\r\n        await this.operServer(mprgCreator);\r\n        return;\r\n      }\r\n    }\r\n    // end of  incremental update\r\n    else\r\n      result = await this._exp.evaluateWithResultTypeAndLength(fieldType, this._field.getSize());\r\n\r\n    // QCR 746053 if the cells type don't match throw error\r\n    if (fieldType === StorageAttribute.BLOB_VECTOR)\r\n      if (result != null)\r\n        result = Operation.operUpdateVectors(this._field, result);\r\n\r\n    recompute = (this._field.getTask() === this._task);\r\n    setRecordUpdated = (!recompute || !this._undo);\r\n    await this._field.setValueAndStartRecompute(result, result == null, true, setRecordUpdated, false);\r\n    if (!this._undo)\r\n      this._field.setUpdated();\r\n\r\n    // QCR # 270949 : If field is updated with update operation, modified flag should be set in order to cause re-compute.\r\n    this._field.setModified();\r\n\r\n    await this._field.updateDisplay();\r\n    flowMonitor.addFlowOperationUpdate(FlowMonitorInterface.FLWMTR_END, this._task.GetTaskDetails());\r\n  }\r\n\r\n  /// <summary>\r\n  /// can a non-modifiable field be modified. the way to get the answer depends on the local/remote dataview\r\n  /// </summary>\r\n  /// <param name=\"mprgCreator\">true if the field may be modified and the calling method should continue</param>\r\n  /// <returns></returns>\r\n  private async CanModify(mprgCreator: Task): Promise<boolean> {\r\n    let execOperCommand: ExecOperCommand = ((this._cmdToServer instanceof ExecOperCommand) ? <ExecOperCommand>this._cmdToServer : null);\r\n\r\n    execOperCommand.Operation = this;\r\n    execOperCommand.MprgCreator = mprgCreator;\r\n    return (await this.Task.DataviewManager.Execute(this._cmdToServer)).Success;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   updates the data content of a vector without changing its header data\r\n  ///   such as cell type and size - is used only in update operations between vectors\r\n  ///   for example vectors of alpha with cell size the differ or vector of memo with vector of alpha\r\n  /// </summary>\r\n  /// <param name = \"vec\">the flat representation of the the new vector\r\n  ///   field the field to be updated\r\n  /// </param>\r\n  /// <returns> a flat representation of the updated vector after the Update</returns>\r\n  static operUpdateVectors(field: Field, vec: string): string {\r\n    let result: string = null;\r\n    if (field.getType() === StorageAttribute.BLOB_VECTOR) {\r\n      let cellsAttr: StorageAttribute = VectorType.getCellsAttr(vec);\r\n      let cellsType: StorageAttribute = field.getCellsType();\r\n\r\n      if (StorageAttributeCheck.isTheSameType(cellsAttr, cellsType)) {\r\n        let newVec: VectorType = new VectorType(vec);\r\n        newVec.adjustToFit(field);\r\n        return newVec.toString();\r\n      }\r\n      return result;\r\n    }\r\n    throw new ApplicationException(\"in operUpdateVectors \" + field.getName() + \" is not of type vector\");\r\n  }\r\n\r\n  /// <summary>\r\n  ///   execute Raise Event\r\n  /// </summary>\r\n  /// <param name = \"mprgCreator\">if the operation belongs to a main program it points to the task which\r\n  ///   caused the main program to become active. Otherwise it's false.\r\n  /// </param>\r\n  /// <param name = \"returnedFromServer\">indicates whether we just came back from the server to be passed to EventsManager.Instance.handleEvent()</param>\r\n  private async operRaiseEvent(mprgCreator: Task, returnedFromServer: boolean): Promise<void> {\r\n\r\n    let immediate: boolean = await this.Immediate();\r\n\r\n    // create a new run time event using the original as template\r\n    let aRtEvt: RunTimeEvent = this._rtEvt.replicate();\r\n    await aRtEvt.setPublicName();\r\n\r\n    aRtEvt.setImmediate(immediate);\r\n    aRtEvt.setMainPrgCreator(null);\r\n\r\n    if (immediate) {\r\n      aRtEvt.setCtrl(<MgControl>this._task.getLastParkedCtrl());\r\n      aRtEvt.setArgList(this._argList);\r\n\r\n      if (aRtEvt.getTask().isMainProg())\r\n        aRtEvt.setMainPrgCreator(mprgCreator);\r\n\r\n      AccessHelper.eventsManager.checkAndSaveRouteEventIfCtxRemovedFromSrvr (aRtEvt);\r\n      AccessHelper.eventsManager.pushExecStack(this._task.getTaskTag() , this._evtHandler.getId().toString() , this._serverId);\r\n      await AccessHelper.eventsManager.handleEvent(aRtEvt, returnedFromServer);\r\n      AccessHelper.eventsManager.popExecStack();\r\n    }\r\n    else {\r\n      // send arguments by value\r\n      let arglist = new ArgumentsList();\r\n      await arglist.Initialize(this._argList)\r\n      aRtEvt.setArgList(arglist);\r\n      aRtEvt.setTask(null);\r\n      AccessHelper.eventsManager.addToTail(aRtEvt);\r\n      AccessHelper.eventsManager.checkAndSaveRouteEventIfCtxRemovedFromSrvr (aRtEvt);\r\n    }\r\n  }\r\n\r\n\r\n\r\n  /// <summary>\r\n  ///   execute browser Call operation\r\n  /// </summary>\r\n  /// <param name = \"mprgCreator\">if the operation belongs to a main program it points to the task which\r\n  ///   caused the main program to become active. Otherwise it's false.\r\n  /// </param>\r\n  private async operCall(mprgCreator: Task): Promise<void> {\r\n    await this.operServer(mprgCreator);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   execute Server operation\r\n  /// </summary>\r\n  /// <param name = \"mprgCreator\">if the operation belongs to a main program it points to the task which\r\n  ///   caused the main program to become active. Otherwise it's false.\r\n  /// </param>\r\n  async operServer(mprgCreator: Task): Promise<void> {\r\n    let command: ExecOperCommand = ((this._cmdToServer instanceof ExecOperCommand) ? <ExecOperCommand>this._cmdToServer : null);\r\n    Debug.Assert(command !== null);\r\n    if (this._task.isMainProg())\r\n      command.MprgCreator = mprgCreator;\r\n    else\r\n      command.MprgCreator = null;\r\n\r\n    command.SetExecutionStack(AccessHelper.eventsManager.getExecStack());\r\n    command.Operation = this;\r\n    await AccessHelper.mgDataTable.execRequestWithSubformRecordCycle(<CommandsTable>this._task.getMGData().CmdsToServer, this._cmdToServer, null);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the value of the Block End index\r\n  /// </summary>\r\n  getBlockEnd(): number {\r\n    return this._blockEnd;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   sets the value of the Block End index\r\n  /// </summary>\r\n  setBlockEnd(val: number): void {\r\n    this._blockEnd = val;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the value of the Block Close index\r\n  /// </summary>\r\n  getBlockClose(): number {\r\n    return this._blockClose;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   sets the value of the Block Close index\r\n  /// </summary>\r\n  setBlockClose(val: number): void {\r\n    this._blockClose = val;\r\n  }\r\n\r\n  getTaskTag(): string {\r\n    return this._task.getTaskTag();\r\n  }\r\n\r\n  getHandlerId(): string {\r\n    return this._evtHandler.getId().toString();\r\n  }\r\n\r\n  getEventHandler(): EventHandler {\r\n    return this._evtHandler;\r\n  }\r\n\r\n  getExecOnServer(): boolean {\r\n    return this._execOnServer;\r\n  }\r\n\r\n  setExecOnServer(val : boolean): void {\r\n    this._execOnServer = val;\r\n  }\r\n\r\n  getExecOnClient(): boolean {\r\n    return this._execOnClient;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   checks if the operation can be executed or not\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  private async canExecute(): Promise<boolean> {\r\n    return await this.getCondVal();\r\n  }\r\n\r\n  /// <summary>\r\n  /// </summary>\r\n  /// <param name = \"buffer\"></param>\r\n  /// <returns></returns>\r\n  public async AddFlowDescription(buffer: StringBuilder): Promise<void> {\r\n    switch (this._type) {\r\n      case ConstInterface.MG_OPER_VERIFY:\r\n        buffer.Append(\"Verify: \");\r\n        if (this._exp == null)\r\n          buffer.Append(this._text);\r\n        else buffer.Append(\"Exp #\").Append(this._exp.getId());\r\n        break;\r\n      case ConstInterface.MG_OPER_BLOCK:\r\n        buffer.Append(\"Block If\");\r\n        break;\r\n      case ConstInterface.MG_OPER_LOOP:\r\n        buffer.Append(\"Block Loop\");\r\n        break;\r\n      case ConstInterface.MG_OPER_ELSE:\r\n        buffer.Append(\"Block Else\");\r\n        break;\r\n      case ConstInterface.MG_OPER_EVALUATE:\r\n        buffer.Append(\"Evaluate Exp #\").Append(this._exp.getId());\r\n        break;\r\n      case ConstInterface.MG_OPER_UPDATE:\r\n        buffer.AppendFormat(\"Update {0} with Exp #{1}\", this._field.getVarName(), this._exp.getId());\r\n        break;\r\n      case ConstInterface.MG_OPER_ENDBLOCK:\r\n        buffer.Append(\"End Block\");\r\n        break;\r\n      case ConstInterface.MG_OPER_USR_EXIT:\r\n        buffer.Append(\"Invoke OS\");\r\n        break;\r\n      case ConstInterface.MG_OPER_RAISE_EVENT:\r\n        buffer.Append(\"Raise Event:\");\r\n        this._rtEvt.AppendDescription(buffer);\r\n        buffer.AppendFormat(\" (Wait={0})\", (await this.Immediate() ? 'Y' : 'N'));\r\n        break;\r\n      case ConstInterface.MG_OPER_SERVER:\r\n        buffer.Append(\"Run server-side operation\");\r\n        break;\r\n      case ConstInterface.MG_OPER_CALL:\r\n        buffer.Append(\"Call program\");\r\n        break;\r\n      default:\r\n        buffer.AppendFormat(\"<<Unknown Operation Code {0}>>\", this._type);\r\n        break;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  GetArgList(): ArgumentsList {\r\n    return this._argList;\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  GetReturnValueField(): Field {\r\n    return this._field;\r\n  }\r\n\r\n  /// <summary>\r\n  ///  returns subform control name for call with destination\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  GetSubformControlName(): string {\r\n    return this._subformCtrlName;\r\n  }\r\n\r\n  toString(): string {\r\n    return NString.Format(\"Executing operation number {0}\", this._serverId + 1);\r\n  }\r\n\r\n  /// <summary>\r\n  ///  returns runtimeEvent for a raise event operation\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  GetRuntimeEvent(): RunTimeEvent{\r\n    return this._rtEvt;\r\n  }\r\n}\r\n"]}