@qrvey/utils 1.3.2 → 1.4.0-1

package/src/filters/adapters/transformFilters.ts

@@ -1,386 +0,0 @@
-import { isTokenLabel } from '../../tokens/isTokenLabel';
-import { FILTER_VALIDATOR } from '../constants/common/FILTER_VALIDATOR';
-import { FILTER_SCOPE } from '../constants/common/FILTER_SCOPE';
-import { FILTER_SECTION } from '../constants/common/FILTER_SECTION';
-import { FILTER_BACKEND_VALIDATOR } from '../constants/backend/FILTER_BACKEND_VALIDATOR';
-import { _get } from '../../general/object/get';
-import { capitalize } from '../../general/string/capitalize';
-
-
-/**
- * Transform the old filters structure into the new one
- * 
- * @param {Object} oldFiltersObj an object with the old filters structure
- * @param {String} section could be 'ANALYZE', 'PB', 'UM' or any other value. Deafult is 'ANYWHERE'
- * 
- * @returns {Object} an object with the new filters structure
- * 
- * @example
- * 
- * const oldPreferenceFilters = {
- *   "WWXHAULtR-_-xYOQAdpqT__ENABLED": true,
- *   "WWXHAULtR-_-xYOQAdpqT__ALL--ENABLED": true,
- *   "WWXHAULtR-_-xYOQAdpqT__COLLAPSED": false,
- *   "WWXHAULtR-_-xYOQAdpqT__LABEL": "GLOBAL",
- *   "WWXHAULtR-_-xYOQAdpqT-_-AK4M8UV2": {
- *     "formulaId": null,
- *     "panelId": null,
- *     "values": [
- *       {
- *         "EQUALS": [
- *           {
- *             "id": "AK4M8UV2a0",
- *             "value": "A",
- *             "enabled": true,
- *             "imageUrl": null
- *           },
- *           {
- *             "id": "AK4M8UV2a1",
- *             "value": "B",
- *             "enabled": true,
- *             "imageUrl": null
- *           }
- *         ]
- *       }
- *     ],
- *     "bucketId": null,
- *     "text": "MC",
- *     "title": "MC",
- *     "type": "SINGLE_CHOICE",
- *     "qid": "AK4M8UV2",
- *     "dataset": {
- *       "sourceid": "xYOQAdpqT",
- *       "name": "Form All Questions",
- *       "qrveyid": "xYOQAdpqT",
- *       "text": "Form All Questions",
- *       "linkid": 0
- *     },
- *     "enabled": true,
- *     "linked": null
- *   }
- * };
- * 
- * const filterData = transformFilters(oldPreferenceFilters, 'ANALYZE');
- */
-export function transformFilters(oldFiltersObj = {}, section: string = FILTER_SECTION.ANYWHERE) {
-  const filterData = { enabled: true, logic: [], section };
-  const tempScopes = {};
-  Object.keys(oldFiltersObj).forEach(key => {
-    if (key.endsWith('__ALL--ENABLED')) filterData.enabled = oldFiltersObj[key];
-    if (!key.endsWith('ENABLED') && !key.endsWith('LABEL') && !key.endsWith('COLLAPSED')) {
-      const filterSeparator = '-_-';
-      const keyArray = key.split(filterSeparator);
-      const tempArray = [ ...keyArray ];
-      tempArray.pop();
-      let enabledKey = '__ENABLED';
-      let collapsedKey = '__COLLAPSED';
-      let labelKey = '__LABEL';
-      if (keyArray.length === 5) {
-        tempArray.pop();
-        enabledKey = '__PANELS--ENABLED';
-        collapsedKey = '__PANELS--COLLAPSED';
-        labelKey = '__PANELS--LABEL';
-      }
-      const keyBase = tempArray.join(filterSeparator);
-      const scopeLabel = getScopeLabel(oldFiltersObj[keyBase + labelKey]);
-      const scopeId = tempArray[tempArray.length - 1] !== 'VIEW' ? tempArray[tempArray.length - 1] : undefined;
-      const scopeKey = `${scopeLabel}|${scopeId}`;
-      if (!tempScopes[scopeKey]) {
-        tempScopes[scopeKey] = {
-          enabled: oldFiltersObj[keyBase + enabledKey],
-          scope: scopeLabel,
-          filters: [],
-          uiExtras: {
-            scopeid: scopeId,
-            collapsed: oldFiltersObj[keyBase + collapsedKey],
-            section
-          }
-        };
-      }
-      const filtersObj = validateComplexTypes(oldFiltersObj[key], Object.keys(oldFiltersObj[key].values[0]));
-      const validations = Object.keys(filtersObj.values[0]);
-      tempScopes[scopeKey].filters.push({
-        operator: 'AND',
-        expressions: [
-          {
-            operator: 'OR',
-            uiExtras: { expressionid: `${filtersObj.qid}|${scopeId}|${filtersObj.panelid || ''}` },
-            expressions: getExpressions(filtersObj, validations, scopeLabel, scopeId, section)
-          }
-        ]
-      });
-    }
-  });
-  filterData.logic = Object.values(tempScopes);
-  return filterData;
-}
-
-function validateComplexTypes(oldFiltersItem, validations) {
-  if (!['IMAGEUPLOAD', 'TEXTFIELD', 'LONGTEXT', 'NAME', 'ADDRESS', 'USADDRESS'].includes(oldFiltersItem.type)) return oldFiltersItem;
-  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')}`;
-      if (!complexFiltersItem.values[0][newKey]) {
-        complexFiltersItem.values[0][newKey] = [value];
-      } else {
-        complexFiltersItem.values[0][newKey].push(value);
-      }
-    });
-  });
-  return complexFiltersItem;
-}
-  
-function getScopeLabel(oldScopeLabel: string) {
-  switch (oldScopeLabel) {
-    case 'GLOBAL':
-      return FILTER_SCOPE.GLOBAL;
-    case 'PAGE':
-      return FILTER_SCOPE.PAGE;
-    case 'TAB':
-      return FILTER_SCOPE.TAB;
-    case 'PANEL':
-      return FILTER_SCOPE.CHART;
-    default:
-      return oldScopeLabel;
-  }
-}
-
-function getValidationType(oldValidation: string, columnType: string, formulaType?: string) {
-  switch (oldValidation) {
-    case 'EQUALS':
-    case 'EQUAL':
-      return FILTER_VALIDATOR.EQUALS;
-    case 'NOT_EQUALS':
-    case 'NOT_EQUAL':
-      return FILTER_VALIDATOR.NOT_EQUAL;
-    case 'CONTAINS':
-    case 'CONTAIN':
-      return FILTER_VALIDATOR.CONTAINS;
-    case 'NOT_CONTAINS':
-    case 'NOT_CONTAIN':
-      return FILTER_VALIDATOR.NOT_CONTAIN;
-    case 'LESS_THAN':
-    case 'LESS_THAN_OR_EQUAL':
-      return FILTER_VALIDATOR.LESS_THAN_EQUAL;
-    case 'GREATER_THAN':
-    case 'GREATER_THAN_OR_EQUAL':
-      return FILTER_VALIDATOR.GREATER_THAN_EQUAL;
-    case 'BETWEEN':
-    case 'YEAR':
-    case 'MONTH_YEAR':
-    case 'QUARTER':
-    case 'WEEK':
-    case 'SECOND':
-    case 'MINUTE':
-    case 'HOUR':
-    case 'DAY':
-      return ![columnType, formulaType].includes('DATE') ? FILTER_VALIDATOR.BETWEEN_INCLUSIVE : FILTER_BACKEND_VALIDATOR.RANGE;
-    default:
-      return oldValidation;
-  }
-}
-
-function getValidator(oldValidation: string) {
-  switch (oldValidation) {
-    case 'EQUALS':
-    case 'EQUAL':
-    case 'YEAR':
-    case 'MONTH_YEAR':
-    case 'QUARTER':
-    case 'WEEK':
-    case 'SECOND':
-    case 'MINUTE':
-    case 'HOUR':
-    case 'DAY':
-      return FILTER_VALIDATOR.EQUALS;
-    case 'NOT_EQUALS':
-    case 'NOT_EQUAL':
-      return FILTER_VALIDATOR.NOT_EQUAL;
-    case 'CONTAINS':
-    case 'CONTAIN':
-      return FILTER_VALIDATOR.CONTAINS;
-    case 'NOT_CONTAINS':
-    case 'NOT_CONTAIN':
-      return FILTER_VALIDATOR.NOT_CONTAIN;
-    case 'BETWEEN':
-      return FILTER_VALIDATOR.BETWEEN_INCLUSIVE;
-    case 'LESS_THAN':
-    case 'LESS_THAN_OR_EQUAL':
-      return FILTER_VALIDATOR.LESS_THAN_EQUAL;
-    case 'GREATER_THAN':
-    case 'GREATER_THAN_OR_EQUAL':
-      return FILTER_VALIDATOR.GREATER_THAN_EQUAL;
-    case 'IS_EMPTY':
-      return FILTER_VALIDATOR.IS_NULL;
-    case 'IS_NOT_EMPTY':
-      return FILTER_VALIDATOR.IS_NOT_NULL;
-    default:
-      return oldValidation;
-  }
-}
-
-function getProperty(filterObjItem: any, validationKey: string) {
-  if (filterObjItem.type === 'IMAGE') return 'answer_id';
-  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';
-}
-
-function getFilterRangeValue(range, minProp = 'min', maxProp = 'max', extras = {}) {
-  return { [minProp]: range.from || range.gte, [maxProp]: range.to || range.lte, ...extras };
-}
-
-function getUiRangeValue(oldValue) {
-  if (oldValue.label) return (oldValue.label + '').replace('-', ' ');
-  const range = oldValue.range || oldValue;
-  return `${range.from || range.gte} - ${range.to || range.lte}`;
-}
-
-function getRankingFBvalues(values) {
-  const returnValues = [];
-  values.map(vItem => ({
-    ...vItem,
-    position: +vItem.position + 1
-  })).forEach(vItem => {
-    const groupIndex = returnValues.findIndex(group =>
-      group.every(groupItem => groupItem.value.value !== vItem.value) && group.every(groupItem => groupItem.position !== vItem.position)
-    );
-    const returnItem = {
-      position: vItem.position,
-      value: { enabled: vItem.enabled, value: vItem.value }
-    };
-    if (groupIndex === -1) returnValues.push([returnItem]);
-    else returnValues[groupIndex].push(returnItem);
-  });
-  return returnValues;
-}
-
-function getValues(values, columnType, oldValidation = 'EQUAL', destination = 'value', formulaType?: string) {
-  switch (oldValidation) {
-    case 'BETWEEN':
-    case 'YEAR':
-    case 'MONTH_YEAR':
-      return destination === 'value'
-        ? values.map(val => getFilterRangeValue(val.value.range || val.value, 'gte', 'lte'))
-        : 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'
-        ? values.map(val => getFilterRangeValue({ [prop]: val.value }, 'gte', 'lte'))
-        : 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': {
-      const valueClean = getValidator(oldValidation).toLowerCase().split('_').map(v => capitalize(v)).join(' ');
-      return destination === 'value'
-        ? [valueClean]
-          : destination === 'uiValue'
-          ? values.map(val => ({ value: valueClean, enabled: val.enabled }))
-          : [];
-    }
-    default:
-      return getFilterEqualValues(values, columnType, destination, formulaType);
-  }
-}
-
-function getFilterEqualValues(values, columnType, destination = 'value', formulaType?: string) {
-  if (columnType === 'RANKING') {
-    return destination === 'value'
-      ? values.map(item => ({ position: +item.position, value: item.value }))
-      : destination === 'uiValue'
-        ? values.map(item => ({ value: getUiRangeValue({ from: item.value, to: +item.position + 1 }), enabled: true }))
-        : getRankingFBvalues(values);
-  }
-  const formattedValues = destination === 'value'
-    ? values.map(item => {
-      let value = item.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();
-      } else if (columnType === 'IMAGE') {
-        value = item.id || item.answerid || item.answer_id;
-      } else {
-        value = String(item.value);
-      }
-      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 }));
-  return formattedValues;
-}
-
-function getFormulaType(oldFiltersItem) {
-  if (oldFiltersItem.formulaType) return oldFiltersItem.formulaType;
-  if (oldFiltersItem.formulaId) return oldFiltersItem.type === 'NUMERIC' ? 'number' : oldFiltersItem.type === 'DATE' ? 'date' : 'string';
-  return;
-}
-
-function getExpressions(oldFiltersItem, validations, scopeLabel, scopeid, section) {
-  const expressions = [];
-  validations.forEach(valKey => {
-    const valKeyArray = valKey.split('|');
-    const validationKey = valKeyArray[0];
-    const property = valKeyArray[1] || getProperty(oldFiltersItem, validationKey);
-    const formulaType = getFormulaType(oldFiltersItem);
-    const questionType = formulaType ? 'FORMULA' : oldFiltersItem.type;
-    const expressionItem = {
-      enabled: oldFiltersItem.enabled,
-      property: property,
-      linkid: oldFiltersItem.dataset.linkid,
-      qrveyid: oldFiltersItem.dataset.qrveyid,
-      questionid: oldFiltersItem.qid,
-      formulaType: formulaType,
-      questionType: questionType,
-      type: questionType,
-      validationType: getValidationType(validationKey, questionType, formulaType && formulaType.toUpperCase()),
-      uiExtras: {
-        column: {
-          dataset: {
-            linkid: oldFiltersItem.dataset.linkid,
-            qrveyid: oldFiltersItem.dataset.qrveyid,
-            name: oldFiltersItem.dataset.name
-          },
-          formulaType: formulaType,
-          id: oldFiltersItem.qid,
-          linked: oldFiltersItem.linked,
-          linkid: oldFiltersItem.dataset.linkid,
-          qrveyid: oldFiltersItem.dataset.qrveyid,
-          text: oldFiltersItem.text,
-          type: questionType
-        },
-        operator: 'AND',
-        property: getDateProperty(validationKey, questionType, formulaType && formulaType.toUpperCase()) || property,
-        validator: getValidator(validationKey),
-        panelid: oldFiltersItem.panelId,
-        panelName: oldFiltersItem.panelId ? oldFiltersItem.title : undefined,
-        uiHidden: false,
-        scope: scopeLabel,
-        scopeid,
-        section
-      }
-    };
-    expressions.push({
-      ...expressionItem,
-      value: getValues(oldFiltersItem.values[0][valKey], questionType, validationKey, 'value', formulaType && formulaType.toUpperCase()),
-      uiExtras: {
-        ...expressionItem.uiExtras,
-        values: getValues(oldFiltersItem.values[0][valKey], questionType, validationKey, 'values', formulaType && formulaType.toUpperCase()),
-        uiValue: getValues(oldFiltersItem.values[0][valKey], questionType, validationKey, 'uiValue', formulaType && formulaType.toUpperCase())
-      }
-    });
-  });
-  return expressions;
-}

