@qrvey/utils 1.3.0-9 → 1.3.2

package/src/filters/services/Filters.api.ts

@@ -0,0 +1,159 @@
+import UChartPaginationApi from './UChartPaginationApi';
+import UChartApi from './UChartApi';
+import { IFBData } from '../interfaces/backend/IFBData';
+import { isRangeValidator } from '../helpers/common/isRangeValidator';
+import { getFiltersByVisibility } from '../helpers/common/getFiltersByVisibility';
+import { excludeFiltersByAggregateColumn } from '../helpers/common/excludeFiltersByAggregateColumn';
+import { FDToLogic } from '../adapters/FDToLogic';
+import { getLogicByScopesHierarchy } from '../helpers/backend/getLogicByScopesHierarchy';
+import { buildUserFilters } from '../helpers/backend/buildUserFilters';
+import { applyHierarchyForAggFilters } from '../helpers/applyHierarchyForAggFilters';
+import { getAvailableScopes } from '../helpers/getAvailableScopes';
+import { getAvailableScopesIDsByConfig } from '../helpers/getAvailableScopesIDsByConfig';
+import { FILTER_SCOPE } from '../constants/common/FILTER_SCOPE';
+import { IFSScopeID } from '../interfaces/common/IFSScopeID';
+import { IEndpointConfig } from '../../services/interfaces/IEndpointConfig';
+import { IDataset } from '../../qrvey/interfaces/IDataset';
+import { getAllDatasets } from '../../services/api/getAllDatasets.api';
+import { isEmpty } from '../../general/mix/isEmpty';
+import { IFUChartSettings } from '../interfaces/ui/IFUChartSettings';
+import { IFilterConfig } from '../interfaces/common/IFilterConfig';
+import { IFSGetDataValues } from '../interfaces/common/IFSGetDataValues';
+import { getModel } from '../../services/api/getModel.api';
+import { IModel } from '../../qrvey/interfaces/IModel';
+import { IFUFlattenedFilter } from '../interfaces/ui/IFUFlattenedFilter';
+import { areStaticColumnValues } from '../../qrvey/helpers/areStaticColumnValues';
+import { getValuesFromDataset } from '../helpers/common/getValuesFromDataset';
+import { IFFiltersGetData } from '../interfaces/functions/IFFiltersGetData';
+import { IFUData } from '../interfaces/ui/IFUData';
+import { getDatasetByColumn } from '../../qrvey/helpers/getDatasetByColumn';
+import { getLogicByDatasets } from '../helpers/backend/getLogicByDatasets';
+import { getFiltersByParams } from '../helpers/common/getFiltersByParams';
+
+
+interface IFilterApiConfig extends IFilterConfig {
+  endpoint?: IEndpointConfig;
+  qrveyid: string
+}
+
+export class FiltersApi {
+  // abortCtrl: AbortController;
+  private config: IFilterApiConfig;
+  private chartApi: UChartApi | UChartPaginationApi;
+  private chartPaginationApi;
+
+  constructor(cfg: IFilterApiConfig) {
+    this.setConfig(cfg);
+    this.chartPaginationApi = new UChartPaginationApi();
+    this.chartApi = new UChartApi();
+  }
+
+  /**
+   * Get the model by Qrvey ID
+   * @param qrveyid The Qrvey ID
+   * @returns a promise with the resulting model
+   */
+   getModel(qrveyid?: string): Promise<IModel> {
+    const config = isEmpty(qrveyid) ? { ...this.config } : { ...this.config, qrveyid };
+    return getModel(config, { includeInfo: ['datalinkInfo', 'bucketsInfo', 'formulaInfo', 'componentPreferences'] });
+  }
+
+  /**
+   * Get a dataset list from a collection of Qrvey IDs
+   * @param qrveyids Collection of Qrvey IDs
+   * @returns a promise
+   */
+  public getDatasets(qrveyids: string[]): Promise<IDataset[]> {
+    return getAllDatasets(this.config, qrveyids);
+  }
+
+  // public getAllDataTokens(config): Promise<any> {
+  //   return DataTokensApi.getAll(config);
+  // }
+
+  public getData(config: IFFiltersGetData, resetApi = false): Promise<IFBData> {
+    let promise;
+    if (areStaticColumnValues(config.filter?.column) && isEmpty(config.filter?.column.aggregate)) {
+      promise = getValuesFromDataset({
+        column: config.filter?.column,
+        property: config.filter?.property,
+        lookupDisplay: config.filter?.lookupDisplayIndex,
+        dataset: getDatasetByColumn(config.filter?.column, config.datasets),
+        value: config.valueText,
+      });
+    } else {
+      promise = this.getDataValues(config, resetApi);
+    }
+
+    return promise;
+  }
+
+  /**
+   * Get a promise with a preview of resulting data. Depending on the validator, the endpoint will change.
+   * @param uFilter The Filter Builder Filter
+   * @param filterLogic Additional filter logic to apply in the preview
+   * @param chartSettings
+   * @param resetApi flag to determine when the api should be reseted.
+   * @returns a promise with a preview of resulting data.
+   */
+  private async getDataValues(config: IFSGetDataValues, resetApi = false): Promise<IFBData> {
+    let api: UChartApi | UChartPaginationApi;
+    if (isRangeValidator(config.filter.validator)) {
+      this.chartPaginationApi.afterKey = undefined;
+      api = this.chartApi as UChartApi;
+    } else {
+      api = this.chartPaginationApi as UChartPaginationApi;
+    }
+    return api.getChartResult(this.config, this.getFilter(config), this.getLogic(config), this.getChartRequest(config), resetApi);
+  }
+
+  private getLogic(config: IFSGetDataValues) {
+    const scopes = this.getAvailableScopeIds(config);
+    let filterData = getFiltersByVisibility(config.filterData, scopes);
+    const dataset = config.datasets.find(d => d.qrveyid === config.filter?.column.qrveyid);
+    filterData = getFiltersByParams(filterData, { qrveyid: dataset.qrveyid }, { letPassUndefinedProperties: { filter: true }, filterEmptyArrays: { filter: false } }) as IFUData;
+    filterData = excludeFiltersByAggregateColumn(filterData);
+    const logics = FDToLogic(filterData);
+    const hierarchyLogic = getLogicByScopesHierarchy(logics, scopes, config.filter?.extras.scope);
+  
+    return [
+      ...hierarchyLogic,
+      ...getLogicByDatasets(buildUserFilters(config.userFilters), isEmpty(dataset) ? [] : [dataset.qrveyid]) || [],
+    ];
+  }
+  
+  private getFilter(config: IFSGetDataValues): IFUFlattenedFilter {
+    return { ... config.filter, values: !isEmpty(config.valueText) ? [{ value: config.valueText, enabled: true }] : undefined };
+  }
+  
+  private getChartRequest(config: IFSGetDataValues): IFUChartSettings {
+    const scopes = this.getAvailableScopeIds(config);
+    return applyHierarchyForAggFilters(config.chartRequest, scopes, config.filter?.extras.scope);
+  }
+
+  /**
+  * Gets the available scopes and scope IDs
+  * @returns a collection of the pair Scopes and Scope IDs
+  */
+  private getAvailableScopeIds(config: IFFiltersGetData): IFSScopeID[] {
+    return getAvailableScopes({
+        ...getAvailableScopesIDsByConfig(config),
+        panelid: FILTER_SCOPE.CHART === config.filter?.extras.scope ? config.filter?.extras.scopeid : undefined,
+        scopeid: config.filter?.extras.scopeid,
+        qrveyid: config.filter?.column?.qrveyid,
+        defaultid: config.filter?.column?.qrveyid,
+        scope: undefined,
+        predefinedScopes: [
+          { label: FILTER_SCOPE.DATA, id: config.filter?.column?.qrveyid }
+        ]
+      });
+    }
+
+  /**
+   * Set the config into the Filter Builder Api class
+   * @param config the config.
+   */
+  public setConfig(config: IFilterApiConfig): void {
+    this.config = { ...config };
+  }
+}

