@magic-xpa/engine 4.1100.0-dev4110.25 → 4.1100.0-dev4110.252

package/esm2022/src/rt/OperationTable.mjs

@@ -0,0 +1,67 @@
+import { ApplicationException, Int32, List } from "@magic-xpa/mscorelib";
+import { Operation } from "./Operation";
+import { ConstInterface } from "../ConstInterface";
+export class OperationTable {
+    _operations = new List();
+    _firstBlockOperIdx = Int32.MaxValue;
+    constructor() {
+    }
+    fillData(taskRef, evtHandler, parser) {
+        while (this.initInnerObjects(parser.getNextTag(), taskRef, evtHandler, parser)) {
+        }
+        for (let i = this._firstBlockOperIdx; i < this._operations.length; i = i + 1) {
+            let operation = this._operations.get_Item(i);
+            let operType = operation.getType();
+            if (operType === ConstInterface.MG_OPER_LOOP || operType === ConstInterface.MG_OPER_BLOCK ||
+                operType === ConstInterface.MG_OPER_ELSE) {
+                let operIdx = this.serverId2operIdx(operation.getBlockClose(), i + 1);
+                operation.setBlockClose(operIdx);
+                operIdx = this.serverId2operIdx(operation.getBlockEnd(), operIdx);
+                operation.setBlockEnd(operIdx);
+            }
+        }
+    }
+    initInnerObjects(foundTagName, taskRef, evtHandler, parser) {
+        if (foundTagName != null && foundTagName === (ConstInterface.MG_TAG_OPER)) {
+            let oper = new Operation();
+            oper.fillData(taskRef, evtHandler, parser);
+            this._operations.push(oper);
+            if (this._firstBlockOperIdx === Int32.MaxValue
+                && (oper.getType() === ConstInterface.MG_OPER_LOOP || oper.getType() === ConstInterface.MG_OPER_BLOCK))
+                this._firstBlockOperIdx = this._operations.length - 1;
+            return true;
+        }
+        return false;
+    }
+    getSize() {
+        return this._operations.length;
+    }
+    getOperation(idx) {
+        if (idx >= 0 && idx < this._operations.length)
+            return this._operations.get_Item(idx);
+        throw new ApplicationException("in OperationTable.getOperation() index out of bounds: " + idx);
+    }
+    serverId2operIdx(id, startFrom) {
+        let operIdx = -1;
+        for (let i = startFrom; i < this._operations.length; i = i + 1) {
+            let operation = this._operations.get_Item(i);
+            if (id === operation.getServerId()) {
+                operIdx = i;
+                break;
+            }
+        }
+        return operIdx;
+    }
+    serverId2FollowingOperIdx(id, startFrom) {
+        let operIdx = -1;
+        for (let i = startFrom; i < this._operations.length; i = i + 1) {
+            let operation = this._operations.get_Item(i);
+            if (id < operation.getServerId()) {
+                operIdx = i;
+                break;
+            }
+        }
+        return operIdx;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"OperationTable.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/rt/OperationTable.ts"],"names":[],"mappings":"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","sourcesContent":["import {ApplicationException, Int32, List} from \"@magic-xpa/mscorelib\";\r\nimport { XmlParser } from \"@magic-xpa/utils\";\r\nimport {Operation} from \"./Operation\";\r\nimport {EventHandler} from \"../event/EventHandler\";\r\nimport {Task} from \"../tasks/Task\";\r\nimport {ConstInterface} from \"../ConstInterface\";\r\n\r\n\r\nexport class OperationTable {\r\n  private _operations: List<Operation> = new List<Operation>();\r\n  private _firstBlockOperIdx: number = Int32.MaxValue;\r\n\r\n  constructor(){\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Function for filling own fields, allocate memory for inner objescts.\r\n  ///   Parsing the input String.\r\n  /// </summary>\r\n  /// <param name = \"taskRef\">reference</param>\r\n  /// <param name = \"evtHandler\">to event handler</param>\r\n  fillData(taskRef: Task, evtHandler: EventHandler, parser: XmlParser): void {\r\n    while (this.initInnerObjects(parser.getNextTag(), taskRef, evtHandler, parser)) {\r\n    }\r\n\r\n    /* QCR# 180535.\r\n         * Since blank operations are not sent from the Server, there can be\r\n         * a mismatch in the BlockClose and BlockEnd idx because they contain\r\n         * the serverId.\r\n         * We need to update these idx with the corresponding Client-side idx\r\n         */\r\n\r\n    for (let i: number = this._firstBlockOperIdx; i < this._operations.length; i = i + 1) {\r\n      let operation: Operation = this._operations.get_Item(i);\r\n      let operType: number = operation.getType();\r\n\r\n      if (operType === ConstInterface.MG_OPER_LOOP || operType === ConstInterface.MG_OPER_BLOCK ||\r\n        operType === ConstInterface.MG_OPER_ELSE) {\r\n        let operIdx: number = this.serverId2operIdx(operation.getBlockClose(), i + 1);\r\n        operation.setBlockClose(operIdx);\r\n\r\n        operIdx = this.serverId2operIdx(operation.getBlockEnd(), operIdx);\r\n        operation.setBlockEnd(operIdx);\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   To allocate and fill inner objects of the class\r\n  /// </summary>\r\n  /// <param name = \"foundTagName\">possible  tag name, name of object, which need be allocated\r\n  /// </param>\r\n  /// <param name = \"mgdata\">references\r\n  /// </param>\r\n  /// <param name = \"task\">current\r\n  /// </param>\r\n  /// <param name = \"evtHandler\">to event handler\r\n  /// </param>\r\n  private initInnerObjects(foundTagName: String, taskRef: Task, evtHandler: EventHandler, parser: XmlParser): boolean {\r\n    if (foundTagName != null && foundTagName === (ConstInterface.MG_TAG_OPER)) {\r\n      let oper = new Operation();\r\n      oper.fillData(taskRef, evtHandler, parser);\r\n      this._operations.push(oper);\r\n\r\n      if (this._firstBlockOperIdx === Int32.MaxValue\r\n        && (oper.getType() === ConstInterface.MG_OPER_LOOP || oper.getType() === ConstInterface.MG_OPER_BLOCK))\r\n        this._firstBlockOperIdx = this._operations.length - 1;\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the number of operations in the table\r\n  /// </summary>\r\n  getSize(): number {\r\n    return this._operations.length;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get an operation by its index\r\n  /// </summary>\r\n  /// <param name = \"idx\">the index of the operation in the table\r\n  /// </param>\r\n  getOperation(idx: number): Operation {\r\n    if (idx >= 0 && idx < this._operations.length)\r\n      return this._operations.get_Item(idx);\r\n    throw new ApplicationException(\"in OperationTable.getOperation() index out of bounds: \" + idx);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the operation idx (i.e. the position in the OperationTab)\r\n  ///   depending on the serverId\r\n  /// </summary>\r\n  /// <param name = \"id:\">the serverId to search\r\n  /// </param>\r\n  /// <param name = \"startFrom:\">the idx from where the search is to begin\r\n  /// </param>\r\n  /// <returns> the operation idx, if serverId is matched. Otherwise -1.\r\n  /// </returns>\r\n  serverId2operIdx(id: number, startFrom: number): number {\r\n    let operIdx: number = -1;\r\n\r\n    for (let i: number = startFrom; i < this._operations.length; i = i + 1) {\r\n      let operation: Operation = this._operations.get_Item(i);\r\n\r\n      if (id === operation.getServerId()) {\r\n        operIdx = i;\r\n        break;\r\n      }\r\n    }\r\n    return operIdx;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the operation idx (i.e. the position in the OperationTab)\r\n  ///   depending on the serverId\r\n  /// </summary>\r\n  /// <param name = \"id:\">the serverId to search\r\n  /// </param>\r\n  /// <param name = \"startFrom:\">the idx from where the search is to begin\r\n  /// </param>\r\n  /// <returns> the operation idx, if serverId is matched. Otherwise -1.\r\n  /// </returns>\r\n  serverId2FollowingOperIdx(id: number, startFrom: number): number {\r\n    let operIdx: number = -1;\r\n\r\n    for (let i: number = startFrom; i < this._operations.length; i = i + 1) {\r\n      let operation: Operation = this._operations.get_Item(i);\r\n\r\n      if (id < operation.getServerId()) {\r\n        operIdx = i;\r\n        break;\r\n      }\r\n    }\r\n    return operIdx;\r\n  }\r\n}\r\n"]}

package/esm2022/src/rt/Recompute.mjs

