@qrvey/utils 1.3.3 → 1.4.0-2

package/src/filters/adapters/logicToFlatUI.ts

@@ -1,171 +0,0 @@
-// FROM Logic structure = Old logic structure (v2.0)
-// TO Logic structure = Cleaner logic structure
-
-import { adaptDateGroupingProperty } from "./adaptDateGroupingProperty";
-import { COLUMN } from "../../columns/constants/COLUMN";
-import { OLD_IFilterLogic } from "../interfaces/OLD_IFilterLogic";
-import { IFUFlattenedFilter } from "../interfaces/ui/IFUFlattenedFilter";
-import { isEmpty } from "../../general/mix/isEmpty";
-import { OLD_IFilterExpression } from "../interfaces/OLD_IFilterExpression";
-import { _hasProperty } from "../../general/object/hasProperty";
-import { FILTER_BACKEND_VALIDATOR } from "../constants/backend/FILTER_BACKEND_VALIDATOR";
-import { getFilterid } from "../helpers/common/getFilterid";
-import { FILTER_SCOPE } from "../constants/common/FILTER_SCOPE";
-import { _get } from "../../general/object/get";
-import { IFSValueRanking } from "../interfaces/common/IFSValueRanking";
-import { OLD_IFilterDetail } from "../interfaces/OLD_IFilterDetail";
-import { isNullValidator } from "../helpers/common/isNullValidator";
-import { FILTER_VALIDATOR_INFO } from "../constants/common/FILTER_VALIDATOR_INFO";
-
-
-/**
- * Adapts the Old logic structure (v2.0) to the flattened UI filter Structure.
- * @param logics The old logic structure (v2.0)
- * @returns The Flattened UI Filters array
- */
-export function logicToFlatUI(logics: OLD_IFilterLogic[] = []): IFUFlattenedFilter[] {
-    if (isEmpty(logics)) return [];
-
-    const uFilters: IFUFlattenedFilter[] = [];
-    logics.forEach(scopeItem => {
-        if (scopeItem.filters.length > 0) {
-            scopeItem.filters.forEach(filterItem => {
-                filterItem.expressions.forEach((expression1: OLD_IFilterExpression) => {
-                    _hasProperty(expression1, 'expressions') ? expression1.expressions.forEach((expression2: OLD_IFilterExpression) => {
-                        buildFilterByExpression(expression2, scopeItem, uFilters);
-                    }) : buildFilterByExpression(expression1, scopeItem, uFilters);
-                });
-            });
-        }
-    });
-    return uFilters;
-}
-
-function buildFilterByExpression(expression: OLD_IFilterExpression, scopeItem: OLD_IFilterLogic, uFilters: IFUFlattenedFilter[]) {
-    const uiExtras = expression.uiExtras;
-    const index = uiExtras.column.type === COLUMN.RANKING ? getFilter(uFilters, expression.uiExtras, true) as number : -1;
-    if (index === -1 && (!uiExtras.nullValues || expression.validationType !== FILTER_BACKEND_VALIDATOR.IS_NULL)) {
-        const uFilter: IFUFlattenedFilter = getFilterByExpression(expression, scopeItem);
-        uFilter.filterid = getFilterid(uFilter);
-        uFilters.push(uFilter);
-    }
-    if (uiExtras.column.type === COLUMN.RANKING && isEmpty(uiExtras.column.aggregate)) {
-        // Restore uiExtras.values array into single IFilterDetail object values array
-        if (index > -1) uFilters[index].values.push(uiExtras.values[0]);
-        const refinedRankingValues = refineRankingValues((index > -1 ? uFilters[index].values : uiExtras.values ) as IFSValueRanking[][], uiExtras.uiValue);
-        if (index > -1) uFilters[index].values = refinedRankingValues;
-        else uFilters[uFilters.length - 1].values = refinedRankingValues;
-    }
-}
-
-function getFilterByExpression(expression: OLD_IFilterExpression, scopeItem: OLD_IFilterLogic): IFUFlattenedFilter {
-    const uiExtras = expression.uiExtras;
-    const scopeid = scopeItem.scope !== FILTER_SCOPE.GLOBAL ? _get(scopeItem, 'uiExtras.scopeid') : undefined;
-    const info = !isEmpty(uiExtras.info) ? { icon: uiExtras.info.icon, label: uiExtras.info.label } : undefined;
-    const property = adaptDateGroupingProperty(uiExtras.property);
-
-    return {
-        collapsed: uiExtras.collapsed,
-        column: {
-            id: uiExtras.column?.id,
-            formulaType: uiExtras.column?.formulaType,
-            linkid: uiExtras.column?.linkid,
-            linked: uiExtras.column?.linked,
-            qrveyid: uiExtras.column?.qrveyid,
-            aggregate: (uiExtras.column?.aggregate as any)?.label || uiExtras.column?.aggregate,
-            calculation: (uiExtras.column?.calculation as any)?.value || uiExtras.column?.calculation,
-            label: _get(uiExtras.column, 'text') || _get(uiExtras.column, 'label'),
-            property: uiExtras.column.property,
-            sorting: uiExtras.column.sorting,
-            outputFormat: uiExtras.column?.outputFormat,
-            type: uiExtras.column?.type,
-        },
-        dateSection: uiExtras.dateSection,
-        displayed: true,
-        enabled: uiExtras.enabled,
-        extras: {
-            ...uiExtras.extras,
-            panelid: uiExtras.panelid,
-            filterLabel: uiExtras.panelName,
-            info,
-            scopeid,
-            scope: scopeItem.scope,
-            section: uiExtras.section,
-            scopeInfo: {
-                collapsed: scopeItem.uiExtras?.collapsed,
-                enabled: scopeItem.enabled,
-                displayed: true,
-                scope: scopeItem.scope,
-                scopeid,
-            },
-            dataset: {
-                collapsed: false,
-                enabled: true,
-                displayed: true,
-                qrveyid: uiExtras.column?.qrveyid,
-                label: _get(uiExtras.column, 'dataset.name') || _get(uiExtras.column, 'label'),
-                linkid: uiExtras.column?.linkid,
-            },
-        },
-        filterid: undefined,
-        lookupDisplayIndex: uiExtras.lookupDisplayIndex,
-        nullValues: uiExtras.nullValues,
-        operator: uiExtras.operator,
-        property,
-        selectAll: uiExtras.selectAll,
-        validator: uiExtras.validator,
-        values: getValues(uiExtras),
-    };
-}
-
-function getValues(uiExtras: OLD_IFilterDetail) {
-    if (isNullValidator(uiExtras.validator) && isEmpty(uiExtras.values)) {
-        return [{ value: FILTER_VALIDATOR_INFO[uiExtras.validator].label, enabled: uiExtras.uiValue[0].enabled != null ? uiExtras.uiValue[0].enabled : true }];
-    }
-    if (uiExtras.column.type !== COLUMN.RANKING || !isEmpty(uiExtras.column.aggregate)) {
-        return uiExtras.values;
-    }
-    return [];    
-    
-}
-
-/**
- * Get the filter or the index of the given array, validating an old filter structure.
- * @param filters The array of UI filters
- * @param filter The old logic structure filter
- * @param getIndex Determines if the index or returns the UI filter object
- * @returns the index or the UI filter object
- */
-function getFilter(filters: IFUFlattenedFilter[], filter: OLD_IFilterDetail, getIndex = false): number | IFUFlattenedFilter {
-    const validator = (f: IFUFlattenedFilter) => f.validator === filter.validator &&
-        f.column.id === filter.column.id &&
-        f.column.qrveyid === filter.column.qrveyid &&
-        f.column.linkid === filter.column.linkid &&
-        _get(f.column, 'aggregate.label') === _get(filter.column, 'aggregate.label') &&
-        f.extras.scope === filter.scope &&
-        f.extras.scopeid === filter.scopeid &&
-        f.property === filter.property &&
-        f.extras.panelid === filter.panelid;
-    return getIndex ? filters.findIndex(validator) : filters.find(validator);
-}
-
-/**
- * Refines the values of the Ranking column type.
- * @param values the Array of Ranking values
- * @param uiValues Object with additional info about the values of the filter.
- * @returns the array of Ranking values 
- */
-function refineRankingValues(values: IFSValueRanking[][] = [], uiValues = []): IFSValueRanking[][] {
-    return values.map(valueGroup => {
-        return [
-            ...valueGroup.map(value => {
-                const rValue = uiValues.find(uiV => uiV.valueid === value.value.valueid);
-                return {
-                    ...value,
-                    displayed: rValue && rValue.displayed != null ? rValue.displayed : true,
-                    enabled: rValue && rValue.enabled != null ? rValue.enabled : true,
-                };
-            })
-        ];
-    });
-}

