@qrvey/utils 1.3.0-1 → 1.3.0-12

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

@@ -0,0 +1,35 @@
+import { isEmpty } from "../../../general/mix/isEmpty";
+import { IDataset } from "../../../qrvey/interfaces/IDataset";
+import { IFUData } from "../../interfaces/ui/IFUData";
+
+/**
+ * Filtering the filters by the columns of datasets.
+ * Module specially for CLS.
+ * @param data the filter data
+ * @param datasets the collection of datasets and their columns
+ * @returns A new filter data with the filtered filters by columns
+ */
+export function getFiltersByDatasetsColumns(data: IFUData, datasets: IDataset[] = []): IFUData {
+    if (isEmpty(data) || isEmpty(data.scopes)) return;
+
+    return {
+        ...data,
+        scopes: data.scopes.map(scope => ({
+            ...scope,
+            datasets: scope.datasets.map(filterDataset => {
+                const dataset = datasets.find(data => data.qrveyid === filterDataset.qrveyid);
+                if (!isEmpty(dataset)) {
+                    return {
+                        ...filterDataset,
+                        filters: filterDataset.filters.map(filter => {
+                            const column = (dataset.options || []).find(cInfo => cInfo.id === filter.column.id && cInfo.qrveyid === filter.column.qrveyid);
+                            if (!isEmpty(column)) {
+                                return { ...filter };
+                            }
+                        }).filter(Boolean)
+                    };
+                }
+            }).filter(dataset => !isEmpty(dataset) && dataset.filters.length > 0)
+        })).filter(scope => !isEmpty(scope) && scope.datasets.length > 0)
+    };
+}

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

@@ -5,12 +5,12 @@ import { IFSData } from "../../interfaces/common/IFSData";
 import { IFSDataset } from "../../interfaces/common/IFSDataset";
 import { IFSFilter } from "../../interfaces/common/IFSFilter";
 import { IFSParamsToGetFilter } from "../../interfaces/common/IFSParamsToGetFilter";
-import { IFSParamsToGetFilterSettings } from "../../interfaces/common/IFSParamsToGetFilterSettings";
 import { IFSScope } from "../../interfaces/common/IFSScope";
 import { IFSValue } from "../../interfaces/common/IFSValue";
 import { IFSValueRange } from "../../interfaces/common/IFSValueRange";
 import { IFSValueRanking } from "../../interfaces/common/IFSValueRanking";
 import { IFSValueRelativeDate } from "../../interfaces/common/IFSValueRelativeDate";
+import { IFFiltersParamsToGetFilter } from "../../interfaces/functions/IFFiltersParamsToGetFilter";
 import { IFValue } from "../../interfaces/IFValue";
 import { IFUData } from "../../interfaces/ui/IFUData";
 import { getParamsToGetFilterSettings } from "./getParamsToGetFilterSettings";
@@ -33,7 +33,7 @@ import { resolveScopeConditions } from "./resolveScopeConditions";
  * @param params given parameters to validate the dataset 
  * @returns a new Filter object structure
  */
-export function getFiltersByParams(filterData: IFSData | IFUData, params: IFSParamsToGetFilter, settings?: IFSParamsToGetFilterSettings): IFSData | IFUData {
+export function getFiltersByParams(filterData: IFSData | IFUData, params: IFSParamsToGetFilter, settings?: IFFiltersParamsToGetFilter): IFSData | IFUData {
     if (isEmpty(filterData) || isEmpty(filterData.scopes)) return;
     if (isEmpty(params)) return filterData;
     filterData = cloneDeep(filterData);
@@ -52,7 +52,7 @@ export function getFiltersByParams(filterData: IFSData | IFUData, params: IFSPar
                     if (resolveFilterConditions(filter, params, settings.letPassUndefinedProperties.filter, settings.letPassUndefinedParams.filter)) {
                       return {
                         ...filter,
-                        values: filter.values.map((value: IFValue) => {
+                        values: (filter.values || []).map((value: IFValue) => {
                           if (Array.isArray(value) && value.length > 0) {
                             const rankingValues = value as IFSValueRanking[];
                             return rankingValues.map(rValue => {
@@ -64,7 +64,7 @@ export function getFiltersByParams(filterData: IFSData | IFUData, params: IFSPar
                           }
                         }).filter(Boolean) };
                     }
-                  }).filter(filter => !isEmpty(filter) && (!settings.filterEmptyArrays.filter || filter.values.length > 0))
+                  }).filter(filter => !isEmpty(filter) && (!settings.filterEmptyArrays.filter || filter.selectAll || filter.values?.length > 0))
                 };  
               }  
             }).filter(dataset => !isEmpty(dataset) && (!settings.filterEmptyArrays.dataset || dataset.filters.length > 0))

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

