13387853952

Committed 18 Feb 2025 09:55AM CUT coverage: 91.681% (+0.06%) from 91.622%

Build # 13387853952

Build Type

Pull #14647

github

Committed by

web-flow

Commit Message

Merge 54a18c10f into 10ddb05cf

Pull Request Pull Request #14647: feat(query-builder): support for nested queries and other improvements

Run Details

13326 of 15595 branches covered (85.45%)

901 of 977 new or added lines in 19 files covered. (92.22%)

1 existing line in 1 file now uncovered.

26881 of 29320 relevant lines covered (91.68%)

33936.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

74.83

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

/**
 * Provides base filtering operations
 * Implementations should be Singleton
 *
 * @export
 */
export class IgxFilteringOperand {
    protected static _instance: IgxFilteringOperand = null;
    public operations: IFilteringOperation[];

    constructor() {
        this.operations = [{
            name: 'null',
            isUnary: true,
            iconName: 'filter_null',
            logic: (target: any) => target === null
        }, {
            name: 'notNull',
            isUnary: true,
            iconName: 'filter_not_null',
            logic: (target: any) => target !== null
        }, {
            name: 'in',
            isUnary: false,
            isNestedQuery: true,
            iconName: 'in',
            logic: (target: any, searchVal: Set<any>) => this.findValueInSet(target, searchVal)
        },
        {
            name: 'notIn',
            isUnary: false,
            isNestedQuery: true,
            iconName: 'not-in',
            logic: (target: any, searchVal: Set<any>) => !this.findValueInSet(target, searchVal)
        }];
    }

    public static instance(): IgxFilteringOperand {
        return this._instance || (this._instance = new this());
    }

    /**
     * Returns an array of names of the conditions which are visible in the filtering UI
     */
    public conditionList(): string[] {
        return this.operations.filter(f => !f.hidden && !f.isNestedQuery).map((element) => element.name);    
    }

    /**
     * Returns an array of names of the conditions which are visible in the UI, including "In" and "Not In", allowing the creation of sub-queries.
     */
    public extendedConditionList(): string[] {
        return this.operations.filter(f => !f.hidden).map((element) => element.name);
    }

    /**
     * Returns an instance of the condition with the specified name.
     *
     * @param name The name of the condition.
     */
    public condition(name: string): IFilteringOperation {
        return this.operations.find((element) => element.name === name);
    }

    /**
     * Adds a new condition to the filtering operations.
     *
     * @param operation The filtering operation.
     */
    public append(operation: IFilteringOperation) {
        this.operations.push(operation);
    }

    /**
     * @hidden
     */
    public findValueInSet(target: any, searchVal: Set<any>) {
        return searchVal.has(target);
    }
}

/* blazorCSSuppress */
/**
 * Provides filtering operations for booleans
 *
 * @export
 */
export class IgxBooleanFilteringOperand extends IgxFilteringOperand {
    protected constructor() {
        super();
        const newOperations: IFilteringOperation[] = [{
            name: 'all',
            isUnary: true,
            iconName: 'filter_all',
            logic: (_target: boolean) => true
        }, {
            name: 'true',
            isUnary: true,
            iconName: 'filter_true',
            logic: (target: boolean) => !!(target && target !== null && target !== undefined)
        }, {
            name: 'false',
            isUnary: true,
            iconName: 'filter_false',
            logic: (target: boolean) => !target && target !== null && target !== undefined
        }, {
            name: 'empty',
            isUnary: true,
            iconName: 'filter_empty',
            logic: (target: boolean) => target === null || target === undefined
        }, {
            name: 'notEmpty',
            isUnary: true,
            iconName: 'filter_not_empty',
            logic: (target: boolean) => target !== null && target !== undefined
        }];
        
        this.operations = newOperations.concat(this.operations);
    }
}

/* blazorCSSuppress */
/**
 * @internal
 * @hidden
 */
class IgxBaseDateTimeFilteringOperand extends IgxFilteringOperand {
    protected constructor() {
        super();
        const newOperations: IFilteringOperation[] = [{
            name: 'empty',
            isUnary: true,
            iconName: 'filter_empty',
            logic: (target: Date) => target === null || target === undefined
        }, {
            name: 'notEmpty',
            isUnary: true,
            iconName: 'filter_not_empty',
            logic: (target: Date) => target !== null && target !== undefined
        }];
        
        this.operations = newOperations.concat(this.operations);
    }

