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

package/esm2022/src/data/DataView.mjs

@@ -0,0 +1,1613 @@
+import { ApplicationException, Debug, Int32, Int64, isNullOrUndefined, List, NNumber } from '@magic-xpa/mscorelib';
+import { Constants, InternalInterface, Logger, Misc, StorageAttribute, XMLConstants, XmlParser } from '@magic-xpa/utils';
+import { DataModificationTypes, DisplayConvertor, PIC, PropInterface } from '@magic-xpa/gui';
+import { ConstInterface } from '../ConstInterface';
+import { RecordsTable } from './RecordsTable';
+import { Record } from './Record';
+import { TaskBase } from '../tasks/TaskBase';
+import { FieldsTableExt as FieldsTable } from './FieldsTable';
+import { RecordOutOfDataViewException, RecordOutOfDataViewException_ExceptionType } from './RecordOutOfDataViewException';
+import { CommandFactory } from '../commands/ClientToServer/CommandFactory';
+import { XMLBasedDcValuesBuilder } from './XMLBasedDcValuesBuilder';
+import { Field } from './Field';
+import { EventSubType } from '../enums';
+import { RemoteCommandsProcessor } from '../remote/RemoteCommandsProcessor';
+import { FieldBase } from './FieldBase';
+import { CommandsProcessorManager } from '../CommandsProcessorManager';
+import { DataViewBase } from './DataViewBase';
+import { AccessHelper, ClearEventsOnStopExecution } from '../AccessHelper';
+import { MGDataCollection } from '../tasks/MGDataCollection';
+export const SET_DISPLAYLINE_BY_DV = Int32.MinValue;
+const COMPUTE_NEWREC_ON_CLIENT = 'C';
+const UNKNOWN_RCMPS_NOT_INITED = 'M';
+const UNKNOWN_RCMPS_FOUND = 'Y';
+const INVOKED_FROM_OFFLINE_TASK = '-99999';
+const CHUNK_CACHE_NEXT = 'N';
+const CHUNK_CACHE_PREV = 'P';
+const CHUNK_DV_BOTTOM = 'B';
+const CHUNK_DV_TOP = 'T';
+const COMPUTE_FLUSH_UPDATES = 'H';
+const COMPUTE_NEWREC_ON_SERVER = 'S';
+const END_DV_TAG = '</' + ConstInterface.MG_TAG_DATAVIEW + '>';
+const RECOVERY_ACT_BEGIN_SCREEN = 'S';
+const RECOVERY_ACT_BEGIN_TABLE = 'T';
+const RECOVERY_ACT_CANCEL = 'C';
+const RECOVERY_ACT_MOVE_DIRECTION_BEGIN = 'B';
+const RECOVERY_ACT_NONE = 'N';
+const TRANS_STAT_CLOSED = 'C';
+const TRANS_STAT_OPENED = 'O';
+export class DataView extends DataViewBase {
+    _cacheLruTimeStamp = 0;
+    _changed = false;
+    _chunkSize = 30;
+    _computeBy = '\0';
+    _currRecId = 0;
+    _currRecIdx = 0;
+    _dvPosValue = 0;
+    _firstDv = true;
+    _flushUpdates = false;
+    _hasMainTable = true;
+    _insertAt = ' ';
+    set InsertAt(value) {
+        this._insertAt = value;
+    }
+    get InsertAt() {
+        return this._insertAt;
+    }
+    InLocalDataviewCommand = false;
+    _lastCreatedRecId = 0;
+    _lastSessionCounter = Int64.MinValue;
+    _locateFirstRec = -1;
+    _modifiedRecordsTab = null;
+    _oldTopRecIdx = Int32.MinValue;
+    _original = null;
+    _pendingRecovery = RECOVERY_ACT_NONE;
+    _prevCurrRec = null;
+    _recordsTab = null;
+    _recovery = ConstInterface.RECOVERY_NONE;
+    _rmIdx = 0;
+    _rmSize = 0;
+    _skipParsing = false;
+    _topRecId = 0;
+    _topRecIdx = Int32.MinValue;
+    _topRecIdxModified = false;
+    _transCleared = false;
+    _unknownRcmp = UNKNOWN_RCMPS_NOT_INITED;
+    IsOneWayKey = false;
+    _includesFirst = false;
+    _includesLast = false;
+    _serverTransCacheEmpty = true;
+    _currRec_DO_NOT_USE_DIRECTLY_USE_SETTER_GETTER = null;
+    get CurrRec() {
+        return this._currRec_DO_NOT_USE_DIRECTLY_USE_SETTER_GETTER;
+    }
+    set CurrRec(value) {
+        if (this._currRec_DO_NOT_USE_DIRECTLY_USE_SETTER_GETTER !== null && value === null) {
+            this._currRec_DO_NOT_USE_DIRECTLY_USE_SETTER_GETTER.resetDcValueId();
+        }
+        this._currRec_DO_NOT_USE_DIRECTLY_USE_SETTER_GETTER = value;
+        if (this._currRec_DO_NOT_USE_DIRECTLY_USE_SETTER_GETTER !== null) {
+            this._currRec_DO_NOT_USE_DIRECTLY_USE_SETTER_GETTER.SetDcValueId();
+        }
+    }
+    get FlushUpdates() {
+        return this._flushUpdates;
+    }
+    get HasMainTable() {
+        return this._hasMainTable;
+    }
+    DBViewSize = 0;
+    taskModeFromCache;
+    get CurrentRecId() {
+        return this._currRecId;
+    }
+    Dvcount = 0;
+    TotalRecordsCount = 0;
+    RecordsBeforeCurrentView = 0;
+    get FirstRecord() {
+        return this._recordsTab.getRecByIdx(0);
+    }
+    get LastRecord() {
+        return this._recordsTab.getRecByIdx(this._recordsTab.getSize() - 1);
+    }
+    constructor(taskOrDataView) {
+        super();
+        if (taskOrDataView instanceof TaskBase) {
+            this._task = taskOrDataView;
+            this._fieldsTab = new FieldsTable();
+            this._recordsTab = new RecordsTable(true);
+            this._modifiedRecordsTab = new RecordsTable(false);
+        }
+        else {
+            Object.assign(this, taskOrDataView);
+        }
+    }
+    Init() {
+        this.init();
+    }
+    IncludesFirst() {
+        return this._includesFirst;
+    }
+    get ServerTransactionCacheEmpty() {
+        return this._serverTransCacheEmpty;
+    }
+    IncludesLast() {
+        return this._includesLast;
+    }
+    fillHeaderData(parser) {
+        while (this.initHeaderInnerObjects(parser, parser.getNextTag())) {
+        }
+        this.Dvcount = this._task.ctl_itm_4_parent_vee(0, 1);
+    }
+    initHeaderInnerObjects(parser, foundTagName) {
+        if (foundTagName === null)
+            return false;
+        if (foundTagName === XMLConstants.MG_TAG_DVHEADER) {
+            Logger.Instance.WriteDevToLog('dvheader found');
+            this.getHeaderAttributes(parser);
+            this._fieldsTab.fillData(parser, this);
+            this._fieldsTab.setRMPos(this._rmSize, this._rmIdx);
+        }
+        else if (foundTagName === ('/' + XMLConstants.MG_TAG_DVHEADER)) {
+            parser.setCurrIndex2EndOfTag();
+            return false;
+        }
+        else
+            return false;
+        return true;
+    }
+    getHeaderAttributes(parser) {
+        let tokensVector;
+        let tag;
+        let attribute;
+        let valueStr;
+        let endContext = parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex());
+        if (endContext !== -1 && endContext < parser.getXMLdata().length) {
+            tag = parser.getXMLsubstring(endContext);
+            parser.add2CurrIndex(tag.indexOf(XMLConstants.MG_TAG_DVHEADER) + XMLConstants.MG_TAG_DVHEADER.length);
+            tokensVector = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);
+            for (let j = 0; j < tokensVector.length; j += 2) {
+                attribute = (tokensVector.get_Item(j));
+                valueStr = (tokensVector.get_Item(j + 1));
+                switch (attribute) {
+                    case ConstInterface.MG_ATTR_RMPOS: {
+                        let i = valueStr.indexOf(',');
+                        if (i > -1) {
+                            this._rmSize = NNumber.Parse(valueStr.substr(0, i));
+                            this._rmIdx = NNumber.Parse(valueStr.substr(i + 1));
+                        }
+                        break;
+                    }
+                    case ConstInterface.MG_ATTR_COMPUTE_BY:
+                        this._computeBy = valueStr[0];
+                        if (this._computeBy === COMPUTE_FLUSH_UPDATES) {
+                            this._computeBy = COMPUTE_NEWREC_ON_SERVER;
+                            this._flushUpdates = true;
+                        }
+                        else
+                            this._flushUpdates = false;
+                        break;
+                    case ConstInterface.MG_ATTR_HAS_MAIN_TBL:
+                        this._hasMainTable = XmlParser.getBoolean(valueStr);
+                        break;
+                    case ConstInterface.MG_ATTR_CHUNK_SIZE:
+                        this._chunkSize = XmlParser.getInt(valueStr);
+                        break;
+                    case ConstInterface.MG_ATTR_CHUNK_SIZE_EXPRESSION:
+                        break;
+                    default:
+                        Logger.Instance.WriteExceptionToLogWithMsg('Unknown attribute for <' + XMLConstants.MG_TAG_DVHEADER + '> tag: ' +
+                            attribute);
+                        break;
+                }
+            }
+            parser.setCurrIndex(++endContext);
+            return;
+        }
+        Logger.Instance.WriteExceptionToLogWithMsg('in DataView.getHeaderAttributes(): out of bounds');
+    }
+    async fillData(parser) {
+        this._skipParsing = false;
+        while (await this.initInnerObjects(parser, parser.getNextTag())) {
+        }
+        this.ResetFirstDv();
+    }
+    GetTransactionBegin() {
+        let transBegin = '\0';
+        let transBeginProp = this._task.getProp(PropInterface.PROP_TYPE_TRASACTION_BEGIN);
+        if (transBeginProp !== null) {
+            transBegin = (transBeginProp.GetComputedValue()).charAt(0);
+        }
+        return transBegin;
+    }
+    async initInnerObjects(parser, foundTagName) {
+        let form = this._task.getForm();
+        if (foundTagName == null)
+            return false;
+        if (foundTagName === (ConstInterface.MG_TAG_DATAVIEW)) {
+            let invalidate = await this.getAttributes(parser);
+            if (this._skipParsing) {
+                let endContext = parser.getXMLdata().indexOf(END_DV_TAG, parser.getCurrIndex());
+                parser.setCurrIndex(endContext + END_DV_TAG.length);
+            }
+            else {
+                this.fillExecStack(parser);
+                this.fillDataDc(parser);
+                if (invalidate && form != null)
+                    form.SetTableItemsCount(0, true);
+                let taskRefreshType = this._recordsTab.fillData(this, this._insertAt, parser);
+                if (form != null) {
+                    if (form.Opened) {
+                        if (this._insertAt === 'B' && (invalidate || this._recordsTab.InsertedRecordsCount > 0)) {
+                            if (invalidate || !this._task.getForm().isTableWithPagination()) {
+                                form.SetTableItemsCount(0, true);
+                                form.setTableItemsCount(false);
+                            }
+                            else
+                                form.InsertTableItems(0, this._recordsTab.InsertedRecordsCount);
+                        }
+                        else
+                            form.setTableItemsCount(false);
+                    }
+                }
+                if (this.CurrRec != null && this.CurrRec.InRecompute && taskRefreshType === Constants.TASK_REFRESH_NONE)
+                    taskRefreshType = Constants.TASK_REFRESH_CURR_REC;
+                if (invalidate) {
+                    taskRefreshType = Constants.TASK_REFRESH_FORM;
+                    if (this._task.IsSubForm)
+                        this.getTask().DoSubformPrefixSuffix = true;
+                }
+                this.getTask().SetRefreshType(taskRefreshType);
+                this.UpdateDataviewAfterInsert();
+                let newRecId = this._recordsTab.getInitialCurrRecId();
+                if (newRecId !== Int32.MinValue && (this._recovery === ConstInterface.RECOVERY_NONE || this._firstDv)) {
+                    if (this._firstDv && this._recovery === ConstInterface.RECOVERY_NONE &&
+                        (this._task.getLevel().charCodeAt(0) === 0 || this._task.getLevel() === Constants.TASK_LEVEL_TASK))
+                        this._task.setLevel(Constants.TASK_LEVEL_TASK);
+                    this._fieldsTab.invalidate(true, Field.LEAVE_FLAGS);
+                    if (newRecId !== this._currRecId) {
+                        await this.setCurrRec(newRecId, !this._firstDv);
+                        this._original = this.CurrRec.replicate();
+                        if (this._firstDv)
+                            this.takeFldValsFromCurrRec();
+                        if (this._task.getForm() != null)
+                            (this._task.getForm()).updateDisplayLineByDV();
+                    }
+                    else
+                        this.takeFldValsFromCurrRec();
+                }
+                else if (invalidate && this._recordsTab.getSize() > 0) {
+                    if (form == null || form.isScreenMode()) {
+                        try {
+                            await this.setCurrRecByIdx(0, false, true, false, 0);
+                        }
+                        catch (exception) {
+                            if (exception instanceof RecordOutOfDataViewException) {
+                            }
+                            else
+                                throw exception;
+                        }
+                    }
+                    else {
+                        this._fieldsTab.invalidate(true, Field.LEAVE_FLAGS);
+                        this.setTopRecIdx(0);
+                        if (this._task.getForm() != null)
+                            this._task.getForm().SetTableTopIndex();
+                        try {
+                            await this.setCurrRecByIdx(0, false, true, true, 0);
+                            if (this._task.getForm() != null)
+                                (this._task.getForm()).updateDisplayLineByDV();
+                        }
+                        catch (exception) {
+                            if (exception instanceof RecordOutOfDataViewException) {
+                            }
+                            else
+                                throw exception;
+                        }
+                        if (this._task.getLevel() === Constants.TASK_LEVEL_CONTROL && this._task.getLastParkedCtrl() != null)
+                            this._task.getLastParkedCtrl().resetPrevVal();
+                    }
+                    this.saveOriginal();
+                    this._fieldsTab.invalidate(true, FieldBase.CLEAR_FLAGS);
+                }
+                if (this._firstDv)
+                    this.setPrevCurrRec();
+                if (invalidate && this._task.IsSubForm)
+                    this._task.getForm().getSubFormCtrl().RefreshOnVisible = false;
+                if (this._recovery === ConstInterface.RECOVERY_NONE) {
+                    if (this.getTask().getAfterRetry(ConstInterface.RECOVERY_RETRY) &&
+                        !this.getTask().IsAfterRetryBeforeBuildXML)
+                        this._task.setLevel(Constants.TASK_LEVEL_RECORD);
+                }
+                else {
+                    let transBegin = this.GetTransactionBegin();
+                    let stopExecution = true;
+                    switch (this._recovery) {
+                        case ConstInterface.RECOVERY_ROLLBACK:
+                            if (transBegin === ConstInterface.TRANS_RECORD_PREFIX) {
+                                if (this._task.getMode() === Constants.TASK_MODE_DELETE ||
+                                    !this._task.IsInteractive)
+                                    stopExecution = false;
+                                else {
+                                    this.getTask().setAfterRetry(ConstInterface.RECOVERY_ROLLBACK);
+                                    this.CurrRec.restart(this.CurrRec.getMode());
+                                    this.CurrRec.resetModified();
+                                    this._original = this.CurrRec.replicate();
+                                    this._pendingRecovery = RECOVERY_ACT_CANCEL;
+                                }
+                            }
+                            else if (transBegin !== ConstInterface.TRANS_NONE) {
+                                this._task.setLevel(Constants.TASK_LEVEL_TASK);
+                                this._pendingRecovery = RECOVERY_ACT_BEGIN_TABLE;
+                                this.getTask().setAfterRetry(ConstInterface.RECOVERY_ROLLBACK);
+                            }
+                            break;
+                        case ConstInterface.RECOVERY_RETRY:
+                            this.RecoveryRetry(transBegin);
+                            break;
+                    }
+                    if (stopExecution) {
+                        AccessHelper.eventsManager.setStopExecution(true);
+                        this.getTask().TaskSuffixExecuted = false;
+                    }
+                }
+            }
+        }
+        else if (foundTagName === '/' + ConstInterface.MG_TAG_DATAVIEW) {
+            if (this._includesFirst && this._includesLast && this.isEmpty()) {
+                this._currRecId = Int32.MinValue;
+                this._currRecIdx = Int32.MinValue;
+                this.CurrRec = null;
+                this.setTopRecIdx(Int32.MinValue);
+            }
+            parser.setCurrIndex2EndOfTag();
+            return false;
+        }
+        else
+            return false;
+        return true;
+    }
+    RecoveryRetry(transBegin) {
+        if (transBegin === ConstInterface.TRANS_RECORD_PREFIX) {
+            this._task.setLevel(Constants.TASK_LEVEL_RECORD);
+            this.getTask().setTransactionFailed(true);
+            this.getTask().setAfterRetry(ConstInterface.RECOVERY_RETRY);
+            this.CurrRec.restart(this.CurrRec.getMode());
+            if (!this._firstDv) {
+                this.takeFldValsFromCurrRec();
+                this._pendingRecovery = RECOVERY_ACT_MOVE_DIRECTION_BEGIN;
+            }
+        }
+        else if (transBegin !== ConstInterface.TRANS_NONE) {
+            this._task.setLevel(Constants.TASK_LEVEL_TASK);
+            this._pendingRecovery = RECOVERY_ACT_BEGIN_SCREEN;
+            this.getTask().setAfterRetry(ConstInterface.RECOVERY_RETRY);
+            this.getTask().setTransactionFailed(true);
+        }
+    }
+    UpdateDataviewAfterInsert() {
+        if (this._insertAt === 'B') {
+            let newRecs = this._recordsTab.InsertedRecordsCount;
+            if (this._currRecIdx !== Int32.MinValue)
+                this._currRecIdx += newRecs;
+            if (this._topRecIdx !== Int32.MinValue)
+                this._topRecIdx += newRecs;
+            if (this._oldTopRecIdx !== Int32.MinValue)
+                this._oldTopRecIdx += newRecs;
+        }
+    }
+    async getAttributes(parser) {
+        let tokensVector;
+        let tag;
+        let boolVal;
+        let dataViewCommand = null;
+        let isEmptyDataview = false;
+        this._recovery = ConstInterface.RECOVERY_NONE;
+        let endContext = parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex());
+        if (endContext !== -1 && endContext < parser.getXMLdata().length) {
+            tag = parser.getXMLsubstring(endContext);
+            parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_DATAVIEW) + ConstInterface.MG_TAG_DATAVIEW.length);
+            tokensVector = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);
+            this._insertAt = ' ';
+            let invalidate = this.peekInvalidate(tokensVector);
+            this._locateFirstRec = 0;
+            for (let j = 0; j < tokensVector.length; j += 2) {
+                let attribute = (tokensVector.get_Item(j));
+                let valueStr = (tokensVector.get_Item(j + 1));
+                switch (attribute) {
+                    case ConstInterface.MG_ATTR_INSERT_AT:
+                        this._insertAt = valueStr[0];
+                        break;
+                    case ConstInterface.MG_ATTR_INCLUDE_FIRST:
+                        boolVal = XmlParser.getBoolean(valueStr);
+                        this.SetIncludesFirst(boolVal);
+                        break;
+                    case ConstInterface.MG_ATTR_INCLUDE_LAST:
+                        boolVal = XmlParser.getBoolean(valueStr);
+                        this.SetIncludesLast(boolVal);
+                        break;
+                    case ConstInterface.MG_ATTR_IS_ONEWAY_KEY:
+                        boolVal = XmlParser.getBoolean(valueStr);
+                        this.SetOneWayKey(boolVal);
+                        break;
+                    case ConstInterface.MG_ATTR_DBVIEWSIZE:
+                        this.DBViewSize = XmlParser.getInt(valueStr);
+                        break;
+                    case ConstInterface.MG_ATTR_INVALIDATE:
+                        {
+                        }
+                        break;
+                    case ConstInterface.MG_ATTR_TOP_REC_ID:
+                        this._topRecId = NNumber.Parse(valueStr);
+                        break;
+                    case ConstInterface.MG_ATTR_TASKMODE:
+                        if (this._task.getOriginalTaskMode() === Constants.TASK_MODE_NONE || invalidate)
+                            this._task.setOriginalTaskMode(valueStr);
+                        this._task.setProp(PropInterface.PROP_TYPE_TASK_MODE, valueStr);
+                        break;
+                    case ConstInterface.MG_ATTR_EMPTY_DATAVIEW:
+                        isEmptyDataview = true;
+                        break;
+                    case XMLConstants.MG_ATTR_TASKID:
+                        continue;
+                    case ConstInterface.MG_ATTR_LOW_ID:
+                        this._lastCreatedRecId = NNumber.Parse(valueStr);
+                        break;
+                    case ConstInterface.MG_ATTR_TRANS_STAT:
+                        let transStat = valueStr[0];
+                        switch (transStat) {
+                            case TRANS_STAT_OPENED:
+                                dataViewCommand = CommandFactory.CreateSetTransactionStateDataviewCommand(this.getTask().getTaskTag(), true);
+                                await this.getTask().DataviewManager.RemoteDataviewManager.Execute(dataViewCommand);
+                                break;
+                            case TRANS_STAT_CLOSED:
+                                dataViewCommand = CommandFactory.CreateSetTransactionStateDataviewCommand(this.getTask().getTaskTag(), false);
+                                await this.getTask().DataviewManager.RemoteDataviewManager.Execute(dataViewCommand);
+                                this.getTask().setTransactionFailed(false);
+                                break;
+                            default:
+                                break;
+                        }
+                        break;
+                    case ConstInterface.MG_ATTR_RECOVERY:
+                        if (this._task.IsTryingToStop)
+                            this.getTask().setTryingToStop(false);
+                        this.getTask().resetExecEndTask();
+                        this._recovery = valueStr[0];
+                        break;
+                    case ConstInterface.MG_ATTR_DVPOS_VALUE:
+                        this._dvPosValue = NNumber.Parse(valueStr);
+                        break;
+                    case ConstInterface.MG_ATTR_LOCATE_FIRST_ID:
+                        this._locateFirstRec = NNumber.Parse(valueStr);
+                        break;
+                    case ConstInterface.MG_ATTR_OFFSET:
+                        break;
+                    case ConstInterface.MG_ATTR_USER_SORT:
+                        let form = this._task.getForm();
+                        form.clearTableColumnSortMark(XmlParser.getBoolean(valueStr));
+                        break;
+                    case ConstInterface.MG_ATTR_VAL_TOTAL_RECORDS_COUNT:
+                        this.TotalRecordsCount = XmlParser.getInt(valueStr);
+                        break;
+                    case ConstInterface.MG_ATTR_VAL_RECORDS_BEFORE_CURRENT_VIEW:
+                        this.RecordsBeforeCurrentView = XmlParser.getInt(valueStr);
+                        break;
+                    case ConstInterface.MG_ATTR_VAL_SERVER_TRANS_CACHE_EMPTY:
+                        this._serverTransCacheEmpty = XmlParser.getBoolean(valueStr);
+                        break;
+                    default:
+                        Logger.Instance.WriteExceptionToLogWithMsg('Unknown attribute for <' + ConstInterface.MG_TAG_DATAVIEW + '> tag: ' + attribute);
+                        break;
+                }
+            }
+            this.setEmptyDataview(isEmptyDataview);
+            parser.setCurrIndex(++endContext);
+            return invalidate;
+        }
+        Logger.Instance.WriteExceptionToLogWithMsg('in DataView.getAttributes(): out of bounds');
+        return false;
+    }
+    SetOneWayKey(val) {
+        this.IsOneWayKey = val;
+    }
+    SetIncludesLast(val) {
+        this._includesLast = val;
+    }
+    SetIncludesFirst(val) {
+        let prevIncludeFirst = this._includesFirst;
+        this._includesFirst = val;
+        if (this._includesFirst !== prevIncludeFirst) {
+            let form = this._task.getForm();
+            if (form !== null) {
+                form.SetTableItemsCount(0, true);
+            }
+        }
+    }
+    fillDataDc(parser) {
+        let dcvBuilder = new XMLBasedDcValuesBuilder();
+        let foundTagName = parser.getNextTag();
+        while (foundTagName !== null && foundTagName === ConstInterface.MG_TAG_DC_VALS) {
+            let dcValsPosition = parser.getCurrIndex();
+            dcvBuilder.SerializedDCVals = parser.ReadToEndOfCurrentElement();
+            let dcv = dcvBuilder.Build();
+            if (dcv !== null)
+                this.AddDcValues(dcv);
+            else
+                Logger.Instance.WriteExceptionToLogWithMsg('Error while parsing DC values at position ' + dcValsPosition);
+            foundTagName = parser.getNextTag();
+        }
+    }
+    AddDcValues(dcv) {
+        this._dcValsCollection.Add(dcv.getId().toString(), dcv);
+    }
+    fillExecStack(parser) {
+        let foundTagName = parser.getNextTag();
+        let execStackTagExists = false;
+        while (foundTagName !== null && foundTagName === ConstInterface.MG_TAG_EXEC_STACK_ENTRY) {
+            this.fillInnerExecStack(parser);
+            foundTagName = parser.getNextTag();
+            execStackTagExists = true;
+        }
+        if (execStackTagExists) {
+            AccessHelper.eventsManager.reverseServerExecStack();
+        }
+    }
+    fillInnerExecStack(parser) {
+        let tokensVector;
+        const endContext = parser.getXMLdata().indexOf(XMLConstants.TAG_TERM, parser.getCurrIndex());
+        let attribute;
+        let taskId = '';
+        let handlerId = '';
+        let operIdx = 0;
+        if (endContext !== -1 && endContext < parser.getXMLdata().length) {
+            let tag = parser.getXMLsubstring(endContext);
+            parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_EXEC_STACK_ENTRY) + ConstInterface.MG_TAG_EXEC_STACK_ENTRY.length);
+            tokensVector = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);
+            for (let j = 0; j < tokensVector.length; j += 2) {
+                attribute = (tokensVector.get_Item(j));
+                let valueStr = (tokensVector.get_Item(j + 1));
+                switch (attribute) {
+                    case XMLConstants.MG_ATTR_TASKID:
+                        taskId = valueStr;
+                        break;
+                    case ConstInterface.MG_ATTR_HANDLERID:
+                        handlerId = valueStr;
+                        break;
+                    case ConstInterface.MG_ATTR_OPER_IDX:
+                        operIdx = XmlParser.getInt(valueStr);
+                        break;
+                }
+            }
+            AccessHelper.eventsManager.pushServerExecStack(taskId, handlerId, operIdx);
+            parser.setCurrIndex(endContext + XMLConstants.TAG_TERM.length);
+        }
+        else
+            Logger.Instance.WriteExceptionToLogWithMsg('in DataView.fillInnerExecStack() out of bounds');
+    }
+    peekInvalidate(tokensVector) {
+        let sessionCounter = CommandsProcessorManager.GetCommandsProcessor().GetSessionCounter();
+        for (let j = 0; j < tokensVector.length; j += 2) {
+            let attribute = tokensVector.get_Item(j);
+            if (attribute === (ConstInterface.MG_ATTR_INVALIDATE)) {
+                let valueStr = tokensVector.get_Item(j + 1);
+                if (XmlParser.getBoolean(valueStr)) {
+                    if (sessionCounter < this._lastSessionCounter)
+                        this._skipParsing = true;
+                    else {
+                        this._lastSessionCounter = sessionCounter;
+                        this.clear();
+                        return true;
+                    }
+                }
+                return false;
+            }
+        }
+        return false;
+    }
+    getFieldByName(fldName) {
+        if (this._fieldsTab !== null)
+            return this._fieldsTab.getField(fldName);
+        Logger.Instance.WriteExceptionToLogWithMsg('in DataView.getField(String): There is no fieldsTab object');
+        return null;
+    }
+    async buildXML(message) {
+        let dcv;
+        let taskTag = this._task.getTaskTag();
+        let brkLevelIndex = this._task.getBrkLevelIndex();
+        let currRecDeleted = false;
+        let serverParent;
+        let contextTask = (this.getTask().GetContextTask());
+        let invokingTaskTag = contextTask.IsOffline ? INVOKED_FROM_OFFLINE_TASK : contextTask.getTaskTag();
+        message.Append('\n      <' + ConstInterface.MG_TAG_DATAVIEW + ' ' + XMLConstants.MG_ATTR_TASKID + '="' +
+            taskTag + '"');
+        message.Append(' ' + ConstInterface.MG_ATTR_TASKLEVEL + '="' + brkLevelIndex + '"');
+        serverParent = '0';
+        let triggeringTask = this.getTask().getTriggeringTask();
+        if (triggeringTask != null) {
+            if (triggeringTask.IsOffline) {
+                let ctlIdx = triggeringTask.getCtlIdx();
+                let mainPrg = AccessHelper.mgDataTable.GetMainProgByCtlIdx(-1, ctlIdx);
+                serverParent = mainPrg.getTaskTag();
+            }
+            else
+                serverParent = triggeringTask.getTaskTag();
+        }
+        if (this._currRecId > Int32.MinValue) {
+            if (this.CurrRec != null)
+                message.Append(' ' + ConstInterface.MG_ATTR_CURR_REC + '="' + this._currRecId + '"');
+            message.Append(' ' + ConstInterface.MG_ATTR_TASKMODE + '="' + this._task.getMode() + '"');
+            if (this._transCleared && !(MGDataCollection.Instance.StartupMgData.getFirstTask().InEndTask && MGDataCollection.Instance.StartupMgData.getFirstTask().ClosingFormUI)) {
+                message.Append(' ' + ConstInterface.MG_ATTR_TRANS_CLEARED + '="1"');
+                this._transCleared = false;
+            }
+            message.Append(' ' + ConstInterface.MG_ATTR_INVOKER_ID + '="' + invokingTaskTag + ',' + serverParent + '"');
+            if (await this.getTask().isCached())
+                message.Append(' ' + ConstInterface.MG_ATTR_DVPOS_VALUE + '="' + this._dvPosValue + '"');
+            message.Append(' ' + ConstInterface.MG_ATTR_LOOP_COUNTER + '="' + this.getTask().getLoopCounter() + '"');
+            if (this._task.IsSubForm) {
+                let subformCtrl = this._task.getForm().getSubFormCtrl();
+                if (!subformCtrl.isVisible() &&
+                    !await subformCtrl.checkProp(PropInterface.PROP_TYPE_REFRESH_WHEN_HIDDEN, false))
+                    message.Append(' ' + ConstInterface.MG_ATTR_SUBFORM_VISIBLE + '="0"');
+            }
+            if (!this._task.IsInteractive)
+                message.Append(' ' + ConstInterface.MG_ATTR_TASK_COUNTER + '="' + this.getTask().getCounter() + '"');
+            if (this._task != null && this._task.GetComputedProperty(PropInterface.PROP_TYPE_PRELOAD_VIEW).GetComputedValueBoolean()) {
+                message.Append(' ' + ConstInterface.MG_ATTR_LAST_REC_ID + '="' +
+                    (this._recordsTab.getRecByIdx(this.getSize() - 1).getId()) + '"');
+                message.Append(' ' + ConstInterface.MG_ATTR_OLD_FIRST_REC_ID + '="' +
+                    this._recordsTab.getRecByIdx(0).getId() + '"');
+            }
+            if (this._task.IsInteractive) {
+                let form = this._task.getForm();
+                if (form != null && this._recordsTab.getSize() > 1) {
+                    message.Append(' ' + ConstInterface.MG_ATTR_CURR_REC_POS_IN_FORM + '="' +
+                        form.getCurrRecPosInForm() + '"');
+                }
+            }
+            message.Append(XMLConstants.TAG_CLOSE);
+            if (this.getTask().ResetRange || this.getTask().UserRngs != null) {
+                message.Append(XMLConstants.START_TAG + ConstInterface.USER_RANGES);
+                if (this.getTask().ResetRange) {
+                    message.Append(' ' + ConstInterface.CLEAR_RANGE + '="1"');
+                    this.getTask().ResetRange = false;
+                }
+                if (this.getTask().UserRngs != null) {
+                    this.getTask().buildXMLForRngs(message, this.getTask().UserRngs, false);
+                    this.getTask().UserRngs.Clear();
+                    this.getTask().UserRngs = null;
+                }
+                else
+                    message.Append(XMLConstants.TAG_TERM);
+            }
+            if (this.getTask().ResetLocate || this.getTask().UserLocs != null) {
+                message.Append(XMLConstants.START_TAG + ConstInterface.USER_LOCATES);
+                if (this.getTask().ResetLocate) {
+                    message.Append(' ' + ConstInterface.CLEAR_LOCATES + '="1"');
+                    this.getTask().ResetLocate = false;
+                }
+                if (this.getTask().UserLocs != null) {
+                    this.getTask().buildXMLForRngs(message, this.getTask().UserLocs, true);
+                    this.getTask().UserLocs.Clear();
+                    this.getTask().UserLocs = null;
+                }
+                else
+                    message.Append(XMLConstants.TAG_TERM);
+            }
+            if (this.getTask().ResetSort || this.getTask().UserSorts != null) {
+                message.Append(XMLConstants.START_TAG + ConstInterface.MG_TAG_SORTS);
+                if (this.getTask().ResetSort) {
+                    message.Append(' ' + ConstInterface.CLEAR_SORTS + '="1"');
+                    this.getTask().ResetSort = false;
+                }
+                if (this.getTask().UserSorts != null)
+                    this.getTask().buildXMLForSorts(message);
+                else
+                    message.Append(XMLConstants.TAG_TERM);
+            }
+            if (await this.getTask().isCached()) {
+                let delList = this.getTask().getTaskCache().getDeletedListToXML();
+                if (delList !== '') {
+                    message.Append(XMLConstants.START_TAG + ConstInterface.MG_TAG_DEL_LIST);
+                    message.Append(' ' + XMLConstants.MG_ATTR_ID + '="' + this._task.getTaskTag() + '"');
+                    message.Append(' ' + ConstInterface.MG_ATTR_REMOVE + '="' + delList + '"');
+                    message.Append(XMLConstants.TAG_TERM);
+                    if (this.getTask().getTaskCache().isDeleted(this._dvPosValue))
+                        this.setChanged(true);
+                    this.getTask().getTaskCache().clearDeletedList();
+                }
+            }
+            let dcValKeys = this._dcValsCollection.Keys;
+            dcValKeys.forEach((dcValKey) => {
+                dcv = this._dcValsCollection.get_Item(dcValKey);
+                if (!dcv.HasReferences) {
+                    message.Append(XMLConstants.START_TAG + ConstInterface.MG_TAG_DC_VALS);
+                    message.Append(' ' + XMLConstants.MG_ATTR_ID + '="' + dcv.getId() + '"');
+                    message.Append(' ' + ConstInterface.MG_ATTR_REMOVE + '="1"');
+                    message.Append(XMLConstants.TAG_TERM);
+                    this._dcValsCollection.Remove(dcValKey);
+                }
+            });
+            if (this.CurrRec != null)
+                currRecDeleted = (this.CurrRec.getMode() === DataModificationTypes.Delete
+                    && this._modifiedRecordsTab.getRecord(this.CurrRec.getId()) != null && this.CurrRec.SendToServer);
+            let skipCurrRec = false;
+            if (this.CurrRec != null && this._modifiedRecordsTab.getRecord(this.CurrRec.getId()) != null)
+                skipCurrRec = AccessHelper.eventsManager.isForceExitPreRecordUpdate(this.getTask());
+            this._modifiedRecordsTab.buildXML(message, skipCurrRec, this.CurrRec.getId());
+            if (this._original != null)
+                this._original.clearMode();
+            for (let i = this._modifiedRecordsTab.getSize() - 1; i >= 0; i--) {
+                if (skipCurrRec && this._modifiedRecordsTab.getRecByIdx(i).getId() === this.CurrRec.getId())
+                    continue;
+                this._modifiedRecordsTab.getRecByIdx(i).clearFlagsHistory();
+                this._modifiedRecordsTab.removeRecord(i);
+            }
+            if (this.CurrRec != null && !currRecDeleted) {
+                let forceBuild = (this._task.isMainProg() && (RemoteCommandsProcessor.IsSessionReInitializing));
+                this.CurrRec.buildXML(message, true, forceBuild);
+            }
+        }
+        else {
+            message.Append(' ' + ConstInterface.MG_ATTR_INVOKER_ID + '="' + invokingTaskTag + ',' + serverParent + '"' +
+                XMLConstants.TAG_CLOSE);
+        }
+        message.Append('\n      </' + ConstInterface.MG_TAG_DATAVIEW + XMLConstants.TAG_CLOSE);
+    }
+    getCurrRec() {
+        if (this.CurrRec === null && this._currRecId > Int32.MinValue) {
+            Logger.Instance.WriteExceptionToLogWithMsg('DataView.getCurrRec(): record ' + this._currRecId + ' not found');
+        }
+        return this.CurrRec;
+    }
+    getPrevCurrRec() {
+        return this._prevCurrRec;
+    }
+    getOriginalRec() {
+        if (this._original === null || this._original.getId() !== this.CurrRec.getId())
+            return this.CurrRec;
+        return this._original;
+    }
+    async setCurrRec(id, compute) {
+        let oldRecId = this._currRecId;
+        if (id > Int32.MinValue) {
+            let newIdx = this._recordsTab.getRecIdx(id);
+            if (newIdx === -1)
+                this._original = null;
+            else {
+                try {
+                    let ignoreCurrRec = this._currRecId === Int32.MinValue;
+                    await this.setCurrRecByIdx(newIdx, !ignoreCurrRec, ignoreCurrRec, compute, Int32.MinValue);
+                    if (id !== oldRecId)
+                        this.saveOriginal();
+                    return true;
+                }
+                catch (exception) {
+                    if (exception instanceof RecordOutOfDataViewException) {
+                    }
+                    else
+                        throw exception;
+                }
+            }
+        }
+        else {
+            this.CurrRec = null;
+            this._original = null;
+            this._currRecId = Int32.MinValue;
+        }
+        return false;
+    }
+    async setCurrRecByIdx(newIdx, doSuffix, ignoreCurrRec, compute, newDisplayLine) {
+        let lastRecIdx = this._recordsTab.getSize() - 1;
+        let oldFirstRec, nextRec;
+        let recordSuff = false;
+        if (newIdx === Constants.MG_DATAVIEW_FIRST_RECORD) {
+            if (this.getTask().isTableWithAbsolutesScrollbar()) {
+                this.RecordsBeforeCurrentView = 0;
+            }
+            if (this._includesFirst) {
+                if (this._currRecIdx >= 0 || this._currRecIdx === Int32.MinValue) {
+                    newIdx = 0;
+                    recordSuff = true;
+                }
+                else
+                    throw new RecordOutOfDataViewException(RecordOutOfDataViewException_ExceptionType.TOP);
+            }
+            else {
+                await this.fetchChunkFromServer(CHUNK_DV_TOP, doSuffix);
+                await this.setCurrRecByIdx(newIdx, false, ignoreCurrRec, compute, SET_DISPLAYLINE_BY_DV);
+                return;
+            }
+        }
+        else if (newIdx === Constants.MG_DATAVIEW_LAST_RECORD) {
+            if (this._includesLast) {
+                if (this._currRecIdx <= lastRecIdx) {
+                    newIdx = lastRecIdx;
+                    recordSuff = true;
+                }
+                else
+                    throw new RecordOutOfDataViewException(RecordOutOfDataViewException_ExceptionType.BOTTOM);
+            }
+            else {
+                if (this.getTask().isTableWithAbsolutesScrollbar())
+                    this.RecordsBeforeCurrentView = this.TotalRecordsCount;
+                await this.fetchChunkFromServer(CHUNK_DV_BOTTOM, doSuffix);
+                if (!this._includesLast)
+                    throw new RecordOutOfDataViewException(RecordOutOfDataViewException_ExceptionType.BOTTOM);
+                if (this.getTask().isTableWithAbsolutesScrollbar()) {
+                    let form = this._task.getForm();
+                    if (form != null) {
+                        while (!this._includesFirst && form.getRowsInPage() >= this.getSize()) {
+                            await this.fetchChunkFromServer(CHUNK_CACHE_PREV, false);
+                        }
+                    }
+                }
+                await this.setCurrRecByIdx(newIdx, false, ignoreCurrRec, compute, SET_DISPLAYLINE_BY_DV);
+                return;
+            }
+        }
+        else if (newIdx < 0) {
+            if (this._includesFirst)
+                throw new RecordOutOfDataViewException(RecordOutOfDataViewException_ExceptionType.TOP);
+            oldFirstRec = this._recordsTab.getRecByIdx(0);
+            if (this._recordsTab.getSize() > 0 || this.IncludesLast())
+                await this.fetchChunkFromServer(CHUNK_CACHE_PREV, doSuffix);
+            else if (this._recordsTab.getSize() === 0 && this.IncludesFirst())
+                await this.fetchChunkFromServer(CHUNK_DV_TOP, doSuffix);
+            else
+                Logger.Instance.WriteExceptionToLogWithMsg('in DataView.fetchChunkFromServer() wrong option');
+            let oldFirstNewIdx = oldFirstRec != null
+                ? this._recordsTab.getRecIdx(oldFirstRec.getId())
+                : this._recordsTab.getSize();
+            if (oldFirstNewIdx !== 0)
+                await this.setCurrRecByIdx(oldFirstNewIdx + newIdx, false, ignoreCurrRec, compute, SET_DISPLAYLINE_BY_DV);
+            return;
+        }
+        else if (newIdx > lastRecIdx) {
+            if (this._includesLast)
+                throw new RecordOutOfDataViewException(RecordOutOfDataViewException_ExceptionType.BOTTOM);
+            if (this.getForm().isRowCreated(newIdx))
+                this.getForm().markRowNOTCreated(newIdx);
+            await this.fetchChunkFromServer(CHUNK_CACHE_NEXT, doSuffix);
+            await this.setCurrRecByIdx(newIdx, false, ignoreCurrRec, compute, SET_DISPLAYLINE_BY_DV);
+            return;
+        }
+        let isCreateLineAboveAct = false;
+        let lastEvent = isNullOrUndefined(AccessHelper.eventsManager.getLastRtEvent()) ? 0 :
+            AccessHelper.eventsManager.getLastRtEvent().getInternalCode();
+        if (newIdx >= 0 && !this.getTask().transactionFailed(ConstInterface.TRANS_RECORD_PREFIX) &&
+            lastEvent === InternalInterface.MG_ACT_CRELINE_ABOVE) {
+            if ((this.getTask().getInCreateLine()) && newIdx == this._currRecIdx) {
+                let newRec = this._recordsTab.getRecByIdx(newIdx);
+                if (newRec.getMode() == DataModificationTypes.Insert)
+                    isCreateLineAboveAct = true;
+            }
+        }
+        if (recordSuff || isCreateLineAboveAct || newIdx !== this._currRecIdx || ignoreCurrRec && compute) {
+            if (!ignoreCurrRec && doSuffix && this.CurrRec != null) {
+                let oldRecTabSize = this._recordsTab.getSize();
+                nextRec = this._recordsTab.getRecByIdx(newIdx);
+                if (nextRec.isNewRec()) {
+                    if (this._task.getMode() !== Constants.TASK_MODE_CREATE &&
+                        !await this._task.checkProp(PropInterface.PROP_TYPE_ALLOW_CREATE, true))
+                        AccessHelper.eventsManager.setStopExecution(true);
+                }
+                if (!AccessHelper.eventsManager.GetStopExecutionFlag()) {
+                    let orgTopRecIdx = 0;
+                    if (this._topRecIdxModified) {
+                        orgTopRecIdx = this.getTopRecIdx();
+                        this.restoreTopRecIdx();
+                    }
+                    await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_REC_SUFFIX);
+                    if (this._topRecIdxModified)
+                        this.setTopRecIdx(orgTopRecIdx);
+                }
+                if (AccessHelper.eventsManager.GetStopExecutionFlag())
+                    throw new RecordOutOfDataViewException(RecordOutOfDataViewException_ExceptionType.REC_SUFFIX_FAILED);
+                if (nextRec !== this.CurrRec && this.getTask().getAfterRetry())
+                    this._task.setLevel(Constants.TASK_LEVEL_TASK);
+                if (oldRecTabSize - 1 === this._recordsTab.getSize() && this._currRecIdx < newIdx)
+                    newIdx--;
+                if (newIdx === this._currRecIdx) {
+                    if (this._task.getMode() === Constants.TASK_MODE_CREATE && !this.CurrRec.isNewRec() &&
+                        !this._task.getForm().inRefreshDisplay())
+                        this._task.setMode(Constants.TASK_MODE_MODIFY);
+                    return;
+                }
+            }
+            this.CurrRec = this._recordsTab.getRecByIdx(newIdx);
+            if (this.CurrRec == null)
+                throw new ApplicationException('in DataView.setCurrRecByIdx() current record not found!');
+            this._currRecId = this.CurrRec.getId();
+            this._currRecIdx = newIdx;
+            if (this._task.getForm() != null) {
+                if (newDisplayLine === SET_DISPLAYLINE_BY_DV) {
+                    (this._task.getForm()).updateDisplayLineByDV();
+                }
+                else
+                    this._task.getForm().DisplayLine = newDisplayLine;
+            }
+            if (this._task.getMode() === Constants.TASK_MODE_CREATE && !this.CurrRec.isNewRec() &&
+                !this._task.getForm().inRefreshDisplay())
+                this._task.setMode(Constants.TASK_MODE_MODIFY);
+            if (compute)
+                await this.currRecCompute(false);
+        }
+    }
+    async currRecCompute(forceClientCompute) {
+        this._fieldsTab.invalidate(false, true);
+        await this.compute(false, forceClientCompute);
+    }
+    saveOriginal() {
+        if (!this.CurrRec.Modified)
+            this._original = this.CurrRec.replicate();
+    }
+    async fetchChunkFromServer(chunkId, doSuffix) {
+        this._task.getForm().FormRefreshed = true;
+        if (doSuffix && this.CurrRec != null) {
+            await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_REC_SUFFIX);
+            if (AccessHelper.eventsManager.GetStopExecutionFlag() || this._task.isAborting())
+                throw new RecordOutOfDataViewException(RecordOutOfDataViewException_ExceptionType.REC_SUFFIX_FAILED);
+            this._task.getForm().setSuffixDone();
+        }
+        let eventCode;
+        let clientRecId = this._currRecId;
+        switch (chunkId) {
+            case CHUNK_DV_TOP:
+                eventCode = InternalInterface.MG_ACT_DATAVIEW_TOP;
+                break;
+            case CHUNK_DV_BOTTOM:
+                eventCode = InternalInterface.MG_ACT_DATAVIEW_BOTTOM;
+                break;
+            case CHUNK_CACHE_PREV:
+                clientRecId = this.FirstRecord == null ? 0 : this.FirstRecord.getId();
+                eventCode = InternalInterface.MG_ACT_CACHE_PREV;
+                break;
+            case CHUNK_CACHE_NEXT:
+                eventCode = InternalInterface.MG_ACT_CACHE_NEXT;
+                clientRecId = this.LastRecord == null ? 0 : this.LastRecord.getId();
+                break;
+            default:
+                Logger.Instance.WriteExceptionToLogWithMsg('in DataView.fetchChunkFromServer() unknown chunk id: ' + chunkId);
+                return;
+        }
+        let cmd = CommandFactory.CreateEventCommand(this._task.getTaskTag(), eventCode);
+        cmd.ClientRecId = clientRecId;
+        await this.getTask().DataviewManager.Execute(cmd);
+    }
+    async FetchRecordsAheadFromServer() {
+        if (!this._includesLast)
+            await this.fetchChunkFromServer(CHUNK_CACHE_NEXT, false);
+        else if (!this._includesFirst)
+            await this.fetchChunkFromServer(CHUNK_CACHE_PREV, false);
+    }
+    recExists(recIdx) {
+        let lastRecIdx = this._recordsTab.getSize() - 1;
+        return recIdx >= 0 && recIdx <= lastRecIdx;
+    }
+    checkFirst(locateFirst) {
+        return this._recordsTab.getRecord(locateFirst) !== null;
+    }
+    getCurrRecIdx() {
+        if (this._currRecIdx === Int32.MinValue) {
+            if (!this.setCurrRec(this._currRecId, true)) {
+                Logger.Instance.WriteWarningToLogWithMsg('DataView.getCurrRecIdx(): _task ' +
+                    (this.getTask()).PreviouslyActiveTaskId +
+                    ', record ' + this._currRecId + ' not found');
+            }
+        }
+        return this._currRecIdx;
+    }
+    getCurrDBViewRowIdx() {
+        return this.CurrRec.getDBViewRowIdx();
+    }
+    setTopRecIdx(newTopRecIdx) {
+        this._oldTopRecIdx = this.getTopRecIdx();
+        this._topRecIdx = newTopRecIdx;
+    }
+    getTopRecIdx() {
+        return this._topRecIdx;
+    }
+    setTopRecIdxModified(val) {
+        this._topRecIdxModified = val;
+    }
+    getChunkSize() {
+        return this._chunkSize;
+    }
+    restoreTopRecIdx() {
+        this._topRecIdx = this._oldTopRecIdx;
+    }
+    clear() {
+        this._recordsTab.removeAll();
+        this._original = null;
+        let mgForm = this._task.getForm();
+        if (mgForm !== null) {
+            this._task.getForm().SetTableItemsCount(0, true);
+        }
+        this._modifiedRecordsTab.removeAll();
+        this.init();
+    }
+    init() {
+        this._currRecId = Int32.MinValue;
+        this._currRecIdx = Int32.MinValue;
+        this.CurrRec = null;
+        this._prevCurrRec = null;
+        this._includesFirst = false;
+        this._includesLast = false;
+        this.IsOneWayKey = false;
+        this.setTopRecIdx(Int32.MinValue);
+        this._fieldsTab.invalidate(false, true);
+    }
+    async computeSubForms() {
+        if (await this.getTask().prepareCache(true)) {
+            if (!await this.getTask().testAndSet(true))
+                await this.compute(true, false);
+        }
+        else
+            await this.compute(true, false);
+    }
+    async compute(subForms, forceClientCompute) {
+        let tmpRec = null;
+        let computeByServer = !this.computeByClient();
+        let orgComputeBy = this._computeBy;
+        if (forceClientCompute)
+            this._computeBy = COMPUTE_NEWREC_ON_CLIENT;
+        try {
+            this.CurrRec.setInCompute(true);
+            if (!subForms) {
+                if (this.CurrRec.isNewRec()) {
+                    if (this._task.getMode() !== Constants.TASK_MODE_CREATE && !super.isEmptyDataview()) {
+                        this._task.setMode(Constants.TASK_MODE_CREATE);
+                    }
+                }
+                else if (this._task.getMode() === Constants.TASK_MODE_CREATE) {
+                    this._task.setMode(Constants.TASK_MODE_MODIFY);
+                }
+            }
+            let getRecordData = computeByServer;
+            if (subForms || (getRecordData && !this.CurrRec.isComputed() && !forceClientCompute)) {
+                let command = CommandFactory.CreateComputeEventCommand(this._task.getTaskTag(), subForms, this._currRecId);
+                await this._task.DataviewManager.Execute(command);
+            }
+            else {
+                if (getRecordData) {
+                    tmpRec = new Record(this.CurrRec.getId(), this);
+                    tmpRec.Initialize();
+                    tmpRec.setInitialFldVals(true, true);
+                }
+                this._fieldsTab.setServerRcmp(false);
+                let from = this._fieldsTab.getRMIdx();
+                let size = this._fieldsTab.getRMSize();
+                for (let i = from; i < from + size; i = i + 1) {
+                    let fld = this._fieldsTab.getField(i);
+                    if (getRecordData && this._fieldsTab.serverRcmpDone() && fld.IsVirtual && !fld.VirAsReal && !fld.hasInitExp()) {
+                        let currRec2 = this.CurrRec;
+                        this.CurrRec = tmpRec;
+                        try {
+                            fld.takeValFromRec();
+                        }
+                        finally {
+                            this.CurrRec = currRec2;
+                        }
+                    }
+                    if (!this._task.getForm().TransferringDataToGUI)
+                        await fld.compute(false);
+                }
+            }
+        }
+        finally {
+            this.CurrRec.setInCompute(false);
+            this.CurrRec.setLateCompute(false);
+            this._computeBy = orgComputeBy;
+        }
+    }
+    async addRecord(doSuffix, ignoreCurrRec, isCrelineAbove) {
+        let newCurrRecId = (--this._lastCreatedRecId);
+        let mode = DataModificationTypes.Insert;
+        return await this.addRecord_1(doSuffix, ignoreCurrRec, false, newCurrRecId, mode, isCrelineAbove);
+    }
+    async addRecord_1(doSuffix, ignoreCurrRec, isFirstRecord, newCurrRecId, mode, isCrelineAbove) {
+        let rec = new Record(newCurrRecId, this);
+        rec.Initialize();
+        rec.setInitialFldVals(false, !isFirstRecord);
+        let newCurrRecIdx = 0;
+        if (isCrelineAbove) {
+            newCurrRecIdx = (this._currRecIdx >= 0
+                ? this._currRecIdx
+                : 0);
+        }
+        else
+            newCurrRecIdx = (this._currRecIdx != Int32.MinValue
+                ? this._currRecIdx + 1
+                : 0);
+        this._recordsTab.insertRecord(rec, newCurrRecIdx);
+        rec.setMode(mode);
+        try {
+            let compute = !isFirstRecord;
+            await this.setCurrRecByIdx(newCurrRecIdx, doSuffix, ignoreCurrRec, compute, Int32.MinValue);
+            if (isFirstRecord && this.getTask().getMode() !== Constants.TASK_MODE_CREATE)
+                rec.setOldRec();
+        }
+        catch (execption) {
+            if (execption instanceof RecordOutOfDataViewException) {
+                if (AccessHelper.eventsManager.GetStopExecutionFlag())
+                    newCurrRecIdx = -1;
+                else
+                    throw new ApplicationException('in DataView.addRecord() invalid exception');
+            }
+            else
+                throw execption;
+        }
+        return newCurrRecIdx;
+    }
+    async removeCurrRec() {
+        let mgForm = this._task.getForm();
+        let onDelete;
+        if (this.CurrRec.getMode() === DataModificationTypes.Insert &&
+            !this.getTask().transactionFailed(ConstInterface.TRANS_RECORD_PREFIX)) {
+            this._modifiedRecordsTab.removeRecord(this.CurrRec);
+            onDelete = false;
+        }
+        else {
+            this.CurrRec.clearMode();
+            this.CurrRec.setMode(DataModificationTypes.Delete);
+            onDelete = true;
+        }
+        this.CurrRec.removeRecFromDc();
+        this._recordsTab.removeRecord(this._currRecIdx);
+        this.setChanged(true);
+        if (this.isEmpty() && !this._task.IsTryingToStop) {
+            await this.MoveToEmptyDataviewIfAllowed();
+        }
+        let newDisplayLine = this.calcLineToMove(onDelete);
+        try {
+            if (mgForm.isScreenMode()) {
+                await this.setCurrRecByIdx(newDisplayLine, false, false, true, SET_DISPLAYLINE_BY_DV);
+            }
+            else {
+                await mgForm.setCurrRowByDisplayLine(newDisplayLine, false, true);
+            }
+        }
+        catch (exception) {
+            if (exception instanceof RecordOutOfDataViewException) {
+                try {
+                    if (!super.isEmptyDataview())
+                        newDisplayLine = mgForm.getPrevLine(newDisplayLine);
+                    if (mgForm.isScreenMode())
+                        await this.setCurrRecByIdx(newDisplayLine, false, false, true, SET_DISPLAYLINE_BY_DV);
+                    else
+                        await mgForm.setCurrRowByDisplayLine(newDisplayLine, false, true);
+                }
+                catch (exception) {
+                    if (exception instanceof RecordOutOfDataViewException) {
+                        this.reset();
+                    }
+                    else
+                        throw exception;
+                }
+            }
+            else
+                throw exception;
+        }
+    }
+    RemoveRecord(record) {
+        let recIdx = this._recordsTab.getRecIdx(record.getId());
+        if (this._topRecIdx > recIdx)
+            this._topRecIdx--;
+        if (this._oldTopRecIdx > recIdx)
+            this._oldTopRecIdx--;
+        if (this._currRecIdx > recIdx)
+            this._currRecIdx--;
+        this._recordsTab.removeRecord(record);
+    }
+    async MoveToEmptyDataviewIfAllowed() {
+        if (!super.isEmptyDataview() && this._task.getMode() !== Constants.TASK_MODE_CREATE) {
+            if (await this._task.checkProp(PropInterface.PROP_TYPE_ALLOW_EMPTY_DATAVIEW, true))
+                super.setEmptyDataview(true);
+        }
+        else {
+            if (this._task.getMode() === Constants.TASK_MODE_CREATE && super.isEmptyDataview())
+                super.setEmptyDataview(false);
+        }
+    }
+    calcLineToMove(onDelete) {
+        let newDisplayLine;
+        if (onDelete)
+            newDisplayLine = this._currRecIdx;
+        else {
+            if (this._currRecIdx > 0)
+                newDisplayLine = this._currRecIdx - 1;
+            else
+                newDisplayLine = this._currRecIdx;
+        }
+        return newDisplayLine;
+    }
+    reset() {
+        this._currRecId = Int32.MinValue;
+        this._currRecIdx = Int32.MinValue;
+        this.CurrRec = null;
+        this.setTopRecIdx(Int32.MinValue);
+        this.SetIncludesFirst(true);
+        this.SetIncludesLast(true);
+    }
+    async cancelEdit(onlyReal, recomputeUnknowns) {
+        let tempCurrRec = null;
+        let recRemoved = false;
+        let inEndTask = this._task.InEndTask;
+        if (inEndTask)
+            onlyReal = true;
+        if (this.CurrRec.getMode() === DataModificationTypes.Insert && this.CurrRec.isNewRec()) {
+            if ((this._includesFirst && this._includesLast && (this._recordsTab === null || this._recordsTab.getSize() === 1)) || !this.HasMainTable) {
+                if (this._original !== null) {
+                    this.CurrRec.setSameAs(this._original, onlyReal);
+                }
+            }
+            else {
+                await this.removeCurrRec();
+                recRemoved = true;
+                this._original = this.CurrRec.replicate();
+            }
+        }
+        else {
+            if (!this.CurrRec.Modified) {
+                let currCtrl = this._task.getLastParkedCtrl();
+                if (currCtrl !== null)
+                    currCtrl.resetPrevVal();
+            }
+            if (recomputeUnknowns)
+                tempCurrRec = this.CurrRec.replicate();
+            if (this._original !== null)
+                this.CurrRec.setSameAs(this._original, onlyReal);
+            if ((this._original !== null && recomputeUnknowns) && !this.CurrRec.isSameRecData(tempCurrRec, false, false))
+                await this.execUnknownRcmps(this._original);
+            this.takeFldValsFromCurrRec();
+            this._original = this.CurrRec.replicate();
+        }
+        return recRemoved;
+    }
+    isEmpty() {
+        return this._includesFirst && this._includesLast && (this._recordsTab === null || this._recordsTab.getSize() === 0);
+    }
+    async addCurrToModified(setRecToOld) {
+        if (isNullOrUndefined(setRecToOld)) {
+            await this.addCurrToModified_0();
+            return;
+        }
+        await this.addCurrToModified_1(setRecToOld);
+    }
+    async addCurrToModified_0() {
+        await this.addCurrToModified(true);
+    }
+    async addCurrToModified_1(setRecToOld) {
+        this._modifiedRecordsTab.addRecord(this.CurrRec);
+        if (setRecToOld) {
+            this.CurrRec.setOldRec();
+        }
+        let command = CommandFactory.CreateSetTransactionStateDataviewCommand(this.getTask().getTaskTag(), true);
+        await this.getTask().DataviewManager.RemoteDataviewManager.Execute(command);
+    }
+    takeFldValsFromCurrRec() {
+        this._fieldsTab.takeValsFromRec();
+    }
+    currEqualsPrev(fldList) {
+        if (this.CurrRec !== null && this._prevCurrRec !== null) {
+            if (this.CurrRec === this._prevCurrRec)
+                return true;
+            for (let i = 0; i < fldList.length; i = i + 1) {
+                if (!this.CurrRec.fldValsEqual(this._prevCurrRec, fldList[i]))
+                    return false;
+            }
+        }
+        else if (this.CurrRec !== this._prevCurrRec)
+            return false;
+        return true;
+    }
+    getTask() {
+        Debug.Assert(this._task instanceof TaskBase);
+        return this._task;
+    }
+    getForm() {
+        return this._task.getForm();
+    }
+    modifiedRecordsNumber() {
+        return this._modifiedRecordsTab.getSize();
+    }
+    getSize() {
+        return this._recordsTab.getSize();
+    }
+    computeByClient() {
+        return this._computeBy === COMPUTE_NEWREC_ON_CLIENT;
+    }
+    recExistsById(id) {
+        return this._recordsTab.getRecord(id) !== null;
+    }
+    ParametersExist(iPos, iLen) {
+        if (arguments.length === 2)
+            return this.ParametersExist_0(iPos, iLen);
+        return this.ParametersExist_1();
+    }
+    ParametersExist_0(iPos, iLen) {
+        for (let i = iPos; i < iPos + iLen; i = i + 1) {
+            if (super.getField(i).isParam())
+                return true;
+        }
+        return false;
+    }
+    ParametersExist_1() {
+        return this.ParametersExist(this._rmIdx, this._rmSize);
+    }
+    recInModifiedTab(id) {
+        let record = this._modifiedRecordsTab.getRecord(id);
+        return record !== null;
+    }
+    setPrevCurrRec(rec) {
+        if (arguments.length === 0) {
+            this.setPrevCurrRec_0();
+            return;
+        }
+        this.setPrevCurrRec_1(rec);
+    }
+    setPrevCurrRec_0() {
+        this._prevCurrRec = this.CurrRec;
+    }
+    setPrevCurrRec_1(rec) {
+        this._prevCurrRec = rec;
+    }
+    isPrevCurrRecNull() {
+        return this._prevCurrRec === null;
+    }
+    async execUnknownRcmps(orgRec) {
+        let i;
+        let from = this._fieldsTab.getRMIdx();
+        let size = this._fieldsTab.getRMSize();
+        let rec = this.getCurrRec();
+        if (this._unknownRcmp === UNKNOWN_RCMPS_NOT_INITED) {
+            for (i = from; i < from + size && this._unknownRcmp === UNKNOWN_RCMPS_NOT_INITED; i++) {
+                let field = this._fieldsTab.getField(i);
+                if (field.IsVirtual && !field.hasInitExp() && field.isServerRcmp())
+                    this._unknownRcmp = UNKNOWN_RCMPS_FOUND;
+            }
+        }
+        if (this._unknownRcmp === UNKNOWN_RCMPS_FOUND && rec !== null) {
+            for (i = from; i < from + size; i = i + 1) {
+                let field = this._fieldsTab.getField(i);
+                if (field.IsVirtual && !field.hasInitExp() && field.isServerRcmp() && !rec.fldValsEqual(orgRec, i)) {
+                    let fieldValue = rec.GetFieldValue(i);
+                    let isNullFld = rec.IsNull(i);
+                    rec.setFieldValue(i, orgRec.GetFieldValue(i), false);
+                    await field.setValueAndStartRecompute(fieldValue, isNullFld, false, false, false);
+                }
+            }
+        }
+    }
+    setTransCleared() {
+        this._transCleared = true;
+    }
+    async processRecovery() {
+        if (!this._task.isAborting()) {
+            let orgAction = this._pendingRecovery;
+            let orgStopExecution = AccessHelper.eventsManager.GetStopExecutionFlag();
+            this._pendingRecovery = RECOVERY_ACT_NONE;
+            if (orgStopExecution)
+                AccessHelper.eventsManager.setStopExecution(false);
+            let temporaryResetInCtrlPrefix = this._task.InCtrlPrefix;
+            if (temporaryResetInCtrlPrefix)
+                this._task.InCtrlPrefix = false;
+            switch (orgAction) {
+                case RECOVERY_ACT_CANCEL:
+                    (this._task.DataView.getCurrRec()).resetUpdated();
+                    this.getTask().getTaskCache().clearCache();
+                    if (this.getSize() === 1 && this._task.getMode() === Constants.TASK_MODE_CREATE) {
+                        this.CurrRec.resetModified();
+                        this.CurrRec.clearMode();
+                        this.CurrRec.setMode(DataModificationTypes.Insert);
+                        this.CurrRec.setNewRec();
+                        this._original.setSameAs(this.CurrRec, false);
+                    }
+                    await AccessHelper.eventsManager.handleInternalEventWithTaskAndEventSubtype(this.getTask(), InternalInterface.MG_ACT_CANCEL, EventSubType.CancelWithNoRollback);
+                    break;
+                case RECOVERY_ACT_MOVE_DIRECTION_BEGIN:
+                    let lastParkedControl = this._task.getLastParkedCtrl();
+                    if (lastParkedControl !== null)
+                        await lastParkedControl.invoke();
+                    break;
+                case RECOVERY_ACT_BEGIN_SCREEN:
+                    this.getTask().setPreventRecordSuffix(true);
+                    await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_TBL_BEGPAGE);
+                    this.getTask().setPreventRecordSuffix(false);
+                    break;
+                case RECOVERY_ACT_BEGIN_TABLE:
+                    this._task.ActionManager.enable(InternalInterface.MG_ACT_TBL_BEGTBL, true);
+                    await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_TBL_BEGTBL);
+                    this.getTask().getTaskCache().clearCache();
+                    break;
+                default:
+                    AccessHelper.eventsManager.setStopExecution(orgStopExecution);
+                    break;
+            }
+            if (temporaryResetInCtrlPrefix)
+                this._task.InCtrlPrefix = true;
+            if (orgAction !== RECOVERY_ACT_NONE)
+                AccessHelper.eventsManager.setStopExecution(true, orgAction !== RECOVERY_ACT_BEGIN_TABLE ? ClearEventsOnStopExecution.ALL : ClearEventsOnStopExecution.SERVER);
+        }
+    }
+    replicate() {
+        let rep = new DataView(this);
+        rep._recordsTab = this._recordsTab.replicate();
+        rep._currRecId = rep._recordsTab.getRecByIdx(0).getId();
+        rep._currRecIdx = 0;
+        rep.CurrRec = rep._recordsTab.getRecByIdx(0);
+        rep._prevCurrRec = rep._recordsTab.getRecByIdx(0);
+        rep._original = rep._recordsTab.getRecByIdx(0);
+        rep.setTopRecIdx(Int32.MinValue);
+        return rep;
+    }
+    getDvPosValue() {
+        return this._dvPosValue;
+    }
+    getFirstDv() {
+        return this._firstDv;
+    }
+    ResetFirstDv() {
+        this._firstDv = false;
+    }
+    getCacheLRU() {
+        return this._cacheLruTimeStamp;
+    }
+    setCacheLRU() {
+        this._cacheLruTimeStamp = Misc.getSystemMilliseconds();
+    }
+    async setSameAs(newDv) {
+        this._rmSize = newDv._rmSize;
+        this._rmIdx = newDv._rmIdx;
+        this._computeBy = newDv._computeBy;
+        this._flushUpdates = newDv._flushUpdates;
+        this._currRecId = newDv._currRecId;
+        this._currRecIdx = newDv._currRecIdx;
+        this._topRecId = newDv._topRecId;
+        this.CurrRec = newDv.CurrRec;
+        this._original = newDv._original;
+        this._prevCurrRec = null;
+        this._fieldsTab = newDv._fieldsTab;
+        this._recordsTab = newDv._recordsTab;
+        this._modifiedRecordsTab = newDv._modifiedRecordsTab;
+        this._includesFirst = newDv._includesFirst;
+        this._includesLast = newDv._includesLast;
+        this._insertAt = newDv._insertAt;
+        this._lastCreatedRecId = newDv._lastCreatedRecId;
+        this._task = newDv._task;
+        this._dcValsCollection = newDv._dcValsCollection;
+        this._recovery = newDv._recovery;
+        this._pendingRecovery = newDv._pendingRecovery;
+        this._hasMainTable = newDv._hasMainTable;
+        this._chunkSize = newDv._chunkSize;
+        this._firstDv = newDv._firstDv;
+        this._lastSessionCounter = newDv._lastSessionCounter;
+        this._skipParsing = newDv._skipParsing;
+        this._unknownRcmp = newDv._unknownRcmp;
+        this._transCleared = newDv._transCleared;
+        this._dvPosValue = newDv._dvPosValue;
+        this._cacheLruTimeStamp = newDv._cacheLruTimeStamp;
+        this._changed = newDv._changed;
+        this._locateFirstRec = newDv._locateFirstRec;
+        super.setEmptyDataview(newDv.isEmptyDataview());
+        this._task.setMode(newDv.taskModeFromCache);
+        try {
+            if (this.getTask().HasLoacte()) {
+                await this.setCurrRec(this._locateFirstRec, true);
+                this.setTopRecIdx(this._recordsTab.getRecIdx(this._locateFirstRec));
+            }
+            else {
+                this.getTask().setPreventRecordSuffix(true);
+                await this.setCurrRecByIdx(Int32.MinValue, true, false, true, Int32.MinValue);
+                this.getTask().setPreventRecordSuffix(false);
+                this.setTopRecIdx(0);
+            }
+            if (!this._task.getForm().isScreenMode()) {
+                if (this._task.getForm().isTableWithPagination()) {
+                    this.TotalRecordsCount = newDv.TotalRecordsCount;
+                    this.RecordsBeforeCurrentView = newDv.RecordsBeforeCurrentView;
+                }
+                await this.setCurrRecByIdx(this._topRecIdx, true, false, true, Int32.MinValue);
+            }
+            if (this._task.getForm() !== null)
+                this._task.getForm().updateDisplayLineByDV();
+        }
+        catch (ex) {
+            if (ex instanceof RecordOutOfDataViewException) {
+                Logger.Instance.WriteDevToLog('wrong top record idx in DataView.setSameAs' + ex.Message);
+            }
+            else
+                throw ex;
+        }
+    }
+    setChanged(val) {
+        this._changed = val;
+    }
+    getChanged() {
+        return this._changed;
+    }
+    getLocateFirstRec() {
+        return this._locateFirstRec;
+    }
+    setLocateFirstRec(newFirst) {
+        this._locateFirstRec = newFirst;
+    }
+    getRecByIdx(idx) {
+        return this._recordsTab.getRecByIdx(idx);
+    }
+    getServerCurrRec() {
+        return this._recordsTab.getServerCurrRec();
+    }
+    zeroServerCurrRec() {
+        this._recordsTab.zeroServerCurrRec();
+    }
+    inRollback() {
+        let inRollback = false;
+        if (this._recovery === ConstInterface.RECOVERY_ROLLBACK && this.getTask().isTransactionOwner()) {
+            inRollback = true;
+        }
+        return inRollback;
+    }
+    getRecIdx(id) {
+        return this._recordsTab.getRecIdx(id);
+    }
+    backupCurrent() {
+        return this.CurrRec.replicate();
+    }
+    restoreCurrent(recBackup) {
+        Debug.Assert(recBackup !== null);
+        this._currRecId = recBackup.getId();
+        this._currRecIdx = this._recordsTab.getRecIdx(this._currRecId);
+        this.CurrRec = this._recordsTab.getRecByIdx(this._currRecIdx);
+        this.CurrRec.setSameAs(recBackup, false);
+        this.takeFldValsFromCurrRec();
+    }
+    GetCurrentRecId() {
+        return this._currRecId;
+    }
+    DataviewBoundriesAreChanged(orgIncludesFirst, orgIncludesLast) {
+        return orgIncludesFirst !== this.IncludesFirst() || orgIncludesLast !== this.IncludesLast();
+    }
+    GetRouteParams() {
+        let params = new List();
+        for (let i = 0; i < this._fieldsTab.getSize(); i++) {
+            let field = this._fieldsTab.getField(i);
+            let val;
+            if (field.IsExposedRouteParam && !field.isNull()) {
+                switch (field.getType()) {
+                    case StorageAttribute.ALPHA:
+                    case StorageAttribute.UNICODE:
+                        {
+                            val = field.getDispValue();
+                            if (field.isNull())
+                                val = field.getNullDisplay();
+                            val = val.trim();
+                            params.push(val.length === 0 ? ' ' : val);
+                        }
+                        break;
+                    case StorageAttribute.BOOLEAN:
+                        {
+                            if (field.isNull())
+                                params.push(false);
+                            else
+                                params.push((field.getDispValue()).charAt(0) === '1');
+                        }
+                        break;
+                    case StorageAttribute.NUMERIC: {
+                        val = field.getDispValue();
+                        if (field.isNull())
+                            val = field.getNullDisplay();
+                        let pic = new PIC(field.getPicture(), field.getType(), this.getTask().getCompIdx());
+                        val = DisplayConvertor.Instance.mg2disp(val, '', pic, true, 0, false);
+                        params.push(val);
+                        break;
+                    }
+                }
+            }
+        }
+        return (params.length > 0) ? params : null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DataView.js","sourceRoot":"","sources":["../../../../../../projects/engine/src/data/DataView.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ApplicationException,\r\n  Debug,\r\n  Int32,\r\n  Int64,\r\n  isNullOrUndefined,\r\n  List,\r\n  NNumber,\r\n  StringBuilder\r\n} from '@magic-xpa/mscorelib';\r\nimport {\r\n  Constants,\r\n  InternalInterface,\r\n  Logger,\r\n  Misc,\r\n  StorageAttribute,\r\n  XMLConstants,\r\n  XmlParser\r\n} from '@magic-xpa/utils';\r\nimport {\r\n  DataModificationTypes,\r\n  DcValues,\r\n  DisplayConvertor,\r\n  IRecord,\r\n  MgControlBase,\r\n  MgFormBase,\r\n  PIC,\r\n  Property,\r\n  PropInterface\r\n} from '@magic-xpa/gui';\r\nimport { ConstInterface } from '../ConstInterface';\r\nimport { RecordsTable } from './RecordsTable';\r\nimport { Record } from './Record';\r\nimport { TaskBase } from '../tasks/TaskBase';\r\nimport { MgForm } from '../gui/MgForm';\r\nimport { FieldsTableExt as FieldsTable } from './FieldsTable';\r\nimport {\r\n  RecordOutOfDataViewException,\r\n  RecordOutOfDataViewException_ExceptionType\r\n} from './RecordOutOfDataViewException';\r\nimport { IClientCommand } from '../commands/IClientCommand';\r\nimport { CommandFactory } from '../commands/ClientToServer/CommandFactory';\r\nimport { XMLBasedDcValuesBuilder } from './XMLBasedDcValuesBuilder';\r\nimport { Field } from './Field';\r\nimport { MgControl } from '../gui/MgControl';\r\nimport { EventSubType } from '../enums';\r\nimport { EventCommand } from '../commands/ClientToServer/EventCommand';\r\nimport { RemoteCommandsProcessor } from '../remote/RemoteCommandsProcessor';\r\nimport { FieldBase } from './FieldBase';\r\nimport { CommandsProcessorManager } from '../CommandsProcessorManager';\r\nimport { DataViewBase } from './DataViewBase';\r\nimport { AccessHelper, ClearEventsOnStopExecution } from '../AccessHelper';\r\nimport { MGDataCollection } from '../tasks/MGDataCollection';\r\nimport { Task } from '../tasks/Task';\r\n\r\n\r\n// CONSTANTS\r\nexport const SET_DISPLAYLINE_BY_DV: number = Int32.MinValue;\r\nconst COMPUTE_NEWREC_ON_CLIENT: string = 'C';\r\nconst UNKNOWN_RCMPS_NOT_INITED: string = 'M';\r\nconst UNKNOWN_RCMPS_FOUND: string = 'Y';\r\n\r\nconst INVOKED_FROM_OFFLINE_TASK: string = '-99999';\r\n\r\nconst CHUNK_CACHE_NEXT: string = 'N';\r\nconst CHUNK_CACHE_PREV: string = 'P';\r\nconst CHUNK_DV_BOTTOM: string = 'B';\r\nconst CHUNK_DV_TOP: string = 'T';\r\n\r\nconst COMPUTE_FLUSH_UPDATES: string = 'H';\r\n\r\nconst COMPUTE_NEWREC_ON_SERVER: string = 'S';\r\nconst END_DV_TAG: string = '</' + ConstInterface.MG_TAG_DATAVIEW + '>';\r\nconst RECOVERY_ACT_BEGIN_SCREEN: string = 'S';\r\n\r\n// recovery action taken by the client in response to recovery type\r\nconst RECOVERY_ACT_BEGIN_TABLE: string = 'T';\r\nconst RECOVERY_ACT_CANCEL: string = 'C';\r\nconst RECOVERY_ACT_MOVE_DIRECTION_BEGIN: string = 'B';\r\nconst RECOVERY_ACT_NONE: string = 'N';\r\nconst TRANS_STAT_CLOSED: string = 'C';\r\nconst TRANS_STAT_OPENED: string = 'O';\r\n\r\n/// <summary>\r\n///   this class represents the dataview of a task\r\nexport class DataView extends DataViewBase {\r\n  private _cacheLruTimeStamp: number = 0;\r\n  private _changed: boolean = false;\r\n  private _chunkSize: number = 30;\r\n  private _computeBy: string = '\\0'; // tells the client to execute the compute of new records on the client or on the server\r\n  private _currRecId: number = 0;\r\n  private _currRecIdx: number = 0;\r\n  private _dvPosValue: number = 0;\r\n  private _firstDv: boolean = true;\r\n  private _flushUpdates: boolean = false; // TRUE means that whenever a record is changed we must send it to the server\r\n  private _hasMainTable: boolean = true;\r\n\r\n  private _insertAt: string = ' ';\r\n\r\n  set InsertAt(value: string) {\r\n    this._insertAt = value;\r\n  }\r\n\r\n  get InsertAt(): string {\r\n    return this._insertAt;\r\n  }\r\n\r\n  /// <summary>\r\n  /// true, if we are executing local dataview command\r\n  /// </summary>\r\n  InLocalDataviewCommand: boolean = false;\r\n  private _lastCreatedRecId: number = 0; // the record id of the last created record id\r\n  private _lastSessionCounter: number = Int64.MinValue;\r\n  private _locateFirstRec: number = -1;\r\n  private _modifiedRecordsTab: RecordsTable = null; // after sending these records to the server the list is cleared\r\n\r\n  private _oldTopRecIdx: number = Int32.MinValue;\r\n  private _original: Record = null;\r\n  private _pendingRecovery: string = RECOVERY_ACT_NONE; // when different than NONE, means the server order for recovery was not performed (yet).\r\n  private _prevCurrRec: Record = null;\r\n  private _recordsTab: RecordsTable = null; // <dataview> ...</dataview> tag\r\n  private _recovery: string = ConstInterface.RECOVERY_NONE; // recovery action request, received from the server\r\n  private _rmIdx: number = 0; // the index of the first field in the record main\r\n  private _rmSize: number = 0; // number of \"select\"s in the record main\r\n  private _skipParsing: boolean = false;\r\n  private _topRecId: number = 0;\r\n  private _topRecIdx: number = Int32.MinValue;\r\n  private _topRecIdxModified: boolean = false;\r\n  private _transCleared: boolean = false; // If true, _task is the owner of a Rec level transaction and the _task is in _task suffix\r\n  private _unknownRcmp: string = UNKNOWN_RCMPS_NOT_INITED; // signals if a virtual field without init expression has server rcmp action\r\n\r\n  IsOneWayKey: boolean = false;\r\n\r\n  _includesFirst: boolean = false;\r\n  _includesLast: boolean = false;\r\n  _serverTransCacheEmpty: boolean = true; // indication whether the server side transaction cache is empty\r\n\r\n  private _currRec_DO_NOT_USE_DIRECTLY_USE_SETTER_GETTER: Record = null;\r\n\r\n  private get CurrRec(): Record {\r\n    return this._currRec_DO_NOT_USE_DIRECTLY_USE_SETTER_GETTER;\r\n  }\r\n\r\n  private set CurrRec(value: Record) {\r\n    // reset the prev dcValIds in mgcontrol\r\n    if (this._currRec_DO_NOT_USE_DIRECTLY_USE_SETTER_GETTER !== null && value === null) {\r\n      this._currRec_DO_NOT_USE_DIRECTLY_USE_SETTER_GETTER.resetDcValueId();\r\n    }\r\n    this._currRec_DO_NOT_USE_DIRECTLY_USE_SETTER_GETTER = value;\r\n\r\n    // set the dcValIds in mgcontrol\r\n    if (this._currRec_DO_NOT_USE_DIRECTLY_USE_SETTER_GETTER !== null) {\r\n      this._currRec_DO_NOT_USE_DIRECTLY_USE_SETTER_GETTER.SetDcValueId();\r\n    }\r\n  }\r\n\r\n  get FlushUpdates(): boolean {\r\n    return this._flushUpdates;\r\n  }\r\n\r\n  get HasMainTable(): boolean {\r\n    return this._hasMainTable;\r\n  }\r\n\r\n  DBViewSize: number = 0;\r\n  taskModeFromCache: string;\r\n\r\n  get CurrentRecId(): number {\r\n    return this._currRecId;\r\n  }\r\n\r\n  Dvcount: number = 0;\r\n  TotalRecordsCount: number = 0;\r\n  RecordsBeforeCurrentView: number = 0;\r\n\r\n  /// <summary>\r\n  /// first Dataview Record\r\n  /// </summary>\r\n  get FirstRecord(): IRecord {\r\n    return this._recordsTab.getRecByIdx(0);\r\n  }\r\n\r\n  /// <summary>\r\n  /// last dataview record\r\n  /// </summary>\r\n  get LastRecord(): IRecord {\r\n    return this._recordsTab.getRecByIdx(this._recordsTab.getSize() - 1);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   CTOR\r\n  /// </summary>\r\n  constructor(task: TaskBase);\r\n  constructor(DataView: DataView);\r\n  constructor(taskOrDataView: DataView | TaskBase) {\r\n    super();\r\n    if (taskOrDataView instanceof TaskBase) {\r\n      this._task = <TaskBase>taskOrDataView;\r\n      this._fieldsTab = new FieldsTable();\r\n      this._recordsTab = new RecordsTable(true);\r\n      this._modifiedRecordsTab = new RecordsTable(false);\r\n    } else {\r\n      Object.assign(this, taskOrDataView);\r\n    }\r\n  }\r\n\r\n  public Init(): void {\r\n    this.init();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   checks if the first row of data is exists in the client's data view\r\n  /// </summary>\r\n  /// <returns> true is the first row of data is included in the client </returns>\r\n  IncludesFirst(): boolean {\r\n    return this._includesFirst;\r\n  }\r\n\r\n  get ServerTransactionCacheEmpty(): boolean {\r\n    return this._serverTransCacheEmpty;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   checks if the last row of data is included in the client's data view\r\n  /// </summary>\r\n  /// <returns> true if the last row of data is included in the client's data view </returns>\r\n  IncludesLast(): boolean {\r\n    return this._includesLast;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parse the DVHEADER tag\r\n  /// </summary>\r\n  fillHeaderData(parser: XmlParser): void {\r\n    while (this.initHeaderInnerObjects(parser, parser.getNextTag())) {\r\n    }\r\n    this.Dvcount = (<TaskBase>this._task).ctl_itm_4_parent_vee(0, 1);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parse the DVHEADER inner objects\r\n  /// </summary>\r\n  /// <param name = \"foundTagName\">  name of tag, of object, which need be allocated</param>\r\n  /// <returns> is finished inner tag</returns>\r\n  private initHeaderInnerObjects(parser: XmlParser, foundTagName: String): boolean {\r\n    if (foundTagName === null)\r\n      return false;\r\n\r\n    if (foundTagName === XMLConstants.MG_TAG_DVHEADER) {\r\n      Logger.Instance.WriteDevToLog('dvheader found');\r\n      this.getHeaderAttributes(parser);\r\n      this._fieldsTab.fillData(parser, this);\r\n      (<FieldsTable>this._fieldsTab).setRMPos(this._rmSize, this._rmIdx);\r\n    } else if (foundTagName === ('/' + XMLConstants.MG_TAG_DVHEADER)) {\r\n      parser.setCurrIndex2EndOfTag();\r\n      return false;\r\n    } else return false;\r\n    return true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the attributes of the DVHEADER tag\r\n  /// </summary>\r\n  private getHeaderAttributes(parser: XmlParser): void {\r\n    let tokensVector: List<string>;\r\n    let tag: string;\r\n    let attribute: string;\r\n    let valueStr: string;\r\n\r\n    let endContext: number = parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex());\r\n    if (endContext !== -1 && endContext < parser.getXMLdata().length) {\r\n      // last position of its tag\r\n      tag = parser.getXMLsubstring(endContext);\r\n      parser.add2CurrIndex(tag.indexOf(XMLConstants.MG_TAG_DVHEADER) + XMLConstants.MG_TAG_DVHEADER.length);\r\n      tokensVector = 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        attribute = (tokensVector.get_Item(j));\r\n        valueStr = (tokensVector.get_Item(j + 1));\r\n\r\n        switch (attribute) {\r\n          case ConstInterface.MG_ATTR_RMPOS: {\r\n            let i: number = valueStr.indexOf(',');\r\n\r\n            if (i > -1) {\r\n              this._rmSize = NNumber.Parse(valueStr.substr(0, i));\r\n              this._rmIdx = NNumber.Parse(valueStr.substr(i + 1));\r\n            }\r\n            break;\r\n          }\r\n          case ConstInterface.MG_ATTR_COMPUTE_BY:\r\n            this._computeBy = valueStr[0];\r\n\r\n            if (this._computeBy === COMPUTE_FLUSH_UPDATES) {\r\n              this._computeBy = COMPUTE_NEWREC_ON_SERVER;\r\n              this._flushUpdates = true;\r\n            } else\r\n              this._flushUpdates = false;\r\n\r\n            break;\r\n          case ConstInterface.MG_ATTR_HAS_MAIN_TBL:\r\n            this._hasMainTable = XmlParser.getBoolean(valueStr);\r\n            break;\r\n          case ConstInterface.MG_ATTR_CHUNK_SIZE:\r\n            this._chunkSize = XmlParser.getInt(valueStr);\r\n            break;\r\n          case ConstInterface.MG_ATTR_CHUNK_SIZE_EXPRESSION:\r\n            break;\r\n          default:\r\n            Logger.Instance.WriteExceptionToLogWithMsg('Unknown attribute for <' + XMLConstants.MG_TAG_DVHEADER + '> tag: ' +\r\n              attribute); // to delete \">\" too\r\n            break;\r\n        }\r\n      }\r\n      parser.setCurrIndex(++endContext);\r\n      return;\r\n    }\r\n    Logger.Instance.WriteExceptionToLogWithMsg('in DataView.getHeaderAttributes(): out of bounds');\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parse the DATAVIEW tag\r\n  /// </summary>\r\n  async fillData(parser: XmlParser): Promise<void> {\r\n    this._skipParsing = false;\r\n    while (await this.initInnerObjects(parser, parser.getNextTag())) {\r\n    }\r\n    this.ResetFirstDv();\r\n  }\r\n\r\n  /// <summary>\r\n  /// get transaction begin of the task\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  private GetTransactionBegin(): string {\r\n    let transBegin: string = '\\0';\r\n    let transBeginProp: Property = this._task.getProp(PropInterface.PROP_TYPE_TRASACTION_BEGIN);\r\n    if (transBeginProp !== null) {\r\n      transBegin = (transBeginProp.GetComputedValue()).charAt(0);\r\n    }\r\n\r\n    return transBegin;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parse the DATAVIEW inner objects\r\n  /// </summary>\r\n  /// <param name = \"foundTagName\">  name of tag, of object, which need be allocated</param>\r\n  /// <returns> is finished inner tag</returns>\r\n  private async initInnerObjects(parser: XmlParser, foundTagName: string): Promise<boolean> {\r\n    let form: MgForm = <MgForm>this._task.getForm();\r\n\r\n    if (foundTagName == null)\r\n      return false;\r\n\r\n    if (foundTagName === (ConstInterface.MG_TAG_DATAVIEW)) {\r\n      let invalidate: boolean = await this.getAttributes(parser);\r\n\r\n      if (this._skipParsing) {\r\n        let endContext: number = parser.getXMLdata().indexOf(END_DV_TAG, parser.getCurrIndex());\r\n        parser.setCurrIndex(endContext + END_DV_TAG.length);\r\n      }\r\n      else {\r\n        // parse the exec stack entries values\r\n        this.fillExecStack(parser);\r\n\r\n        // parse the data controls values\r\n        this.fillDataDc(parser);\r\n        if (invalidate && form != null)\r\n           form.SetTableItemsCount(0, true);\r\n\r\n        let taskRefreshType: string = this._recordsTab.fillData(this, this._insertAt, parser);\r\n\r\n        if (form != null) {\r\n          // For the first time, as the table control is not yet created, no need to update the table item's count.\r\n          // Set the updated table items count only when form is already opened.\r\n          if (form.Opened) {\r\n            if (this._insertAt === 'B' && (invalidate || this._recordsTab.InsertedRecordsCount > 0))\r\n            {\r\n              if (invalidate || !(<MgForm>this._task.getForm()).isTableWithPagination()) {\r\n                form.SetTableItemsCount(0, true);\r\n                form.setTableItemsCount(false);\r\n              }\r\n              else\r\n                form.InsertTableItems(0, this._recordsTab.InsertedRecordsCount);\r\n            }\r\n            else\r\n              form.setTableItemsCount(false);\r\n          }\r\n        }\r\n        if (this.CurrRec != null && this.CurrRec.InRecompute && taskRefreshType === Constants.TASK_REFRESH_NONE)\r\n          taskRefreshType = Constants.TASK_REFRESH_CURR_REC;\r\n\r\n        if (invalidate) {\r\n          taskRefreshType = Constants.TASK_REFRESH_FORM;\r\n          if (this._task.IsSubForm)\r\n            this.getTask().DoSubformPrefixSuffix = true;\r\n        }\r\n\r\n        this.getTask().SetRefreshType(taskRefreshType);\r\n        this.UpdateDataviewAfterInsert();\r\n\r\n        /*\r\n             * the records table might set a new current record. It\r\n             * actually becomes the current record by calling setCurrRec()\r\n             */\r\n        let newRecId: number = this._recordsTab.getInitialCurrRecId();\r\n\r\n        if (newRecId !== Int32.MinValue && (this._recovery === ConstInterface.RECOVERY_NONE || this._firstDv)) {\r\n\r\n          // Make sure the client performs the first record prefix\r\n          if (this._firstDv && this._recovery === ConstInterface.RECOVERY_NONE &&\r\n            (this._task.getLevel().charCodeAt(0) === 0 || this._task.getLevel() === Constants.TASK_LEVEL_TASK))\r\n            this._task.setLevel(Constants.TASK_LEVEL_TASK);\r\n\r\n          // If the server sent us an updated currRec then invalidate all current values.\r\n          // this will force all new values to be copied from the currRec to the dataview,\r\n          // especially virtual fields with no init expression.\r\n          (<FieldsTable>this._fieldsTab).invalidate(true, Field.LEAVE_FLAGS);\r\n\r\n          if (newRecId !== this._currRecId) {\r\n            await this.setCurrRec(newRecId, !this._firstDv);\r\n            this._original = this.CurrRec.replicate();\r\n\r\n            // fix bug #779858: force compute for the first record in a screen mode _task\r\n            if (this._firstDv)\r\n              this.takeFldValsFromCurrRec();\r\n\r\n            // QCR #981320: make sure that virtuals with no init or control are initialized\r\n            if (this._task.getForm() != null)\r\n              (<MgForm>(this._task.getForm())).updateDisplayLineByDV();\r\n          }\r\n          else this.takeFldValsFromCurrRec();\r\n        }\r\n        else if (invalidate && this._recordsTab.getSize() > 0) {\r\n          if (form == null || form.isScreenMode()) {\r\n            try {\r\n              await this.setCurrRecByIdx(0, false, true, false, 0);\r\n            }\r\n            catch (exception) {\r\n              if (exception instanceof RecordOutOfDataViewException) {\r\n              }\r\n              else\r\n                throw exception;\r\n            }\r\n          }\r\n          else {\r\n\r\n            // QCR #431630: For forms in line mode there was a situation in which\r\n            // after invalidation, the current record was set to be the first of\r\n            // the dataview but the current line of the form was greater than 0.\r\n            // It caused saving an original record which is different than the\r\n            // original of the current form line. To solve this problem we first\r\n            // make sure that the cursor parks on the first row of the dataview.\r\n            (<FieldsTable>this._fieldsTab).invalidate(true, Field.LEAVE_FLAGS);\r\n            this.setTopRecIdx(0);\r\n\r\n            if (this._task.getForm() != null)\r\n              (<MgForm>this._task.getForm()).SetTableTopIndex();\r\n\r\n            try {\r\n              await this.setCurrRecByIdx(0, false, true, true, 0);\r\n              if (this._task.getForm() != null)\r\n              // to update tree we need to load nodes first\r\n                (<MgForm>(this._task.getForm())).updateDisplayLineByDV();\r\n            }\r\n            catch (exception) {\r\n              if (exception instanceof RecordOutOfDataViewException) {\r\n              }\r\n              else\r\n                throw exception;\r\n            }\r\n\r\n            if (this._task.getLevel() === Constants.TASK_LEVEL_CONTROL && this._task.getLastParkedCtrl() != null)\r\n              this._task.getLastParkedCtrl().resetPrevVal();\r\n          }\r\n          this.saveOriginal(); // After invalidation, we must save the original record too\r\n          (<FieldsTable>this._fieldsTab).invalidate(true, FieldBase.CLEAR_FLAGS);\r\n        }\r\n\r\n        // QCR #761848 prevCurrRec should set the first time the dataview is initialized\r\n        if (this._firstDv)\r\n          this.setPrevCurrRec();\r\n\r\n        // Make sure that the sub forms are not unnecessarily refreshed:\r\n        // After setting the current record and before executing record prefix\r\n        // we save the current record as the previous record so when the record prefix\r\n        // is executed it will skip refreshing the sub forms. We do that because\r\n        // the server already passes back to the client all the dataviews of the\r\n        // sub forms in a single iteration.\r\n        if (invalidate && this._task.IsSubForm)\r\n          (<MgControlBase>this._task.getForm().getSubFormCtrl()).RefreshOnVisible = false;\r\n\r\n        if (this._recovery === ConstInterface.RECOVERY_NONE) {\r\n          // No need to perform record prefix after a record level transaction retry\r\n          if (this.getTask().getAfterRetry(ConstInterface.RECOVERY_RETRY) &&\r\n            !this.getTask().IsAfterRetryBeforeBuildXML)\r\n            this._task.setLevel(Constants.TASK_LEVEL_RECORD);\r\n        }\r\n        else {\r\n          let transBegin = <string> this.GetTransactionBegin();\r\n\r\n          let stopExecution: boolean = true;\r\n\r\n          switch (this._recovery) {\r\n            case ConstInterface.RECOVERY_ROLLBACK:\r\n\r\n              if (transBegin === ConstInterface.TRANS_RECORD_PREFIX) {\r\n                // QCR #747316 can't rollback a lost record\r\n                // Also, in case of non interactive _task, skip to the next record.\r\n                if (this._task.getMode() === Constants.TASK_MODE_DELETE ||\r\n                  !this._task.IsInteractive)\r\n                  stopExecution = false;\r\n                else {\r\n                  this.getTask().setAfterRetry(ConstInterface.RECOVERY_ROLLBACK);\r\n                  this.CurrRec.restart(this.CurrRec.getMode());\r\n                  this.CurrRec.resetModified();\r\n                  this._original = this.CurrRec.replicate();\r\n                  this._pendingRecovery = RECOVERY_ACT_CANCEL;\r\n                }\r\n              }\r\n              else if (transBegin !== ConstInterface.TRANS_NONE) {\r\n                this._task.setLevel(Constants.TASK_LEVEL_TASK);\r\n                this._pendingRecovery = RECOVERY_ACT_BEGIN_TABLE;\r\n                this.getTask().setAfterRetry(ConstInterface.RECOVERY_ROLLBACK);\r\n                // ensure _task close action is stopped (taskEnd)\r\n              }\r\n              break;\r\n\r\n            case ConstInterface.RECOVERY_RETRY:\r\n              this.RecoveryRetry(transBegin);\r\n              break;\r\n          }\r\n          if (stopExecution) {\r\n            AccessHelper.eventsManager.setStopExecution(true);\r\n            // in case the task suffix was already executed, need to set this flag to false in order to enable it to execute TS again.\r\n            this.getTask().TaskSuffixExecuted = false;\r\n          }\r\n        }\r\n      }\r\n    }\r\n    else if (foundTagName === '/' + ConstInterface.MG_TAG_DATAVIEW) {\r\n      if (this._includesFirst && this._includesLast && this.isEmpty()) {\r\n        this._currRecId = Int32.MinValue;\r\n        this._currRecIdx = Int32.MinValue;\r\n        this.CurrRec = null;\r\n        this.setTopRecIdx(Int32.MinValue);\r\n      }\r\n      parser.setCurrIndex2EndOfTag();\r\n      return false;\r\n    }\r\n    else\r\n      return false;\r\n\r\n    return true;\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"transBegin\"></param>\r\n  private RecoveryRetry(transBegin: string): void {\r\n    if (transBegin === ConstInterface.TRANS_RECORD_PREFIX) {\r\n      // No need to re-perform record prefix during retry.\r\n      this._task.setLevel(Constants.TASK_LEVEL_RECORD);\r\n\r\n      // ensure that the record will be passed to the server after correction\r\n      this.getTask().setTransactionFailed(true);\r\n\r\n      // ensure record prefix is not executed for all tasks which participate in the transaction\r\n      this.getTask().setAfterRetry(ConstInterface.RECOVERY_RETRY);\r\n\r\n      // QCR #479686: no need to add the curr rec to the list anymore\r\n      // because the insert/modify may be canceled and a rollback event\r\n      // would be sent to the server\r\n      this.CurrRec.restart(this.CurrRec.getMode());\r\n\r\n      // An error when initializing the _task needs no movement (error in rec-prefix)\r\n      if (!this._firstDv) {\r\n        this.takeFldValsFromCurrRec();\r\n        this._pendingRecovery = RECOVERY_ACT_MOVE_DIRECTION_BEGIN;\r\n      }\r\n    }\r\n    else if (transBegin !== ConstInterface.TRANS_NONE) {\r\n      this._task.setLevel(Constants.TASK_LEVEL_TASK);\r\n      this._pendingRecovery = RECOVERY_ACT_BEGIN_SCREEN;\r\n      this.getTask().setAfterRetry(ConstInterface.RECOVERY_RETRY);\r\n      // ensure _task close action is stopped (taskEnd)\r\n      this.getTask().setTransactionFailed(true);\r\n    }\r\n  }\r\n\r\n\r\n\r\n  /// <summary>\r\n  /// update Dataview After insert\r\n  /// </summary>\r\n  private UpdateDataviewAfterInsert(): void {\r\n    if (this._insertAt === 'B'/*'B'*/) {\r\n\r\n      let newRecs: number = this._recordsTab.InsertedRecordsCount;\r\n      if (this._currRecIdx !== Int32.MinValue)\r\n        this._currRecIdx += newRecs;\r\n\r\n      if (this._topRecIdx !== Int32.MinValue)\r\n        this._topRecIdx += newRecs;\r\n\r\n      if (this._oldTopRecIdx !== Int32.MinValue)\r\n        this._oldTopRecIdx += newRecs;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the attributes of the DATAVIEW tag\r\n  /// </summary>\r\n  private async getAttributes(parser: XmlParser): Promise<boolean> {\r\n    let tokensVector: List<string>;\r\n    let tag: String;\r\n    let boolVal: boolean;\r\n    let dataViewCommand: IClientCommand = null;\r\n    let isEmptyDataview = false;\r\n\r\n    this._recovery = ConstInterface.RECOVERY_NONE;\r\n    let endContext: number = parser.getXMLdata().indexOf(XMLConstants.TAG_CLOSE, parser.getCurrIndex());\r\n    if (endContext !== -1 && endContext < parser.getXMLdata().length) {\r\n\r\n      // last position of its tag\r\n      tag = parser.getXMLsubstring(endContext);\r\n      parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_DATAVIEW) + ConstInterface.MG_TAG_DATAVIEW.length);\r\n      tokensVector = XmlParser.getTokens(parser.getXMLsubstring(endContext), XMLConstants.XML_ATTR_DELIM);\r\n\r\n      this._insertAt = ' ';\r\n      // find and execute invalidate immediately\r\n      let invalidate: boolean = this.peekInvalidate(tokensVector);\r\n\r\n\r\n\r\n      // locateFirstRec is sent by server only if records are located for the subform.\r\n      // So, it should be initialized to 0.\r\n      this._locateFirstRec = 0;\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        switch (attribute) {\r\n          case ConstInterface.MG_ATTR_INSERT_AT:\r\n            this._insertAt = valueStr[0];\r\n            break;\r\n          case ConstInterface.MG_ATTR_INCLUDE_FIRST:\r\n            boolVal = XmlParser.getBoolean(valueStr);\r\n            this.SetIncludesFirst(boolVal);\r\n            break;\r\n          case ConstInterface.MG_ATTR_INCLUDE_LAST:\r\n            boolVal = XmlParser.getBoolean(valueStr);\r\n            this.SetIncludesLast(boolVal);\r\n            break;\r\n          case ConstInterface.MG_ATTR_IS_ONEWAY_KEY:\r\n            boolVal = XmlParser.getBoolean(valueStr);\r\n            this.SetOneWayKey(boolVal);\r\n            break;\r\n          case ConstInterface.MG_ATTR_DBVIEWSIZE:\r\n            this.DBViewSize = XmlParser.getInt(valueStr);\r\n            break;\r\n          case ConstInterface.MG_ATTR_INVALIDATE: {\r\n\r\n          }\r\n            break;\r\n          case ConstInterface.MG_ATTR_TOP_REC_ID:\r\n            this._topRecId = NNumber.Parse(valueStr);\r\n            break;\r\n          case ConstInterface.MG_ATTR_TASKMODE:\r\n            if ((<TaskBase>this._task).getOriginalTaskMode() === Constants.TASK_MODE_NONE || invalidate)\r\n              (<TaskBase>this._task).setOriginalTaskMode(valueStr);\r\n            this._task.setProp(PropInterface.PROP_TYPE_TASK_MODE, valueStr);\r\n            break;\r\n          case ConstInterface.MG_ATTR_EMPTY_DATAVIEW:\r\n            isEmptyDataview = true;\r\n            break;\r\n          case XMLConstants.MG_ATTR_TASKID:\r\n            continue;\r\n          case ConstInterface.MG_ATTR_LOW_ID:\r\n            this._lastCreatedRecId = NNumber.Parse(valueStr);\r\n            break;\r\n          case ConstInterface.MG_ATTR_TRANS_STAT:\r\n            let transStat: string = valueStr[0];\r\n            switch (transStat) {\r\n              case TRANS_STAT_OPENED:\r\n                dataViewCommand = CommandFactory.CreateSetTransactionStateDataviewCommand(this.getTask().getTaskTag(), true);\r\n                await this.getTask().DataviewManager.RemoteDataviewManager.Execute(dataViewCommand);\r\n                break;\r\n              case TRANS_STAT_CLOSED:\r\n                dataViewCommand = CommandFactory.CreateSetTransactionStateDataviewCommand(this.getTask().getTaskTag(), false);\r\n                await this.getTask().DataviewManager.RemoteDataviewManager.Execute(dataViewCommand);\r\n                this.getTask().setTransactionFailed(false);\r\n                break;\r\n              default:\r\n                break;\r\n            }\r\n            break;\r\n          case ConstInterface.MG_ATTR_RECOVERY:\r\n            if ((<TaskBase>this._task).IsTryingToStop)\r\n              this.getTask().setTryingToStop(false);\r\n            this.getTask().resetExecEndTask();\r\n            this._recovery = valueStr[0];\r\n            break;\r\n          case ConstInterface.MG_ATTR_DVPOS_VALUE:\r\n            this._dvPosValue = NNumber.Parse(valueStr);\r\n            break;\r\n          case ConstInterface.MG_ATTR_LOCATE_FIRST_ID:\r\n            this._locateFirstRec = NNumber.Parse(valueStr);\r\n            break;\r\n          case ConstInterface.MG_ATTR_OFFSET:\r\n\r\n            break;\r\n          case ConstInterface.MG_ATTR_USER_SORT:\r\n            // QCR # 923380:Getting the value of userSort from the dataview header.If true then sort sign will be removed or else shown.\r\n            let form: MgForm = <MgForm>this._task.getForm();\r\n            form.clearTableColumnSortMark(XmlParser.getBoolean(valueStr));\r\n            break;\r\n          case ConstInterface.MG_ATTR_VAL_TOTAL_RECORDS_COUNT:\r\n            this.TotalRecordsCount = XmlParser.getInt(valueStr);\r\n            break;\r\n          case ConstInterface.MG_ATTR_VAL_RECORDS_BEFORE_CURRENT_VIEW:\r\n            this.RecordsBeforeCurrentView = XmlParser.getInt(valueStr);\r\n            break;\r\n\r\n          case ConstInterface.MG_ATTR_VAL_SERVER_TRANS_CACHE_EMPTY:\r\n            this._serverTransCacheEmpty = XmlParser.getBoolean(valueStr);\r\n            break;\r\n\r\n          default:\r\n            Logger.Instance.WriteExceptionToLogWithMsg('Unknown attribute for <' + ConstInterface.MG_TAG_DATAVIEW + '> tag: ' + attribute);\r\n            break;\r\n        }\r\n      }\r\n\r\n      this.setEmptyDataview(isEmptyDataview);\r\n\r\n      parser.setCurrIndex(++endContext);\r\n      return invalidate;\r\n    }\r\n    Logger.Instance.WriteExceptionToLogWithMsg('in DataView.getAttributes(): out of bounds');\r\n    return false;\r\n  }\r\n\r\n\r\n  SetOneWayKey(val: boolean): void {\r\n    this.IsOneWayKey = val;\r\n  }\r\n\r\n  SetIncludesLast(val: boolean): void {\r\n    this._includesLast = val;\r\n  }\r\n\r\n  SetIncludesFirst(val: boolean): void {\r\n    let prevIncludeFirst: boolean = this._includesFirst;\r\n    this._includesFirst = val;\r\n\r\n    if (this._includesFirst !== prevIncludeFirst) {\r\n      let form: MgFormBase = this._task.getForm();\r\n      if (form !== null) {\r\n         form.SetTableItemsCount(0, true);\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parse and fill inner data for all <dc_val> tags are contained into the <dataview>\r\n  /// </summary>\r\n  private fillDataDc(parser: XmlParser): void {\r\n\r\n    // Create a DC values builder.\r\n    let dcvBuilder: XMLBasedDcValuesBuilder = new XMLBasedDcValuesBuilder();\r\n\r\n    // Loop through all \"dc_vals\" tags.\r\n    let foundTagName: string = parser.getNextTag();\r\n\r\n    while (foundTagName !== null && foundTagName === ConstInterface.MG_TAG_DC_VALS) {\r\n\r\n      // Save current index for future reference, in case of an error.\r\n      let dcValsPosition: number = parser.getCurrIndex();\r\n\r\n      dcvBuilder.SerializedDCVals = parser.ReadToEndOfCurrentElement();\r\n      let dcv: DcValues = dcvBuilder.Build();\r\n\r\n      if (dcv !== null)\r\n        this.AddDcValues(dcv);\r\n      else\r\n        Logger.Instance.WriteExceptionToLogWithMsg('Error while parsing DC values at position ' + dcValsPosition);\r\n\r\n      foundTagName = parser.getNextTag();\r\n    }\r\n  }\r\n\r\n  AddDcValues(dcv: DcValues): void {\r\n    this._dcValsCollection.Add(dcv.getId().toString(), dcv);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   parse and fill inner data for all <execstackentry> tags are contained into the <dataview>\r\n  /// </summary>\r\n  private fillExecStack(parser: XmlParser): void {\r\n    let foundTagName: string = parser.getNextTag();\r\n    let execStackTagExists: boolean = false;\r\n\r\n    while (foundTagName !== null && foundTagName === ConstInterface.MG_TAG_EXEC_STACK_ENTRY) {\r\n      this.fillInnerExecStack(parser);\r\n      foundTagName = parser.getNextTag();\r\n      execStackTagExists = true;\r\n    }\r\n    if (execStackTagExists) {\r\n      AccessHelper.eventsManager.reverseServerExecStack();\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   fill inner objects of <execstackentry> tag\r\n  /// </summary>\r\n  private fillInnerExecStack(parser: XmlParser): void {\r\n    let tokensVector: List<string>;\r\n    const endContext: number = parser.getXMLdata().indexOf(XMLConstants.TAG_TERM, parser.getCurrIndex());\r\n    let attribute: string;\r\n    let taskId: string = '';\r\n    let handlerId: string = '';\r\n    let operIdx: number = 0;\r\n\r\n    if (endContext !== -1 && endContext < parser.getXMLdata().length) {\r\n      // last position of its tag\r\n      let tag: string = parser.getXMLsubstring(endContext);\r\n      parser.add2CurrIndex(tag.indexOf(ConstInterface.MG_TAG_EXEC_STACK_ENTRY) + ConstInterface.MG_TAG_EXEC_STACK_ENTRY.length);\r\n\r\n      tokensVector = 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        attribute = (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_TASKID:\r\n            taskId = valueStr;\r\n            break;\r\n          case ConstInterface.MG_ATTR_HANDLERID:\r\n            handlerId = valueStr;\r\n            break;\r\n          case ConstInterface.MG_ATTR_OPER_IDX:\r\n            operIdx = XmlParser.getInt(valueStr);\r\n            break;\r\n        }\r\n      }\r\n      AccessHelper.eventsManager.pushServerExecStack(taskId, handlerId, operIdx);\r\n      parser.setCurrIndex(endContext + XMLConstants.TAG_TERM.length);\r\n    }\r\n    else\r\n      Logger.Instance.WriteExceptionToLogWithMsg('in DataView.fillInnerExecStack() out of bounds');\r\n  }\r\n\r\n  /// <summary>\r\n  ///   search for the invalidate attribute and if it is true then it also clears the dataview\r\n  ///   execute this method BEFORE parsing the records\r\n  /// </summary>\r\n  /// <param name = \"tokensVector\">of all attributes and values</param>\r\n  private peekInvalidate(tokensVector: List<string>): boolean {\r\n    let sessionCounter: number = CommandsProcessorManager.GetCommandsProcessor().GetSessionCounter();\r\n\r\n    for (let j: number = 0; j < tokensVector.length; j += 2) {\r\n      let attribute = tokensVector.get_Item(j);\r\n      if (attribute === (ConstInterface.MG_ATTR_INVALIDATE)) {\r\n        let valueStr = tokensVector.get_Item(j + 1);\r\n\r\n        if (XmlParser.getBoolean(valueStr)) {\r\n\r\n          // QCR #2863: When executing RECURSIVE calls to the server there were cases\r\n          // in which an older dataview superseds a new one because its parsing comes\r\n          // after the parsing of the new dataview. The solution is to skip the\r\n          // parsing of the older dataview if the newer dataview has invalidate=true\r\n          if (sessionCounter < this._lastSessionCounter)\r\n            this._skipParsing = true;\r\n          else {\r\n            this._lastSessionCounter = sessionCounter;\r\n            this.clear();\r\n            return true;\r\n          }\r\n        }\r\n        return false;\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get a field by its name\r\n  /// </summary>\r\n  /// <param name = \"fldName\">of the field </param>\r\n  /// <returns> required field (or null if not found) </returns>\r\n  getFieldByName(fldName: string): Field {\r\n\r\n    if (this._fieldsTab !== null)\r\n      return <Field>this._fieldsTab.getField(fldName);\r\n\r\n    Logger.Instance.WriteExceptionToLogWithMsg('in DataView.getField(String): There is no fieldsTab object');\r\n    return null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   build the XML string for the dataview\r\n  /// </summary>\r\n  /// <param name = \"message\">the message buffer\r\n  /// </param>\r\n  public async buildXML(message: StringBuilder): Promise<void> {\r\n    let dcv: DcValues;\r\n    let taskTag: String = this._task.getTaskTag();\r\n    let brkLevelIndex: number = this._task.getBrkLevelIndex();\r\n    let currRecDeleted: boolean = false;\r\n    let serverParent: String;\r\n\r\n    let contextTask: TaskBase = <TaskBase>(this.getTask().GetContextTask());\r\n    let invokingTaskTag: string = contextTask.IsOffline ? INVOKED_FROM_OFFLINE_TASK : contextTask.getTaskTag();\r\n\r\n    // put the dataview tag even if there are no modified records just to let\r\n    // the server know the current record\r\n    message.Append('\\n      <' + ConstInterface.MG_TAG_DATAVIEW + ' ' + XMLConstants.MG_ATTR_TASKID + '=\"' +\r\n      taskTag + '\"');\r\n\r\n    // QCR 423064 puts the current executing handler index\r\n    message.Append(' ' + ConstInterface.MG_ATTR_TASKLEVEL + '=\"' + brkLevelIndex + '\"');\r\n\r\n    // If the trigger task is an Offline program, the parent on the server should be\r\n    // the Main Program of the current CTL.\r\n    serverParent = '0';\r\n    let triggeringTask: TaskBase = this.getTask().getTriggeringTask();\r\n    if (triggeringTask != null) {\r\n      if (triggeringTask.IsOffline) {\r\n        let ctlIdx: number = triggeringTask.getCtlIdx();\r\n        let mainPrg: TaskBase = <TaskBase> AccessHelper.mgDataTable.GetMainProgByCtlIdx(-1, ctlIdx);\r\n        serverParent = mainPrg.getTaskTag();\r\n      }\r\n      else\r\n        serverParent = triggeringTask.getTaskTag();\r\n    }\r\n\r\n    if (this._currRecId > Int32.MinValue) {\r\n      if (this.CurrRec != null)\r\n        message.Append(' ' + ConstInterface.MG_ATTR_CURR_REC + '=\"' + this._currRecId + '\"');\r\n      message.Append(' ' + ConstInterface.MG_ATTR_TASKMODE + '=\"' + this._task.getMode() + '\"');\r\n\r\n      if (this._transCleared && !(MGDataCollection.Instance.StartupMgData.getFirstTask().InEndTask && MGDataCollection.Instance.StartupMgData.getFirstTask().ClosingFormUI)) {\r\n        message.Append(' ' + ConstInterface.MG_ATTR_TRANS_CLEARED + '=\"1\"');\r\n        this._transCleared = false;\r\n      }\r\n\r\n      // QCR 779982 puts the invoking _task id and the direct parent _task id\r\n      message.Append(' ' + ConstInterface.MG_ATTR_INVOKER_ID + '=\"' + invokingTaskTag + ',' + serverParent + '\"');\r\n\r\n// put the current ((DataView)dataView) dvPos value\r\n      if (await this.getTask().isCached())\r\n        message.Append(' ' + ConstInterface.MG_ATTR_DVPOS_VALUE + '=\"' + this._dvPosValue + '\"');\r\n\r\n      message.Append(' ' + ConstInterface.MG_ATTR_LOOP_COUNTER + '=\"' + this.getTask().getLoopCounter() + '\"');\r\n\r\n      // send subform visibility only if the subform with property \"RefreshWhenHidden=N\" and it is not visible,\r\n      // i.e. not needed refresh from the server\r\n      if (this._task.IsSubForm) {\r\n        let subformCtrl: MgControl = <MgControl>this._task.getForm().getSubFormCtrl();\r\n        if (!subformCtrl.isVisible() &&\r\n          ! await subformCtrl.checkProp(PropInterface.PROP_TYPE_REFRESH_WHEN_HIDDEN, false))\r\n          message.Append(' ' + ConstInterface.MG_ATTR_SUBFORM_VISIBLE + '=\"0\"');\r\n      }\r\n\r\n      if (!this._task.IsInteractive)\r\n        message.Append(' ' + ConstInterface.MG_ATTR_TASK_COUNTER + '=\"' + this.getTask().getCounter() + '\"');\r\n\r\n      // QCR#591973: lastRecid and oldFirstRecID should be sent by client.\r\n      // In case of mouse scrolling, we park on the same record (don't leave the current record). So on server we get curr record on which\r\n      // we were parked before scrolling. So we can not use this index to fetch the record.\r\n      // In this case, we need to send the last fetched record's idx from client in case of scroll down\r\n      // and oldFirstRecID (first record of last sent chunk) in case of scroll up, from which we need to fetch the chunk of records.\r\n      if (this._task != null &&  this._task.GetComputedProperty(PropInterface.PROP_TYPE_PRELOAD_VIEW).GetComputedValueBoolean()) {\r\n        message.Append(' ' + ConstInterface.MG_ATTR_LAST_REC_ID + '=\"' +\r\n          (this._recordsTab.getRecByIdx(this.getSize() - 1).getId()) + '\"');\r\n        message.Append(' ' + ConstInterface.MG_ATTR_OLD_FIRST_REC_ID + '=\"' +\r\n          this._recordsTab.getRecByIdx(0).getId() + '\"');\r\n      }\r\n\r\n\r\n      // send the current position of the current rec in the forms table.\r\n      // it can be used by the server to keep the record in this position after the view refresh.\r\n      if (this._task.IsInteractive) {\r\n        let form: MgForm = <MgForm>this._task.getForm();\r\n        if (form != null && this._recordsTab.getSize() > 1) {\r\n          message.Append(' ' + ConstInterface.MG_ATTR_CURR_REC_POS_IN_FORM + '=\"' +\r\n            form.getCurrRecPosInForm() + '\"');\r\n        }\r\n      }\r\n      message.Append(XMLConstants.TAG_CLOSE);\r\n\r\n      // Add User Ranges\r\n      if (this.getTask().ResetRange || this.getTask().UserRngs != null) {\r\n        message.Append(XMLConstants.START_TAG + ConstInterface.USER_RANGES);\r\n        if (this.getTask().ResetRange) {\r\n          message.Append(' ' + ConstInterface.CLEAR_RANGE + '=\"1\"');\r\n          this.getTask().ResetRange = false;\r\n        }\r\n        if (this.getTask().UserRngs != null) {\r\n          this.getTask().buildXMLForRngs(message, this.getTask().UserRngs, false);\r\n          this.getTask().UserRngs.Clear();\r\n          this.getTask().UserRngs = null;\r\n        }\r\n        else message.Append(XMLConstants.TAG_TERM);\r\n      }\r\n\r\n      // Add User Locates\r\n      if (this.getTask().ResetLocate || this.getTask().UserLocs != null) {\r\n        message.Append(XMLConstants.START_TAG + ConstInterface.USER_LOCATES);\r\n        if (this.getTask().ResetLocate) {\r\n          message.Append(' ' + ConstInterface.CLEAR_LOCATES + '=\"1\"');\r\n          this.getTask().ResetLocate = false;\r\n        }\r\n        if (this.getTask().UserLocs != null) {\r\n          this.getTask().buildXMLForRngs(message, this.getTask().UserLocs, true);\r\n          this.getTask().UserLocs.Clear();\r\n          this.getTask().UserLocs = null;\r\n        }\r\n        else message.Append(XMLConstants.TAG_TERM);\r\n      }\r\n\r\n\r\n      // Add User Sorts\r\n      if (this.getTask().ResetSort || this.getTask().UserSorts != null) {\r\n        message.Append(XMLConstants.START_TAG + ConstInterface.MG_TAG_SORTS);\r\n        if (this.getTask().ResetSort) {\r\n          message.Append(' ' + ConstInterface.CLEAR_SORTS + '=\"1\"');\r\n          this.getTask().ResetSort = false;\r\n        }\r\n        if (this.getTask().UserSorts != null)\r\n          this.getTask().buildXMLForSorts(message);\r\n        else\r\n          message.Append(XMLConstants.TAG_TERM);\r\n      }\r\n\r\n      // send deleted cache entries\r\n      if (await this.getTask().isCached()) {\r\n        let delList: String = this.getTask().getTaskCache().getDeletedListToXML();\r\n        if (delList !== '') {\r\n          message.Append(XMLConstants.START_TAG + ConstInterface.MG_TAG_DEL_LIST);\r\n          message.Append(' ' + XMLConstants.MG_ATTR_ID + '=\"' + this._task.getTaskTag() + '\"');\r\n          message.Append(' ' + ConstInterface.MG_ATTR_REMOVE + '=\"' + delList + '\"');\r\n          message.Append(XMLConstants.TAG_TERM);\r\n\r\n          // if the current active dataview is in the deltede list mark it as un-valid so\r\n          // it wont enter the cache on return from server\r\n          if (this.getTask().getTaskCache().isDeleted(this._dvPosValue))\r\n            this.setChanged(true);\r\n          this.getTask().getTaskCache().clearDeletedList();\r\n        }\r\n      }\r\n\r\n      // remove unnecessary data control values\r\n      let dcValKeys: string[] = this._dcValsCollection.Keys;\r\n\r\n      dcValKeys.forEach((dcValKey: string) => {\r\n        dcv = this._dcValsCollection.get_Item(dcValKey);\r\n\r\n        if (!dcv.HasReferences) {\r\n          message.Append(XMLConstants.START_TAG + ConstInterface.MG_TAG_DC_VALS);\r\n          message.Append(' ' + XMLConstants.MG_ATTR_ID + '=\"' + dcv.getId() + '\"');\r\n          message.Append(' ' + ConstInterface.MG_ATTR_REMOVE + '=\"1\"');\r\n          message.Append(XMLConstants.TAG_TERM);\r\n\r\n          this._dcValsCollection.Remove(dcValKey);\r\n        }\r\n      });\r\n\r\n      if (this.CurrRec != null)\r\n        currRecDeleted = (this.CurrRec.getMode() === DataModificationTypes.Delete\r\n          && this._modifiedRecordsTab.getRecord(this.CurrRec.getId()) != null && this.CurrRec.SendToServer);\r\n\r\n      // If the current user event being handled has Force exit = 'Pre Record Update', then\r\n      // do not add current record to the modified records list. We anyway send current\r\n      // record separately.\r\n      let skipCurrRec: boolean = false;\r\n\r\n      if (this.CurrRec != null && this._modifiedRecordsTab.getRecord(this.CurrRec.getId()) != null)\r\n        skipCurrRec = AccessHelper.eventsManager.isForceExitPreRecordUpdate(this.getTask());\r\n\r\n      this._modifiedRecordsTab.buildXML( message, skipCurrRec, this.CurrRec.getId());\r\n\r\n      if (this._original != null)\r\n        this._original.clearMode();\r\n\r\n      for (let i: number = this._modifiedRecordsTab.getSize() - 1; i >= 0; i--) {\r\n        if (skipCurrRec && this._modifiedRecordsTab.getRecByIdx(i).getId() === this.CurrRec.getId())\r\n          continue;\r\n\r\n        this._modifiedRecordsTab.getRecByIdx(i).clearFlagsHistory();\r\n        this._modifiedRecordsTab.removeRecord(i);\r\n      }\r\n\r\n      if (this.CurrRec != null && !currRecDeleted) {\r\n\r\n        // When we reconnect to the server once it is disconnected, server will create a new context and\r\n        // therefore MP variables are with their intial (empty) value and not with their real values.\r\n        // So, we must always send Main program's field's latest  values to the server.\r\n        let forceBuild: boolean = (this._task.isMainProg() && (RemoteCommandsProcessor.IsSessionReInitializing));\r\n        this.CurrRec.buildXML(message, true, forceBuild);\r\n      }\r\n    }\r\n\r\n    // QCR 779982 if we have main prog with no select's send the invoker and parent _task\r\n    else {\r\n      message.Append(' ' + ConstInterface.MG_ATTR_INVOKER_ID + '=\"' + invokingTaskTag + ',' + serverParent + '\"' +\r\n        XMLConstants.TAG_CLOSE);\r\n    }\r\n    message.Append('\\n      </' + ConstInterface.MG_TAG_DATAVIEW + XMLConstants.TAG_CLOSE);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get a reference to the current record\r\n  /// </summary>\r\n  /// <returns> Record is the reference to the current record </returns>\r\n  getCurrRec(): Record {\r\n    if (this.CurrRec === null && this._currRecId > Int32.MinValue) {\r\n        Logger.Instance.WriteExceptionToLogWithMsg('DataView.getCurrRec(): record ' + this._currRecId + ' not found');\r\n    }\r\n    return this.CurrRec;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get a reference to the previous current record\r\n  /// </summary>\r\n  /// <returns> Record is the reference to the previous current record </returns>\r\n  getPrevCurrRec(): Record {\r\n    return this._prevCurrRec;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get a reference to the original record\r\n  /// </summary>\r\n  /// <returns> Record is the reference to the original record\r\n  /// </returns>\r\n  getOriginalRec(): Record {\r\n\r\n    if (this._original === null || this._original.getId() !== this.CurrRec.getId())\r\n      return this.CurrRec;\r\n    return this._original;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the current record - returns true on success\r\n  /// </summary>\r\n  /// <param name = \"id\">the record id\r\n  /// </param>\r\n  /// <param name = \"compute\">if true then execute compute for the new record\r\n  /// </param>\r\n  async setCurrRec(id: number, compute: boolean): Promise<boolean> {\r\n    let oldRecId: number = this._currRecId;\r\n    if (id > Int32.MinValue) {\r\n      let newIdx: number = this._recordsTab.getRecIdx(id);\r\n\r\n      if (newIdx === -1)\r\n        this._original = null;\r\n      else {\r\n        try {\r\n          let ignoreCurrRec: boolean = this._currRecId === Int32.MinValue;\r\n          await this.setCurrRecByIdx(newIdx, !ignoreCurrRec, ignoreCurrRec, compute, Int32.MinValue);\r\n          if (id !== oldRecId)\r\n            this.saveOriginal();\r\n          return true;\r\n        }\r\n        catch (exception) {\r\n          if (exception instanceof RecordOutOfDataViewException) {\r\n          }\r\n          else\r\n            throw exception;\r\n        }\r\n      }\r\n    }\r\n    else {\r\n      // do not point to any current record\r\n      this.CurrRec = null;\r\n      this._original = null;\r\n      this._currRecId = Int32.MinValue;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Set the current record index and returns true for success\r\n  ///   Use the MG_DATAVIEW_FIRST_RECORD and MG_DATAVIEW_LAST_RECORD constants\r\n  ///   to retrieve the first or the last record respectively\r\n  /// </summary>\r\n  /// <param name = \"newIdx\">the new index </param>\r\n  /// <param name = \"doSuffix\">if true then do the record suffix for the previous record when the record was changed </param>\r\n  /// <param name = \"ignoreCurrRec\">if true all the operations are done is if there is no current record </param>\r\n  /// <param name = \"compute\">if true then execute compute for the new record </param>\r\n  /// <param name = \"newDisplayLine\">to update form </param>\r\n  async setCurrRecByIdx(newIdx: number, doSuffix: boolean, ignoreCurrRec: boolean, compute: boolean, newDisplayLine: number): Promise<void> {\r\n    let lastRecIdx: number = this._recordsTab.getSize() - 1;\r\n    let oldFirstRec: Record, nextRec: Record;\r\n\r\n    // QCR #984960: the variable recordSuff is used to recognize if we have pressed\r\n    // ctrl+home or ctrl+end in these cases we must initiate record suffix\r\n    // the correct way to do this is using the doSuffix parameter but since it is used\r\n    // in a lot of cases sometime not in a correct way, forcing record suffix\r\n    // using doSuffix will cause many changes in the code.\r\n    let recordSuff: boolean = false;\r\n\r\n    if (newIdx === Constants.MG_DATAVIEW_FIRST_RECORD) {\r\n\r\n      // As moving to first record in the view, recordsBeforeCurrentView should be 0.\r\n      if (this.getTask().isTableWithAbsolutesScrollbar()) {\r\n        this.RecordsBeforeCurrentView = 0;\r\n      }\r\n\r\n      if (this._includesFirst) {\r\n        // check if the current record is already the first record of the data view\r\n        if (this._currRecIdx >= 0 || this._currRecIdx === Int32.MinValue) {\r\n          newIdx = 0;\r\n\r\n          // ctrl+home wase pressed\r\n          recordSuff = true;\r\n        }\r\n        else\r\n          throw new RecordOutOfDataViewException(RecordOutOfDataViewException_ExceptionType.TOP);\r\n      }\r\n      else {\r\n        await this.fetchChunkFromServer(CHUNK_DV_TOP, doSuffix);\r\n        await this.setCurrRecByIdx(newIdx, false, ignoreCurrRec, compute, SET_DISPLAYLINE_BY_DV);\r\n        return;\r\n      }\r\n    }\r\n    else if (newIdx === Constants.MG_DATAVIEW_LAST_RECORD) {\r\n      if (this._includesLast) {\r\n        // check if the current record is already the last record of the data view\r\n        if (this._currRecIdx <= lastRecIdx) {\r\n          newIdx = lastRecIdx;\r\n          // ctrl+end was pressed\r\n          recordSuff = true;\r\n        }\r\n        else throw new RecordOutOfDataViewException(RecordOutOfDataViewException_ExceptionType.BOTTOM);\r\n      }\r\n      else {\r\n        // If last record is not in the view, and being fetched from the server, RecordsBeforeCurrentView = TotalRecordsCount. And as this chunk get added\r\n        // into records table, the RecordsBeforeCurrentView will be decremented by no of rows in view.\r\n        // This is because, we open the cursor with reverse direction for which do not bring the counts from gateway.\r\n        if (this.getTask().isTableWithAbsolutesScrollbar())\r\n          this.RecordsBeforeCurrentView = this.TotalRecordsCount;\r\n\r\n        await this.fetchChunkFromServer(CHUNK_DV_BOTTOM, doSuffix);\r\n\r\n        if (!this._includesLast)\r\n          throw new RecordOutOfDataViewException(RecordOutOfDataViewException_ExceptionType.BOTTOM);\r\n\r\n        //Fetching previous chunk is useful for a paginated table only.For non-paginated (HTMl) tables, it fetches\r\n        //one extra chunk. This behavior popped up when using chunksize as default pagesize. So, avoid fetching previous\r\n        //chunk when explicitly needed last chunk only i.e. MG_DATAVIEW_LAST_RECORD case.\r\n        if (this.getTask().isTableWithAbsolutesScrollbar()){\r\n          let form: MgForm = <MgForm>this._task.getForm();\r\n          \r\n          if (form != null) {\r\n            while (!this._includesFirst && form.getRowsInPage() >= this.getSize()) {\r\n              await this.fetchChunkFromServer(CHUNK_CACHE_PREV, false);\r\n            }\r\n          }\r\n        }\r\n        await this.setCurrRecByIdx(newIdx, false, ignoreCurrRec, compute, SET_DISPLAYLINE_BY_DV);\r\n        return;\r\n      }\r\n    }\r\n    // check whether the record was not found beyond the TOP end\r\n    else if (newIdx < 0) {\r\n      if (this._includesFirst)\r\n        throw new RecordOutOfDataViewException(RecordOutOfDataViewException_ExceptionType.TOP);\r\n\r\n      oldFirstRec = this._recordsTab.getRecByIdx(0);\r\n\r\n      if (this._recordsTab.getSize() > 0 || this.IncludesLast())\r\n        await this.fetchChunkFromServer(CHUNK_CACHE_PREV, doSuffix);\r\n      // if no records and its first simulate start table\r\n      else if (this._recordsTab.getSize() === 0 && this.IncludesFirst())\r\n        await this.fetchChunkFromServer(CHUNK_DV_TOP, doSuffix);\r\n      else\r\n        Logger.Instance.WriteExceptionToLogWithMsg('in DataView.fetchChunkFromServer() wrong option');\r\n\r\n      // get the new index of the record which was first before the fetch\r\n      let oldFirstNewIdx: number = oldFirstRec != null\r\n        ? this._recordsTab.getRecIdx(oldFirstRec.getId())\r\n        : this._recordsTab.getSize();\r\n      if (oldFirstNewIdx !== 0)\r\n        await this.setCurrRecByIdx(oldFirstNewIdx + newIdx, false, ignoreCurrRec, compute, SET_DISPLAYLINE_BY_DV);\r\n      return;\r\n    }\r\n    // check whether the record was not found beyond the BOTTOM end\r\n    else if (newIdx > lastRecIdx) {\r\n      if (this._includesLast)\r\n        throw new RecordOutOfDataViewException(RecordOutOfDataViewException_ExceptionType.BOTTOM);\r\n      //the row is actually not created yet in UI, it will be created only after we bring the new chunk\r\n      if (this.getForm().isRowCreated(newIdx))\r\n        this.getForm().markRowNOTCreated(newIdx);\r\n\r\n      await this.fetchChunkFromServer(CHUNK_CACHE_NEXT, doSuffix);\r\n      await this.setCurrRecByIdx(newIdx, false, ignoreCurrRec, compute, SET_DISPLAYLINE_BY_DV);\r\n      return;\r\n    }\r\n\r\n    let  isCreateLineAboveAct : boolean = false;\r\n    let lastEvent : number = isNullOrUndefined(AccessHelper.eventsManager.getLastRtEvent()) ? 0 :\r\n      AccessHelper.eventsManager.getLastRtEvent().getInternalCode();\r\n\r\n    if (newIdx >= 0 && !this.getTask().transactionFailed(ConstInterface.TRANS_RECORD_PREFIX) &&\r\n    lastEvent === InternalInterface.MG_ACT_CRELINE_ABOVE) {\r\n      if (((<Task>this.getTask()).getInCreateLine()) && newIdx == this._currRecIdx) {\r\n        let newRec: Record = this._recordsTab.getRecByIdx(newIdx);\r\n        if (newRec.getMode() == DataModificationTypes.Insert)\r\n          isCreateLineAboveAct = true;\r\n      }\r\n    }\r\n\r\n    // QCR # 984960 - see documentation for the variable recordSuff in the top of this method\r\n    if (recordSuff || isCreateLineAboveAct || newIdx !== this._currRecIdx || ignoreCurrRec && compute) {\r\n      if (!ignoreCurrRec && doSuffix && this.CurrRec != null) {\r\n        let oldRecTabSize: number = this._recordsTab.getSize();\r\n\r\n        nextRec = this._recordsTab.getRecByIdx(newIdx);\r\n        if (nextRec.isNewRec()) {\r\n          if (this._task.getMode() !== Constants.TASK_MODE_CREATE &&\r\n            !await this._task.checkProp(PropInterface.PROP_TYPE_ALLOW_CREATE, true))\r\n            AccessHelper.eventsManager.setStopExecution(true);\r\n        }\r\n\r\n        if (!AccessHelper.eventsManager.GetStopExecutionFlag()) {\r\n          let orgTopRecIdx: number = 0;\r\n          if (this._topRecIdxModified) {\r\n            orgTopRecIdx = this.getTopRecIdx();\r\n            this.restoreTopRecIdx();\r\n          }\r\n          await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_REC_SUFFIX);\r\n          if (this._topRecIdxModified)\r\n            this.setTopRecIdx(orgTopRecIdx);\r\n        }\r\n        if (AccessHelper.eventsManager.GetStopExecutionFlag())\r\n          throw new RecordOutOfDataViewException(RecordOutOfDataViewException_ExceptionType.REC_SUFFIX_FAILED);\r\n\r\n        // QCR #2046: when the next record is different than the current one we should\r\n        // allow the execution of the record prefix by setting the _task level to TASK.\r\n        if (nextRec !== this.CurrRec && this.getTask().getAfterRetry())\r\n          this._task.setLevel(Constants.TASK_LEVEL_TASK);\r\n\r\n        // if the records table size was decreased during handling the\r\n        // record suffix (e.g. cancel edit) and the user tries to move to\r\n        // a record with a higher index then we should also decrease the\r\n        // newIdx to reflect the change\r\n        if (oldRecTabSize - 1 === this._recordsTab.getSize() && this._currRecIdx < newIdx)\r\n          newIdx--;\r\n\r\n        // the new curr rec may be already set by the events chain triggered by the\r\n        // record suffix above - in that case there is no need to continue\r\n        if (newIdx === this._currRecIdx) {\r\n\r\n          // QCR 918983 changes to the _task mode must be done before recompute\r\n          if (this._task.getMode() === Constants.TASK_MODE_CREATE && !this.CurrRec.isNewRec() &&\r\n            !this._task.getForm().inRefreshDisplay())\r\n            this._task.setMode(Constants.TASK_MODE_MODIFY);\r\n          return;\r\n        }\r\n      }\r\n      this.CurrRec = this._recordsTab.getRecByIdx(newIdx);\r\n\r\n      if (this.CurrRec == null)\r\n        throw new ApplicationException('in DataView.setCurrRecByIdx() current record not found!');\r\n\r\n      this._currRecId = this.CurrRec.getId();\r\n      this._currRecIdx = newIdx;\r\n\r\n      if (this._task.getForm() != null) {\r\n\r\n        // QCR #107926, we must update display line here, since currRecCompute which is activated later\r\n        // may go to server and cause refresh display.\r\n        // In case of adding new node to the tree, the node must be actually added to the tree.\r\n        if (newDisplayLine === SET_DISPLAYLINE_BY_DV) {\r\n          (<MgForm>(this._task.getForm())).updateDisplayLineByDV();\r\n        }\r\n        else\r\n          this._task.getForm().DisplayLine = newDisplayLine;\r\n      }\r\n      // QCR 918983 changes to the _task mode must be done before recompute\r\n      if (this._task.getMode() === Constants.TASK_MODE_CREATE && !this.CurrRec.isNewRec() &&\r\n        !this._task.getForm().inRefreshDisplay())\r\n        this._task.setMode(Constants.TASK_MODE_MODIFY);\r\n\r\n      if (compute)\r\n        await this.currRecCompute(false);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   recompute ALL the init expressions of the current record - call this method when\r\n  ///   entering a record\r\n  /// </summary>\r\n  /// <param name = \"forceClientCompute\">if TRUE forces the client to compute the record even if it is flagged\r\n  ///   as \"server computed\".\r\n  /// </param>\r\n  async currRecCompute(forceClientCompute: boolean): Promise<void> {\r\n    (<FieldsTable>this._fieldsTab).invalidate(false, true);\r\n    await this.compute(false, forceClientCompute);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   saves a replication of the current record\r\n  /// </summary>\r\n  saveOriginal(): void {\r\n    if (!this.CurrRec.Modified)\r\n      this._original = this.CurrRec.replicate();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   fetch a chunk of records from the server\r\n  /// </summary>\r\n\r\n  public async fetchChunkFromServer(chunkId: string, doSuffix: boolean): Promise<void> {\r\n\r\n    // QCR #430134: if the server sent us records fewer than the number that fits into a table\r\n    // then we go back to the server and must refresh the screen.\r\n    (<MgForm>this._task.getForm()).FormRefreshed = true;\r\n\r\n    if (doSuffix && this.CurrRec != null) {\r\n      await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_REC_SUFFIX);\r\n      if (AccessHelper.eventsManager.GetStopExecutionFlag() || this._task.isAborting())\r\n        throw new RecordOutOfDataViewException(RecordOutOfDataViewException_ExceptionType.REC_SUFFIX_FAILED);\r\n      (<MgForm>this._task.getForm()).setSuffixDone(); // QCR 758639\r\n    }\r\n\r\n    let eventCode: number;\r\n    let clientRecId: number = this._currRecId;\r\n    switch (chunkId) {\r\n      case CHUNK_DV_TOP:\r\n        eventCode = InternalInterface.MG_ACT_DATAVIEW_TOP;\r\n        break;\r\n      case CHUNK_DV_BOTTOM:\r\n        eventCode = InternalInterface.MG_ACT_DATAVIEW_BOTTOM;\r\n        break;\r\n      case CHUNK_CACHE_PREV:\r\n        clientRecId = this.FirstRecord == null ? 0 : this.FirstRecord.getId();\r\n        eventCode = InternalInterface.MG_ACT_CACHE_PREV;\r\n        break;\r\n      case CHUNK_CACHE_NEXT:\r\n        eventCode = InternalInterface.MG_ACT_CACHE_NEXT;\r\n        clientRecId = this.LastRecord == null ? 0 : this.LastRecord.getId();\r\n        break;\r\n      default:\r\n        Logger.Instance.WriteExceptionToLogWithMsg('in DataView.fetchChunkFromServer() unknown chunk id: ' + chunkId);\r\n        return;\r\n    }\r\n    let cmd: EventCommand = CommandFactory.CreateEventCommand(this._task.getTaskTag(), eventCode);\r\n    cmd.ClientRecId = clientRecId;\r\n    await this.getTask().DataviewManager.Execute(cmd);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   Fetches the chunk from server,\r\n  ///   If the last records is not yet fetched it fetches the next chunk,\r\n  ///   Else, fetches the previous chunk\r\n  /// </summary>\r\n  async FetchRecordsAheadFromServer(): Promise<void> {\r\n    if (!this._includesLast)\r\n      await this.fetchChunkFromServer(CHUNK_CACHE_NEXT, false);\r\n    else if (!this._includesFirst)\r\n      await this.fetchChunkFromServer(CHUNK_CACHE_PREV, false);\r\n  }\r\n\r\n/// <summary>\r\n  ///   returns true if and only if a record with the given index exist\r\n  /// </summary>\r\n  /// <param name = \"recIdx\">index to check </param>\r\n  recExists(recIdx: number): boolean {\r\n    let lastRecIdx: number = this._recordsTab.getSize() - 1;\r\n    return recIdx >= 0 && recIdx <= lastRecIdx;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   checks if the if the current first record exist\r\n  ///   in case there is no locate check include first\r\n  /// </summary>\r\n  checkFirst(locateFirst: number): boolean {\r\n    return this._recordsTab.getRecord(locateFirst) !== null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the current record index\r\n  /// </summary>\r\n  /// <returns> the record index </returns>\r\n  getCurrRecIdx(): number {\r\n    if (this._currRecIdx === Int32.MinValue) {\r\n      if (!this.setCurrRec(this._currRecId, true)) {\r\n        Logger.Instance.WriteWarningToLogWithMsg('DataView.getCurrRecIdx(): _task ' +\r\n          (this.getTask()).PreviouslyActiveTaskId +\r\n          ', record ' + this._currRecId + ' not found');\r\n      }\r\n    }\r\n    return this._currRecIdx;\r\n  }\r\n\r\n  /// <summary>\r\n  /// return the dbviewrowid for the current record\r\n  /// </summary>\r\n  getCurrDBViewRowIdx(): number {\r\n    return this.CurrRec.getDBViewRowIdx();\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   set the top record index and saves the old value\r\n  /// </summary>\r\n  /// <param name = \"newTopRecIdx\">the new value for the top record index </param>\r\n  setTopRecIdx(newTopRecIdx: number): void {\r\n    this._oldTopRecIdx = this.getTopRecIdx();\r\n    this._topRecIdx = newTopRecIdx;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the top record index\r\n  /// </summary>\r\n  getTopRecIdx(): number {\r\n    return this._topRecIdx;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the top record index modified\r\n  /// </summary>\r\n  /// <param name = \"val\">the new value for topRecIdxModified </param>\r\n  setTopRecIdxModified(val: boolean): void {\r\n    this._topRecIdxModified = val;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get the chunk size index\r\n  /// </summary>\r\n  getChunkSize(): number {\r\n    return this._chunkSize;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   restore the old saved value of the top record index\r\n  /// </summary>\r\n  restoreTopRecIdx(): void {\r\n    this._topRecIdx = this._oldTopRecIdx;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   removes all the records from the Dataview\r\n  /// </summary>\r\n  clear(): void {\r\n    this._recordsTab.removeAll();\r\n    this._original = null;\r\n    let mgForm: MgForm = <MgForm>this._task.getForm();\r\n    if (mgForm !== null) {\r\n       this._task.getForm().SetTableItemsCount(0, true);\r\n    }\r\n    this._modifiedRecordsTab.removeAll();\r\n    this.init();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   initialize the class members\r\n  /// </summary>\r\n  private init(): void {\r\n    this._currRecId = Int32.MinValue;\r\n    this._currRecIdx = Int32.MinValue;\r\n    this.CurrRec = null;\r\n    this._prevCurrRec = null;\r\n    this._includesFirst = false;\r\n    this._includesLast = false;\r\n    this.IsOneWayKey = false;\r\n    this.setTopRecIdx(Int32.MinValue);\r\n    (<FieldsTable>this._fieldsTab).invalidate(false, true);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   refreshes the subForms\r\n  /// </summary>\r\n   async computeSubForms(): Promise<void> {\r\n     // we do not need to go to the server due to updates\r\n     if (await this.getTask().prepareCache(true)) {\r\n\r\n       // one of the needed d.v was not found in the cache\r\n       if (!await this.getTask().testAndSet(true))\r\n         await this.compute(true, false);\r\n     }\r\n     else\r\n       await this.compute(true, false);\r\n   }\r\n\r\n  /// <summary>\r\n  ///   compute the values of the fields without updating the display\r\n  /// </summary>\r\n  /// <param name = \"subForms\">if true the a subForms compute is to be done</param>\r\n  /// <param name = \"forceClientCompute\">if TRUE forces the client to compute the record even if it is flagged\r\n  ///   as \"server computed\".\r\n  /// </param>\r\n  private async compute(subForms: boolean, forceClientCompute: boolean): Promise<void> {\r\n    let tmpRec: Record = null;\r\n    let computeByServer: boolean = !this.computeByClient();\r\n    let orgComputeBy: string = this._computeBy;\r\n    /*'C'*/\r\n    if (forceClientCompute)\r\n      this._computeBy = COMPUTE_NEWREC_ON_CLIENT/*'C'*/;\r\n\r\n    try {\r\n      this.CurrRec.setInCompute(true);\r\n\r\n      if (!subForms) {\r\n        if (this.CurrRec.isNewRec()) {\r\n          if (this._task.getMode() !== Constants.TASK_MODE_CREATE /*'C'*/ && !super.isEmptyDataview()) {\r\n            this._task.setMode(Constants.TASK_MODE_CREATE)/*'C'*/;\r\n          }\r\n        }\r\n        else if (this._task.getMode() === Constants.TASK_MODE_CREATE) {\r\n          this._task.setMode(Constants.TASK_MODE_MODIFY)/*'M'*/;\r\n        }\r\n      }\r\n\r\n      let getRecordData: boolean = computeByServer;\r\n      // for newly created records - go to the server (if they were not computed already)\r\n      if (subForms || (getRecordData && !this.CurrRec.isComputed() && !forceClientCompute)) {\r\n        let command: IClientCommand = CommandFactory.CreateComputeEventCommand(this._task.getTaskTag(), subForms, this._currRecId);\r\n        await (<TaskBase>this._task).DataviewManager.Execute(command);\r\n      }\r\n      else {\r\n        // QCR #921475 - relink during compute destroys values of virtual fields with no init exp.\r\n        // thus we save them before the compute and restore them during the loop.\r\n        if (getRecordData) {\r\n          tmpRec = new Record(this.CurrRec.getId(), this);\r\n          tmpRec.Initialize();\r\n          tmpRec.setInitialFldVals(true, true);\r\n        }\r\n\r\n        (<FieldsTable>this._fieldsTab).setServerRcmp(false);\r\n        let from: number = (<FieldsTable>this._fieldsTab).getRMIdx();\r\n        let size: number = (<FieldsTable>this._fieldsTab).getRMSize();\r\n\r\n        for (let i: number = from; i < from + size; i = i + 1) {\r\n          let fld: Field = <Field>this._fieldsTab.getField(i);\r\n          if (getRecordData && (<FieldsTable>this._fieldsTab).serverRcmpDone() && fld.IsVirtual && !fld.VirAsReal && !fld.hasInitExp()) {\r\n            let currRec2: Record = this.CurrRec;\r\n            this.CurrRec = tmpRec;\r\n            try {\r\n              fld.takeValFromRec();\r\n            }\r\n            finally {\r\n              this.CurrRec = currRec2;\r\n            }\r\n          }\r\n\r\n          //TODO: Check if we can use another (maybe, new) function to get the data while transferring them to UI instead of compute().\r\n          if (!(<MgForm>this._task.getForm()).TransferringDataToGUI)\r\n            await fld.compute(false);\r\n        }\r\n      }\r\n    }\r\n    finally {\r\n      this.CurrRec.setInCompute(false);\r\n      this.CurrRec.setLateCompute(false);\r\n      this._computeBy = orgComputeBy;\r\n    }\r\n  }\r\n\r\n  async addRecord(doSuffix: boolean, ignoreCurrRec: boolean, isCrelineAbove: boolean): Promise<number> {\r\n    let newCurrRecId: number = (--this._lastCreatedRecId);\r\n    let mode: DataModificationTypes = DataModificationTypes.Insert;\r\n    return await this.addRecord_1(doSuffix, ignoreCurrRec, false, newCurrRecId, mode, isCrelineAbove);\r\n  }\r\n\r\n  /// <summary>\r\n  ///\r\n  /// </summary>\r\n  /// <param name=\"doSuffix\">if true then do the suffix of the previous record</param>\r\n  /// <param name=\"ignoreCurrRec\">if true then do the suffix of the previous record</param>\r\n  /// <param name=\"isFirstRecord\"> is first record</param>\r\n  /// <param name=\"newCurrRecId\"> new record id</param>\r\n  /// <param name=\"mode\"> operation mode</param>\r\n  /// <returns>the new rec index</returns>\r\n  private async addRecord_1(doSuffix: boolean, ignoreCurrRec: boolean, isFirstRecord: boolean, newCurrRecId: number, mode: DataModificationTypes, isCrelineAbove: boolean): Promise<number> {\r\n\r\n    // give the new record a negative id\r\n    let rec: Record = new Record(newCurrRecId, this);\r\n    rec.Initialize();\r\n    rec.setInitialFldVals(false, !isFirstRecord);\r\n\r\n    let newCurrRecIdx: number = 0;\r\n    if (isCrelineAbove)\r\n    {\r\n      newCurrRecIdx = (this._currRecIdx >= 0\r\n        ? this._currRecIdx\r\n        : 0);\r\n\r\n    }\r\n    else\r\n      newCurrRecIdx = (this._currRecIdx != Int32.MinValue\r\n        ? this._currRecIdx + 1\r\n        : 0);\r\n\r\n\r\n    //let newCurrRecIdx: number = (this._currRecIdx !== Int32.MinValue) ?\r\n      //(this._currRecIdx + 1)\r\n      //: 0;\r\n\r\n    this._recordsTab.insertRecord(rec, newCurrRecIdx);\r\n    rec.setMode(mode);\r\n\r\n    try {\r\n      let compute: boolean = !isFirstRecord;\r\n      await this.setCurrRecByIdx(newCurrRecIdx, doSuffix, ignoreCurrRec, compute, Int32.MinValue);\r\n\r\n      // while we in create mode don't set reset to _newRec\r\n      if (isFirstRecord && this.getTask().getMode() !== Constants.TASK_MODE_CREATE)\r\n        rec.setOldRec();\r\n    }\r\n    catch (execption) {\r\n      if (execption instanceof RecordOutOfDataViewException) {\r\n        if (AccessHelper.eventsManager.GetStopExecutionFlag())\r\n          newCurrRecIdx = -1;\r\n        else\r\n          throw new ApplicationException('in DataView.addRecord() invalid exception');\r\n\r\n      }\r\n      else\r\n        throw execption;\r\n    }\r\n    return newCurrRecIdx;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   remove the current record from the dataview\r\n  /// </summary>\r\n  async removeCurrRec(): Promise<void> {\r\n    let mgForm: MgForm = <MgForm>this._task.getForm();\r\n    let onDelete: boolean; // true if we are removing the record due to delete. false if due to cancel on insert\r\n\r\n    if (this.CurrRec.getMode() === DataModificationTypes.Insert &&\r\n      !this.getTask().transactionFailed(ConstInterface.TRANS_RECORD_PREFIX)) {\r\n      // the record was created by the client so it has to be removed from the\r\n      // modified records table (if it is already there) because the server\r\n      // doesn't have to know anything about it\r\n      this._modifiedRecordsTab.removeRecord(this.CurrRec);\r\n      onDelete = false;\r\n    }\r\n    else {\r\n      // move the current record from the records table to the modified table\r\n      this.CurrRec.clearMode();\r\n      this.CurrRec.setMode(DataModificationTypes.Delete);\r\n      onDelete = true;\r\n    }\r\n    this.CurrRec.removeRecFromDc();\r\n    this._recordsTab.removeRecord(this._currRecIdx);\r\n    this.setChanged(true);\r\n\r\n    if (this.isEmpty() && !(<TaskBase>this._task).IsTryingToStop) {\r\n      await this.MoveToEmptyDataviewIfAllowed();\r\n    }\r\n\r\n    let newDisplayLine: number = this.calcLineToMove(onDelete);\r\n    try {\r\n      if (mgForm.isScreenMode()) {\r\n        await this.setCurrRecByIdx(newDisplayLine, false, false, true, SET_DISPLAYLINE_BY_DV);\r\n      }\r\n      else {\r\n        await mgForm.setCurrRowByDisplayLine(newDisplayLine, false, true);\r\n      }\r\n    }\r\n    catch (exception) {\r\n      if (exception instanceof RecordOutOfDataViewException) {\r\n        // if the current index is beyond the bottom end of the dataview\r\n        // try to set it to the preceding record\r\n        try {\r\n          if (!super.isEmptyDataview())\r\n            newDisplayLine = mgForm.getPrevLine(newDisplayLine);\r\n          if (mgForm.isScreenMode())\r\n            await this.setCurrRecByIdx(newDisplayLine, false, false, true, SET_DISPLAYLINE_BY_DV);\r\n          else\r\n            await mgForm.setCurrRowByDisplayLine(newDisplayLine, false, true);\r\n        }\r\n        catch (exception) {\r\n          if (exception instanceof RecordOutOfDataViewException) {\r\n\r\n            // no more records in the dataview\r\n            // or no nodes in the tree\r\n            this.reset();\r\n          }\r\n          else\r\n            throw exception;\r\n        }\r\n      }\r\n      else\r\n        throw exception;\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  /// remove record\r\n  /// </summary>\r\n  /// <param name=\"record\"></param>\r\n  RemoveRecord(record: Record): void {\r\n    let recIdx: number = this._recordsTab.getRecIdx(record.getId());\r\n\r\n    if (this._topRecIdx > recIdx)\r\n      this._topRecIdx--;\r\n    if (this._oldTopRecIdx > recIdx)\r\n      this._oldTopRecIdx--;\r\n    if (this._currRecIdx > recIdx)\r\n      this._currRecIdx--;\r\n    this._recordsTab.removeRecord(record);\r\n  }\r\n\r\n  /// <summary>\r\n  /// move to empty dataview if allowed\r\n  /// </summary>\r\n  async MoveToEmptyDataviewIfAllowed(): Promise<void> {\r\n    if (!super.isEmptyDataview() && this._task.getMode() !== Constants.TASK_MODE_CREATE) {\r\n      if (await this._task.checkProp(PropInterface.PROP_TYPE_ALLOW_EMPTY_DATAVIEW, true))\r\n        super.setEmptyDataview(true);\r\n    }\r\n    else {\r\n      if (this._task.getMode() === Constants.TASK_MODE_CREATE && super.isEmptyDataview())\r\n        super.setEmptyDataview(false);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns display line to move after delete\r\n  /// </summary>\r\n  /// <param name = \"onDelete\">true if we are removing the record due to delete. false if due to cancel on insert\r\n  /// </param>\r\n  /// <returns>\r\n  /// </returns>\r\n  private calcLineToMove(onDelete: boolean): number {\r\n    let newDisplayLine: number;\r\n\r\n    // if the record is removed due to its deletion, we need to got to the next record in the view -\r\n    // now that we deleted the current record, the index of the next record is the same index that was\r\n    // of the record that was deleted.\r\n\r\n    if (onDelete)\r\n      newDisplayLine = this._currRecIdx;\r\n    else {\r\n      // #750190 Shaya\r\n      // move to the PREV record after cancel\r\n      if (this._currRecIdx > 0)\r\n        newDisplayLine = this._currRecIdx - 1;\r\n      else\r\n        newDisplayLine = this._currRecIdx;\r\n    }\r\n    return newDisplayLine;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   reset values if there is no current record\r\n  /// </summary>\r\n  reset(): void {\r\n    this._currRecId = Int32.MinValue;\r\n    this._currRecIdx = Int32.MinValue;\r\n    this.CurrRec = null;\r\n    this.setTopRecIdx(Int32.MinValue);\r\n    this.SetIncludesFirst(true);\r\n    this.SetIncludesLast(true);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   cancel the editing of the current record and restore the old values of\r\n  ///   the fields\r\n  /// </summary>\r\n  /// <param name = \"onlyReal\">if true only restores the values of the real fields. </param>\r\n  /// <param name = \"recomputeUnknowns\">re-perform unknown recomputes. </param>\r\n  async cancelEdit(onlyReal: boolean, recomputeUnknowns: boolean): Promise<boolean> {\r\n    let tempCurrRec: Record = null;\r\n    let recRemoved: boolean = false;\r\n    let inEndTask: boolean = (<TaskBase>this._task).InEndTask;\r\n\r\n    // QCR #362903 - At _task suffix, we want to preserve the last values of the virtuals.\r\n    if (inEndTask)\r\n      onlyReal = true;\r\n\r\n    if (this.CurrRec.getMode() === DataModificationTypes.Insert && this.CurrRec.isNewRec()) {\r\n      if ((this._includesFirst && this._includesLast && (this._recordsTab === null || this._recordsTab.getSize() === 1)) || !this.HasMainTable) {\r\n\r\n        // defect 121968. When from the parent task \"ViewRefresh\" or \"Cancel\" are done and the subform is in Create node\r\n        // and the subform has no records, _original is null. So pass it.\r\n        if (this._original !== null) {\r\n          this.CurrRec.setSameAs(this._original, onlyReal);\r\n        }\r\n      }\r\n      else {\r\n        await this.removeCurrRec();\r\n        recRemoved = true;\r\n        this._original = this.CurrRec.replicate(); // must copy again to prevent altering the original values\r\n      }\r\n    }\r\n    // if (currRec.modified())\r\n    else {\r\n      if (!this.CurrRec.Modified) {\r\n        let currCtrl: MgControl = <MgControl>this._task.getLastParkedCtrl();\r\n        if (currCtrl !== null)\r\n          currCtrl.resetPrevVal();\r\n      }\r\n\r\n      if (recomputeUnknowns)\r\n        tempCurrRec = this.CurrRec.replicate();\r\n\r\n      // ATTENTION !!!\r\n      // we don't step over the currRec reference with the original record\r\n      // to assure that if this record is both in the records table and in\r\n      // the modified table these tables will keep referencing the same instance\r\n      if (this._original !== null)\r\n        this.CurrRec.setSameAs(this._original, onlyReal);\r\n\r\n      if ((this._original !== null && recomputeUnknowns) && !this.CurrRec.isSameRecData(tempCurrRec, false, false))\r\n        await this.execUnknownRcmps(this._original);\r\n\r\n      this.takeFldValsFromCurrRec();\r\n      this._original = this.CurrRec.replicate(); // must copy again to prevent altering the original values\r\n    }\r\n    return recRemoved;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   check if there are no records in the dataview\r\n  /// </summary>\r\n  isEmpty(): boolean {\r\n    return this._includesFirst && this._includesLast && (this._recordsTab === null || this._recordsTab.getSize() === 0);\r\n  }\r\n\r\n  async addCurrToModified(): Promise<void> ;\r\n  async addCurrToModified(setRecToOld: boolean): Promise<void> ;\r\n  async addCurrToModified(setRecToOld?: boolean): Promise<void> {\r\n    if (isNullOrUndefined(setRecToOld)) {\r\n      await this.addCurrToModified_0();\r\n      return;\r\n    }\r\n    await this.addCurrToModified_1(setRecToOld);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   add the current record to the modified records table - if it is not already there\r\n  /// </summary>\r\n  private async addCurrToModified_0(): Promise<void> {\r\n    await this.addCurrToModified(true);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   add the current record to the modified records table - if it is not already there\r\n  /// </summary>\r\n  /// <param name=\"isSetOldRec\"></param>\r\n  private async addCurrToModified_1(setRecToOld: boolean): Promise<void> {\r\n    this._modifiedRecordsTab.addRecord(this.CurrRec);\r\n    if (setRecToOld) {\r\n      this.CurrRec.setOldRec();\r\n    }\r\n    let command: IClientCommand = CommandFactory.CreateSetTransactionStateDataviewCommand(this.getTask().getTaskTag(), true);\r\n    await this.getTask().DataviewManager.RemoteDataviewManager.Execute(command);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   take the field values from the current record\r\n  /// </summary>\r\n  takeFldValsFromCurrRec(): void {\r\n    (<FieldsTable>this._fieldsTab).takeValsFromRec();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   compare a selected fields values between the current record and the previous record\r\n  ///   and return true if their values are equal\r\n  /// </summary>\r\n  /// <param name = \"fldList\">the list of field indexes to compare\r\n  /// </param>\r\n  currEqualsPrev(fldList: number[]): boolean {\r\n    if (this.CurrRec !== null && this._prevCurrRec !== null) {\r\n      if (this.CurrRec === this._prevCurrRec)\r\n        return true;\r\n\r\n      for (let i: number = 0; i < fldList.length; i = i + 1) {\r\n        if (!this.CurrRec.fldValsEqual(this._prevCurrRec, fldList[i]))\r\n          return false;\r\n      }\r\n    }\r\n    else if (this.CurrRec !== this._prevCurrRec)\r\n  return false;\r\n\r\n    return true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return a reference to the _task of this dataview\r\n  /// </summary>\r\n  getTask(): TaskBase {\r\n    Debug.Assert(this._task instanceof TaskBase);\r\n    return <TaskBase>this._task;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return a reference to the form for _task of this dataview\r\n  /// </summary>\r\n  getForm(): MgForm {\r\n    return <MgForm>this._task.getForm();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the number of records in the modified records table\r\n  /// </summary>\r\n  modifiedRecordsNumber(): number {\r\n    return this._modifiedRecordsTab.getSize();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   return the number of records in the dataview\r\n  /// </summary>\r\n  getSize(): number {\r\n    return this._recordsTab.getSize();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if the client knows how to init a new record.\r\n  /// </summary>\r\n  computeByClient(): boolean {\r\n    return this._computeBy === COMPUTE_NEWREC_ON_CLIENT/*'C'*/;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   is Record exists in the DataView\r\n  /// </summary>\r\n  /// <param name = \"id\">of needed record </param>\r\n  /// <returns> true if the record exists </returns>\r\n  recExistsById(id: number): boolean {\r\n    return this._recordsTab.getRecord(id) !== null;\r\n  }\r\n\r\n\r\n  ParametersExist(iPos: number, iLen: number): boolean;\r\n  ParametersExist(): boolean;\r\n  ParametersExist(iPos?: number, iLen?: number): boolean {\r\n    if (arguments.length === 2)\r\n      return this.ParametersExist_0(iPos, iLen);\r\n    return this.ParametersExist_1();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   check if there are params in the specified range\r\n  /// </summary>\r\n  /// <param name = \"iPos\">position of first field</param>\r\n  /// <param name = \"iLen\">number of fields in the range</param>\r\n  /// <returns> true = there are parameters in the range</returns>\r\n  private ParametersExist_0(iPos: number, iLen: number): boolean {\r\n    for (let i: number = iPos; i < iPos + iLen; i = i + 1) {\r\n      if ((<Field>super.getField(i)).isParam())\r\n        return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /// <summary>\r\n  /// check if there are params in Dataview tab\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  private ParametersExist_1(): boolean {\r\n    return this.ParametersExist(this._rmIdx, this._rmSize);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns true if a record is in the modified records table\r\n  /// </summary>\r\n  /// <param name = \"id\">the id of the record</param>\r\n  recInModifiedTab(id: number): boolean {\r\n    let record: Record = this._modifiedRecordsTab.getRecord(id);\r\n    return record !== null;\r\n  }\r\n\r\n  setPrevCurrRec(): void;\r\n  setPrevCurrRec(rec: Record): void;\r\n  setPrevCurrRec(rec?: Record): void {\r\n    if (arguments.length === 0) {\r\n      this.setPrevCurrRec_0();\r\n      return;\r\n    }\r\n    this.setPrevCurrRec_1(rec);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   saves the current record as the previous current record\r\n  /// </summary>\r\n  private setPrevCurrRec_0(): void {\r\n    this._prevCurrRec = this.CurrRec;\r\n  }\r\n\r\n  private setPrevCurrRec_1(rec: Record): void {\r\n    this._prevCurrRec = rec;\r\n  }\r\n\r\n  isPrevCurrRecNull(): boolean {\r\n    return this._prevCurrRec === null;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   recompute all virtuals with no init expression which have server recompute defined for them.\r\n  /// </summary>\r\n  /// <param name = \"orgRec\">contains the virtual's original value </param>\r\n  private async execUnknownRcmps(orgRec: Record): Promise<void> {\r\n\r\n    let i: number;\r\n    let from: number = (<FieldsTable>this._fieldsTab).getRMIdx();\r\n    let size: number = (<FieldsTable>this._fieldsTab).getRMSize();\r\n\r\n    let rec: Record = this.getCurrRec();\r\n\r\n    // First time - initialize unknownRcmp value\r\n    if (this._unknownRcmp === UNKNOWN_RCMPS_NOT_INITED) {\r\n\r\n      for (i = from;\r\n           i < from + size && this._unknownRcmp === UNKNOWN_RCMPS_NOT_INITED;\r\n           i++) {\r\n\r\n        let field: Field = <Field>this._fieldsTab.getField(i);\r\n\r\n        if (field.IsVirtual && !field.hasInitExp() && field.isServerRcmp())\r\n          this._unknownRcmp = UNKNOWN_RCMPS_FOUND/*'Y'*/;\r\n\r\n      }\r\n    }\r\n\r\n    if (this._unknownRcmp === UNKNOWN_RCMPS_FOUND /*'Y'*/ && rec !== null) {\r\n      for (i = from; i < from + size; i = i + 1) {\r\n\r\n        let field: Field = <Field>this._fieldsTab.getField(i);\r\n        if (field.IsVirtual && !field.hasInitExp() && field.isServerRcmp() && !rec.fldValsEqual(orgRec, i)) {\r\n          let fieldValue: string = rec.GetFieldValue(i);\r\n          let isNullFld: boolean = rec.IsNull(i);\r\n          rec.setFieldValue(i, orgRec.GetFieldValue(i), false);\r\n          await field.setValueAndStartRecompute(fieldValue, isNullFld, false, false, false);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   set the transCleared flag\r\n  /// </summary>\r\n  setTransCleared(): void {\r\n    this._transCleared = true;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   perform any data error recovery action\r\n  /// </summary>\r\n  public async processRecovery(): Promise<void> {\r\n    if (!this._task.isAborting()) {\r\n      let orgAction: string = this._pendingRecovery;\r\n      let orgStopExecution: boolean = AccessHelper.eventsManager.GetStopExecutionFlag();\r\n\r\n      this._pendingRecovery = RECOVERY_ACT_NONE;\r\n      if (orgStopExecution)\r\n        AccessHelper.eventsManager.setStopExecution(false);\r\n\r\n      let temporaryResetInCtrlPrefix: boolean = (<TaskBase>this._task).InCtrlPrefix;\r\n\r\n      // if the error from which we recover happened while in ctrl prefix, reset it for the action to be executed here,\r\n      // so that entering a new control will work (Defect 122387).\r\n      if (temporaryResetInCtrlPrefix)\r\n        (<TaskBase>this._task).InCtrlPrefix = false;\r\n\r\n      switch (orgAction) {\r\n        case RECOVERY_ACT_CANCEL:\r\n          ((<DataView>this._task.DataView).getCurrRec()).resetUpdated();\r\n\r\n          // QCR #773979 (updated record cant be canceled)\r\n\r\n          // clear the cache\r\n          this.getTask().getTaskCache().clearCache();\r\n\r\n          // qcr #776952. create mode and only 1 rec on dv. The server has ordered\r\n          // a rollback. Here, we reset original rec and curr rec to insert mode,\r\n          // otherwise, next time the client will set update mode for the rec instead of insert.\r\n          if (this.getSize() === 1 && this._task.getMode() === Constants.TASK_MODE_CREATE) {\r\n            this.CurrRec.resetModified();\r\n            this.CurrRec.clearMode();\r\n            this.CurrRec.setMode(DataModificationTypes.Insert);\r\n            this.CurrRec.setNewRec();\r\n            this._original.setSameAs(this.CurrRec, false);\r\n          }\r\n\r\n          // The cancel handled here will not caused a rollback since it was raised by rollback. (rollb already done in server).\r\n          await AccessHelper.eventsManager.handleInternalEventWithTaskAndEventSubtype(this.getTask(), InternalInterface.MG_ACT_CANCEL,\r\n            EventSubType.CancelWithNoRollback);\r\n          break;\r\n\r\n        case RECOVERY_ACT_MOVE_DIRECTION_BEGIN:\r\n          // Defect 152320: When Database error occurs we need not call Record suffix again as this is called from Record suffix.\r\n          // We need to attempt to park on lastparkedCtrl and wait there\r\n          let lastParkedControl: MgControl = <MgControl>this._task.getLastParkedCtrl();\r\n          if(lastParkedControl !== null)\r\n            await lastParkedControl.invoke();\r\n          break;\r\n\r\n        case RECOVERY_ACT_BEGIN_SCREEN:\r\n          this.getTask().setPreventRecordSuffix(true);\r\n          await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_TBL_BEGPAGE);\r\n          this.getTask().setPreventRecordSuffix(false);\r\n          break;\r\n\r\n        case RECOVERY_ACT_BEGIN_TABLE:\r\n          // make sure the action is enabled no matter our location in the table. otherwise, rec prefix will not be executed after rollback.\r\n          this._task.ActionManager.enable(InternalInterface.MG_ACT_TBL_BEGTBL, true);\r\n          await AccessHelper.eventsManager.handleInternalEventWithTask(this._task, InternalInterface.MG_ACT_TBL_BEGTBL);\r\n          // clear the cache\r\n          this.getTask().getTaskCache().clearCache();\r\n          break;\r\n\r\n\r\n        default:\r\n          AccessHelper.eventsManager.setStopExecution(orgStopExecution);\r\n          break;\r\n      }\r\n      if (temporaryResetInCtrlPrefix)\r\n        (<TaskBase>this._task).InCtrlPrefix = true;\r\n\r\n      if (orgAction !== RECOVERY_ACT_NONE)\r\n        AccessHelper.eventsManager.setStopExecution(true, orgAction !== RECOVERY_ACT_BEGIN_TABLE ? ClearEventsOnStopExecution.ALL : ClearEventsOnStopExecution.SERVER);\r\n    }\r\n  }\r\n\r\n  /// <summary>\r\n  ///   repleciates the current dataview\r\n  /// </summary>\r\n  replicate(): DataView {\r\n    let rep: DataView = new DataView(this);\r\n    rep._recordsTab = this._recordsTab.replicate();\r\n    rep._currRecId = rep._recordsTab.getRecByIdx(0).getId();\r\n    rep._currRecIdx = 0;\r\n    rep.CurrRec = rep._recordsTab.getRecByIdx(0);\r\n    rep._prevCurrRec = rep._recordsTab.getRecByIdx(0);\r\n    rep._original = rep._recordsTab.getRecByIdx(0);\r\n    rep.setTopRecIdx(Int32.MinValue);\r\n    // we must check dcVals if it need to be replicated as well currenty we think not\r\n    return rep;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns the dvPos value non hashed\r\n  /// </summary>\r\n  getDvPosValue(): number {\r\n    return this._dvPosValue;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   check is it is the first time the d.v is parsed\r\n  /// </summary>\r\n  getFirstDv(): boolean {\r\n    return this._firstDv;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   reset is the first time the d.v is parsed\r\n  /// </summary>\r\n  ResetFirstDv(): void {\r\n    this._firstDv = false;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   get this dataview cache time stamp\r\n  /// </summary>\r\n  getCacheLRU(): number {\r\n    return this._cacheLruTimeStamp;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   sets the time stamp of the dataview\r\n  ///   used when inserting dataview in cache\r\n  /// </summary>\r\n  setCacheLRU(): void {\r\n    this._cacheLruTimeStamp = Misc.getSystemMilliseconds();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   news to take the values from the given dv and to set them as the current values\r\n  ///   the given dv is usually created via dataview.replicate()\r\n  ///   this method does not take the values of  lastSessionCount and cacheLRUTimeStamp\r\n  ///   from the given dv since they should be propagated from one current dv to the other\r\n  /// </summary>\r\n  async setSameAs(newDv: DataView): Promise<void> {\r\n    this._rmSize = newDv._rmSize;\r\n    this._rmIdx = newDv._rmIdx;\r\n    this._computeBy = newDv._computeBy;\r\n    this._flushUpdates = newDv._flushUpdates;\r\n    this._currRecId = newDv._currRecId;\r\n    this._currRecIdx = newDv._currRecIdx;\r\n    this._topRecId = newDv._topRecId;\r\n    this.CurrRec = newDv.CurrRec;\r\n    this._original = newDv._original;\r\n    this._prevCurrRec = null;\r\n    this._fieldsTab = newDv._fieldsTab;\r\n    this._recordsTab = newDv._recordsTab;\r\n    this._modifiedRecordsTab = newDv._modifiedRecordsTab;\r\n    this._includesFirst = newDv._includesFirst;\r\n    this._includesLast = newDv._includesLast;\r\n    this._insertAt = newDv._insertAt;\r\n    this._lastCreatedRecId = newDv._lastCreatedRecId;\r\n    this._task = newDv._task;\r\n    this._dcValsCollection = newDv._dcValsCollection;\r\n    this._recovery = newDv._recovery;\r\n    this._pendingRecovery = newDv._pendingRecovery;\r\n    this._hasMainTable = newDv._hasMainTable;\r\n    this._chunkSize = newDv._chunkSize;\r\n    this._firstDv = newDv._firstDv;\r\n    this._lastSessionCounter = newDv._lastSessionCounter;\r\n    this._skipParsing = newDv._skipParsing;\r\n    this._unknownRcmp = newDv._unknownRcmp;\r\n    this._transCleared = newDv._transCleared;\r\n    this._dvPosValue = newDv._dvPosValue;\r\n    this._cacheLruTimeStamp = newDv._cacheLruTimeStamp;\r\n    this._changed = newDv._changed;\r\n    this._locateFirstRec = newDv._locateFirstRec;\r\n    super.setEmptyDataview(newDv.isEmptyDataview());\r\n    this._task.setMode(newDv.taskModeFromCache);\r\n\r\n    // UPDATE THE TABLE DISPLAY\r\n    try {\r\n      if (this.getTask().HasLoacte()) {\r\n        await this.setCurrRec(this._locateFirstRec, true);\r\n        this.setTopRecIdx(this._recordsTab.getRecIdx(this._locateFirstRec));\r\n      }\r\n      else {\r\n        this.getTask().setPreventRecordSuffix(true);\r\n        await this.setCurrRecByIdx(Int32.MinValue, true, false, true, Int32.MinValue);\r\n        this.getTask().setPreventRecordSuffix(false);\r\n        this.setTopRecIdx(0);\r\n      }\r\n\r\n      if (!this._task.getForm().isScreenMode()) {\r\n        if ((<MgForm>this._task.getForm()).isTableWithPagination()) {\r\n          this.TotalRecordsCount = newDv.TotalRecordsCount;\r\n          this.RecordsBeforeCurrentView = newDv.RecordsBeforeCurrentView;\r\n        }\r\n        await this.setCurrRecByIdx(this._topRecIdx, true, false, true, Int32.MinValue);\r\n      }\r\n\r\n      if (this._task.getForm() !== null)\r\n        (<MgForm>this._task.getForm()).updateDisplayLineByDV();\r\n    }\r\n    catch (ex) {\r\n      if (ex instanceof RecordOutOfDataViewException) {\r\n        Logger.Instance.WriteDevToLog('wrong top record idx in DataView.setSameAs' + ex.Message);\r\n      }\r\n      else\r\n        throw ex;\r\n    }\r\n  }\r\n\r\n  setChanged(val: boolean): void {\r\n    this._changed = val;\r\n  }\r\n\r\n  getChanged(): boolean {\r\n    return this._changed;\r\n  }\r\n\r\n  getLocateFirstRec(): number {\r\n    return this._locateFirstRec;\r\n  }\r\n\r\n  setLocateFirstRec(newFirst: number): void {\r\n    this._locateFirstRec = newFirst;\r\n  }\r\n\r\n  /// <summary>\r\n  ///   returns a record by its idx\r\n  /// </summary>\r\n  getRecByIdx(idx: number): Record {\r\n    return this._recordsTab.getRecByIdx(idx);\r\n  }\r\n\r\n  getServerCurrRec(): Record {\r\n    return this._recordsTab.getServerCurrRec();\r\n  }\r\n\r\n  zeroServerCurrRec(): void {\r\n    this._recordsTab.zeroServerCurrRec();\r\n  }\r\n\r\n  inRollback(): boolean {\r\n    let inRollback: boolean = false;\r\n\r\n    if (this._recovery === ConstInterface.RECOVERY_ROLLBACK /*'R'*/ && this.getTask().isTransactionOwner()) {\r\n      inRollback = true;\r\n    }\r\n    return inRollback;\r\n  }\r\n\r\n  /// <summary>\r\n  /// </summary>\r\n  /// <param name = \"id\"> </param>\r\n  /// <returns> </returns>\r\n  getRecIdx(id: number): number {\r\n    return this._recordsTab.getRecIdx(id);\r\n  }\r\n\r\n  /// <summary>\r\n  ///   backup current record\r\n  /// </summary>\r\n  backupCurrent(): Record {\r\n    return this.CurrRec.replicate();\r\n  }\r\n\r\n  /// <summary>\r\n  ///   restore current record from backup\r\n  /// </summary>\r\n  /// <param name = \"recBackup\">backup of previous current record </param>\r\n  restoreCurrent(recBackup: Record): void {\r\n    Debug.Assert(recBackup !== null);\r\n    this._currRecId = recBackup.getId();\r\n    this._currRecIdx = this._recordsTab.getRecIdx(this._currRecId);\r\n    this.CurrRec = this._recordsTab.getRecByIdx(this._currRecIdx);\r\n    this.CurrRec.setSameAs(recBackup, false);\r\n    this.takeFldValsFromCurrRec();\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  /// return the id of the current record\r\n  /// </summary>\r\n  /// <returns></returns>\r\n  GetCurrentRecId(): number {\r\n    return this._currRecId;\r\n  }\r\n\r\n  /// <summary>\r\n  /// dataview boundaries are changed\r\n  /// </summary>\r\n  /// <param name=\"orgIncludesFirst\"></param>\r\n  /// <param name=\"orgIncludesLast\"></param>\r\n  /// <returns></returns>\r\n  DataviewBoundriesAreChanged(orgIncludesFirst: boolean, orgIncludesLast: boolean): boolean {\r\n    return orgIncludesFirst !== this.IncludesFirst() || orgIncludesLast !== this.IncludesLast();\r\n  }\r\n\r\n\r\n  /// <summary>\r\n  ///   get route params\r\n  /// </summary>\r\n  GetRouteParams(): List<any> {\r\n    let params: List<any> = new List();\r\n    for (let i = 0; i < this._fieldsTab.getSize(); i++) {\r\n\r\n      let field: Field = <Field>this._fieldsTab.getField(i);\r\n      let val: any;\r\n      if (field.IsExposedRouteParam && !field.isNull()) {\r\n        switch (field.getType())\r\n        {\r\n          case StorageAttribute.ALPHA:\r\n          case StorageAttribute.UNICODE: {\r\n            val = field.getDispValue();\r\n            if (field.isNull())\r\n              val = field.getNullDisplay();\r\n            val = val.trim();\r\n            params.push((<string>val).length === 0 ? ' ' : val);\r\n          }\r\n          break;\r\n\r\n          case StorageAttribute.BOOLEAN: {\r\n            if (field.isNull())\r\n              params.push(false);\r\n            else\r\n              params.push((field.getDispValue()).charAt(0) === '1');\r\n          }\r\n            break;\r\n\r\n          case StorageAttribute.NUMERIC: {\r\n            val = field.getDispValue();\r\n            if (field.isNull())\r\n              val = field.getNullDisplay();\r\n            let pic: PIC = new PIC(field.getPicture(), field.getType(), this.getTask().getCompIdx());\r\n            val = DisplayConvertor.Instance.mg2disp(val, '', pic, true, 0, false);\r\n            params.push(val);\r\n            break;\r\n          }\r\n        }\r\n      }\r\n    }\r\n    return (params.length > 0) ? params : null;\r\n  }\r\n}\r\n"]}