package/src/filters/services/UChartApi.ts

@@ -0,0 +1,265 @@
+import { isDateColumn } from '../../columns/helpers/isDateColumn';
+import { isNumericalColumn } from '../../columns/helpers/isNumericalColumn';
+import { isRangeValidator } from '../helpers/common/isRangeValidator';
+import { cloneDeep } from '../../general/object/cloneDeep';
+import { IFBData } from '../interfaces/backend/IFBData';
+import { IFilterConfig } from '../interfaces/common/IFilterConfig';
+import { IFUFlattenedFilter } from '../interfaces/ui/IFUFlattenedFilter';
+import { IFBLogic } from '../interfaces/backend/IFBLogic';
+import { IFUChartSettings } from '../interfaces/ui/IFUChartSettings';
+import { isEmpty } from '../../general/mix/isEmpty';
+import { OLD_IFilterData } from '../interfaces/OLD_IFilterData';
+import { COLUMN } from '../../columns/constants/COLUMN';
+import { getAggFiltersBySummaryIndex } from '../helpers/backend/getAggFiltersBySummaryIndex';
+import { IFUColumn } from '../interfaces/ui/IFUColumn';
+import { _get } from '../../general/object/get';
+import { AGGREGATE } from '../../charts/constants/AGGREGATE';
+import { IFValidator } from '../interfaces/IFValidator';
+import { FILTER_VALIDATOR } from '../constants/common/FILTER_VALIDATOR';
+import { flatUIToOldLogic } from '../adapters/flatUIToOldLogic';
+import ChartsApi from '../../services/api/Charts.api';
+import { IFSValue } from '../interfaces/common/IFSValue';
+import { getAggFilters } from '../helpers/OLD_getAggFilters';
+
+export default class UChartApi {
+
+  /**
+   * Gets a promise with a resulting data
+   * @param config the config
+   * @param uFilter The filter Builder filter
+   * @param filterLogic Additional filter logic to apply in the preview
+   * @param chartSettings The settings of the chart. For Aggregate Columns.
+   * @returns a promise with a resulting data
+   */
+  getChartResult = (config: IFilterConfig, uFilter: IFUFlattenedFilter, filterLogic: IFBLogic[] = [], chartSettings?: IFUChartSettings, _resetApi = false): Promise<IFBData> => {
+    const requestBody = this._getPreviewRequestBody(uFilter, filterLogic, chartSettings);
+    const customChartApi = new ChartsApi({ ...config, qrvey_id: isEmpty(uFilter.column.aggregate) ? uFilter.column.qrveyid : chartSettings?.qrveyid });
+    return customChartApi.getResults(requestBody, false, true).then(response => {
+      return this._getDataFromResponse(response, uFilter);
+    }).catch(_ => {
+      return { data: [] };
+    });
+  };
+
+  /**
+   * Gets request body structure
+   * @param uFilter The filter Builder filter
+   * @param filterLogic Additional filter logic to apply in the preview
+   * @param chartSettings The settings of the chart. For Aggregate Columns.
+   * @returns the request body structure
+   */
+  private _getPreviewRequestBody = (uFilter: IFUFlattenedFilter, filterLogic: IFBLogic[] = [], chartSettings?: IFUChartSettings) => {
+    const { column, validator } = uFilter;
+    const haveAggFilters = (chartSettings?.aggregateColumns || []).length && (chartSettings?.chart || []).length;
+    let searchLogic: OLD_IFilterData;
+    if (!isEmpty(uFilter.values)) {
+        searchLogic = flatUIToOldLogic([ {
+            ...uFilter,
+            validator: this._getValidationType(column, validator),
+            column: { ...uFilter.column, linkid: undefined }
+        }]);
+    }
+    let filterCharts = [];
+    if (haveAggFilters) {
+        filterCharts = chartSettings?.chart.map(chart => {
+          if (uFilter.column.type === COLUMN.AGGREGATED_FORMULA) return chart;
+            const summaryIndex = (chart.summaries || []).findIndex(s => s.questionid === uFilter.column.id && s.aggregate === uFilter.column.aggregate);
+            const summary = summaryIndex !== -1 && chart.summaries[summaryIndex];
+            const chartAggFilters = getAggFiltersBySummaryIndex(chart.aggFilters, summaryIndex);
+            const searchAggFilters = getAggFilters(searchLogic?.logic || [], summary ? [summary] : []);
+
+            return {
+                ...chart,
+                aggFilters: searchAggFilters || chartAggFilters,
+                summaries: summary ? [summary] : []
+            };
+      }).filter(chart => chart.summaries.length);
+    }
+    const chartsBody = !filterCharts[0] ? [this._getChartBody(uFilter)] : [filterCharts[0]];
+    const filters = [
+      ...filterLogic,
+      ...!filterCharts[0] ? searchLogic?.logic || [] : []
+    ];
+    return { charts: chartsBody, logic: filters, qrveyid: column.qrveyid };
+  };
+
+  /**
+   * Gets chart body structure
+   * @param uFilter The filter Builder filter
+   * @param chartSettings The settings of the chart. For Aggregate Columns.
+   * @returns the chart body structure
+   */
+  private _getChartBody = (uFilter: IFUFlattenedFilter, chartSettings?: IFUChartSettings) => {
+    const dimensions = this._getDimensionsBody(uFilter, chartSettings);
+    const summaries = this._getSummariesBody(uFilter);
+
+    return { dimensions, summaries };
+  };
+
+  /**
+   * Gets dimension body structure
+   * @param uFilter The filter Builder filter
+   * @param chartSettings The settings of the chart. For Aggregate Columns.
+   * @returns the dimension body structure
+   */
+  private _getDimensionsBody = (uFilter: IFUFlattenedFilter, chartSettings?: IFUChartSettings) => {
+    const { column, validator } = uFilter;
+
+    let dimensions;
+    if (!isRangeValidator(validator)) {
+      dimensions = [{
+        questionid: column.id,
+        qrveyid: column.qrveyid,
+        // linkid: column.linkid,
+        maxDataPoints: this._getMaxDataPoints(column, chartSettings),
+        type: column.type,
+        formulaType: column.type === 'FORMULA' ? column.formulaType : undefined,
+        sortOption: this._getSortOption(column)
+      }];
+      dimensions = this._refineBodies([ ...dimensions ], uFilter);
+    }
+    return dimensions;
+  };
+
+  /**
+   * Gets max data point number
+   * @param column The column to filter
+   * @param chartSettings The settings of the chart. For Aggregate Columns.
+   * @returns max data point number
+   */
+  private _getMaxDataPoints = (column: IFUColumn, chartSettings?: IFUChartSettings) => {
+    return !isDateColumn(column) && !isEmpty(column.aggregate) ? _get(chartSettings, 'maxDataPoints.option', 1000) : 1000;
+  };
+
+  /**
+   * Gets sort option structure
+   * @param column The column to filter
+   * @returns sort option structure
+   */
+  private _getSortOption = (column: IFUColumn) => {
+    let sortBy = 'CATEGORY';
+    let sortDirection = isNumericalColumn(column) ? 'DESC' : 'ASC';
+    if (!isEmpty(column.sorting)) {
+      sortBy = _get(column.sorting, 'sortBy');
+      sortDirection = _get(column.sorting, 'order');
+      if (sortBy == null) sortBy = 'VALUE';
+      if (sortDirection == null) sortDirection = 'DESC';
+    }
+    return { sortBy, sortDirection };
+  };
+
+  /**
+   * Gets summaries body structure
+   * @param uFilter The filter Builder filter
+   * @returns summaries body structure
+   */
+  private _getSummariesBody = (uFilter: IFUFlattenedFilter) => {
+    const { column, validator } = uFilter;
+
+    const summary = {
+      aggregate: _get(column, 'aggregate.label', AGGREGATE.COUNT),
+      questionid: column.id,
+      property: !isDateColumn(uFilter.column) ? uFilter.property : undefined,
+      type: column.type
+    };
+    let summaries = [ summary ];
+    if (isNumericalColumn(column) || isRangeValidator(validator)) {
+      summaries = [
+        { ...summary, aggregate: AGGREGATE.MIN },
+        { ...summary, aggregate: AGGREGATE.MAX }
+      ];
+    }
+    return summaries;
+  };
+
+  /**
+   * Refines the body structure
+   * @param bodies The body structure
+   * @param uFilter The filter Builder filter
+   * @returns the body structure
+   */
+  private _refineBodies = (bodies: any[], uFilter: IFUFlattenedFilter) => {
+    const _bodies = cloneDeep(bodies);
+    if (uFilter.property != null) {
+      _bodies.forEach(body => {
+        if (isDateColumn(uFilter.column)) {
+          body['groupType'] = 'DATE';
+          body['groupValue'] = uFilter.property.toUpperCase();
+        } else {
+          body['property'] = uFilter.property;
+        }
+      });
+    }
+    return _bodies;
+  };
+
+  /**
+   * Gets the validation type for the preview request
+   * @param column The column to filter
+   * @param vaildator Validator Type
+   * @returns the validator type for the preview request
+   */
+  private _getValidationType = (column: IFUColumn, validator: IFValidator): IFValidator => {
+    if (isDateColumn(column) || column.type === COLUMN.BUCKET || isNumericalColumn(column)) {
+      return FILTER_VALIDATOR.EQUALS;
+    } else {
+      if ([FILTER_VALIDATOR.NOT_CONTAIN, FILTER_VALIDATOR.EQUALS, FILTER_VALIDATOR.NOT_EQUAL].includes(validator)) {
+        return FILTER_VALIDATOR.CONTAINS;
+      } else if (validator === FILTER_VALIDATOR.NOT_END_WITH) {
+        return FILTER_VALIDATOR.ENDS_WITH;
+      } else if (validator === FILTER_VALIDATOR.NOT_START_WITH) {
+        return FILTER_VALIDATOR.STARTS_WITH;
+      } else {
+        return validator;
+      }
+    }
+  };
+
+  /**
+   * Gets the Data from preview Response
+   * @param response The preview presponse
+   * @param uFilter The filter Builder filter
+   * @returns The resulting data
+   */
+  private _getDataFromResponse = (response: any, uFilter: IFUFlattenedFilter): IFBData => {
+    const data = { data: [] };
+    if (isRangeValidator(uFilter.validator)) {
+      data.data = isEmpty(uFilter.column.aggregate)
+        ? _get(response, '[0].summary', []).map(summary => ({ value: summary }))
+        : [{ value: _get(response, '[0].min') }, { value: _get(response, '[0].max') }];
+    } else if (!this.isResultEmpty(response)) {
+      const records = _get(response, 'data');
+      data.data = isEmpty(uFilter.column.aggregate)
+        ? records.map(record => ({
+          value: record.key.toString()
+        }))
+        : this._getResponseSummaries(records);
+    }
+    return data;
+  };
+
+  /**
+   * Gets summaries from preview response
+   * @param records The data from preview response
+   * @param values The values from the preview response
+   * @returns the sumaries
+   */
+  private _getResponseSummaries = (records: any[], values: IFSValue[] = []): IFSValue[] => {
+    records.forEach(record => {
+      const value = record.summary[0].toString();
+      if (Array.isArray(record.items) && record.items.length) values = this._getResponseSummaries(record.items, values);
+      else if (!Array.isArray(record.items) && !isEmpty(values.find(v => v.value === value))) values.push({ value });
+    });
+    return values;
+  };
+
+  private isResultEmpty = (resultObject, validateNesteddata = false): boolean => {
+    const result = _get(resultObject, '[0].data');
+    let validation = isEmpty(result);
+    if (validateNesteddata && !validation) {
+      // Searching empty data when Chart is Multiseries. At least, Chart needs a single item to draw in the serie. (See the second level of the result object)
+      validation = result.every(data => !isEmpty(data) && isEmpty(_get(data, 'items')));
+    }
+    return validation;
+  };
+}