    /**
     * Splits a Date object into parts
     *
     * @memberof IgxDateFilteringOperand
     */
    public static getDateParts(date: Date, dateFormat?: string): IDateParts {
        const res = {
            day: null,
            hours: null,
            milliseconds: null,
            minutes: null,
            month: null,
            seconds: null,
            year: null
        };
        if (!date || !dateFormat) {
            return res;
        }
        if (dateFormat.indexOf('y') >= 0) {
            res.year = date.getFullYear();
        }
        if (dateFormat.indexOf('M') >= 0) {
            res.month = date.getMonth();
        }
        if (dateFormat.indexOf('d') >= 0) {
            res.day = date.getDate();
        }
        if (dateFormat.indexOf('h') >= 0) {
            res.hours = date.getHours();
        }
        if (dateFormat.indexOf('m') >= 0) {
            res.minutes = date.getMinutes();
        }
        if (dateFormat.indexOf('s') >= 0) {
            res.seconds = date.getSeconds();
        }
        if (dateFormat.indexOf('f') >= 0) {
            res.milliseconds = date.getMilliseconds();
        }
        return res;
    }

    /**
     * @hidden
     */
    public override findValueInSet(target: any, searchVal: Set<any>) {
        if (!target) {
            return false;
        }
        return searchVal.has((target instanceof Date) ? target.toISOString() : target);
    }

    protected validateInputData(target: Date) {
        if (!(target instanceof Date)) {
            throw new Error('Could not perform filtering on \'date\' column because the datasource object type is not \'Date\'.');
        }
    }
}

/* blazorCSSuppress */
/**
 * Provides filtering operations for Dates
 *
 * @export
 */
export class IgxDateFilteringOperand extends IgxBaseDateTimeFilteringOperand {
    protected constructor() {
        super();
        const newOperations: IFilteringOperation[] = [{
            name: 'equals',
            isUnary: false,
            iconName: 'filter_equal',
            logic: (target: Date, searchVal: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);

                const targetp = IgxDateFilteringOperand.getDateParts(target, 'yMd');
                const searchp = IgxDateFilteringOperand.getDateParts(searchVal, 'yMd');
                return targetp.year === searchp.year &&
                    targetp.month === searchp.month &&
                    targetp.day === searchp.day;
            }
        }, {
            name: 'doesNotEqual',
            isUnary: false,
            iconName: 'filter_not_equal',
            logic: (target: Date, searchVal: Date) => {
                if (!target) {
                    return true;
                }

                this.validateInputData(target);

                const targetp = IgxDateFilteringOperand.getDateParts(target, 'yMd');
                const searchp = IgxDateFilteringOperand.getDateParts(searchVal, 'yMd');
                return targetp.year !== searchp.year ||
                    targetp.month !== searchp.month ||
                    targetp.day !== searchp.day;
            }
        }, {
            name: 'before',
            isUnary: false,
            iconName: 'filter_before',
            logic: (target: Date, searchVal: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);

                return target < searchVal;
            }
        }, {
            name: 'after',
            isUnary: false,
            iconName: 'filter_after',
            logic: (target: Date, searchVal: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);

                return target > searchVal;
            }
        }, {
            name: 'today',
            isUnary: true,
            iconName: 'filter_today',
            logic: (target: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);

                const d = IgxDateFilteringOperand.getDateParts(target, 'yMd');
                const now = IgxDateFilteringOperand.getDateParts(new Date(), 'yMd');
                return d.year === now.year &&
                    d.month === now.month &&
                    d.day === now.day;
            }
        }, {
            name: 'yesterday',
            isUnary: true,
            iconName: 'filter_yesterday',
            logic: (target: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);

                const td = IgxDateFilteringOperand.getDateParts(target, 'yMd');
                const y = ((d) => new Date(d.setDate(d.getDate() - 1)))(new Date());
                const yesterday = IgxDateFilteringOperand.getDateParts(y, 'yMd');
                return td.year === yesterday.year &&
                    td.month === yesterday.month &&
                    td.day === yesterday.day;
            }
        }, {
            name: 'thisMonth',
            isUnary: true,
            iconName: 'filter_this_month',
            logic: (target: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);

                const d = IgxDateFilteringOperand.getDateParts(target, 'yM');
                const now = IgxDateFilteringOperand.getDateParts(new Date(), 'yM');
                return d.year === now.year &&
                    d.month === now.month;
            }
        }, {
            name: 'lastMonth',
            isUnary: true,
            iconName: 'filter_last_month',
            logic: (target: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);

                const d = IgxDateFilteringOperand.getDateParts(target, 'yM');
                const now = IgxDateFilteringOperand.getDateParts(new Date(), 'yM');
                if (!now.month) {
                    now.month = 11;
                    now.year -= 1;
                } else {
                    now.month--;
                }
                return d.year === now.year &&
                    d.month === now.month;
            }
        }, {
            name: 'nextMonth',
            isUnary: true,
            iconName: 'filter_next_month',
            logic: (target: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);

                const d = IgxDateFilteringOperand.getDateParts(target, 'yM');
                const now = IgxDateFilteringOperand.getDateParts(new Date(), 'yM');
                if (now.month === 11) {
                    now.month = 0;
                    now.year += 1;
                } else {
                    now.month++;
                }
                return d.year === now.year &&
                    d.month === now.month;
            }
        }, {
            name: 'thisYear',
            isUnary: true,
            iconName: 'filter_this_year',
            logic: (target: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);

                const d = IgxDateFilteringOperand.getDateParts(target, 'y');
                const now = IgxDateFilteringOperand.getDateParts(new Date(), 'y');
                return d.year === now.year;
            }
        }, {
            name: 'lastYear',
            isUnary: true,
            iconName: 'filter_last_year',
            logic: (target: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);

                const d = IgxDateFilteringOperand.getDateParts(target, 'y');
                const now = IgxDateFilteringOperand.getDateParts(new Date(), 'y');
                return d.year === now.year - 1;
            }
        }, {
            name: 'nextYear',
            isUnary: true,
            iconName: 'filter_next_year',
            logic: (target: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);

                const d = IgxDateFilteringOperand.getDateParts(target, 'y');
                const now = IgxDateFilteringOperand.getDateParts(new Date(), 'y');
                return d.year === now.year + 1;
            }
        }];
        
        this.operations = newOperations.concat(this.operations);
    }

    public override findValueInSet(target: any, searchVal: Set<any>) {
        if (!target) {
            return false;
        }

        target = target.toDateString();
        return searchVal.has(target);
    }
}

