dsl-to-sql 1.0.0-fabric-1p-development.1

package/src/epm-query-builder/base/BaseSuperFilterBuilder.ts

@@ -0,0 +1,627 @@
+import {
+  FilterConfig,
+  SuperFilterConfig,
+  SuperFilterChild,
+  MeasureFilterConfig,
+  RangeFilter,
+  EpmQueryBuilderOptions,
+} from '@epm-query-builder/types/query-builder-types';
+import { SharedFilterBuilder } from '@epm-query-builder/base/SharedFilterBuilder';
+import { BaseUtilities } from '@epm-query-builder/base/BaseUtilities';
+import { FilterValidationError } from '@epm-query-builder/errors/QueryBuilderErrors';
+
+export class BaseSuperFilterBuilder {
+  protected options: EpmQueryBuilderOptions;
+
+  constructor(options: EpmQueryBuilderOptions) {
+    this.options = options;
+  }
+
+  buildWhereClause(): string {
+    if (!this.options.superFilters) {
+      return '';
+    }
+
+    return this.buildNestedFilterGroups(this.options.superFilters);
+  }
+
+  protected buildNestedFilterGroups(superFilters: SuperFilterConfig): string {
+    if (!superFilters.children?.length) {
+      return '';
+    }
+
+    const childConditions = superFilters.children
+      .map((child) => this.buildSuperFilterChild(child))
+      .filter((condition) => condition);
+
+    if (childConditions.length === 0) {
+      return '';
+    }
+
+    const operator = superFilters.condition?.toUpperCase() === 'OR' ? ' OR ' : ' AND ';
+    return childConditions.length === 1
+      ? childConditions[0]
+      : `(${childConditions.join(operator)})`;
+  }
+
+  protected buildSuperFilterChild(child: SuperFilterChild): string {
+    if (child.isGroup && child.children) {
+      const nestedGroup: SuperFilterConfig = {
+        groupId: child.groupId || 'nested',
+        groupLabel: child.groupLabel || 'nested',
+        condition: child.condition || 'AND',
+        children: child.children,
+      };
+      return this.buildNestedFilterGroups(nestedGroup);
+    } else if (child.isFilter && child.filters) {
+      return this.buildFilterCondition(child.filters);
+    } else if (child.filters) {
+      return this.buildFilterCondition(child.filters);
+    }
+    return '';
+  }
+
+  protected buildFilterCondition(filter: FilterConfig): string {
+    if (!filter) return '';
+
+    if (filter.filterType?.toUpperCase() === 'MEASURE') {
+      return this.buildMeasureFilter();
+    }
+
+    if (
+      filter.filterType?.toUpperCase() === 'RANGE' &&
+      Array.isArray(filter.aggregationType) &&
+      filter.aggregationType.length > 0
+    ) {
+      return '';
+    }
+    return SharedFilterBuilder.buildFilterCondition(filter);
+  }
+
+  protected buildValuesFilter(filter: FilterConfig): string {
+    if (filter.isCrossHighlight === true) {
+      return this.buildCrossHighlightFilter(filter);
+    }
+    return SharedFilterBuilder.buildValuesFilter(filter);
+  }
+
+  protected buildRangeFilter(filter: FilterConfig): string {
+    return SharedFilterBuilder.buildRangeFilter(filter);
+  }
+
+  protected buildDateFilter(filter: FilterConfig): string {
+    if (!filter.columnNames?.length || !filter.dateRangeFilter?.length) {
+      return '';
+    }
+
+    const column = filter.columnNames[0];
+    const dateRange = filter.dateRangeFilter[0];
+
+    const startDate = BaseUtilities.formatValue(dateRange.startDate);
+    const endDate = BaseUtilities.formatValue(dateRange.endDate);
+
+    return `${column} BETWEEN ${startDate} AND ${endDate}`;
+  }
+
+  protected buildMeasureFilter(): string {
+    const measureFilters = this.extractMeasureFilters();
+    if (measureFilters.length === 0) {
+      return '';
+    }
+
+    const conditions = measureFilters.map((filter) => this.buildMeasureCondition(filter));
+    return BaseUtilities.combineConditions(
+      conditions.filter((c) => c),
+      'AND',
+    );
+  }
+
+  protected extractMeasureFilters(): MeasureFilterConfig[] {
+    if (!this.options.superFilters?.children) {
+      return [];
+    }
+
+    const measureFilters: MeasureFilterConfig[] = [];
+
+    this.extractMeasureFiltersRecursively(this.options.superFilters.children, measureFilters);
+    return measureFilters;
+  }
+
+  private extractMeasureFiltersRecursively(
+    children: SuperFilterChild[],
+    measureFilters: MeasureFilterConfig[],
+  ): void {
+    children.forEach((child) => {
+      if (child.filters) {
+        const filter = child.filters;
+        const isMeasureFilterType = filter.filterType === 'MEASURE';
+        const isRangeWithAggregation =
+          filter.filterType === 'RANGE' &&
+          Array.isArray(filter.aggregationType) &&
+          filter.aggregationType.length > 0;
+
+        if (isMeasureFilterType || isRangeWithAggregation) {
+          if (filter.rangeFilter?.length) {
+            filter.rangeFilter.forEach((range: RangeFilter) => {
+              const hasFrom =
+                range.from !== undefined && range.from !== null && range.fromCondition;
+              const hasTo = range.to !== undefined && range.to !== null && range.toCondition;
+              const hasLegacyOperator =
+                range.operator &&
+                range.value !== undefined &&
+                range.value !== null &&
+                !hasFrom &&
+                !hasTo;
+
+              if (hasFrom) {
+                measureFilters.push({
+                  id: `${filter.tableNames?.[0]}.${filter.columnNames?.[0]}`,
+                  columnName: filter.columnNames?.[0] || '',
+                  tableName: filter.tableNames?.[0] || '',
+                  aggregationType: filter.aggregationType?.[0],
+                  operator: this.normalizeRangeOperator(range.fromCondition),
+                  value: range.from,
+                  dataType: filter.dataType?.[0] || 'string',
+                  logicalOperator:
+                    hasTo && range.logicalOperator
+                      ? range.logicalOperator
+                      : filter.logicalOperator || 'AND',
+                });
+              }
+
+              if (hasTo) {
+                measureFilters.push({
+                  id: `${filter.tableNames?.[0]}.${filter.columnNames?.[0]}`,
+                  columnName: filter.columnNames?.[0] || '',
+                  tableName: filter.tableNames?.[0] || '',
+                  aggregationType: filter.aggregationType?.[0],
+                  operator: this.normalizeRangeOperator(range.toCondition),
+                  value: range.to,
+                  dataType: filter.dataType?.[0] || 'string',
+                  logicalOperator:
+                    hasFrom && range.logicalOperator
+                      ? range.logicalOperator
+                      : filter.logicalOperator || 'AND',
+                });
+              }
+
+              if (hasLegacyOperator) {
+                measureFilters.push({
+                  id: `${filter.tableNames?.[0]}.${filter.columnNames?.[0]}`,
+                  columnName: filter.columnNames?.[0] || '',
+                  tableName: filter.tableNames?.[0] || '',
+                  aggregationType: filter.aggregationType?.[0],
+                  operator: this.normalizeRangeOperator(range.operator),
+                  value: range.value,
+                  dataType: filter.dataType?.[0] || 'string',
+                  logicalOperator: filter.logicalOperator || 'AND',
+                });
+              }
+            });
+          }
+        }
+      }
+
+      if (child.children) {
+        this.extractMeasureFiltersRecursively(child.children, measureFilters);
+      }
+    });
+  }
+
+  private normalizeRangeOperator(operator: string): string {
+    if (!operator) return 'IS_EQUAL_TO';
+
+    const normalized = operator.toUpperCase().trim();
+
+    switch (normalized) {
+      case 'IS':
+      case 'EQUALS':
+        return 'IS_EQUAL_TO';
+      case 'IS_NOT':
+      case 'NOT_EQUALS':
+        return 'IS_NOT_EQUAL_TO';
+      case 'IS_GREATER_THAN':
+        return 'IS_GREATER_THAN';
+      case 'IS_GREATER_THAN_OR_EQUAL_TO':
+      case 'IS_ON_OR_AFTER':
+        return 'IS_GREATER_THAN_OR_EQUAL_TO';
+      case 'IS_LESS_THAN':
+      case 'IS_BEFORE':
+        return 'IS_LESS_THAN';
+      case 'IS_LESS_THAN_OR_EQUAL_TO':
+      case 'IS_ON_OR_BEFORE':
+        return 'IS_LESS_THAN_OR_EQUAL_TO';
+      case 'IS_BLANK':
+        return 'IS_BLANK';
+      case 'IS_NOT_BLANK':
+        return 'IS_NOT_BLANK';
+      default:
+        return normalized.includes('_') ? normalized : 'IS_EQUAL_TO';
+    }
+  }
+
+  protected buildMeasureCondition(filter: MeasureFilterConfig): string {
+    const measureExpr = filter.aggregationType
+      ? `${filter.aggregationType.toUpperCase()}("${filter.tableName}"."${filter.columnName}")`
+      : `"${filter.tableName}"."${filter.columnName}"`;
+
+    const value = filter.dataType === 'string' ? `'${filter.value}'` : filter.value;
+
+    switch (filter.operator.toUpperCase()) {
+      case 'IS':
+      case 'IS_EQUAL_TO':
+        return `${measureExpr} = ${value}`;
+      case 'IS_NOT':
+      case 'IS_NOT_EQUAL_TO':
+        return `${measureExpr} != ${value}`;
+      case 'IS_GREATER_THAN':
+        return `${measureExpr} > ${value}`;
+      case 'IS_GREATER_THAN_OR_EQUAL_TO':
+        return `${measureExpr} >= ${value}`;
+      case 'IS_LESS_THAN':
+        return `${measureExpr} < ${value}`;
+      case 'IS_LESS_THAN_OR_EQUAL_TO':
+        return `${measureExpr} <= ${value}`;
+      case 'IS_BLANK':
+        return `${measureExpr} IS NULL`;
+      case 'IS_NOT_BLANK':
+        return `${measureExpr} IS NOT NULL`;
+      default:
+        return `${measureExpr} = ${value}`;
+    }
+  }
+
+  protected buildTupleFilter(filter: FilterConfig): string {
+    if (!filter.columnNames?.length || !filter.valuesFilter?.length) {
+      return '';
+    }
+
+    const columns = filter.columnNames;
+    const tupleConditions: string[] = [];
+
+    filter.valuesFilter.forEach((valueItem) => {
+      if (Array.isArray(valueItem.id)) {
+        const tupleValues = valueItem.id
+          .map((id, index) => `${columns[index]} = ${BaseUtilities.formatValue(id.toString())}`)
+          .join(' AND ');
+        tupleConditions.push(`(${tupleValues})`);
+      }
+    });
+
+    const operator = filter.valuesFilterApplicationType === 'INCLUDE' ? 'OR' : 'AND NOT';
+    const result =
+      tupleConditions.length > 0
+        ? tupleConditions.length === 1
+          ? tupleConditions[0]
+          : `(${tupleConditions.join(` ${operator} `)})`
+        : '';
+
+    return filter.isCrossHighlight === true ? this.wrapWithCrossHighlight(result) : result;
+  }
+
+  protected buildSearchFilter(filter: FilterConfig): string {
+    return SharedFilterBuilder.buildSearchFilter(filter);
+  }
+
+  protected buildRankingFilter(filter: FilterConfig): string {
+    return SharedFilterBuilder.buildRankingFilter(filter);
+  }
+
+  protected buildBlankFilter(filter: FilterConfig): string {
+    if (!filter.columnNames?.length || !filter.blankFilterConfig) {
+      return '';
+    }
+
+    const column = filter.columnNames[0];
+    const blankConfig = filter.blankFilterConfig;
+
+    if (blankConfig.operator === 'IS_BLANK') {
+      if (blankConfig.treatEmptyStringAsBlank) {
+        return `(${column} IS NULL OR TRIM(${column}) = '')`;
+      } else {
+        return `${column} IS NULL`;
+      }
+    } else {
+      if (blankConfig.treatEmptyStringAsBlank) {
+        return `(${column} IS NOT NULL AND TRIM(${column}) != '')`;
+      } else {
+        return `${column} IS NOT NULL`;
+      }
+    }
+  }
+
+  protected buildRelativePeriodFilter(filter: FilterConfig): string {
+    if (!filter.columnNames?.length || !filter.relativePeriodFilter) {
+      return '';
+    }
+
+    const tableName =
+      filter.tableNames?.[0] || BaseUtilities.getDefaultTableNameFromOptions(this.options);
+    const column = BaseUtilities.buildColumnReference(tableName, filter.columnNames[0]);
+    return this.buildRelativePeriodCondition(column, filter.relativePeriodFilter);
+  }
+
+  protected buildDateHierarchyFilter(filter: FilterConfig): string {
+    if (!filter.columnNames?.length || !filter.dateHierarchyConfig) {
+      return '';
+    }
+
+    const tableName =
+      filter.tableNames?.[0] || BaseUtilities.getDefaultTableNameFromOptions(this.options);
+    const column = BaseUtilities.buildColumnReference(tableName, filter.columnNames[0]);
+    const hierarchyConfig = filter.dateHierarchyConfig;
+
+    if (!hierarchyConfig.level) {
+      return `${column} IS NOT NULL`;
+    }
+
+    if (!hierarchyConfig.values?.length) {
+      let hierarchyFunction: string;
+      switch (hierarchyConfig.level) {
+        case 'YEAR':
+          hierarchyFunction = `EXTRACT(YEAR FROM ${column})`;
+          break;
+        case 'QUARTER':
+          hierarchyFunction = `EXTRACT(QUARTER FROM ${column})`;
+          break;
+        case 'MONTH':
+          hierarchyFunction = `EXTRACT(MONTH FROM ${column})`;
+          break;
+        case 'DAY':
+          hierarchyFunction = `EXTRACT(DAY FROM ${column})`;
+          break;
+        case 'WEEK':
+          hierarchyFunction = `EXTRACT(WEEK FROM ${column})`;
+          break;
+        case 'DAYOFWEEK':
+          hierarchyFunction = `EXTRACT(DAYOFWEEK FROM ${column})`;
+          break;
+        default:
+          return `${column} IS NOT NULL`;
+      }
+      return `${hierarchyFunction} IS NOT NULL`;
+    }
+
+    let hierarchyFunction: string;
+    switch (hierarchyConfig.level) {
+      case 'YEAR':
+        hierarchyFunction = `EXTRACT(YEAR FROM ${column})`;
+        break;
+      case 'QUARTER':
+        hierarchyFunction = `EXTRACT(QUARTER FROM ${column})`;
+        break;
+      case 'MONTH':
+        hierarchyFunction = `EXTRACT(MONTH FROM ${column})`;
+        break;
+      case 'DAY':
+        hierarchyFunction = `EXTRACT(DAY FROM ${column})`;
+        break;
+      case 'WEEK':
+        hierarchyFunction = `EXTRACT(WEEK FROM ${column})`;
+        break;
+      case 'DAYOFWEEK':
+        hierarchyFunction = `EXTRACT(DAYOFWEEK FROM ${column})`;
+        break;
+      default:
+        throw new FilterValidationError(
+          'DATE_HIERARCHY',
+          `unsupported level: ${hierarchyConfig.level}`,
+          {
+            level: hierarchyConfig.level,
+            supportedLevels: ['YEAR', 'QUARTER', 'MONTH', 'DAY', 'WEEK', 'DAYOFWEEK'],
+          },
+        );
+    }
+
+    if (hierarchyConfig.values.length === 1) {
+      return `${hierarchyFunction} = ${hierarchyConfig.values[0]}`;
+    } else {
+      const valuesList = hierarchyConfig.values.join(', ');
+      return `${hierarchyFunction} IN (${valuesList})`;
+    }
+  }
+
+  protected buildFieldParameterFilter(filter: FilterConfig): string {
+    if (!filter.fieldParameterMapping) {
+      return '';
+    }
+
+    const mapping = filter.fieldParameterMapping;
+    if (!mapping.targetField) {
+      return '';
+    }
+
+    const tableName =
+      mapping.targetTable || BaseUtilities.getDefaultTableNameFromOptions(this.options);
+    const column = BaseUtilities.buildColumnReference(tableName, mapping.targetField);
+
+    if (mapping.filterValues?.length) {
+      if (mapping.filterValues.length === 1) {
+        return `${column} = '${mapping.filterValues[0]}'`;
+      } else {
+        const valuesList = mapping.filterValues.map((v) => `'${v}'`).join(', ');
+        return `${column} IN (${valuesList})`;
+      }
+    }
+
+    return `${column} IS NOT NULL`;
+  }
+
+  protected buildRelativePeriodCondition(
+    column: string,
+    config: { duration: number; period: string; relativeDateFilter: string },
+  ): string {
+    const now = 'CURRENT_DATE';
+    const duration = config.duration;
+    const period = config.period;
+
+    switch (config.relativeDateFilter) {
+      case 'IS_IN_THE_LAST':
+        switch (period) {
+          case 'DAYS':
+            return `${column} >= ${now} - INTERVAL '${duration} days'`;
+          case 'WEEKS':
+            return `${column} >= ${now} - INTERVAL '${duration} weeks'`;
+          case 'MONTHS':
+            return `${column} >= ${now} - INTERVAL '${duration} months'`;
+          case 'YEARS':
+            return `${column} >= ${now} - INTERVAL '${duration} years'`;
+          default:
+            return `${column} >= ${now} - INTERVAL '${duration} days'`;
+        }
+      case 'IS_IN_THE_NEXT':
+        switch (period) {
+          case 'DAYS':
+            return `${column} <= ${now} + INTERVAL '${duration} days'`;
+          case 'WEEKS':
+            return `${column} <= ${now} + INTERVAL '${duration} weeks'`;
+          case 'MONTHS':
+            return `${column} <= ${now} + INTERVAL '${duration} months'`;
+          case 'YEARS':
+            return `${column} <= ${now} + INTERVAL '${duration} years'`;
+          default:
+            return `${column} <= ${now} + INTERVAL '${duration} days'`;
+        }
+      case 'IS_IN_THIS':
+        switch (period) {
+          case 'DAYS':
+            return `DATE_TRUNC('day', ${column}) = DATE_TRUNC('day', ${now})`;
+          case 'WEEKS':
+            return `DATE_TRUNC('week', ${column}) = DATE_TRUNC('week', ${now})`;
+          case 'MONTHS':
+            return `DATE_TRUNC('month', ${column}) = DATE_TRUNC('month', ${now})`;
+          case 'YEARS':
+            return `DATE_TRUNC('year', ${column}) = DATE_TRUNC('year', ${now})`;
+          default:
+            return `DATE_TRUNC('day', ${column}) = DATE_TRUNC('day', ${now})`;
+        }
+      default:
+        return `${column} = ${now}`;
+    }
+  }
+
+  private wrapWithCrossHighlight(condition: string): string {
+    return condition;
+  }
+
+  private buildCrossHighlightFilter(filter: FilterConfig): string {
+    if (!filter.columnNames?.length || !filter.valuesFilter?.length) {
+      return '';
+    }
+
+    const column = filter.columnNames[0];
+    const values = filter.valuesFilter
+      .flatMap((vf) => (Array.isArray(vf.id) ? vf.id : [vf.id]))
+      .filter((v) => v !== undefined);
+    const valueList = values.map((v) => BaseUtilities.formatValue(v.toString())).join(',');
+
+    return `${column} IN (${valueList})`;
+  }
+
+  protected calculateTopNValue(value: number, totalCount: number, isPercentage: boolean): number {
+    if (totalCount === 0 || !isPercentage) {
+      return value;
+    }
+    return Math.floor((value * totalCount) / 100);
+  }
+
+  protected calculateDistinctRowsCount(filter: FilterConfig, defaultCount: number): number {
+    if (filter.distinctRowsCount && filter.distinctRowsCount > 0) {
+      return filter.distinctRowsCount;
+    }
+
+    if (this.options.superFilters?.children) {
+      for (const child of this.options.superFilters.children) {
+        if (Array.isArray(child.filters) && child.filters.length > 0) {
+          const firstFilter = child.filters[0];
+          if (firstFilter.distinctRowsCount && firstFilter.distinctRowsCount > 0) {
+            return firstFilter.distinctRowsCount;
+          }
+        }
+      }
+    }
+
+    return defaultCount;
+  }
+
+  protected extractFilters(): {
+    columnName: string;
+    values: string[];
+    applicationType: string;
+  }[] {
+    if (!this.options.superFilters?.children) {
+      return [];
+    }
+
+    const filters: {
+      columnName: string;
+      values: string[];
+      applicationType: string;
+    }[] = [];
+
+    this.options.superFilters.children.forEach((child) => {
+      const filter = child.filters;
+      if (!filter) return;
+
+      switch (filter.filterType) {
+        case 'VALUES':
+          if (filter.columnNames?.length > 0) {
+            const columnName = filter.columnNames[0];
+            const values =
+              filter.valuesFilter
+                ?.flatMap((vf) => (Array.isArray(vf.id) ? vf.id : [vf.id]))
+                .filter((v) => v !== undefined) || [];
+            const applicationType = filter.valuesFilterApplicationType || 'include';
+
+            filters.push({
+              columnName,
+              values,
+              applicationType,
+            });
+          }
+          break;
+        case 'RANGE':
+          break;
+        case 'DATE':
+          break;
+        default:
+          break;
+      }
+    });
+
+    return filters;
+  }
+
+  protected applyLogicalOperator(conditions: string[], filter: FilterConfig): string {
+    if (!conditions.length) return '';
+    if (conditions.length === 1) return conditions[0];
+
+    const logicalOp = filter.logicalOperator?.toUpperCase() === 'OR' ? 'OR' : 'AND';
+    return conditions.join(` ${logicalOp} `);
+  }
+
+  protected handleTupleFilter(filter: FilterConfig): boolean {
+    return Boolean(filter.isTupleFilter || (filter.columnIds && filter.columnIds.length > 1));
+  }
+
+  protected handleCrossHighlight(filter: FilterConfig): boolean {
+    return Boolean(filter.isCrossHighlight);
+  }
+
+  protected validateDataTypes(filter: FilterConfig): boolean {
+    if (!filter.dataType?.length || !filter.columnDataType?.length) {
+      return true;
+    }
+    return filter.dataType.every((type) =>
+      ['string', 'number', 'date', 'boolean'].includes(type.toLowerCase()),
+    );
+  }
+
+  protected processSourceTypes(filter: FilterConfig): string[] {
+    return filter.sourceType || [];
+  }
+
+  protected isRankingFilterEnabled(filter: FilterConfig): boolean {
+    return Boolean(filter.isRankingFilter || filter.rankingConfig);
+  }
+}