package/src/filters/classes/FilterInputErrorHandler.ts

@@ -1,213 +0,0 @@
-// import { isDateColumn } from "../../columns/helpers/isDateColumn";
-// import { isNumericalColumn } from "../../columns/helpers/isNumericalColumn";
-import { IColumn } from "../../columns/interfaces/IColumn";
-// import { getDateByDateFormat } from "../../dates/helpers/getDateByDateFormat";
-// import { getDateFormatByProperty } from "../../dates/helpers/getDateFormatByProperty";
-// import { validateDate } from "../../dates/helpers/validateDate";
-import { IDateFormat } from "../../dates/interfaces/IDateFormat";
-// import { isEmpty } from "../../general/mix/isEmpty";
-// import { isNaNV2 } from "../../general/mix/isNaNV2";
-import { I18nService } from "../../globalization/service/i18nextBuilder";
-// import { isTokenLabel } from "../../tokens/isTokenLabel";
-// import { FILTER_VALIDATOR } from "../constants/common/FILTER_VALIDATOR";
-// import { isRangeValidator } from "../helpers/common/isRangeValidator";
-// import { IFSValueRange } from "../interfaces/common/IFSValueRange";
-import { IFProperty } from "../interfaces/IFProperty";
-import { IFValidator } from "../interfaces/IFValidator";
-import { IFValue } from "../interfaces/IFValue";
-
-interface IFilterErrorHandlerConfig {
-    column: IColumn;
-    locale: I18nService;
-    property: IFProperty;
-    validator: IFValidator;
-    value: IFValue[]
-}
-
-interface IFilterErrorHandlerError{
-    searcherInput: IFilterErrorHandlerErrorInfo[];
-    minInput: IFilterErrorHandlerErrorInfo[];
-    maxInput: IFilterErrorHandlerErrorInfo[];
-    range: IFilterErrorHandlerErrorInfo[];
-}
-
-interface IFilterErrorHandlerErrorInfo {
-    message: string;
-    type: IFilterErrorHandlerType;
-}
-
-type IFilterErrorHandlerType = FILTER_ERROR_TYPE;
-
-const enum FILTER_ERROR_TYPE {
-    REPEATED_VALUE = 'REPEATED_VALUE',
-    INVALID_INPUT = 'INVALID_INPUT',
-    INVALID_INPUT_DATE_QUARTER = 'INVALID_INPUT_DATE_QUARTER',
-    INVALID_INPUT_DATE_YEAR = 'INVALID_INPUT_DATE_YEAR',
-    INVALID_INPUT_DATE_DAY = 'INVALID_INPUT_DATE_DAY',
-    INVALID_INPUT_DATE_MONTH = 'INVALID_INPUT_DATE_MONTH',
-    INVALID_INPUT_DATE_WEEK = 'INVALID_INPUT_DATE_WEEK',
-    INVALID_INPUT_NUMERIC = 'INVALID_INPUT_NUMERIC',
-    MIN_LIMIT = 'MIN_LIMIT',
-    MAX_LIMIT = 'MAX_LIMIT'
-}
-
-/**
- * @ignore
- */
-export class FilterInputErrorHandler {
-    private _column: IColumn;
-    private _locale: I18nService;
-    private _property: IFProperty;
-    private _validator: IFValidator;
-    private _value: IFValue[];
-
-    private _dateFormat: IDateFormat;
-    private _valueKeys: string[];
-
-    private _error: IFilterErrorHandlerError;
-
-    constructor(config: IFilterErrorHandlerConfig) {
-        this._column = config.column;
-        this._locale = config.locale;
-        this._property = config.property;
-        this._validator = config.validator;
-    }
-
-    // protected set column(column: IColumn) {
-    //     this.column = column;
-    //     this.validate();
-    // }
-
-    // protected set property(property: IFProperty) {
-    //     this._property = property;
-    //     this._dateFormat = getDateFormatByProperty(this._property);
-    //     this.validate();
-    // }
-
-    // protected set validator(validator: IFValidator) {
-    //     this._validator = validator;
-    //     this._valueKeys = this.getValueKeysToValidate();
-    //     this.validate();
-    // }
-
-    // public set value(value: IFValue[]) {
-    //     this._value = value;
-    //     this.validate();
-    // }
-
-    // public get error(): IFilterErrorHandlerError {
-    //     return this._error;
-    // }
-
-    // private validate() {
-    //     if (isRangeValidator(this._validator)) {
-    //         this.validateRangeValues();
-    //     } else {
-    //         this.validateValues();
-    //     }
-    // }
-
-
-    // /**
-    //  * Returns the range type by the given validator. This function is useful in slidebar component
-    //  * @param validator The filter validator
-    //  * @returns the range type
-    //  */
-    // private getValueKeysToValidate(): string[] {
-    //     switch (this._validator) {
-    //         case FILTER_VALIDATOR.BETWEEN_INCLUSIVE:
-    //         case FILTER_VALIDATOR.BETWEEN_EXCLUSIVE:
-    //             return ['MIN', 'MAX'];
-    //         case FILTER_VALIDATOR.LESS_THAN:
-    //         case FILTER_VALIDATOR.LESS_THAN_EQUAL:
-    //         case FILTER_VALIDATOR.BEFORE:
-    //         case FILTER_VALIDATOR.BEFORE_ON:
-    //             return ['MAX'];
-    //             break;
-    //         case FILTER_VALIDATOR.GREATER_THAN:
-    //         case FILTER_VALIDATOR.GREATER_THAN_EQUAL:
-    //         case FILTER_VALIDATOR.AFTER:
-    //         case FILTER_VALIDATOR.AFTER_ON:
-    //             return ['MIN'];
-    //         default:
-    //             return ['MIN', 'MAX'];
-    //     }
-    // }
-
-    // private validateRangeValues() {
-    //     (this._value as IFSValueRange[]).forEach(value => {
-    //         if (this._valueKeys.length > 2) {
-    //             if (!this.validateValue(value.min)) this.error.minInput.push(this.getErrorInfo(value, 'minInput'));
-    //             if (this.validateValue(value.max)) this.error.maxInput.push(this.getErrorInfo(value, 'maxInput'));
-    //             if (this.validateRange(value.min, value.max)) this.error.range.push(this.getErrorInfo(value, 'range'));
-    //         }
-    //         return value;
-    //     });
-    // }
-
-    // private getErrorInfo(value: IFValue, infoKey: keyof IFilterErrorHandlerError): IFilterErrorHandlerErrorInfo {
-    //     switch (infoKey) {
-    //         case 'minInput':
-    //             return {
-                    
-
-    //             }
-    //     }
-    // }
-
-    // public validateValue(value: string): IFilterErrorHandlerErrorInfo {
-    //     if (isTokenLabel(value)) return;
-
-    //     if ((isNumericalColumn(this._column) || !isEmpty(this._column.aggregate)) && isNaNV2(value)) {
-    //         return {
-    //             type: FILTER_ERROR_TYPE.INVALID_INPUT_NUMERIC,
-    //             message: this.getErrorMessage(FILTER_ERROR_TYPE.INVALID_INPUT_NUMERIC),
-    //         };
-    //     } else if (isDateColumn(this._column)) {
-    //         return validateDate(value, this._dateFormat);
-    //     }
-    //     return;
-    // }
-
-    // public validateRange(minValue: string, maxValue: string): boolean {
-    //     if (isTokenLabel(minValue) || isTokenLabel(maxValue)) return true;
-
-    //     if (isNumericalColumn(this._column) || !isEmpty(this._column.aggregate) ) {
-    //         return minValue < maxValue;
-    //     } else  if (isDateColumn(this._column)) {
-    //         const formattedValue1 = getDateByDateFormat(minValue, this._dateFormat);
-    //         const formattedValue2 = getDateByDateFormat(maxValue, this._dateFormat);
-
-    //         return formattedValue1 < formattedValue2;
-    //     }
-    // }
-
-    // private validValue(value: string): boolean {
-        
-    // }
-
-    // private getErrorMessage(type: IInputErrorType, config?: { values?: string[], plural?: boolean, isDate?: boolean, dateFormat: IDateFormat }) {
-    //     let message = '', values;
-    //     config = { values: _get(config, 'values', []), plural: _get(config, 'plural', false), isDate: _get(config, 'isDate', false), dateFormat: _get(config, 'dateFormat') };
-    //     if (config.values.length) {
-    //       values = '"' + config.values.join('", "') + '"';
-    //       config.plural = config.values.length > 1;
-    //     }
-    //     const valueTypeMessage = config.isDate ? 'date' : 'value';
-    //     if (type === ERROR_TYPE.INVALID_INPUT) {
-    //       message = getInvalidInputErrorMessage(values, config.plural);
-    //     } else if (INVALID_INPUT_DATE.includes(type)) {
-    //       message = getInvalidInputDateErrorMessage(config.dateFormat, values, config.plural); 
-    //     } else if (type === ERROR_TYPE.INVALID_INPUT_NUMERIC) {
-    //       message = getInvalidInputErrorMessage(values, config.plural).concat(config.plural ? ' They ' : ' It ').concat('should be numeric format.');
-    //     } else if (type === ERROR_TYPE.MAX_LIMIT) {
-    //       message = 'Max '.concat(valueTypeMessage).concat(' should be ').concat(config.isDate ? 'after' : 'greater than').concat(' the Min ').concat(valueTypeMessage);
-    //     } else if (type === ERROR_TYPE.MIN_LIMIT) {
-    //       message = 'Min '.concat(valueTypeMessage).concat(' should be ').concat(config.isDate ? 'before' : 'less than').concat(' the Max ').concat(valueTypeMessage);
-    //     } else if (type === ERROR_TYPE.REPEATED_VALUE) {
-    //       message = values ? values.concat(' already exist').concat(config.plural ? '' : 's') : config.plural ? 'These filters already exist.' : 'This filter already exists.';
-    //     }
-    //     return message;
-    //   }
-      
-}