/* blazorCSSuppress */
export class IgxDateTimeFilteringOperand extends IgxBaseDateTimeFilteringOperand {
    protected constructor() {
        super();
        const newOperations: IFilteringOperation[] = [{
            name: 'equals',
            isUnary: false,
            iconName: 'filter_equal',
            logic: (target: Date, searchVal: Date) => {
                if (!target) {
                    return false;
                }
                this.validateInputData(target);
                const targetp = IgxDateTimeFilteringOperand.getDateParts(target, 'yMdhms');
                const searchp = IgxDateTimeFilteringOperand.getDateParts(searchVal, 'yMdhms');
                return targetp.year === searchp.year &&
                    targetp.month === searchp.month &&
                    targetp.day === searchp.day &&
                    targetp.hours === searchp.hours &&
                    targetp.minutes === searchp.minutes &&
                    targetp.seconds === searchp.seconds;
            }
        }, {
            name: 'doesNotEqual',
            isUnary: false,
            iconName: 'filter_not_equal',
            logic: (target: Date, searchVal: Date) => {
                if (!target) {
                    return true;
                }
                this.validateInputData(target);
                const targetp = IgxDateTimeFilteringOperand.getDateParts(target, 'yMdhms');
                const searchp = IgxDateTimeFilteringOperand.getDateParts(searchVal, 'yMdhms');
                return targetp.year !== searchp.year ||
                    targetp.month !== searchp.month ||
                    targetp.day !== searchp.day ||
                    targetp.hours !== searchp.hours ||
                    targetp.minutes !== searchp.minutes ||
                    targetp.seconds !== searchp.seconds;
            }
        }, {
            name: 'before',
            isUnary: false,
            iconName: 'filter_before',
            logic: (target: Date, searchVal: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);

                return target < searchVal;
            }
        }, {
            name: 'after',
            isUnary: false,
            iconName: 'filter_after',
            logic: (target: Date, searchVal: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);

                return target > searchVal;
            }
        }, {
            name: 'today',
            isUnary: true,
            iconName: 'filter_today',
            logic: (target: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);

                const d = IgxDateTimeFilteringOperand.getDateParts(target, 'yMd');
                const now = IgxDateTimeFilteringOperand.getDateParts(new Date(), 'yMd');
                return d.year === now.year &&
                    d.month === now.month &&
                    d.day === now.day;
            }
        }, {
            name: 'yesterday',
            isUnary: true,
            iconName: 'filter_yesterday',
            logic: (target: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);

                const td = IgxDateTimeFilteringOperand.getDateParts(target, 'yMd');
                const y = ((d) => new Date(d.setDate(d.getDate() - 1)))(new Date());
                const yesterday = IgxDateTimeFilteringOperand.getDateParts(y, 'yMd');
                return td.year === yesterday.year &&
                    td.month === yesterday.month &&
                    td.day === yesterday.day;
            }
        }, {
            name: 'thisMonth',
            isUnary: true,
            iconName: 'filter_this_month',
            logic: (target: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);

                const d = IgxDateTimeFilteringOperand.getDateParts(target, 'yM');
                const now = IgxDateTimeFilteringOperand.getDateParts(new Date(), 'yM');
                return d.year === now.year &&
                    d.month === now.month;
            }
        }, {
            name: 'lastMonth',
            isUnary: true,
            iconName: 'filter_last_month',
            logic: (target: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);

                const d = IgxDateTimeFilteringOperand.getDateParts(target, 'yM');
                const now = IgxDateTimeFilteringOperand.getDateParts(new Date(), 'yM');
                if (!now.month) {
                    now.month = 11;
                    now.year -= 1;
                } else {
                    now.month--;
                }
                return d.year === now.year &&
                    d.month === now.month;
            }
        }, {
            name: 'nextMonth',
            isUnary: true,
            iconName: 'filter_next_month',
            logic: (target: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);

                const d = IgxDateTimeFilteringOperand.getDateParts(target, 'yM');
                const now = IgxDateTimeFilteringOperand.getDateParts(new Date(), 'yM');
                if (now.month === 11) {
                    now.month = 0;
                    now.year += 1;
                } else {
                    now.month++;
                }
                return d.year === now.year &&
                    d.month === now.month;
            }
        }, {
            name: 'thisYear',
            isUnary: true,
            iconName: 'filter_this_year',
            logic: (target: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);

                const d = IgxDateTimeFilteringOperand.getDateParts(target, 'y');
                const now = IgxDateTimeFilteringOperand.getDateParts(new Date(), 'y');
                return d.year === now.year;
            }
        }, {
            name: 'lastYear',
            isUnary: true,
            iconName: 'filter_last_year',
            logic: (target: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);

                const d = IgxDateTimeFilteringOperand.getDateParts(target, 'y');
                const now = IgxDateTimeFilteringOperand.getDateParts(new Date(), 'y');
                return d.year === now.year - 1;
            }
        }, {
            name: 'nextYear',
            isUnary: true,
            iconName: 'filter_next_year',
            logic: (target: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);

                const d = IgxDateTimeFilteringOperand.getDateParts(target, 'y');
                const now = IgxDateTimeFilteringOperand.getDateParts(new Date(), 'y');
                return d.year === now.year + 1;
            }
        }];
        
        this.operations = newOperations.concat(this.operations);
    }
}

