@syncfusion/ej2-treegrid 31.1.17 → 31.1.20

package/dist/ts/treegrid/actions/edit.ts

@@ -1,1083 +0,0 @@
-import { Grid, Edit as GridEdit, SaveEventArgs, CellSaveArgs, CellEditArgs, getUid, getObject,
-    NotifyArgs, Row, ActionEventArgs, resetRowIndex, BatchChanges} from '@syncfusion/ej2-grids';
-import { Column, RecordDoubleClickEventArgs, RowInfo, parentsUntil } from '@syncfusion/ej2-grids';
-import { TreeGrid } from '../base/treegrid';
-import { ITreeData, CellSaveEventArgs } from '../base/interface';
-import * as events from '../base/constant';
-import { isNullOrUndefined, extend, setValue, removeClass, KeyboardEventArgs, addClass, getValue } from '@syncfusion/ej2-base';
-import { DataManager, Deferred, RemoteSaveAdaptor, AdaptorOptions, Query } from '@syncfusion/ej2-data';
-import { findChildrenRecords, getParentData, isCountRequired, isRemoteData  } from '../utils';
-import { editAction, updateParentRow } from './crud-actions';
-import { RowPosition } from '../enum';
-import { BatchEdit } from './batch-edit';
-import { AggregateRow } from '../models/summary';
-
-/**
- * TreeGrid Edit Module
- * The `Edit` module is used to handle editing actions.
- */
-export class Edit {
-    private parent: TreeGrid;
-    private isSelfReference: boolean;
-    private addedRecords: string = 'addedRecords';
-    private deletedRecords: string = 'deletedRecords';
-    private addRowIndex: number;
-    private addRowRecord: ITreeData;
-    private isOnBatch: boolean;
-    private keyPress: string;
-    private selectedIndex: number;
-    private doubleClickTarget: Element;
-    private internalProperties: ITreeData;
-    private previousNewRowPosition : RowPosition;
-    private batchEditModule: BatchEdit;
-    private isTabLastRow: boolean;
-    private prevAriaRowIndex: string = '-1';
-    private isAddedRowByMethod: boolean = false;
-    private isAddedRowByContextMenu: boolean = false;
-    private editedRowIndex: number;
-    private isScrollByFocus : boolean;
-    private isIndexUndefined : boolean = false;
-    /**
-     * Constructor for Edit module
-     *
-     * @param {TreeGrid} parent - Tree Grid instance
-     */
-    constructor(parent: TreeGrid) {
-        Grid.Inject(GridEdit);
-
-        this.parent = parent;
-        this.isSelfReference = !isNullOrUndefined(parent.parentIdMapping);
-        this.previousNewRowPosition = null;
-        this.internalProperties = {};
-        this.batchEditModule = new BatchEdit(this.parent);
-        this.addEventListener();
-    }
-    /**
-     * For internal use only - Get the module name.
-     *
-     * @private
-     * @returns {string} Returns Edit module name
-     */
-    protected getModuleName(): string {
-        return 'edit';
-    }
-
-    /**
-     * @hidden
-     * @returns {void}
-     */
-    public addEventListener(): void {
-        this.parent.on(events.crudAction, this.crudAction, this);
-        this.parent.on(events.beginEdit, this.beginEdit, this);
-        this.parent.on(events.beginAdd, this.beginAdd, this);
-        this.parent.on(events.recordDoubleClick, this.recordDoubleClick, this);
-        this.parent.on(events.cellSave, this.cellSave, this);
-        this.parent.on(events.batchCancel, this.batchCancel, this);
-        this.parent.grid.on(events.keyPressed, this.keyPressed, this);
-        this.parent.grid.on('batchedit-form', this.lastCellTab, this);
-        this.parent.grid.on('content-ready', this.contentready, this);
-        this.parent.on(events.cellEdit, this.cellEdit, this);
-        this.parent.on('actionBegin', this.editActionEvents, this);
-        this.parent.on('actionComplete', this.editActionEvents, this);
-        this.parent.grid.on(events.doubleTap, this.recordDoubleClick, this);
-        this.parent.grid.on('dblclick', this.gridDblClick, this);
-        this.parent.grid.on('recordAdded', this.customCellSave, this);
-        this.parent.on('savePreviousRowPosition', this.savePreviousRowPosition, this);
-        // this.parent.on(events.beforeDataBound, this.beforeDataBound, this);
-        this.parent.grid.on(events.beforeStartEdit, this.beforeStartEdit, this);
-        this.parent.grid.on(events.beforeBatchCancel, this.beforeBatchCancel, this);
-        this.parent.grid.on('reset-edit-props', this.resetIsOnBatch, this);
-        this.parent.grid.on('get-row-position', this.getRowPosition, this);
-    }
-    private gridDblClick(e: MouseEvent): void {
-        this.doubleClickTarget = e.target as HTMLElement;
-        if ((e.target as HTMLElement).classList.contains('e-frame') && this.parent.getCurrentViewRecords().length === 0)
-        {
-            this.doubleClickTarget = null;
-        }
-        if ((e.target as HTMLElement).classList.contains('e-treegridcollapse') || (e.target as HTMLElement).classList.contains('e-treegridexpand')) {
-            const tr: Element = parentsUntil(e.target as Element, 'e-row');
-            const rowIndex: number = tr && parseInt(tr.getAttribute('aria-rowindex'), 10) - 1;
-            if (!isNullOrUndefined(rowIndex) && rowIndex >= 0 && this.parent.allowPaging) {
-                /* eslint-disable-next-line */
-                (this.parent.grid.getDataRows()[rowIndex]as HTMLTableRowElement).dataset.uid = (this.parent.grid.contentModule.getRows()[rowIndex] as any).uid;
-            }
-        }
-    }
-    private getRowPosition(addArgs: { newRowPosition: RowPosition, addRowIndex: number, dataRowIndex: number }): void {
-        addArgs.newRowPosition = this.parent.editSettings.newRowPosition;
-        addArgs.addRowIndex = this.addRowIndex;
-        addArgs.dataRowIndex = +this.prevAriaRowIndex;
-    }
-    private beforeStartEdit(args: Object) : void {
-        if (this.parent.editSettings.mode === 'Cell') {
-            this.parent.trigger(events.actionBegin, args);
-        }
-    }
-    private beforeBatchCancel(args: Object) : void {
-        if (this.parent.editSettings.mode === 'Cell') {
-            args['requestType'] = 'cancel';
-            this.parent.trigger(events.actionComplete, args);
-        }
-    }
-    /**
-     * @hidden
-     * @returns {void}
-     */
-    public removeEventListener(): void {
-        if (this.parent.isDestroyed) { return; }
-        this.parent.off(events.crudAction, this.crudAction);
-        this.parent.off(events.beginEdit, this.beginEdit);
-        this.parent.off(events.beginAdd, this.beginAdd);
-        this.parent.off(events.recordDoubleClick, this.recordDoubleClick);
-        this.parent.off(events.batchCancel, this.batchCancel);
-        this.parent.grid.off(events.keyPressed, this.keyPressed);
-        this.parent.grid.off('batchedit-form', this.lastCellTab);
-        this.parent.grid.off('content-ready', this.contentready);
-        this.parent.off(events.cellEdit, this.cellEdit);
-        this.parent.off('actionBegin', this.editActionEvents);
-        this.parent.off('actionComplete', this.editActionEvents);
-        this.parent.grid.off('recordAdded', this.customCellSave);
-        this.parent.grid.off(events.doubleTap, this.recordDoubleClick);
-        this.parent.off('savePreviousRowPosition', this.savePreviousRowPosition);
-        this.parent.grid.off(events.beforeStartEdit, this.beforeStartEdit);
-        this.parent.grid.off(events.beforeBatchCancel, this.beforeBatchCancel);
-        this.parent.grid.off('dblclick', this.gridDblClick);
-        this.parent.grid.off('reset-edit-props', this.resetIsOnBatch);
-        this.parent.grid.off('get-row-position', this.getRowPosition);
-        //this.parent.grid.off('click', this.gridSingleClick);
-    }
-    /**
-     * To destroy the editModule
-     *
-     * @returns {void}
-     * @hidden
-     */
-    public destroy(): void {
-        this.removeEventListener();
-    }
-
-    /**
-     * @param {Column[]} cols - Column property Collection
-     * @hidden
-     * @returns {void}
-     */
-    public applyFormValidation(cols?: Column[]): void {
-        this.parent.grid.editModule.applyFormValidation(cols);
-    }
-    private editActionEvents(args: Object): void {
-        const eventArgs: ActionEventArgs | CellSaveEventArgs = getObject('editAction', args);
-        const eventName: string = getObject('name', eventArgs);
-        const treeObj: TreeGrid = this.parent;
-        const adaptor: AdaptorOptions = !isNullOrUndefined((treeObj.dataSource as DataManager))
-            && (treeObj.dataSource as DataManager).adaptor;
-        if (!isNullOrUndefined(adaptor) && (isRemoteData(treeObj) || adaptor instanceof RemoteSaveAdaptor) &&
-          (eventArgs.requestType === 'save' && eventArgs.action === 'add') &&
-          (treeObj.editSettings.newRowPosition === 'Child' || treeObj.editSettings.newRowPosition === 'Below'
-          || treeObj.editSettings.newRowPosition === 'Above')) {
-            if (eventName === 'actionBegin') {
-                const rowIndex: number = isNullOrUndefined(eventArgs.row) || !Object.keys(eventArgs.row).length ? this.selectedIndex :
-                    (<HTMLTableRowElement>eventArgs.row).rowIndex - 1;
-                const keyData: string = (!isNullOrUndefined(rowIndex) && rowIndex !== -1) ?
-                    treeObj.getCurrentViewRecords()[parseInt(rowIndex.toString(), 10)][treeObj.getPrimaryKeyFieldNames()[0]] : -1;
-                treeObj.grid.query.addParams('relationalKey', keyData);
-            } else if (eventName === 'actionComplete') {
-                const paramsLength: number = treeObj.grid.query.params.length;
-                for (let i: number = 0; i < paramsLength; i++) {
-                    if (treeObj.grid.query.params[parseInt(i.toString(), 10)].key === 'relationalKey') {
-                        treeObj.grid.query.params.splice(i);
-                    }
-                }
-            }
-        }
-        if (this.parent.enableInfiniteScrolling && eventName === 'actionComplete') {
-            this.infiniteAddAction(eventArgs);
-        }
-        if (this.parent.editSettings.mode === 'Batch' &&  eventArgs.requestType === 'paging') {
-            this.parent.notify('batchPageAction', {});
-        }
-    }
-    private infiniteAddAction(args: ActionEventArgs | CellSaveEventArgs): void {
-        if ((args.requestType === 'save' && args.action === 'add') || args.requestType === 'delete') {
-            if (this.parent.editSettings.newRowPosition !== 'Top' && this.selectedIndex !== -1
-         && (args.requestType === 'save' && args.action === 'add')) {
-                const rowObjects: Row<Column>[] = this.parent.grid.getRowsObject();
-                const newRowObject: Row<Column> = rowObjects.splice(0, 1)[0];
-                let newRowObjectIndex: number = this.addRowIndex;
-                const currentData: ITreeData[] = this.parent.getCurrentViewRecords();
-                if (this.parent.editSettings.newRowPosition === 'Below' || this.parent.editSettings.newRowPosition === 'Child') {
-                    newRowObjectIndex += findChildrenRecords(currentData[newRowObjectIndex + 1]).length;
-                }
-                newRowObjectIndex = this.parent.editSettings.newRowPosition === 'Below' ? newRowObjectIndex + 1 : newRowObjectIndex;
-                rowObjects.splice(newRowObjectIndex, 0, newRowObject);
-                const newRecord: ITreeData = currentData.splice(0, 1)[0];
-                currentData.splice(newRowObjectIndex, 0, newRecord);
-                this.updateInfiniteCurrentViewData(newRecord, this.addRowIndex);
-            }
-            const movableRows: Element[] = this.parent.grid.getRows();
-            const movableRowsObject: Row<Column>[] = this.parent.grid.getRowsObject();
-            const isCache: boolean = this.parent.infiniteScrollSettings.enableCache;
-            if (!isCache) {
-                resetRowIndex(this.parent.grid, this.parent.grid.getRowsObject(), this.parent.grid.getRows() as HTMLTableRowElement[], 0);
-                this.updateIndex(this.parent.grid.dataSource, this.parent.getRows(), this.parent.getCurrentViewRecords());
-            }
-            if (!isCache && this.parent.getFrozenColumns() > 0) {
-                resetRowIndex(this.parent.grid, movableRowsObject, movableRows as HTMLTableRowElement[], 0);
-                this.updateIndex(this.parent.grid.dataSource, movableRows, this.parent.getCurrentViewRecords());
-            }
-        }
-    }
-
-    private updateInfiniteCurrentViewData(newRecord: ITreeData, newRowIndex: number): void {
-        const infiniteData: string = 'infiniteCurrentViewData'; const updateCurrentViewData: string = 'updateCurrentViewData';
-        const size: number = Math.ceil(newRowIndex / this.parent.grid.pageSettings.pageSize);
-        let page: number = size > 0 ? size : 1;
-        let dataIndex: number = newRowIndex - ((page - 1) * this.parent.pageSettings.pageSize);
-        const infiniteCurrentViewData: { [x: number]: Object[] } = this.parent.grid.infiniteScrollModule[`${infiniteData}`];
-        infiniteCurrentViewData[1].splice(0, 1);
-        let data: Object[] = infiniteCurrentViewData[parseInt(page.toString(), 10)];
-        if (!isNullOrUndefined(this.addRowRecord)) {
-            data.filter((e: ITreeData, index: number): void => {
-                if (e.uniqueID === this.addRowRecord.uniqueID) {
-                    dataIndex = index;
-                }
-            });
-            if (this.addRowRecord.hasChildRecords && this.addRowRecord.childRecords.length &&
-          this.parent.editSettings.newRowPosition === 'Below' || this.parent.editSettings.newRowPosition === 'Child') {
-                dataIndex += findChildrenRecords(this.addRowRecord).length;
-            }
-        }
-        if (dataIndex >= this.parent.pageSettings.pageSize) {
-            page += 1;
-            data = infiniteCurrentViewData[parseInt(page.toString(), 10)];
-            dataIndex = dataIndex - this.parent.pageSettings.pageSize >= 0 ? dataIndex - this.parent.pageSettings.pageSize : 0;
-        }
-        dataIndex = this.parent.editSettings.newRowPosition === 'Below' ? dataIndex + 1 : dataIndex;
-        data.splice(dataIndex, 0, newRecord);
-        this.parent.grid.infiniteScrollModule[`${updateCurrentViewData}`]();
-    }
-
-    private recordDoubleClick(args: RecordDoubleClickEventArgs): void {
-        const target: HTMLElement = <HTMLElement>args.target;
-        if (isNullOrUndefined(target.closest('td.e-rowcell'))) {
-            return;
-        }
-        if (!(this.parent.grid.editSettings.allowEditing) || this.parent.grid.isEdit) {
-            return;
-        }
-        const column: Column = this.parent.grid.getColumnByIndex(+target.closest('td.e-rowcell').getAttribute('aria-colindex') - 1);
-        if (this.parent.editSettings.mode === 'Cell' && !this.isOnBatch && column && !column.isPrimaryKey &&
-            this.parent.editSettings.allowEditing && column.allowEditing && !(target.classList.contains('e-treegridexpand') ||
-                target.classList.contains('e-treegridcollapse')) && this.parent.editSettings.allowEditOnDblClick) {
-            this.isOnBatch = true;
-            this.parent.grid.setProperties({ selectedRowIndex: args.rowIndex }, true);
-            if (this.parent.enableVirtualization) {
-                const tr: HTMLTableRowElement = <HTMLTableRowElement>parentsUntil(args.target as Element, 'e-row');
-                this.prevAriaRowIndex = tr.getAttribute('aria-rowindex');
-                tr.setAttribute('aria-rowindex', (tr.rowIndex + 1) + '');
-            }
-            this.updateGridEditMode('Batch');
-        }
-        else if (this.parent.editSettings.mode === 'Cell' && (!column.allowEditing || column.isPrimaryKey)){
-            this.isOnBatch = true;
-            this.updateGridEditMode('Batch');
-        }
-    }
-    private updateGridEditMode(mode: string): void {
-        this.parent.grid.setProperties({editSettings: {mode: mode}}, true);
-        const updateMethod: Function = getObject('updateEditObj', this.parent.grid.editModule) as Function;
-        updateMethod.apply(this.parent.grid.editModule);
-        this.parent.grid.isEdit = false;
-    }
-
-    private resetIsOnBatch(): void {
-        if (this.parent.enableVirtualization && this.parent.editSettings.mode === 'Cell') {
-            this.isOnBatch = false;
-            this.updateGridEditMode('Normal');
-        }
-    }
-
-    private keyPressed(args: KeyboardEventArgs): void {
-        if (this.isOnBatch  || args.action === 'tab' || args.action === 'shiftTab') {
-            this.keyPress = args.action;
-        }
-        if (args.action === 'f2') {
-            this.recordDoubleClick(args as Object);
-        }
-        if (args.action === 'escape') {
-            this.closeEdit();
-        }
-    }
-
-    private deleteUniqueID( value: string) : void {
-        const idFilter: string = 'uniqueIDFilterCollection';
-        delete this.parent[`${idFilter}`][`${value}`];
-        const id: string = 'uniqueIDCollection';
-        delete this.parent[`${id}`][`${value}`];
-    }
-
-    private cellEdit(args: CellEditArgs): Deferred | void {
-        const promise: string = 'promise';
-        const prom: Deferred = args[`${promise}`];
-        delete args[`${promise}`];
-        if (this.parent.enableVirtualization && !isNullOrUndefined(this.prevAriaRowIndex) && this.prevAriaRowIndex !== '-1') {
-            args.row.setAttribute('aria-rowindex', this.prevAriaRowIndex);
-            this.prevAriaRowIndex = undefined;
-        }
-        if (this.keyPress !== 'enter') {
-            this.parent.trigger(events.cellEdit, args, (celleditArgs: CellEditArgs) => {
-                if (!celleditArgs.cancel && this.parent.editSettings.mode === 'Cell') {
-                    this.enableToolbarItems('edit');
-                } else if (celleditArgs.cancel && this.parent.editSettings.mode === 'Cell') {
-                    this.isOnBatch = false;
-                    this.updateGridEditMode('Normal');
-                }
-                if (!isNullOrUndefined(prom)) {
-                    prom.resolve(celleditArgs);
-                }
-            });
-        }
-        if (this.doubleClickTarget && (this.doubleClickTarget.classList.contains('e-treegridexpand') ||
-      this.doubleClickTarget.classList.contains('e-treegridcollapse') || this.doubleClickTarget.classList.contains('e-summarycell'))) {
-            args.cancel = true; this.doubleClickTarget = null;
-            return;
-        }
-        if (this.parent.editSettings.mode === 'Cell') {
-            if (this.keyPress === 'tab' || this.keyPress === 'shiftTab') {
-                this.keyPress = null;
-            } else if (this.keyPress === 'enter') {
-                args.cancel = true;
-                this.keyPress = null;
-                setValue('isEditCollapse', false, this.parent);
-            }
-            if (!args.columnObject.allowEditing) {
-                args.cancel = true;
-            }
-        }
-        if (this.parent.enableVirtualization) {
-            this.parent.grid.contentModule['editedRowIndex'] = this.parent.grid.editModule.editModule['index'];
-        }
-    // if (this.isAdd && this.parent.editSettings.mode === 'Batch' && !args.cell.parentElement.classList.contains('e-insertedrow')) {
-    //   this.isAdd = false;
-    // }
-    }
-
-    private enableToolbarItems(request: string): void {
-        if (!isNullOrUndefined(this.parent.grid.toolbarModule)) {
-            const toolbarID: string = this.parent.element.id  + '_gridcontrol_';
-            this.parent.grid.toolbarModule.enableItems([toolbarID + 'add', toolbarID + 'edit', toolbarID + 'delete'], request === 'save');
-            this.parent.grid.toolbarModule.enableItems([toolbarID + 'update', toolbarID + 'cancel'], request === 'edit' );
-        }
-    }
-
-    private batchCancel(): void {
-        if (this.parent.editSettings.mode === 'Cell') {
-            const cellDetails: RowInfo = getValue('editModule.cellDetails', this.parent.grid.editModule);
-            if (!isNullOrUndefined(this.editedRowIndex)) {
-                cellDetails.rowIndex = this.editedRowIndex;
-            }
-            const treeCell: HTMLElement = this.parent.getCellFromIndex(cellDetails.rowIndex, this.parent.treeColumnIndex) as HTMLElement;
-            this.parent.renderModule.cellRender({
-                data: cellDetails.rowData,
-                cell: treeCell,
-                column: this.parent.grid.getColumns()[this.parent.treeColumnIndex]
-            });
-            this.updateGridEditMode('Normal');
-            this.isOnBatch = false;
-        }
-        if (this.parent.editSettings.mode === 'Batch') {
-            this.parent.notify('batchCancelAction', {});
-        }
-    }
-
-
-    private customCellSave(args: ActionEventArgs): void {
-        if (isCountRequired(this.parent) && this.parent.editSettings.mode === 'Cell' && args.action === 'edit') {
-            this.updateCell(args, args.rowIndex);
-            this.afterCellSave(args, args.row as HTMLTableRowElement);
-        }
-    }
-
-    private cellSave(args: CellSaveArgs): void {
-        if (this.parent.editSettings.mode === 'Cell' && this.parent.element.querySelector('form')) {
-            args.cancel = true;
-            const editModule: string = 'editModule';
-            setValue('isEditCollapse', true, this.parent);
-            args.rowData[args.columnName] = args.value;
-            let row: HTMLTableRowElement;
-            if (isNullOrUndefined(args.cell)) {
-                row = this.parent.grid.editModule[`${editModule}`].form.parentElement.parentNode;
-            } else {
-                row = <HTMLTableRowElement>args.cell.parentNode;
-            }
-            let rowIndex: number;
-            const primaryKeys: string[] = this.parent.getPrimaryKeyFieldNames();
-            if (isNullOrUndefined(row)) {
-                this.parent.grid.getCurrentViewRecords().filter((e: ITreeData, i: number) => {
-                    if (e[primaryKeys[0]] === args.rowData[primaryKeys[0]]) { rowIndex = i; return; }
-                });
-            } else {
-                const freeze: boolean = (this.parent.getFrozenLeftColumnsCount() > 0 ||
-                                         this.parent.getFrozenRightColumnsCount() > 0 ) ? true : false;
-                if (freeze) {
-                    if (this.parent.getRows().indexOf(row) !== -1) {
-                        rowIndex = this.parent.getRows().indexOf(row);
-                    } else {
-                        rowIndex = this.parent.getRows().indexOf(row);
-                    }
-                } else {
-                    rowIndex = (this.parent.getRows().indexOf(row) === -1 && (this.parent.getFrozenColumns() > 0)) ?
-                        this.parent.grid.getRows().indexOf(row) : this.parent.getRows().indexOf(row);
-                }
-            }
-            const arg: CellSaveEventArgs = {};
-            extend(arg, args);
-            arg.cancel = false;
-            arg.type = 'save';
-            row = <HTMLTableRowElement>this.parent.grid.getRows()[row.rowIndex];
-            this.parent.trigger(events.actionBegin, arg);
-            if (!arg.cancel) {
-                if ((row.rowIndex === this.parent.getCurrentViewRecords().length - 1) && this.keyPress === 'tab') {
-                    this.isTabLastRow = true;
-                }
-                if (!isRemoteData(this.parent) &&
-                !(this.parent.dataSource instanceof DataManager && this.parent.dataSource.adaptor instanceof RemoteSaveAdaptor )) {
-                    if (isCountRequired(this.parent)) {
-                        const eventPromise: string = 'eventPromise';
-                        const editArgs: ActionEventArgs = { requestType : 'save', data : args.rowData, action : 'edit', row : row,
-                            rowIndex : rowIndex, rowData : args.rowData, columnName : args.columnName,
-                            filterChoiceCount: null, excelSearchOperator: null };
-                        this.parent.grid.getDataModule()[`${eventPromise}`](editArgs, this.parent.grid.query);
-                    } else {
-                        this.updateCell(args, rowIndex);
-                        setValue('isEdit', false, this.parent.grid);
-                        this.afterCellSave(args, row);
-                    }
-                } else if (isRemoteData(this.parent) ||
-                       (this.parent.dataSource instanceof DataManager && this.parent.dataSource.adaptor instanceof RemoteSaveAdaptor )) {
-                    const query: Query = this.parent.grid.query;
-                    if (this.parent['isGantt'] && this.parent.loadChildOnDemand) {
-                        this.updateCell(args, rowIndex);
-                        setValue('isEdit', false, this.parent.grid);
-                        this.afterCellSave(args, row);
-                    }
-                    else {
-                        let crud: Promise<Object> = null;
-                        crud = <Promise<Object>>(this.parent.grid.dataSource as DataManager).update(primaryKeys[0], args.rowData,
-                                                                                                    query.fromTable,
-                                                                                                    query, args.previousValue);
-                        crud.then((e: Object) => {
-                            if (!isNullOrUndefined(e)) {
-                                args.rowData[args.columnName] = e[args.columnName];
-                            }
-                            this.updateCell(args, rowIndex);
-                            setValue('isEdit', false, this.parent.grid);
-                            this.afterCellSave(args, row);
-                        });
-                    }
-                }
-            } else {
-                this.parent.grid.isEdit = true;
-            }
-        }
-        if (this.parent.enableVirtualization) {
-            this.parent.grid.contentModule['virtualData'] = {};
-        }
-    }
-
-    private afterCellSave(args: CellSaveArgs, row: HTMLTableRowElement ): void {
-        if (this.parent.grid.aggregateModule) {
-            this.parent.grid.aggregateModule.refresh(args.rowData);
-        }
-        this.parent.grid.editModule.destroyWidgets([this.parent.grid.getColumnByField(args.columnName)]);
-        this.parent.grid.editModule.formObj.destroy();
-        if (this.keyPress !== 'tab' && this.keyPress !== 'shiftTab') {
-            this.updateGridEditMode('Normal');
-            this.isOnBatch = false;
-        }
-        this.enableToolbarItems('save');
-        removeClass([row], ['e-editedrow', 'e-batchrow']);
-        removeClass(row.querySelectorAll('.e-rowcell'), ['e-editedbatchcell', 'e-updatedtd']);
-        if (this.parent['isCellSaveFocus'] !== false) {
-            this.parent.grid.focusModule.restoreFocus();
-        }
-        editAction({ value: <ITreeData>args.rowData, action: 'edit' }, this.parent, this.isSelfReference,
-                   this.addRowIndex, this.selectedIndex, args.columnName);
-        if ((row.rowIndex === this.parent.getCurrentViewRecords().length - 1) && this.keyPress === 'enter') {
-            this.keyPress = null;
-        }
-        const saveArgs: CellSaveEventArgs = {
-            type: 'save', column: this.parent.getColumnByField(args.columnName), data: args.rowData,
-            previousData: args.previousValue, row: row, target: (args.cell as HTMLElement)
-        };
-        if (this.parent.aggregates.map((ag: AggregateRow) => ag.showChildSummary === true).length) {
-            this.parent.grid.refresh();
-        }
-        this.parent.trigger(events.actionComplete, saveArgs);
-    }
-
-    private lastCellTab(): void {
-        if (!this.parent.grid.isEdit && this.isOnBatch && this.keyPress === 'tab' && this.parent.editSettings.mode === 'Cell') {
-            if (!this.parent.editSettings.allowNextRowEdit) {
-                this.updateGridEditMode('Normal');
-                this.isOnBatch = false;
-                this.keyPress = null;
-            } else {
-                this.enableToolbarItems('edit');
-            }
-        }
-    }
-
-    private updateCell(args: CellSaveArgs, rowIndex: number): void {
-        this.parent.grid.editModule.updateCell(rowIndex, args.columnName, args.rowData[args.columnName]);
-        this.parent.grid.getRowsObject()[parseInt(rowIndex.toString(), 10)].data = args.rowData;
-    }
-    private crudAction(details: { value: ITreeData, action: string }, columnName?: string): void {
-        editAction(details, this.parent, this.isSelfReference, this.addRowIndex, this.selectedIndex, columnName, this.addRowRecord);
-        this.parent.parentData = [];
-        const data: Object = this.parent.grid.dataSource instanceof DataManager ?
-            this.parent.grid.dataSource.dataSource.json : this.parent.grid.dataSource;
-        for (let i: number = 0; i < (<Object[]>data).length; i++) {
-            data[parseInt(i.toString(), 10)].index = i;
-            const key: string = this.parent.grid.getPrimaryKeyFieldNames()[0];
-            if (details.value[`${key}`] === data[parseInt(i.toString(), 10)][`${key}`]) {
-                if (details.action === 'add') {
-                    data[parseInt(i.toString(), 10)].level = this.internalProperties.level;
-                    data[parseInt(i.toString(), 10)].taskData = this.internalProperties.taskData;
-                    data[parseInt(i.toString(), 10)].uniqueID = this.internalProperties.uniqueID;
-                    if (!isNullOrUndefined(this.internalProperties.parentItem)) {
-                        data[parseInt(i.toString(), 10)].parentItem = this.internalProperties.parentItem;
-                        data[parseInt(i.toString(), 10)].parentUniqueID = this.internalProperties.parentUniqueID;
-                    }
-                    data[parseInt(i.toString(), 10)].childRecords = this.internalProperties.childRecords;
-                }
-            }
-            setValue('uniqueIDCollection.' + data[parseInt(i.toString(), 10)].uniqueID + '.index', i, this.parent);
-            const adaptor: AdaptorOptions = (this.parent.dataSource as DataManager).adaptor;
-            if ((isRemoteData(this.parent) || adaptor instanceof RemoteSaveAdaptor)) {
-                setValue('uniqueIDCollection.' + data[parseInt(i.toString(), 10)].uniqueID, data[parseInt(i.toString(), 10)], this.parent);
-            }
-            if (!data[parseInt(i.toString(), 10)].level) {
-                this.parent.parentData.push(data[parseInt(i.toString(), 10)]);
-            }
-        }
-        if (!this.parent.enableInfiniteScrolling) {
-            if (details.action === 'add' && this.previousNewRowPosition != null) {
-                this.parent.setProperties({editSettings: {newRowPosition:  this.previousNewRowPosition}}, true);
-                this.previousNewRowPosition = null;
-            }}
-    }
-    private updateIndex (data: Object, rows: Object, records: Object): void {
-        for (let j: number = 0; j < this.parent.getDataRows().length; j++ ) {
-            const data1: ITreeData = records[parseInt(j.toString(), 10)];
-            if (!isNullOrUndefined(data1)) {
-                const index: number = getValue('uniqueIDCollection.' + data1.uniqueID + '.index', this.parent);
-                data1.index = index;
-                if (!isNullOrUndefined(data1.parentItem)) {
-                    const parentIndex: number = getValue('uniqueIDCollection.' + data1.parentItem.uniqueID + '.index', this.parent);
-                    data1.parentItem.index = parentIndex;
-                }
-            }
-        }
-        let count: number = -1;
-        let treeColIndex: number = this.parent.treeColumnIndex;
-        if (this.parent.getFrozenColumns() > 0) {
-            const cells: NodeListOf<Element> = (rows[0] as Element).querySelectorAll('.e-rowcell');
-            for (let l: number = 0; l < cells.length; l++) {
-                if (cells[parseInt(l.toString(), 10)].classList.contains('e-gridrowindex0level0')) {
-                    treeColIndex = l;
-                    break;
-                }
-            }
-        }
-        for (let k: number = 0; k < this.parent.getRows().length; k++) {
-            if (!rows[parseInt(k.toString(), 10)].classList.contains('e-detailrow')) {
-                count++;
-            }
-            const data2: ITreeData = records[parseInt(count.toString(), 10)];
-            if (!isNullOrUndefined(data2)) {
-                let index: number = data2.index;
-                const level: number = data2.level;
-                const row: Element = rows[parseInt(k.toString(), 10)];
-                if (!isNullOrUndefined(data2.parentItem)) {
-                    index = getValue('uniqueIDCollection.' + data2.parentItem.uniqueID + '.index', this.parent);
-                }
-                const treecell: HTMLElement = (row as HTMLTableRowElement).cells[parseInt(treeColIndex.toString(), 10)];
-                if (!isNullOrUndefined(treecell)) {
-                    for (let l: number = 0; l < treecell.classList.length; l++) {
-                        const value: string = treecell.classList[parseInt(l.toString(), 10)];
-                        const remove: RegExp = /e-gridrowindex/i;
-                        const removed: RegExp = /e-griddetailrowindex/i;
-                        const result: RegExpMatchArray = value.match(remove);
-                        const results: RegExpMatchArray = value.match(removed);
-                        if (result != null) {
-                            removeClass([treecell], value);
-                        }
-                        if (results != null) {
-                            removeClass([treecell], value);
-                        }
-                    }
-                    if (!rows[parseInt(k.toString(), 10)].classList.contains('e-detailrow')) {
-                        addClass([treecell], 'e-gridrowindex' + index + 'level' + level);
-                    }else {
-                        addClass([treecell], 'e-griddetailrowindex' + index + 'level' + level);
-                    }
-                }
-            }
-        }
-    }
-    private beginAdd(): void {
-        let position: string;
-        let index: number = this.addRowIndex;
-        let records: Object[] = this.parent.grid.getCurrentViewRecords();
-        if (this.parent.editSettings.mode === 'Batch') {
-            index = this.batchEditModule.getAddRowIndex();
-            this.selectedIndex = this.batchEditModule.getSelectedIndex();
-            if (this.parent.getBatchChanges()[this.addedRecords].length > 1
-              || this.parent.getBatchChanges()[this.deletedRecords].length) {
-                records = this.batchEditModule.getBatchRecords();
-            }
-        }
-        const rows: Element[] = this.parent.grid.getDataRows();
-        const firstAriaIndex: number = rows.length ? +rows[0].getAttribute('aria-rowindex') - 1 : 0;
-        const lastAriaIndex: number = rows.length ? +rows[rows.length - 1].getAttribute('aria-rowindex') - 1 : 0;
-        const withinRange: boolean = this.selectedIndex >= firstAriaIndex && this.selectedIndex <= lastAriaIndex;
-        const isVirtualization: boolean = this.parent.enableVirtualization && this.addRowIndex > -1 && this.prevAriaRowIndex !== '-1';
-        if (this.parent.editSettings.mode !== 'Dialog') {
-            if (this.parent.editSettings.newRowPosition === 'Above') {
-                position = 'before';
-            } else if ((this.parent.editSettings.newRowPosition === 'Below' || this.parent.editSettings.newRowPosition === 'Child')
-                  && (this.selectedIndex > -1 || isVirtualization) && withinRange) {
-                position = 'after';
-                if (!isNullOrUndefined(records[parseInt(index.toString(), 10)]) &&
-                 (records[parseInt(index.toString(), 10)] as ITreeData).expanded) {
-                    if (this.parent.editSettings.mode === 'Batch' && (this.parent.getBatchChanges()[this.addedRecords].length > 1
-                || this.parent.getBatchChanges()[this.deletedRecords].length)) {
-                        index += findChildrenRecords(records[parseInt(index.toString(), 10)]).length;
-                        if (this.parent.editSettings.newRowPosition !== 'Child') {
-                            const batchChildCount: number = this.batchEditModule.getBatchChildCount();
-                            index = index + batchChildCount;
-                        }
-                    } else if (!this.parent.enableVirtualization) {
-                        index += findChildrenRecords(records[parseInt(index.toString(), 10)]).length;
-                    }
-                }
-            }
-            if ((this.selectedIndex > -1 || isVirtualization) && withinRange
-          && (index || (this.parent.editSettings.newRowPosition === 'Child'
-          || this.parent.editSettings.newRowPosition === 'Below'))) {
-                if (index >= rows.length - 1) {
-                    index = rows.length - 2;
-                }
-                const r: string = 'rows';
-                const newRowObject: Row<Column> =  this.parent.grid.contentModule[`${r}`][0];
-                const focussedElement: HTMLInputElement = <HTMLInputElement>document.activeElement;
-                rows[index + 1][`${position}`](rows[0]);
-                setValue('batchIndex', index + 1, this.batchEditModule);
-                const rowObjectIndex: number = this.parent.editSettings.newRowPosition  === 'Above' ? index : index + 1;
-                if (this.parent.editSettings.mode === 'Batch') {
-                    this.parent.grid.contentModule[`${r}`].splice(0, 1);
-                    this.parent.grid.contentModule[`${r}`].splice(rowObjectIndex, 0, newRowObject);
-                }
-                if (this.parent.editSettings.mode === 'Row' || this.parent.editSettings.mode === 'Cell') {
-                    const errors: NodeListOf<Element> = this.parent.grid.getContentTable().querySelectorAll('.e-griderror');
-                    for (let i: number = 0; i < errors.length; i++) {
-                        errors[parseInt(i.toString(), 10)].remove();
-                    }
-                    setValue('errorRules', [], this.parent.grid.editModule.formObj);
-                }
-                if (isVirtualization) {
-                    this.prevAriaRowIndex = '-1';
-                }
-                if (!this.parent.enableVirtualization || this.parent.enableVirtualization) {
-                    this.isScrollByFocus = true;
-                    focussedElement.focus();
-                }
-                if (this.parent.enableVirtualization && !Object.keys(this.parent.grid.contentModule['emptyRowData']).length) {
-                    this.parent.grid.contentModule['createEmptyRowdata']();
-                }
-            }
-        }
-        if (this.parent.editSettings.mode === 'Batch' && !isNullOrUndefined(this.addRowIndex) && this.addRowIndex !== -1 && this['isAddedRowByMethod'] && !this.isAddedRowByContextMenu) {
-            index = this.batchEditModule.getAddRowIndex();
-            this.selectedIndex = this.batchEditModule.getSelectedIndex();
-            const batchAddedRecords: ITreeData[] = this.parent.getBatchChanges()['addedRecords'];
-            let newlyAddedRecord: ITreeData;
-            if (batchAddedRecords.length) {
-                for (let i: number = 0; i < batchAddedRecords.length; i++) {
-                    if (isNullOrUndefined(batchAddedRecords[parseInt(i.toString(), 10)].uniqueID)) {
-                        newlyAddedRecord = batchAddedRecords[parseInt(i.toString(), 10)];
-                    }
-                }
-            }
-            const args: Object = {
-                action : 'add',
-                data: newlyAddedRecord,
-                index: index,
-                seletedRow: 0
-            };
-            this.beginAddEdit(args);
-            this.batchEditModule['batchAddRowRecord'].push(this.batchEditModule['addRowRecord']);
-            this.batchEditModule['batchAddedRecords'].push(args['data']);
-        }
-    }
-    // private beforeDataBound(args: BeforeDataBoundArgs): void {
-    //   if (this.parent.grid.isEdit && this.parent.dataSource instanceof DataManager &&
-    //         this.parent.dataSource.adaptor instanceof RemoteSaveAdaptor) {
-    //     let action: string = getValue('action', args);
-    //     let data: Object = getValue('data', args);
-    //     if (action === 'edit' && !isNullOrUndefined(this.editedData)) {
-    //       data = extend(this.editedData, data);
-    //       this.editedData = null;
-    //     }
-    //     if (!isNullOrUndefined(this.addedData)) {
-    //       let addedData: Object = args.result[args.result.length - 1];
-    //       addedData = extend(this.addedData, addedData);
-    //       this.addedData = null;
-    //       args.result.splice(this.addedIndex, 0, addedData);
-    //       args.result.splice(args.result.length, 1);
-    //     }
-    //   }
-    // }
-    private beginEdit(args: SaveEventArgs): void {
-        if (args.requestType === 'refresh' && this.isOnBatch) {
-            args.cancel = true; return;
-        }
-        if (this.parent.editSettings.mode === 'Cell' && args.requestType === 'beginEdit') {
-            args.cancel = true; return;
-        }
-        if (this.doubleClickTarget && args.requestType !== 'delete' && (this.doubleClickTarget.classList.contains('e-treegridexpand') ||
-            this.doubleClickTarget.classList.contains('e-treegridcollapse') || this.doubleClickTarget.classList.contains('e-frame'))) {
-            args.cancel = true; this.doubleClickTarget = null;
-            return;
-        }
-        if (args.requestType === 'delete') {
-            const data: ITreeData[] = <ITreeData[]>args.data;
-            if (isNullOrUndefined((args.data[0] as ITreeData).uniqueID)) {
-                const primaryKeys: string[] = this.parent.getPrimaryKeyFieldNames();
-                for (let i: number = 0; i < data.length; i++) {
-                    this.parent.flatData.filter((e: ITreeData) => {
-                        if (e[`${primaryKeys[0]}`] === args.data[parseInt(i.toString(), 10)][primaryKeys[0]]) {
-                            data[parseInt(i.toString(), 10)] = e;
-                        }
-                    });
-                }
-            }
-            for (let i: number = 0; i < data.length; i++) {
-                this.deleteUniqueID(data[parseInt(i.toString(), 10)].uniqueID);
-                const childs: ITreeData[] = findChildrenRecords(data[parseInt(i.toString(), 10)]);
-                for (let c: number = 0; c < childs.length; c++) {
-                    this.deleteUniqueID(childs[parseInt(c.toString(), 10)].uniqueID);
-                }
-                args.data = [...args.data as object[], ...childs];
-            }
-        }
-        if (args.requestType === 'add' || (this.isAddedRowByMethod && (this.parent.enableVirtualization || this.parent.enableInfiniteScrolling))) {
-            if (!(this.parent.grid.selectedRowIndex === -1 && this.isAddedRowByMethod)
-            && args.index === this.parent.grid.selectedRowIndex || args.index === 0 ) {
-                this.selectedIndex = this.parent.grid.selectedRowIndex;
-            }
-            if (this.parent.enableVirtualization) {
-                let selector: string = '.e-row[aria-rowindex="' + (this.selectedIndex + 1) + '"]';
-                let row: HTMLTableRowElement;
-                if (this.selectedIndex > -1 && this.parent.editSettings.newRowPosition !== 'Top' &&
-                  this.parent.editSettings.newRowPosition !== 'Bottom') {
-                    this.prevAriaRowIndex = this.selectedIndex.toString();
-                    row = <HTMLTableRowElement>this.parent.getContent().querySelector(selector);
-                    this.addRowIndex = row ? row.rowIndex : 0;
-                } else {
-                    if (this.prevAriaRowIndex && this.prevAriaRowIndex !== '-1') {
-                        selector = '.e-row[aria-rowindex="' + (this.prevAriaRowIndex + 1) + '"]';
-                        row = <HTMLTableRowElement>this.parent.getContent().querySelector(selector);
-                        this.addRowIndex = row ? row.rowIndex : 0;
-                    } else {
-                        this.addRowIndex = 0;
-                    }
-                }
-            } else {
-                if (this.isAddedRowByMethod && (this.parent.enableVirtualization || this.parent.enableInfiniteScrolling)) {
-                    if (args.index !== 0) {
-                        this.addRowIndex = args.index;
-                    } else {
-                        this.addRowIndex = this.parent.grid.selectedRowIndex;
-                    }
-                } else {
-                    this.addRowIndex = this.parent.grid.selectedRowIndex > -1 ? this.parent.grid.selectedRowIndex : 0;
-                }
-            }
-            const selectedRecords: any = this.parent.getSelectedRecords()[0];
-            if ((this.isAddedRowByMethod || (this.isAddedRowByContextMenu && this.parent.grid.selectedRowIndex !== -1)) &&
-                (this.parent.enableVirtualization || this.parent.enableInfiniteScrolling)) {
-                this.addRowRecord = this.parent.flatData[this.parent.grid.selectedRowIndex];
-                if (this.parent.enableVirtualization && this.isAddedRowByContextMenu) {
-                    this.addRowRecord = this.parent.getCurrentViewRecords()[this.addRowIndex];
-                }
-            }
-            else if (!isNullOrUndefined(selectedRecords)) {
-                this.addRowRecord = selectedRecords;
-            }
-        }
-        if (this.isAddedRowByMethod && args.index !== 0) {
-            this.addRowRecord = this.parent.flatData[args.index];
-            this.addRowIndex = args.index;
-        }
-        if (this.parent.editSettings.newRowPosition === 'Child' && this.isIndexUndefined &&
-            !isNullOrUndefined(this.parent.getSelectedRecords()[0])) {
-            this.addRowRecord = this.parent.getSelectedRecords()[0];
-            this.isIndexUndefined = false;
-        }
-        if (isNullOrUndefined(this.addRowRecord) && this.parent.getCurrentViewRecords().length > this.addRowIndex &&
-            args.requestType === 'save' && this.parent.getSelectedRecords().length !== 0)
-        {
-            this.addRowRecord = this.parent.getCurrentViewRecords()[this.addRowIndex];
-        }
-        this.isAddedRowByMethod = false;
-        args = this.beginAddEdit(args);
-        // if (args.requestType === 'save' &&
-        //    ((this.parent.dataSource instanceof DataManager && this.parent.dataSource.adaptor instanceof RemoteSaveAdaptor))) {
-        //      if (args.action === 'edit') {
-        //           this.editedData = args.data;
-        //      } else if (args.action === 'add') {
-        //           this.addedData = value;
-        //      }
-
-        // }
-    }
-    private savePreviousRowPosition(): void {
-        if (this.previousNewRowPosition === null) {
-            this.previousNewRowPosition = this.parent.editSettings.newRowPosition;
-        }
-    }
-    private beginAddEdit(args: SaveEventArgs): SaveEventArgs {
-        const value: ITreeData = args.data;
-        if (args.action === 'add') {
-            const key: string = this.parent.grid.getPrimaryKeyFieldNames()[0];
-            let position: string = null;
-            value.taskData = isNullOrUndefined(value.taskData) ? extend({}, args.data) : value.taskData;
-            let currentData: ITreeData[];
-
-            if (this.parent.enableVirtualization && args.index !== 0) {
-                currentData = this.parent.flatData;
-            }
-            else if (this.parent.editSettings.mode === 'Batch' && this['isAddedRowByMethod'] && !isNullOrUndefined(this.addRowIndex)) {
-                currentData = this.batchEditModule['batchRecords'];
-            }
-            else {
-                currentData = <ITreeData[]>this.parent.grid.getCurrentViewRecords();
-            }
-            if (this.parent.enableVirtualization && args.index !== 0) {
-                this.addRowIndex = this.parent.flatData.indexOf( this.addRowRecord);
-                this.selectedIndex = this.addRowIndex;
-            }
-            let index: number =  this.addRowIndex;
-            value.uniqueID = getUid(this.parent.element.id + '_data_');
-            setValue('uniqueIDCollection.' +  value.uniqueID , value, this.parent);
-            let level: number = 0; let idMapping: Object;
-            let parentUniqueID: string; let parentItem: Object; let parentIdMapping: string;
-            const isVirtualization: boolean = this.parent.enableVirtualization && this.addRowIndex > -1 && this.prevAriaRowIndex !== '-1';
-            const rows: HTMLTableRowElement[] = this.parent.getRows();
-            const firstAriaIndex: number = rows.length ? currentData.indexOf(currentData[0]) : 0;
-            const lastAriaIndex: number = rows.length ? +rows[rows.length - 1].getAttribute('aria-rowindex') - 1 : 0;
-            const withinRange: boolean = this.parent.enableVirtualization && args.index !== 0 ? true :
-                this.selectedIndex >= firstAriaIndex && this.selectedIndex <= lastAriaIndex;
-            if (currentData.length && !isNullOrUndefined(index)) {
-                idMapping = currentData[this.addRowIndex][this.parent.idMapping];
-                parentIdMapping = currentData[this.addRowIndex][this.parent.parentIdMapping];
-                if (currentData[this.addRowIndex].parentItem) {
-                    parentUniqueID = currentData[this.addRowIndex].parentItem.uniqueID;
-                }
-                parentItem = currentData[this.addRowIndex].parentItem;
-            }
-            if (this.parent.editSettings.newRowPosition !== 'Top' && currentData.length && !isNullOrUndefined(index)) {
-                level = currentData[this.addRowIndex].level;
-                if (this.parent.editSettings.newRowPosition === 'Above') {
-                    position = 'before'; index = currentData[this.addRowIndex].index;
-                } else if (this.parent.editSettings.newRowPosition === 'Below') {
-                    position = 'after';
-                    const childRecordCount: number = findChildrenRecords(currentData[this.addRowIndex]).length;
-                    const currentDataIndex: number = currentData[this.addRowIndex].index;
-                    index = (childRecordCount > 0) ? ( currentDataIndex + childRecordCount) : (currentDataIndex);
-                } else if (this.parent.editSettings.newRowPosition === 'Child') {
-                    position = 'after';
-                    if ((this.selectedIndex > -1 || isVirtualization) && withinRange) {
-                        value.parentItem = extend({}, currentData[this.addRowIndex]);
-                        value.parentUniqueID = value.parentItem.uniqueID;
-                        delete value.parentItem.childRecords; delete value.parentItem[this.parent.childMapping];
-                    }
-                    const childRecordCount1: number = findChildrenRecords(currentData[this.addRowIndex]).length;
-                    const currentDataIndex1: number = currentData[this.addRowIndex].index;
-                    if (this.selectedIndex >= 0) {
-                        value.level = level + 1;
-                    }
-                    index = (childRecordCount1 > 0) ? ( currentDataIndex1 + childRecordCount1) : (currentDataIndex1);
-                    if (this.isSelfReference) {
-                        if (!this.parent.isLocalData && this.parent.editModule.selectedIndex === -1) {
-                            value.taskData[this.parent.parentIdMapping] = value[this.parent.parentIdMapping] = null;
-                        }
-                        else {
-                            value.taskData[this.parent.parentIdMapping] = value[this.parent.parentIdMapping] = idMapping;
-                        }
-                        if (!isNullOrUndefined(value.parentItem)) {
-                            updateParentRow(key, value.parentItem, 'add', this.parent, this.isSelfReference, value);
-                        }
-                    }
-                }
-                if (this.parent.editSettings.newRowPosition === 'Above' || this.parent.editSettings.newRowPosition === 'Below') {
-                    if ((this.selectedIndex > -1 || isVirtualization) && level && withinRange) {
-                        value.parentUniqueID = parentUniqueID; value.parentItem = extend({}, parentItem);
-                        delete value.parentItem.childRecords; delete value.parentItem[this.parent.childMapping];
-                    }
-                    value.level = level;
-                    if (this.isSelfReference) {
-                        value.taskData[this.parent.parentIdMapping] = value[this.parent.parentIdMapping] = parentIdMapping;
-                        if (!isNullOrUndefined(value.parentItem)) {
-                            updateParentRow(key, value.parentItem, 'add', this.parent, this.isSelfReference, value);
-                        }
-                    }
-                }
-                if (position != null && (this.selectedIndex > -1 || isVirtualization) && withinRange) {
-                    args.index = position === 'before' ? index : index + 1;
-                }
-                if (this.parent.editSettings.newRowPosition === 'Bottom') {
-                    level = 0;
-                    const dataSource: Object[] = <Object[]>(this.parent.grid.dataSource instanceof DataManager ?
-                        this.parent.grid.dataSource.dataSource.json : this.parent.grid.dataSource);
-                    args.index = dataSource.length;
-                }
-            }
-            if (isNullOrUndefined(value.level)) {
-                value.level = level;
-            }
-            value.hasChildRecords = false; value.childRecords = []; value.index = 0;
-        }
-        if (args.action === 'add') {
-            this.internalProperties = { level: value.level, parentItem: value.parentItem, uniqueID: value.uniqueID,
-                taskData: value.taskData, parentUniqueID: isNullOrUndefined(value.parentItem) ? undefined : value.parentItem.uniqueID,
-                childRecords: value.childRecords };
-        }
-        if (args.requestType === 'delete') {
-            const deletedValues: ITreeData[] = args.data as Object[];
-            const primaryKeyField: string[] = this.parent.getPrimaryKeyFieldNames();
-            if (!isNullOrUndefined(primaryKeyField) && primaryKeyField.length > 0) {
-                for (let i: number = 0; i < deletedValues.length; i++) {
-                    const deletevalue: any = deletedValues[parseInt(i.toString(), 10)].parentItem;
-                    if (deletevalue) {
-                        const parentItem: ITreeData = getParentData(this.parent, deletevalue.uniqueID);
-                        if (!isNullOrUndefined(parentItem) && parentItem.hasChildRecords) {
-                            const childIndex: number = parentItem.childRecords.findIndex((child: any) =>
-                                (deletedValues[parseInt(i.toString(), 10)] as any)[primaryKeyField[0]] === child[primaryKeyField[0]]);
-                            parentItem.childRecords.splice(childIndex, 1);
-                        }
-                    }
-                }
-            }
-        }
-        return args;
-    }
-
-
-    /**
-     * If the data,index and position given, Adds the record to treegrid rows otherwise it will create edit form.
-     *
-     * @returns {void}
-     */
-
-    public addRecord(data?: Object, index?: number, position?: RowPosition): void {
-        if (this.parent.editSettings.newRowPosition === this.previousNewRowPosition || this.previousNewRowPosition === null) {
-            this.previousNewRowPosition = this.parent.editSettings.newRowPosition;
-        }
-        if (isNullOrUndefined(index)) {
-            this.isIndexUndefined = true;
-        }
-        if (!this.isSelfReference && !isNullOrUndefined(data) && Object.hasOwnProperty.call(data, this.parent.childMapping)) {
-            const addRecords: ITreeData[] = [];
-            const previousEditMode: string = this.parent.editSettings.mode;
-            const previousGridEditMode: string = this.parent.grid.editSettings.mode;
-            addRecords.push(data);
-            this.parent.setProperties({ editSettings: { mode: 'Batch' } }, true);
-            this.parent.grid.setProperties({ editSettings: { mode: 'Batch' } }, true);
-            if (!isNullOrUndefined(position)) { this.parent.setProperties({ editSettings: { newRowPosition: position } }, true); }
-            const updatedRecords: BatchChanges = { addedRecords: addRecords, changedRecords: [], deletedRecords: [] };
-            this.parent.notify(events.batchSave, { updatedRecords, index });
-            this.parent.setProperties({ editSettings: { mode: previousEditMode } }, true);
-            this.parent.grid.setProperties({ editSettings: { mode: previousGridEditMode } }, true);
-            this.parent.refresh();
-        }
-        else {
-            if (data) {
-                if (index > -1) {
-                    this.selectedIndex = index;
-                    this.addRowIndex = index;
-                } else {
-                    this.selectedIndex = this.parent.selectedRowIndex;
-                    this.addRowIndex = this.parent.selectedRowIndex;
-                }
-                if (position) {
-                    this.parent.setProperties({ editSettings: { newRowPosition: position } }, true);
-                }
-                this.parent.grid.editModule.addRecord(data, index);
-            } else {
-                this.parent.grid.editModule.addRecord(data, index);
-            }
-        }
-    }
-
-    /**
-     * Checks the status of validation at the time of editing. If validation is passed, it returns true.
-     *
-     * @returns {boolean} Returns form validation results
-     */
-    public editFormValidate(): boolean {
-        return this.parent.grid.editModule.editFormValidate();
-    }
-
-    /**
-     * @hidden
-     * @returns {void}
-     */
-    public destroyForm(): void {
-        this.parent.grid.editModule.destroyForm();
-    }
-
-    private contentready (e: { rows: Row<Column>[], args?: NotifyArgs }): void {
-        if (!isNullOrUndefined(e.args.requestType)
-      && (e.args.requestType.toString() === 'delete' || e.args.requestType.toString() === 'save'
-        || (this.parent.editSettings.mode === 'Batch' && e.args.requestType.toString() === 'batchsave'))) {
-            this.updateIndex(this.parent.grid.dataSource, this.parent.getRows(), this.parent.getCurrentViewRecords());
-            if (this.parent.frozenRows || this.parent.getFrozenColumns() || this.parent.frozenColumns) {
-                if ((this.parent.grid.dataSource as Object[]).length === this.parent.getDataRows().length) {
-                    this.updateIndex(this.parent.grid.dataSource, this.parent.getDataRows(), this.parent.getCurrentViewRecords());
-                }
-            }
-        }
-    }
-
-    /**
-     * If the row index and field is given, edits the particular cell in a row.
-     *
-     * @returns {void}
-     */
-
-    public editCell(rowIndex?: number, field?: string): void {
-        if (this.parent.editSettings.mode === 'Cell' || this.parent.editSettings.mode === 'Batch') {
-            if (this.parent.editSettings.mode !== 'Batch') {
-                this.isOnBatch = true;
-                this.updateGridEditMode('Batch');
-            }
-            this.parent.grid.editModule.editCell(rowIndex, field);
-        }
-    }
-
-    /**
-     * Cancels edited state.
-     *
-     * @returns {void}
-     */
-    private closeEdit(): void {
-        if (this.parent.enableVirtualization && this.parent.grid.editSettings.mode === 'Batch' && this.parent.grid.pageSettings.currentPage > 1) {
-            this.editedRowIndex = this.parent.grid.editModule.editModule['cellDetails'].rowIndex;
-            this.parent.grid.editModule.editModule['cellDetails'].rowIndex = parseInt(this.parent.getRows()[this.parent.grid.editModule.editModule['cellDetails'].rowIndex].getAttribute('aria-rowIndex'), 10) - 1;
-        }
-        this.parent.grid.editModule.closeEdit();
-    }
-}