package/src/filters/adapters/logicToUI.ts

@@ -1,19 +0,0 @@
-import { FILTER_STRUCTURE_VERSION } from "../constants/common/FILTER_STRUCTURE_VERSION";
-import { FILTER_SECTION } from "../constants/common/FILTER_SECTION";
-import { IFUData } from "../interfaces/ui/IFUData";
-import { IFSection } from "../interfaces/IFSection";
-import { OLD_IFilterLogic } from "../interfaces/OLD_IFilterLogic";
-import { flatUIToUI } from "./flatUIToUI";
-import { logicToFlatUI } from "./logicToFlatUI";
-
-/**
- * Generates a UI filter structure from the old logic structure (v2.0).
- * @param uFilters Array of filters from old logic structure
- * @param datasetsInfo Collection of datasets information
- * @returns a UI Filter Data.
- */
- export function logicToUI(logics: OLD_IFilterLogic[] = [], section: IFSection = FILTER_SECTION.ANYWHERE, enabled = true, version = FILTER_STRUCTURE_VERSION): IFUData {
-    const flatUiFilters = logicToFlatUI(logics);
-    const uiFilters = flatUIToUI(flatUiFilters, section, enabled, version);
-    return uiFilters;
-}

package/src/filters/adapters/modelAnswerToFilterValue.ts

@@ -1,15 +0,0 @@
-import { IModelAnswer } from "../../qrvey/interfaces/IModelAnswer";
-import { IFSValue } from "../interfaces/common/IFSValue";
-
-/**
- * Adapter for model answer to convert to recognizable values for Filter Builder
- * @param answers Array of the qrvey model answers
- * @returns Array of values
- */
- export function modelAnswerToFilterValue(answers: IModelAnswer[] = []): IFSValue[] {
-    return answers.map(answer => ({
-      value: answer.answer,
-      valueid: answer.answerid,
-      imageUrl: answer.answerUrl
-    }));
-}

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;
-}