package/src/filters/classes/index.ts

@@ -1 +0,0 @@
-export * from './FilterInputErrorHandler';

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

@@ -1,21 +0,0 @@
-export enum FILTER_BACKEND_VALIDATOR {
-  EQUALS = 'EQUAL',
-  NOT_EQUAL = 'NOT_EQUAL',
-  CONTAINS = 'CONTAIN',
-  NOT_CONTAIN = 'NOT_CONTAIN',
-  ENDS_WITH = 'END_WITH',
-  NOT_END_WITH = 'NOT_END_WITH',
-  STARTS_WITH = 'START_WITH',
-  NOT_START_WITH = 'NOT_START_WITH',
-  BETWEEN = 'BETWEEN',
-  LESS_THAN = 'LESS_THAN',
-  LESS_THAN_EQUAL = 'LESS_THAN_OR_EQUAL',
-  GREATER_THAN = 'GREATER_THAN',
-  GREATER_THAN_EQUAL = 'GREATER_THAN_OR_EQUAL',
-  IS_NULL = 'IS_EMPTY',
-  IS_NOT_NULL = 'IS_NOT_EMPTY',
-  RANGE = 'RANGE',
-  NOT_RANGE = 'NOT_RANGE',
-  IN = 'IN',
-  RELATIVE = 'RELATIVE'
-}

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