/* blazorCSSuppress */
export class IgxTimeFilteringOperand extends IgxBaseDateTimeFilteringOperand {
    protected constructor() {
        super();
        const newOperations: IFilteringOperation[] = [{
            name: 'at',
            isUnary: false,
            iconName: 'filter_equal',
            logic: (target: Date, searchVal: Date) => {
                if (!target) {
                    return false;
                }
                this.validateInputData(target);
                const targetp = IgxTimeFilteringOperand.getDateParts(target, 'hms');
                const searchp = IgxTimeFilteringOperand.getDateParts(searchVal, 'hms');
                return targetp.hours === searchp.hours &&
                    targetp.minutes === searchp.minutes &&
                    targetp.seconds === searchp.seconds;
            }
        }, {
            name: 'not_at',
            isUnary: false,
            iconName: 'filter_not_equal',
            logic: (target: Date, searchVal: Date) => {
                if (!target) {
                    return true;
                }
                this.validateInputData(target);
                const targetp = IgxTimeFilteringOperand.getDateParts(target, 'hms');
                const searchp = IgxTimeFilteringOperand.getDateParts(searchVal, 'hms');
                return targetp.hours !== searchp.hours ||
                    targetp.minutes !== searchp.minutes ||
                    targetp.seconds !== searchp.seconds;
            }
        }, {
            name: 'before',
            isUnary: false,
            iconName: 'filter_before',
            logic: (target: Date, searchVal: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);
                const targetn = IgxTimeFilteringOperand.getDateParts(target, 'hms');
                const search = IgxTimeFilteringOperand.getDateParts(searchVal, 'hms');

                return targetn.hours < search.hours ? true : targetn.hours === search.hours && targetn.minutes < search.minutes ?
                    true : targetn.hours === search.hours && targetn.minutes === search.minutes && targetn.seconds < search.seconds;
            }
        }, {
            name: 'after',
            isUnary: false,
            iconName: 'filter_after',
            logic: (target: Date, searchVal: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);
                const targetn = IgxTimeFilteringOperand.getDateParts(target, 'hms');
                const search = IgxTimeFilteringOperand.getDateParts(searchVal, 'hms');

                return targetn.hours > search.hours ? true : targetn.hours === search.hours && targetn.minutes > search.minutes ?
                    true : targetn.hours === search.hours && targetn.minutes === search.minutes && targetn.seconds > search.seconds;
            }
        }, {
            name: 'at_before',
            isUnary: false,
            iconName: 'filter_before',
            logic: (target: Date, searchVal: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);
                const targetn = IgxTimeFilteringOperand.getDateParts(target, 'hms');
                const search = IgxTimeFilteringOperand.getDateParts(searchVal, 'hms');
                return (targetn.hours === search.hours && targetn.minutes === search.minutes && targetn.seconds === search.seconds) ||
                targetn.hours < search.hours ? true : targetn.hours === search.hours && targetn.minutes < search.minutes ?
                    true : targetn.hours === search.hours && targetn.minutes === search.minutes && targetn.seconds < search.seconds;
            }
        }, {
            name: 'at_after',
            isUnary: false,
            iconName: 'filter_after',
            logic: (target: Date, searchVal: Date) => {
                if (!target) {
                    return false;
                }

                this.validateInputData(target);
                const targetn = IgxTimeFilteringOperand.getDateParts(target, 'hms');
                const search = IgxTimeFilteringOperand.getDateParts(searchVal, 'hms');
                return (targetn.hours === search.hours && targetn.minutes === search.minutes && targetn.seconds === search.seconds) ||
                    targetn.hours > search.hours ? true : targetn.hours === search.hours && targetn.minutes > search.minutes ?
                    true : targetn.hours === search.hours && targetn.minutes === search.minutes && targetn.seconds > search.seconds;
            }
        }];
        
        this.operations = newOperations.concat(this.operations);
    }

    /**
     * @hidden
     */
    public override findValueInSet(target: any, searchVal: Set<any>) {
        if (!target) {
            return false;
        }
        return searchVal.has(target.toLocaleTimeString());
    }
}