@@ -0,0 +1,355 @@
+import { PropInterface, PropTable } from "@magic-xpa/gui";
+import { FieldBase } from "../data/FieldBase";
+import { List } from "@magic-xpa/mscorelib";
+import { CommandsProcessorBase_SendingInstruction } from "../CommandsProcessorBase";
+import { Constants, InternalInterface, Logger, XMLConstants, XmlParser } from "@magic-xpa/utils";
+import { Record } from "../data/Record";
+import { CommandFactory } from "../commands/ClientToServer/CommandFactory";
+import { RemoteCommandsProcessor } from "../remote/RemoteCommandsProcessor";
+import { DataviewHeaderBase } from "./DataviewHeaderBase";
+import { FlowMonitorQueue } from "../util/FlowMonitorQueue";
+import { ConstInterface } from "../ConstInterface";
+import { Environment } from "../env/Environment";
+import { AccessHelper } from "../AccessHelper";
+export var Recompute_RcmpBy;
+(function (Recompute_RcmpBy) {
+    Recompute_RcmpBy["CLIENT"] = "C";
+    Recompute_RcmpBy["SERVER_ON_CHANGE"] = "O";
+})(Recompute_RcmpBy || (Recompute_RcmpBy = {}));
+export class Recompute {
+    _ctrlProps = null;
+    _formProps = null;
+    _isOwnerFld = true;
+    OwnerFld = null;
+    _rcmpOrder = null;
+    _subForms = null;
+    _subFormsOnlyRecomp = false;
+    _hasServerLinksRecomputes = false;
+    RcmpMode = null;
+    Task = null;
+    constructor() {
+    }
+    fillData(dataView, taskRef, parser) {
+        this.Task = taskRef;
+        this._isOwnerFld = true;
+        while (this.initInnerObjects(parser, parser.getNextTag(), dataView)) {
+        }
+    }
+    initInnerObjects(parser, foundTagName, dataView) {
+        switch (foundTagName) {
+            case XMLConstants.MG_TAG_FLD:
+                if (this._isOwnerFld) {
+                    this.fillFldField(parser, dataView);
+                    this._isOwnerFld = false;
+                }
+                else
+                    this.fillFldField(parser, dataView);
+                break;
+            case ConstInterface.MG_TAG_LINK:
+                this.fillLink(parser, dataView);
+                break;
+            case XMLConstants.MG_TAG_CONTROL:
+                if (this._ctrlProps == null)
+                    this._ctrlProps = new PropTable();
+                this._ctrlProps.fillDataByExists(this.Task, parser);
+                if (this._ctrlProps.getCtrlRef() != null && this._ctrlProps.getCtrlRef().IsRepeatable && this.OwnerFld.IsVirtual &&
+                    !(this.OwnerFld.hasInitExp()))
+                    this.OwnerFld.causeTableInvalidation(true);
+                break;
+            case XMLConstants.MG_TAG_FORM_PROPERTIES:
+                if (this._formProps == null)
+                    this._formProps = new PropTable();
+                this._formProps.fillDataByExists(this.Task, parser);
+                break;
+            case ConstInterface.MG_TAG_FLD_END:
+                parser.setCurrIndex2EndOfTag();
+                return false;
+            default:
+                Logger.Instance.WriteExceptionToLogWithMsg("There is no such tag in Recompute. Insert else if to Recompute.initInnerObjects for " + foundTagName);
+                return false;
+        }
+        return true;
+    }
+    AddRecomputeItem(item) {
+        if (this._rcmpOrder === null)
+            this._rcmpOrder = new List();
+        this._rcmpOrder.push(item);
+    }
+    fillLink(parser, dataView) {
+        let endContext = parser.getXMLdata().indexOf(XMLConstants.TAG_TERM, parser.getCurrIndex());
+        if (endContext !== -1 && endContext < parser.getXMLdata().length) {
+            let tag = parser.getXMLsubstring(endContext);
+            parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_LINK) + ConstInterface.MG_TAG_LINK.length);
+            let tokensVector = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);
+            for (let j = 0; j < tokensVector.length; j += 2) {
+                let attribute = (tokensVector.get_Item(j));
+                let valueStr = (tokensVector.get_Item(j + 1));
+                if (attribute === XMLConstants.MG_ATTR_ID)
+                    this.AddRecomputeItem(dataView.getTask().getDataviewHeaders().getDataviewHeaderById(XmlParser.getInt(valueStr)));
+                else
+                    Logger.Instance.WriteExceptionToLogWithMsg("There is no such tag in Recompute class. Insert case to Recompute.fillLink for " + attribute);
+            }
+            parser.setCurrIndex(endContext + XMLConstants.TAG_TERM.length);
+            return;
+        }
+        else
+            Logger.Instance.WriteExceptionToLogWithMsg("in Recompute.fillLink() out of bounds");
+    }
+    fillFldField(parser, dataView) {
+        let endContext = parser.getXMLdata().indexOf(this._isOwnerFld
+            ? XMLConstants.TAG_CLOSE
+            : XMLConstants.TAG_TERM, parser.getCurrIndex());
+        if (endContext !== -1 && endContext < parser.getXMLdata().length) {
+            let tag = parser.getXMLsubstring(endContext);
+            parser.add2CurrIndex(tag.indexOf(XMLConstants.MG_TAG_FLD) + XMLConstants.MG_TAG_FLD.length);
+            let tokensVector = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);
+            this.initElements(tokensVector, dataView);
+            if (this._isOwnerFld) {
+                parser.setCurrIndex(++endContext);
+                return;
+            }
+            parser.setCurrIndex(endContext + XMLConstants.TAG_TERM.length);
+            return;
+        }
+        Logger.Instance.WriteExceptionToLogWithMsg("in Command.FillData() out of bounds");
+    }
+    initElements(tokensVector, dataView) {
+        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 XMLConstants.MG_ATTR_ID: {
+                    let fldId = XmlParser.getInt(valueStr);
+                    let fld = dataView.getField(fldId);
+                    if (this._isOwnerFld) {
+                        this.OwnerFld = fld;
+                        this.OwnerFld.setRecompute(this);
+                    }
+                    else {
+                        fld.setRecomputed();
+                        this.AddRecomputeItem(fld);
+                    }
+                    break;
+                }
+                case ConstInterface.MG_ATTR_RECOMPUTEBY:
+                    this.RcmpMode = valueStr[0];
+                    break;
+                case ConstInterface.MG_ATTR_SUB_FORM_RCMP:
+                    this._subFormsOnlyRecomp = true;
+                    break;
+                case ConstInterface.MG_ATTR_HAS_LINK_RECOMPUTES:
+                    this._hasServerLinksRecomputes = true;
+                    break;
+                case XMLConstants.MG_ATTR_NAME:
+                    break;
+                default:
+                    Logger.Instance.WriteExceptionToLogWithMsg("There is no such tag in Recompute class. Insert case to Recompute.initElements for " + attribute);
+                    break;
+            }
+        }
+    }
+    async execute(rec) {
+        let i;
+        let fld;
+        let cmdsToServer = this.Task.getMGData().CmdsToServer;
+        let cmd;
+        try {
+            rec.setInRecompute(true);
+            this.Task.SetInRecompute(true);
+            this.SetSubformsInRecompute(true);
+            let allowServerRecompute = this._hasServerLinksRecomputes ||
+                (this.Task.getForm().AllowedSubformRecompute && await this.checkRefreshSubForms());
+            if (this.RcmpMode !== Recompute_RcmpBy.CLIENT && allowServerRecompute) {
+                let inClient = this._subFormsOnlyRecomp;
+                this.Task.ExecuteClientSubformRefresh = false;
+                if (inClient) {
+                    inClient = await this.Task.prepareCache(true);
+                    if (inClient)
+                        inClient = await this.Task.testAndSet(true);
+                }
+                if (!inClient) {
+                    this.Task.DataView.GetFieldsTab().setServerRcmp(true);
+                    cmd = CommandFactory.CreateRecomputeCommand(this.Task.getTaskTag(), this.OwnerFld.getId(), !this.Task.getForm().AllowedSubformRecompute);
+                    cmdsToServer.Add(cmd);
+                    await RemoteCommandsProcessor.GetInstance().Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);
+                }
+                if (this.Task.ExecuteClientSubformRefresh)
+                    await this.RefreshSubforms();
+                else {
+                    if (await this.recPrefixSubForms())
+                        await this.recSuffixSubForms();
+                    this.Task.CleanDoSubformPrefixSuffix();
+                }
+            }
+            else {
+                try {
+                    FlowMonitorQueue.Instance.addRecompute(this.OwnerFld.getVarName(), this.Task.GetTaskDetails());
+                    if (this._formProps != null)
+                        await this._formProps.RefreshDisplay(false, false);
+                    if (this._ctrlProps != null)
+                        await this._ctrlProps.RefreshDisplay(false, false);
+                    if (this._rcmpOrder != null) {
+                        for (i = 0; i < this._rcmpOrder.length; i++) {
+                            if (this._rcmpOrder.get_Item(i) instanceof FieldBase) {
+                                fld = this._rcmpOrder.get_Item(i);
+                                await this.fldRcmp(fld, true);
+                            }
+                            else if (this._rcmpOrder.get_Item(i) instanceof DataviewHeaderBase) {
+                                let curLnk = this._rcmpOrder.get_Item(i);
+                                await curLnk.getLinkedRecord(rec);
+                                let linkFields = this.Task.DataView.GetFieldsTab().getLinkFields(curLnk.Id);
+                                rec.setInCompute(true);
+                                let saveInForceUpdate = rec.InForceUpdate;
+                                rec.InForceUpdate = false;
+                                for (let j = 0; j < linkFields.length; j++) {
+                                    await this.fldRcmp(linkFields.get_Item(j), false);
+                                    rec.clearFlag((linkFields.get_Item(j)).getId(), Record.FLAG_UPDATED);
+                                    rec.clearFlag((linkFields.get_Item(j)).getId(), Record.FLAG_MODIFIED);
+                                    rec.clearFlag((linkFields.get_Item(j)).getId(), Record.FLAG_CRSR_MODIFIED);
+                                    rec.clearHistoryFlag((linkFields.get_Item(j)).getId());
+                                }
+                                rec.InForceUpdate = saveInForceUpdate;
+                                let retFld = curLnk.ReturnField;
+                                if (retFld != null)
+                                    await this.fldRcmp(retFld, false);
+                                rec.setInCompute(false);
+                                rec.setForceSaveOrg(true);
+                            }
+                        }
+                    }
+                    await this.RefreshSubforms();
+                }
+                catch (e) {
+                    Logger.Instance.WriteExceptionToLogWithMsg("in Recompute.execute(): " + e.Message);
+                }
+            }
+            this.Task.SetInRecompute(false);
+            this.SetSubformsInRecompute(false);
+        }
+        finally {
+            rec.buildLinksPosStr();
+            rec.setInRecompute(false);
+        }
+    }
+    async RefreshSubforms() {
+        if (this.Task.getForm().AllowedSubformRecompute) {
+            let subformsToRefresh = await this.GetSubformsToRefresh();
+            for (let i = 0; i < subformsToRefresh.length; i++) {
+                let subformTask = subformsToRefresh.get_Item(i);
+                await this.Task.SubformRefresh(subformTask, true);
+            }
+        }
+    }
+    async SetSubformsInRecompute(inRecompute) {
+        let subformsToRefresh = await this.GetSubformsToRefresh();
+        for (let i = 0; i < subformsToRefresh.length; i++) {
+            let subformTask = subformsToRefresh.get_Item(i);
+            subformTask.SetInRecompute(inRecompute);
+        }
+    }
+    async fldRcmp(fld, computeField) {
+        if (fld.IsVirtual
+            || ((this.Task.getMode() !== Constants.TASK_MODE_QUERY ||
+                Environment.Instance.allowUpdateInQueryMode(this.Task.getCompIdx())))) {
+            if (!fld.isInEvalProcess()) {
+                if (computeField)
+                    await fld.compute(true);
+                else
+                    await fld.setValueAndStartRecompute(fld.getValue(false), fld.isNull(), true, false, false);
+                await fld.updateDisplay();
+            }
+        }
+    }
+    buildSubFormList() {
+        if (this._subForms === null) {
+            this._subForms = new List();
+            let subTasksTab = this.Task.getSubTasks();
+            if (subTasksTab !== null) {
+                for (let i = 0; i < subTasksTab.getSize(); i = i + 1) {
+                    let subForm = subTasksTab.getTask(i);
+                    if (subForm.getForm().getSubFormCtrl() !== null && subForm.refreshesOn(this.OwnerFld.getId())) {
+                        this._subForms.push(subForm);
+                    }
+                }
+            }
+        }
+    }
+    RemoveSubform(subformTask) {
+        this._subForms.Remove(subformTask);
+    }
+    AddSubform(subformTask) {
+        if (this._subForms === null)
+            this._subForms = new List();
+        if (!this._subForms.Contains(subformTask))
+            this._subForms.push(subformTask);
+    }
+    async recSuffixSubForms() {
+        let i;
+        let subForm;
+        let successful = true;
+        let subformCtrl;
+        this.buildSubFormList();
+        for (i = 0; successful && i < this._subForms.length; i++) {
+            subForm = this._subForms.get_Item(i);
+            subformCtrl = subForm.getForm().getSubFormCtrl();
+            if (subForm.isStarted() && !subformCtrl.RefreshOnVisible &&
+                await subformCtrl.checkProp(PropInterface.PROP_TYPE_AUTO_REFRESH, true) && !subForm.InSelect
+                && subForm.DoSubformPrefixSuffix) {
+                await AccessHelper.eventsManager.handleInternalEventWithTask(subForm, InternalInterface.MG_ACT_REC_SUFFIX);
+                successful = !AccessHelper.eventsManager.GetStopExecutionFlag();
+            }
+        }
+        this.Task.DataView.setPrevCurrRec();
+        return (successful);
+    }
+    async checkRefreshSubForms() {
+        let refresh = !this._subFormsOnlyRecomp;
+        let subformsToRefresh = await this.GetSubformsToRefresh();
+        if (subformsToRefresh.length > 0)
+            refresh = true;
+        return refresh;
+    }
+    async GetSubformsToRefresh() {
+        let subTasks = new List();
+        let subformCtrl;
+        this.buildSubFormList();
+        for (let i = 0; i < this._subForms.length; i++) {
+            let subTask = this._subForms[i];
+            subformCtrl = subTask.getForm().getSubFormCtrl();
+            if (subTask.isStarted() && await subformCtrl.checkProp(PropInterface.PROP_TYPE_AUTO_REFRESH, true) &&
+                !subTask.InSelect && !subTask.InEndTask) {
+                await subformCtrl.checkProp(PropInterface.PROP_TYPE_VISIBLE, true);
+                if (!subformCtrl.isVisible() && !await subformCtrl.checkProp(PropInterface.PROP_TYPE_REFRESH_WHEN_HIDDEN, false))
+                    subformCtrl.RefreshOnVisible = true;
+                else
+                    subTasks.push(subTask);
+            }
+        }
+        return subTasks;
+    }
+    async recPrefixSubForms() {
+        let i;
+        let subForm;
+        let successful = true;
+        let subformCtrl;
+        this.buildSubFormList();
+        for (i = 0; successful && i < this._subForms.length; i++) {
+            subForm = this._subForms.get_Item(i);
+            subformCtrl = subForm.getForm().getSubFormCtrl();
+            if (subForm.isStarted() && !subformCtrl.RefreshOnVisible
+                && await subformCtrl.checkProp(PropInterface.PROP_TYPE_AUTO_REFRESH, true)
+                && !subForm.InSelect && subForm.DoSubformPrefixSuffix) {
+                await AccessHelper.eventsManager.handleInternalEventWithTaskAndSubformRefresh(subForm, InternalInterface.MG_ACT_REC_PREFIX, true);
+                successful = !AccessHelper.eventsManager.GetStopExecutionFlag();
+            }
+        }
+        return successful;
+    }
+    notifyServerOnChange() {
+        return this.RcmpMode === Recompute_RcmpBy.SERVER_ON_CHANGE;
+    }
+    isServerRcmp() {
+        return this.RcmpMode !== Recompute_RcmpBy.CLIENT;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Recompute.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/rt/Recompute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,aAAa,EAAE,SAAS,EAAC,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAC,SAAS,EAAC,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAC,IAAI,EAAC,MAAM,sBAAsB,CAAC;AAE1C,OAAO,EAAC,wCAAwC,EAAC,MAAM,0BAA0B,CAAC;AAClF,OAAO,EAAC,SAAS,EAAE,iBAAiB,EAAE,MAAM,EAAE,YAAY,EAAE,SAAS,EAAC,MAAM,kBAAkB,CAAC;AAC/F,OAAO,EAAC,MAAM,EAAC,MAAM,gBAAgB,CAAC;AAGtC,OAAO,EAAC,cAAc,EAAC,MAAM,2CAA2C,CAAC;AACzE,OAAO,EAAC,uBAAuB,EAAC,MAAM,mCAAmC,CAAC;AAC1E,OAAO,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAI1D,OAAO,EAAC,cAAc,EAAC,MAAM,mBAAmB,CAAC;AAEjD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C,MAAM,CAAN,IAAY,gBAGX;AAHD,WAAY,gBAAgB;IAC1B,gCAAY,CAAA;IACZ,0CAAsB,CAAA;AACxB,CAAC,EAHW,gBAAgB,KAAhB,gBAAgB,QAG3B;AAED,MAAM,OAAO,SAAS;IACZ,UAAU,GAAc,IAAI,CAAC;IAC7B,UAAU,GAAc,IAAI,CAAC;IAC7B,WAAW,GAAY,IAAI,CAAC;IACpC,QAAQ,GAAc,IAAI,CAAC;IAEnB,UAAU,GAAyC,IAAI,CAAC;IACxD,SAAS,GAAe,IAAI,CAAC;IAC7B,mBAAmB,GAAY,KAAK,CAAC;IACrC,yBAAyB,GAAY,KAAK,CAAC;IACnD,QAAQ,GAAqB,IAAI,CAAC;IAElC,IAAI,GAAS,IAAI,CAAC;IAElB;IACA,CAAC;IAOD,QAAQ,CAAC,QAAkB,EAAE,OAAa,EAAE,MAAiB;QAE3D,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC;QACpB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACxB,OAAO,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,MAAM,CAAC,UAAU,EAAE,EAAE,QAAQ,CAAC,EAAE,CAAC;QACtE,CAAC;IACH,CAAC;IAMO,gBAAgB,CAAC,MAAiB,EAAE,YAAoB,EAAE,QAAkB;QAClF,QAAQ,YAAY,EAAE,CAAC;YACrB,KAAK,YAAY,CAAC,UAAU;gBAE1B,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;oBACrB,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;oBACpC,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;gBAC3B,CAAC;;oBAEC,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;gBACtC,MAAM;YAER,KAAK,cAAc,CAAC,WAAW;gBAC7B,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;gBAChC,MAAM;YAER,KAAK,YAAY,CAAC,cAAc;gBAC9B,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI;oBACzB,IAAI,CAAC,UAAU,GAAG,IAAI,SAAS,EAAE,CAAC;gBAGpC,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;gBAGpD,IAAI,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,IAAI,IAAI,IAAI,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,CAAC,YAAY,IAAI,IAAI,CAAC,QAAQ,CAAC,SAAS;oBAC9G,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,CAAC;oBAC7B,IAAI,CAAC,QAAQ,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAC;gBAC7C,MAAM;YAER,KAAK,YAAY,CAAC,sBAAsB;gBACtC,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI;oBACzB,IAAI,CAAC,UAAU,GAAG,IAAI,SAAS,EAAE,CAAC;gBAGpC,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;gBACpD,MAAM;YAER,KAAK,cAAc,CAAC,cAAc;gBAChC,MAAM,CAAC,qBAAqB,EAAE,CAAC;gBAC/B,OAAO,KAAK,CAAC;YAEf;gBACE,MAAM,CAAC,QAAQ,CAAC,0BAA0B,CAAC,sFAAsF,GAAG,YAAY,CAAC,CAAC;gBAClJ,OAAO,KAAK,CAAC;QACjB,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,gBAAgB,CAAC,IAAoC;QAC3D,IAAI,IAAI,CAAC,UAAU,KAAK,IAAI;YAC1B,IAAI,CAAC,UAAU,GAAG,IAAI,IAAI,EAAE,CAAC;QAC/B,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC7B,CAAC;IAKO,QAAQ,CAAC,MAAiB,EAAE,QAAkB;QACpD,IAAI,UAAU,GAAW,MAAM,CAAC,UAAU,EAAE,CAAC,OAAO,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC;QACnG,IAAI,UAAU,KAAK,CAAC,CAAC,IAAI,UAAU,GAAG,MAAM,CAAC,UAAU,EAAE,CAAC,MAAM,EAAE,CAAC;YAEjE,IAAI,GAAG,GAAW,MAAM,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;YACrD,MAAM,CAAC,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,cAAc,CAAC,WAAW,CAAC,GAAG,cAAc,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;YAElG,IAAI,YAAY,GAAiB,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,eAAe,CAAC,UAAU,CAAC,EAAE,YAAY,CAAC,cAAc,CAAC,CAAC;YAEtH,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;gBACxD,IAAI,SAAS,GAAW,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;gBACnD,IAAI,QAAQ,GAAW,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;gBAEtD,IAAI,SAAS,KAAK,YAAY,CAAC,UAAU;oBACvC,IAAI,CAAC,gBAAgB,CAAQ,QAAQ,CAAC,OAAO,EAAG,CAAC,kBAAkB,EAAE,CAAC,qBAAqB,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;;oBAEtH,MAAM,CAAC,QAAQ,CAAC,0BAA0B,CAAC,iFAAiF,GAAG,SAAS,CAAC,CAAC;YACjJ,CAAC;YACD,MAAM,CAAC,YAAY,CAAC,UAAU,GAAG,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;YAC/D,OAAO;QACT,CAAC;;YAEC,MAAM,CAAC,QAAQ,CAAC,0BAA0B,CAAC,uCAAuC,CAAC,CAAC;IACxF,CAAC;IASO,YAAY,CAAC,MAAiB,EAAE,QAAkB;QACxD,IAAI,UAAU,GAAW,MAAM,CAAC,UAAU,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW;YACnE,CAAC,CAAC,YAAY,CAAC,SAAS;YACxB,CAAC,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC;QAElD,IAAI,UAAU,KAAK,CAAC,CAAC,IAAI,UAAU,GAAG,MAAM,CAAC,UAAU,EAAE,CAAC,MAAM,EAAE,CAAC;YAGjE,IAAI,GAAG,GAAW,MAAM,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;YACrD,MAAM,CAAC,aAAa,CAAC,GAAG,CAAC,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,GAAG,YAAY,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;YAE5F,IAAI,YAAY,GAAiB,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,eAAe,CAAC,UAAU,CAAC,EACrF,YAAY,CAAC,cAAc,CAAC,CAAC;YAC/B,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;YAC1C,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;gBACrB,MAAM,CAAC,YAAY,CAAC,EAAE,UAAU,CAAC,CAAC;gBAClC,OAAO;YACT,CAAC;YACD,MAAM,CAAC,YAAY,CAAC,UAAU,GAAG,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;YAC/D,OAAO;QACT,CAAC;QACD,MAAM,CAAC,QAAQ,CAAC,0BAA0B,CAAC,qCAAqC,CAAC,CAAC;IACpF,CAAC;IAWO,YAAY,CAAC,YAA0B,EAAE,QAAkB;QACjE,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;YACxD,IAAI,SAAS,GAAW,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;YACnD,IAAI,QAAQ,GAAW,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YAEtD,QAAQ,SAAS,EAAE,CAAC;gBAClB,KAAK,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC;oBAC7B,IAAI,KAAK,GAAW,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;oBAC/C,IAAI,GAAG,GAAc,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;oBAC9C,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;wBACrB,IAAI,CAAC,QAAQ,GAAG,GAAG,CAAC;wBACpB,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;oBACnC,CAAC;yBACI,CAAC;wBACJ,GAAG,CAAC,aAAa,EAAE,CAAC;wBACpB,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;oBAC7B,CAAC;oBACD,MAAM;gBACR,CAAC;gBACD,KAAK,cAAc,CAAC,mBAAmB;oBACrC,IAAI,CAAC,QAAQ,GAAqB,QAAQ,CAAC,CAAC,CAAC,CAAC;oBAC9C,MAAM;gBAER,KAAK,cAAc,CAAC,qBAAqB;oBACvC,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;oBAChC,MAAM;gBAER,KAAK,cAAc,CAAC,2BAA2B;oBAC7C,IAAI,CAAC,yBAAyB,GAAG,IAAI,CAAC;oBACtC,MAAM;gBAER,KAAK,YAAY,CAAC,YAAY;oBAE5B,MAAM;gBAER;oBACE,MAAM,CAAC,QAAQ,CAAC,0BAA0B,CAAC,qFAAqF,GAAG,SAAS,CAAC,CAAC;oBAC9I,MAAM;YACV,CAAC;QACH,CAAC;IACH,CAAC;IAMM,KAAK,CAAC,OAAO,CAAC,GAAW;QAC9B,IAAI,CAAS,CAAC;QACd,IAAI,GAAc,CAAC;QACnB,IAAI,YAAY,GAAiC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,YAAY,CAAC;QACpF,IAAI,GAAmB,CAAC;QAExB,IAAI,CAAC;YACH,GAAG,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;YACzB,IAAI,CAAC,IAAI,CAAC,cAAc,CAAE,IAAI,CAAC,CAAC;YAChC,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAC;YAClC,IAAI,oBAAoB,GAAY,IAAI,CAAC,yBAAyB;gBAC9D,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,uBAAuB,IAAI,MAAM,IAAI,CAAC,oBAAoB,EAAE,CAAC,CAAC;YAGvF,IAAI,IAAI,CAAC,QAAQ,KAAK,gBAAgB,CAAC,MAAM,IAAI,oBAAoB,EAAE,CAAC;gBACtE,IAAI,QAAQ,GAAY,IAAI,CAAC,mBAAmB,CAAC;gBACjD,IAAI,CAAC,IAAI,CAAC,2BAA2B,GAAG,KAAK,CAAC;gBAG9C,IAAI,QAAQ,EAAE,CAAC;oBACb,QAAQ,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;oBAE9C,IAAI,QAAQ;wBACV,QAAQ,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;gBAChD,CAAC;gBACD,IAAI,CAAC,QAAQ,EAAE,CAAC;oBACA,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAG,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;oBACrE,GAAG,GAAG,cAAc,CAAC,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,uBAAuB,CAAC,CAAC;oBACzI,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;oBACtB,MAAM,uBAAuB,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,wCAAwC,CAAC,kBAAkB,CAAC,CAAC;gBACnH,CAAC;gBACD,IAAI,IAAI,CAAC,IAAI,CAAC,2BAA2B;oBACvC,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;qBAC1B,CAAC;oBACJ,IAAI,MAAM,IAAI,CAAC,iBAAiB,EAAE;wBAChC,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC;oBACjC,IAAI,CAAC,IAAI,CAAC,0BAA0B,EAAE,CAAC;gBACzC,CAAC;YACH,CAAC;iBAEI,CAAC;gBACJ,IAAI,CAAC;oBACH,gBAAgB,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;oBAG/F,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI;wBACzB,MAAM,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;oBAGrD,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI;wBACzB,MAAM,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;oBAGrD,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI,EAAE,CAAC;wBAC5B,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;4BAC5C,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,YAAY,SAAS,EAAE,CAAC;gCACrD,GAAG,GAAc,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gCAC7C,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;4BAChC,CAAC;iCACI,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,YAAY,kBAAkB,EAAE,CAAC;gCACnE,IAAI,MAAM,GAAuB,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gCAC7D,MAAM,MAAM,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;gCAGlC,IAAI,UAAU,GAAkC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAG,CAAC,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;gCAC5G,GAAG,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;gCACvB,IAAI,iBAAiB,GAAY,GAAG,CAAC,aAAa,CAAC;gCACnD,GAAG,CAAC,aAAa,GAAG,KAAK,CAAC;gCAE1B,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oCACnD,MAAM,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;oCAClD,GAAG,CAAC,SAAS,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,MAAM,CAAC,YAAY,CAAC,CAAC;oCACrE,GAAG,CAAC,SAAS,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,MAAM,CAAC,aAAa,CAAC,CAAC;oCACtE,GAAG,CAAC,SAAS,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,MAAM,CAAC,kBAAkB,CAAC,CAAC;oCAC3E,GAAG,CAAC,gBAAgB,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC;gCACzD,CAAC;gCACD,GAAG,CAAC,aAAa,GAAG,iBAAiB,CAAC;gCAGtC,IAAI,MAAM,GAAc,MAAM,CAAC,WAAW,CAAC;gCAC3C,IAAI,MAAM,IAAI,IAAI;oCAChB,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;gCAEpC,GAAG,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;gCACxB,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;4BAC5B,CAAC;wBACH,CAAC;oBACH,CAAC;oBACD,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;gBAC/B,CAAC;gBACD,OAAO,CAAC,EAAE,CAAC;oBACT,MAAM,CAAC,QAAQ,CAAC,0BAA0B,CAAC,0BAA0B,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC;gBACrF,CAAC;YAEH,CAAC;YACD,IAAI,CAAC,IAAI,CAAC,cAAc,CAAE,KAAK,CAAC,CAAC;YACjC,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC;QACrC,CAAC;gBAEO,CAAC;YACP,GAAG,CAAC,gBAAgB,EAAE,CAAC;YACvB,GAAG,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC;IAKO,KAAK,CAAC,eAAe;QAC3B,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,uBAAuB,EAAE,CAAC;YAChD,IAAI,iBAAiB,GAAe,MAAM,IAAI,CAAC,oBAAoB,EAAE,CAAC;YACtE,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,iBAAiB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC1D,IAAI,WAAW,GAAS,iBAAiB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBACtD,MAAM,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;YACpD,CAAC;QAEH,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,sBAAsB,CAAC,WAAoB;QAErD,IAAI,iBAAiB,GAAe,MAAM,IAAI,CAAC,oBAAoB,EAAE,CAAC;QACtE,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,iBAAiB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC1D,IAAI,WAAW,GAAS,iBAAiB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;YACpD,WAAW,CAAC,cAAc,CAAC,WAAW,CAAC,CAAC;QAC5C,CAAC;IACL,CAAC;IAMO,KAAK,CAAC,OAAO,CAAC,GAAc,EAAE,YAAqB;QACzD,IAAI,GAAG,CAAC,SAAS;eACZ,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,SAAS,CAAC,eAAe;gBACpD,WAAW,CAAC,QAAQ,CAAC,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC1E,IAAI,CAAC,GAAG,CAAC,eAAe,EAAE,EAAE,CAAC;gBAC3B,IAAI,YAAY;oBACd,MAAM,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;;oBAExB,MAAM,GAAG,CAAC,yBAAyB,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;gBAC7F,MAAM,GAAG,CAAC,aAAa,EAAE,CAAC;YAC5B,CAAC;QACH,CAAC;IACH,CAAC;IAIO,gBAAgB;QACtB,IAAI,IAAI,CAAC,SAAS,KAAK,IAAI,EAAE,CAAC;YAC5B,IAAI,CAAC,SAAS,GAAG,IAAI,IAAI,EAAQ,CAAC;YAClC,IAAI,WAAW,GAAe,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YAEtD,IAAI,WAAW,KAAK,IAAI,EAAE,CAAC;gBACzB,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,OAAO,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;oBAC7D,IAAI,OAAO,GAAe,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;oBAEjD,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC,cAAc,EAAE,KAAK,IAAI,IAAI,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC;wBAC9F,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;oBAC/B,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAMD,aAAa,CAAC,WAAiB;QAC7B,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IACrC,CAAC;IAMD,UAAU,CAAC,WAAiB;QAC1B,IAAI,IAAI,CAAC,SAAS,KAAK,IAAI;YACzB,IAAI,CAAC,SAAS,GAAG,IAAI,IAAI,EAAQ,CAAC;QACpC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC;YACvC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACrC,CAAC;IAMO,KAAK,CAAC,iBAAiB;QAC7B,IAAI,CAAS,CAAC;QACd,IAAI,OAAa,CAAC;QAClB,IAAI,UAAU,GAAY,IAAI,CAAC;QAC/B,IAAI,WAAsB,CAAC;QAG3B,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAGxB,KAAK,CAAC,GAAG,CAAC,EAAE,UAAU,IAAI,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACzD,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;YACrC,WAAW,GAAc,OAAO,CAAC,OAAO,EAAE,CAAC,cAAc,EAAE,CAAC;YAC5D,IAAI,OAAO,CAAC,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC,gBAAgB;gBACtD,MAAM,WAAW,CAAC,SAAS,CAAC,aAAa,CAAC,sBAAsB,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ;mBACzF,OAAO,CAAC,qBAAqB,EAAE,CAAC;gBACnC,MAAM,YAAY,CAAC,aAAa,CAAC,2BAA2B,CAAC,OAAO,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;gBAC3G,UAAU,GAAG,CAAC,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE,CAAC;YAClE,CAAC;QACH,CAAC;QACU,IAAI,CAAC,IAAI,CAAC,QAAS,CAAC,cAAc,EAAE,CAAC;QAChD,OAAO,CAAC,UAAU,CAAC,CAAC;IACtB,CAAC;IAGO,KAAK,CAAC,oBAAoB;QAChC,IAAI,OAAO,GAAY,CAAC,IAAI,CAAC,mBAAmB,CAAC;QACjD,IAAI,iBAAiB,GAAe,MAAM,IAAI,CAAC,oBAAoB,EAAE,CAAC;QACtE,IAAI,iBAAiB,CAAC,MAAM,GAAG,CAAC;YAC9B,OAAO,GAAG,IAAI,CAAC;QACjB,OAAO,OAAO,CAAC;IACjB,CAAC;IAMO,KAAK,CAAC,oBAAoB;QAEhC,IAAI,QAAQ,GAAe,IAAI,IAAI,EAAQ,CAAC;QAC5C,IAAI,WAAsB,CAAC;QAE3B,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAExB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAC,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAC5C,CAAC;YACC,IAAI,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YAChC,WAAW,GAAc,OAAO,CAAC,OAAO,EAAE,CAAC,cAAc,EAAE,CAAC;YAC5D,IAAI,OAAO,CAAC,SAAS,EAAE,IAAI,MAAO,WAAW,CAAC,SAAS,CAAC,aAAa,CAAC,sBAAsB,EAAE,IAAI,CAAC;gBACjG,CAAC,OAAO,CAAC,QAAQ,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC;gBAG1C,MAAM,WAAW,CAAC,SAAS,CAAC,aAAa,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAC;gBACnE,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,IAAI,CAAC,MAAM,WAAW,CAAC,SAAS,CAAC,aAAa,CAAC,6BAA6B,EAAE,KAAK,CAAC;oBAC9G,WAAW,CAAC,gBAAgB,GAAG,IAAI,CAAC;;oBACjC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC9B,CAAC;QACH,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAMO,KAAK,CAAC,iBAAiB;QAC7B,IAAI,CAAS,CAAC;QACd,IAAI,OAAa,CAAC;QAClB,IAAI,UAAU,GAAY,IAAI,CAAC;QAC/B,IAAI,WAAsB,CAAC;QAG3B,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAGxB,KAAK,CAAC,GAAG,CAAC,EAAE,UAAU,IAAI,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACzD,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;YACrC,WAAW,GAAc,OAAO,CAAC,OAAO,EAAE,CAAC,cAAc,EAAE,CAAC;YAC5D,IAAI,OAAO,CAAC,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC,gBAAgB;mBACnD,MAAO,WAAW,CAAC,SAAS,CAAC,aAAa,CAAC,sBAAsB,EAAE,IAAI,CAAC;mBACxE,CAAC,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,qBAAqB,EAAE,CAAC;gBACxD,MAAM,YAAY,CAAC,aAAa,CAAC,4CAA4C,CAAC,OAAO,EAAE,iBAAiB,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAC;gBAClI,UAAU,GAAG,CAAC,YAAY,CAAC,aAAa,CAAC,oBAAoB,EAAE,CAAC;YAClE,CAAC;QACH,CAAC;QACD,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,oBAAoB;QAClB,OAAO,IAAI,CAAC,QAAQ,KAAK,gBAAgB,CAAC,gBAAgB,CAAC;IAC7D,CAAC;IAGD,YAAY;QACV,OAAO,IAAI,CAAC,QAAQ,KAAK,gBAAgB,CAAC,MAAM,CAAC;IACnD,CAAC;CAEF","sourcesContent":["import {PropInterface, PropTable} from \"@magic-xpa/gui\";\r\nimport {FieldBase} from \"../data/FieldBase\";\r\nimport {List} from \"@magic-xpa/mscorelib\";\r\nimport {Task} from \"../tasks/Task\";\r\nimport {CommandsProcessorBase_SendingInstruction} from \"../CommandsProcessorBase\";\r\nimport {Constants, InternalInterface, Logger, XMLConstants, XmlParser} from \"@magic-xpa/utils\";\r\nimport {Record} from \"../data/Record\";\r\nimport {CommandsTable} from \"../CommandsTable\";\r\nimport {IClientCommand} from \"../commands/IClientCommand\";\r\nimport {CommandFactory} from \"../commands/ClientToServer/CommandFactory\";\r\nimport {RemoteCommandsProcessor} from \"../remote/RemoteCommandsProcessor\";\r\nimport {DataviewHeaderBase} from \"./DataviewHeaderBase\";\r\nimport {FlowMonitorQueue} from \"../util/FlowMonitorQueue\";\r\nimport {FieldsTableExt as FieldsTable } from \"../data/FieldsTable\";\r\nimport {TasksTable} from \"../tasks/TasksTable\";\r\nimport {MgControl} from \"../gui/MgControl\";\r\nimport {ConstInterface} from \"../ConstInterface\";\r\nimport {DataView} from \"../data/DataView\";\r\nimport { Environment } from \"../env/Environment\";\r\nimport { AccessHelper } from \"../AccessHelper\";\r\n\r\nexport enum Recompute_RcmpBy {\r\n  CLIENT = 'C',\r\n  SERVER_ON_CHANGE = 'O'\r\n}\r\n\r\nexport class Recompute {\r\n  private _ctrlProps: PropTable = null; // affected control properties\r\n  private _formProps: PropTable = null; // affected form properties\r\n  private _isOwnerFld: boolean = true; // denotes if the current parsed field tag is the owner field\r\n  OwnerFld: FieldBase = null; // the field that owns this recompute structure\r\n\r\n  private _rcmpOrder: List<FieldBase | DataviewHeaderBase> = null; // affected fields and links. Can't use List<T> - holds both fields and links\r\n  private _subForms: List<Task> = null; // subforms (tasks) affected by this recompute\r\n  private _subFormsOnlyRecomp: boolean = false;\r\n  private _hasServerLinksRecomputes: boolean = false; // true, if the field has any link recomputes and it is a server recompute\r\n  RcmpMode: Recompute_RcmpBy = null;  // Who (and when) performs rcmp (by client,\r\n\r\n  Task: Task = null; // a reference to the task of this Recompute\r\n\r\n  constructor(){\r\n  }\r\n  /// <summary>\r\n  ///   to fill all relevant data for <fld ...> ...</fld> tag\r\n  /// </summary>\r\n  /// <param name = \"dataView\">reference to all DataView object, which consist relevant fields </param>\r\n  /// <param name = \"taskRef\">to parent task, which need be initialized in ControlTable.Control.task </param>\r\n  /// <returns> index of the end of current <fld ...>=> </fld> </returns>\r\n  fillData(dataView: DataView, taskRef: Task, parser: XmlParser): void {\r\n\r\n    this.Task = taskRef;\r\n    this._isOwnerFld = true; // start of new <fld> tag\r\n    while (this.initInnerObjects(parser, parser.getNextTag(), dataView)) {\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Fill inner members and needed links for the current 'fld'\r\n  /// </summary>\r\n  /// <param name = \"((DataView)dataView)\">reference to all DataView object, which consist relevant fields </param>\r\n  private initInnerObjects(parser: XmlParser, foundTagName: string, dataView: DataView): boolean {\r\n    switch (foundTagName) {\r\n      case XMLConstants.MG_TAG_FLD:\r\n        // init <fld id = recompute_by=> first time, init reference by id\r\n        if (this._isOwnerFld) {\r\n          this.fillFldField(parser, dataView);\r\n          this._isOwnerFld = false; // must to be after FillFldField\r\n        }\r\n        else\r\n          this.fillFldField(parser, dataView); // it's not need ((DataView)dataView), it's not first <fld >\r\n        break;\r\n\r\n      case ConstInterface.MG_TAG_LINK:\r\n        this.fillLink(parser, dataView);\r\n        break;\r\n\r\n      case XMLConstants.MG_TAG_CONTROL:\r\n        if (this._ctrlProps == null)\r\n          this._ctrlProps = new PropTable();\r\n\r\n        // fill the prop table using the existing properties\r\n        this._ctrlProps.fillDataByExists(this.Task, parser);\r\n\r\n        // if virtual field causes recompute of repeatable control\r\n        if (this._ctrlProps.getCtrlRef() != null && this._ctrlProps.getCtrlRef().IsRepeatable && this.OwnerFld.IsVirtual &&\r\n          !(this.OwnerFld.hasInitExp()))\r\n          this.OwnerFld.causeTableInvalidation(true);\r\n        break;\r\n\r\n      case XMLConstants.MG_TAG_FORM_PROPERTIES:\r\n        if (this._formProps == null)\r\n          this._formProps = new PropTable();\r\n\r\n        // fill the prop table using the existing properties\r\n        this._formProps.fillDataByExists(this.Task, parser);\r\n        break;\r\n\r\n      case ConstInterface.MG_TAG_FLD_END:\r\n        parser.setCurrIndex2EndOfTag();\r\n        return false;\r\n\r\n      default:\r\n        Logger.Instance.WriteExceptionToLogWithMsg(\"There is no such tag in Recompute. Insert else if to Recompute.initInnerObjects for \" + foundTagName);\r\n        return false;\r\n    }\r\n    return true;\r\n  }\r\n\r\n  private AddRecomputeItem(item: FieldBase | DataviewHeaderBase): void {\r\n    if (this._rcmpOrder === null)\r\n      this._rcmpOrder = new List();\r\n    this._rcmpOrder.push(item);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   fill the recomputed link data (only id)\r\n  /// </summary>\r\n  private fillLink(parser: XmlParser, dataView: DataView): void {\r\n    let endContext: number = parser.getXMLdata().indexOf(XMLConstants.TAG_TERM, 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_LINK) + ConstInterface.MG_TAG_LINK.length);\r\n\r\n      let tokensVector: List<string> = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);\r\n\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        if (attribute === XMLConstants.MG_ATTR_ID)\r\n          this.AddRecomputeItem((<Task>dataView.getTask()).getDataviewHeaders().getDataviewHeaderById(XmlParser.getInt(valueStr)));\r\n\r\n        else Logger.Instance.WriteExceptionToLogWithMsg(\"There is no such tag in Recompute class. Insert case to Recompute.fillLink for \" + attribute);\r\n      }\r\n      parser.setCurrIndex(endContext + XMLConstants.TAG_TERM.length); // to delete \"/>\" too\r\n      return;\r\n    }\r\n    else\r\n      Logger.Instance.WriteExceptionToLogWithMsg(\"in Recompute.fillLink() out of bounds\");\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Init RecomputeBy member and init reference from the FieldRoot to the Recompute object\r\n  /// </summary>\r\n  /// <param name = \"xmlParser.getXMLdata()\">, input string full XML.innerText </param>\r\n  /// <param name = \"xmlParser.getCurrIndex()\">, index of start first <fld ...> tag </param>\r\n  /// <param name = \"((DataView)dataView)\">reference to all DataView object, which consist relevant fields </param>\r\n  /// <returns> index of end of <fld ...> tag </returns>\r\n  private fillFldField(parser: XmlParser, dataView: DataView): void {\r\n    let endContext: number = parser.getXMLdata().indexOf(this._isOwnerFld\r\n      ? XMLConstants.TAG_CLOSE\r\n      : XMLConstants.TAG_TERM, 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(XMLConstants.MG_TAG_FLD) + XMLConstants.MG_TAG_FLD.length);\r\n\r\n      let tokensVector: List<string> = XmlParser.getTokens(parser.getXMLsubstring(endContext),\r\n        XMLConstants.XML_ATTR_DELIM);\r\n      this.initElements(tokensVector, dataView);\r\n      if (this._isOwnerFld) {\r\n        parser.setCurrIndex(++endContext);\r\n        return;\r\n      }\r\n      parser.setCurrIndex(endContext + XMLConstants.TAG_TERM.length);\r\n      return;\r\n    }\r\n    Logger.Instance.WriteExceptionToLogWithMsg(\"in Command.FillData() out of 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 element </param>\r\n  /// <param name = \"((DataView)dataView)\">reference to field objects, for <fld id = ...>\r\n  ///                                                            if ((DataView)dataView)==null=> it's first found field, need to init reference\r\n  ///                                                            from the FieldRoot\r\n  ///                                                            if ((DataView)dataView)!=null=> add the data to currient Record, it's not first <fld>\r\n  /// </param>\r\n  private initElements(tokensVector: List<string>, dataView: DataView): 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 XMLConstants.MG_ATTR_ID: {\r\n          let fldId: number = XmlParser.getInt(valueStr);\r\n          let fld = <FieldBase>dataView.getField(fldId);\r\n          if (this._isOwnerFld) {\r\n            this.OwnerFld = fld;\r\n            this.OwnerFld.setRecompute(this);\r\n          }\r\n          else {\r\n            fld.setRecomputed();\r\n            this.AddRecomputeItem(fld);\r\n          }\r\n          break;\r\n        }\r\n        case ConstInterface.MG_ATTR_RECOMPUTEBY:\r\n          this.RcmpMode = <Recompute_RcmpBy>valueStr[0];\r\n          break;\r\n\r\n        case ConstInterface.MG_ATTR_SUB_FORM_RCMP:\r\n          this._subFormsOnlyRecomp = true;\r\n          break;\r\n\r\n        case ConstInterface.MG_ATTR_HAS_LINK_RECOMPUTES:\r\n          this._hasServerLinksRecomputes = true;\r\n          break;\r\n\r\n        case XMLConstants.MG_ATTR_NAME:\r\n          /* ignore the name */\r\n          break;\r\n\r\n        default:\r\n          Logger.Instance.WriteExceptionToLogWithMsg(\"There is no such tag in Recompute class. Insert case to Recompute.initElements for \" + attribute);\r\n          break;\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   execute recompute\r\n  /// </summary>\r\n  /// <param name = \"rec\">the record on which the recompute is executed</param>\r\n  public async execute(rec: Record): Promise<void> {\r\n    let i: number;\r\n    let fld: FieldBase;\r\n    let cmdsToServer: CommandsTable = <CommandsTable>this.Task.getMGData().CmdsToServer;\r\n    let cmd: IClientCommand;\r\n\r\n    try {\r\n      rec.setInRecompute(true);\r\n      this.Task.SetInRecompute (true);\r\n      this.SetSubformsInRecompute(true);\r\n      let allowServerRecompute: boolean = this._hasServerLinksRecomputes ||\r\n          (this.Task.getForm().AllowedSubformRecompute && await this.checkRefreshSubForms());\r\n\r\n      // SERVER\r\n      if (this.RcmpMode !== Recompute_RcmpBy.CLIENT && allowServerRecompute) {\r\n        let inClient: boolean = this._subFormsOnlyRecomp;\r\n        this.Task.ExecuteClientSubformRefresh = false;\r\n\r\n        // if the recompute is not only due to sub-forms go to server\r\n        if (inClient) {\r\n          inClient = await this.Task.prepareCache(true);\r\n          // if all sub-form are not update\r\n          if (inClient)\r\n            inClient = await this.Task.testAndSet(true); // try to take dataviews from cache\r\n        }\r\n        if (!inClient) {\r\n          (<FieldsTable>this.Task.DataView.GetFieldsTab()).setServerRcmp(true);\r\n          cmd = CommandFactory.CreateRecomputeCommand(this.Task.getTaskTag(), this.OwnerFld.getId(), !this.Task.getForm().AllowedSubformRecompute);\r\n          cmdsToServer.Add(cmd);\r\n          await RemoteCommandsProcessor.GetInstance().Execute(CommandsProcessorBase_SendingInstruction.TASKS_AND_COMMANDS);\r\n        }\r\n        if (this.Task.ExecuteClientSubformRefresh)\r\n          await this.RefreshSubforms();\r\n        else {\r\n          if (await this.recPrefixSubForms())\r\n            await this.recSuffixSubForms();\r\n          this.Task.CleanDoSubformPrefixSuffix();\r\n        }\r\n      }\r\n      // CLIENT\r\n      else {\r\n        try {\r\n          FlowMonitorQueue.Instance.addRecompute(this.OwnerFld.getVarName(), this.Task.GetTaskDetails());\r\n\r\n          // FORM PROPERTIES\r\n          if (this._formProps != null)\r\n            await this._formProps.RefreshDisplay(false, false);\r\n\r\n          // CTRL PROPERTIES\r\n          if (this._ctrlProps != null)\r\n            await this._ctrlProps.RefreshDisplay(false, false);\r\n\r\n          // re-cumpute client side fields and links\r\n          if (this._rcmpOrder != null) {\r\n            for (i = 0; i < this._rcmpOrder.length; i++) {\r\n              if (this._rcmpOrder.get_Item(i) instanceof FieldBase) {\r\n                fld = <FieldBase>this._rcmpOrder.get_Item(i);\r\n                await this.fldRcmp(fld, true);\r\n              }\r\n              else if (this._rcmpOrder.get_Item(i) instanceof DataviewHeaderBase) {\r\n                let curLnk = <DataviewHeaderBase>this._rcmpOrder.get_Item(i);\r\n                await curLnk.getLinkedRecord(rec);\r\n\r\n                // if we have recomputed a link we should also start the recompute process on all of its fields\r\n                let linkFields: List<FieldBase> = (<FieldsTable>this.Task.DataView.GetFieldsTab()).getLinkFields(curLnk.Id);\r\n                rec.setInCompute(true);\r\n                let saveInForceUpdate: boolean = rec.InForceUpdate;\r\n                rec.InForceUpdate = false;\r\n\r\n                for (let j: number = 0; j < linkFields.length; j++) {\r\n                  await this.fldRcmp(linkFields.get_Item(j), false);\r\n                  rec.clearFlag((linkFields.get_Item(j)).getId(), Record.FLAG_UPDATED);\r\n                  rec.clearFlag((linkFields.get_Item(j)).getId(), Record.FLAG_MODIFIED);\r\n                  rec.clearFlag((linkFields.get_Item(j)).getId(), Record.FLAG_CRSR_MODIFIED);\r\n                  rec.clearHistoryFlag((linkFields.get_Item(j)).getId());\r\n                }\r\n                rec.InForceUpdate = saveInForceUpdate;\r\n\r\n                // start recompute process on the ret val of the link\r\n                let retFld: FieldBase = curLnk.ReturnField;\r\n                if (retFld != null)\r\n                  await this.fldRcmp(retFld, false);\r\n\r\n                rec.setInCompute(false);\r\n                rec.setForceSaveOrg(true);\r\n              }\r\n            }\r\n          }\r\n          await this.RefreshSubforms();\r\n        }\r\n        catch (e) {\r\n          Logger.Instance.WriteExceptionToLogWithMsg(\"in Recompute.execute(): \" + e.Message);\r\n        }\r\n\r\n      }  // END CLIENT BLOCK\r\n      this.Task.SetInRecompute (false);\r\n      this.SetSubformsInRecompute(false);\r\n    }\r\n\r\n    finally {\r\n      rec.buildLinksPosStr();\r\n      rec.setInRecompute(false);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  // Subforms recompute\r\n  /// </summary>\r\n  private async RefreshSubforms(): Promise<void> {\r\n    if (this.Task.getForm().AllowedSubformRecompute) {\r\n      let subformsToRefresh: List<Task> = await this.GetSubformsToRefresh();\r\n      for (let i: number = 0; i < subformsToRefresh.length; i++) {\r\n        let subformTask: Task = subformsToRefresh.get_Item(i);\r\n        await this.Task.SubformRefresh(subformTask, true);\r\n      }\r\n\r\n    }\r\n  }\r\n\r\n  private async SetSubformsInRecompute(inRecompute: boolean): Promise<void> {\r\n\r\n      let subformsToRefresh: List<Task> = await this.GetSubformsToRefresh();\r\n      for (let i: number = 0; i < subformsToRefresh.length; i++) {\r\n        let subformTask: Task = subformsToRefresh.get_Item(i);\r\n          subformTask.SetInRecompute(inRecompute);\r\n      }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   a helper function to recompute fields\r\n  /// </summary>\r\n  /// <param name = \"fld\">- the fiedl to recompute</param>\r\n  private async fldRcmp(fld: FieldBase, computeField: boolean): Promise<void> {\r\n    if (fld.IsVirtual\r\n      || ((this.Task.getMode() !== Constants.TASK_MODE_QUERY ||\r\n        Environment.Instance.allowUpdateInQueryMode(this.Task.getCompIdx())))) {\r\n      if (!fld.isInEvalProcess()) {\r\n        if (computeField)\r\n          await fld.compute(true);\r\n        else\r\n          await fld.setValueAndStartRecompute(fld.getValue(false), fld.isNull(), true, false, false);\r\n        await fld.updateDisplay();\r\n      }\r\n    }\r\n  }\r\n\r\n\r\n  /// <summary></summary>\r\n  private buildSubFormList(): void {\r\n    if (this._subForms === null) {\r\n      this._subForms = new List<Task>();\r\n      let subTasksTab: TasksTable = this.Task.getSubTasks();\r\n\r\n      if (subTasksTab !== null) {\r\n        for (let i: number = 0; i < subTasksTab.getSize(); i = i + 1) {\r\n          let subForm: Task = <Task>subTasksTab.getTask(i);\r\n          // QCR #299153. Add only subforms (not subtasks).\r\n          if (subForm.getForm().getSubFormCtrl() !== null && subForm.refreshesOn(this.OwnerFld.getId())) {\r\n            this._subForms.push(subForm);\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// Removes the specific task from subforms list\r\n  /// </summary>\r\n  /// <param name=\"subformTask\"></param>\r\n  RemoveSubform(subformTask: Task): void {\r\n    this._subForms.Remove(subformTask);\r\n  }\r\n\r\n  /// <summary>\r\n  /// Inserts the specific subform task into the subform list\r\n  /// </summary>\r\n  /// <param name=\"subformTask\"></param>\r\n  AddSubform(subformTask: Task): void {\r\n    if (this._subForms === null)\r\n      this._subForms = new List<Task>();\r\n    if (!this._subForms.Contains(subformTask))\r\n      this._subForms.push(subformTask);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   execute record suffix for the affected subforms if Refresh is needed\r\n  ///   returns true if finished successfully and it is needed to refresh\r\n  /// </summary>\r\n  private async recSuffixSubForms(): Promise<boolean> {\r\n    let i: number;\r\n    let subForm: Task;\r\n    let successful: boolean = true;\r\n    let subformCtrl: MgControl;\r\n\r\n    // build the subforms list and save it for future use\r\n    this.buildSubFormList();\r\n\r\n    // execute \"record suffix\" for the subforms\r\n    for (i = 0; successful && i < this._subForms.length; i++) {\r\n      subForm = this._subForms.get_Item(i);\r\n      subformCtrl = <MgControl>subForm.getForm().getSubFormCtrl();\r\n      if (subForm.isStarted() && !subformCtrl.RefreshOnVisible &&\r\n        await subformCtrl.checkProp(PropInterface.PROP_TYPE_AUTO_REFRESH, true) && !subForm.InSelect\r\n        && subForm.DoSubformPrefixSuffix) {\r\n        await AccessHelper.eventsManager.handleInternalEventWithTask(subForm, InternalInterface.MG_ACT_REC_SUFFIX);\r\n        successful = !AccessHelper.eventsManager.GetStopExecutionFlag();\r\n      }\r\n    }\r\n    (<DataView>this.Task.DataView).setPrevCurrRec();\r\n    return (successful);\r\n  }\r\n\r\n  // check if do refresh for any subform that the field affects\r\n  private async checkRefreshSubForms(): Promise<boolean> {\r\n    let refresh: boolean = !this._subFormsOnlyRecomp;\r\n    let subformsToRefresh: List<Task> = await this.GetSubformsToRefresh();\r\n    if (subformsToRefresh.length > 0)\r\n      refresh = true;\r\n    return refresh;\r\n  }\r\n\r\n  /// <summary>\r\n  /// Gets a list of those subforms that must be refreshed.\r\n  /// </summary>\r\n  /// <returns>list of subforms to refresh</returns>\r\n  private async GetSubformsToRefresh(): Promise<List<Task>> {\r\n\r\n    let subTasks: List<Task> = new List<Task>();\r\n    let subformCtrl: MgControl;\r\n    // build the subforms list and save it for future use\r\n    this.buildSubFormList();\r\n\r\n    for (let i = 0; i<this._subForms.length; i++)\r\n    {\r\n      let subTask = this._subForms[i];\r\n      subformCtrl = <MgControl>subTask.getForm().getSubFormCtrl();\r\n      if (subTask.isStarted() && await  subformCtrl.checkProp(PropInterface.PROP_TYPE_AUTO_REFRESH, true) &&\r\n        !subTask.InSelect && !subTask.InEndTask) {\r\n\r\n        // compute the visibility property for the subform control before use it in isVisible() method\r\n        await subformCtrl.checkProp(PropInterface.PROP_TYPE_VISIBLE, true);\r\n        if (!subformCtrl.isVisible() && !await subformCtrl.checkProp(PropInterface.PROP_TYPE_REFRESH_WHEN_HIDDEN, false))\r\n          subformCtrl.RefreshOnVisible = true;\r\n        else subTasks.push(subTask);\r\n      }\r\n    }\r\n    return subTasks;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   execute record prefix for the affected subforms if Refresh is needed\r\n  ///   returns true if finished successfully and it is needed to refresh\r\n  /// </summary>\r\n  private async recPrefixSubForms(): Promise<boolean> {\r\n    let i: number;\r\n    let subForm: Task;\r\n    let successful: boolean = true;\r\n    let subformCtrl: MgControl;\r\n\r\n    // build the subforms list and save it for future use\r\n    this.buildSubFormList();\r\n\r\n    // execute \"record prefix\" for the subforms\r\n    for (i = 0; successful && i < this._subForms.length; i++) {\r\n      subForm = this._subForms.get_Item(i);\r\n      subformCtrl = <MgControl>subForm.getForm().getSubFormCtrl();\r\n      if (subForm.isStarted() && !subformCtrl.RefreshOnVisible\r\n        && await  subformCtrl.checkProp(PropInterface.PROP_TYPE_AUTO_REFRESH, true)\r\n        && !subForm.InSelect && subForm.DoSubformPrefixSuffix) {\r\n        await AccessHelper.eventsManager.handleInternalEventWithTaskAndSubformRefresh(subForm, InternalInterface.MG_ACT_REC_PREFIX, true);\r\n        successful = !AccessHelper.eventsManager.GetStopExecutionFlag();\r\n      }\r\n    }\r\n    return successful;\r\n  }\r\n\r\n  notifyServerOnChange(): boolean {\r\n    return this.RcmpMode === Recompute_RcmpBy.SERVER_ON_CHANGE;\r\n  }\r\n\r\n  /// <returns> true if the client doesn't know to recompute this field</returns>\r\n  isServerRcmp(): boolean {\r\n    return this.RcmpMode !== Recompute_RcmpBy.CLIENT;\r\n  }\r\n\r\n}\r\n"]}

