@qrvey/filters 0.0.45 → 0.1.0

package/src/helpers/filter-adapt.logic.helpers.ts

@@ -1,631 +0,0 @@
-import {
-  _hasProperty,
-  COLUMN,
-  COLUMN_PROPERTY,
-  flattenDeep,
-  isDateColumn,
-  isEmpty,
-} from "@qrvey/utils";
-
-import { filterToVisual } from "./filter-adapt.helpers";
-import { isNullValidator } from "./filter-validators.helpers";
-import { getFilterType } from "./getFilterType";
-
-import {
-  FILTER_GROUPING,
-  IFilterGrouping,
-} from "../resources/filter-grouping.resources";
-import {
-  FILTER_LOGIC_VALIDATOR,
-  IFilterLogic,
-  IFilterLogicExpression,
-  IFilterLogicExpressionValue,
-  IFilterLogicExpressionValueRange,
-  IFilterLogicExpressionValueRanking,
-  IFilterLogicExpressionValueRegular,
-  IFilterLogicExpressionValueRelative,
-  IFilterLogicFilter,
-  IFilterLogicValidator,
-} from "../resources/filter-logic.resources";
-import {
-  FILTER_OPERATOR,
-  IFilterOperator,
-} from "../resources/filter-operators.resources";
-import {
-  FILTER_LOGIC_VALIDATOR_BY_VALIDATOR,
-  FILTER_VALIDATOR,
-} from "../resources/filter-validators.resources";
-import {
-  IFilterValueRange,
-  IFilterValueRanking,
-  IFilterValueRegular,
-  IFilterValueRelativeDate,
-} from "../resources/filter-values.resources";
-import {
-  IFilterUI,
-  IFilterVisual,
-  IFilterVisualDataset,
-  IFilterVisualScope,
-} from "../resources/filter-visual.resources";
-import { FILTER_TYPE, IFilter } from "../resources/filters.resources";
-
-/**
- * Generates a Logic structure from the filter collection
- * @param filters the filter collection
- * @returns the logic structure
- */
-export function filterToLogic(filters: IFilter[]): IFilterLogic[] {
-  if (isEmpty(filters)) return [];
-
-  const visual = filterToVisual(filters)!;
-  return visualToLogic(visual);
-}
-
-/**
- * Generates a Logic structure from the visual filter structure
- * @param visual the visual filter structure
- * @returns the logic structure
- */
-export function visualToLogic(visual: IFilterVisual): IFilterLogic[] {
-  return visual.scopes.reduce(
-    (logics: IFilterLogic[], scope: IFilterVisualScope) => {
-      const logic: IFilterLogic = buildLogic(scope);
-      let filters: IFilterLogicFilter[] = [];
-      if (scope.datasets.length > 0) {
-        scope.datasets.forEach((dataset: IFilterVisualDataset) => {
-          const expressions = buildLogicFilters(dataset.filters, true);
-          filters = filters.concat(expressions);
-        });
-      }
-      logics.push({ ...logic, filters });
-      return logics;
-    },
-    [],
-  );
-}
-
-/**
- * Gets the Logic structure for the given scope
- * @param scope the visual filter scope object
- * @returns a logic structure
- */
-function buildLogic(scope: IFilterVisualScope): IFilterLogic {
-  return {
-    filters: [],
-    scope: scope.scope,
-    scopeid: scope.id,
-  };
-}
-
-/**
- * Gets the Logic Filters collection based on filters
- * @param filters the filter collection
- * @param groupColumns a flag to know if the
- * @returns the logic filter collection
- */
-function buildLogicFilters(
-  filters: IFilterUI[],
-  groupColumns = false,
-): IFilterLogicFilter[] {
-  const expression = numericExpression(filters, groupColumns);
-  const orOperators = expression.split("+");
-
-  const getFilter = (fi: string): IFilterLogicExpression | undefined => {
-    const filter = filters.find((f) => f.id === fi);
-    if (filter == null) return;
-
-    return buildLogicExpression(filter);
-  };
-
-  const expressions = orOperators
-    .map((group) => {
-      const andOperators = group.split("*");
-      if (andOperators.length > 1) {
-        const groupedExpression: IFilterLogicFilter = {
-          operator: FILTER_OPERATOR.AND,
-          expressions: andOperators
-            .map<IFilterLogicExpression>(
-              (group2) =>
-                getColumnExpressions(
-                  group2,
-                  getFilter,
-                ) as IFilterLogicExpression,
-            )
-            .filter(Boolean),
-        };
-        return groupedExpression;
-      }
-      return getColumnExpressions(group, getFilter);
-    })
-    .filter(Boolean);
-  if (orOperators.length > 1) {
-    return [
-      {
-        operator: FILTER_OPERATOR.OR,
-        expressions: expressions as IFilterLogicExpression[],
-      },
-    ];
-  }
-
-  if (_hasProperty(expressions[0], "expressions")) {
-    return expressions as IFilterLogicFilter[];
-  }
-  return [
-    {
-      operator: FILTER_OPERATOR.AND,
-      expressions: expressions as IFilterLogicExpression[],
-    },
-  ];
-}
-
-/**
- *
- * @param group
- * @param getFilter
- */
-function getColumnExpressions(
-  group: string,
-  getFilter: (fi: string) => IFilterLogicExpression | undefined,
-): IFilterLogicFilter | IFilterLogicExpression {
-  const columnOrOperators = group.split("/");
-  if (columnOrOperators.length > 1) {
-    return {
-      operator: FILTER_OPERATOR.OR,
-      expressions: columnOrOperators
-        .map((group3) => getFilter(group3))
-        .filter(Boolean),
-    } as IFilterLogicFilter;
-  }
-  return getFilter(group) as IFilterLogicExpression;
-}
-
-/**
- *
- * @param operator
- * @param priority
- */
-function logicToNumeric(
-  operator: IFilterOperator,
-  priority = false,
-): "*" | "/" | "+" {
-  if (operator === FILTER_OPERATOR.AND) {
-    return "*";
-  }
-  return priority ? "/" : "+";
-}
-
-/**
- *
- * @param filters
- * @param groupColumns
- */
-function numericExpression(filters: IFilterUI[], groupColumns = false) {
-  let expression = "";
-  filters.forEach((item: IFilterUI, index: number) => {
-    const filter: IFilterUI = filters[index + 1] || {};
-    const operator = logicToNumeric(
-      item.operator,
-      groupColumns && item.columnId === filter?.columnId,
-    );
-    expression += `${item.id}${operator}`;
-  });
-  return expression.substring(0, expression.length - 1);
-}
-
-/**
- * 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 buildLogicExpression(
-  filter: IFilterUI,
-): IFilterLogicExpression {
-  const expression: IFilterLogicExpression = {
-    enabled: filter.enabled,
-    groupValue: getLogicExpressionGroupValue(filter),
-    questionid: filter.columnId,
-    property: getLogicExpressionProperty(filter),
-    validationType: getLogicExpressionValidator(filter),
-    value: getFilterLogicValues(filter),
-  };
-  expression.enabled =
-    filter.selectAll || expression.value!.length > 0 ? filter.enabled : false;
-
-  return expression;
-}
-
-/**
- * Gets a group value for the backend logic structure
- * @param filter The filter object
- * @returns the group value
- */
-function getLogicExpressionGroupValue(
-  filter: IFilterUI,
-): IFilterGrouping | undefined {
-  if (
-    filter.aggregateType == null &&
-    isDateColumn({
-      formulaType: filter.formulaType,
-      type: filter.columnType,
-      id: filter.columnId,
-      qrveyid: filter.datasetId,
-    }) &&
-    filter.grouping != null
-  ) {
-    return filter.grouping;
-  }
-
-  return undefined;
-}
-
-/**
- * Gets a property for the logic expression structure
- * @param filter The filter
- * @returns a property
- */
-function getLogicExpressionProperty(
-  filter: IFilterUI,
-): IFilterGrouping | string | undefined {
-  if (isEmpty(filter.aggregateType)) {
-    if (
-      isNullValidator(filter.validator) ||
-      isDateColumn({
-        formulaType: filter.formulaType,
-        type: filter.columnType,
-        id: filter.columnId,
-        qrveyid: filter.datasetId,
-      })
-    ) {
-      return undefined;
-    } else if (
-      filter.columnType === COLUMN.EXPRESSION &&
-      filter.grouping != null
-    ) {
-      return undefined;
-    } else if (
-      filter.columnType === COLUMN.LOOKUP &&
-      filter.grouping === FILTER_GROUPING.LOOKUP_DISPLAY &&
-      filter.lookupDisplayIndex != null
-    ) {
-      return (filter.grouping as string)
-        ?.concat("_")
-        .concat(filter.lookupDisplayIndex.toString());
-    } else if (filter.columnType === COLUMN.IMAGE) {
-      return (filter.values as IFilterValueRegular[]).every((value) =>
-        isEmpty(value.id),
-      )
-        ? undefined
-        : COLUMN_PROPERTY.IMAGE_ANSWER_ID;
-    }
-  }
-  return filter.grouping;
-}
-
-/**
- * Gets the filter logic Validator
- * @param filter the filter object
- * @returns the Filter Logic Validator
- */
-function getLogicExpressionValidator(filter: IFilterUI): IFilterLogicValidator {
-  let logicValidator = FILTER_LOGIC_VALIDATOR_BY_VALIDATOR[filter.validator];
-
-  if (filter.selectAll && filter.validator === FILTER_VALIDATOR.EQUALS)
-    logicValidator = FILTER_LOGIC_VALIDATOR.NOT_EQUAL;
-
-  if (filter.selectAll && filter.validator === FILTER_VALIDATOR.NOT_EQUAL)
-    logicValidator = FILTER_LOGIC_VALIDATOR.EQUALS;
-
-  return logicValidator;
-}
-
-/**
- * Gets the expresion values in the logic format
- * @param filter The filter structure
- * @returns A collection of backend expression value
- */
-export function getFilterLogicValues(
-  filter: IFilterUI,
-): IFilterLogicExpressionValue[] {
-  const values = filter.values || [];
-
-  switch (filter.validator) {
-    case FILTER_VALIDATOR.EQUALS:
-    case FILTER_VALIDATOR.NOT_EQUAL:
-    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:
-      if (
-        getFilterType(filter.columnType, filter.validator) ===
-        FILTER_TYPE.RANKING
-      )
-        return getRankingValues(values as IFilterValueRanking[][]);
-      return getResultValues(values as IFilterValueRegular[], filter);
-    case FILTER_VALIDATOR.BETWEEN_INCLUSIVE:
-      return getInclusiveRange(values as IFilterValueRange[]);
-    case FILTER_VALIDATOR.BETWEEN_EXCLUSIVE:
-      return getExclusiveRange(values as IFilterValueRange[]);
-    case FILTER_VALIDATOR.BEFORE:
-    case FILTER_VALIDATOR.LESS_THAN:
-      return getBeforeValues(values as IFilterValueRange[]);
-    case FILTER_VALIDATOR.BEFORE_ON:
-    case FILTER_VALIDATOR.LESS_THAN_EQUAL:
-      return getBeforeOnValues(values as IFilterValueRange[]);
-    case FILTER_VALIDATOR.AFTER:
-    case FILTER_VALIDATOR.GREATER_THAN:
-      return getAfterValues(values as IFilterValueRange[]);
-    case FILTER_VALIDATOR.AFTER_ON:
-    case FILTER_VALIDATOR.GREATER_THAN_EQUAL:
-      return getAfterOnValues(values as IFilterValueRange[]);
-    case FILTER_VALIDATOR.IS_NULL:
-    case FILTER_VALIDATOR.IS_NOT_NULL:
-      return getNullValues(values as IFilterValueRegular[], filter);
-    case FILTER_VALIDATOR.IN:
-      return getInValues(values as IFilterValueRelativeDate[]);
-    default:
-      return [];
-  }
-}
-
-/**
- * Gets the expression values for Exclusive Ranges
- * @param values the collection of values
- * @returns the logic expression values
- */
-function getExclusiveRange(
-  values: IFilterValueRange[],
-): IFilterLogicExpressionValueRange[] {
-  return values.reduce(
-    (
-      expressionValues: IFilterLogicExpressionValueRange[],
-      value: IFilterValueRange,
-    ) => {
-      const expressionValue = getValue(value, {
-        lt: value.max,
-        gt: value.min,
-      }) as IFilterLogicExpressionValueRange;
-      if (expressionValue != null) expressionValues.push(expressionValue);
-
-      return expressionValues;
-    },
-    [],
-  );
-}
-
-/**
- * Gets the expression values for Inclusive Ranges
- * @param values the collection of values
- * @returns the logic expression values
- */
-function getInclusiveRange(
-  values: IFilterValueRange[],
-): IFilterLogicExpressionValueRange[] {
-  return values.reduce(
-    (
-      expressionValues: IFilterLogicExpressionValueRange[],
-      value: IFilterValueRange,
-    ) => {
-      const expressionValue = getValue(value, {
-        lte: value.max,
-        gte: value.min,
-      }) as IFilterLogicExpressionValueRange;
-      if (expressionValue != null) expressionValues.push(expressionValue);
-
-      return expressionValues;
-    },
-    [],
-  );
-}
-
-/**
- * Gets the expression values for Before Ranges
- * @param values the collection of values
- * @returns the logic expression values
- */
-function getBeforeValues(
-  values: IFilterValueRange[],
-): IFilterLogicExpressionValueRange[] {
-  return values.reduce(
-    (
-      expressionValues: IFilterLogicExpressionValueRange[],
-      value: IFilterValueRange,
-    ) => {
-      const expressionValue = getValue(value, {
-        lt: value.max,
-      }) as IFilterLogicExpressionValueRange;
-      if (expressionValue != null) expressionValues.push(expressionValue);
-
-      return expressionValues;
-    },
-    [],
-  );
-}
-
-/**
- * Gets the expression values for BeforeOn Ranges
- * @param values the collection of values
- * @returns the logic expression values
- */
-function getBeforeOnValues(
-  values: IFilterValueRange[],
-): IFilterLogicExpressionValueRange[] {
-  return values.reduce(
-    (
-      expressionValues: IFilterLogicExpressionValueRange[],
-      value: IFilterValueRange,
-    ) => {
-      const expressionValue = getValue(value, {
-        lte: value.max,
-      }) as IFilterLogicExpressionValueRange;
-      if (expressionValue != null) expressionValues.push(expressionValue);
-
-      return expressionValues;
-    },
-    [],
-  );
-}
-
-/**
- * Gets the expression values for After Ranges
- * @param values the collection of values
- * @returns the logic expression values
- */
-function getAfterValues(
-  values: IFilterValueRange[],
-): IFilterLogicExpressionValueRange[] {
-  return values.reduce(
-    (
-      expressionValues: IFilterLogicExpressionValueRange[],
-      value: IFilterValueRange,
-    ) => {
-      const expressionValue = getValue(value, {
-        gt: value.min,
-      }) as IFilterLogicExpressionValueRange;
-      if (expressionValue != null) expressionValues.push(expressionValue);
-
-      return expressionValues;
-    },
-    [],
-  );
-}
-
-/**
- * Gets the expression values for AfterOn Ranges
- * @param values the collection of values
- * @returns the logic expression values
- */
-function getAfterOnValues(
-  values: IFilterValueRange[],
-): IFilterLogicExpressionValueRange[] {
-  return values.reduce(
-    (
-      expressionValues: IFilterLogicExpressionValueRange[],
-      value: IFilterValueRange,
-    ) => {
-      const expressionValue = getValue(value, {
-        gte: value.min,
-      }) as IFilterLogicExpressionValueRange;
-      if (expressionValue != null) expressionValues.push(expressionValue);
-
-      return expressionValues;
-    },
-    [],
-  );
-}
-
-/**
- * Gets the expression values for Nulls
- * @param values the collection of values
- * @param filter the filter structure
- * @returns the logic expression values
- */
-function getNullValues(
-  values: IFilterValueRegular[],
-  filter: IFilterUI,
-): IFilterLogicExpressionValueRegular[] {
-  const addValue = values.length > 0 && values.every((value) => value.enabled);
-  return addValue ? [filter.validator] : [];
-}
-
-/**
- * Gets the expression values for Relative Dates
- * @param values the collection of values
- * @returns the logic expression values
- */
-function getInValues(
-  values: IFilterValueRelativeDate[],
-): IFilterLogicExpressionValueRelative[] {
-  return values.reduce(
-    (
-      expressionValues: IFilterLogicExpressionValueRelative[],
-      value: IFilterValueRelativeDate,
-    ) => {
-      const expressionValue = getValue(
-        value,
-        value,
-      ) as IFilterLogicExpressionValueRelative;
-      if (expressionValue != null) expressionValues.push(expressionValue);
-
-      return expressionValues;
-    },
-    [],
-  );
-}
-
-/**
- * Gets the value on the filter values
- * @param objectValue The filter structure
- * @param value The filter structure
- * @returns the value
- */
-function getValue(
-  objectValue:
-    | IFilterValueRegular
-    | IFilterValueRange
-    | IFilterValueRelativeDate,
-  value: IFilterLogicExpressionValue | string,
-): IFilterLogicExpressionValue | undefined {
-  return objectValue.enabled ? value : undefined;
-}
-
-/**
- * Gets the expression values. Depending on the column type
- * @param values a collection of filter values
- * @param filter The filter structure
- * @returns Expression values
- */
-function getResultValues(
-  values: IFilterValueRegular[],
-  filter: IFilterUI,
-): IFilterLogicExpressionValue[] {
-  return values.reduce(
-    (
-      expressionValues: IFilterLogicExpressionValueRegular[],
-      value: IFilterValueRegular,
-    ) => {
-      let expressionValue = "";
-      if (value.enabled) {
-        expressionValue = value.value || "";
-        if (filter.columnType === COLUMN.IMAGE) {
-          expressionValue = value.id || value.imageUrl || value.value || "";
-        }
-      }
-      if (!isEmpty(expressionValue)) expressionValues.push(expressionValue);
-
-      return expressionValues;
-    },
-    [],
-  );
-}
-
-/**
- * Gets the Ranking values.
- * @param values a collection of filter values in the ranking structure
- * @returns Expression values for ranking
- */
-function getRankingValues(
-  values: IFilterValueRanking[][],
-): IFilterLogicExpressionValueRanking[] {
-  const flattenValues: IFilterValueRanking[] = flattenDeep(values);
-  return flattenValues.reduce(
-    (
-      expressionValues: IFilterLogicExpressionValueRanking[],
-      value: IFilterValueRanking,
-    ) => {
-      let expressionValue: IFilterLogicExpressionValueRanking;
-      if (value.enabled) {
-        expressionValue = {
-          position: value.position - 1,
-          value: value.value!,
-        };
-      }
-      if (expressionValue! != null) expressionValues.push(expressionValue);
-
-      return expressionValues;
-    },
-    [],
-  );
-}

package/src/helpers/filter-builder.helpers.ts

@@ -1,28 +0,0 @@
-import { FilterResources } from "../classes/FilterResources";
-import { IFilterFilterGroupingSettings } from "../resources/filter-functions.resources";
-import { IFilterGrouping } from "../resources/filter-grouping.resources";
-import { DEFAULT_FILTER, IFilter } from "../resources/filters.resources";
-
-/**
- * Gets the filter grouping for a given filter.
- * @param filter The filter to get the grouping for.
- * @param settings Settings for the filter grouping.
- * @returns The filter grouping.
- */
-export function getFilterGrouping(
-  filter: Partial<IFilter>,
-  settings?: IFilterFilterGroupingSettings,
-): IFilterGrouping | undefined {
-  return (
-    (settings?.strictValidation
-      ? FilterResources.getGroupingInfoByColumnType(
-          {
-            type: filter.columnType ?? DEFAULT_FILTER.columnType,
-            formulaType: filter.formulaType,
-          },
-          filter.grouping,
-          settings,
-        )?.value
-      : filter.grouping) || DEFAULT_FILTER.grouping
-  );
-}