@@ -1,12 +1,13 @@
-import { IFSMergeFiltersSettings } from "../../interfaces/common/IFSMergeFiltersSettings";
+import { IFFiltersMergeFilters } from "../../interfaces/functions/IFFiltersMergeFilters";
 
 /**
  * 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 {
+export function getMergeFiltersSettings(settings?: IFFiltersMergeFilters): IFFiltersMergeFilters {
     return {
+        overwriteFilterProps: settings?.overwriteFilterProps ?? true,
         overwriteValues: settings?.overwriteValues ?? false,
         setGroupedColumnOperator: settings?.setGroupedColumnOperator ?? true
     };

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

@@ -0,0 +1,12 @@
+import { IFFiltersMergeValues } from "../../interfaces/functions/IFFiltersMergeValues";
+
+/**
+ * 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 getMergeValuesSettings(settings?: IFFiltersMergeValues): IFFiltersMergeValues {
+    return {
+        overwriteValues: settings?.overwriteValues ?? false,
+    };
+}

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

@@ -1,11 +1,11 @@
-import { IFSParamsToGetFilterSettings } from "../../interfaces/common/IFSParamsToGetFilterSettings";
+import { IFFiltersParamsToGetFilter } from "../../interfaces/functions/IFFiltersParamsToGetFilter";
 
 /**
  * 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 {
+export function getParamsToGetFilterSettings(settings?: IFFiltersParamsToGetFilter): IFFiltersParamsToGetFilter {
     return {
         letPassUndefinedParams: {
             dataset: settings?.letPassUndefinedParams?.dataset ?? true,

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

@@ -0,0 +1,19 @@
+import { getDataAnswersByColumn } from "../../../qrvey/helpers/getDataAnswersByColumn";
+import { modelAnswerToFilterValue } from "../../adapters/modelAnswerToFilterValue";
+import { IFBData } from "../../interfaces/backend/IFBData";
+import { IFFiltersGetValuesFromDataset } from "../../interfaces/functions/IFFiltersGetValuesFromDataset";
+
+/**
+ * Gets the values from the model object that will be used to filter. Static values are values to belong from static values questions. Static values questions are questions that do not need request an info from backend, instead the info is got from Model object.
+ * @param props Configuration to get static values from the given dataset.
+ * @returns The values.
+ */
+export function getValuesFromDataset(props: IFFiltersGetValuesFromDataset): IFBData {
+    const answers = getDataAnswersByColumn({ column: props.column, dataset: props.dataset, property: props.property, lookupDisplay: props.lookupDisplay });
+    const data = modelAnswerToFilterValue(answers);
+    const values: IFBData = { data, total: data.length };
+    if (props.value) {
+      values.data = values.data.filter(v => v.value.toLowerCase().includes(props.value.toLowerCase()));
+    }
+    return values;
+}

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

@@ -0,0 +1,19 @@
+import { getDataAnswersByColumn } from "../../../qrvey/helpers/getDataAnswersByColumn";
+import { modelAnswerToFilterValue } from "../../adapters/modelAnswerToFilterValue";
+import { IFBData } from "../../interfaces/backend/IFBData";
+import { IFFiltersGetValuesFromModel } from "../../interfaces/functions/IFFiltersGetValuesFromModel";
+
+/**
+ * Gets the values from the model object that will be used to filter. Static values are values to belong from static values questions. Static values questions are questions that do not need request an info from backend, instead the info is got from Model object.
+ * @param props Configuration to get static values from the given model.
+ * @returns The values.
+ */
+export function getValuesFromModel(props: IFFiltersGetValuesFromModel): IFBData {
+    const answers = getDataAnswersByColumn({ column: props.column, model: props.model, property: props.property, lookupDisplay: props.lookupDisplay });
+    const data = modelAnswerToFilterValue(answers);
+    const values: IFBData = { data, total: data.length };
+    if (props.value) {
+      values.data = values.data.filter(v => v.value.toLowerCase().includes(props.value.toLowerCase()));
+    }
+    return values;
+}

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

