@qrvey/utils 1.1.0-9 → 1.1.2-1

package/src/filters/adapters/transformFilters.ts

@@ -1,5 +1,5 @@
-import { capitalize } from '../../general/index';
-import { get } from '../../general/object/get';
+import { capitalize, _get } from '../../general/index';
+import { isTokenLabel } from '../../tokens/isTokenLabel';
 import { FILTER_BACKEND_VALIDATOR, FILTER_SCOPE, FILTER_SECTION, FILTER_VALIDATOR } from '../constants/index';
 
 
@@ -58,7 +58,7 @@ import { FILTER_BACKEND_VALIDATOR, FILTER_SCOPE, FILTER_SECTION, FILTER_VALIDATO
  * 
  * const filterData = transformFilters(oldPreferenceFilters, 'ANALYZE');
  */
-export function transformFilters(oldFiltersObj: object = {}, section: string = FILTER_SECTION.ANYWHERE) {
+export function transformFilters(oldFiltersObj = {}, section: string = FILTER_SECTION.ANYWHERE) {
   const filterData = { enabled: true, logic: [], section };
   const tempScopes = {};
   Object.keys(oldFiltersObj).forEach(key => {
@@ -113,7 +113,7 @@ export function transformFilters(oldFiltersObj: object = {}, section: string = F
 
 function validateComplexTypes(oldFiltersItem, validations) {
   if (!['IMAGEUPLOAD', 'TEXTFIELD', 'LONGTEXT', 'NAME', 'ADDRESS', 'USADDRESS'].includes(oldFiltersItem.type)) return oldFiltersItem;
-  const complexFiltersItem = { ...oldFiltersItem, values: [{}] }
+  const complexFiltersItem = { ...oldFiltersItem, values: [{}] };
   validations.forEach(valKey => {
     oldFiltersItem.values[0][valKey].forEach(value => {
       const newKey = `${valKey}|${(value.targetFilter || value.property || '').toLowerCase().replace('_text', '').replace('_type', 'type')}`;
@@ -218,14 +218,14 @@ function getValidator(oldValidation: string) {
 
 function getProperty(filterObjItem: any, validationKey: string) {
   if (filterObjItem.type === 'IMAGE') return 'answer_id';
-  const value = get(filterObjItem, `values[0]['${validationKey}'][0]`, {});
+  const value = _get(filterObjItem, `values[0]['${validationKey}'][0]`, {});
   const property = filterObjItem.property || value.property || value.targetFilter;
   return property && property.toUpperCase();
 }
 
 function getDateProperty(validationKey, columnType: string, formulaType?: string) {
   if (![columnType, formulaType].includes('DATE')) return;
-  return (['MONTH_YEAR', 'YEAR', 'QUARTER', 'WEEK', 'HOUR', 'MINUTE', 'SECOND'].includes(validationKey)) ? validationKey.split('_')[0].toLowerCase() : 'day';
+  return ['MONTH_YEAR', 'YEAR', 'QUARTER', 'WEEK', 'HOUR', 'MINUTE', 'SECOND'].includes(validationKey) ? validationKey.split('_')[0].toLowerCase() : 'day';
 }
 
 function getFilterRangeValue(range, minProp = 'min', maxProp = 'max', extras = {}) {
@@ -262,29 +262,31 @@ function getValues(values, columnType, oldValidation = 'EQUAL', destination = 'v
     case 'BETWEEN':
     case 'YEAR':
     case 'MONTH_YEAR':
-      return (destination === 'value')
+      return destination === 'value'
         ? values.map(val => getFilterRangeValue(val.value.range || val.value, 'gte', 'lte'))
-        : (destination === 'uiValue')
+        : destination === 'uiValue'
           ? values.map(val => getFilterRangeValue(val.value.range || val.value, 'min', 'max', { enabled: val.enabled, value: getUiRangeValue(val.value), validationLabel: oldValidation }))
           : ['YEAR', 'MONTH_YEAR', 'QUARTER'].includes(oldValidation)
             ? values.map(item => ({ value: getUiRangeValue(item.value) }))
             : values.map(val => getFilterRangeValue(val.value.range || val.value));
     case 'LESS_THAN':
-    case 'GREATER_THAN':
-      const prop = oldValidation === 'LESS_THAN' ? 'lte' : 'gte'
-      return (destination === 'value')
+    case 'GREATER_THAN': {
+      const prop = oldValidation === 'LESS_THAN' ? 'lte' : 'gte';
+      return destination === 'value'
         ? values.map(val => getFilterRangeValue({ [prop]: val.value }, 'gte', 'lte'))
-        : (destination === 'uiValue')
+        : destination === 'uiValue'
           ? values.map(val => getFilterRangeValue({ [prop]: val.value }, 'min', 'max', { enabled: val.enabled, value: val.value }))
           : values.map(val => getFilterRangeValue({ [prop]: val.value }));
+    }
     case 'IS_EMPTY':
-    case 'IS_NOT_EMPTY':
+    case 'IS_NOT_EMPTY': {
       const valueClean = getValidator(oldValidation).toLowerCase().split('_').map(v => capitalize(v)).join(' ');
-      return (destination === 'value')
+      return destination === 'value'
         ? [valueClean]
-          : (destination === 'uiValue')
+          : destination === 'uiValue'
           ? values.map(val => ({ value: valueClean, enabled: val.enabled }))
           : [];
+    }
     default:
       return getFilterEqualValues(values, columnType, destination, formulaType);
   }
@@ -292,16 +294,16 @@ function getValues(values, columnType, oldValidation = 'EQUAL', destination = 'v
 
 function getFilterEqualValues(values, columnType, destination = 'value', formulaType?: string) {
   if (columnType === 'RANKING') {
-    return (destination === 'value')
+    return destination === 'value'
       ? values.map(item => ({ position: +item.position, value: item.value }))
-      : (destination === 'uiValue')
+      : destination === 'uiValue'
         ? values.map(item => ({ value: getUiRangeValue({ from: item.value, to: +item.position + 1 }), enabled: true }))
         : getRankingFBvalues(values);
   }
-  const formattedValues = (destination === 'value')
+  const formattedValues = destination === 'value'
     ? values.map(item => {
       let value = item.value;
-      if ([columnType, formulaType].includes('DATE') && !isTokenBoxLabel(value)) {
+      if ([columnType, formulaType].includes('DATE') && !isTokenLabel(value)) {
         value = getFilterRangeValue(item.value.range || item.value, 'gte', 'lte');
       } else if (columnType === 'YES_NO') {
         value = item.value.toLowerCase();
@@ -312,7 +314,7 @@ function getFilterEqualValues(values, columnType, destination = 'value', formula
       }
       return value;
     })
-    : values.map(item => ({ value: columnType === 'YES_NO' ? item.value.toLowerCase() : ([columnType, formulaType].includes('DATE') ? item.value.label || item.value : String(item.value)), valueid: columnType === 'EXPRESSION' ? undefined : item.id || item.answerid, enabled: item.enabled || true }));
+    : values.map(item => ({ value: columnType === 'YES_NO' ? item.value.toLowerCase() : [columnType, formulaType].includes('DATE') ? item.value.label || item.value : String(item.value), valueid: columnType === 'EXPRESSION' ? undefined : item.id || item.answerid, enabled: item.enabled || true }));
   return formattedValues;
 }
 
@@ -378,13 +380,3 @@ function getExpressions(oldFiltersItem, validations, scopeLabel, scopeid, sectio
   });
   return expressions;
 }
-
-/**
- * Get a text and evaluate if it matchs with a token box label.
- * @param label string to evaluate
- * @return True is label matchs; otherwise false
- */
-function isTokenBoxLabel(label: string): boolean {
-  const regex = new RegExp('^(\{\{)([^{}]+)(\}\})$', 'gi');
-  return regex.test(label);
-}

package/src/filters/constants/backend/FILTER_BACKEND_VALIDATOR.ts

@@ -18,4 +18,4 @@ export const enum FILTER_BACKEND_VALIDATOR {
   NOT_RANGE = 'NOT_RANGE',
   IN = 'IN',
   RELATIVE = 'RELATIVE'
-};
+}

package/src/filters/constants/common/FILTER_GROUPED_COLUMN_OPERATOR.ts

@@ -0,0 +1,3 @@
+import { FILTER_OPERATOR } from "./FILTER_OPERATOR";
+
+export const FILTER_GROUPED_COLUMN_OPERATOR = FILTER_OPERATOR.OR;

package/src/filters/constants/common/FILTER_OPERATOR.ts

@@ -1,4 +1,4 @@
 export const enum FILTER_OPERATOR {
     AND = 'AND',
     OR = 'OR'
-};
+}

package/src/filters/constants/common/FILTER_VALIDATOR.ts

@@ -20,4 +20,4 @@ export const enum FILTER_VALIDATOR {
   BEFORE_ON = 'BEFORE_ON',
   AFTER_ON = 'AFTER_ON',
   IN = 'IN'
-};
+}

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

@@ -1,5 +1,6 @@
 export * from './FILTER_DATE_SECTION';
 export * from './FILTER_DATE_SECTIONS';
+export * from './FILTER_GROUPED_COLUMN_OPERATOR';
 export * from './FILTER_OPERATOR';
 export * from './FILTER_SCOPE_LABEL';
 export * from './FILTER_SCOPE';

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

@@ -4,14 +4,22 @@ import { getBackendProperty } from "./getBackendProperty";
 import { getBackendValidator } from "./getBackendValidator";
 import { getBackendValues } from "./getBackendValues";
 
+/**
+ * Builds filter expression by the filter data.
+ * - If the resulting value array is empty the enabled property will be false.
+ * @param filter The filter to transform
+ * @returns a filter expression
+ */
 export function buildExpression(filter: IFSFilter): IFBExpression {
-    return {
-        enabled: filter.enabled,
+    const expression = {
         groupValue: getBackendGroupValue(filter),
         questionid: filter.column.id,
         questionType: filter.column.type,
         property: getBackendProperty(filter),
         validationType: getBackendValidator(filter.validator),
         value: getBackendValues(filter),
-    }
+    };
+    expression['enabled'] = expression.value.length > 0 ? filter.enabled : false;
+
+    return expression;
 }

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

@@ -33,7 +33,7 @@ export function buildFilters(filters: IFSFilter[], groupColumns = false): IFBFil
         if (_hasProperty(expressions[0], 'expressions')) {
             return expressions;
         } else {
-            return [{ operator: FILTER_OPERATOR.AND, expressions }]
+            return [{ operator: FILTER_OPERATOR.AND, expressions }];
         }
     }
 }
@@ -57,7 +57,7 @@ function logicToNumeric (operator, priority = false) {
 function numericExpression(filters: IFSFilter[], groupColumns = false) {
     let expression = '';
     filters.forEach((item, index) => {
-        const nextColumn = (filters[index + 1] || {}).column
+        const nextColumn = (filters[index + 1] || {}).column;
         const operator = logicToNumeric(item.operator, groupColumns && item.column?.id === nextColumn?.id);
         expression += `${item.filterid}${operator}`;
     });

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

@@ -1,6 +1,7 @@
 import { isEmpty } from "../../../general";
 import { isDateColumn } from "../../../qrvey/isDateColumn";
 import { IFProperty, IFSFilter } from "../../interfaces";
+import { arePropertiesDateP } from "../common";
 
 /**
  * Gets a group value for the backend logic structure
@@ -8,7 +9,7 @@ import { IFProperty, IFSFilter } from "../../interfaces";
  * @returns a property
  */
 export function getBackendGroupValue(filter: IFSFilter): IFProperty {
-    if (isEmpty(filter.column.aggregate) && isDateColumn(filter.column as any) && filter.property != null) {
+    if (!arePropertiesDateP(filter.column, filter.property) && isEmpty(filter.column.aggregate) && isDateColumn(filter.column as any) && filter.property != null) {
         return filter.property;
     }
 }

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

@@ -2,7 +2,7 @@ import { COLUMN, COLUMN_PROPERTY } from "../../../constants";
 import { isEmpty } from "../../../general";
 import { isDateColumn } from "../../../qrvey/isDateColumn";
 import { IFProperty, IFSFilter } from "../../interfaces";
-import { isNullValidator } from "../common";
+import { arePropertiesDateP, isNullValidator } from "../common";
 
 /**
  * Gets a property for the logic structure
@@ -11,8 +11,11 @@ import { isNullValidator } from "../common";
  */
 export function getBackendProperty(filter: IFSFilter): IFProperty {
   if (isEmpty(filter.column.aggregate)) {
-    if ((isDateColumn(filter.column as any) && filter.property != null) || isNullValidator(filter.validator)) return undefined;
-    if ((filter.column.type === COLUMN.EXPRESSION && filter.property != null)) {
+    if (isNullValidator(filter.validator)) {
+      return undefined;
+    } else if (isDateColumn(filter.column as any)) {
+      return arePropertiesDateP(filter.column, filter.property) ? filter.property?.split('p&')[1] as IFProperty : undefined;
+    } else if (filter.column.type === COLUMN.EXPRESSION && filter.property != null) {
         return undefined;
     } else if (filter.column.type === COLUMN.LOOKUP && filter.property === COLUMN_PROPERTY.LOOKUP_DISPLAY && filter.lookupDisplayIndex != null) {
       return filter.property.concat('_').concat(filter.lookupDisplayIndex.toString()) as any;

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

@@ -20,40 +20,42 @@ export function getBackendValues(filter: IFSFilter): IFBackendExpressionValue[]
         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.value);
+            return (filter.values as IFSValue[]).map(value => value.enabled ? value.value : undefined);
         case FILTER_VALIDATOR.BETWEEN_INCLUSIVE:
-            return (filter.values as IFSValueRange[]).map(value => (
+            return (filter.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 => (
+            return (filter.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 => (
+            return (filter.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 => (
+            return (filter.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 => (
+            return (filter.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 => (
+            return (filter.values as IFSValueRange[]).map(value => value.enabled ? 
                 { gte: value.min }
-            ));
+             : undefined).filter(Boolean);
         case FILTER_VALIDATOR.IS_NULL:
-        case FILTER_VALIDATOR.IS_NOT_NULL:
-            return [FILTER_VALIDATOR_VALUE[filter.validator].label];
+        case FILTER_VALIDATOR.IS_NOT_NULL: {
+            const addValue = filter.values.length > 0 && (filter.values as IFSValue[]).every(value => value.enabled);
+            return addValue ? [FILTER_VALIDATOR_VALUE[filter.validator].label] : [];
+        }
         case FILTER_VALIDATOR.IN:
-            return filter.values as IFBExpressionRelativeDate[];
+            return (filter.values as IFBExpressionRelativeDate[]).map(value => value.enabled ? value : undefined).filter(Boolean);
         default:
             return [];
     }
@@ -67,12 +69,14 @@ export function getBackendValues(filter: IFSFilter): IFBackendExpressionValue[]
  */
 function getResultValues(values: IFSValue[], filter: IFSFilter): IFBExpressionValue[] {
   return values.map((value: IFSValue) => {
-    if (filter.column.type === COLUMN.IMAGE) {
-      return value.valueid;
-    } else {
-      return value.value;
+    if (value.enabled) {
+        if (filter.column.type === COLUMN.IMAGE) {
+            return value.valueid;
+        } else {
+            return value.value;
+        }
     }
-  }).filter(value => value);
+  }).filter(Boolean);
 }
 
 /**
@@ -83,8 +87,8 @@ function getResultValues(values: IFSValue[], filter: IFSFilter): IFBExpressionVa
  */
 function getRankingValues(values: IFSValueRanking[][], rankingGroupIndex?: number): IFBExpressionValueRanking[] {
   const flattenValues: IFSValueRanking[] = rankingGroupIndex == null ? flattenDeep(values) : values[rankingGroupIndex];
-  return flattenValues.map(rankingValue => ({
+  return flattenValues.map(rankingValue => rankingValue.enabled ? {
     position: rankingValue.position - 1,
     value: rankingValue.value.value
-  }));
+  } : undefined).filter(Boolean);
 }

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

@@ -1,5 +1,5 @@
 import { getAttribute } from '../../../general';
-import { IFilterBuilderGeneralConfig } from '../../interfaces'
+import { IFilterBuilderGeneralConfig } from '../../interfaces';
 
 /**
  * Returns a filter builder config object by a any given config

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

@@ -12,5 +12,5 @@ export function areFiltersEquals(filter1: IFSFilter, filter2: IFSFilter): boolea
         filter1.extras.panelid === filter2.extras.panelid &&
         filter1.column.id === filter2.column.id &&
         filter1.column?.aggregate === filter2.column?.aggregate &&
-        filter1.column?.calculation === filter2.column?.calculation
+        filter1.column?.calculation === filter2.column?.calculation;
 }

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

@@ -0,0 +1,14 @@
+import { DATE_P_PROPERTIES } from "../../../date";
+import { isEmpty } from "../../../general";
+import { isDateColumn } from "../../../qrvey/isDateColumn";
+import { IFProperty, IFSColumn, IFUColumn } from "../../interfaces";
+
+/**
+ * Determines if the filter column and property is a distinct group dates type
+ * @param column The filter column
+ * @param property The filter property
+ * @returns True if the given property is included from distinct group dates type
+ */
+export function arePropertiesDateP(column: IFUColumn | IFSColumn, property: IFProperty): boolean {
+  return isDateColumn(column as any) && isEmpty(column.aggregate) && DATE_P_PROPERTIES.includes(property);
+}

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

@@ -78,5 +78,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/getFilterColumnLabel.ts

@@ -13,5 +13,5 @@ export function getFilterColumnLabel(column: IFUColumn): string {
     if (column.aggregate != null) labels.push(column.aggregate);
     if (column.calculation != null) labels.push(column.calculation);
   
-    return (labels.length > 0) ? `(${labels.join(' - ')})` : '';
+    return labels.length > 0 ? `(${labels.join(' - ')})` : '';
 }

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

@@ -6,7 +6,7 @@ import { getFilterColumnLabel } from "./getFilterColumnLabel";
  * @param filter the UI filter
  * @returns a sring label
  */
-export function getFilterLabel(filter: IFUFilter) {
+export function getFilterLabel(filter: IFUFilter): string {
     const text = filter.extras.filterLabel ?? filter.column.label;
     return text + ' ' + getFilterColumnLabel(filter.column);
 }

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

@@ -28,5 +28,5 @@ export function getFilterid(filter: IFSFilter, index?: number): string {
     if (filter.column?.calculation != null) filterid.push(filter.column?.calculation);
     if (index != null) filterid.push(index.toString());
 
-    return (filterid.length > 0) ? filterid.join('|') : '';
+    return filterid.length > 0 ? filterid.join('|') : '';
 }

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

@@ -6,7 +6,7 @@ import { IFSData, IFSScope } from "../../interfaces";
  * @param filterData The filter data object
  * @returns The new filter data object that were get the aggregate filters
  */
- export function getFiltersByAggregateColumn(filterData: IFSData) {
+ export function getFiltersByAggregateColumn(filterData: IFSData): IFSData {
   if (isEmpty(filterData) || isEmpty(filterData.scopes)) return;
   filterData = cloneDeep(filterData);
   

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

@@ -1,4 +1,4 @@
-import { cloneDeep, isEmpty } from "../../../general";
+import { cloneDeep, isEmpty, _hasProperty } from "../../../general";
 import { IFSData, IFSDataset, IFSFilter, IFSScope, IFSParamsToGetFilter, IFValue, IFSValueRanking, IFSValue, IFSValueRange, IFSValueRelativeDate, IFUData, IFSParamsToGetFilterSettings } from "../../interfaces";
 import { getParamsToGetFilterSettings } from "./getParamsToGetFilterSettings";
 import { resolveDatasetConditions } from "./resolveDatasetConditions";
@@ -20,7 +20,6 @@ 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 {
     if (isEmpty(filterData) || isEmpty(filterData.scopes)) return;
     if (isEmpty(params)) return filterData;
@@ -44,21 +43,21 @@ export function getFiltersByParams(filterData: IFSData | IFUData, params: IFSPar
                           if (Array.isArray(value) && value.length > 0) {
                             const rankingValues = value as IFSValueRanking[];
                             rankingValues.map(rValue => {
-                              if (params.enableds == null || params.enableds === rValue.enabled) return rValue;
+                              if (!_hasProperty(params, 'enableds') || !_hasProperty(params.enableds, 'values') || params.enableds.values === rValue.enabled) return rValue;
                             }).filter(Boolean);
                           } else {
                             value = value as IFSValue | IFSValueRange | IFSValueRelativeDate;
-                            if (params.enableds == null || params.enableds === value.enabled) return value;
+                            if (!_hasProperty(params, 'enableds') || !_hasProperty(params.enableds, 'values') || params.enableds.values === value.enabled) return value;
                           }
                         }).filter(Boolean) };
                     }
-                  }).filter(filter => !isEmpty(filter) && filter.values.length > 0)
+                  }).filter(filter => !isEmpty(filter) && (!settings.filterEmptyArrays.filter || filter.values.length > 0))
                 };  
               }  
-            }).filter(dataset => !isEmpty(dataset) && dataset.filters.length > 0)
+            }).filter(dataset => !isEmpty(dataset) && (!settings.filterEmptyArrays.dataset || dataset.filters.length > 0))
           };
         }
-    }).filter(scope => !isEmpty(scope) && scope.datasets.length > 0);
+    }).filter(scope => !isEmpty(scope) && (!settings.filterEmptyArrays.scope || scope.datasets.length > 0));
 
     return filterData.scopes.length > 0 ? filterData : undefined;
 }