Extract unique values and apply filter strategy based on dimension memberName and function.

Author: MKirova

projects/igniteui-angular/src/lib/data-operations/pivot-strategy.ts

@@ -1,6 +1,9 @@
 
+import { GridType } from '../grids/common/grid.interface';
+import { IgxPivotGridComponent } from '../grids/pivot-grid/pivot-grid.component';
 import { IPivotDimension, IPivotKeys, IPivotValue, PivotDimensionType } from '../grids/pivot-grid/pivot-grid.interface';
 import { PivotUtil } from '../grids/pivot-grid/pivot-util';
+import { FilteringStrategy } from './filtering-strategy';
 
 export interface IPivotDimensionStrategy {
     process(collection: any,
@@ -149,3 +152,24 @@ export class PivotColumnDimensionsStrategy implements IPivotDimensionStrategy {
         return !(record[pivotKeys.records] && record[pivotKeys.records].some(r => r[pivotKeys.records]));
     }
 }
+
+export class DimensionValuesFilteringStrategy extends FilteringStrategy {
+    /**
+     * Creates a new instance of FormattedValuesFilteringStrategy.
+     *
+     * @param fields An array of column field names that should be formatted.
+     * If omitted the values of all columns which has formatter will be formatted.
+     */
+    constructor(private fields?: string[]) {
+        super();
+    }
+
+    protected getFieldValue(rec: any, fieldName: string, isDate: boolean = false, isTime: boolean = false,
+         grid?: IgxPivotGridComponent): any {
+        const config = grid.pivotConfiguration;
+        const allDimensions = config.rows.concat(config.columns).concat(config.filters).filter(x => x !== null);
+        const enabledDimensions = allDimensions.filter(x => x && x.enabled);
+        const dim = PivotUtil.flatten(enabledDimensions).find(x => x.memberName === fieldName);
+        return PivotUtil.extractValueFromDimension(dim, rec);
+    }
+}

projects/igniteui-angular/src/lib/grids/pivot-grid/pivot-grid.component.ts

@@ -30,12 +30,12 @@ import { GridType } from '../common/grid.interface';
 import { IgxGridNavigationService } from '../grid-navigation.service';
 import { IgxGridCRUDService } from '../common/crud.service';
 import { IgxGridSummaryService } from '../summaries/grid-summary.service';
-import { IPivotConfiguration, IPivotKeys, PivotDimensionType } from './pivot-grid.interface';
+import { IPivotConfiguration, IPivotDimension, IPivotKeys, PivotDimensionType } from './pivot-grid.interface';
 import { IgxPivotHeaderRowComponent } from './pivot-header-row.component';
 import { IgxColumnGroupComponent } from '../columns/column-group.component';
 import { IgxColumnComponent } from '../columns/column.component';
 import { PivotUtil } from './pivot-util';
-import { NoopPivotDimensionsStrategy } from '../../data-operations/pivot-strategy';
+import { DimensionValuesFilteringStrategy, NoopPivotDimensionsStrategy } from '../../data-operations/pivot-strategy';
 import { IgxGridExcelStyleFilteringComponent } from '../filtering/excel-style/grid.excel-style-filtering.component';
 import { IgxPivotGridNavigationService } from './pivot-grid-navigation.service';
 import { IgxColumnResizingService } from '../resizing/resizing.service';
@@ -46,6 +46,7 @@ import { cloneArray, PlatformUtil } from '../../core/utils';
 import { IgxGridTransaction } from '../hierarchical-grid/public_api';
 import { IgxPivotFilteringService } from './pivot-filtering.service';
 import { DataUtil } from '../../data-operations/data-util';
+import { IFilteringExpressionsTree } from '../../data-operations/filtering-expressions-tree';
 
 let NEXT_ID = 0;
 const MINIMUM_COLUMN_WIDTH = 200;
@@ -112,7 +113,7 @@ export class IgxPivotGridComponent extends IgxGridBaseDirective implements OnIni
 
 
     public columnGroupStates = new Map<string, boolean>();
-    public originalDataColumns;
+    public dimensionDataColumns;
     public pivotKeys: IPivotKeys = {aggregations: 'aggregations', records: 'records', children: 'children', level: 'level'};
     public isPivot = true;
     protected _defaultExpandState = true;
@@ -168,6 +169,7 @@ export class IgxPivotGridComponent extends IgxGridBaseDirective implements OnIni
     public ngOnInit() {
         // pivot grid always generates columns automatically.
         this.autoGenerate = true;
+        this.uniqueColumnValuesStrategy = this.uniqueColumnValuesStrategy || this.uniqueDimensionValuesStrategy;
         super.ngOnInit();
     }
 
@@ -188,6 +190,32 @@ export class IgxPivotGridComponent extends IgxGridBaseDirective implements OnIni
         });
     }
 
