basesite-shared-grid-lib 0.0.0-watch

package/esm2020/lib/helpers/oDataProvider.mjs

@@ -0,0 +1,787 @@
+import { replaceAll } from './utils';
+export class OdataProvider {
+    constructor(options) {
+        /**
+         * Name of field contain count of record results in grouping odata query
+         * @default childCount
+         */
+        this.groupCountFieldName = 'childCount';
+        /**
+         * Use in odata build query
+         * @default false
+         */
+        this.isCaseSensitiveStringFilter = false;
+        /**Creator a cancelable Promise */
+        this.createCancelablePromise = () => {
+            let cancel;
+            const pr = new Promise((_, reject) => {
+                cancel = reject;
+            }).catch(() => { });
+            return {
+                promise: pr,
+                cancel,
+            };
+        };
+        /**Odata query operations */
+        this.odataOperator = {
+            // Logical
+            equals: (col, value1) => `${col} eq ${value1}`,
+            blank: (col, value1) => `${col} eq ${value1}`,
+            notBlank: (col, value1) => `${col} ne ${value1}`,
+            notEqual: (col, value1) => `${col} ne ${value1}`,
+            lessThan: (col, value1) => `${col} lt ${value1}`,
+            lessThanOrEqual: (col, value1) => `${col} le ${value1}`,
+            greaterThan: (col, value1) => `${col} gt ${value1}`,
+            greaterThanOrEqual: (col, value1) => `${col} ge ${value1}`,
+            inRange: (col, value1, value2) => `(${col} ge ${value1} and ${col} le ${value2})`,
+            // String
+            equalsStr: (col, value1, isCaseSensitiveStringFilter) => `${this.ifTolowerCol(col, isCaseSensitiveStringFilter)} eq ${this.ifTolower(value1, isCaseSensitiveStringFilter)}`,
+            notEqualStr: (col, value1, isCaseSensitiveStringFilter) => `${this.ifTolowerCol(col, isCaseSensitiveStringFilter)} ne ${this.ifTolower(value1, isCaseSensitiveStringFilter)}`,
+            contains: (col, value1, isCaseSensitiveStringFilter) => `contains(${this.ifTolowerCol(col, isCaseSensitiveStringFilter)},${this.ifTolower(value1, isCaseSensitiveStringFilter)})`,
+            notContains: (col, value1, isCaseSensitiveStringFilter) => `contains(${this.ifTolowerCol(col, isCaseSensitiveStringFilter)},${this.ifTolower(value1, isCaseSensitiveStringFilter)}) eq false`,
+            startsWith: (col, value1, isCaseSensitiveStringFilter) => `startswith(${this.ifTolowerCol(col, isCaseSensitiveStringFilter)},${this.ifTolower(value1, isCaseSensitiveStringFilter)})  eq true`,
+            endsWith: (col, value1, isCaseSensitiveStringFilter) => `endswith(${this.ifTolowerCol(col, isCaseSensitiveStringFilter)},${this.ifTolower(value1, isCaseSensitiveStringFilter)})  eq true`,
+            inStr: (col, values, isCaseSensitiveStringFilter) => `${this.ifTolowerCol(col, isCaseSensitiveStringFilter)} in (${values
+                .map((x) => `'${this.ifTolower(this.encode(x), isCaseSensitiveStringFilter)}'`)
+                .join()})`,
+            in: (col, values) => `${col} in (${values.map((x) => `${this.encode(x)}`).join()})`,
+            notIn: (col, values) => `not (${col} in (${values.map((x) => `${x}`).join()}))`,
+            // Date
+            trunc: (col) => `date(${col})`,
+        };
+        /**
+         * Apply tolower for column in odata syntax
+         * @param col column name
+         * @param isCaseSensitiveStringFilter need apply tolower
+         */
+        this.ifTolowerCol = (col, isCaseSensitiveStringFilter) => isCaseSensitiveStringFilter ? col : `tolower(${col})`;
+        /**
+         *
+         * @param value string value
+         * @param isCaseSensitiveStringFilter  need apply tolower
+         */
+        this.ifTolower = (value, isCaseSensitiveStringFilter) => isCaseSensitiveStringFilter ? value : value ? value.toLowerCase() : value;
+        /**
+         * Odata aggregation operations
+         */
+        this.odataAggregation = {
+            // Logical
+            sum: (col, asField) => `${col} with sum as ${col || asField}`,
+            min: (col, asField) => `${col} with min as ${col || asField}`,
+            max: (col, asField) => `${col} with max as ${col || asField}`,
+            avg: (col, asField) => `${col} with average as ${col || asField}`,
+            count: (col, asField) => `$count as ${col || asField}`,
+        };
+        /**
+         * Odata query builder
+         * @param options parameter for odata query
+         */
+        this.toQuery = (options) => {
+            let path = [];
+            if (options) {
+                path.push('$count=true');
+            }
+            if (options.skip) {
+                path.push(`$skip=${options.skip}`);
+            }
+            if (options.top) {
+                path.push(`$top=${options.top}`);
+            }
+            if (options.sort && options.sort.length > 0) {
+                path.push('$orderby=' + options.sort.join(','));
+            }
+            if (options.filter && options.filter.length > 0) {
+                path.push('$filter=' + options.filter.join(' and '));
+            }
+            if (options.apply && options.apply.length > 0) {
+                path.push('$apply=' + options.apply.join('/'));
+            }
+            if (options.expand && options.expand.length > 0) {
+                path.push('$expand=' + options.expand.join(','));
+            }
+            if (options.select && options.select.length > 0) {
+                path.push('$select=' + options.select.join(','));
+            }
+            let query = '';
+            if (path.length > 0) {
+                var defaultFilters = path.filter((x) => {
+                    if (x.indexOf('$count') >= 0 ||
+                        x.indexOf('$top') >= 0 ||
+                        x.indexOf('$orderby') >= 0 ||
+                        x.indexOf('$apply') >= 0 ||
+                        x.indexOf('$expand') >= 0 ||
+                        x.indexOf('$select') >= 0) {
+                        return x;
+                    }
+                });
+                if (defaultFilters && defaultFilters.length > 0) {
+                    query = '?' + defaultFilters.join('&');
+                }
+                var customFilters = path.filter(function (obj) {
+                    return defaultFilters.indexOf(obj) == -1;
+                });
+                if (customFilters && customFilters.length > 0) {
+                    if (customFilters.length == 1)
+                        query = query + '&' + customFilters;
+                    else
+                        query = query + customFilters.join('and');
+                }
+            }
+            query = query.replace('and$filter=', '&filter=');
+            return query;
+        };
+        /**
+         * Add quotes for string value
+         * @param value string value
+         */
+        this.encode = (value) => this.isStrVal(value) ? replaceAll(value, "'", "''") : value;
+        /**
+         * Conctat to date a time for create datetime format for odata query
+         * @param value date string
+         */
+        this.toDateTime = (value) => {
+            const dt = new Date(value);
+            if (isNaN(dt.getTime()))
+                return null;
+            const dt1 = new Date(Date.UTC(dt.getFullYear(), dt.getMonth(), dt.getDate()));
+            return dt1.toISOString();
+        };
+        /**
+         *
+         * @param colName columnName
+         * @returns is CaseSensitive for column
+         */
+        this.getIsNeedCaseSensitive = (colName) => {
+            if (!this.isCaseSensitiveStringFilter &&
+                this.caseSensitiveColumns &&
+                this.caseSensitiveColumns.length > 0) {
+                return this.caseSensitiveColumns.indexOf(colName) >= 0;
+            }
+            return this.isCaseSensitiveStringFilter;
+        };
+        /**
+         * Convert ag-grid column filter to odata query
+         * @param colName columnName
+         * @param col ag-grid column
+         */
+        this.getFilterOdata = (colName, col) => {
+            const me = this;
+            const isCaseSensitiveStringFilter = me.getIsNeedCaseSensitive(colName);
+            const customFilter = me.customFilters && me.customFilters[colName];
+            colName = replaceAll(colName, '.', '/');
+            colName = me.getWrapColumnName(colName);
+            if (customFilter) {
+                return customFilter(colName, col, isCaseSensitiveStringFilter, me);
+            }
+            else {
+                switch (col.filterType) {
+                    case 'number':
+                        return me.odataOperator[col.type](colName, col.filter, col.filterTo);
+                    case 'text': {
+                        let operatorName = col.type;
+                        const filter = me.encode(col.filter) || '';
+                        // let filterTo = me.encode(col.filterTo);
+                        if ((operatorName === 'equals' || operatorName === 'notEqual') &&
+                            !isCaseSensitiveStringFilter) {
+                            operatorName += 'Str';
+                        }
+                        return me.odataOperator[operatorName](colName, `'${filter}'`, isCaseSensitiveStringFilter);
+                    }
+                    case 'date':
+                        if (col.dateFrom != null &&
+                            me.toDateTime(col.dateFrom) != null &&
+                            (col.dateTo == null ||
+                                (col.dateTo != null && me.toDateTime(col.dateTo) != null))) {
+                            return me.odataOperator[col.type](colName, `${me.toDateTime(col.dateFrom)}`, `${me.toDateTime(col.dateTo)}`);
+                        }
+                        break;
+                    case 'set':
+                        return col.values.length > 0
+                            ? me.odataOperator.inStr(colName, col.values, isCaseSensitiveStringFilter)
+                            : '';
+                    default:
+                        break;
+                }
+            }
+            return '';
+        };
+        /**
+         * Caclulate pivot data for ag-grid from odata
+         * @param pivotCols pivot columns
+         * @param rowGroupCols row group columns
+         * @param valueCols value columns
+         * @param data odata result
+         * @param countField count field name
+         */
+        this.getPivot = (pivotCols, rowGroupCols, valueCols, data, countField) => {
+            // assume 1 pivot col and 1 value col for this example
+            const me = this;
+            const pivotData = [];
+            const aggColsList = [];
+            const colKeyExistsMap = {};
+            const secondaryColDefs = [];
+            const secondaryColDefsMap = {};
+            data.forEach(function (item) {
+                var pivotValues = [];
+                pivotCols.forEach(function (pivotCol) {
+                    var pivotField = pivotCol.id;
+                    var pivotValue = me.getValue(pivotField, item);
+                    if (pivotValue !== null &&
+                        pivotValue !== undefined &&
+                        pivotValue.toString) {
+                        pivotValues.push(pivotValue.toString());
+                    }
+                    else {
+                        pivotValues.push('-');
+                    }
+                });
+                // var pivotValue = item[pivotField].toString();
+                var pivotItem = {};
+                valueCols.forEach(function (valueCol) {
+                    var valField = valueCol.id;
+                    var colKey = createColKey(pivotValues, valField);
+                    var value = me.getValue(valField, item);
+                    pivotItem[colKey] = value;
+                    if (!colKeyExistsMap[colKey]) {
+                        addNewAggCol(colKey, valueCol);
+                        addNewSecondaryColDef(colKey, pivotValues, valueCol);
+                        colKeyExistsMap[colKey] = true;
+                    }
+                });
+                if (countField) {
+                    pivotItem[countField] = me.getValue(countField, item);
+                }
+                rowGroupCols.forEach(function (rowGroupCol) {
+                    var rowGroupField = rowGroupCol.id.split('.')[0];
+                    pivotItem[rowGroupField] = item[rowGroupField];
+                });
+                pivotData.push(pivotItem);
+            });
+            function addNewAggCol(colKey, valueCol) {
+                var newCol = {
+                    id: colKey,
+                    field: colKey,
+                    aggFunc: valueCol.aggFunc,
+                };
+                aggColsList.push(newCol);
+            }
+            function addNewSecondaryColDef(colKey, pivotValues, valueCol) {
+                var parentGroup = null;
+                var keyParts = [];
+                pivotValues.forEach(function (pivotValue) {
+                    keyParts.push(pivotValue);
+                    var colKey = createColKey(keyParts);
+                    var groupColDef = secondaryColDefsMap[colKey];
+                    if (!groupColDef) {
+                        groupColDef = {
+                            groupId: colKey,
+                            headerName: pivotValue,
+                            children: [],
+                        };
+                        secondaryColDefsMap[colKey] = groupColDef;
+                        if (parentGroup) {
+                            parentGroup.children.push(groupColDef);
+                        }
+                        else {
+                            secondaryColDefs.push(groupColDef);
+                        }
+                    }
+                    parentGroup = groupColDef;
+                });
+                parentGroup.children.push({
+                    colId: colKey,
+                    headerName: valueCol.aggFunc + '(' + valueCol.displayName + ')',
+                    field: colKey,
+                    suppressMenu: true,
+                    sortable: false,
+                });
+            }
+            function createColKey(pivotValues, valueField) {
+                var result = pivotValues.join('|');
+                if (valueField !== undefined) {
+                    result += '|' + valueField;
+                }
+                result = replaceAll(result, '.', '*');
+                return result;
+            }
+            return {
+                data: pivotData,
+                aggCols: aggColsList,
+                secondaryColDefs: secondaryColDefs,
+            };
+        };
+        /**
+         *
+         * @param rowData array odata result
+         * @param rowGroupCols row group columns
+         * @param groupKeys what groups the user is viewing
+         * @param countField count field name
+         */
+        this.buildGroupsFromData = (rowData, rowGroupCols, groupKeys, countField) => {
+            const me = this;
+            let rowGroupCol = rowGroupCols[groupKeys.length];
+            let field = rowGroupCol.id;
+            let mappedRowData = me.groupBy(rowData, field);
+            let groups = [];
+            me.iterateObject(mappedRowData, function (key, rowData) {
+                var groupItem = me.aggregateList(rowData, countField);
+                groupItem[field] = key;
+                groups.push(groupItem);
+            });
+            return groups;
+        };
+        /**
+         * Internal function for execute callback function for each property of object
+         * @param object object contained odata grouped result
+         * @param callback function do somthing
+         */
+        this.iterateObject = (object, callback) => {
+            if (!object) {
+                return;
+            }
+            const keys = Object.keys(object);
+            for (let i = 0; i < keys.length; i++) {
+                const key = keys[i];
+                const value = object[key];
+                callback(key, value);
+            }
+        };
+        /**
+         * Prepeare grouped data
+         * @param rowData array odata result
+         * @param field grouping field
+         */
+        this.groupBy = (rowData, field) => {
+            var result = {};
+            const me = this;
+            rowData.forEach(function (item) {
+                var key = me.getValue(field, item);
+                var listForThisKey = result[key];
+                if (!listForThisKey) {
+                    listForThisKey = [];
+                    result[key] = listForThisKey;
+                }
+                listForThisKey.push(item);
+            });
+            return result;
+        };
+        /**
+         * Calculate total count records in group
+         * @param rowData array odata result data
+         * @param countField field contained count of all records
+         */
+        this.aggregateList = (rowData, countField) => {
+            var result = {};
+            rowData.forEach((row) => {
+                if (countField && row[countField] != null) {
+                    const totalCount = (result[countField] || 0) + (row[countField] || 0);
+                    delete row[countField];
+                    result[countField] = totalCount;
+                }
+                result = Object.assign(result, row);
+            });
+            return result;
+        };
+        /**
+             * Calculate distinct values for input field from Odata api
+             * @param field The field of the row to get the cells data from
+             * @param callback The function for return distinct values for input field
+             * @param beforeRequest The function for customize request
+             * @example
+             * <pre><code>
+             *  const setFilterValuesFuncParams = params => {
+             *    const me = this
+             *    const col = params.colDef.field
+             *    const storeName = me.getStoreName(col)
+             *    const callback = data => {
+             *      if (data) {
+             *        me.setState({ [storeName]: data })
+             *        params.success(data)
+             *      }
+             *    }
+             *    odataProviderInstance.getFilterValuesParams(params.colDef.field, callback)
+             *  }
+             *
+             * ///....
+             *      <AgGridColumn
+                          field="product"
+                          headerName={'PRODUCT'}
+                          filter="agSetColumnFilter"
+                          // rowGroup
+                          // enablePivot
+                          enableRowGroup
+                          filterParams={{
+                            values: setFilterValuesFuncParams,
+                            newRowsAction: 'keep'
+                          }}
+                          // filterParams={{caseSensitive: true}}
+                        />
+             * </code></pre>
+             */
+        this.getFilterValuesParams = (field, callback, beforeRequest) => {
+            const me = this;
+            const options = {
+                apply: [`groupby((${me.getWrapColumnName(field)}))`],
+            };
+            if (beforeRequest) {
+                beforeRequest(options);
+            }
+            me.callApi(me.toQuery(options)).then((x) => {
+                if (x) {
+                    let values = me.getOdataResult(x);
+                    callback(values.map((y) => y[field]));
+                }
+            });
+        };
+        /**
+         * Detect is string value
+         * @param value
+         */
+        this.isStrVal = (value) => typeof value === 'string';
+        /**
+         * Extartc values from odata response
+         * @param response
+         */
+        this.getOdataResult = (response) => Array.isArray(response) ? response : response.value;
+        /**
+         * Endocing column name to odata notation
+         * @param colName column name
+         */
+        this.getWrapColumnName = (colName) => colName ? replaceAll(colName, '.', '/') : '';
+        /**
+         * Set result
+         * @param params ag-grid details for the request
+         * @param isServerMode detect type of params
+         * @param rowsThisBlock data of the request
+         * @param rowCount count of total result
+         */
+        this.setResult = (params, isServerMode, rowsThisBlock, rowCount) => {
+            if (isServerMode) {
+                params.success({
+                    rowData: rowsThisBlock,
+                    rowCount: rowCount,
+                });
+            }
+            else {
+                params.successCallback(rowsThisBlock, rowCount);
+            }
+        };
+        /**
+         * Generate odata options for build query from ag-grid request
+         * @param params ag-grid details for the request
+         */
+        this.getOdataOptions = (params) => {
+            const me = this;
+            const options = {};
+            const isServerMode = 'request' in params;
+            const request = isServerMode
+                ? params.request
+                : params;
+            const childCount = me.groupCountFieldName;
+            if (this.beforeRequest) {
+                this.beforeRequest(options, this, request);
+            }
+            if (request.sortModel.length > 0) {
+                const sort = options.sort || [];
+                for (let i = 0; i < request.sortModel.length; i++) {
+                    const col = request.sortModel[i];
+                    let colName = me.getWrapColumnName(col.colId);
+                    if (col.sort !== 'asc') {
+                        colName += ' desc';
+                    }
+                    sort.push(colName);
+                }
+                options.sort = sort;
+            }
+            const filter = options.filter || [];
+            for (const colName in request.filterModel) {
+                if (request.filterModel.hasOwnProperty(colName)) {
+                    const col = request.filterModel[colName];
+                    let colFilter = '';
+                    if (!col.operator) {
+                        colFilter = me.getFilterOdata(colName, col);
+                        if (colFilter) {
+                            filter.push(colFilter);
+                        }
+                    }
+                    else {
+                        const condition1 = me.getFilterOdata(colName, col.condition1);
+                        const condition2 = me.getFilterOdata(colName, col.condition2);
+                        if (condition1 && condition2) {
+                            colFilter = `(${condition1} ${col.operator.toLowerCase()} ${condition2})`;
+                            filter.push(colFilter);
+                        }
+                    }
+                }
+            }
+            let pivotActive = false;
+            const apply = options.apply || [];
+            if (isServerMode) {
+                const requestSrv = request;
+                pivotActive =
+                    requestSrv.pivotMode &&
+                        requestSrv.pivotCols.length > 0 &&
+                        requestSrv.valueCols.length > 0;
+                if (requestSrv.rowGroupCols.length > 0) {
+                    const filterGroupBy = [];
+                    if (requestSrv.groupKeys.length < requestSrv.rowGroupCols.length) {
+                        // If request only groups
+                        for (let idx = 0; idx < requestSrv.groupKeys.length; idx++) {
+                            const colValue = requestSrv.groupKeys[idx];
+                            const condition = `${me.getWrapColumnName(requestSrv.rowGroupCols[idx].field)} eq ${(me.isStrVal(colValue) ? "'" : '') +
+                                me.encode(colValue) +
+                                (me.isStrVal(colValue) ? "'" : '')}`;
+                            filterGroupBy.push(condition);
+                        }
+                        if (filterGroupBy.length > 0 || filter.length > 0) {
+                            // Filters must by first
+                            apply.push(`filter(${filterGroupBy.concat(filter).join(' and ')})`);
+                        }
+                        const aggregate = [];
+                        if (childCount) {
+                            aggregate.push(me.odataAggregation.count(childCount));
+                        }
+                        if (requestSrv.valueCols.length > 0) {
+                            for (let idx = 0; idx < requestSrv.valueCols.length; idx++) {
+                                const colValue = requestSrv.valueCols[idx];
+                                colValue.aggFunc &&
+                                    aggregate.push(me.odataAggregation[colValue.aggFunc](me.getWrapColumnName(colValue.field)));
+                            }
+                        }
+                        let groups = [
+                            me.getWrapColumnName(requestSrv.rowGroupCols[requestSrv.groupKeys.length].field),
+                        ];
+                        const sort = options.sort || [];
+                        const sortColOnly = sort.map((x) => x.split(' ')[0]);
+                        if (pivotActive) {
+                            groups = groups.concat(requestSrv.pivotCols.map((x) => me.getWrapColumnName(x.field)));
+                            groups.forEach((x) => {
+                                if (sortColOnly.indexOf(x) < 0) {
+                                    sort.push(x);
+                                }
+                            });
+                        }
+                        options.sort = sort;
+                        apply.push(`groupby((${groups.join(',')})${aggregate.length > 0 ? `,aggregate(${aggregate.join(',')})` : ''})`);
+                        options.apply = apply;
+                        if (options.sort && options.sort.length > 0) {
+                            options.sort = options.sort.filter((x) => groups.indexOf(x.split(' ')[0]) >= 0);
+                        }
+                        // delete options.sort;
+                    }
+                    else {
+                        // If request rowData by group filter
+                        for (let idx = 0; idx < requestSrv.groupKeys.length; idx++) {
+                            const colValue = requestSrv.groupKeys[idx];
+                            const condition = `${me.getWrapColumnName(requestSrv.rowGroupCols[idx].field)} eq ${(me.isStrVal(colValue) ? "'" : '') +
+                                me.encode(colValue) +
+                                (me.isStrVal(colValue) ? "'" : '')}`;
+                            filter.push(condition);
+                        }
+                    }
+                }
+            }
+            if (filter.length > 0) {
+                options.filter = filter;
+            }
+            if (apply.length > 0) {
+                options.apply = apply;
+                delete options.filter;
+                delete options.expand;
+                delete options.select;
+                // options.sort = null;
+            }
+            options.skip = request.startRow;
+            options.top = (request.endRow || 0) - (request.startRow || 0);
+            if (!options.apply && options.skip === 0) {
+                options.count = true;
+            }
+            return options;
+        };
+        /**
+         * Generate odata query from ag-grid request
+         * @param params ag-grid details for the request
+         */
+        this.getOdataQuery = (params) => this.toQuery(this.getOdataOptions(params));
+        Object.assign(this, options);
+        if (this.callApi == null) {
+            throw new Error('callApi must be specified');
+        }
+        if (typeof this.callApi !== 'function') {
+            throw new Error('callApi must be a function');
+        }
+        if (this.beforeRequest != null &&
+            typeof this.beforeRequest !== 'function') {
+            throw new Error('beforeRequest must be a function');
+        }
+        if (this.afterLoadData != null &&
+            typeof this.afterLoadData !== 'function') {
+            throw new Error('afterLoadData must be a function');
+        }
+        if (this.setError != null && typeof this.setError !== 'function') {
+            throw new Error('setError must be a function');
+        }
+        this.cancelPromice = this.createCancelablePromise();
+    }
+    /**
+     * Extract value from record by path to field
+     * @param field path to column value
+     * @param obj  record
+     */
+    getValue(field, obj) {
+        const paths = field.split('.');
+        if (paths.length === 1) {
+            return obj[field];
+        }
+        else {
+            return paths.reduce((object, path) => {
+                return (object || {})[path]; // Oliver Steele's pattern
+            }, obj);
+        }
+    }
+    /**
+     * grid calls this to get rows for IServerSideDatasource
+     * @param params ag-grid details for the request
+     */
+    /**
+     * grid calls this to get rows implement
+     * @param params ag-grid details for the request
+     */
+    getRows(params) {
+        const me = this;
+        const childCount = me.groupCountFieldName;
+        const isServerMode = 'request' in params;
+        const request = isServerMode
+            ? params.request
+            : params;
+        const requestSrv = request;
+        const pivotActive = !isServerMode
+            ? false
+            : requestSrv.pivotMode &&
+                requestSrv.pivotCols.length > 0 &&
+                requestSrv.valueCols.length > 0;
+        if (!pivotActive) {
+            let fn = params.columnApi.setPivotResultColumns;
+            if (fn != null) {
+                // if ((params as any).columnApi.isPivotMode()) {
+                params.columnApi.setPivotResultColumns([]);
+                // }
+            }
+            else {
+                params.columnApi.setSecondaryColumns([]);
+            }
+        }
+        const options = me.getOdataOptions(params);
+        const query = me.toQuery(options);
+        if (options.skip === 0 &&
+            (!isServerMode ||
+                (isServerMode &&
+                    params.parentNode.level === -1))) {
+            me.cancelPromice.cancel();
+            me.cancelPromice = me.createCancelablePromise();
+        }
+        Promise.race([me.cancelPromice.promise, me.callApi(query)]).then(async (x) => {
+            if (!x) {
+                params.failCallback();
+            }
+            else {
+                const values = me.getOdataResult(x);
+                if (!pivotActive) {
+                    if (!options.apply) {
+                        me.setResult(params, isServerMode, values, x['@odata.count'] || x[0]?.totalCount);
+                        if (this.afterLoadData) {
+                            this.afterLoadData(options, values, x['@odata.count'] || x[0]?.totalCount);
+                        }
+                    }
+                    else {
+                        let count = values.length;
+                        if (count === options.top && options.skip === 0) {
+                            // If received grouped count of value large than requested then request total count of values
+                            me.callApi(query + '/aggregate($count as count)').then((y) => {
+                                count = me.getOdataResult(y)[0].count;
+                                me.setResult(params, isServerMode, values, count);
+                            });
+                        }
+                        else {
+                            if (options.skip != null && options.skip > 0) {
+                                count = null;
+                            }
+                            me.setResult(params, isServerMode, values, count);
+                            if (this.afterLoadData) {
+                                this.afterLoadData(options, values, count);
+                            }
+                        }
+                    }
+                }
+                else {
+                    let rowData = me.getOdataResult(x);
+                    // Check count
+                    if (rowData.length === options.top &&
+                        options.skip === 0 &&
+                        requestSrv.groupKeys.length === 0) {
+                        let eof = false;
+                        while (!eof) {
+                            options.skip += options.top || 0;
+                            const subQuery = me.toQuery(options);
+                            const newRowData = await me.callApi(subQuery);
+                            if (!newRowData) {
+                                params.failCallback();
+                                return;
+                            }
+                            eof = newRowData.length !== options.top;
+                            rowData = rowData.concat(newRowData);
+                        }
+                    }
+                    const pivotResult = me.getPivot(requestSrv.pivotCols, requestSrv.rowGroupCols, requestSrv.valueCols, rowData, childCount);
+                    rowData = pivotResult.data;
+                    const secondaryColDefs = pivotResult.secondaryColDefs;
+                    rowData = me.buildGroupsFromData(rowData, requestSrv.rowGroupCols, requestSrv.groupKeys, childCount);
+                    const totalCount = requestSrv.groupKeys.length === 0
+                        ? rowData.length
+                        : rowData.length === options.top
+                            ? null
+                            : rowData.length;
+                    // if (totalCount > (options.top || 0)) {
+                    //   const serverSideBlock = (params as any).parentNode.rowModel
+                    //     .rowNodeBlockLoader.blocks[0];
+                    //   serverSideBlock.rowNodeCacheParams.blockSize = totalCount;
+                    //   serverSideBlock.endRow = serverSideBlock.startRow + totalCount;
+                    //   serverSideBlock.createRowNodes();
+                    // }
+                    me.setResult(params, isServerMode, rowData, totalCount);
+                    if (this.afterLoadData) {
+                        this.afterLoadData(options, rowData, totalCount);
+                    }
+                    if (requestSrv.groupKeys.length === 0) {
+                        if (this.beforeSetSecondaryColumns) {
+                            this.beforeSetSecondaryColumns(secondaryColDefs);
+                        }
+                        let fn = params.columnApi.setPivotResultColumns;
+                        if (fn) {
+                            params.columnApi.setPivotResultColumns(secondaryColDefs);
+                        }
+                        else {
+                            params.columnApi.setSecondaryColumns(secondaryColDefs);
+                        }
+                    }
+                }
+            }
+        }, (err) => {
+            me.setResult(params, isServerMode, [], 0);
+            if (this.setError) {
+                this.setError(err, params);
+            }
+        });
+    }
+}
+export class OdataProviderClient extends OdataProvider {
+    getRows(params) {
+        super.getRows(params);
+    }
+}
+export class OdataServerSideProvider extends OdataProvider {
+    getRows(params) {
+        super.getRows(params);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"oDataProvider.js","sourceRoot":"","sources":["../../../../../projects/basesite-shared-grid-lib/src/lib/helpers/oDataProvider.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  IGetRowsParams,\r\n  ColDef,\r\n  ColGroupDef,\r\n  ColumnVO,\r\n  IServerSideGetRowsRequest,\r\n  IServerSideGetRowsParams,\r\n} from 'ag-grid-community';\r\n\r\nimport {\r\n  OdataQueryExtendFull,\r\n  OdataQueryExtendOptions,\r\n  OdataQueryOptions,\r\n  PivotResultDat,\r\n} from './types';\r\n\r\nimport { replaceAll } from './utils';\r\nexport declare class OdataProviderOptions {\r\n  /**\r\n   * Function for call odata api\r\n   */\r\n  callApi: (query: string) => Promise<any>;\r\n  /**\r\n   * Name of field contain count of record results in grouping odata query\r\n   * @default childCount\r\n   */\r\n  groupCountFieldName?: string;\r\n  /**\r\n   * Use in odata build query\r\n   * @default false\r\n   */\r\n  isCaseSensitiveStringFilter?: boolean;\r\n  /**\r\n   * Callback for extend odata query options for implement user logic\r\n   */\r\n  beforeRequest?: (\r\n    options: OdataQueryOptions,\r\n    provider: OdataProvider,\r\n    request: IGetRowsParams | IServerSideGetRowsRequest\r\n  ) => void;\r\n  /**\r\n    * Callback for pivot or group for aplly column ag-grid settings\r\n    * @example\r\n    * <pre><code>\r\n    * beforeSetSecondaryColumns = secondaryColumns => {\r\n     for (let i = 0; i < secondaryColumns.length; i++) {\r\n       const col = secondaryColumns[i]\r\n       if (col.children) {\r\n         beforeSetSecondaryColumns(col.children)\r\n       } else {\r\n         //Aplly new setting for group dyncamic created column\r\n         // col.cellClassRules = \r\n         // col.valueFormatter = \r\n       }\r\n     }\r\n   }\r\n    * </pre></code>\r\n    */\r\n  beforeSetSecondaryColumns?: (\r\n    secondaryColDefs: (ColDef | ColGroupDef)[]\r\n  ) => void;\r\n  /**\r\n    * Callback invoked after load data\r\n    * @param options odata provider options\r\n    * @param rowData data for ag-grid\r\n    * @param totalCount total count records\r\n    * \r\n    * @example\r\n    * <pre><code>\r\n         afterLoadData = (options, rowData, totalCount) => {\r\n             if (options.skip === 0 && rowData.length > 0) {\r\n             gridApi.columnController.autoSizeAllColumns()\r\n             }\r\n         }\r\n    * </code></pre>\r\n    */\r\n  afterLoadData?: (\r\n    options: OdataQueryExtendOptions,\r\n    rowData: any[],\r\n    totalCount: number\r\n  ) => void;\r\n  /**\r\n   * Callback for catch error\r\n   */\r\n  setError?: (\r\n    error: any,\r\n    params: IGetRowsParams | IServerSideGetRowsParams\r\n  ) => void;\r\n  /**\r\n   * List of columns by id/field are case sensitive for build odata query\r\n   */\r\n  caseSensitiveColumns?: string[];\r\n  /**\r\n     * Use for specified column custom filter implementation\r\n     * <pre><code>\r\n         customFilters: {\r\n             \"customer\": (colName,col,isCaseSensitiveStringFilter,provider) =>{\r\n               return provider.odataOperator.in(\r\n                colName,\r\n                col.values\r\n              )\r\n             }\r\n         }\r\n     */\r\n  customFilters?: {\r\n    [index: string]: (\r\n      colName: string,\r\n      col: any,\r\n      isCaseSensitiveStringFilter: boolean,\r\n      provider: OdataProvider\r\n    ) => string;\r\n  };\r\n}\r\n\r\ndeclare interface CancelablePromise {\r\n  promise: Promise<any>;\r\n  cancel: () => void;\r\n}\r\nexport class OdataProvider implements OdataProviderOptions {\r\n  /**\r\n   * Function for call odata api\r\n   */\r\n  callApi!: (query: string) => Promise<any>;\r\n  /**\r\n   * Name of field contain count of record results in grouping odata query\r\n   * @default childCount\r\n   */\r\n  groupCountFieldName: string = 'childCount';\r\n  /**\r\n   * Use in odata build query\r\n   * @default false\r\n   */\r\n  isCaseSensitiveStringFilter: boolean = false;\r\n  /**\r\n   * Callback for extend odata query options for implement user logic\r\n   */\r\n  beforeRequest:\r\n    | ((\r\n        options: OdataQueryOptions,\r\n        provider: OdataProvider,\r\n        request: IGetRowsParams | IServerSideGetRowsRequest\r\n      ) => void)\r\n    | undefined;\r\n  /**\r\n      * Callback for pivot or group for aplly column ag-grid settings\r\n      * @example\r\n      * <pre><code>\r\n      * beforeSetSecondaryColumns = secondaryColumns => {\r\n       for (let i = 0; i < secondaryColumns.length; i++) {\r\n         const col = secondaryColumns[i]\r\n         if (col.children) {\r\n           beforeSetSecondaryColumns(col.children)\r\n         } else {\r\n           //Aplly new setting for group dyncamic created column\r\n           // col.cellClassRules = \r\n           // col.valueFormatter = \r\n         }\r\n       }\r\n     }\r\n      * </pre></code>\r\n      */\r\n  beforeSetSecondaryColumns:\r\n    | ((secondaryColDefs: (ColDef | ColGroupDef)[]) => void)\r\n    | undefined;\r\n  /**\r\n      * Callback invoked after load data\r\n      * @param options odata provider options\r\n      * @param rowData data for ag-grid\r\n      * @param totalCount total count records\r\n      * \r\n      * @example\r\n      * <pre><code>\r\n           afterLoadData = (options, rowData, totalCount) => {\r\n               if (options.skip === 0 && rowData.length > 0) {\r\n               gridApi.columnController.autoSizeAllColumns()\r\n               }\r\n           }\r\n      * </code></pre>\r\n      */\r\n  afterLoadData:\r\n    | ((\r\n        options: OdataQueryExtendOptions,\r\n        rowData: any[],\r\n        totalCount: number\r\n      ) => void)\r\n    | undefined;\r\n  /**\r\n   * Callback for catch error\r\n   */\r\n  setError:\r\n    | ((error: any, params: IGetRowsParams | IServerSideGetRowsParams) => void)\r\n    | undefined;\r\n  /**\r\n   * List of columns by id/field are case sensitive for build odata query\r\n   */\r\n  caseSensitiveColumns?: string[];\r\n  /**\r\n     * Use for specified column custom filter implementation\r\n     * <pre><code>\r\n         customFilters: {\r\n             \"customer\": (colName,col,isCaseSensitiveStringFilter,provider) =>{\r\n               return provider.odataOperator.in(\r\n                colName,\r\n                col.values\r\n              )\r\n             }\r\n         }\r\n     */\r\n  customFilters?: {\r\n    [index: string]: (\r\n      colName: string,\r\n      col: any,\r\n      isCaseSensitiveStringFilter: boolean,\r\n      provider: OdataProvider\r\n    ) => string;\r\n  };\r\n  cancelPromice: CancelablePromise;\r\n  constructor(options: OdataProviderOptions) {\r\n    Object.assign(this, options);\r\n    if (this.callApi == null) {\r\n      throw new Error('callApi must be specified');\r\n    }\r\n    if (typeof this.callApi !== 'function') {\r\n      throw new Error('callApi must be a function');\r\n    }\r\n    if (\r\n      this.beforeRequest != null &&\r\n      typeof this.beforeRequest !== 'function'\r\n    ) {\r\n      throw new Error('beforeRequest must be a function');\r\n    }\r\n    if (\r\n      this.afterLoadData != null &&\r\n      typeof this.afterLoadData !== 'function'\r\n    ) {\r\n      throw new Error('afterLoadData must be a function');\r\n    }\r\n    if (this.setError != null && typeof this.setError !== 'function') {\r\n      throw new Error('setError must be a function');\r\n    }\r\n    this.cancelPromice = this.createCancelablePromise();\r\n  }\r\n\r\n  /**Creator a cancelable Promise */\r\n  createCancelablePromise = (): CancelablePromise => {\r\n    let cancel: any;\r\n    const pr = new Promise((_, reject) => {\r\n      cancel = reject;\r\n    }).catch(() => {});\r\n    return {\r\n      promise: pr,\r\n      cancel,\r\n    };\r\n  };\r\n  /**Odata query operations */\r\n  odataOperator: any = {\r\n    // Logical\r\n    equals: (col: string, value1: string): string => `${col} eq ${value1}`,\r\n    blank: (col: string, value1: string): string => `${col} eq ${value1}`,\r\n    notBlank: (col: string, value1: string): string => `${col} ne ${value1}`,\r\n    notEqual: (col: string, value1: string): string => `${col} ne ${value1}`,\r\n    lessThan: (col: string, value1: string): string => `${col} lt ${value1}`,\r\n    lessThanOrEqual: (col: string, value1: string): string =>\r\n      `${col} le ${value1}`,\r\n    greaterThan: (col: string, value1: string): string => `${col} gt ${value1}`,\r\n    greaterThanOrEqual: (col: string, value1: string): string =>\r\n      `${col} ge ${value1}`,\r\n    inRange: (col: string, value1: string, value2: any): string =>\r\n      `(${col} ge ${value1} and ${col} le ${value2})`,\r\n    // String\r\n    equalsStr: (\r\n      col: string,\r\n      value1: string,\r\n      isCaseSensitiveStringFilter: boolean\r\n    ): string =>\r\n      `${this.ifTolowerCol(\r\n        col,\r\n        isCaseSensitiveStringFilter\r\n      )} eq ${this.ifTolower(value1, isCaseSensitiveStringFilter)}`,\r\n    notEqualStr: (\r\n      col: string,\r\n      value1: string,\r\n      isCaseSensitiveStringFilter: boolean\r\n    ): string =>\r\n      `${this.ifTolowerCol(\r\n        col,\r\n        isCaseSensitiveStringFilter\r\n      )} ne ${this.ifTolower(value1, isCaseSensitiveStringFilter)}`,\r\n    contains: (\r\n      col: string,\r\n      value1: string,\r\n      isCaseSensitiveStringFilter: boolean\r\n    ): string =>\r\n      `contains(${this.ifTolowerCol(\r\n        col,\r\n        isCaseSensitiveStringFilter\r\n      )},${this.ifTolower(value1, isCaseSensitiveStringFilter)})`,\r\n    notContains: (\r\n      col: string,\r\n      value1: string,\r\n      isCaseSensitiveStringFilter: boolean\r\n    ): string =>\r\n      `contains(${this.ifTolowerCol(\r\n        col,\r\n        isCaseSensitiveStringFilter\r\n      )},${this.ifTolower(value1, isCaseSensitiveStringFilter)}) eq false`,\r\n    startsWith: (\r\n      col: string,\r\n      value1: string,\r\n      isCaseSensitiveStringFilter: boolean\r\n    ): string =>\r\n      `startswith(${this.ifTolowerCol(\r\n        col,\r\n        isCaseSensitiveStringFilter\r\n      )},${this.ifTolower(value1, isCaseSensitiveStringFilter)})  eq true`,\r\n    endsWith: (\r\n      col: string,\r\n      value1: string,\r\n      isCaseSensitiveStringFilter: boolean\r\n    ): string =>\r\n      `endswith(${this.ifTolowerCol(\r\n        col,\r\n        isCaseSensitiveStringFilter\r\n      )},${this.ifTolower(value1, isCaseSensitiveStringFilter)})  eq true`,\r\n    inStr: (\r\n      col: string,\r\n      values: string[],\r\n      isCaseSensitiveStringFilter: boolean\r\n    ): string =>\r\n      `${this.ifTolowerCol(col, isCaseSensitiveStringFilter)} in (${values\r\n        .map(\r\n          (x) =>\r\n            `'${this.ifTolower(this.encode(x), isCaseSensitiveStringFilter)}'`\r\n        )\r\n        .join()})`,\r\n    in: (col: string, values: string[]) =>\r\n      `${col} in (${values.map((x) => `${this.encode(x)}`).join()})`,\r\n    notIn: (col: string, values: string[]) =>\r\n      `not (${col} in (${values.map((x) => `${x}`).join()}))`,\r\n    // Date\r\n    trunc: (col: string): string => `date(${col})`,\r\n  };\r\n\r\n  /**\r\n   * Apply tolower for column in odata syntax\r\n   * @param col column name\r\n   * @param isCaseSensitiveStringFilter need apply tolower\r\n   */\r\n  ifTolowerCol = (col: string, isCaseSensitiveStringFilter: boolean): string =>\r\n    isCaseSensitiveStringFilter ? col : `tolower(${col})`;\r\n\r\n  /**\r\n   *\r\n   * @param value string value\r\n   * @param isCaseSensitiveStringFilter  need apply tolower\r\n   */\r\n  ifTolower = (value: string, isCaseSensitiveStringFilter: boolean): string =>\r\n    isCaseSensitiveStringFilter ? value : value ? value.toLowerCase() : value;\r\n  /**\r\n   * Odata aggregation operations\r\n   */\r\n  odataAggregation: any = {\r\n    // Logical\r\n    sum: (col: string, asField?: any): string =>\r\n      `${col} with sum as ${col || asField}`,\r\n    min: (col: string, asField?: any): string =>\r\n      `${col} with min as ${col || asField}`,\r\n    max: (col: string, asField?: any): string =>\r\n      `${col} with max as ${col || asField}`,\r\n    avg: (col: string, asField?: any): string =>\r\n      `${col} with average as ${col || asField}`,\r\n    count: (col: string, asField?: any): string =>\r\n      `$count as ${col || asField}`,\r\n  };\r\n  /**\r\n   * Odata query builder\r\n   * @param options parameter for odata query\r\n   */\r\n  toQuery = (options: OdataQueryExtendFull): string => {\r\n    let path: string[] = [];\r\n    if (options) {\r\n      path.push('$count=true');\r\n    }\r\n    if (options.skip) {\r\n      path.push(`$skip=${options.skip}`);\r\n    }\r\n    if (options.top) {\r\n      path.push(`$top=${options.top}`);\r\n    }\r\n    if (options.sort && options.sort.length > 0) {\r\n      path.push('$orderby=' + options.sort.join(','));\r\n    }\r\n    if (options.filter && options.filter.length > 0) {\r\n      path.push('$filter=' + options.filter.join(' and '));\r\n    }\r\n    if (options.apply && options.apply.length > 0) {\r\n      path.push('$apply=' + options.apply.join('/'));\r\n    }\r\n    if (options.expand && options.expand.length > 0) {\r\n      path.push('$expand=' + options.expand.join(','));\r\n    }\r\n    if (options.select && options.select.length > 0) {\r\n      path.push('$select=' + options.select.join(','));\r\n    }\r\n    let query: string = '';\r\n    if (path.length > 0) {\r\n      var defaultFilters = path.filter((x: any) => {\r\n        if (\r\n          x.indexOf('$count') >= 0 ||\r\n          x.indexOf('$top') >= 0 ||\r\n          x.indexOf('$orderby') >= 0 ||\r\n          x.indexOf('$apply') >= 0 ||\r\n          x.indexOf('$expand') >= 0 ||\r\n          x.indexOf('$select') >= 0\r\n        ) {\r\n          return x;\r\n        }\r\n      });\r\n      if (defaultFilters && defaultFilters.length > 0) {\r\n        query = '?' + defaultFilters.join('&');\r\n      }\r\n      var customFilters = path.filter(function (obj) {\r\n        return defaultFilters.indexOf(obj) == -1;\r\n      });\r\n      if (customFilters && customFilters.length > 0) {\r\n        if (customFilters.length == 1) query = query + '&' + customFilters;\r\n        else query = query + customFilters.join('and');\r\n      }\r\n    }\r\n    query = query.replace('and$filter=', '&filter=');\r\n    return query;\r\n  };\r\n  /**\r\n   * Add quotes for string value\r\n   * @param value string value\r\n   */\r\n  encode = (value: string): string =>\r\n    this.isStrVal(value) ? replaceAll(value, \"'\", \"''\") : value;\r\n  /**\r\n   * Conctat to date a time for create datetime format for odata query\r\n   * @param value date string\r\n   */\r\n  toDateTime = (value: string): string | null => {\r\n    const dt = new Date(value);\r\n    if (isNaN(dt.getTime())) return null;\r\n    const dt1 = new Date(\r\n      Date.UTC(dt.getFullYear(), dt.getMonth(), dt.getDate())\r\n    );\r\n    return dt1.toISOString();\r\n  };\r\n  /**\r\n   *\r\n   * @param colName columnName\r\n   * @returns is CaseSensitive for column\r\n   */\r\n  private getIsNeedCaseSensitive = (colName: string) => {\r\n    if (\r\n      !this.isCaseSensitiveStringFilter &&\r\n      this.caseSensitiveColumns &&\r\n      this.caseSensitiveColumns.length > 0\r\n    ) {\r\n      return this.caseSensitiveColumns.indexOf(colName) >= 0;\r\n    }\r\n    return this.isCaseSensitiveStringFilter;\r\n  };\r\n  /**\r\n   * Convert ag-grid column filter to odata query\r\n   * @param colName columnName\r\n   * @param col ag-grid column\r\n   */\r\n  private getFilterOdata = (colName: string, col: any): string => {\r\n    const me = this;\r\n    const isCaseSensitiveStringFilter = me.getIsNeedCaseSensitive(colName);\r\n    const customFilter = me.customFilters && me.customFilters[colName];\r\n    colName = replaceAll(colName, '.', '/');\r\n    colName = me.getWrapColumnName(colName);\r\n    if (customFilter) {\r\n      return customFilter(colName, col, isCaseSensitiveStringFilter, me);\r\n    } else {\r\n      switch (col.filterType) {\r\n        case 'number':\r\n          return me.odataOperator[col.type](colName, col.filter, col.filterTo);\r\n        case 'text': {\r\n          let operatorName = col.type;\r\n          const filter = me.encode(col.filter) || '';\r\n          // let filterTo = me.encode(col.filterTo);\r\n          if (\r\n            (operatorName === 'equals' || operatorName === 'notEqual') &&\r\n            !isCaseSensitiveStringFilter\r\n          ) {\r\n            operatorName += 'Str';\r\n          }\r\n          return me.odataOperator[operatorName](\r\n            colName,\r\n            `'${filter}'`,\r\n            isCaseSensitiveStringFilter\r\n          );\r\n        }\r\n        case 'date':\r\n          if (\r\n            col.dateFrom != null &&\r\n            me.toDateTime(col.dateFrom) != null &&\r\n            (col.dateTo == null ||\r\n              (col.dateTo != null && me.toDateTime(col.dateTo) != null))\r\n          ) {\r\n            return me.odataOperator[col.type](\r\n              colName,\r\n              `${me.toDateTime(col.dateFrom)}`,\r\n              `${me.toDateTime(col.dateTo)}`\r\n            );\r\n          }\r\n          break;\r\n        case 'set':\r\n          return col.values.length > 0\r\n            ? me.odataOperator.inStr(\r\n                colName,\r\n                col.values,\r\n                isCaseSensitiveStringFilter\r\n              )\r\n            : '';\r\n        default:\r\n          break;\r\n      }\r\n    }\r\n    return '';\r\n  };\r\n\r\n  /**\r\n   * Extract value from record by path to field\r\n   * @param field path to column value\r\n   * @param obj  record\r\n   */\r\n  private getValue(field: string, obj: any): any {\r\n    const paths = field.split('.');\r\n    if (paths.length === 1) {\r\n      return obj[field];\r\n    } else {\r\n      return paths.reduce((object, path) => {\r\n        return (object || {})[path]; // Oliver Steele's pattern\r\n      }, obj);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Caclulate pivot data for ag-grid from odata\r\n   * @param pivotCols pivot columns\r\n   * @param rowGroupCols row group columns\r\n   * @param valueCols value columns\r\n   * @param data odata result\r\n   * @param countField count field name\r\n   */\r\n  private getPivot = (\r\n    pivotCols: ColumnVO[],\r\n    rowGroupCols: ColumnVO[],\r\n    valueCols: ColumnVO[],\r\n    data: any[],\r\n    countField: string\r\n  ): PivotResultDat => {\r\n    // assume 1 pivot col and 1 value col for this example\r\n    const me = this;\r\n    const pivotData: any[] = [];\r\n    const aggColsList: any[] = [];\r\n\r\n    const colKeyExistsMap: any = {};\r\n\r\n    const secondaryColDefs: any[] = [];\r\n    const secondaryColDefsMap: any = {};\r\n\r\n    data.forEach(function (item) {\r\n      var pivotValues: string[] = [];\r\n      pivotCols.forEach(function (pivotCol) {\r\n        var pivotField = pivotCol.id;\r\n        var pivotValue = me.getValue(pivotField, item);\r\n        if (\r\n          pivotValue !== null &&\r\n          pivotValue !== undefined &&\r\n          pivotValue.toString\r\n        ) {\r\n          pivotValues.push(pivotValue.toString());\r\n        } else {\r\n          pivotValues.push('-');\r\n        }\r\n      });\r\n\r\n      // var pivotValue = item[pivotField].toString();\r\n      var pivotItem: any = {};\r\n\r\n      valueCols.forEach(function (valueCol) {\r\n        var valField = valueCol.id;\r\n        var colKey = createColKey(pivotValues, valField);\r\n\r\n        var value = me.getValue(valField, item);\r\n        pivotItem[colKey] = value;\r\n\r\n        if (!colKeyExistsMap[colKey]) {\r\n          addNewAggCol(colKey, valueCol);\r\n          addNewSecondaryColDef(colKey, pivotValues, valueCol);\r\n          colKeyExistsMap[colKey] = true;\r\n        }\r\n      });\r\n      if (countField) {\r\n        pivotItem[countField] = me.getValue(countField, item);\r\n      }\r\n\r\n      rowGroupCols.forEach(function (rowGroupCol) {\r\n        var rowGroupField = rowGroupCol.id.split('.')[0];\r\n        pivotItem[rowGroupField] = item[rowGroupField];\r\n      });\r\n\r\n      pivotData.push(pivotItem);\r\n    });\r\n\r\n    function addNewAggCol(colKey: string, valueCol: ColumnVO): void {\r\n      var newCol = {\r\n        id: colKey,\r\n        field: colKey,\r\n        aggFunc: valueCol.aggFunc,\r\n      };\r\n      aggColsList.push(newCol);\r\n    }\r\n\r\n    function addNewSecondaryColDef(\r\n      colKey: any,\r\n      pivotValues: any,\r\n      valueCol: any\r\n    ) {\r\n      var parentGroup: any = null;\r\n\r\n      var keyParts: any = [];\r\n\r\n      pivotValues.forEach(function (pivotValue: any) {\r\n        keyParts.push(pivotValue);\r\n        var colKey = createColKey(keyParts);\r\n        var groupColDef: any = secondaryColDefsMap[colKey];\r\n        if (!groupColDef) {\r\n          groupColDef = {\r\n            groupId: colKey,\r\n            headerName: pivotValue,\r\n            children: [],\r\n          };\r\n          secondaryColDefsMap[colKey] = groupColDef;\r\n          if (parentGroup) {\r\n            parentGroup.children.push(groupColDef);\r\n          } else {\r\n            secondaryColDefs.push(groupColDef);\r\n          }\r\n        }\r\n        parentGroup = groupColDef;\r\n      });\r\n\r\n      parentGroup.children.push({\r\n        colId: colKey,\r\n        headerName: valueCol.aggFunc + '(' + valueCol.displayName + ')',\r\n        field: colKey,\r\n        suppressMenu: true,\r\n        sortable: false,\r\n      });\r\n    }\r\n\r\n    function createColKey(pivotValues: string[], valueField?: string): string {\r\n      var result = pivotValues.join('|');\r\n      if (valueField !== undefined) {\r\n        result += '|' + valueField;\r\n      }\r\n      result = replaceAll(result, '.', '*');\r\n      return result;\r\n    }\r\n\r\n    return {\r\n      data: pivotData,\r\n      aggCols: aggColsList,\r\n      secondaryColDefs: secondaryColDefs,\r\n    };\r\n  };\r\n\r\n  /**\r\n   *\r\n   * @param rowData array odata result\r\n   * @param rowGroupCols row group columns\r\n   * @param groupKeys what groups the user is viewing\r\n   * @param countField count field name\r\n   */\r\n  private buildGroupsFromData = (\r\n    rowData: any[],\r\n    rowGroupCols: ColumnVO[],\r\n    groupKeys: string[],\r\n    countField: string\r\n  ): any[] => {\r\n    const me = this;\r\n    let rowGroupCol = rowGroupCols[groupKeys.length];\r\n    let field = rowGroupCol.id;\r\n    let mappedRowData = me.groupBy(rowData, field);\r\n    let groups: any = [];\r\n\r\n    me.iterateObject(mappedRowData, function (key, rowData) {\r\n      var groupItem = me.aggregateList(rowData, countField);\r\n      groupItem[field] = key;\r\n      groups.push(groupItem);\r\n    });\r\n    return groups;\r\n  };\r\n\r\n  /**\r\n   * Internal function for execute callback function for each property of object\r\n   * @param object object contained odata grouped result\r\n   * @param callback function do somthing\r\n   */\r\n  private iterateObject = (\r\n    object: any,\r\n    callback: (key: string, rowData: any[]) => void\r\n  ): void => {\r\n    if (!object) {\r\n      return;\r\n    }\r\n    const keys = Object.keys(object);\r\n    for (let i = 0; i < keys.length; i++) {\r\n      const key = keys[i];\r\n      const value = object[key];\r\n      callback(key, value);\r\n    }\r\n  };\r\n\r\n  /**\r\n   * Prepeare grouped data\r\n   * @param rowData array odata result\r\n   * @param field grouping field\r\n   */\r\n  private groupBy = (rowData: any[], field: string): any => {\r\n    var result: any = {};\r\n    const me = this;\r\n    rowData.forEach(function (item) {\r\n      var key = me.getValue(field, item);\r\n      var listForThisKey = result[key];\r\n      if (!listForThisKey) {\r\n        listForThisKey = [];\r\n        result[key] = listForThisKey;\r\n      }\r\n      listForThisKey.push(item);\r\n    });\r\n    return result;\r\n  };\r\n\r\n  /**\r\n   * Calculate total count records in group\r\n   * @param rowData array odata result data\r\n   * @param countField field contained count of all records\r\n   */\r\n  private aggregateList = (rowData: any[], countField: string): any => {\r\n    var result: any = {};\r\n    rowData.forEach((row) => {\r\n      if (countField && row[countField] != null) {\r\n        const totalCount = (result[countField] || 0) + (row[countField] || 0);\r\n        delete row[countField];\r\n        result[countField] = totalCount;\r\n      }\r\n      result = Object.assign(result, row);\r\n    });\r\n    return result;\r\n  };\r\n\r\n  /**\r\n       * Calculate distinct values for input field from Odata api\r\n       * @param field The field of the row to get the cells data from \r\n       * @param callback The function for return distinct values for input field\r\n       * @param beforeRequest The function for customize request\r\n       * @example \r\n       * <pre><code>\r\n       *  const setFilterValuesFuncParams = params => {\r\n       *    const me = this\r\n       *    const col = params.colDef.field\r\n       *    const storeName = me.getStoreName(col)\r\n       *    const callback = data => {\r\n       *      if (data) {\r\n       *        me.setState({ [storeName]: data })\r\n       *        params.success(data)\r\n       *      }\r\n       *    }\r\n       *    odataProviderInstance.getFilterValuesParams(params.colDef.field, callback)\r\n       *  }\r\n       * \r\n       * ///....\r\n       *      <AgGridColumn\r\n                    field=\"product\"\r\n                    headerName={'PRODUCT'}\r\n                    filter=\"agSetColumnFilter\"\r\n                    // rowGroup\r\n                    // enablePivot\r\n                    enableRowGroup\r\n                    filterParams={{\r\n                      values: setFilterValuesFuncParams,\r\n                      newRowsAction: 'keep'\r\n                    }}\r\n                    // filterParams={{caseSensitive: true}}\r\n                  />\r\n       * </code></pre>\r\n       */\r\n  getFilterValuesParams = (\r\n    field: string,\r\n    callback: (data: any[]) => void,\r\n    beforeRequest: (options: OdataQueryExtendFull) => void | undefined\r\n  ): void => {\r\n    const me = this;\r\n    const options: OdataQueryExtendFull = {\r\n      apply: [`groupby((${me.getWrapColumnName(field)}))`],\r\n    };\r\n    if (beforeRequest) {\r\n      beforeRequest(options);\r\n    }\r\n    me.callApi(me.toQuery(options)).then((x) => {\r\n      if (x) {\r\n        let values = me.getOdataResult(x);\r\n        callback(values.map((y: any) => y[field]));\r\n      }\r\n    });\r\n  };\r\n  /**\r\n   * Detect is string value\r\n   * @param value\r\n   */\r\n  isStrVal = (value: any): boolean => typeof value === 'string';\r\n  /**\r\n   * Extartc values from odata response\r\n   * @param response\r\n   */\r\n  private getOdataResult = (response: any): any =>\r\n    Array.isArray(response) ? response : response.value;\r\n  /**\r\n   * Endocing column name to odata notation\r\n   * @param colName column name\r\n   */\r\n  private getWrapColumnName = (colName: string | undefined): string =>\r\n    colName ? replaceAll(colName, '.', '/') : '';\r\n  /**\r\n   * grid calls this to get rows for IServerSideDatasource\r\n   * @param params ag-grid details for the request\r\n   */\r\n  /**\r\n   * grid calls this to get rows implement\r\n   * @param params ag-grid details for the request\r\n   */\r\n  public getRows(params: IGetRowsParams | IServerSideGetRowsParams): void {\r\n    const me = this;\r\n    const childCount = me.groupCountFieldName;\r\n    const isServerMode = 'request' in params;\r\n    const request = isServerMode\r\n      ? (params as IServerSideGetRowsParams).request\r\n      : (params as IGetRowsParams);\r\n    const requestSrv = request as IServerSideGetRowsRequest;\r\n\r\n    const pivotActive = !isServerMode\r\n      ? false\r\n      : requestSrv.pivotMode &&\r\n        requestSrv.pivotCols.length > 0 &&\r\n        requestSrv.valueCols.length > 0;\r\n\r\n    if (!pivotActive) {\r\n      let fn = (params as any).columnApi.setPivotResultColumns;\r\n      if (fn != null) {\r\n        // if ((params as any).columnApi.isPivotMode()) {\r\n        (params as any).columnApi.setPivotResultColumns([]);\r\n        // }\r\n      } else {\r\n        (params as any).columnApi.setSecondaryColumns([]);\r\n      }\r\n    }\r\n    const options = me.getOdataOptions(params);\r\n    const query = me.toQuery(options);\r\n    if (\r\n      options.skip === 0 &&\r\n      (!isServerMode ||\r\n        (isServerMode &&\r\n          (params as IServerSideGetRowsParams).parentNode.level === -1))\r\n    ) {\r\n      me.cancelPromice.cancel();\r\n      me.cancelPromice = me.createCancelablePromise();\r\n    }\r\n    Promise.race([me.cancelPromice.promise, me.callApi(query)]).then(\r\n      async (x) => {\r\n        if (!x) {\r\n          params.failCallback();\r\n        } else {\r\n          const values = me.getOdataResult(x);\r\n          if (!pivotActive) {\r\n            if (!options.apply) {\r\n              me.setResult(\r\n                params,\r\n                isServerMode,\r\n                values,\r\n                x['@odata.count'] || x[0]?.totalCount\r\n              );\r\n              if (this.afterLoadData) {\r\n                this.afterLoadData(\r\n                  options,\r\n                  values,\r\n                  x['@odata.count'] || x[0]?.totalCount\r\n                );\r\n              }\r\n            } else {\r\n              let count = values.length;\r\n              if (count === options.top && options.skip === 0) {\r\n                // If received grouped count of value large than requested then request total count of values\r\n                me.callApi(query + '/aggregate($count as count)').then((y) => {\r\n                  count = me.getOdataResult(y)[0].count;\r\n                  me.setResult(params, isServerMode, values, count);\r\n                });\r\n              } else {\r\n                if (options.skip != null && options.skip > 0) {\r\n                  count = null;\r\n                }\r\n                me.setResult(params, isServerMode, values, count);\r\n                if (this.afterLoadData) {\r\n                  this.afterLoadData(options, values, count);\r\n                }\r\n              }\r\n            }\r\n          } else {\r\n            let rowData = me.getOdataResult(x);\r\n            // Check count\r\n            if (\r\n              rowData.length === options.top &&\r\n              options.skip === 0 &&\r\n              requestSrv.groupKeys.length === 0\r\n            ) {\r\n              let eof = false;\r\n              while (!eof) {\r\n                options.skip += options.top || 0;\r\n                const subQuery = me.toQuery(options);\r\n                const newRowData = await me.callApi(subQuery);\r\n                if (!newRowData) {\r\n                  params.failCallback();\r\n                  return;\r\n                }\r\n                eof = newRowData.length !== options.top;\r\n                rowData = rowData.concat(newRowData);\r\n              }\r\n            }\r\n            const pivotResult = me.getPivot(\r\n              requestSrv.pivotCols,\r\n              requestSrv.rowGroupCols,\r\n              requestSrv.valueCols,\r\n              rowData,\r\n              childCount\r\n            );\r\n            rowData = pivotResult.data;\r\n            const secondaryColDefs = pivotResult.secondaryColDefs;\r\n            rowData = me.buildGroupsFromData(\r\n              rowData,\r\n              requestSrv.rowGroupCols,\r\n              requestSrv.groupKeys,\r\n              childCount\r\n            );\r\n            const totalCount =\r\n              requestSrv.groupKeys.length === 0\r\n                ? rowData.length\r\n                : rowData.length === options.top\r\n                ? null\r\n                : rowData.length;\r\n            // if (totalCount > (options.top || 0)) {\r\n            //   const serverSideBlock = (params as any).parentNode.rowModel\r\n            //     .rowNodeBlockLoader.blocks[0];\r\n            //   serverSideBlock.rowNodeCacheParams.blockSize = totalCount;\r\n            //   serverSideBlock.endRow = serverSideBlock.startRow + totalCount;\r\n            //   serverSideBlock.createRowNodes();\r\n            // }\r\n            me.setResult(params, isServerMode, rowData, totalCount);\r\n            if (this.afterLoadData) {\r\n              this.afterLoadData(options, rowData, totalCount);\r\n            }\r\n            if (requestSrv.groupKeys.length === 0) {\r\n              if (this.beforeSetSecondaryColumns) {\r\n                this.beforeSetSecondaryColumns(secondaryColDefs);\r\n              }\r\n              let fn = (params as any).columnApi.setPivotResultColumns;\r\n              if (fn) {\r\n                (params as any).columnApi.setPivotResultColumns(\r\n                  secondaryColDefs\r\n                );\r\n              } else {\r\n                (params as any).columnApi.setSecondaryColumns(secondaryColDefs);\r\n              }\r\n            }\r\n          }\r\n        }\r\n      },\r\n      (err) => {\r\n        me.setResult(params, isServerMode, [], 0);\r\n        if (this.setError) {\r\n          this.setError(err, params);\r\n        }\r\n      }\r\n    );\r\n  }\r\n  /**\r\n   * Set result\r\n   * @param params ag-grid details for the request\r\n   * @param isServerMode detect type of params\r\n   * @param rowsThisBlock data of the request\r\n   * @param rowCount count of total result\r\n   */\r\n  private setResult = (\r\n    params: IGetRowsParams | IServerSideGetRowsParams,\r\n    isServerMode: boolean,\r\n    rowsThisBlock: any[],\r\n    rowCount?: number\r\n  ): void => {\r\n    if (isServerMode) {\r\n      (params as IServerSideGetRowsParams).success({\r\n        rowData: rowsThisBlock,\r\n        rowCount: rowCount,\r\n      });\r\n    } else {\r\n      (params as IGetRowsParams).successCallback(rowsThisBlock, rowCount);\r\n    }\r\n  };\r\n  /**\r\n   * Generate odata options for build query from ag-grid request\r\n   * @param params ag-grid details for the request\r\n   */\r\n  getOdataOptions = (\r\n    params: IGetRowsParams | IServerSideGetRowsParams\r\n  ): OdataQueryExtendFull => {\r\n    const me = this;\r\n    const options: OdataQueryExtendFull = {};\r\n    const isServerMode = 'request' in params;\r\n    const request = isServerMode\r\n      ? (params as IServerSideGetRowsParams).request\r\n      : (params as IGetRowsParams);\r\n    const childCount = me.groupCountFieldName;\r\n    if (this.beforeRequest) {\r\n      this.beforeRequest(options, this, request);\r\n    }\r\n    if (request.sortModel.length > 0) {\r\n      const sort = options.sort || [];\r\n      for (let i = 0; i < request.sortModel.length; i++) {\r\n        const col = request.sortModel[i];\r\n        let colName = me.getWrapColumnName(col.colId);\r\n        if (col.sort !== 'asc') {\r\n          colName += ' desc';\r\n        }\r\n        sort.push(colName);\r\n      }\r\n      options.sort = sort;\r\n    }\r\n\r\n    const filter = options.filter || [];\r\n    for (const colName in request.filterModel) {\r\n      if (request.filterModel.hasOwnProperty(colName)) {\r\n        const col = request.filterModel[colName];\r\n        let colFilter = '';\r\n        if (!col.operator) {\r\n          colFilter = me.getFilterOdata(colName, col);\r\n          if (colFilter) {\r\n            filter.push(colFilter);\r\n          }\r\n        } else {\r\n          const condition1 = me.getFilterOdata(colName, col.condition1);\r\n          const condition2 = me.getFilterOdata(colName, col.condition2);\r\n          if (condition1 && condition2) {\r\n            colFilter = `(${condition1} ${col.operator.toLowerCase()} ${condition2})`;\r\n            filter.push(colFilter);\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    let pivotActive = false;\r\n\r\n    const apply = options.apply || [];\r\n    if (isServerMode) {\r\n      const requestSrv = request as IServerSideGetRowsRequest;\r\n      pivotActive =\r\n        requestSrv.pivotMode &&\r\n        requestSrv.pivotCols.length > 0 &&\r\n        requestSrv.valueCols.length > 0;\r\n      if (requestSrv.rowGroupCols.length > 0) {\r\n        const filterGroupBy: string[] = [];\r\n        if (requestSrv.groupKeys.length < requestSrv.rowGroupCols.length) {\r\n          // If request only groups\r\n          for (let idx = 0; idx < requestSrv.groupKeys.length; idx++) {\r\n            const colValue = requestSrv.groupKeys[idx];\r\n            const condition = `${me.getWrapColumnName(\r\n              requestSrv.rowGroupCols[idx].field\r\n            )} eq ${\r\n              (me.isStrVal(colValue) ? \"'\" : '') +\r\n              me.encode(colValue) +\r\n              (me.isStrVal(colValue) ? \"'\" : '')\r\n            }`;\r\n            filterGroupBy.push(condition);\r\n          }\r\n          if (filterGroupBy.length > 0 || filter.length > 0) {\r\n            // Filters must by first\r\n            apply.push(`filter(${filterGroupBy.concat(filter).join(' and ')})`);\r\n          }\r\n\r\n          const aggregate: string[] = [];\r\n          if (childCount) {\r\n            aggregate.push(me.odataAggregation.count(childCount));\r\n          }\r\n          if (requestSrv.valueCols.length > 0) {\r\n            for (let idx = 0; idx < requestSrv.valueCols.length; idx++) {\r\n              const colValue = requestSrv.valueCols[idx];\r\n              colValue.aggFunc &&\r\n                aggregate.push(\r\n                  me.odataAggregation[colValue.aggFunc](\r\n                    me.getWrapColumnName(colValue.field)\r\n                  )\r\n                );\r\n            }\r\n          }\r\n          let groups = [\r\n            me.getWrapColumnName(\r\n              requestSrv.rowGroupCols[requestSrv.groupKeys.length].field\r\n            ),\r\n          ];\r\n          const sort = options.sort || [];\r\n          const sortColOnly = sort.map((x) => x.split(' ')[0]);\r\n          if (pivotActive) {\r\n            groups = groups.concat(\r\n              requestSrv.pivotCols.map((x) => me.getWrapColumnName(x.field))\r\n            );\r\n            groups.forEach((x) => {\r\n              if (sortColOnly.indexOf(x) < 0) {\r\n                sort.push(x);\r\n              }\r\n            });\r\n          }\r\n          options.sort = sort;\r\n          apply.push(\r\n            `groupby((${groups.join(',')})${\r\n              aggregate.length > 0 ? `,aggregate(${aggregate.join(',')})` : ''\r\n            })`\r\n          );\r\n\r\n          options.apply = apply;\r\n          if (options.sort && options.sort.length > 0) {\r\n            options.sort = options.sort.filter(\r\n              (x) => groups.indexOf(x.split(' ')[0]) >= 0\r\n            );\r\n          }\r\n          // delete options.sort;\r\n        } else {\r\n          // If request rowData by group filter\r\n          for (let idx = 0; idx < requestSrv.groupKeys.length; idx++) {\r\n            const colValue = requestSrv.groupKeys[idx];\r\n            const condition = `${me.getWrapColumnName(\r\n              requestSrv.rowGroupCols[idx].field\r\n            )} eq ${\r\n              (me.isStrVal(colValue) ? \"'\" : '') +\r\n              me.encode(colValue) +\r\n              (me.isStrVal(colValue) ? \"'\" : '')\r\n            }`;\r\n            filter.push(condition);\r\n          }\r\n        }\r\n      }\r\n    }\r\n    if (filter.length > 0) {\r\n      options.filter = filter;\r\n    }\r\n    if (apply.length > 0) {\r\n      options.apply = apply;\r\n      delete options.filter;\r\n      delete options.expand;\r\n      delete options.select;\r\n      // options.sort = null;\r\n    }\r\n    options.skip = request.startRow;\r\n    options.top = (request.endRow || 0) - (request.startRow || 0);\r\n\r\n    if (!options.apply && options.skip === 0) {\r\n      options.count = true;\r\n    }\r\n    return options;\r\n  };\r\n  /**\r\n   * Generate odata query from ag-grid request\r\n   * @param params ag-grid details for the request\r\n   */\r\n  getOdataQuery = (params: IGetRowsParams | IServerSideGetRowsParams): string =>\r\n    this.toQuery(this.getOdataOptions(params));\r\n}\r\n\r\nexport class OdataProviderClient extends OdataProvider {\r\n  public override getRows(params: IServerSideGetRowsParams) {\r\n    super.getRows(params);\r\n  }\r\n}\r\nexport class OdataServerSideProvider extends OdataProvider {\r\n  public override getRows(params: IServerSideGetRowsParams): void {\r\n    super.getRows(params);\r\n  }\r\n}\r\n"]}