@@ -1,25 +1,32 @@
 export * from './areFiltersEquals';
-export * from './isDateDistinctProperty';
+
 export * from './excludeFiltersByAggregateColumn';
 export * from './excludeFiltersByParams';
 export * from './excludeFiltersByScopes';
+
 export * from './getFilterColumnLabel';
 export * from './getFilterid';
 export * from './getFilterLabel';
 export * from './getFiltersByAggregateColumn';
+export * from './getFiltersByDatasetsColumns';
 export * from './getFiltersByParams';
 export * from './getFiltersByScopes';
 export * from './getFiltersByScopesIds';
 export * from './getFiltersByVisibility';
 export * from './getMergeFiltersSettings';
 export * from './getParamsToGetFilterSettings';
+export * from './getValuesFromModel';
+export * from './getValuesFromDataset';
 export * from './haveFiltersByDataset';
 export * from './isBetweenValidator';
+export * from './isDateDistinctProperty';
 export * from './isInValidator';
 export * from './isNullValidator';
 export * from './isRangeValidator';
 export * from './isRegularValidator';
 export * from './mergeFilters';
+export * from './mergeValues';
 export * from './resolveDatasetConditions';
 export * from './resolveFilterConditions';
 export * from './resolveScopeConditions';
+// export * from './validateFilterTextByColumn';

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

@@ -4,18 +4,12 @@ import { FILTER_GROUPED_COLUMN_OPERATOR } from "../../constants/common/FILTER_GR
 import { IFSData } from "../../interfaces/common/IFSData";
 import { IFSDataset } from "../../interfaces/common/IFSDataset";
 import { IFSFilter } from "../../interfaces/common/IFSFilter";
-import { IFSMergeFiltersSettings } from "../../interfaces/common/IFSMergeFiltersSettings";
 import { IFSScope } from "../../interfaces/common/IFSScope";
-import { IFSValue } from "../../interfaces/common/IFSValue";
-import { IFSValueRange } from "../../interfaces/common/IFSValueRange";
-import { IFSValueRelativeDate } from "../../interfaces/common/IFSValueRelativeDate";
-import { IFValue } from "../../interfaces/IFValue";
+import { IFFiltersMergeFilters } from "../../interfaces/functions/IFFiltersMergeFilters";
 import { IFUData } from "../../interfaces/ui/IFUData";
+import { getFilterid } from "./getFilterid";
 import { getMergeFiltersSettings } from "./getMergeFiltersSettings";
-import { isInValidator } from "./isInValidator";
-import { isNullValidator } from "./isNullValidator";
-import { isRangeValidator } from "./isRangeValidator";
-import { isRegularValidator } from "./isRegularValidator";
+import { mergeValues } from "./mergeValues";
 import { resolveDatasetConditions } from "./resolveDatasetConditions";
 import { resolveFilterConditions } from "./resolveFilterConditions";
 import { resolveScopeConditions } from "./resolveScopeConditions";
@@ -24,10 +18,10 @@ import { resolveScopeConditions } from "./resolveScopeConditions";
  * Merge filter data structures in a new one. The first Filter Data passed in the argument has the priority
  * @param filterData1 The target filter data
  * @param filterData2 the filter data to be merged
- * @param overwriteValues Flag to overwrite or not the filter values
+ * @param settings configuration of the mergeFilter
  * @returns a new filter data structure
  */
