@qrvey/utils 1.1.0-9 → 1.1.2-1

package/src/filters/helpers/common/getFiltersByVisibility.ts

@@ -14,7 +14,7 @@ export function getFiltersByVisibility(filterData: IFSData | IFUData, scopes: IF
     filterData = cloneDeep(filterData);
 
     filterData = getFiltersByScopesIds(filterData, scopes);
-    filterData = getFiltersByParams(filterData, { enableds: true });
+    filterData = getFiltersByParams(filterData, { enableds: { datasets: true, scopes: true, values: true } }, { filterEmptyArrays: { filter: false } });
 
     return filterData;
 }

package/src/filters/helpers/common/getMergeFiltersSettings.ts

@@ -0,0 +1,13 @@
+import { IFSMergeFiltersSettings } from "../../interfaces/common/IFSMergeFiltersSettings";
+
+/**
+ * Transforms the given MergeFilters settings object. Adds the missing properties if they do not exist.
+ * @param settings an object to the MergeFilters settings
+ * @returns a new MergeFilters settings object.
+ */
+export function getMergeFiltersSettings(settings?: IFSMergeFiltersSettings): IFSMergeFiltersSettings {
+    return {
+        overwriteValues: settings?.overwriteValues ?? false,
+        setGroupedColumnOperator: settings?.setGroupedColumnOperator ?? true
+    };
+}

package/src/filters/helpers/common/getParamsToGetFilterSettings.ts

@@ -1,5 +1,10 @@
 import { IFSParamsToGetFilterSettings } from "../../interfaces";
 
+/**
+ * Transforms the given ParamsToGetFilter settings object. Adds the missing properties if they do not exist.
+ * @param settings an object to the ParamsToGetFilter settings
+ * @returns a new ParamsToGetFilter settings object.
+ */
 export function getParamsToGetFilterSettings(settings?: IFSParamsToGetFilterSettings): IFSParamsToGetFilterSettings {
     return {
         letPassUndefinedParams: {
@@ -11,6 +16,11 @@ export function getParamsToGetFilterSettings(settings?: IFSParamsToGetFilterSett
             dataset: settings?.letPassUndefinedProperties?.dataset ?? false,
             filter: settings?.letPassUndefinedProperties?.filter ?? false,
             scope: settings?.letPassUndefinedProperties?.scope ?? false,
+        },
+        filterEmptyArrays: {
+            dataset: settings?.filterEmptyArrays?.dataset ?? true,
+            filter: settings?.filterEmptyArrays?.filter ?? true,
+            scope: settings?.filterEmptyArrays?.scope ?? true,
         }
-    }
+    };
 }

package/src/filters/helpers/common/index.ts

@@ -1,4 +1,5 @@
 export * from './areFiltersEquals';
+export * from './arePropertiesDateP';
 export * from './excludeFiltersByAggregateColumn';
 export * from './excludeFiltersByParams';
 export * from './excludeFiltersByScopes';
@@ -10,6 +11,7 @@ export * from './getFiltersByParams';
 export * from './getFiltersByScopes';
 export * from './getFiltersByScopesIds';
 export * from './getFiltersByVisibility';
+export * from './getMergeFiltersSettings';
 export * from './getParamsToGetFilterSettings';
 export * from './haveFiltersByDataset';
 export * from './isBetweenValidator';

package/src/filters/helpers/common/isInValidator.ts

@@ -6,6 +6,6 @@ import { IFValidator } from "../../interfaces";
  * @param validator The validator
  * @returns true: it is a In validator; false: it is not a In validator
  */
