@syncfusion/ej2-treegrid 30.1.38 → 31.1.17

package/dist/ts/treegrid/base/data.ts

@@ -0,0 +1,904 @@
+import { extend, isNullOrUndefined, setValue, getValue, addClass, removeClass } from '@syncfusion/ej2-base';
+import { DataManager, Query, Group, DataUtil, QueryOptions, ReturnOption, ParamOption } from '@syncfusion/ej2-data';
+import { ITreeData, RowExpandedEventArgs } from './interface';
+import { TreeGrid } from './treegrid';
+import { showSpinner, hideSpinner } from '@syncfusion/ej2-popups';
+import { getObject, BeforeDataBoundArgs, VirtualContentRenderer, getUid, Row, Column } from '@syncfusion/ej2-grids';
+import { ColumnModel as GridColumnModel, NotifyArgs, SaveEventArgs, Action, VirtualInfo } from '@syncfusion/ej2-grids';
+import { isRemoteData, isOffline, isCountRequired, getExpandStatus } from '../utils';
+import * as events from './constant';
+
+/**
+ * Internal dataoperations for tree grid
+ *
+ * @hidden
+ */
+export class DataManipulation {
+    //Internal variables
+    private taskIds: Object[];
+    private parentItems: Object[];
+    private zerothLevelData: BeforeDataBoundArgs;
+    private storedIndex: number;
+    private batchChanges: Object;
+    private addedRecords: string = 'addedRecords';
+    private parent: TreeGrid;
+    private dataResults: ReturnOption;
+    private sortedData: Object[];
+    private hierarchyData: Object[];
+    private isSelfReference: boolean;
+    private isSortAction: boolean;
+    private infiniteScrollData: Object[];
+    constructor(grid: TreeGrid) {
+        this.parent = grid;
+        this.parentItems = [];
+        this.taskIds = [];
+        this.hierarchyData = [];
+        this.storedIndex = -1;
+        this.sortedData = [];
+        this.isSortAction = false;
+        this.addEventListener();
+        this.dataResults =  <ReturnOption>{};
+        this.isSelfReference = !isNullOrUndefined(this.parent.parentIdMapping);
+    }
+
+    /**
+     * @hidden
+     * @returns {void}
+     */
+    public addEventListener(): void {
+        this.parent.on('updateRemoteLevel', this.updateParentRemoteData, this);
+        this.parent.grid.on('sorting-begin', this.beginSorting, this);
+        this.parent.on('updateAction', this.updateData, this);
+        this.parent.on(events.remoteExpand, this.collectExpandingRecs, this);
+        this.parent.on('dataProcessor', this.dataProcessor, this);
+    }
+
+    /**
+     * @hidden
+     * @returns {void}
+     */
+    public removeEventListener(): void {
+        if (this.parent.isDestroyed) { return; }
+        this.parent.off(events.remoteExpand, this.collectExpandingRecs);
+        this.parent.off('updateRemoteLevel', this.updateParentRemoteData);
+        this.parent.off('updateAction', this.updateData);
+        this.parent.off('dataProcessor', this.dataProcessor);
+        this.parent.grid.off('sorting-begin', this.beginSorting);
+    }
+
+    /**
+     * To destroy the dataModule
+     *
+     * @returns {void}
+     * @hidden
+     */
+    public destroy(): void {
+        this.removeEventListener();
+    }
+
+    /**
+     * @hidden
+     * @returns {boolean} -Returns whether remote data binding
+     */
+    public isRemote(): boolean {
+        if (!(this.parent.dataSource instanceof DataManager)) {
+            return false;
+        }
+        return true;
+        // let gridData:  DataManager = <DataManager>this.parent.dataSource;
+        // return gridData.dataSource.offline !== true && gridData.dataSource.url !== undefined;
+    }
+
+    /**
+     * Function to manipulate datasource
+     *
+     * @param {Object} data - Provide tree grid datasource to convert to flat data
+     * @hidden
+     * @returns {void}
+     */
+    public convertToFlatData(data: Object): void {
+        this.parent.flatData = <Object[]>(!isNullOrUndefined(data) && Object.keys(data).length === 0
+            && !(this.parent.dataSource instanceof DataManager) ?
+            this.parent.dataSource : []);
+        this.parent.parentData = [];
+        if ((isRemoteData(this.parent) && !isOffline(this.parent)) && data instanceof DataManager && !(data instanceof Array)) {
+            const dm: DataManager = <DataManager>this.parent.dataSource;
+            if (this.parent.parentIdMapping) {
+                this.parent.query = isNullOrUndefined(this.parent.query) ?
+                    new Query() : this.parent.query;
+                if (this.parent.parentIdMapping) {
+                    const filterKey: Object[] = this.parent.query.params.filter((param: ParamOption) => param.key === 'IdMapping');
+                    if (this.parent.initialRender && !filterKey.length) {
+                        this.parent.query.where(this.parent.parentIdMapping, 'equal', null);
+                        this.parent.query.addParams('IdMapping', this.parent.idMapping);
+                    }
+                }
+                if (!this.parent.hasChildMapping) {
+                    let qry: Query = this.parent.query.clone();
+                    qry.queries = [];
+                    qry = qry.select([this.parent.parentIdMapping]);
+                    qry.isCountRequired = true;
+                    dm.executeQuery(qry).then((e: ReturnOption) => {
+                        this.parentItems = DataUtil.distinct(<Object[]>e.result, this.parent.parentIdMapping, false);
+                        let req: number;
+                        if (<Object[]>e.result) {
+                            req = 0;
+                        } else {
+                            req = 1;
+                        }
+                        if (req === 0) {
+                            setValue('grid.contentModule.isLoaded', true, this.parent);
+                            if (!isNullOrUndefined(this.zerothLevelData)) {
+                                setValue('cancel', false, this.zerothLevelData);
+                                getValue('grid.renderModule', this.parent).dataManagerSuccess(this.zerothLevelData);
+                                this.zerothLevelData = null;
+                            }
+                            this.parent.grid.hideSpinner();
+                        }
+                    });
+                }
+            }
+        } else if (data instanceof Array) {
+            this.convertJSONData(data);
+        }
+    }
+
+    private convertJSONData(data: Object): void {
+        this.hierarchyData = [];
+        this.taskIds = [];
+        if (!this.parent.idMapping) {
+            this.hierarchyData = <Object[]> data;
+        } else {
+            const keys: string[] = Object.keys(data);
+            for (let i: number = 0; i < keys.length; i++) {
+                const tempData: Object = data[parseInt(i.toString(), 10)];
+                this.hierarchyData.push(extend({}, tempData));
+                if (!isNullOrUndefined(tempData[this.parent.idMapping])) {
+                    this.taskIds.push(tempData[this.parent.idMapping]);
+                }
+            }
+        }
+        if (this.isSelfReference) {
+            const selfData: ITreeData[] = [];
+            const mappingData: Object[] = new DataManager(this.hierarchyData).executeLocal(
+                new Query()
+                    .group(this.parent.parentIdMapping)
+            );
+            for (let i: number = 0; i < mappingData.length; i++) {
+                const groupData: Group = mappingData[parseInt(i.toString(), 10)];
+                const index: number = this.taskIds.indexOf(groupData.key);
+                if (!isNullOrUndefined(groupData.key)) {
+                    if (index > -1) {
+                        const childData: Object[] = (groupData.items);
+                        this.hierarchyData[parseInt(index.toString(), 10)][this.parent.childMapping] = childData;
+                        continue;
+                    }
+                }
+                selfData.push(...groupData.items);
+            }
+            this.hierarchyData = this.selfReferenceUpdate(selfData);
+        }
+        if (!Object.keys(this.hierarchyData).length) {
+            const isGantt: string = 'isGantt';
+            const referenceData: boolean = !(this.parent.dataSource instanceof DataManager) && this.parent[`${isGantt}`];
+            this.parent.flatData = referenceData ? <Object[]>(this.parent.dataSource) : [];
+        } else {
+            this.createRecords(this.hierarchyData);
+        }
+        this.storedIndex = -1;
+    }
+    // private crudActions(): void {
+    //   if (this.parent.dataSource instanceof DataManager && (this.parent.dataSource.adaptor instanceof RemoteSaveAdaptor)) {
+    //     let oldUpdate: Function = this.parent.dataSource.adaptor.update;
+    //     this.parent.dataSource.adaptor.update =
+    //         function (dm: DataManager, keyField: string, value: Object, tableName?: string, query?: Query, original?: Object): Object {
+    //                value = getPlainData(value);
+    //                return oldUpdate.apply(this, [dm, keyField, value, tableName, query, original]);
+    //              }
+    //   }
+    // }
+    private selfReferenceUpdate(selfData: ITreeData[]): ITreeData[] {
+        const result: ITreeData[] = [];
+        while (this.hierarchyData.length > 0 && selfData.length > 0) {
+            const index: number = selfData.indexOf(this.hierarchyData[0]);
+            if ( index === -1) {
+                this.hierarchyData.shift();
+            } else {
+                result.push(this.hierarchyData.shift());
+                selfData.splice(index, 1);
+            }
+        }
+        return result;
+    }
+    /**
+     * Function to update the zeroth level parent records in remote binding
+     *
+     * @param {BeforeDataBoundArgs} args - contains data before its bounds to tree grid
+     * @hidden
+     * @returns {void}
+     */
+    private updateParentRemoteData(args?: BeforeDataBoundArgs) : void {
+        const actionArgs: string = 'actionArgs';
+        if (isRemoteData(this.parent) && this.parent.enableVirtualization && args[`${actionArgs}`].requestType === 'virtualscroll' ) {
+            this.parent.hideSpinner();
+        }
+        const records: ITreeData[] = args.result;
+        if (isRemoteData(this.parent) && this.parent.enableVirtualization && (args[`${actionArgs}`].requestType === 'virtualscroll' || args[`${actionArgs}`].action === 'clearFilter' || args[`${actionArgs}`].searchString === '')) {
+            this.parent.query.expands = [];
+        }
+        if (!this.parent.hasChildMapping && !this.parentItems.length &&
+      (this.parent.loadChildOnDemand)) {
+            this.zerothLevelData = args;
+            setValue('cancel', true, args);
+        } else {
+            if (this.parent.loadChildOnDemand) {
+                for (let rec: number = 0; rec < records.length; rec++) {
+                    if (isCountRequired(this.parent) && records[parseInt(rec.toString(), 10)].hasChildRecords &&
+                    this.parent.initialRender) {
+                        records[parseInt(rec.toString(), 10)].expanded = false;
+                    }
+                    if (isRemoteData(this.parent) && this.parent.enableVirtualization) {
+                        const childRecords: ITreeData[] = [];
+                        const parent: TreeGrid = this.parent;
+                        records.filter((e: ITreeData): void => {
+                            if (e[`${parent.parentIdMapping}`] === records[parseInt(rec.toString(), 10)][`${parent.idMapping}`]) {
+                                childRecords.push(e);
+                            }
+                        });
+                        if (childRecords.length) {
+                            records[parseInt(rec.toString(), 10)].expanded = true;
+                        }
+                        else if (records[parseInt(rec.toString(), 10)].hasChildRecords) {
+                            records[parseInt(rec.toString(), 10)].expanded = false;
+                        }
+                    }
+                    if (isNullOrUndefined(records[parseInt(rec.toString(), 10)].index)) {
+                        records[parseInt(rec.toString(), 10)].taskData = extend({}, records[parseInt(rec.toString(), 10)]);
+                        records[parseInt(rec.toString(), 10)].uniqueID = getUid(this.parent.element.id + '_data_');
+                        setValue('uniqueIDCollection.' + records[parseInt(rec.toString(), 10)].uniqueID, records[parseInt(rec.toString(), 10)], this.parent);
+                        if (isRemoteData(this.parent) && this.parent.enableVirtualization && records[parseInt(rec.toString(), 10)][`${this.parent.parentIdMapping}`] && (isNullOrUndefined(records[parseInt(rec.toString(), 10)].level) || records[parseInt(rec.toString(), 10)].level === 0)) {
+                            const parentID: any = records[parseInt(rec.toString(), 10)][`${this.parent.parentIdMapping}`];
+                            const parentRec: any = records.find((record: any) => record[`${this.parent.idMapping}`] === parentID);
+                            if (parentRec) {
+                                records[parseInt(rec.toString(), 10)].level = parentRec.level + 1;
+                            }
+                            else {
+                                const parentRec: any = (args.actual as any).flatData.find((record: any) => record[`${this.parent.idMapping}`] === parentID);
+                                if (isNullOrUndefined(parentRec[`${this.parent.parentIdMapping}`])) {
+                                    records[parseInt(rec.toString(), 10)].level = 1;
+                                }
+                                else {
+                                    records[parseInt(rec.toString(), 10)].level = parentRec.level + 1;
+                                }
+                            }
+                        }
+                        else {
+                            records[parseInt(rec.toString(), 10)].level = 0;
+                        }
+                        records[parseInt(rec.toString(), 10)].index = Math.ceil(Math.random() * 1000);
+                        if ((records[parseInt(rec.toString(), 10)][this.parent.hasChildMapping] ||
+                          this.parentItems.indexOf(records[parseInt(rec.toString(), 10)][this.parent.idMapping]) !== -1)) {
+                            records[parseInt(rec.toString(), 10)].hasChildRecords = true;
+                        }
+                        records[parseInt(rec.toString(), 10)].checkboxState = 'uncheck';
+                    }
+                }
+            } else {
+                const dataResults: string = 'dataResults';
+                const expandRecord: string = 'expandRecord';
+                if (!isNullOrUndefined(records) && !((!this.parent.loadChildOnDemand) && isCountRequired(this.parent) && !isNullOrUndefined(this.parent[`${dataResults}`][`${expandRecord}`])) &&
+                !(isRemoteData(this.parent) && !this.parent.loadChildOnDemand && args[`${actionArgs}`].isExpandCollapse && this.parent.enableVirtualization)) {
+                    this.convertToFlatData(records);
+                }
+            }
+        }
+        if (isRemoteData(this.parent) && !this.parent.loadChildOnDemand && args[`${actionArgs}`].isExpandCollapse && this.parent.enableVirtualization) {
+            args.result = records;
+        }
+        else if (isRemoteData(this.parent) && this.parent.enableVirtualization && this.parent.loadChildOnDemand) {
+            args.result = records;
+        }
+        else {
+            args.result = !this.parent.loadChildOnDemand ? this.parent.flatData : records;
+        }
+        if (isRemoteData(this.parent) && this.parent.enableVirtualization && !this.parent.loadChildOnDemand
+            && this.parent.grid.aggregates.length && this.parent.grid.sortSettings.columns.length === 0
+            && this.parent.grid.filterSettings.columns.length === 0 && !this.parent.grid.searchSettings.key.length) {
+            const query: string = 'query';
+            const summaryQuery: QueryOptions[] = args[`${query}`].queries.filter((q: QueryOptions) => q.fn === 'onAggregates');
+            args.result = this.parent.summaryModule.calculateSummaryValue(summaryQuery, this.parent.flatData, true);
+        }
+        this.parent.notify('updateResults', args);
+    }
+
+    /**
+     * Function to manipulate datasource
+     *
+     * @param {{record: ITreeData, rows: HTMLTableRowElement[], parentRow: HTMLTableRowElement}} rowDetails - Row details for which child rows has to be fetched
+     * @param {ITreeData} rowDetails.record - current expanding record
+     * @param {HTMLTableRowElement[]} rowDetails.rows - Expanding Row element
+     * @param {HTMLTableRowElement} rowDetails.parentRow  - Curent expanding row element
+     * @param {boolean} isChild - Specified whether current record is already a child record
+     * @hidden
+     * @returns {void}
+     */
+    private collectExpandingRecs(rowDetails: {record: ITreeData, rows: HTMLTableRowElement[], parentRow: HTMLTableRowElement},
+                                 isChild?: boolean): void {
+        let gridRows: HTMLTableRowElement[] = this.parent.getRows();
+        const name: string = 'name';
+        if (this.parent.rowTemplate) {
+            const rows: HTMLCollection = (this.parent.getContentTable() as HTMLTableElement).rows;
+            gridRows = [].slice.call(rows);
+        }
+        let childRecord: ITreeData;
+        if (rowDetails.rows.length > 0) {
+            if (!isChild) {
+                rowDetails.record.expanded = true;
+            }
+            for (let i: number = 0; i < rowDetails.rows.length; i++) {
+                this.parent['toggleRowVisibility'](rowDetails.rows[parseInt(i.toString(), 10)], 'e-childrow-visible');
+                if (!this.parent.loadChildOnDemand) {
+                    const targetEle: Element = rowDetails.rows[parseInt(i.toString(), 10)].getElementsByClassName('e-treegridcollapse')[0];
+                    childRecord = this.parent.rowTemplate ?
+                        this.parent.grid.getCurrentViewRecords()[rowDetails.rows[parseInt(i.toString(), 10)].rowIndex] :
+                        this.parent.grid.getRowObjectFromUID(rowDetails.rows[parseInt(i.toString(), 10)].getAttribute('data-uid')).data;
+                    if (!isNullOrUndefined(targetEle) && childRecord.expanded) {
+                        addClass([targetEle], 'e-treegridexpand');
+                        removeClass([targetEle], 'e-treegridcollapse');
+                    }
+                    let childRows: HTMLTableRowElement[] = [];
+                    childRows = gridRows.filter(
+                        (r: HTMLTableRowElement) =>
+                            r.querySelector(
+                                '.e-gridrowindex' + childRecord.index + 'level' + (childRecord.level + 1)
+                            )
+                    );
+                    if (childRows.length && childRecord.expanded) {
+                        this.collectExpandingRecs({ record: childRecord, rows: childRows, parentRow: rowDetails.parentRow }, true);
+                    }
+                }
+                const expandingTd: Element = rowDetails.rows[parseInt(i.toString(), 10)].querySelector('.e-detailrowcollapse');
+                if (!isNullOrUndefined(expandingTd)) {
+                    this.parent.grid.detailRowModule.expand(expandingTd);
+                }
+            }
+            this.parent.grid.pageSettings.totalRecordsCount += rowDetails.rows.length;
+        } else {
+            this.fetchRemoteChildData({action: rowDetails[`${name}`], record: rowDetails.record, rows: rowDetails.rows, parentRow: rowDetails.parentRow});
+        }
+    }
+
+    private fetchRemoteChildData(rowDetails: { action: string, record: ITreeData, rows: HTMLTableRowElement[],
+        parentRow: HTMLTableRowElement }): void {
+        const args: RowExpandedEventArgs = {row: rowDetails.parentRow, data: rowDetails.record};
+        const dm: DataManager = <DataManager>this.parent.dataSource;
+        const query: Query = this.parent.grid.getDataModule().generateQuery();
+        const clonequries: QueryOptions[] = query.queries.filter((e: QueryOptions) => e.fn !== 'onPage' && e.fn !== 'onWhere');
+        query.queries = clonequries;
+        query.isCountRequired = true;
+        let idMappingValue: number | string = parseInt(rowDetails.record[this.parent.idMapping], 10);
+        if (isNaN(idMappingValue)) {
+            idMappingValue = rowDetails.record[this.parent.idMapping].toString();
+        }
+        if (this.parent.enableVirtualization && rowDetails.action === 'remoteExpand') {
+            query.take(this.parent.grid.pageSettings.pageSize);
+            const expandDetail: Object[] = [];
+            expandDetail.push('ExpandingAction', idMappingValue.toString());
+            query.expand(expandDetail);
+        }
+        else if (this.parent.enableVirtualization && rowDetails.action === 'collapse') {
+            query.take(this.parent.grid.pageSettings.pageSize);
+            const expandDetail: Object[] = [];
+            expandDetail.push('CollapsingAction', idMappingValue.toString());
+            query.expand(expandDetail);
+        }
+        query.where(this.parent.parentIdMapping, 'equal', rowDetails.record[this.parent.idMapping]);
+        if (rowDetails.action === 'remoteExpand' && this.parent.grid.filterSettings && this.parent.grid.filterSettings.columns.length) {
+            const filterqry: QueryOptions[] = this.parent.grid.getDataModule().generateQuery().queries.filter((e: QueryOptions) => e.fn !== 'onPage' && typeof e.e.predicates !== 'undefined');
+            query.queries.push(filterqry[0]);
+        }
+        showSpinner(this.parent.element);
+        dm.executeQuery(query).then((e: ReturnOption) => {
+            const remoteExpandedData: string = 'remoteExpandedData';
+            const remoteCollapsedData: string = 'remoteCollapsedData';
+            const level: string = 'level';
+            let datas: ITreeData[] = this.parent.grid.currentViewData.slice();
+            let inx: number;
+            const idMapping: string = this.parent.idMapping;
+            if (this.parent['isGantt'] && this.parent.loadChildOnDemand && this.parent.hasChildMapping) {
+                for (let i: number = 0; i < this.parent.grid.currentViewData.length; i++) {
+                    if (rowDetails.record[idMapping as string] === this.parent.grid.currentViewData[i as number][idMapping as string]) {
+                        inx = i;
+                        break;
+                    }
+                }
+            }
+            else {
+                inx = datas.indexOf(rowDetails.record);
+            }
+            if (this.parent.enableVirtualization && (rowDetails.action === 'collapse' || rowDetails.action === 'remoteExpand')) {
+                datas = [];
+                for (let i: number = 0; i < inx; i++) {
+                    datas.push(this.parent.grid.currentViewData[parseInt(i.toString(), 10)]);
+                }
+            }
+            if (inx === -1) {
+                this.parent.grid.getRowsObject().forEach((rows: Row<Column>) => {
+                    if ((rows.data as ITreeData).uniqueID === rowDetails.record.uniqueID) {
+                        inx = rows.index;
+                    }
+                });
+            }
+            const haveChild: boolean[] = getObject('actual.nextLevel', e);
+            let result: ITreeData[] = <ITreeData[]>e.result;
+            const resultChildData: ITreeData[] = [];
+            if (rowDetails.action === 'remoteExpand' && this.parent.grid.filterModule && this.parent.grid.filterModule['value']) {
+                for (let i: number = 0; i < datas.length; i++) {
+                    if (Object.prototype.hasOwnProperty.call(datas[parseInt(i.toString(), 10)], this.parent.parentIdMapping) && datas[parseInt(i.toString(), 10)]['' + this.parent.parentIdMapping] !== null && datas[parseInt(i.toString(), 10)].level === 0) {
+                        datas.splice(i, 1);
+                        i--;
+                    }
+                }
+                for (let i: number = 0; i < result.length; i++) {
+                    if (rowDetails.record['' + this.parent.idMapping] !== result[parseInt(i.toString(), 10)]['' + this.parent.idMapping] &&
+                        rowDetails.record['' + this.parent.idMapping] === result[parseInt(i.toString(), 10)]['' + this.parent.parentIdMapping]) {
+                        if (Object.prototype.hasOwnProperty.call(result, i)) {
+                            resultChildData.push(result[parseInt(i.toString(), 10)]);
+                        }
+                    }
+                }
+                result = resultChildData;
+            }
+            if (this.parent.enableVirtualization && rowDetails.action === 'remoteExpand') {
+                rowDetails.record.childRecords = [];
+                for (let i: number = 0; i < result.length; i++) {
+                    if (rowDetails.record['' + this.parent.idMapping] !== result[parseInt(i.toString(), 10)]['' + this.parent.idMapping] &&
+                        rowDetails.record['' + this.parent.idMapping] === result[parseInt(i.toString(), 10)]['' + this.parent.parentIdMapping] && Object.prototype.hasOwnProperty.call(result, i)) {
+                        rowDetails.record.childRecords.push(result[parseInt(i.toString(), 10)]);
+                    }
+                }
+            }
+            else {
+                rowDetails.record.childRecords = result;
+            }
+            for (let r: number = 0; r < result.length; r++) {
+                const record: any = result[parseInt(r.toString(), 10)];
+                if (this.parent.enableVirtualization && record[`${this.parent.idMapping}`] === rowDetails.record[`${this.parent.idMapping}`] && rowDetails.action === 'remoteExpand') {
+                    this.parent[`${remoteExpandedData}`].push(rowDetails.record);
+                }
+                else if (this.parent.enableVirtualization && record[`${this.parent.idMapping}`] === rowDetails.record[`${this.parent.idMapping}`] && rowDetails.action === 'collapse') {
+                    for (let i: number = 0; i < this.parent[`${remoteExpandedData}`].length; i++) {
+                        if (rowDetails.record[`${this.parent.idMapping}`] === this.parent[`${remoteExpandedData}`][parseInt(i.toString(), 10)][`${this.parent.idMapping}`]) {
+                            this.parent[`${remoteExpandedData}`].splice(i, 1);
+                        }
+                    }
+                }
+                record.taskData = extend({}, record);
+                if (record[`${this.parent.parentIdMapping}`] && this.parent.enableVirtualization && this.parent[`${remoteExpandedData}`].length) {
+                    for (let i: number = 0; i < this.parent[`${remoteExpandedData}`].length; i++) {
+                        if (record[`${this.parent.parentIdMapping}`] === this.parent[`${remoteExpandedData}`][parseInt(i.toString(), 10)][`${this.parent.idMapping}`]) {
+                            record.level = this.parent[`${remoteExpandedData}`][parseInt(i.toString(), 10)][`${level}`] + 1;
+                            const parentData: ITreeData = this.parent[`${remoteExpandedData}`][parseInt(i.toString(), 10)];
+                            delete parentData.childRecords;
+                            record.parentItem = parentData;
+                            record.parentUniqueID = parentData.uniqueID;
+                        }
+                    }
+                }
+                else if (this.parent.enableVirtualization) {
+                    if ((record[`${this.parent.hasChildMapping}`] ||
+             this.parentItems.indexOf(record[`${this.parent.idMapping}`]) !== -1)
+             && !(haveChild && !haveChild[parseInt(r.toString(), 10)])) {
+                        if (isNullOrUndefined(record[`${this.parent.parentIdMapping}`])) {
+                            record.level = 0;
+                            if (rowDetails.action === 'remoteExpand') {
+                                record.childRecords = [];
+                                record.childRecords = rowDetails.record.childRecords;
+                            }
+                        }
+                        else {
+                            record.level = rowDetails.record.level;
+                        }
+                    }
+                    else {
+                        const parentData: ITreeData = extend({}, rowDetails.record);
+                        delete parentData.childRecords;
+                        record.parentItem = parentData;
+                        record.parentUniqueID = rowDetails.record.uniqueID;
+                    }
+                }
+                else {
+                    record.level = rowDetails.record.level + 1;
+                    const parentData: ITreeData = extend({}, rowDetails.record);
+                    delete parentData.childRecords;
+                    record.parentItem = parentData;
+                    record.parentUniqueID = rowDetails.record.uniqueID;
+                }
+                record.index = Math.ceil(Math.random() * 1000);
+                record.uniqueID = getUid(this.parent.element.id + '_data_');
+                if (rowDetails.record[`${this.parent.idMapping}`] === record[`${this.parent.idMapping}`]) {
+                    rowDetails.record.uniqueID = record.uniqueID;
+                }
+                record.checkboxState = 'uncheck';
+                if (this.parent.enableVirtualization && isNullOrUndefined(record.level)) {
+                    for (let p: number = 0; p < this.parent.grid.currentViewData.length; p++) {
+                        if (this.parent.grid.currentViewData[parseInt(p.toString(), 10)][`${this.parent.idMapping}`] === record[`${this.parent.parentIdMapping}`]) {
+                            record.level = this.parent.grid.currentViewData[parseInt(p.toString(), 10)]['level'] + 1;
+                        }
+                    }
+                }
+                setValue('uniqueIDCollection.' + record.uniqueID, record, this.parent);
+                // delete result[r].parentItem.childRecords;
+                if ((record[`${this.parent.hasChildMapping}`] ||
+                    this.parentItems.indexOf(record[`${this.parent.idMapping}`]) !== -1)
+                    && !(haveChild && !haveChild[parseInt(r.toString(), 10)])) {
+                    record.hasChildRecords = true;
+                    if (this.parent.enableVirtualization && !this.parent.loadChildOnDemand) {
+                        for (let i: number = 0; i < this.parent[`${remoteCollapsedData}`].length; i++) {
+                            if (record[`${this.parent.idMapping}`] === this.parent[`${remoteCollapsedData}`][parseInt(i.toString(), 10)][`${this.parent.idMapping}`]) {
+                                record.expanded = this.parent[`${remoteCollapsedData}`][parseInt(i.toString(), 10)]['expanded'];
+                            }
+                        }
+                        if (rowDetails.action === 'collapse' && record[`${this.parent.idMapping}`] !== rowDetails.record[`${this.parent.idMapping}`] && record.expanded !== false) {
+                            record.expanded = true;
+                        }
+                        else if (rowDetails.action === 'collapse' && record[`${this.parent.idMapping}`] === rowDetails.record[`${this.parent.idMapping}`]) {
+                            record.expanded = false;
+                            this.parent[`${remoteCollapsedData}`].push(rowDetails.record);
+                        }
+                        else if (rowDetails.action === 'remoteExpand') {
+                            for (let i: number = 0; i < this.parent.grid.currentViewData.length; i++) {
+                                if (this.parent.grid.currentViewData[parseInt(i.toString(), 10)][`${this.parent.idMapping}`] === record[`${this.parent.idMapping}`]) {
+                                    result.splice(r, 1, this.parent.grid.currentViewData[parseInt(i.toString(), 10)]);
+                                }
+                            }
+                            if (record[this.parent.idMapping] === rowDetails.record[`${this.parent.idMapping}`]) {
+                                for (let i: number = 0; i < this.parent[`${remoteCollapsedData}`].length; i++) {
+                                    if (rowDetails.record[`${this.parent.idMapping}`] === this.parent[`${remoteCollapsedData}`][parseInt(i.toString(), 10)][`${this.parent.idMapping}`]) {
+                                        this.parent[`${remoteCollapsedData}`].splice(i, 1);
+                                    }
+                                }
+                            }
+                            if (record.expanded !== false) {
+                                record.expanded = true;
+                            }
+                        }
+                    }
+                    else if (this.parent.enableVirtualization && record[`${this.parent.idMapping}`] === rowDetails.record[`${this.parent.idMapping}`] && rowDetails.action !== 'collapse') {
+                        record.expanded = true;
+                    }
+                    else if (!(this.parent.enableVirtualization && !this.parent.loadChildOnDemand)) {
+                        record.expanded = false;
+                    }
+                }
+                const exists: boolean = datas.some((data: any) => data[`${this.parent.idMapping}`] === record[this.parent.idMapping]);
+                if (!exists) {
+                    datas.splice(inx + r + 1, 0, record);
+                }
+            }
+            const localIdMapping: string = this.parent.idMapping;
+            datas.sort(function (firstRecord: any, secondRecord: any): number {
+                return firstRecord[`${localIdMapping}`] - secondRecord[`${localIdMapping}`];
+            });
+            setValue('result', datas, e); setValue('action', 'beforecontentrender', e);
+            this.parent.trigger(events.actionComplete, e);
+            hideSpinner(this.parent.element);
+            if (this.parent.grid.aggregates.length > 0 && !this.parent.enableVirtualization) {
+                let gridQuery: Query = getObject('query', e);
+                const result: string = 'result';
+                if (isNullOrUndefined(gridQuery)) {
+                    gridQuery = getValue('grid.renderModule.data', this.parent).aggregateQuery(new Query());
+                }
+                if (!isNullOrUndefined(gridQuery)) {
+                    const summaryQuery: QueryOptions[] = gridQuery.queries.filter((q: QueryOptions) => q.fn === 'onAggregates');
+                    e[`${result}`] = this.parent.summaryModule.calculateSummaryValue(summaryQuery, e[`${result}`], true);
+                }
+            }
+            if (rowDetails.action === 'remoteExpand' && this.parent.allowPaging && this.parent.pageSettings.pageSizeMode === 'All') {
+                this.parent.grid.pageSettings.totalRecordsCount = this.parent.grid.pageSettings.totalRecordsCount + result.length;
+            }
+            if (this.parent.enableVirtualization) {
+                this.parent.grid.pageSettings.totalRecordsCount = e.count;
+            }
+            e.count = this.parent.grid.pageSettings.totalRecordsCount;
+            const virtualArgs: NotifyArgs = {};
+            if (this.parent.enableVirtualization) {
+                this.remoteVirtualAction(virtualArgs);
+            }
+            const notifyArgs: { index: number, childData: ITreeData[] } = { index: inx, childData : result };
+            if (this.parent.enableInfiniteScrolling) {
+                this.parent.notify('infinite-remote-expand', notifyArgs);
+            } else {
+                getValue('grid.renderModule', this.parent).dataManagerSuccess(e, virtualArgs);
+            }
+            this.parent.trigger(events.expanded, args);
+        });
+    }
+
+    private remoteVirtualAction(virtualArgs: NotifyArgs): void {
+        virtualArgs.requestType = 'refresh';
+        setValue('isExpandCollapse', true, virtualArgs);
+        const contentModule: VirtualContentRenderer = getValue('grid.contentModule', this.parent);
+        const currentInfo: VirtualInfo = getValue('currentInfo', contentModule);
+        const prevInfo: VirtualInfo = getValue('prevInfo', contentModule);
+        if (currentInfo.loadNext && this.parent.grid.pageSettings.currentPage === currentInfo.nextInfo.page
+            && !this.parent.loadChildOnDemand) {
+            this.parent.grid.pageSettings.currentPage = prevInfo.page;
+        }
+    }
+
+    private beginSorting(): void {
+        this.isSortAction = true;
+        if (isRemoteData(this.parent) && this.parent.enableVirtualization) {
+            const index: number = this.parent.query.queries.indexOf(this.parent.query.queries.filter((q: QueryOptions) => q.fn === 'onSortBy')[0]);
+            if (index !== -1) {
+                this.parent.query.queries.splice(index, 1);
+            }
+            if (this.parent.grid.sortSettings.columns.length === 0) {
+                this.parent.query.sortBy(null, null);
+            }
+        }
+    }
+
+    private createRecords(data: Object, parentRecords?: ITreeData): ITreeData[] {
+        const treeGridData: ITreeData[] = [];
+        const keys: string[] = Object.keys(data);
+        for (let i: number = 0, len: number = keys.length; i < len; i++) {
+            const currentData: ITreeData = extend({}, data[parseInt(i.toString(), 10)]);
+            currentData.taskData = data[parseInt(i.toString(), 10)];
+            let level: number = 0;
+            this.storedIndex++;
+            if (!Object.prototype.hasOwnProperty.call(currentData, 'index')) {
+                currentData.index = this.storedIndex;
+            }
+            const childMapping: any = currentData[this.parent.childMapping];
+            const hasChildren: boolean = !isNullOrUndefined(childMapping) && childMapping.length > 0;
+            const shouldCount: boolean = isCountRequired(this.parent);
+            const hasChildMapping: any = currentData[this.parent.hasChildMapping];
+            if ((hasChildren && !shouldCount) || (hasChildMapping && shouldCount)) {
+                currentData.hasChildRecords = true;
+            } else {
+                currentData.hasChildRecords = false;
+            }
+            if ((!isNullOrUndefined(childMapping) && !shouldCount) ||
+                (hasChildMapping) && shouldCount) {
+                if (this.parent.enableCollapseAll || !isNullOrUndefined(this.parent.dataStateChange)
+                    && isNullOrUndefined(childMapping)) {
+                    currentData.expanded = false;
+                } else {
+                    currentData.expanded = !isNullOrUndefined(currentData[this.parent.expandStateMapping])
+                        ? currentData[this.parent.expandStateMapping] : true;
+                }
+            }
+            if (!Object.prototype.hasOwnProperty.call(currentData, 'index')) {
+                currentData.index =  currentData.hasChildRecords ? this.storedIndex : this.storedIndex;
+            }
+            if (this.isSelfReference && isNullOrUndefined(currentData[this.parent.parentIdMapping])) {
+                this.parent.parentData.push(currentData);
+            }
+            currentData.uniqueID = getUid(this.parent.element.id + '_data_');
+            setValue('uniqueIDCollection.' + currentData.uniqueID, currentData, this.parent);
+            if (!isNullOrUndefined(parentRecords)) {
+                const parentData: ITreeData = extend({}, parentRecords);
+                delete parentData.childRecords;
+                delete parentData[this.parent.childMapping];
+                if (this.isSelfReference) {
+                    delete parentData.taskData[this.parent.childMapping];
+                }
+                currentData.parentItem = parentData;
+                currentData.parentUniqueID = parentData.uniqueID;
+                level = parentRecords.level + 1;
+            }
+            if (!Object.prototype.hasOwnProperty.call(currentData, 'level')) {
+                currentData.level = level;
+            }
+            currentData.checkboxState = 'uncheck';
+            const remoteCollapsedData: string = 'remoteCollapsedData';
+            if (this.parent.enableVirtualization && !this.parent.loadChildOnDemand && isRemoteData(this.parent)
+                 && !this.parent.initialRender){
+                if (!currentData.hasChildRecords && isNullOrUndefined(currentData[`${this.parent.parentIdMapping}`])) {
+                    currentData.hasChildRecords = true;
+                    for (let c: number = 0; c < this.parent[`${remoteCollapsedData}`].length; c++) {
+                        if (this.parent[`${remoteCollapsedData}`][parseInt(c.toString(), 10)][`${this.parent.idMapping}`] === currentData[`${this.parent.idMapping}`]) {
+                            currentData.expanded = false;
+                        }
+                    }
+                }
+                else if (currentData.level === 0 && isNullOrUndefined(parentRecords) && !currentData.hasChildRecords) {
+                    currentData.level = currentData.level + 1;
+                }
+                if (currentData[`${this.parent.hasChildMapping}`] && !isNullOrUndefined(currentData[`${this.parent.expandStateMapping}`])) {
+                    currentData.expanded = currentData[`${this.parent.expandStateMapping}`];
+                    currentData.hasChildRecords = true;
+                }
+                this.parent.flatData.push(currentData);
+            }
+            else if (isNullOrUndefined(currentData[`${this.parent.parentIdMapping}`]) || currentData.parentItem) {
+                if (!isNullOrUndefined(this.parent.rowDropSettings.targetID)) {
+                    if (!this.parent.rowDragAndDropModule['isDuplicateData'](currentData)) {
+                        this.parent.flatData.push(currentData);
+                    }
+                }
+                else {
+                    this.parent.flatData.push(currentData);
+                }
+                this.parent['infiniteScrollData'].push(currentData);
+            }
+            if (!this.isSelfReference && currentData.level === 0) {
+                this.parent.parentData.push(currentData);
+            }
+            if (!isNullOrUndefined(currentData[this.parent.childMapping] && currentData[this.parent.childMapping].length )) {
+                const record: ITreeData[] = this.createRecords(currentData[this.parent.childMapping], currentData);
+                currentData.childRecords = record;
+            }
+            treeGridData.push(currentData);
+        }
+        return treeGridData;
+    }
+
+    /**
+     * Function to perform filtering/sorting action for local data
+     *
+     * @param {BeforeDataBoundArgs} args - data details to be processed before binding to grid
+     * @hidden
+     * @returns {void}
+     */
+    public dataProcessor(args?: BeforeDataBoundArgs) : void {
+        const isExport: boolean = getObject('isExport', args); const expresults: Object = getObject('expresults', args);
+        const exportType: string = getObject('exportType', args); const isPrinting: boolean = getObject('isPrinting', args);
+        let dataObj: Object; const actionArgs: NotifyArgs = getObject('actionArgs', args);
+        let requestType: Action = getObject('requestType', args); let actionData: Object = getObject('data', args);
+        let action: string = getObject('action', args); const actionAddArgs: SaveEventArgs = actionArgs;
+        const primaryKeyColumnName: string = this.parent.getPrimaryKeyFieldNames()[0];
+        const dataValue: ITreeData = getObject('data', actionAddArgs);
+        if ((!isNullOrUndefined(actionAddArgs)) && (!isNullOrUndefined(actionAddArgs.action)) && (actionAddArgs.action === 'add')
+      && (!isNullOrUndefined(actionAddArgs.data)) && isNullOrUndefined(actionAddArgs.data[`${primaryKeyColumnName}`])) {
+            actionAddArgs.data[`${primaryKeyColumnName}`] = args.result[actionAddArgs.index][`${primaryKeyColumnName}`];
+            dataValue.taskData[`${primaryKeyColumnName}`] = args.result[actionAddArgs.index][`${primaryKeyColumnName}`];
+        }
+        if ((!isNullOrUndefined(actionArgs) && Object.keys(actionArgs).length) || requestType === 'save') {
+            requestType = requestType ? requestType : actionArgs.requestType;
+            actionData = actionData ? actionData : getObject('data', actionArgs);
+            action = action ? action : getObject('action', actionArgs);
+            if (this.parent.editSettings.mode === 'Batch') {
+                this.batchChanges = this.parent.grid.editModule.getBatchChanges();
+            }
+            if (this.parent.isLocalData) {
+                this.updateAction(actionData, action, requestType);
+            }
+        }
+        if (isExport && !isNullOrUndefined(expresults)) {
+            dataObj = expresults;
+        } else {
+            dataObj = isCountRequired(this.parent) ? getValue('result', this.parent.grid.dataSource)
+                : this.parent.grid.dataSource;
+        }
+        let results: ITreeData[] = dataObj instanceof DataManager ? (<DataManager>dataObj).dataSource.json : <ITreeData[]>dataObj;
+        let count: number = isCountRequired(this.parent) ? getValue('count', this.parent.dataSource)
+            : results.length;
+        const qry: Query = new Query(); let gridQuery: Query = getObject('query', args);
+        let filterQuery: QueryOptions[]; let searchQuery: QueryOptions[];
+        if (!isNullOrUndefined(gridQuery)) {
+            filterQuery = gridQuery.queries.filter((q: QueryOptions) => q.fn === 'onWhere');
+            searchQuery = gridQuery.queries.filter((q: QueryOptions) => q.fn === 'onSearch');
+        }
+        if ((this.parent.grid.allowFiltering && this.parent.grid.filterSettings.columns.length) ||
+         (this.parent.grid.searchSettings.key.length > 0) || (!isNullOrUndefined(gridQuery) &&
+         (filterQuery.length || searchQuery.length) && this.parent.isLocalData)) {
+            if (isNullOrUndefined(gridQuery)) {
+                gridQuery = new Query(); gridQuery = getValue('grid.renderModule.data', this.parent).filterQuery(gridQuery);
+                gridQuery = getValue('grid.renderModule.data', this.parent).searchQuery(gridQuery);
+            }
+            const fltrQuery: QueryOptions[]  = gridQuery.queries.filter((q: QueryOptions) => q.fn === 'onWhere');
+            const srchQuery: QueryOptions[]  = gridQuery.queries.filter((q: QueryOptions) => q.fn === 'onSearch');
+            qry.queries = fltrQuery.concat(srchQuery); const filteredData: Object = new DataManager(results).executeLocal(qry);
+            this.parent.notify('updateFilterRecs', { data: filteredData });
+            results = <ITreeData[]>this.dataResults.result; this.dataResults.result = null;
+            if (this.parent.grid.aggregates.length > 0) {
+                const query: Query = getObject('query', args);
+                if (isNullOrUndefined(gridQuery)) {
+                    gridQuery = getValue('grid.renderModule.data', this.parent).aggregateQuery(new Query());
+                }
+                if (!isNullOrUndefined(query)) {
+                    const summaryQuery: QueryOptions[]  = query.queries.filter((q: QueryOptions) => q.fn === 'onAggregates');
+                    results = this.parent.summaryModule.calculateSummaryValue(summaryQuery, results, true);
+                }
+            }
+        }
+        if (this.parent.grid.aggregates.length && this.parent.grid.sortSettings.columns.length === 0
+      && this.parent.grid.filterSettings.columns.length === 0 && !this.parent.grid.searchSettings.key.length) {
+            let gridQuery: Query = getObject('query', args);
+            if (isNullOrUndefined(gridQuery)) {
+                gridQuery = getValue('grid.renderModule.data', this.parent).aggregateQuery(new Query());
+            }
+            const summaryQuery: QueryOptions[]  = gridQuery.queries.filter((q: QueryOptions) => q.fn === 'onAggregates');
+            results = this.parent.summaryModule.calculateSummaryValue(summaryQuery, this.parent.flatData, true);
+        }
+        if (this.parent.grid.sortSettings.columns.length > 0 || this.isSortAction) {
+            this.isSortAction = false;
+            const parentData: Object = this.parent.parentData;
+            const query: Query = getObject('query', args); const srtQry: Query = new Query();
+            for (let srt: number = this.parent.grid.sortSettings.columns.length - 1; srt >= 0; srt--) {
+                const getColumnByField: string = 'getColumnByField';
+                const col: GridColumnModel = this.parent.grid.renderModule.data[`${getColumnByField}`](this.parent.grid.
+                    sortSettings.columns[parseInt(srt.toString(), 10)].field);
+                const compFun: Function | string = col.sortComparer && isOffline(this.parent) ?
+                    (col.sortComparer as Function).bind(col) :
+                    this.parent.grid.sortSettings.columns[parseInt(srt.toString(), 10)].direction;
+                srtQry.sortBy(this.parent.grid.sortSettings.columns[parseInt(srt.toString(), 10)].field, compFun);
+            }
+            const modifiedData: Object = new DataManager(parentData).executeLocal(srtQry);
+            if (this.parent.allowRowDragAndDrop && !isNullOrUndefined(this.parent.rowDragAndDropModule['draggedRecord']) &&
+            this.parent.rowDragAndDropModule['droppedRecord'].hasChildRecords && this.parent.rowDragAndDropModule['dropPosition'] !== 'middleSegment') {
+                const dragdIndex: number = (modifiedData as ITreeData[]).indexOf(this.parent.rowDragAndDropModule['draggedRecord']);
+                (modifiedData as ITreeData[]).splice(dragdIndex, 1);
+                const dropdIndex: number = (modifiedData as ITreeData[]).indexOf(this.parent.rowDragAndDropModule['droppedRecord']);
+                if (this.parent.rowDragAndDropModule['droppedRecord'].hasChildRecords && this.parent.rowDragAndDropModule['dropPosition'] === 'topSegment') {
+                    (modifiedData as ITreeData[]).splice(dropdIndex, 0, this.parent.rowDragAndDropModule['draggedRecord']);
+                }
+                else if (this.parent.rowDragAndDropModule['dropPosition'] === 'bottomSegment') {
+                    (modifiedData as ITreeData[]).splice(dropdIndex + 1, 0, this.parent.rowDragAndDropModule['draggedRecord']);
+                }
+            }
+            const sortArgs: { modifiedData: ITreeData[], filteredData: ITreeData[], srtQry: Query}
+      = {modifiedData: <Object[]>modifiedData, filteredData: results, srtQry: srtQry};
+            this.parent.notify('createSort', sortArgs); results = sortArgs.modifiedData;
+            this.dataResults.result = null; this.sortedData = results; this.parent.notify('updateModel', {});
+            if (this.parent.grid.aggregates.length > 0 && !isNullOrUndefined(query)) {
+                const isSort: boolean = false;
+                const query: Query = getObject('query', args);
+                const summaryQuery: QueryOptions[]  = query.queries.filter((q: QueryOptions) => q.fn === 'onAggregates');
+                results = this.parent.summaryModule.calculateSummaryValue(summaryQuery, this.sortedData, isSort);
+            }
+        }
+        count = isCountRequired(this.parent) ? getValue('count', this.parent.dataSource)
+            : results.length;
+        const temp: BeforeDataBoundArgs = this.paging(results, count, isExport, isPrinting, exportType, args);
+        results = temp.result; count = temp.count;
+        args.result = results; args.count = count;
+        this.parent.notify('updateResults', args);
+    }
+    private paging(results: ITreeData[], count: number, isExport: boolean,
+                   isPrinting: boolean, exportType: string, args: Object): BeforeDataBoundArgs {
+        if (this.parent.allowPaging && (!isExport || exportType === 'CurrentPage')
+     && (!isPrinting || this.parent.printMode === 'CurrentPage'))  {
+            this.parent.notify(events.pagingActions, {result: results, count: count, actionArgs: args});
+            results = <ITreeData[]>this.dataResults.result;
+            count = isCountRequired(this.parent) ? getValue('count', this.parent.dataSource)
+                : this.dataResults.count;
+        } else if ((this.parent.enableVirtualization || this.parent.enableInfiniteScrolling) && (!isExport || exportType === 'CurrentPage')
+              && getValue('requestType', args) !== 'save') {
+            const actArgs: Object = this.parent.enableInfiniteScrolling ? args : getValue('actionArgs', args);
+            this.parent.notify(events.pagingActions, {result: results, count: count, actionArgs: actArgs});
+            results = <ITreeData[]>this.dataResults.result;
+            count = this.dataResults.count;
+        }
+        const isPdfExport: string = 'isPdfExport'; const isCollapsedStatePersist: string = 'isCollapsedStatePersist';
+        if ((isPrinting === true || (args[`${isPdfExport}`] && (isNullOrUndefined(args[`${isCollapsedStatePersist}`])
+       || args[`${isCollapsedStatePersist}`]))) && this.parent.printMode === 'AllPages') {
+            const actualResults: ITreeData[] = [];
+            for (let i: number = 0; i < results.length; i++) {
+                const expandStatus: boolean = getExpandStatus(this.parent, results[parseInt(i.toString(), 10)], this.parent.parentData);
+                if (expandStatus) {
+                    actualResults.push(results[parseInt(i.toString(), 10)]);
+                }
+            }
+            results = actualResults;
+            count = results.length;
+        }
+        const value: BeforeDataBoundArgs = { result: results, count: count };
+        return value;
+    }
+
+    private updateData(dataResult: {result: ITreeData, count: number}): void {
+        this.dataResults = <ReturnOption>dataResult;
+    }
+    private updateAction(actionData: ITreeData, action: string, requestType: string): void {
+        if ((requestType === 'delete' || requestType === 'save')) {
+            this.parent.notify(events.crudAction, { value: actionData, action: action || requestType });
+        }
+        if (requestType === 'batchsave' && this.parent.editSettings.mode === 'Batch') {
+            this.parent.notify(events.batchSave, {});
+        }
+    }
+}