Merge branch 'master' into mevtimov/feat-7344-master

Author: ChronosSF

projects/igniteui-angular/src/lib/core/utils.ts

@@ -103,6 +103,34 @@ export function cloneValue(value: any): any {
     return value;
 }
 
+/**
+ * Parse provided input to Date.
+ * @param value input to parse
+ * @returns Date if parse succeed or null
+ * @hidden
+ */
+export function parseDate(value: any): Date | null {
+    // if value is Invalid Date return null
+    if (isDate(value)) {
+        return !isNaN(value.getTime()) ? value : null;
+    }
+    return value ? new Date(value) : null;
+}
+
+/**
+ * Returns an array with unique dates only.
+ * @param columnValues collection of date values (might be numbers or ISO 8601 strings)
+ * @returns collection of unique dates.
+ * @hidden
+ */
+export function uniqueDates(columnValues: any[]) {
+    return columnValues.reduce((a, c) => {
+        if (!a.cache[c.label]) { a.result.push(c); }
+        a.cache[c.label] = true;
+        return a;
+      }, {result: [], cache: {}}).result;
+}
+
 /**
  * Checks if provided variable is Object
  * @param value Value to check
@@ -119,8 +147,8 @@ export function isObject(value: any): boolean {
  * @returns true if provided variable is Date
  * @hidden
  */