+    public uniqueDimensionValuesStrategy(column: IgxColumnComponent, exprTree: IFilteringExpressionsTree,
+        done: (uniqueValues: any[]) => void) {
+        const config = this.pivotConfiguration;
+        const allDimensions = config.rows.concat(config.columns).concat(config.filters).filter(x => x !== null);
+        const enabledDimensions = allDimensions.filter(x => x && x.enabled);
+        const dim = PivotUtil.flatten(enabledDimensions).find(x => x.memberName === column.field);
+        this.getDimensionData(dim, exprTree, uniqueValues => done(uniqueValues));
+    }
+
+    public getDimensionData(dim: IPivotDimension,
+        dimExprTree: IFilteringExpressionsTree,
+        done: (colVals: any[]) => void) {
+            let columnValues = [];
+            const data = this.gridAPI.get_data();
+            const allValuesHierarchy = PivotUtil.getFieldsHierarchy(
+                data,
+                [dim],
+                PivotDimensionType.Column,
+                {aggregations: 'aggregations', records: 'records', children: 'children', level: 'level'}
+                );
+            const flatData = Array.from(allValuesHierarchy.values());
+            columnValues = flatData.map(record => this.extractValue(record['value']));
+            done(columnValues);
+            return;
+    }
+
     /** @hidden */
     public featureColumnsWidth() {
         return this.pivotRowWidths;
@@ -367,7 +395,7 @@ export class IgxPivotGridComponent extends IgxGridBaseDirective implements OnIni
      protected autogenerateColumns() {
          let columns = [];
          const data = this.gridAPI.get_data();
-         this.originalDataColumns = this.generateOriginalColumns();
+         this.dimensionDataColumns = this.generateDimensionColumns();
          let fieldsMap;
          if (this.pivotConfiguration.columnStrategy && this.pivotConfiguration.columnStrategy instanceof NoopPivotDimensionsStrategy) {
             const fields = this.generateDataFields(data);
@@ -393,15 +421,15 @@ export class IgxPivotGridComponent extends IgxGridBaseDirective implements OnIni
         }
     }
 
-    protected generateOriginalColumns() {
-        const data = this.gridAPI.get_data();
-        const fields = this.generateDataFields(data);
+    protected generateDimensionColumns() {
+        const config = this.pivotConfiguration;
+        const allDimensions = config.rows.concat(config.columns).concat(config.filters).filter(x => x !== null);
+        const leafFields = PivotUtil.flatten(allDimensions, 0).filter(x => !x.childLevel).map(x => x.memberName);
         const columns = [];
         const factory = this.resolver.resolveComponentFactory(IgxColumnComponent);
-        fields.forEach((field) => {
+        leafFields.forEach((field) => {
             const ref = factory.create(this.viewRef.injector);
             ref.instance.field = field;
-            ref.instance.dataType = this.resolveDataTypes(data[0][field]);
             ref.changeDetectorRef.detectChanges();
             columns.push(ref.instance);
         });
@@ -436,10 +464,10 @@ export class IgxPivotGridComponent extends IgxGridBaseDirective implements OnIni
             if (value.dimension && value.dimension.filters) {
                 const state = {
                     expressionsTree: value.dimension.filters.filteringOperands[0],
-                    strategy: this.filterStrategy,
+                    strategy: this.filterStrategy || new DimensionValuesFilteringStrategy(),
                     advancedFilteringExpressionsTree: this.advancedFilteringExpressionsTree
                 };
-                const filtered = DataUtil.filter(cloneArray(value.records), state);
+                const filtered = DataUtil.filter(cloneArray(value.records), state, this);
                 if (filtered.length === 0) {
                     shouldGenerate = false;
                 }
@@ -514,4 +542,7 @@ export class IgxPivotGridComponent extends IgxGridBaseDirective implements OnIni
         });
         return cols;
     }
+    private extractValue(value) {
+        return value.split('-')[value.split('-').length - 1];
+    }
 }

projects/igniteui-angular/src/lib/grids/pivot-grid/pivot-grid.pipes.ts

@@ -4,9 +4,12 @@ import { DataUtil } from '../../data-operations/data-util';
 import { FilteringExpressionsTree, IFilteringExpressionsTree } from '../../data-operations/filtering-expressions-tree';
 import { IFilteringStrategy } from '../../data-operations/filtering-strategy';
 import { IPivotConfiguration, IPivotDimension, IPivotKeys } from './pivot-grid.interface';
-import { PivotColumnDimensionsStrategy, PivotRowDimensionsStrategy } from '../../data-operations/pivot-strategy';
+import { DimensionValuesFilteringStrategy, PivotColumnDimensionsStrategy,
+     PivotRowDimensionsStrategy } from '../../data-operations/pivot-strategy';
 import { PivotUtil } from './pivot-util';
 import { FilteringLogic } from '../../data-operations/filtering-expression.interface';
+import { GridBaseAPIService, IgxGridBaseDirective } from '../hierarchical-grid/public_api';
+import { GridType } from '../common/grid.interface';
 /**
  * @hidden
  */
@@ -96,7 +99,7 @@ export class IgxPivotColumnPipe implements PipeTransform {
     pure: true
 })
 export class IgxPivotGridFilterPipe implements PipeTransform {
-
+    constructor(private gridAPI: GridBaseAPIService<IgxGridBaseDirective & GridType>) { }
     public transform(collection: any[],
         config: IPivotConfiguration,
         filterStrategy: IFilteringStrategy,
@@ -115,15 +118,15 @@ export class IgxPivotGridFilterPipe implements PipeTransform {
         });
         const state = {
             expressionsTree,
-            strategy: filterStrategy,
+            strategy: filterStrategy || new DimensionValuesFilteringStrategy(),
             advancedExpressionsTree
         };
 
         if (FilteringExpressionsTree.empty(state.expressionsTree) && FilteringExpressionsTree.empty(state.advancedExpressionsTree)) {
             return collection;
         }
 
-        const result = DataUtil.filter(cloneArray(collection), state);
+        const result = DataUtil.filter(cloneArray(collection), state, this.gridAPI.grid);
 
         return result;
     }

projects/igniteui-angular/src/lib/grids/pivot-grid/pivot-header-row.component.ts

@@ -90,11 +90,11 @@ export class IgxPivotHeaderRowComponent extends IgxGridHeaderRowComponent {
         let dim = dimension;
         let col;
         while(dim) {
-            col = this.grid.originalDataColumns.find(x => x.field === dim.memberName || x.field === dim.member);
+            col = this.grid.dimensionDataColumns.find(x => x.field === dim.memberName || x.field === dim.member);
             if (col) {
                 break;
             } else {
-                dim = dimension.childLevel;
+                dim = dim.childLevel;
             }
         }
         this.grid.filteringService.toggleFilterDropdown(event.target, col);