-export function isInValidator(validator: IFValidator) {
+export function isInValidator(validator: IFValidator): boolean {
     return validator === FILTER_VALIDATOR.IN;
 }

package/src/filters/helpers/common/mergeFilters.ts

@@ -1,5 +1,10 @@
 import { cloneDeep, isEmpty } from "../../../general";
-import { IFSData, IFSDataset, IFSFilter, IFSScope, IFSValue, IFSValueRange, IFUData, IFValue } from "../../interfaces";
+import { FILTER_GROUPED_COLUMN_OPERATOR } from "../../constants/common/FILTER_GROUPED_COLUMN_OPERATOR";
+import { IFSData, IFSDataset, IFSFilter, IFSScope, IFSValue, IFSValueRange, IFSValueRelativeDate, IFUData, IFValue } from "../../interfaces";
+import { IFSMergeFiltersSettings } from "../../interfaces/common/IFSMergeFiltersSettings";
+import { getMergeFiltersSettings } from "./getMergeFiltersSettings";
+import { isInValidator } from "./isInValidator";
+import { isNullValidator } from "./isNullValidator";
 import { isRangeValidator } from "./isRangeValidator";
 import { isRegularValidator } from "./isRegularValidator";
 import { resolveDatasetConditions } from "./resolveDatasetConditions";
@@ -13,7 +18,7 @@ import { resolveScopeConditions } from "./resolveScopeConditions";
  * @param overwriteValues Flag to overwrite or not the filter values
  * @returns a new filter data structure
  */
-export function mergeFilters(filterData1: IFSData | IFUData, filterData2: IFSData | IFUData, overwriteValues = false): IFSData | IFUData {
+export function mergeFilters(filterData1: IFSData | IFUData, filterData2: IFSData | IFUData, settings?: IFSMergeFiltersSettings): IFSData | IFUData {
     if (isEmpty(filterData1) || isEmpty(filterData1.scopes)) {
         if (isEmpty(filterData2) || isEmpty(filterData2.scopes)) return;
         return filterData2;
@@ -23,12 +28,13 @@ export function mergeFilters(filterData1: IFSData | IFUData, filterData2: IFSDat
     filterData1 = cloneDeep(filterData1);
     filterData2 = cloneDeep(filterData2);
 
+    settings = getMergeFiltersSettings(settings);
     return {
         enabled: filterData1.enabled,
-        scopes: mergeScopes(filterData1.scopes, filterData2.scopes, overwriteValues),
+        scopes: mergeScopes(filterData1.scopes, filterData2.scopes, settings),
         section: filterData1.section,
         version: filterData1.version
-    }
+    };
 }
 
 /**
@@ -38,14 +44,14 @@ export function mergeFilters(filterData1: IFSData | IFUData, filterData2: IFSDat
  * @param overwriteValues Flag to overwrite or not the filter values
  * @returns a new scope structure array
  */
-function mergeScopes(scopes1: IFSScope[] = [], scopes2: IFSScope[] = [], overwriteValues = false): IFSScope[] {
+function mergeScopes(scopes1: IFSScope[] = [], scopes2: IFSScope[] = [], settings?: IFSMergeFiltersSettings): IFSScope[] {
     let newScopes = scopes1.reduce((scopes: IFSScope[], scope1: IFSScope) => {
         const scope2Index = scopes2.findIndex(scope2 => resolveScopeConditions(scope2, { scope: scope1.scope, scopeid: scope1.scopeid }));
         if (scope2Index > -1) {
             scope1 = {
                 ...scope1,
-                datasets: mergeDatasets(scope1.datasets, scopes2[scope2Index].datasets, overwriteValues)
-            }
+                datasets: mergeDatasets(scope1.datasets, scopes2[scope2Index].datasets, settings)
+            };
             scopes2.splice(scope2Index, 1);
         }
         scopes.push(scope1);
@@ -63,14 +69,14 @@ function mergeScopes(scopes1: IFSScope[] = [], scopes2: IFSScope[] = [], overwri
  * @param overwriteValues Flag to overwrite or not the filter values
  * @returns a new dataset structure array
  */
-function mergeDatasets(datasets1: IFSDataset[] = [], datasets2: IFSDataset[] = [], overwriteValues = false): IFSDataset[] {
+function mergeDatasets(datasets1: IFSDataset[] = [], datasets2: IFSDataset[] = [], settings?: IFSMergeFiltersSettings): IFSDataset[] {
     let newDatasets = datasets1.reduce((datasets: IFSDataset[], dataset1: IFSDataset) => {
         const dataset2Index = datasets2.findIndex(dataset2 => resolveDatasetConditions(dataset2, { qrveyid: dataset1.qrveyid, linkid: dataset1.linkid }));
         if (dataset2Index > -1) {
             dataset1 = {
                 ...dataset1,
-                filters: mergeFilterss(dataset1.filters, datasets2[dataset2Index].filters, overwriteValues)
-            }
+                filters: mergeFilterss(dataset1.filters, datasets2[dataset2Index].filters, settings)
+            };
             datasets2.splice(dataset2Index, 1);
         }
         datasets.push(dataset1);
@@ -88,15 +94,14 @@ function mergeDatasets(datasets1: IFSDataset[] = [], datasets2: IFSDataset[] = [
  * @param overwriteValues Flag to overwrite or not the filter values
  * @returns a new filter structure array
  */
-function mergeFilterss(filters1: IFSFilter[] = [], filters2: IFSFilter[] = [], overwriteValues = false): IFSFilter[] {
+function mergeFilterss(filters1: IFSFilter[] = [], filters2: IFSFilter[] = [], settings?: IFSMergeFiltersSettings): IFSFilter[] {
     let newFilters = filters1.reduce((filters: IFSFilter[], filter1: IFSFilter) => {
         const filter2Index = filters2.findIndex(filter2 => resolveFilterConditions(filter2, { column: filter1.column, dateSection: filter1.dateSection, panelid: filter1.extras.panelid, property: filter1.property, validator: filter1.validator }));
         if (filter2Index > -1) {
-            filter1 = {
-                ...filter1,
-                values: mergeValues(filter1, filters2[filter2Index], overwriteValues)
-            }
+            filter1 = { ...filter1, values: mergeValues(filter1, filters2[filter2Index], settings.overwriteValues) };
             filters2.splice(filter2Index, 1);
+        } else {
+            filter1 = { ...filter1, operator: settings.setGroupedColumnOperator ? FILTER_GROUPED_COLUMN_OPERATOR : filter1.operator };
         }
         filters.push(filter1);
         return filters;
@@ -118,7 +123,15 @@ function mergeValues(filter1: IFSFilter, filter2: IFSFilter, overwrite = false):
 
     let newValues = [];
     if (!overwrite) {
-        if (isRangeValidator(filter1.validator)) {
+        if (isInValidator(filter1.validator)) {
+            newValues = filter1.values.reduce((values: IFValue[], value1: IFSValueRelativeDate) => {
+                const value2Index = (filter2.values as IFSValueRelativeDate[]).findIndex(value2 => value2.anchor === value1.anchor && value2.cursor === value1.cursor && value2.includeCurrent === value1.includeCurrent && value2.isCalendarDate === value1.isCalendarDate && value2.number === value1.number && value2.unit === value1.unit);
+                if (value2Index === -1) {
+                    values.push(filter2.values[value2Index]);
+                }
+                return values;
+            }, filter1.values as IFValue[]);
+        } else if (isRangeValidator(filter1.validator)) {
             newValues = filter1.values.reduce((values: IFValue[], value1: IFSValueRange) => {
                 const value2Index = (filter2.values as IFSValueRange[]).findIndex(value2 => value2.max === value1.max && value2.min === value1.min);
                 if (value2Index === -1) {
@@ -126,7 +139,7 @@ function mergeValues(filter1: IFSFilter, filter2: IFSFilter, overwrite = false):
                 }
                 return values;
             }, filter1.values as IFValue[]);
-        } else if (isRegularValidator(filter1.validator)) {
+        } else if (isRegularValidator(filter1.validator) || isNullValidator(filter1.validator)) {
             newValues = filter1.values.reduce((values: IFValue[], value1: IFSValue) => {
                 const value2Index = (filter2.values as IFSValue[]).findIndex(value2 => value2.imageUrl === value1.imageUrl && value2.value === value1.value);
                 if (value2Index === -1) {

package/src/filters/helpers/common/resolveDatasetConditions.ts

@@ -10,7 +10,7 @@ import { IFSDataset, IFSParamsToGetFilter } from "../../interfaces";
  * @returns true: the condition is satisfied
  */
 export function resolveDatasetConditions(dataset: IFSDataset, params: IFSParamsToGetFilter, letPassUndefinedProperties = false, letPassUndefinedParams = true): boolean {
-    return (!_hasProperty(params, 'enableds') || (letPassUndefinedProperties && dataset.enabled == null) || (letPassUndefinedParams && params.enableds == null) || params.enableds === dataset.enabled) &&
+    return (!_hasProperty(params, 'enableds') || !_hasProperty(params.enableds, 'datasets') || (letPassUndefinedProperties && dataset.enabled == null) || (letPassUndefinedParams && params.enableds.datasets == null) || params.enableds.datasets === dataset.enabled) &&
     (!_hasProperty(params, 'qrveyid') || (letPassUndefinedProperties && dataset.qrveyid == null) || (letPassUndefinedParams && isEmpty(params.qrveyid)) || params.qrveyid === dataset.qrveyid) &&
     (!_hasProperty(params, 'linkid') || (letPassUndefinedProperties && dataset.linkid == null) || (letPassUndefinedParams && isEmpty(params.linkid)) || params.linkid === dataset.linkid) &&
     dataset.filters.length > 0;

package/src/filters/helpers/common/resolveFilterConditions.ts

@@ -10,7 +10,7 @@ import { IFSFilter, IFSParamsToGetFilter } from "../../interfaces";
  * @returns true: the condition is satisfied
  */
 export function resolveFilterConditions(filter: IFSFilter, params: IFSParamsToGetFilter, letPassUndefinedProperties = false, letPassUndefinedParams = true): boolean {
-    return (!_hasProperty(params, 'enableds') || (letPassUndefinedProperties && filter.enabled == null) || (letPassUndefinedParams && params.enableds == null) || params.enableds === filter.enabled) &&
+    return (!_hasProperty(params, 'enableds') || !_hasProperty(params.enableds, 'filters') || (letPassUndefinedProperties && filter.enabled == null) || (letPassUndefinedParams && params.enableds.filters == null) || params.enableds.filters === filter.enabled) &&
     (!_hasProperty(params, 'dateSection') || (letPassUndefinedProperties && filter.dateSection == null) || (letPassUndefinedParams && isEmpty(params.dateSection)) || params.dateSection === filter.dateSection) &&
     (!_hasProperty(params, 'panelid') || (letPassUndefinedProperties && filter.extras.panelid == null) || (letPassUndefinedParams && isEmpty(params.panelid)) || params.panelid === filter.extras.panelid) &&
     (!_hasProperty(params, 'property') || (letPassUndefinedProperties && filter.property == null) || (letPassUndefinedParams && isEmpty(params.property)) || params.property === filter.property) &&
@@ -18,6 +18,5 @@ export function resolveFilterConditions(filter: IFSFilter, params: IFSParamsToGe
     (!_hasProperty(params, 'column') || (letPassUndefinedProperties && filter.column == null) || (letPassUndefinedParams && isEmpty(params.column)) || (params.column?.id === filter.column.id &&
         params.column?.qrveyid === filter.column.qrveyid &&
         params.column?.linkid === filter.column.linkid &&
-        params.column?.aggregate === filter.column.aggregate)) &&
-    filter.values.length > 0
+        params.column?.aggregate === filter.column.aggregate));
 }

package/src/filters/helpers/common/resolveScopeConditions.ts

@@ -10,7 +10,7 @@ import { IFSParamsToGetFilter, IFSScope } from "../../interfaces";
  * @returns true: the condition is satisfied
  */
 export function resolveScopeConditions(scope: IFSScope, params: IFSParamsToGetFilter, letPassUndefinedProperties = false, letPassUndefinedParams = true): boolean {
-    return (!_hasProperty(params, 'enableds') || (letPassUndefinedProperties && scope.enabled == null) || (letPassUndefinedParams && params.enableds == null) || params.enableds === scope.enabled) &&
+    return (!_hasProperty(params, 'enableds') || !_hasProperty(params.enableds, 'scopes') || (letPassUndefinedProperties && scope.enabled == null) || (letPassUndefinedParams && params.enableds.scopes == null) || params.enableds.scopes === scope.enabled) &&
     (!_hasProperty(params, 'scope') || (letPassUndefinedProperties && scope.scope == null) || (letPassUndefinedParams && isEmpty(params.scope)) || scope.scope === params.scope) &&
     (!_hasProperty(params, 'scopeid') || (letPassUndefinedProperties && scope.scopeid == null) || (letPassUndefinedParams && isEmpty(params.scopeid)) || scope.scopeid === params.scopeid) &&
     scope.datasets.filter.length > 0;

package/src/filters/helpers/getAggFiltersFromFilterData.ts

@@ -1,8 +1,6 @@
 import { isEmpty } from "../../general";
-import { IFBExpressionAggregate, IFBFilterAggregate, IFSData } from "../interfaces";
-import { getBackendValidator, getBackendValues } from "./backend";
+import { IFBFilterAggregate, IFSData } from "../interfaces";
 import { getFiltersByAggregateColumn } from "./common";
-import { FDToFlatUI } from "../adapters";
 
 /**
  * 
@@ -11,30 +9,29 @@ import { FDToFlatUI } from "../adapters";
  * @returns 
  */
 // [TODO: FILTERS - FIX AGGREGATE FILTERS]
-export function getAggFiltersFromFilterData(filterData: IFSData, summaries: any[]): IFBFilterAggregate {
+export function getAggFiltersFromFilterData(filterData: IFSData, _summaries: any[]): IFBFilterAggregate {
   filterData = { ...getFiltersByAggregateColumn(filterData) }; 
   if (isEmpty(filterData)) return;
 
-  const uFilters = FDToFlatUI(filterData);
+  // const uFilters = FDToFlatUI(filterData);
 
-  const aggFilters: IFBExpressionAggregate[] = uFilters.map(uFilter => {
-    const summaryIndex = summaries.findIndex(summary =>
-        uFilter.column.id === summary.questionid &&
-        uFilter.column.qrveyid === summary.qrveyid &&
-        uFilter.column.linkid === summary.linkid &&
-        uFilter.column.aggregate === summary.aggregate
-    );
-    if (summaryIndex > -1) {
-        return {
-          enabled: uFilter.enabled,
-          summaryIndex,
-          validationType: getBackendValidator(uFilter.validator),
-          value: getBackendValues(uFilter),
-        };
-      }
-  }).filter(Boolean);
+  // const aggFilters: IFBExpressionAggregate[] = uFilters.map(uFilter => {
+  //   const summaryIndex = summaries.findIndex(summary =>
+  //       uFilter.column.id === summary.questionid &&
+  //       uFilter.column.qrveyid === summary.qrveyid &&
+  //       uFilter.column.linkid === summary.linkid &&
+  //       uFilter.column.aggregate === summary.aggregate
+  //   );
+  //   if (summaryIndex > -1) {
+  //       return {
+  //         enabled: uFilter.enabled,
+  //         summaryIndex,
+  //         validationType: getBackendValidator(uFilter.validator),
+  //         value: getBackendValues(uFilter),
+  //       };
+  //     }
+  // }).filter(Boolean);
 
-  debugger
 //   // [TODO: FILTERS - Adapt filter.validator and filter.values in the backend format]
 //   const aggFilters: IFBFilterAggregate[] = filterData.scopes.map((scope) => {
 //     scope.datasets.forEach(dataset => {
@@ -61,5 +58,5 @@ export function getAggFiltersFromFilterData(filterData: IFSData, summaries: any[
 
 //   }).filter(aggFilter => aggFilter && aggFilter.expressions && aggFilter.expressions.length);
   
-  return // aggFilters && concatAggFilters(aggFilters);
+  return; // aggFilters && concatAggFilters(aggFilters);
 }

package/src/filters/helpers/getAvailableScopesIDsByConfig.ts

@@ -14,5 +14,5 @@ export function getAvailableScopesIDsByConfig(config: any = {}): IFSAvailableSco
         tabid: getAttribute(config, 'tab_id') || config.tabid,
         pageid: getAttribute(config, 'page_id') || config.pageid,
         defaultid: getAttribute(config, 'default_id') || config.defaultid,
-    }
+    };
 }

package/src/filters/helpers/getScopesByHierarchy.ts

@@ -10,9 +10,9 @@ import { IFScope, IFSScopeID } from "../interfaces";
 export function getScopesByHierarchy(scopes: IFSScopeID[] = [], currentScope: IFScope = FILTER_SCOPE.GLOBAL): IFSScopeID[] {
     const scopeIndex = scopes.findIndex(s => s.label === currentScope);
     const chartScopeIndex = scopes.findIndex(s => s.label === FILTER_SCOPE.CHART);
-    return (scopeIndex !== -1)
+    return scopeIndex !== -1
       ? scopes.slice(0, scopeIndex)
-      : (chartScopeIndex !== -1)
+      : chartScopeIndex !== -1
         ? scopes.slice(0, chartScopeIndex)
         : [];
 }

package/src/filters/helpers/ui/excludeUIFlatFiltersByScopes.ts

@@ -1,5 +1,5 @@
 import { cloneDeep, isEmpty } from "../../../general";
-import { IFScope, IFSData, IFUFlattenedFilter } from "../../interfaces";
+import { IFScope, IFUFlattenedFilter } from "../../interfaces";
 
 /**
  * Excludes and returns a UI Flat Filters without filters by the given scopes
@@ -7,7 +7,7 @@ import { IFScope, IFSData, IFUFlattenedFilter } from "../../interfaces";
  * @param scopes collection of scopes types
  * @returns The new array of UI Flattened filters
  */
-export function excludeUIFlatFiltersByScopes(uFilters: IFUFlattenedFilter[] = [], scopes: IFScope[]): IFUFlattenedFilter[] {
+export function excludeUIFlatFiltersByScopes(uFilters: IFUFlattenedFilter[] = [], scopes: IFScope[] = []): IFUFlattenedFilter[] {
     if (isEmpty(uFilters)) return [];
 
     uFilters = cloneDeep(uFilters);

package/src/filters/helpers/ui/getUIFlatFilterByParams.ts

@@ -14,7 +14,7 @@ import { resolveUIFlatFilterByParams } from "./resolveUIFlatFiltersByParams";
    * - Property type
    * @returns The index of the uFilter array or the Filter object s
    */
-export function getUIFlatFilterByParams(uFilters: IFUFlattenedFilter[] = [], params: IFUParamsToGetFilter, getIndex = false): number | IFUFlattenedFilter {
+export function getUIFlatFilterByParams(uFilters: IFUFlattenedFilter[] = [], params: IFUParamsToGetFilter = {}, getIndex = false): number | IFUFlattenedFilter {
     if (isEmpty(params)) return;
     uFilters = cloneDeep(uFilters);
 

package/src/filters/helpers/ui/getUIFlatFiltersByParams.ts

@@ -15,7 +15,7 @@ import { resolveUIFlatFilterByParams } from "./resolveUIFlatFiltersByParams";
    * - Enabled flags
    * @returns The index of the uFilter array or the Filter object s
    */
- export function getUIFlatFiltersByParams(uFilters: IFUFlattenedFilter[] = [], params: IFUParamsToGetFilter): IFUFlattenedFilter[] {
+ export function getUIFlatFiltersByParams(uFilters: IFUFlattenedFilter[] = [], params: IFUParamsToGetFilter = {}): IFUFlattenedFilter[] {
     if (isEmpty(params)) return;
     uFilters = cloneDeep(uFilters);
 

package/src/filters/helpers/ui/getUIFlatFiltersByScopes.ts

@@ -7,7 +7,7 @@ import { IFScope, IFUFlattenedFilter } from "../../interfaces";
  * @param scopes collection of scopes types
  * @returns The new array of UI Flattened filters
  */
- export function getUIFlatFiltersByScopes(uFilters: IFUFlattenedFilter[] = [], scopes: IFScope[]): IFUFlattenedFilter[] {
+ export function getUIFlatFiltersByScopes(uFilters: IFUFlattenedFilter[] = [], scopes: IFScope[] = []): IFUFlattenedFilter[] {
     if (isEmpty(uFilters)) return [];
     uFilters = cloneDeep(uFilters);
 

package/src/filters/helpers/ui/getUIValues.ts

@@ -1,4 +1,4 @@
-import { FILTER_VALIDATOR, FILTER_VALIDATOR_VALUE} from "../../constants";
+import { FILTER_VALIDATOR, FILTER_VALIDATOR_VALUE } from "../../constants";
 import { RELATIVE_CURSOR, RELATIVE_CURSOR_VALUE } from "../../../date";
 import { IFSFilter, IFSValue, IFSValueRange, IFSValueRanking, IFSValueRelativeDate, IFUValue } from "../../interfaces";
 import { COLUMN } from "../../../constants";
@@ -12,7 +12,7 @@ export function getUIValues(filter: IFSFilter, addEnableds = false, rankingGroup
         case FILTER_VALIDATOR.GREATER_THAN_EQUAL:
             return (filter.values as IFSValueRange[]).map(value => ({
                 value: value.min,
-                enabled: addEnableds ? (value.enabled != null ? value.enabled : true) : undefined,
+                enabled: addEnableds ? value.enabled != null ? value.enabled : true : undefined,
             }));
         case FILTER_VALIDATOR.BEFORE_ON:
         case FILTER_VALIDATOR.LESS_THAN_EQUAL:
@@ -20,26 +20,26 @@ export function getUIValues(filter: IFSFilter, addEnableds = false, rankingGroup
         case FILTER_VALIDATOR.LESS_THAN:
             return (filter.values as IFSValueRange[]).map(value => ({
                 value: value.max,
-                enabled: addEnableds ? (value.enabled != null ? value.enabled : true) : undefined,
+                enabled: addEnableds ? value.enabled != null ? value.enabled : true : undefined,
             }));
         case FILTER_VALIDATOR.BETWEEN_INCLUSIVE:
         case FILTER_VALIDATOR.BETWEEN_EXCLUSIVE:
             return (filter.values as IFSValueRange[]).map(value => ({
                 value: `${value.min} - ${value.max}`,
-                enabled: addEnableds ? (value.enabled != null ? value.enabled : true) : undefined,
+                enabled: addEnableds ? value.enabled != null ? value.enabled : true : undefined,
             }));
         case FILTER_VALIDATOR.IS_NULL:
         case FILTER_VALIDATOR.IS_NOT_NULL:
             return [{
                 value: FILTER_VALIDATOR_VALUE[filter.validator].label,
-                enabled: addEnableds ? filter.enabled : undefined,
+                enabled: addEnableds ? (filter.values as IFSValue[])[0]?.enabled : undefined,
             }];
         case FILTER_VALIDATOR.IN:
             return (filter.values as IFSValueRelativeDate[]).map(value => ({
                 value: 
                 `${RELATIVE_CURSOR_VALUE[value.cursor].label} ${value.cursor !== RELATIVE_CURSOR.THIS && value.number > 1 ? value.number : ''} ${getValueUiUnitRelativeDate(value)} ${value.cursor !== RELATIVE_CURSOR.THIS ? `from ${value.anchor || 'current date'}`: ''}`,
                 enabled: addEnableds ? filter.enabled : undefined,
-            }))
+            }));
         default:
             if (filter.column.type === COLUMN.RANKING && isEmpty(filter.column.aggregate)) {
                 return getRankingUIValues(filter.values as IFSValueRanking[][], addEnableds, rankingGroupIndex);
@@ -47,17 +47,17 @@ export function getUIValues(filter: IFSFilter, addEnableds = false, rankingGroup
             return ((filter.values || []) as IFSValue[]).map(val => ({
                 imageUrl: val.imageUrl,
                 value: val.value,
-                enabled: addEnableds ? (val.enabled != null ? val.enabled : true) : undefined,
+                enabled: addEnableds ? val.enabled != null ? val.enabled : true : undefined,
                 valueid: val.valueid,
             }));
     }
 }
 
 function getValueUiUnitRelativeDate(relative: IFSValueRelativeDate) {
-    return relative.cursor !== RELATIVE_CURSOR.THIS && relative.number > 1 ? `${relative.unit}s`: relative.unit
+    return relative.cursor !== RELATIVE_CURSOR.THIS && relative.number > 1 ? `${relative.unit}s`: relative.unit;
 }
 
-function getRankingUIValues(values: IFSValueRanking[][], addEnableds = false , rankingGroupIndex?: number) {
+function getRankingUIValues(values: IFSValueRanking[][], addEnableds = false, rankingGroupIndex?: number) {
     const flattenValues: IFSValueRanking[] = rankingGroupIndex == null ? flattenDeep(values) : values[rankingGroupIndex];
     return flattenValues.map((rankingValue) => ({
         rankingIndex: rankingGroupIndex,

package/src/filters/helpers/ui/resolveUIFlatFiltersByParams.ts

@@ -16,5 +16,5 @@ export function resolveUIFlatFilterByParams(filter: IFUFlattenedFilter, params:
         (isEmpty(params.scopeid) || filter.extras.scopeid === params.scopeid) &&
         (isEmpty(params.panelid) || filter.extras.panelid === params.panelid) &&
         (isEmpty(params.validator) || filter.validator === params.validator) &&
-        (isEmpty(params.property) || filter.property === params.property)
+        (isEmpty(params.property) || filter.property === params.property);
 }

package/src/filters/interfaces/OLD_IFilterDetail.ts

@@ -1,4 +1,5 @@
 import { IQrveyColumn } from "../../interfaces/Qrvey.Interface";
+import { IFSFilterExtrasInfo } from "./common";
 import { IFDateSection } from "./IFDateSection";
 import { IFOperator } from "./IFOperator";
 import { IFProperty } from "./IFProperty";
@@ -25,6 +26,7 @@ export interface OLD_IFilterDetail {
     panelid?: string;
     panelName?: string;
     expressionid?: string;
+    info?: IFSFilterExtrasInfo;
     scope?: IFScope;
     scopeid?: string;
     scopeEnabled?: boolean;
@@ -37,4 +39,6 @@ export interface OLD_IFilterDetail {
     }[] | IFUValue[];
     section?: IFSection;
     groupValue?: IFProperty
+
+    extras?: any; // Specific case for those filters that need to store something else
 }