-export function mergeFilters(filterData1: IFSData | IFUData, filterData2: IFSData | IFUData, settings?: IFSMergeFiltersSettings): IFSData | IFUData {
+export function mergeFilters(filterData1: IFSData | IFUData, filterData2: IFSData | IFUData, settings?: IFFiltersMergeFilters): IFSData | IFUData {
     if (isEmpty(filterData1) || isEmpty(filterData1.scopes)) {
         if (isEmpty(filterData2) || isEmpty(filterData2.scopes)) return;
         return filterData2;
@@ -50,10 +44,10 @@ export function mergeFilters(filterData1: IFSData | IFUData, filterData2: IFSDat
  * Gets a new scope structure array by merging two scope structures
  * @param scopes1 the target scope structure
  * @param scopes2 the scope to be merged
- * @param overwriteValues Flag to overwrite or not the filter values
+ * @param settings configuration of the mergeFilter
  * @returns a new scope structure array
  */
-function mergeScopes(scopes1: IFSScope[] = [], scopes2: IFSScope[] = [], settings?: IFSMergeFiltersSettings): IFSScope[] {
+function mergeScopes(scopes1: IFSScope[] = [], scopes2: IFSScope[] = [], settings?: IFFiltersMergeFilters): 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) {
@@ -75,10 +69,10 @@ function mergeScopes(scopes1: IFSScope[] = [], scopes2: IFSScope[] = [], setting
  * Gets a new dataset structure array by merging two dataset structures
  * @param datasets1 the target dataset structure
  * @param datasets2 the dataset to be merged
- * @param overwriteValues Flag to overwrite or not the filter values
+ * @param settings configuration of the mergeFilter
  * @returns a new dataset structure array
  */
-function mergeDatasets(datasets1: IFSDataset[] = [], datasets2: IFSDataset[] = [], settings?: IFSMergeFiltersSettings): IFSDataset[] {
+function mergeDatasets(datasets1: IFSDataset[] = [], datasets2: IFSDataset[] = [], settings?: IFFiltersMergeFilters): 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) {
@@ -100,18 +94,20 @@ function mergeDatasets(datasets1: IFSDataset[] = [], datasets2: IFSDataset[] = [
  * Gets a new filter structure array by merging two filter structures
  * @param filters1 the target filter structure
  * @param filters2 the filter to be merged
- * @param overwriteValues Flag to overwrite or not the filter values
+ * @param settings configuration of the mergeFilter
  * @returns a new filter structure array
  */
-function mergeFilterss(filters1: IFSFilter[] = [], filters2: IFSFilter[] = [], settings?: IFSMergeFiltersSettings): IFSFilter[] {
+function mergeFilterss(filters1: IFSFilter[] = [], filters2: IFSFilter[] = [], settings?: IFFiltersMergeFilters): 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], settings.overwriteValues) };
+            filter1 = { ...filter1, values: mergeValues(filter1, filters2[filter2Index], settings) };
+            filter1 = mergeFilterProps(filter1, filters2[filter2Index], settings);
             filters2.splice(filter2Index, 1);
         } else {
             filter1 = { ...filter1, operator: settings.setGroupedColumnOperator ? FILTER_GROUPED_COLUMN_OPERATOR : filter1.operator };
         }
+        filter1.filterid = getFilterid(filter1);
         filters.push(filter1);
         return filters;
     }, [] as IFSFilter[]);
@@ -121,49 +117,26 @@ function mergeFilterss(filters1: IFSFilter[] = [], filters2: IFSFilter[] = [], s
 }
 
 /**
- * Gets a new value structure array by merging two value structures
+ * Gets a new filter structure when the setting is configured
  * @param filter1 the target filter structure
  * @param filter2 the filter to be used to merge the values
- * @param overwrite Flag to overwrite or not the filter values
- * @returns a new value structure array
+ * @param settings configuration of the mergeFilter
+ * @returns a new filter structure with overwritted props
  */
-function mergeValues(filter1: IFSFilter, filter2: IFSFilter, overwrite = false): IFValue[] {
-    if (isEmpty(filter1) && isEmpty(filter2)) return [];
-
-    let newValues = [];
-    if (!overwrite) {
-        if (isInValidator(filter1.validator)) {
-            newValues = filter2.values.reduce((values: IFValue[], value2: IFSValueRelativeDate) => {
-                const value1Index = (filter1.values as IFSValueRelativeDate[]).findIndex(value1 => 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 (value1Index === -1) {
-                    values.push(value2);
-                }
-                return values;
-            }, filter1.values as IFValue[]);
-        } else if (isRangeValidator(filter1.validator)) {
-            newValues = filter2.values.reduce((values: IFValue[], value2: IFSValueRange) => {
-                const value1Index = (filter1.values as IFSValueRange[]).findIndex(value1 => value2.max === value1.max && value2.min === value1.min);
-                if (value1Index === -1) {
-                    values.push(value2);
-                }
-                return values;
-            }, filter1.values as IFValue[]);
-        } else if (isRegularValidator(filter1.validator) || isNullValidator(filter1.validator)) {
-            newValues = filter2.values.reduce((values: IFValue[], value2: IFSValue) => {
-                const value1Index = (filter1.values as IFSValue[]).findIndex(value1 => value2.imageUrl === value1.imageUrl && value2.value === value1.value);
-                if (value1Index === -1) {
-                    values.push(value2);
-                }
-                return values;
-            }, filter1.values as IFValue[]);
-        } else {
-            filter1.values = filter1.values.concat(filter2.values);
-            newValues = filter1.values;
-        }
-    } else {
-        filter1.values = filter2.values;
-        newValues = filter1.values;
+function mergeFilterProps(filter1: IFSFilter, filter2: IFSFilter, settings?: IFFiltersMergeFilters) {
+    if (settings.overwriteFilterProps) {
+        filter1 = {
+            ...filter1,
+            collapsed: filter2.collapsed ?? filter1.collapsed,
+            displayed: filter2.displayed ?? filter1.displayed,
+            dateSection: filter2.dateSection,
+            extras: filter2.extras,
+            enabled: filter2.enabled ?? filter1.enabled,
+            filterid: filter2.filterid,
+            lookupDisplayIndex: filter2.lookupDisplayIndex,
+            nullValues: filter2.nullValues,
+            selectAll: filter2.selectAll,
+        };
     }
-
-    return newValues;
+    return filter1;
 }

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

@@ -0,0 +1,90 @@
+import { isEmpty } from "../../../general/mix/isEmpty";
+import { IFSFilter } from "../../interfaces/common/IFSFilter";
+import { IFSValue } from "../../interfaces/common/IFSValue";
+import { IFSValueRange } from "../../interfaces/common/IFSValueRange";
+import { IFSValueRelativeDate } from "../../interfaces/common/IFSValueRelativeDate";
+import { IFFiltersMergeValues } from "../../interfaces/functions/IFFiltersMergeValues";
+import { IFValue } from "../../interfaces/IFValue";
+import { getMergeValuesSettings } from "./getMergeValuesSettings";
+import { isInValidator } from "./isInValidator";
+import { isNullValidator } from "./isNullValidator";
+import { isRangeValidator } from "./isRangeValidator";
+import { isRegularValidator } from "./isRegularValidator";
+
+/**
+ * Gets a new value structure array by merging two value structures
+ * @param filter1 the target filter structure
+ * @param filter2 the filter to be used to merge the values
+ * @param settings configuration of the mergeFilter
+ * @returns a new value structure array
+ */
+export function mergeValues(filter1: IFSFilter, filter2: IFSFilter, settings?: IFFiltersMergeValues): IFValue[] {
+    if (isEmpty(filter1) && isEmpty(filter2)) return [];
+
+    settings = getMergeValuesSettings(settings);
+
+    let newValues = [];
+    let filter1Values = filter1.values || [];
+    const filter2Values = filter2.values || [];
+    if (settings.overwriteValues) {
+        filter1Values = filter2Values;
+        newValues = filter1Values;
+    } else {
+        if (isInValidator(filter1.validator)) {
+            newValues = filter2Values.reduce((values: IFSValueRelativeDate[], value2: IFSValueRelativeDate) => {
+                const value1Index = (filter1Values as IFSValueRelativeDate[]).findIndex(value1 => 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 (value1Index === -1) {
+                    values.push(value2);
+                } else {
+                    values[value1Index] = {
+                        anchor: value2.anchor,
+                        cursor: value2.cursor,
+                        displayed: value2.displayed ?? values[value1Index].displayed,
+                        enabled: value2.enabled ?? values[value1Index].enabled,
+                        includeCurrent: value2.includeCurrent,
+                        isCalendarDate: value2.isCalendarDate,
+                        number: value2.number,
+                        unit: value2.unit,
+                    };
+                }
+                return values;
+            }, filter1Values as IFValue[]);
+        } else if (isRangeValidator(filter1.validator)) {
+            newValues = filter2Values.reduce((values: IFSValueRange[], value2: IFSValueRange) => {
+                const value1Index = (filter1Values as IFSValueRange[]).findIndex(value1 => value2.max === value1.max && value2.min === value1.min);
+                if (value1Index === -1) {
+                    values.push(value2);
+                } else {
+                    values[value1Index] = {
+                        displayed: value2.displayed ?? values[value1Index].displayed,
+                        enabled: value2.enabled ?? values[value1Index].enabled,
+                        max: value2.max,
+                        min: value2.min,
+                    };
+                }
+                return values;
+            }, filter1Values as IFValue[]);
+        } else if (isRegularValidator(filter1.validator) || isNullValidator(filter1.validator)) {
+            newValues = filter2Values.reduce((values: IFSValue[], value2: IFSValue) => {
+                const value1Index = (filter1Values as IFSValue[]).findIndex(value1 => value2.imageUrl === value1.imageUrl && value2.value === value1.value);
+                if (value1Index === -1) {
+                    values.push(value2);
+                } else {
+                    values[value1Index] = {
+                        displayed: value2.displayed ?? values[value1Index].displayed,
+                        enabled: value2.enabled ?? values[value1Index].enabled,
+                        imageUrl: value2.imageUrl,
+                        value: value2.value,
+                        valueid: value2.valueid,
+                    };
+                }
+                return values;
+            }, filter1Values as IFValue[]);
+        } else {
+            filter1Values = filter1Values.concat(filter2Values);
+            newValues = filter1Values;
+        }
+    }
+
+    return newValues;
+}

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

@@ -17,8 +17,8 @@ export function resolveFilterConditions(filter: IFSFilter, params: IFSParamsToGe
     (!_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) &&
     (!_hasProperty(params, 'validator') || (letPassUndefinedProperties && filter.validator == null) || (letPassUndefinedParams && isEmpty(params.validator)) || params.validator === filter.validator) &&
-    (!_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));
+    (!_hasProperty(params, 'column') || (letPassUndefinedProperties && filter.column == null) || (letPassUndefinedParams && isEmpty(params.column)) || ((letPassUndefinedParams && isEmpty(params.column?.id) || params.column?.id === filter.column.id) &&
+        (letPassUndefinedParams && isEmpty(params.column?.qrveyid) || params.column?.qrveyid === filter.column.qrveyid) &&
+        (letPassUndefinedParams && isEmpty(params.column?.linkid) || params.column?.linkid === filter.column.linkid) &&
+        (letPassUndefinedParams && isEmpty(params.column?.aggregate) || params.column?.aggregate === filter.column.aggregate)));
 }

package/src/filters/helpers/getAggFiltersFromFilterData.ts

@@ -4,12 +4,12 @@ import { IFSData } from "../interfaces/common/IFSData";
 import { getFiltersByAggregateColumn } from "./common/getFiltersByAggregateColumn";
 
 /**
- * 
- * @param logics 
- * @param summaries 
- * @returns 
+ * @todo FIX AGGREGATE FILTERS
+ * @private
+ * @param filterData 
+ * @param _summaries 
+ * @returns the aggFilters structure
  */
-// [TODO: FILTERS - FIX AGGREGATE FILTERS]
 export function getAggFiltersFromFilterData(filterData: IFSData, _summaries: any[]): IFBFilterAggregate {
   filterData = { ...getFiltersByAggregateColumn(filterData) }; 
   if (isEmpty(filterData)) return;

package/src/filters/helpers/index.ts

@@ -4,6 +4,9 @@ export * from './common/index';
 export * from './ui/index';
 
 export * from './applyHierarchyForAggFilters';
+// export * from './getAggFiltersFromFilterData';
 export * from './getAvailableScopes';
 export * from './getAvailableScopesIDsByConfig';
 export * from './getScopesByHierarchy';
+
+export * from './OLD_getAggFilters';

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

@@ -2,7 +2,7 @@ import { isEmpty } from "../../../general/mix/isEmpty";
 import { cloneDeep } from "../../../general/object/cloneDeep";
 import { IFUFlattenedFilter } from "../../interfaces/ui/IFUFlattenedFilter";
 import { IFUParamsToGetFilter } from "../../interfaces/ui/IFUParamsToGetFilter";
-import { resolveUIFlatFilterByParams } from "./resolveUIFlatFiltersByParams";
+import { resolveUIFlatFilterByParams } from "./resolveUIFlatFilterByParams";
 
  /**
    * Gets a filter from the given Flattened UI Filters by given params. Return a index of the array or an object

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

@@ -2,7 +2,7 @@ import { isEmpty } from "../../../general/mix/isEmpty";
 import { cloneDeep } from "../../../general/object/cloneDeep";
 import { IFUFlattenedFilter } from "../../interfaces/ui/IFUFlattenedFilter";
 import { IFUParamsToGetFilter } from "../../interfaces/ui/IFUParamsToGetFilter";
-import { resolveUIFlatFilterByParams } from "./resolveUIFlatFiltersByParams";
+import { resolveUIFlatFilterByParams } from "./resolveUIFlatFilterByParams";
 
 /**
    * Gets a filter from the given Flattened UI Filters by given params. Return a index of the array or an object

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

@@ -12,65 +12,74 @@ import { IFSValueRanking } from "../../interfaces/common/IFSValueRanking";
 import { flattenDeep } from "../../../general/array/flattenDeep";
 import { RELATIVE_CURSOR_INFO } from "../../../dates/relative/constants/RELATIVE_CURSOR_INFO";
 import { IFUUIValueSettings } from "../../interfaces/ui/IFUUIValueSettings";
-import { getI18nDateGroupLabel, IDateColumnPropertyType } from "../../..";
+import { getI18nDateGroupLabel } from "../../../globalization/helpers/getI18nDateGroupLabel";
+import { IDateColumnPropertyType } from "../../../columns/interfaces/IDateColumnPropertyType";
 
 /**
- * Gets the UI Values from the filter object
- * @param filter The filter object
- * @param settings configuration for this function
+ * Gets the UI Values generated depending on the validator
+ * @param filter the filter structure
+ * @param settings a settings for this function
  * @returns an array of values
  */
 export function getUIValues(filter: IFSFilter, settings?: IFUUIValueSettings): IFUValue[] {
     settings = getUiValuesSettings(settings);
+
+    const values = filter.values || [];
     switch (filter.validator) {
         case FILTER_VALIDATOR.AFTER:
         case FILTER_VALIDATOR.GREATER_THAN:
         case FILTER_VALIDATOR.AFTER_ON:
         case FILTER_VALIDATOR.GREATER_THAN_EQUAL:
-            return (filter.values as IFSValueRange[]).map(value => ({
+            return (values as IFSValueRange[]).map(value => ({
                 value: getValueLabel(value.min, filter, settings),
+                displayed: value.displayed != null ? value.displayed : true,
                 enabled: settings.addEnableds ? value.enabled != null ? value.enabled : true : undefined,
             }));
         case FILTER_VALIDATOR.BEFORE_ON:
         case FILTER_VALIDATOR.LESS_THAN_EQUAL:
         case FILTER_VALIDATOR.BEFORE:
         case FILTER_VALIDATOR.LESS_THAN:
-            return (filter.values as IFSValueRange[]).map(value => ({
+            return (values as IFSValueRange[]).map(value => ({
                 value: getValueLabel(value.max, filter, settings),
+                displayed: value.displayed != null ? value.displayed : true,
                 enabled: settings.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 => ({
+            return (values as IFSValueRange[]).map(value => ({
                 value: `${getValueLabel(value.min, filter, settings)} ${getRangeSeparator(settings)} ${getValueLabel(value.max, filter, settings)}`,
+                displayed: value.displayed != null ? value.displayed : true,
                 enabled: settings.addEnableds ? value.enabled != null ? value.enabled : true : undefined,
             }));
         case FILTER_VALIDATOR.IS_NULL:
         case FILTER_VALIDATOR.IS_NOT_NULL:
             return [{
                 value: settings?.translate ? settings.translate('filter.validators.' + filter.validator.toLowerCase() + '_label') : FILTER_VALIDATOR_INFO[filter.validator].label,
-                enabled: settings.addEnableds ? (filter.values as IFSValue[])[0]?.enabled : undefined,
+                displayed: (values as IFSValue[])[0]?.displayed,
+                enabled: settings.addEnableds ? (values as IFSValue[])[0]?.enabled : undefined,
             }];
         case FILTER_VALIDATOR.IN:
-            return (filter.values as IFSValueRelativeDate[]).map(value => {
+            return (values as IFSValueRelativeDate[]).map(value => {
                 const cursor = settings?.translate ? settings.translate(RELATIVE_CURSOR_INFO[value.cursor].i18nLabelPath) : RELATIVE_CURSOR_INFO[value.cursor].i18nLabelPath;
                 const from = settings?.translate ? settings.translate('filter.relative_container.from_label') : 'from';
                 const anchor = settings?.translate ?  settings?.translate('filter.relative_container.current_date') : 'current date';
                 return {
                     value: 
                     `${cursor} ${value.cursor !== RELATIVE_CURSOR.THIS && value.number > 1 ? value.number : ''} ${getValueUiUnitRelativeDate(value, settings)} ${value.cursor !== RELATIVE_CURSOR.THIS ? `${from} ${value.anchor || anchor}`: ''}`,
-                    enabled: settings.addEnableds ? filter.enabled : undefined,
+                    displayed: value.displayed != null ? value.displayed : true,
+                    enabled: settings.addEnableds ? value.enabled : undefined,
                 };
             });
         default:
             if (filter.column.type === COLUMN.RANKING && isEmpty(filter.column.aggregate)) {
-                return getRankingUIValues(filter.values as IFSValueRanking[][], settings.addEnableds, settings.rankingGroupIndex);
+                return getRankingUIValues(values as IFSValueRanking[][], settings.addEnableds, settings.rankingGroupIndex);
             }
-            return ((filter.values || []) as IFSValue[]).map(val => ({
-                imageUrl: val.imageUrl,
-                value: getValueLabel(val.value, filter, settings),
-                enabled: settings.addEnableds ? val.enabled != null ? val.enabled : true : undefined,
-                valueid: val.valueid,
+            return (values as IFSValue[]).map(value => ({
+                imageUrl: value.imageUrl,
+                value: getValueLabel(value.value, filter, settings),
+                displayed: value.displayed != null ? value.displayed : true,
+                enabled: settings.addEnableds ? value.enabled != null ? value.enabled : true : undefined,
+                valueid: value.valueid,
             }));
     }
 }
@@ -100,6 +109,7 @@ function getRankingUIValues(values: IFSValueRanking[][], addEnableds = false, ra
         rankingIndex: rankingGroupIndex,
         value: `${rankingValue.value.value} - ${rankingValue.position}`,
         valueid: rankingValue.value.valueid,
+        displayed: rankingValue.displayed != null ? rankingValue.displayed : true,
         enabled: addEnableds ? rankingValue.enabled : undefined
     }));
 }

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

@@ -8,4 +8,5 @@ export * from './getUIFlatFiltersByParams';
 export * from './getUIFlatFiltersByScopes';
 export * from './getUIValues';
 export * from './getUpdatedUIFilters';
+export * from './resolveUIFlatFilterByParams';
 export * from './transformFilterValues';

package/src/filters/helpers/ui/{resolveUIFlatFiltersByParams.ts → resolveUIFlatFilterByParams.ts}

@@ -1,5 +1,6 @@
-import { isEmpty } from "../../../general";
-import { IFUFlattenedFilter, IFUParamsToGetFilter } from "../../interfaces";
+import { isEmpty } from "../../../general/mix/isEmpty";
+import { IFUFlattenedFilter } from "../../interfaces/ui/IFUFlattenedFilter";
+import { IFUParamsToGetFilter } from "../../interfaces/ui/IFUParamsToGetFilter";
 
 /**
  * Resolves conditions between UI flattened filter and given parameters