package/esm2022/src/rt/RecomputeTable.mjs

@@ -0,0 +1,63 @@
+import { NString } from "@magic-xpa/mscorelib";
+import { Base64, Logger, XMLConstants, XmlParser } from "@magic-xpa/utils";
+import { Recompute } from "./Recompute";
+import { AccessHelper } from "../AccessHelper";
+export class RecomputeTable {
+    fillAttributes(parser) {
+        let endContext = parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex());
+        let Index = parser.getXMLdata().indexOf(XMLConstants.MG_TAG_RECOMPUTE, parser.getCurrIndex()) + XMLConstants.MG_TAG_RECOMPUTE.length;
+        let task = null;
+        let tokensVector = XmlParser.getTokens(parser.getXMLdata().substr(Index, endContext - Index), '"');
+        for (let j = 0; j < tokensVector.length; j += 2) {
+            let attribute = (tokensVector.get_Item(j));
+            let valueStr = (tokensVector.get_Item(j + 1));
+            if (attribute === XMLConstants.MG_ATTR_TASKID)
+                task = AccessHelper.mgDataTable.GetTaskByID(valueStr);
+            else
+                Logger.Instance.WriteExceptionToLogWithMsg(NString.Format("Unrecognized attribute: '{0}'", attribute));
+        }
+        parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);
+        return task;
+    }
+    fillData(parser) {
+        let task = this.fillAttributes(parser);
+        if (task !== null) {
+            Logger.Instance.WriteDevToLog("goes to refill recompute");
+            this.fillData_1(task.DataView, task, parser);
+        }
+        else
+            parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);
+    }
+    fillData_1(dataView, task, parser) {
+        if (parser.getNextTag() == XMLConstants.MG_TAG_RECOMPUTE) {
+            let currrentIndex = parser.getCurrIndex();
+            let encoded = parser.ReadContentOfCurrentElement().trim();
+            let decoded = Base64.decode(encoded.substr(0, encoded.length).trim());
+            let newXmlData = parser.getXMLdata().replace(encoded.trim(), decoded);
+            parser.setXMLdata(newXmlData);
+            parser.setCurrIndex(currrentIndex);
+        }
+        while (this.initInnerObjects(parser, parser.getNextTag(), dataView, task)) {
+        }
+    }
+    initInnerObjects(parser, nameOfFound, dataView, task) {
+        if (nameOfFound === null)
+            return false;
+        if (nameOfFound === XMLConstants.MG_TAG_RECOMPUTE)
+            parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);
+        else if (nameOfFound === XMLConstants.MG_TAG_FLD) {
+            let recompute = new Recompute();
+            recompute.fillData(dataView, task, parser);
+        }
+        else if (nameOfFound === '/' + XMLConstants.MG_TAG_RECOMPUTE) {
+            parser.setCurrIndex2EndOfTag();
+            return false;
+        }
+        else {
+            Logger.Instance.WriteExceptionToLogWithMsg("There is no such tag in <recompute>, add case to RecomputeTable.initInnerObjects for " + nameOfFound);
+            return false;
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RecomputeTable.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/rt/RecomputeTable.ts"],"names":[],"mappings":"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","sourcesContent":["import {List, NString} from \"@magic-xpa/mscorelib\";\r\nimport {Base64, Logger, XMLConstants, XmlParser} from \"@magic-xpa/utils\";\r\nimport {Task} from \"../tasks/Task\";\r\nimport {DataView} from \"../data/DataView\";\r\nimport {Recompute} from \"./Recompute\";\r\nimport { AccessHelper } from \"../AccessHelper\";\r\n\r\n/// <summary>\r\n///   Data for <recompute>....</recompute>\r\n///   this class is used only to create the Recompute objects but do not\r\n///   hold any data\r\n/// </summary>\r\nexport class RecomputeTable {\r\n\r\n  /// <summary>\r\n  ///   get the recompute attributes\r\n  /// </summary>\r\n  private fillAttributes(parser: XmlParser): Task {\r\n    let endContext: number = parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex());\r\n    let Index: number = parser.getXMLdata().indexOf(XMLConstants.MG_TAG_RECOMPUTE, parser.getCurrIndex()) + XMLConstants.MG_TAG_RECOMPUTE.length;\r\n\r\n    let task: Task = null;\r\n    let tokensVector: List<string> = XmlParser.getTokens(parser.getXMLdata().substr(Index, endContext - Index), '\"');\r\n\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      if (attribute === XMLConstants.MG_ATTR_TASKID)\r\n          task = <Task>AccessHelper.mgDataTable.GetTaskByID(valueStr);\r\n      else\r\n          Logger.Instance.WriteExceptionToLogWithMsg(NString.Format(\"Unrecognized attribute: '{0}'\", attribute));\r\n    }\r\n    parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);\r\n    // start of <fld ...>\r\n\r\n    return task;\r\n  }\r\n\r\n  fillData(parser: XmlParser): void {\r\n    let task: Task = this.fillAttributes(parser);\r\n\r\n    if (task !== null) {\r\n      Logger.Instance.WriteDevToLog(\"goes to refill recompute\");\r\n      this.fillData_1(<DataView>task.DataView, task, parser);\r\n    }\r\n    else\r\n       parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   To parse input string and fill inner data : Vector props\r\n  /// </summary>\r\n  fillData_1(dataView: DataView, task: Task, parser: XmlParser): void {\r\n     if (parser.getNextTag() == XMLConstants.MG_TAG_RECOMPUTE) {\r\n      let currrentIndex = parser.getCurrIndex(); // get the currentIndex of Recompute tag\r\n      let encoded = parser.ReadContentOfCurrentElement().trim(); // get value of encoded value of Recompute\r\n      let decoded = Base64.decode(encoded.substr(0, encoded.length).trim()); //decode the value of recompute\r\n      let newXmlData = parser.getXMLdata().replace(encoded.trim(), decoded); // replace the encoded value with decoded value\r\n      parser.setXMLdata(newXmlData); //create a parser with newXML\r\n      parser.setCurrIndex(currrentIndex); // set the current index of parser to recompute tag\r\n    }\r\n\r\n    while (this.initInnerObjects(parser, parser.getNextTag(), dataView, task)) {\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Fill Recompute Object, gives its reference to Field and reference of Field to him\r\n  /// </summary>\r\n  private initInnerObjects(parser: XmlParser, nameOfFound: String, dataView: DataView, task: Task): boolean {\r\n    if (nameOfFound === null)\r\n      return false;\r\n\r\n    if (nameOfFound === XMLConstants.MG_TAG_RECOMPUTE)\r\n      parser.setCurrIndex(parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex()) + 1);\r\n    // start of <fld ...>\r\n    else if (nameOfFound === XMLConstants.MG_TAG_FLD) {\r\n      let recompute: Recompute = new Recompute();\r\n      recompute.fillData(dataView, task, parser); // get reference to DataView, to make linked ref. : Recompute<-Field\r\n      // taskReference for Recompute.props=> ControlTable.Control.task\r\n    }\r\n    else if (nameOfFound === '/' + XMLConstants.MG_TAG_RECOMPUTE) {\r\n      parser.setCurrIndex2EndOfTag();\r\n      return false;\r\n    }\r\n    else {\r\n      Logger.Instance.WriteExceptionToLogWithMsg(\r\n        \"There is no such tag in <recompute>, add case to RecomputeTable.initInnerObjects for \" + nameOfFound);\r\n      return false;\r\n    }\r\n    return true;\r\n  }\r\n}\r\n"]}