@@ -1 +0,0 @@
-export * from './FILTER_BACKEND_VALIDATOR';

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

@@ -1,10 +0,0 @@
-import { COLUMN } from "../../../columns/constants/COLUMN";
-
-// COLUMNS TYPES FOR THE CONTAINS LAYOUT
-export const COLUMNS_FOR_CONTAINS_VALIDATOR = [
-    COLUMN.EMAIL_FORM,
-    COLUMN.LONGTEXT,
-    COLUMN.NAME,
-    COLUMN.PHONE,
-    COLUMN.TEXTFIELD
-];

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

@@ -1,6 +0,0 @@
-import { COLUMN } from "../../../columns/constants/COLUMN";
-
-// COLUMNS TYPES FOR GETTING VALIDATORS THAT USE EQUAL LAYOUT
-export const COLUMNS_FOR_EQUALS_LAYOUT = [
-    COLUMN.BUCKET
-];

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

@@ -1,11 +0,0 @@
-import { COLUMN } from "../../../columns/constants/COLUMN";
-
-// COLUMNS TYPES FOR GETTING VALIDATORS THAT USE EQUAL AND NULL LAYOUTS
-export const COLUMNS_FOR_EQUALS_NULL_LAYOUT = [
-    COLUMN.EXPRESSION,
-    COLUMN.IMAGE,
-    COLUMN.MULTIPLE_CHOICE,
-    COLUMN.RANKING,
-    COLUMN.SINGLE_CHOICE,
-    COLUMN.YES_NO
-];

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

@@ -1,7 +0,0 @@
-import { COLUMN } from "../../../columns/constants/COLUMN";
-
-// COLUMNS TYPES FOR GETTING VALIDATORS THAT USE NULL LAYOUT
-export const COLUMNS_FOR_NULL_LAYOUT = [
-    COLUMN.PASSWORD,
-    COLUMN.SIGNATURE
-];

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

@@ -1,13 +0,0 @@
-import { COLUMN } from "../../../columns/constants/COLUMN";
-
-// QUESTION TYPES FOR GETTING VALIDATORS THAT USE TEXT LAYOUT
-export const COLUMNS_FOR_TEXT_LAYOUT = [
-    COLUMN.ADDRESS,
-    COLUMN.DROPDOWN,
-    COLUMN.EMAIL_FORM,
-    COLUMN.LONGTEXT,
-    COLUMN.NAME,
-    COLUMN.PHONE,
-    COLUMN.USADDRESS,
-    COLUMN.LOOKUP
-];