@qrvey/utils 1.3.0-11 → 1.3.0-14

package/src/filters/constants/builder/FILTER_BUILDER_SCOPE_LABEL.ts

@@ -1,4 +1,4 @@
-import { FILTER_SCOPE } from "..";
+import { FILTER_SCOPE } from "../common/FILTER_SCOPE";
 
 export const FILTER_BUILDER_SCOPE_LABEL = {
     [FILTER_SCOPE.GLOBAL]: 'All pages',

package/src/filters/constants/builder/STATIC_OPTION_COLUMNS.ts

@@ -1,7 +1,8 @@
 import { COLUMN } from "../../../columns/constants/COLUMN";
+import { IColumnType } from "../../../columns/interfaces/IColumnType";
 
 // COLUMN TYPES FOR GETTING OPTION VALUES (i.e FROM MODEL OBJECT)
-export const STATIC_OPTION_COLUMNS = [
+export const STATIC_OPTION_COLUMNS: IColumnType[] = [
     COLUMN.DROPDOWN,
     COLUMN.EXPRESSION,
     COLUMN.IMAGE,

package/src/filters/constants/builder/index.ts

@@ -3,6 +3,7 @@ export * from './COLUMNS_FOR_EQUALS_LAYOUT';
 export * from './COLUMNS_FOR_EQUALS_NULL_LAYOUT';
 export * from './COLUMNS_FOR_NULL_LAYOUT';
 export * from './COLUMNS_FOR_TEXT_LAYOUT';
+export * from './FILTER_BUILDER_SCOPE_LABEL';
 export * from './FILTER_FLOW';
 export * from './FILTER_VALIDATORS_FOR_SLIDEBAR';
 export * from './FILTER_VALIDATORS_FOR_WINDOW';

package/src/filters/helpers/OLD_getAggFilters.ts

@@ -0,0 +1,90 @@
+import { COLUMN } from "../../columns/constants/COLUMN";
+import { isEmpty } from "../../general/mix/isEmpty";
+import { cloneDeep } from "../../general/object/cloneDeep";
+import { _get } from "../../general/object/get";
+import { FILTER_OPERATOR } from "../constants/common/FILTER_OPERATOR";
+import { IFBExpressionAggregate } from "../interfaces/backend/IFBExpressionAggregate";
+import { IFBFilterAggregate } from "../interfaces/backend/IFBFilterAggregate";
+import { IFOperator } from "../interfaces/IFOperator";
+import { OLD_IFilterExpression } from "../interfaces/OLD_IFilterExpression";
+import { OLD_IFilterLogic } from "../interfaces/OLD_IFilterLogic";
+
+/**
+ * @deprecated soon
+ * @param logics 
+ * @param summaries 
+ * @returns the filter aggregate structure
+ */
+export function getAggFilters(logics: OLD_IFilterLogic[] = [], summaries: any[] = []): IFBFilterAggregate {
+    const aggregateFilters: OLD_IFilterLogic[] = getAggregateFilters(logics) as OLD_IFilterLogic[];
+    const aggFilters: IFBFilterAggregate[] = aggregateFilters.map(aggFilter => {
+      const expressions = getExpressionsInLogic([aggFilter]);
+      return expressions && expressions.length && {
+        operator: FILTER_OPERATOR.OR,
+        expressions: expressions.map((expression): IFBExpressionAggregate => {
+          const summaryIndex = summaries.findIndex(summary =>
+            expression.questionid === summary.questionid &&
+            expression.qrveyid === summary.qrveyid &&
+            expression.linkid === summary.linkid &&
+            _get(expression.uiExtras.column, 'aggregate') === summary.aggregate
+          );
+          if (summaryIndex > -1 || expression.questionType === COLUMN.AGGREGATED_FORMULA) {
+            return {
+              enabled: expression.enabled,
+              summaryIndex,
+              validationType: expression.validationType,
+              value: expression.value,
+            };
+          }
+          return;
+        }).filter(Boolean)
+      };
+    }).filter(aggFilter => aggFilter && aggFilter.expressions && aggFilter.expressions.length);
+    return aggFilters && concatAggFilters(aggFilters);
+}
+
+/**
+ * Filters and gets the filters used for aggregate values.
+ * @param logics The filter logic structure
+ * @param formatToFilters Flag to change de way of returning the filter structure.
+ * @returns the aggregate filters in the IFilterFilters way or as logic structure.
+ */
+function getAggregateFilters(logics: OLD_IFilterLogic[] = []): OLD_IFilterLogic[] {
+    logics = cloneDeep(logics);
+    const aggregateLogics = logics.reduce((newLogics: OLD_IFilterLogic[], logic: OLD_IFilterLogic) => {
+      if (!logic) return newLogics;
+      // if ([FILTER_SCOPE.DEFAULT, FILTER_SCOPE.CHART].includes(logic.scope)) {
+        logic.filters.forEach((filter, index) => {
+          const expressions = _get(filter, 'expressions[0].expressions');
+          if (!isEmpty(expressions)) {
+            const aggregateFilters = (filter.expressions[0].expressions as OLD_IFilterExpression[]).filter(expression => !isEmpty(expression.uiExtras.column.aggregate));
+            logic.filters[index].expressions[0].expressions = aggregateFilters;
+            if (!filter.expressions[0].expressions.length) logic.filters[index] = undefined;
+          }
+        });
+        logic.filters = logic.filters.filter(filter => filter);
+        if (logic.filters.length) newLogics.push(logic);
+      //}
+      return newLogics;
+    }, [] as OLD_IFilterLogic[]);
+    return aggregateLogics;
+}
+
+function concatAggFilters(aggFilters: IFBFilterAggregate[], operator: IFOperator = FILTER_OPERATOR.AND): IFBFilterAggregate {
+    const expressions = aggFilters.filter(Boolean);
+    if (!expressions.length) return undefined;
+    else if (expressions.length === 1) return expressions[0];
+    return {
+        operator,
+        expressions: aggFilters.filter(Boolean)
+    };
+}
+
+function getExpressionsInLogic(logics: OLD_IFilterLogic[] = []): OLD_IFilterExpression[] {
+    return logics.reduce((expressions: OLD_IFilterExpression[], logic: OLD_IFilterLogic) => {
+      logic.filters.forEach(filter => {
+        expressions = expressions.concat(filter.expressions[0].expressions);
+      });
+      return expressions;
+    }, [] as OLD_IFilterExpression[]);
+}

package/src/filters/helpers/applyHierarchyForAggFilters.ts

@@ -9,9 +9,9 @@ import { getScopesByHierarchy } from "./getScopesByHierarchy";
 /**
  * [TODO: Make a proper description for this function]
  * @param chartSettings Chart Settings for the Filter Builder
- * @param scopes 
- * @param currentScope 
- * @returns 
+ * @param scopes the pair id/label scopes
+ * @param currentScope the scope to be validated
+ * @returns the chart settings
  */
 export function applyHierarchyForAggFilters(chartSettings: IFUChartSettings, scopes: IFSScopeID[] = [], currentScope: IFScope = FILTER_SCOPE.GLOBAL): IFUChartSettings {
   if (isEmpty(chartSettings)) return;

package/src/filters/helpers/backend/buildExpression.ts

@@ -17,10 +17,10 @@ export function buildExpression(filter: IFSFilter): IFBExpression {
         questionid: filter.column.id,
         questionType: filter.column.type,
         property: getBackendProperty(filter),
-        validationType: getBackendValidator(filter.validator),
+        validationType: getBackendValidator(filter),
         value: getBackendValues(filter),
     };
-    expression['enabled'] = expression.value.length > 0 ? filter.enabled : false;
+    expression['enabled'] =  filter.selectAll || expression.value?.length > 0 ? filter.enabled : false;
 
     return expression;
 }

package/src/filters/helpers/backend/getAggFiltersBySummaryIndex.ts

@@ -2,10 +2,12 @@ import { filterNestedTree } from "../../../general/array/filterNestedTree";
 import { IFBFilterAggregate } from "../../interfaces/backend/IFBFilterAggregate";
 
 /**
+ * @todo Make a proper description for this function
  * 
- * @param aggFilters 
- * @param summaryIndex 
- * @returns 
+ * Gets the aggFilters structure by an index
+ * @param aggFilters The aggFilter Structure
+ * @param summaryIndex an index
+ * @returns a new aggFilters structure
  */
 export function getAggFiltersBySummaryIndex(aggFilters: IFBFilterAggregate, summaryIndex: number): IFBFilterAggregate {
     if (!aggFilters) return undefined;

package/src/filters/helpers/backend/getBackendValidator.ts

@@ -1,19 +1,19 @@
 import { FILTER_BACKEND_VALIDATOR } from "../../constants/backend/FILTER_BACKEND_VALIDATOR";
 import { FILTER_VALIDATOR } from "../../constants/common/FILTER_VALIDATOR";
 import { IFBackendValidator } from "../../interfaces/backend/IFBackendValidator";
-import { IFValidator } from "../../interfaces/IFValidator";
+import { IFSFilter } from "../../interfaces/common/IFSFilter";
 
 /**
  * Gets the Validator that is used in requests
  * @param validator Filter Validator used in UI
  * @returns Filter Validator used in Backend
  */
-export function getBackendValidator(validator: IFValidator): IFBackendValidator {
-    switch (validator) {
+export function getBackendValidator(filter: IFSFilter): IFBackendValidator {
+    switch (filter.validator) {
       case FILTER_VALIDATOR.EQUALS:
-        return FILTER_BACKEND_VALIDATOR.EQUALS;
+        return filter.selectAll ? FILTER_BACKEND_VALIDATOR.NOT_EQUAL : FILTER_BACKEND_VALIDATOR.EQUALS;
       case FILTER_VALIDATOR.NOT_EQUAL:
-        return FILTER_BACKEND_VALIDATOR.NOT_EQUAL;
+        return filter.selectAll ? FILTER_BACKEND_VALIDATOR.EQUALS : FILTER_BACKEND_VALIDATOR.NOT_EQUAL;
       case FILTER_VALIDATOR.CONTAINS:
         return FILTER_BACKEND_VALIDATOR.CONTAINS;
       case FILTER_VALIDATOR.NOT_CONTAIN:

package/src/filters/helpers/backend/getBackendValues.ts

@@ -19,53 +19,55 @@ import { IFSValueRanking } from "../../interfaces/common/IFSValueRanking";
  * @returns A collection of backend expression value
  */
 export function getBackendValues(filter: IFSFilter): IFBackendExpressionValue[] {
+    const values = filter.values || [];
+
     switch (filter.validator) {
         case FILTER_VALIDATOR.EQUALS:
         case FILTER_VALIDATOR.NOT_EQUAL:
-            if (filter.column.type === COLUMN.RANKING && isEmpty(filter.column.aggregate)) return getRankingValues(filter.values as IFSValueRanking[][]);
-            return getResultValues(filter.values as IFSValue[], filter);
+            if (filter.column.type === COLUMN.RANKING && isEmpty(filter.column.aggregate)) return getRankingValues(values as IFSValueRanking[][]);
+            return getResultValues(values as IFSValue[], filter);
         case FILTER_VALIDATOR.CONTAINS:
         case FILTER_VALIDATOR.NOT_CONTAIN:
         case FILTER_VALIDATOR.STARTS_WITH:
         case FILTER_VALIDATOR.NOT_START_WITH:
         case FILTER_VALIDATOR.ENDS_WITH:
         case FILTER_VALIDATOR.NOT_END_WITH:
-            return (filter.values as IFSValue[]).map(value => value.enabled ? value.value : undefined);
+            return (values as IFSValue[]).map(value => value.enabled ? value.value : undefined);
         case FILTER_VALIDATOR.BETWEEN_INCLUSIVE:
-            return (filter.values as IFSValueRange[]).map(value => value.enabled ? 
+            return (values as IFSValueRange[]).map(value => value.enabled ? 
                 { lte: value.max, gte: value.min }
              : undefined).filter(Boolean);
         case FILTER_VALIDATOR.BETWEEN_EXCLUSIVE:
-            return (filter.values as IFSValueRange[]).map(value => value.enabled ? 
+            return (values as IFSValueRange[]).map(value => value.enabled ? 
                 { lt: value.max, gt: value.min }
              : undefined).filter(Boolean);
         case FILTER_VALIDATOR.BEFORE:
         case FILTER_VALIDATOR.LESS_THAN:
-            return (filter.values as IFSValueRange[]).map(value => value.enabled ? 
+            return (values as IFSValueRange[]).map(value => value.enabled ? 
                 { lt: value.max }
              : undefined).filter(Boolean);
         case FILTER_VALIDATOR.BEFORE_ON:
         case FILTER_VALIDATOR.LESS_THAN_EQUAL:
-            return (filter.values as IFSValueRange[]).map(value => value.enabled ? 
+            return (values as IFSValueRange[]).map(value => value.enabled ? 
                 { lte: value.max }
              : undefined).filter(Boolean);
         case FILTER_VALIDATOR.AFTER:
         case FILTER_VALIDATOR.GREATER_THAN:
-            return (filter.values as IFSValueRange[]).map(value => value.enabled ? 
+            return (values as IFSValueRange[]).map(value => value.enabled ? 
                 { gt: value.min }
              : undefined).filter(Boolean);
         case FILTER_VALIDATOR.AFTER_ON:
         case FILTER_VALIDATOR.GREATER_THAN_EQUAL:
-            return (filter.values as IFSValueRange[]).map(value => value.enabled ? 
+            return (values as IFSValueRange[]).map(value => value.enabled ? 
                 { gte: value.min }
              : undefined).filter(Boolean);
         case FILTER_VALIDATOR.IS_NULL:
         case FILTER_VALIDATOR.IS_NOT_NULL: {
-            const addValue = filter.values.length > 0 && (filter.values as IFSValue[]).every(value => value.enabled);
+            const addValue = values.length > 0 && (values as IFSValue[]).every(value => value.enabled);
             return addValue ? [FILTER_VALIDATOR_INFO[filter.validator].label] : [];
         }
         case FILTER_VALIDATOR.IN:
-            return (filter.values as IFBExpressionRelativeDate[]).map(value => value.enabled ? value : undefined).filter(Boolean);
+            return (values as IFBExpressionRelativeDate[]).map(value => value.enabled ? value : undefined).filter(Boolean);
         default:
             return [];
     }
@@ -73,12 +75,13 @@ export function getBackendValues(filter: IFSFilter): IFBackendExpressionValue[]
 
 /**
  * Gets the expression values. Depending on the column type
+ * @private
  * @param values a collection of filter values
  * @param filter The filter structure
- * @returns 
+ * @returns Expression values
  */
 function getResultValues(values: IFSValue[], filter: IFSFilter): IFBExpressionValue[] {
-  return values.map((value: IFSValue) => {
+  return (values || []).map((value: IFSValue) => {
     if (value.enabled) {
         if (filter.column.type === COLUMN.IMAGE) {
             return value.valueid || value.imageUrl || value.value;
@@ -91,6 +94,7 @@ function getResultValues(values: IFSValue[], filter: IFSFilter): IFBExpressionVa
 
 /**
  * Gets the Ranking values. 
+ * @private
  * @param values a collection of filter values in the ranking structure
  * @param rankingGroupIndex determine the value by this index to build and return it
  * @returns Expression values for ranking

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

@@ -6,5 +6,6 @@ export * from './getBackendGroupValue';
 export * from './getBackendProperty';
 export * from './getBackendValidator';
 export * from './getBackendValues';
-export * from './getLogicByScopesHierarchy';
 export * from './getLogicByScopes';
+export * from './getLogicByScopesHierarchy';
+// export * from './hasDatasetRelatedFilters';

package/src/filters/helpers/builder/getFilterBuilderGeneralConfig.ts

@@ -1,12 +1,12 @@
 import { getAttribute } from '../../../general/object/getAttribute';
-import { IFilterBuilderGeneralConfig } from '../../interfaces/builder/IFilterBuilderGeneralConfig';
+import { IFilterConfig } from '../../interfaces/common/IFilterConfig';
 
 /**
  * Returns a filter builder config object by a any given config
  * @param config any config object
  * @returns The filter builder config object
  */
-export function getFilterBuilderGeneralConfig(config: any = {}): IFilterBuilderGeneralConfig {
+export function getFilterBuilderGeneralConfig(config: any = {}): IFilterConfig {
     return {
         apiKey: getAttribute(config, 'api_key') || config.apiKey,
         appid: getAttribute(config, 'app_id') || config.appid,

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

@@ -42,7 +42,7 @@ export function excludeFiltersByParams(filterData: IFSData | IFUData, params: IF
                     if (resolveFilterConditions(filter, params)) {
                       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[];
                             rankingValues.map(rValue => {
@@ -54,7 +54,7 @@ export function excludeFiltersByParams(filterData: IFSData | IFUData, params: IF
                           }
                         }).filter(Boolean) };
                     }
-                  }).filter(filter => !isEmpty(filter) && filter.values.length > 0)
+                  }).filter(filter => !isEmpty(filter) && (filter.selectAll && filter.values?.length > 0))
                 };  
               }  
             }).filter(dataset => !isEmpty(dataset) && dataset.filters.length > 0)
@@ -88,5 +88,5 @@ function resolveFilterConditions(filter: IFSFilter, params: IFSParamsToGetFilter
         params.column?.qrveyid !== filter.column.qrveyid &&
         params.column?.linkid !== filter.column.linkid) &&
         params.column?.aggregate !== filter.column.aggregate) &&
-    filter.values.length > 0;
+    filter.values?.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,8 +1,9 @@
 export * from './areFiltersEquals';
-export * from './isDateDistinctProperty';
+
 export * from './excludeFiltersByAggregateColumn';
 export * from './excludeFiltersByParams';
 export * from './excludeFiltersByScopes';
+
 export * from './getFilterColumnLabel';
 export * from './getFilterid';
 export * from './getFilterLabel';
@@ -14,13 +15,18 @@ 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';