/* blazorCSSuppress */
/**
 * Provides filtering operations for numbers
 *
 * @export
 */
export class IgxNumberFilteringOperand extends IgxFilteringOperand {
    protected constructor() {
        super();
        const newOperations: IFilteringOperation[] = [{
            name: 'equals',
            isUnary: false,
            iconName: 'filter_equal',
            logic: (target: number, searchVal: number) => target === searchVal
        }, {
            name: 'doesNotEqual',
            isUnary: false,
            iconName: 'filter_not_equal',
            logic: (target: number, searchVal: number) => target !== searchVal
        }, {
            name: 'greaterThan',
            isUnary: false,
            iconName: 'filter_greater_than',
            logic: (target: number, searchVal: number) => target > searchVal
        }, {
            name: 'lessThan',
            isUnary: false,
            iconName: 'filter_less_than',
            logic: (target: number, searchVal: number) => target < searchVal
        }, {
            name: 'greaterThanOrEqualTo',
            isUnary: false,
            iconName: 'filter_greater_than_or_equal',
            logic: (target: number, searchVal: number) => target >= searchVal
        }, {
            name: 'lessThanOrEqualTo',
            isUnary: false,
            iconName: 'filter_less_than_or_equal',
            logic: (target: number, searchVal: number) => target <= searchVal
        }, {
            name: 'empty',
            isUnary: true,
            iconName: 'filter_empty',
            logic: (target: number) => target === null || target === undefined || isNaN(target)
        }, {
            name: 'notEmpty',
            isUnary: true,
            iconName: 'filter_not_empty',
            logic: (target: number) => target !== null && target !== undefined && !isNaN(target)
        }];
        
        this.operations = newOperations.concat(this.operations);
    }
}

