Recreate filtering expression condition based on correct condition.Name value [master] (#16902)

* test(test): assert if correct condition is recreated based on conditionName

* chore(chore): expose function to be used in tests

* fix(grid): recreate condition based on condition.name

Author: hanastasov

projects/igniteui-angular/core/src/data-operations/expressions-tree-util.spec.ts

@@ -1,6 +1,6 @@
 import { FilteringLogic, IFilteringExpression } from './filtering-expression.interface';
 import { FilteringExpressionsTree, IFilteringExpressionsTree } from './filtering-expressions-tree';
-import { recreateTree, recreateTreeFromFields } from './expressions-tree-util';
+import { recreateExpression, recreateTree, recreateTreeFromFields } from './expressions-tree-util';
 import { IgxBooleanFilteringOperand, IgxDateFilteringOperand, IgxDateTimeFilteringOperand, IgxNumberFilteringOperand, IgxStringFilteringOperand, IgxTimeFilteringOperand } from './filtering-condition';
 import type { EntityType, FieldType } from './grid-types';
 
@@ -477,4 +477,30 @@ describe('Unit testing FilteringUtil', () => {
         expect(nestedCondition.condition.name).toBe('greaterThan');
         expect(nestedCondition.condition.logic(200, nestedCondition.searchVal)).toBe(true);
     });
+
+    it('should recreate string expression with correct conditionName', () => {
+        const fields: FieldType[] = [
+            { field: 'Name', dataType: 'string' }
+        ];
+
+        // such expression will exist if user has changed the condition OR restore grid state through the IgxGridState directive
+        const expression: IFilteringExpression = {
+            fieldName: 'Name',
+            conditionName: 'contains',
+            searchVal: 'test',
+            condition: {
+                name: 'startsWith',
+                iconName: 'starts_with',
+                isUnary: false,
+            }
+        };
+
+        const result = recreateExpression(expression, fields);
+
+        expect(result.condition).toBe(IgxStringFilteringOperand.instance().condition('startsWith'));
+        expect(result.condition.logic).toBeDefined();
+        expect(result.conditionName).toBe('startsWith');
+        expect(result.searchVal).toBe('test');
+    });
+
 });

projects/igniteui-angular/core/src/data-operations/expressions-tree-util.ts

@@ -125,7 +125,7 @@ function getFilteringCondition(dataType: string, name: string): IFilteringOperat
  */
 function recreateOperatorFromDataType(expression: IFilteringExpression, dataType: string): IFilteringOperation {
     if (!expression.condition?.logic) {
-        return getFilteringCondition(dataType, expression.conditionName || expression.condition?.name);
+        return getFilteringCondition(dataType, expression.condition?.name || expression.conditionName);
     }
 
     return expression.condition;
@@ -138,25 +138,22 @@ function recreateOperatorFromDataType(expression: IFilteringExpression, dataType
  * @param fields An array of fields to use for recreating the expression.
  * @returns The recreated expression.
  */
-function recreateExpression(expression: IFilteringExpression, fields: FieldType[]): IFilteringExpression {
+export function recreateExpression(expression: IFilteringExpression, fields: FieldType[]): IFilteringExpression {
     const field = fields?.find(f => f.field === expression.fieldName);
 
     if (field && !expression.condition?.logic) {
         if (!field.filters) {
             expression.condition = recreateOperatorFromDataType(expression, field.dataType);
         } else {
-            expression.condition = field.filters.condition(expression.conditionName || expression.condition?.name);
+            expression.condition = field.filters.condition(expression.condition?.name || expression.conditionName);
         }
     }
 
     if (!expression.condition && expression.conditionName) {
         throw Error('Wrong `conditionName`, `condition` or `field` provided! It is possible that there is a type mismatch between the condition type and field type.');
     }
 
-    if (!expression.conditionName) {
-        expression.conditionName = expression.condition?.name;
-    }
-
+    expression.conditionName = expression.condition?.name;
     expression.searchVal = recreateSearchValue(expression.searchVal, field?.dataType);
 
     return expression;