-export function isDate(value: any) {
-    return Object.prototype.toString.call(value) === '[object Date]';
+export function isDate(value: any): boolean {
+    return value instanceof Date;
 }
 
 /**

projects/igniteui-angular/src/lib/data-operations/data-util.ts

@@ -15,6 +15,7 @@ import { ITreeGridRecord } from '../grids/tree-grid/public_api';
 import { cloneValue, mergeObjects, mkenum } from '../core/utils';
 import { Transaction, TransactionType, HierarchicalTransaction } from '../services/transaction/transaction';
 import { getHierarchy, isHierarchyMatch } from './operations';
+import { GridType } from '../grids/common/grid.interface';
 
 /**
  * @hidden
@@ -31,25 +32,27 @@ export type DataType = (typeof DataType)[keyof typeof DataType];
  * @hidden
  */
 export class DataUtil {
-    public static sort<T>(data: T[], expressions: ISortingExpression[], sorting: IGridSortingStrategy = new IgxSorting()): T[] {
-        return sorting.sort(data, expressions);
+    public static sort<T>(data: T[], expressions: ISortingExpression[], sorting: IGridSortingStrategy = new IgxSorting(),
+        grid?: GridType): T[] {
+        return sorting.sort(data, expressions, grid);
     }
 
     public static treeGridSort(hierarchicalData: ITreeGridRecord[],
         expressions: ISortingExpression[],
         sorting: IGridSortingStrategy = new IgxDataRecordSorting(),
-        parent?: ITreeGridRecord): ITreeGridRecord[] {
+        parent?: ITreeGridRecord,
+        grid?: GridType): ITreeGridRecord[] {
         let res: ITreeGridRecord[] = [];
         hierarchicalData.forEach((hr: ITreeGridRecord) => {
             const rec: ITreeGridRecord = DataUtil.cloneTreeGridRecord(hr);
             rec.parent = parent;
             if (rec.children) {
-                rec.children = DataUtil.treeGridSort(rec.children, expressions, sorting, rec);
+                rec.children = DataUtil.treeGridSort(rec.children, expressions, sorting, rec, grid);
             }
             res.push(rec);
         });
 
-        res = DataUtil.sort(res, expressions, sorting);
+        res = DataUtil.sort(res, expressions, sorting, grid);
 
         return res;
     }
@@ -66,7 +69,7 @@ export class DataUtil {
         return rec;
     }
 
-    public static group<T>(data: T[], state: IGroupingState, grid: any = null,
+    public static group<T>(data: T[], state: IGroupingState, grid: GridType = null,
         groupsRecords: any[] = [], fullResult: IGroupByResult = { data: [], metadata: [] }): IGroupByResult {
         const grouping = new IgxGrouping();
         groupsRecords.splice(0, groupsRecords.length);
@@ -105,11 +108,11 @@ export class DataUtil {
         return data.slice(index * recordsPerPage, (index + 1) * recordsPerPage);
     }
 
-    public static filter<T>(data: T[], state: IFilteringState): T[] {
+    public static filter<T>(data: T[], state: IFilteringState, grid?: GridType): T[] {
         if (!state.strategy) {
             state.strategy = new FilteringStrategy();
         }
-        return state.strategy.filter(data, state.expressionsTree, state.advancedExpressionsTree);
+        return state.strategy.filter(data, state.expressionsTree, state.advancedExpressionsTree, grid);
     }
 
     public static correctPagingState(state: IPagingState, length: number) {

projects/igniteui-angular/src/lib/data-operations/filtering-condition.ts

@@ -391,7 +391,7 @@ export class IgxDateFilteringOperand extends IgxFilteringOperand {
 
     protected findValueInSet(target: any, searchVal: Set<any>) {
         if (!target) { return false; }
-        return searchVal.has(new Date(target.getFullYear(), target.getMonth(), target.getDate()).toISOString());
+        return searchVal.has(target.toISOString());
     }
 }
 

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

@@ -23,7 +23,7 @@ describe('Unit testing FilteringStrategy', () => {
                 searchVal: 1
             }
         ];
-        const res = fs.filter(data, expressionTree);
+        const res = fs.filter(data, expressionTree, null, null);
         expect(dataGenerator.getValuesForColumn(res, 'number'))
                     .toEqual([2, 3, 4]);
     });
@@ -65,7 +65,7 @@ describe('Unit testing FilteringStrategy', () => {
                 searchVal: 'ROW'
             }
         ];
-        const res = filterstr.filter(data, expressionTree);
+        const res = filterstr.filter(data, expressionTree, null, null);
         expect(dataGenerator.getValuesForColumn(res, 'number'))
                     .toEqual([0]);
     });

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

@@ -1,9 +1,13 @@
 import { FilteringLogic, IFilteringExpression } from './filtering-expression.interface';
 import { FilteringExpressionsTree, IFilteringExpressionsTree } from './filtering-expressions-tree';
-import { resolveNestedPath } from '../core/utils';
+import { resolveNestedPath, parseDate } from '../core/utils';
+import { GridType } from '../grids/common/grid.interface';
+
+const DateType = 'date';
 
 export interface IFilteringStrategy {
-    filter(data: any[], expressionsTree: IFilteringExpressionsTree, advancedExpressionsTree?: IFilteringExpressionsTree): any[];
+    filter(data: any[], expressionsTree: IFilteringExpressionsTree, advancedExpressionsTree?: IFilteringExpressionsTree,
+        grid?: GridType): any[];
 }
 
 export class NoopFilteringStrategy implements IFilteringStrategy {
@@ -22,17 +26,17 @@ export class NoopFilteringStrategy implements IFilteringStrategy {
 
 export abstract class BaseFilteringStrategy implements IFilteringStrategy  {
     public abstract filter(data: any[], expressionsTree: IFilteringExpressionsTree,
-        advancedExpressionsTree?: IFilteringExpressionsTree): any[];
+        advancedExpressionsTree?: IFilteringExpressionsTree, grid?: GridType): any[];
 
-    protected abstract getFieldValue(rec: object, fieldName: string): any;
+    protected abstract getFieldValue(rec: object, fieldName: string, isDate: boolean): any;
 
-    public findMatchByExpression(rec: object, expr: IFilteringExpression): boolean {
+    public findMatchByExpression(rec: object, expr: IFilteringExpression, isDate?: boolean): boolean {
         const cond = expr.condition;
-        const val = this.getFieldValue(rec, expr.fieldName);
+        const val = this.getFieldValue(rec, expr.fieldName, isDate);
         return cond.logic(val, expr.searchVal, expr.ignoreCase);
     }
 
-    public matchRecord(rec: object, expressions: IFilteringExpressionsTree | IFilteringExpression): boolean {
+    public matchRecord(rec: object, expressions: IFilteringExpressionsTree | IFilteringExpression, grid?: GridType): boolean {
         if (expressions) {
             if (expressions instanceof FilteringExpressionsTree) {
                 const expressionsTree = expressions as IFilteringExpressionsTree;
@@ -42,7 +46,7 @@ export abstract class BaseFilteringStrategy implements IFilteringStrategy  {
                 if (expressionsTree.filteringOperands && expressionsTree.filteringOperands.length) {
                     for (let i = 0; i < expressionsTree.filteringOperands.length; i++) {
                         operand = expressionsTree.filteringOperands[i];
-                        matchOperand = this.matchRecord(rec, operand);
+                        matchOperand = this.matchRecord(rec, operand, grid);
 
                         // Return false if at least one operand does not match and the filtering logic is And
                         if (!matchOperand && operator === FilteringLogic.And) {
@@ -61,7 +65,9 @@ export abstract class BaseFilteringStrategy implements IFilteringStrategy  {
                 return true;
             } else {
                 const expression = expressions as IFilteringExpression;
-                return this.findMatchByExpression(rec, expression);
+                const isDate = grid && grid.getColumnByName(expression.fieldName) ?
+                    grid.getColumnByName(expression.fieldName).dataType === DateType : false;
+                return this.findMatchByExpression(rec, expression, isDate);
             }
         }
 
@@ -78,7 +84,8 @@ export class FilteringStrategy extends BaseFilteringStrategy {
         return this._instace || (this._instace = new this());
     }
 
-    public filter<T>(data: T[], expressionsTree: IFilteringExpressionsTree, advancedExpressionsTree?: IFilteringExpressionsTree): T[] {
+    public filter<T>(data: T[], expressionsTree: IFilteringExpressionsTree, advancedExpressionsTree: IFilteringExpressionsTree,
+        grid: GridType): T[] {
         let i;
         let rec;
         const len = data.length;
@@ -88,14 +95,16 @@ export class FilteringStrategy extends BaseFilteringStrategy {
         }
         for (i = 0; i < len; i++) {
             rec = data[i];
-            if (this.matchRecord(rec, expressionsTree) && this.matchRecord(rec, advancedExpressionsTree)) {
+            if (this.matchRecord(rec, expressionsTree, grid) && this.matchRecord(rec, advancedExpressionsTree, grid)) {
                 res.push(rec);
             }
         }
         return res;
     }
 
-    protected getFieldValue(rec: object, fieldName: string): any {
-        return resolveNestedPath(rec, fieldName);
+    protected getFieldValue(rec: object, fieldName: string, isDate: boolean = false): any {
+        let value = resolveNestedPath(rec, fieldName);
+        value = value && isDate ? parseDate(value) : value;
+        return value;
     }
 }

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

@@ -1,18 +1,22 @@
-import { cloneArray, resolveNestedPath } from '../core/utils';
+import { cloneArray, resolveNestedPath, parseDate } from '../core/utils';
 import { IGroupByRecord } from './groupby-record.interface';
 import { ISortingExpression, SortingDirection } from './sorting-expression.interface';
 import { IGroupingExpression } from './grouping-expression.interface';
 import { IGroupingState } from './groupby-state.interface';
 import { IGroupByExpandState } from './groupby-expand-state.interface';
 import { IGroupByResult } from './grouping-result.interface';
 import { getHierarchy, isHierarchyMatch } from './operations';
+import { GridType } from '../grids/common/grid.interface';
+
+const DATE_TYPE = 'date';
 
 export interface ISortingStrategy {
     sort: (data: any[],
            fieldName: string,
            dir: SortingDirection,
            ignoreCase: boolean,
-           valueResolver: (obj: any, key: string) => any) => any[];
+           valueResolver: (obj: any, key: string, isDate?: boolean) => any,
+           isDate?: boolean) => any[];
 }
 
 export class DefaultSortingStrategy implements ISortingStrategy {
@@ -28,11 +32,12 @@ export class DefaultSortingStrategy implements ISortingStrategy {
                 fieldName: string,
                 dir: SortingDirection,
                 ignoreCase: boolean,
-                valueResolver: (obj: any, key: string) => any) {
+                valueResolver: (obj: any, key: string, isDate?: boolean) => any,
+                isDate?: boolean) {
         const key = fieldName;
         const reverse = (dir === SortingDirection.Desc ? -1 : 1);
         const cmpFunc = (obj1, obj2) => {
-            return this.compareObjects(obj1, obj2, key, reverse, ignoreCase, valueResolver);
+            return this.compareObjects(obj1, obj2, key, reverse, ignoreCase, valueResolver, isDate);
         };
         return this.arraySort(data, cmpFunc);
     }
@@ -56,9 +61,10 @@ export class DefaultSortingStrategy implements ISortingStrategy {
                              key: string,
                              reverse: number,
                              ignoreCase: boolean,
-                             valueResolver: (obj: any, key: string) => any) {
-        let a = valueResolver(obj1, key);
-        let b = valueResolver(obj2, key);
+                             valueResolver: (obj: any, key: string, isDate?: boolean) => any,
+                             isDate: boolean) {
+        let a = valueResolver(obj1, key, isDate);
+        let b = valueResolver(obj2, key, isDate);
         if (ignoreCase) {
             a = a && a.toLowerCase ? a.toLowerCase() : a;
             b = b && b.toLowerCase ? b.toLowerCase() : b;
@@ -72,7 +78,7 @@ export class DefaultSortingStrategy implements ISortingStrategy {
 }
 
 export interface IGridSortingStrategy {
-    sort(data: any[], expressions: ISortingExpression[]): any[];
+    sort(data: any[], expressions: ISortingExpression[], grid?: GridType): any[];
 }
 
 export class NoopSortingStrategy implements IGridSortingStrategy {
@@ -90,24 +96,25 @@ export class NoopSortingStrategy implements IGridSortingStrategy {
 }
 
 export class IgxSorting implements IGridSortingStrategy {
-    public sort(data: any[], expressions: ISortingExpression[]): any[] {
-        return this.sortDataRecursive(data, expressions);
+    public sort(data: any[], expressions: ISortingExpression[], grid?: GridType): any[] {
+        return this.sortDataRecursive(data, expressions, 0, grid);
     }
 
     private groupedRecordsByExpression(data: any[],
             index: number,
-            expression: IGroupingExpression): any[] {
+            expression: IGroupingExpression,
+            isDate: boolean = false): any[] {
         let i;
         let groupval;
         const res = [];
         const key = expression.fieldName;
         const len = data.length;
         res.push(data[index]);
-        groupval = this.getFieldValue(data[index], key);
+        groupval = this.getFieldValue(data[index], key, isDate);
         index++;
         const comparer = expression.groupingComparer || DefaultSortingStrategy.instance().compareValues;
         for (i = index; i < len; i++) {
-            if (comparer(this.getFieldValue(data[i], key), groupval) === 0) {
+            if (comparer(this.getFieldValue(data[i], key, isDate), groupval) === 0) {
                 res.push(data[i]);
             } else {
                 break;
@@ -117,7 +124,8 @@ export class IgxSorting implements IGridSortingStrategy {
     }
     private sortDataRecursive<T>(data: T[],
                                  expressions: ISortingExpression[],
-                                 expressionIndex: number = 0): T[] {
+                                 expressionIndex: number = 0,
+                                 grid: GridType): T[] {
         let i;
         let j;
         let expr: ISortingExpression;
@@ -133,16 +141,18 @@ export class IgxSorting implements IGridSortingStrategy {
         if (!expr.strategy) {
             expr.strategy = DefaultSortingStrategy.instance();
         }
-        data = expr.strategy.sort(data, expr.fieldName, expr.dir, expr.ignoreCase, this.getFieldValue);
+        const isDate = grid && grid.getColumnByName(expr.fieldName) ?
+            grid.getColumnByName(expr.fieldName).dataType === DATE_TYPE : false;
+        data = expr.strategy.sort(data, expr.fieldName, expr.dir, expr.ignoreCase, this.getFieldValue, isDate);
         if (expressionIndex === exprsLen - 1) {
             return data;
         }
         // in case of multiple sorting
         for (i = 0; i < dataLen; i++) {
-            gbData = this.groupedRecordsByExpression(data, i, expr);
+            gbData = this.groupedRecordsByExpression(data, i, expr, isDate);
             gbDataLen = gbData.length;
             if (gbDataLen > 1) {
-                gbData = this.sortDataRecursive(gbData, expressions, expressionIndex + 1);
+                gbData = this.sortDataRecursive(gbData, expressions, expressionIndex + 1, grid);
             }
             for (j = 0; j < gbDataLen; j++) {
                 data[i + j] = gbData[j];
@@ -152,20 +162,21 @@ export class IgxSorting implements IGridSortingStrategy {
         return data;
     }
     protected groupDataRecursive<T>(data: T[], state: IGroupingState, level: number,
-        parent: IGroupByRecord, metadata: IGroupByRecord[], grid: any = null,
+        parent: IGroupByRecord, metadata: IGroupByRecord[], grid: GridType = null,
         groupsRecords: any[] = [], fullResult: IGroupByResult = { data: [], metadata: [] }): T[] {
         const expressions = state.expressions;
         const expansion = state.expansion;
         let i = 0;
         let result = [];
         while (i < data.length) {
-            const group = this.groupedRecordsByExpression(data, i, expressions[level]);
             const column = grid ? grid.getColumnByName(expressions[level].fieldName) : null;
+            const isDate = column?.dataType === DATE_TYPE;
+            const group = this.groupedRecordsByExpression(data, i, expressions[level], isDate);
             const groupRow: IGroupByRecord = {
                 expression: expressions[level],
                 level,
                 records: cloneArray(group),
-                value: this.getFieldValue(group[0], expressions[level].fieldName),
+                value: this.getFieldValue(group[0], expressions[level].fieldName, isDate),
                 groupParent: parent,
                 groups: [],
                 height: grid ? grid.renderedRowHeight : null,
@@ -205,14 +216,14 @@ export class IgxSorting implements IGridSortingStrategy {
         }
         return result;
     }
-    protected getFieldValue(obj: any, key: string): any {
-        return resolveNestedPath(obj, key);
+    protected getFieldValue(obj: any, key: string, isDate: boolean = false): any {
+        return isDate ? parseDate(resolveNestedPath(obj, key)) : resolveNestedPath(obj, key);
     }
 }
 
 export class IgxDataRecordSorting extends IgxSorting {
 
-    protected getFieldValue(obj: any, key: string): any {
-        return resolveNestedPath(obj.data, key);
+    protected getFieldValue(obj: any, key: string, isDate: boolean = false): any {
+        return isDate ? parseDate(resolveNestedPath(obj.data, key)) : resolveNestedPath(obj.data, key);
     }
 }