/* blazorCSSuppress */
/**
 * Provides filtering operations for strings
 *
 * @export
 */
export class IgxStringFilteringOperand extends IgxFilteringOperand {
    protected constructor() {
        super();
        const newOperations: IFilteringOperation[] = [{
            name: 'contains',
            isUnary: false,
            iconName: 'filter_contains',
            logic: (target: string, searchVal: string, ignoreCase?: boolean) => {
                const search = IgxStringFilteringOperand.applyIgnoreCase(searchVal, ignoreCase);
                target = IgxStringFilteringOperand.applyIgnoreCase(target, ignoreCase);
                return target.indexOf(search) !== -1;
            }
        }, {
            name: 'doesNotContain',
            isUnary: false,
            iconName: 'filter_does_not_contain',
            logic: (target: string, searchVal: string, ignoreCase?: boolean) => {
                const search = IgxStringFilteringOperand.applyIgnoreCase(searchVal, ignoreCase);
                target = IgxStringFilteringOperand.applyIgnoreCase(target, ignoreCase);
                return target.indexOf(search) === -1;
            }
        }, {
            name: 'startsWith',
            isUnary: false,
            iconName: 'filter_starts_with',
            logic: (target: string, searchVal: string, ignoreCase?: boolean) => {
                const search = IgxStringFilteringOperand.applyIgnoreCase(searchVal, ignoreCase);
                target = IgxStringFilteringOperand.applyIgnoreCase(target, ignoreCase);
                return target.startsWith(search);
            }
        }, {
            name: 'endsWith',
            isUnary: false,
            iconName: 'filter_ends_with',
            logic: (target: string, searchVal: string, ignoreCase?: boolean) => {
                const search = IgxStringFilteringOperand.applyIgnoreCase(searchVal, ignoreCase);
                target = IgxStringFilteringOperand.applyIgnoreCase(target, ignoreCase);
                return target.endsWith(search);
            }
        }, {
            name: 'equals',
            isUnary: false,
            iconName: 'filter_equal',
            logic: (target: string, searchVal: string, ignoreCase?: boolean) => {
                const search = IgxStringFilteringOperand.applyIgnoreCase(searchVal, ignoreCase);
                target = IgxStringFilteringOperand.applyIgnoreCase(target, ignoreCase);
                return target === search;
            }
        }, {
            name: 'doesNotEqual',
            isUnary: false,
            iconName: 'filter_not_equal',
            logic: (target: string, searchVal: string, ignoreCase?: boolean) => {
                const search = IgxStringFilteringOperand.applyIgnoreCase(searchVal, ignoreCase);
                target = IgxStringFilteringOperand.applyIgnoreCase(target, ignoreCase);
                return target !== search;
            }
        }, {
            name: 'empty',
            isUnary: true,
            iconName: 'filter_empty',
            logic: (target: string) => target === null || target === undefined || target.length === 0
        }, {
            name: 'notEmpty',
            isUnary: true,
            iconName: 'filter_not_empty',
            logic: (target: string) => target !== null && target !== undefined && target.length > 0
        }];
        
        this.operations = newOperations.concat(this.operations);
    }

    /**
     * Applies case sensitivity on strings if provided
     *
     * @memberof IgxStringFilteringOperand
     */
    public static applyIgnoreCase(a: string, ignoreCase: boolean): string {
        a = a ?? '';
        // bulletproof
        return ignoreCase ? ('' + a).toLowerCase() : a;
    }
}

/* tsPlainInterface */
/* marshalByValue */
/**
 * Interface describing filtering operations
 *
 * @export
 */
export interface IFilteringOperation {
    name: string;
    isUnary: boolean;
    isNestedQuery?: boolean;
    iconName: string;
    hidden?: boolean;
    /* blazorCSSuppress */
    /* blazorAlternateType: FilteringOperationLogicHandler */
    logic: (value: any, searchVal?: any, ignoreCase?: boolean) => boolean;
}

/**
 * Interface describing Date object in parts
 *
 * @export
 */
export interface IDateParts {
    year: number;
    month: number;
    day: number;
    hours: number;
    minutes: number;
    seconds: number;
    milliseconds: number;
}

IgniteUI / igniteui-angular / 13387853952

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous