rez_core 3.1.164 → 3.1.165

package/src/module/filter/service/filter.service.ts

@@ -1,841 +1,841 @@
-import { BadRequestException, Inject, Injectable } from '@nestjs/common';
-import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
-import { EntityMasterService } from 'src/module/meta/service/entity-master.service';
-import { EntityTableColumnService } from 'src/module/meta/service/entity-table-column.service';
-import { EntityTableService } from 'src/module/meta/service/entity-table.service';
-import { DataSource } from 'typeorm';
-import { FilterCondition, FilterRequestDto } from '../dto/filter-request.dto';
-import { SavedFilterService } from './saved-filter.service';
-
-import * as moment from 'moment';
-import { EntityRelationService } from 'src/module/meta/service/entity-relation.service';
-import { ResolverService } from 'src/module/meta/service/resolver.service';
-import { LoggingService } from 'src/utils/service/loggingUtil.service';
-
-@Injectable()
-export class FilterService {
-  constructor(
-    private dataSource: DataSource,
-    private readonly attributeMasterService: AttributeMasterService,
-    private readonly entityMasterService: EntityMasterService,
-    @Inject('SavedFilterService')
-    private readonly savedFilterService: SavedFilterService,
-    @Inject('EntityRelationService')
-    private readonly entityRelationService: EntityRelationService,
-    private readonly resolverService: ResolverService,
-    @Inject() protected readonly loggingService: LoggingService,
-  ) {}
-  private readonly skipAppCodeFilterEntities = ['ORGP'];
-  private readonly skipOrgFilterEntities = ['ORGP'];
-
-  private async gettab_value_counts(
-    tableName: string,
-    column: string | undefined,
-    whereClauses: { query: string; params: Record<string, any> }[],
-  ) {
-    if (!column) return [];
-
-    let whereSQL = '';
-    const values: any[] = [];
-
-    // Convert whereClauses to SQL
-    if (whereClauses.length > 0) {
-      const clauseParts = whereClauses.map((clause) => {
-        let parsedQuery = clause.query.replace(/\be\./g, ''); // removes e. prefix
-        Object.entries(clause.params).forEach(([key, val]) => {
-          parsedQuery = parsedQuery.replace(new RegExp(`:${key}`, 'g'), '?');
-          values.push(val);
-        });
-        return parsedQuery;
-      });
-
-      whereSQL = `WHERE ${clauseParts.join(' AND ')}`;
-    }
-
-    // Construct raw SQL
-    const rawSQL = `
-  SELECT ${column} AS tab_value, COUNT(*) AS tab_value_count
-  FROM ${tableName}
-  ${whereSQL}
-  GROUP BY ${column}
-`;
-
-    const rows = await this.dataSource.query(rawSQL, values);
-
-    const total = rows.reduce(
-      (sum, r) => sum + parseInt(r.tab_value_count, 10),
-      0,
-    );
-
-    return [
-      { tab_value: 'All', tab_value_count: total },
-      ...rows.map((r) => ({
-        tab_value: r.tab_value ?? 'UNKNOWN',
-        tab_value_count: parseInt(r.tab_value_count, 10),
-      })),
-    ];
-  }
-
-  async applyFilterWrapper(dto: FilterRequestDto) {
-    const {
-      entity_type,
-      quickFilter = [],
-      savedFilterCode,
-      attributeFilter = [],
-      loggedInUser,
-    } = dto;
-  
-  
-    // 🔹 Step 1: Collect all filters (from body + savedFilter)
-    const savedFilters = await this.getSavedFilters(savedFilterCode ?? undefined);
-    const allFilters = [...quickFilter, ...attributeFilter, ...savedFilters].filter(
-      (f) => f.filter_value !== '',
-    );
-
-  
-    // 🔹 Step 2: Group filters by filter_entity_type
-    const grouped = allFilters.reduce(
-      (acc, f) => {
-        if (!acc[f.filter_entity_type]) acc[f.filter_entity_type] = [];
-        acc[f.filter_entity_type].push(f);
-        return acc;
-      },
-      {} as Record<string, any[]>,
-    );
-  
-    console.log('🟠 [FilterService] Grouped filters by entity type:', grouped);
-  
-    // 🔹 Step 3: Handle sub-entities first
-    let intersectionIds: number[] | null = null;
-    for (const [subEntityType, filters] of Object.entries(grouped)) {
-      if (subEntityType === entity_type) continue; // skip main entity for now
-  
-      let { queryParams, tabs, ...newDto } = dto;
-  
-      const subDto: FilterRequestDto = {
-        ...newDto,
-        entity_type: subEntityType,
-        quickFilter: filters as FilterCondition[],
-        savedFilterCode: null, // already merged
-        attributeFilter: [],
-      };
-  
-      const subResult = await this.applyFilter(subDto);
-      const subEntityIds = subResult.data.entity_list.map((row) => row.id);
-  
-      console.log(`🧩 [FilterService] Sub-entity ${subEntityType} returned IDs:`, subEntityIds);
-  
-      if (!subEntityIds.length) {
-        console.log(`ℹ️ [FilterService] No records for sub-entity ${subEntityType}, returning empty result`);
-        return {
-          success: true,
-          data: { entity_tabs: [], entity_list: [], pagination: {} },
-        };
-      }
-  
-      const relatedIds = await this.entityRelationService.getRelatedEntityIds(
-        entity_type,
-        subEntityType,
-        subEntityIds,
-        dto.loggedInUser.organization_id,
-      );
-  
-      intersectionIds =
-        intersectionIds === null
-          ? relatedIds
-          : intersectionIds.filter((id) => relatedIds.includes(id));
-  
-
-      if (intersectionIds.length === 0) {
-        console.log('🚫 [FilterService] No intersection IDs left, returning empty result');
-        return {
-          success: true,
-          data: { entity_tabs: [], entity_list: [], pagination: {} },
-        };
-      }
-    }
-  
-    // 🔹 Step 4: Call applyFilter for main entity
-    const mainFilters = grouped[entity_type] || [];
-    const mainDto: FilterRequestDto = {
-      ...dto,
-      quickFilter: [...mainFilters],
-      savedFilterCode: null,
-      attributeFilter: [],
-    };
-  
-    if (intersectionIds && intersectionIds.length > 0) {
-      (mainDto.quickFilter ??= []).push({
-        filter_attribute: 'id',
-        filter_operator: 'equal',
-        filter_value: intersectionIds,
-        filter_entity_type: entity_type,
-      });
-    }
-  
-    return this.applyFilter(mainDto);
-  }
-  
-  async applyFilter(dto: FilterRequestDto) {
-    const {
-      entity_type,
-      quickFilter,
-      savedFilterCode,
-      attributeFilter,
-      tabs,
-      sortby,
-      loggedInUser,
-      queryParams,
-      customLevelType,
-      customLevelId,
-      customAppCode,
-    } = dto;
-  
-    // abstract user details
-    const {
-      level_type,
-      level_id,
-      id: user_id,
-      appcode,
-      organization_id,
-    } = loggedInUser || {};
-  
-    // Fetch meta from entity table service
-    const entityMeta = await this.entityMasterService.getEntityData(
-      entity_type,
-      loggedInUser,
-    );
-    const tableName = entityMeta?.data_source; // data_source is the table name
-  
-    if (!tableName) {
-      console.error(`❌ [FilterService] Invalid entity_type: ${entity_type}`);
-      throw new BadRequestException(`Invalid entity_type: ${entity_type}`);
-    }
-  
-    const getAttributeColumnMeta =
-      await this.attributeMasterService.findAttributesByMappedEntityType(
-        entity_type,
-        loggedInUser,
-      );
-  
-    const attributeMetaMap = getAttributeColumnMeta.reduce(
-      (acc, attr) => {
-        acc[attr.attribute_key] = attr;
-        return acc;
-      },
-      {} as Record<string, any>,
-    );
-  
-    // Get and parse saved filters
-    const savedFilters = await this.getSavedFilters(
-      savedFilterCode ?? undefined,
-    );
-    const savedFiltersNormalized = savedFilters.map((f) => ({
-      filter_attribute: f.filter_attribute,
-      filter_operator: f.filter_operator,
-      filter_value: f.filter_value,
-    }));
-
-    const baseFilters = [
-      ...(quickFilter || []).filter(
-        (f) => f.filter_value != null && f.filter_value !== '',
-      ),
-      ...savedFiltersNormalized.filter(
-        (f) => f.filter_value != null && f.filter_value !== '',
-      ),
-      ...(attributeFilter || []).filter(
-        (f) => f.filter_value != null && f.filter_value !== '',
-      ),
-    ];
-  
-  
-    // Build where clauses
-    const baseWhere = this.buildWhereClauses(baseFilters, attributeMetaMap);
-  
-    // check level_id and level_type
-    if (
-      entity_type != 'ORGP' &&
-      level_type &&
-      level_id &&
-      organization_id &&
-      !customLevelType &&
-      !customLevelId
-    ) {
-      baseWhere.push({
-        query:
-          'e.organization_id = :organization_id AND e.level_type = :level_type AND e.level_id = :level_id',
-        params: { organization_id, level_type, level_id },
-      });
-    }
-  
-    if (customLevelType && customLevelId && customAppCode) {
-      baseWhere.push({
-        query:
-          'e.organization_id = :organization_id AND e.level_type = :customLevelType AND e.level_id = :customLevelId AND e.appcode = :customAppCode',
-        params: { organization_id, customLevelType, customLevelId, customAppCode },
-      });
-    }
-  
-    // Handle queryParams filters
-    if (queryParams) {
-      Object.entries(queryParams).forEach(([key, value]) => {
-        if (!value) return;
-  
-        if (key === 'attributeName' && queryParams['attributeValue']) {
-          const attrName = value;
-          const attrValue = queryParams['attributeValue'];
-          baseWhere.push({
-            query: `e.${attrName} = :${attrName}`,
-            params: { [attrName]: attrValue },
-          });
-        } else if (key !== 'attributeValue') {
-          baseWhere.push({
-            query: `e.${key} = :${key}`,
-            params: { [key]: value },
-          });
-        }
-      });
-    }
-  
-    console.log('🟠 [FilterService] Constructed baseWhere clauses:', baseWhere);
-  
-    // layout preference query
-    const layoutPreference = await this.dataSource.query(
-      `SELECT mapped_json 
-       FROM cr_entity_layout_pref
-       WHERE user_id = ? AND mapped_entity_type = ? AND mapped_level_id = ? AND mapped_level_type = ? AND type = 'layout'`,
-      [user_id, entity_type, level_id, level_type],
-    );
-  
-    // Extract layout preference
-    const layout = layoutPreference?.[0]?.mapped_json?.quick_tab || {};
-    const showList = layout?.show_list?.map((val) => val.toLowerCase()) || [];
-  
-    let allTabs;
-    if (layout.attribute) {
-      allTabs = await this.gettab_value_counts(
-        entityMeta?.data_source,
-        layout.attribute,
-        baseWhere,
-      );
-    } else {
-      allTabs = await this.gettab_value_counts(
-        entityMeta?.data_source,
-        tabs?.columnName,
-        baseWhere,
-      );
-    }
-
-    let filteredTabs;
-  
-    if (showList?.length > 0) {
-      const isAllNeeded = layout?.isAllSelected && !showList.includes('all');
-      if (isAllNeeded) showList.push('all');
-  
-      filteredTabs = allTabs.filter((tab) =>
-        showList.includes(tab.tab_value.toLowerCase()),
-      );
-  
-      const allTab = filteredTabs.find(
-        (tab) => tab.tab_value?.toLowerCase() === 'all',
-      );
-      filteredTabs = filteredTabs.filter(
-        (tab) => tab.tab_value?.toLowerCase() !== 'all',
-      );
-  
-      // SORTING LOGIC
-      if (layout.sorting === 'asc') {
-        filteredTabs.sort((a, b) =>
-          a.tab_value.toLowerCase().localeCompare(b.tab_value.toLowerCase()),
-        );
-      } else if (layout.sorting === 'dsc') {
-        filteredTabs.sort((a, b) =>
-          b.tab_value.toLowerCase().localeCompare(a.tab_value.toLowerCase()),
-        );
-      } else if (layout.sorting === 'count_asc') {
-        filteredTabs.sort((a, b) => a.tab_value_count - b.tab_value_count);
-      } else if (layout.sorting === 'count_dsc') {
-        filteredTabs.sort((a, b) => b.tab_value_count - a.tab_value_count);
-      } else if (layout.sorting === 'custom') {
-        const orderMap = new Map<string, number>(
-          showList.map((val, index) => [val.toLowerCase(), index]),
-        );
-        filteredTabs.sort((a, b) => {
-          const aIndex = orderMap.get(a.tab_value.toLowerCase()) ?? Infinity;
-          const bIndex = orderMap.get(b.tab_value.toLowerCase()) ?? Infinity;
-          return aIndex - bIndex;
-        });
-      }
-  
-      if (allTab) filteredTabs.unshift(allTab);
-  
-      if (layout?.isCombineOther) {
-        const originalAllTab = allTabs.find(
-          (tab) => tab.tab_value.toLowerCase() === 'all',
-        );
-        const allCount = originalAllTab?.tab_value_count ?? 0;
-        const knownTabCountSum = filteredTabs
-          .filter((tab) => tab.tab_value.toLowerCase() !== 'all')
-          .reduce((acc, tab) => acc + tab.tab_value_count, 0);
-  
-        const othersCount = allCount - knownTabCountSum;
-        filteredTabs.push({
-          tab_value: 'OTHERS',
-          tab_value_count: othersCount < 0 ? 0 : othersCount,
-        });
-      }
-    } else {
-      filteredTabs = allTabs;
-    }
-  
-  
-    const dataWhere = [...baseWhere];
-  
-    if (tabs?.columnName && tabs?.value) {
-      const tabAttrMeta = attributeMetaMap[tabs.columnName];
-      const tabValue = tabs.value.toLowerCase();
-  
-      if (tabValue === 'others') {
-        const valuesToExclude = showList.filter((v) => v !== 'all');
-        if (valuesToExclude.length > 0) {
-          for (const value of valuesToExclude) {
-            const resolvedId = await this.resolverService.getResolvedId(
-              loggedInUser,
-              tabs.columnName,
-              value,
-              entity_type,
-            );
-            if (resolvedId) {
-              const tabCondition = this.buildCondition(
-                {
-                  filter_attribute: tabs.columnName,
-                  filter_operator: 'not_equal',
-                  filter_value: [resolvedId],
-                  skip_id: true,
-                },
-                tabAttrMeta,
-              );
-              if (tabCondition) dataWhere.push(tabCondition);
-            }
-          }
-        }
-      } else if (tabValue !== 'all') {
-        const resolvedId = await this.resolverService.getResolvedId(
-          loggedInUser,
-          tabs.columnName,
-          tabs.value,
-          entity_type,
-        );
-  
-        if (resolvedId) {
-          const tabCondition = this.buildCondition(
-            {
-              filter_attribute: tabs.columnName,
-              filter_operator: 'equal',
-              filter_value: [resolvedId],
-              skip_id: true,
-            },
-            tabAttrMeta,
-          );
-          if (tabCondition) dataWhere.push(tabCondition);
-        }
-      }
-    }
-  
-    const qb = this.dataSource.createQueryBuilder().select('e.*').from(tableName, 'e');
-    dataWhere.forEach((clause) => qb.andWhere(clause.query, clause.params));
-  
-    if (layoutPreference && layoutPreference[0]?.mapped_json?.sorting) {
-      if (Array.isArray(layoutPreference[0]?.mapped_json?.sorting?.tabs)) {
-        const preferenceTabArray = layoutPreference[0]?.mapped_json?.sorting?.tabs;
-        const tabFilter = preferenceTabArray.find(
-          (tabData) => tabData.tab_name === tabs?.value,
-        );
-        tabFilter?.sortby.forEach(({ column, order }) => {
-          qb.addOrderBy(`e.${column}`, order?.toUpperCase() === 'DSC' ? 'DESC' : 'ASC');
-        });
-      } else if (Array.isArray(layoutPreference[0]?.mapped_json?.sorting?.sortby)) {
-        layoutPreference[0]?.mapped_json?.sorting?.sortby?.forEach(({ column, order }) => {
-          qb.addOrderBy(`e.${column}`, order?.toUpperCase() === 'DSC' ? 'DESC' : 'ASC');
-        });
-      }
-    }
-  
-    qb.addOrderBy('e.created_date', 'DESC');
-  
-    const page = dto.page && dto.page > 0 ? dto.page : 1;
-    const size = dto.size && dto.size > 0 ? dto.size : 10;
-    qb.skip((page - 1) * size).take(size);
-  
-    const entity_list = await qb.getRawMany();
-  
-    console.log(`📦 [FilterService] Fetched ${entity_list.length} records`);
-  
-    const dateAttributes = Object.entries(attributeMetaMap)
-      .filter(([_, attr]) => attr.data_type === 'date')
-      .map(([key]) => key);
-  
-    const formatDate = (dateStr: string | null): string | null =>
-      dateStr ? moment(dateStr).format('DD-MM-YYYY') : '';
-  
-    const formatDatesInRow = (row: any): any => {
-      const formattedRow = { ...row };
-      for (const key of dateAttributes) {
-        if (formattedRow[key]) formattedRow[key] = formatDate(formattedRow[key]);
-      }
-      return formattedRow;
-    };
-  
-    const formattedEntityList = entity_list.map(formatDatesInRow);
-  
-    const resolvedEntityList = await Promise.all(
-      formattedEntityList.map((row) =>
-        this.resolverService.getResolvedData(loggedInUser, row, entity_type),
-      ),
-    );
-
-    const resolvedTabs = await Promise.all(
-      filteredTabs.map(async (tab) => {
-        const tabAttrKey = layout?.attribute || tabs?.columnName;
-  
-        if (
-          !tabAttrKey ||
-          tab.tab_value?.toLowerCase() === 'all' ||
-          tab.tab_value?.toLowerCase() === 'others'
-        ) {
-          return tab;
-        }
-  
-        const resolvedVal = await this.resolverService.getResolvedValue(
-          loggedInUser,
-          tabAttrKey,
-          tab.tab_value,
-          entity_type,
-        );
-  
-        return { ...tab, tab_value: resolvedVal ?? tab.tab_value };
-      }),
-    );
-  
-  
-    const countQb = this.dataSource
-      .createQueryBuilder()
-      .select('COUNT(*)', 'count')
-      .from(tableName, 'e');
-    dataWhere.forEach((clause) => countQb.andWhere(clause.query, clause.params));
-    const countResult = await countQb.getRawOne();
-    const total = parseInt(countResult.count, 10);
-  
-    console.log('📊 [FilterService] Returning final result with total:', total);
-  
-    return {
-      success: true,
-      data: {
-        entity_tabs: resolvedTabs,
-        entity_list: resolvedEntityList,
-        pagination: {
-          total,
-          page,
-          size,
-          totalPages: Math.ceil(total / size),
-          hasNextPage: page * size < total,
-          hasPreviousPage: page > 1,
-        },
-      },
-    };
-  }
-  
-  private parseFilters(raw: any, isSingle = false): any[] {
-    if (!raw) return [];
-
-    if (typeof raw === 'string') {
-      try {
-        const parsed = JSON.parse(raw);
-        return isSingle ? [parsed] : parsed;
-      } catch {
-        throw new BadRequestException('Invalid JSON in filter input');
-      }
-    }
-
-    return isSingle ? [raw] : Array.isArray(raw) ? raw : [];
-  }
-
-  private async getSavedFilters(code?: string): Promise<any[]> {
-    if (!code) return [];
-
-    const savedFilter = await this.savedFilterService.getDetailsByCode(code);
-    if (!savedFilter) {
-      throw new BadRequestException(`Saved filter not found for code: ${code}`);
-    }
-    return savedFilter;
-  }
-
-  private buildWhereClauses(
-    filters: any[],
-    attributeMeta: Record<string, any>,
-  ) {
-    return filters
-      .map((f) => this.buildCondition(f, attributeMeta[f.filter_attribute]))
-      .filter(
-        (clause): clause is { query: string; params: any } => clause !== null,
-      );
-  }
-
-  private buildCondition(
-    filter: any,
-    meta: any,
-  ): { query: string; params: any } | null {
-    if (!meta) return null;
-
-    let attr = filter.filter_attribute;
-    const val = filter.filter_value;
-    const op = filter.filter_operator;
-    const key = `param_${attr}_${Math.random().toString(36).substring(2, 8)}`;
-
-    // if (
-    //   (meta.data_source_type === 'entity' ||
-    //     meta.data_source_type === 'master') &&
-    //   !filter.skip_id
-    // ) {
-    //   attr = `${attr}_id`;
-    // }
-
-    switch (meta.data_type) {
-      case 'text':
-        return this.buildTextCondition(attr, op, val, key);
-      case 'number':
-        return this.buildNumberCondition(attr, op, val, key);
-      case 'date':
-        return this.buildDateCondition(attr, op, val, key);
-      case 'select':
-        return this.buildMultiSelectCondition(attr, op, val, key);
-      case 'multiselect':
-        return this.buildMultiSelectCondition(attr, op, val, key);
-      case 'checkbox':
-        return this.buildMultiSelectCondition(attr, op, val, key);
-      case 'radio':
-        return this.buildMultiSelectCondition(attr, op, val, key);
-      case 'year':
-        return this.buildYearCondition(attr, op, val, key);
-      default:
-        return null;
-    }
-  }
-
-  private buildTextCondition(attr: string, op: string, val: any, key: string) {
-    switch (op) {
-      case 'contains':
-        return {
-          query: `LOWER(e.${attr}) LIKE :${key}`,
-          params: { [key]: `%${val ? val.toLowerCase() : ''}%` },
-        };
-      case 'equal':
-        return {
-          query: `e.${attr} = :${key}`,
-          params: { [key]: val },
-        };
-      case 'not_equal':
-        return {
-          query: `e.${attr} != :${key}`,
-          params: { [key]: val },
-        };
-      case 'empty':
-        return {
-          query: `e.${attr} IS NULL`,
-          params: {},
-        };
-      case 'not_empty':
-        return {
-          query: `e.${attr} IS NOT NULL`,
-          params: {},
-        };
-      default:
-        throw new BadRequestException(`Unsupported operator for text: ${op}`);
-    }
-  }
-
-  private buildNumberCondition(
-    attr: string,
-    op: string,
-    val: any,
-    key: string,
-  ) {
-    switch (op) {
-      case 'equal':
-        return { query: `e.${attr} = :${key}`, params: { [key]: val } };
-      case 'not_equal':
-        return { query: `e.${attr} != :${key}`, params: { [key]: val } };
-      case 'greater_than':
-        return { query: `e.${attr} > :${key}`, params: { [key]: val } };
-      case 'less_than':
-        return { query: `e.${attr} < :${key}`, params: { [key]: val } };
-      case 'less_than_qual_to':
-        return { query: `e.${attr} <= :${key}`, params: { [key]: val } };
-      case 'greater_than_qual_to':
-        return { query: `e.${attr} >= :${key}`, params: { [key]: val } };
-      case 'empty':
-        return { query: `e.${attr} IS NULL`, params: {} };
-      case 'not_empty':
-        return { query: `e.${attr} IS NOT NULL`, params: {} };
-
-      default:
-        throw new BadRequestException(`Unsupported operator for number: ${op}`);
-    }
-  }
-
-  private buildDateCondition(attr: string, op: string, val: any, key: string) {
-    switch (op) {
-      case 'equal':
-        return { query: `e.${attr} = :${key}`, params: { [key]: val } };
-      case 'before':
-        return { query: `e.${attr} < :${key}`, params: { [key]: val } };
-      case 'after':
-        return { query: `e.${attr} > :${key}`, params: { [key]: val } };
-      case 'between': {
-        if (typeof val === 'string') {
-          val = val.split(',').map((v) => v.trim());
-        }
-
-        if (
-          !Array.isArray(val) ||
-          val.length !== 2 ||
-          val[0] === '' ||
-          val[1] === ''
-        ) {
-          // throw new BadRequestException(`Invalid value for in_between: ${val}`);
-          console.log(`Invalid value for in_between: ${val}`);
-          return null;
-        }
-        return {
-          query: `e.${attr} BETWEEN :${key}_start AND :${key}_end`,
-          params: {
-            [`${key}_start`]: val[0],
-            [`${key}_end`]: val[1],
-          },
-        };
-      }
-
-      case 'today': {
-        const today = new Date().toISOString().split('T')[0]; // 'YYYY-MM-DD'
-
-        return {
-          query: `DATE(e.${attr}) = :today`,
-          params: {
-            today,
-          },
-        };
-      }
-
-      case 'empty': {
-        return {
-          query: `e.${attr} IS NULL`,
-          params: {},
-        };
-      }
-
-      case 'not_empty': {
-        return {
-          query: `e.${attr} IS NOT NULL`,
-          params: {},
-        };
-      }
-      default:
-        throw new BadRequestException(`Unsupported operator for date: ${op}`);
-    }
-  }
-
-  private buildSelectCondition(
-    attr: string,
-    op: string,
-    val: any,
-    key: string,
-  ) {
-    switch (op) {
-      case 'equal':
-        return { query: `e.${attr} = :${key}`, params: { [key]: val } };
-      case 'not_equal':
-        return { query: `e.${attr} != :${key}`, params: { [key]: val } };
-      case 'empty':
-        return { query: `e.${attr} IS NULL`, params: {} };
-      case 'not_empty':
-        return { query: `e.${attr} IS NOT NULL`, params: {} };
-      default:
-        throw new BadRequestException(`Unsupported operator for select: ${op}`);
-    }
-  }
-
-  private buildMultiSelectCondition(
-    attr: string,
-    op: string,
-    val: any,
-    key: string,
-  ) {
-    if (Array.isArray(val) && val.length === 0) {
-      return { query: '1=1', params: {} };
-    }
-
-    if ((op === 'equal' || op === 'not_equal') && !Array.isArray(val)) {
-      throw new BadRequestException(
-        `Value for multi-select must be an array for operator: ${op}`,
-      );
-    }
-
-    switch (op) {
-      case 'equal':
-        return {
-          query: `e.${attr} IN (:${key})`,
-          params: { [key]: val },
-        };
-      case 'not_equal':
-        return {
-          query: `e.${attr} NOT IN (:${key})`,
-          params: { [key]: val },
-        };
-      case 'contains':
-        return {
-          query: `e.${attr} LIKE :${key}`,
-          params: { [key]: `%${val}%` },
-        };
-      case 'not_contains':
-        return {
-          query: `e.${attr} NOT LIKE :${key}`,
-          params: { [key]: `%${val}%` },
-        };
-      case 'empty':
-        return { query: `e.${attr} IS NULL`, params: {} };
-      case 'not_empty':
-        return { query: `e.${attr} IS NOT NULL`, params: {} };
-      default:
-        throw new BadRequestException(
-          `Unsupported operator for multiselect: ${op}`,
-        );
-    }
-  }
-
-  private buildYearCondition(attr: string, op: string, val: any, key: string) {
-    switch (op) {
-      case 'equal':
-        return {
-          query: `e.${attr} = :${key}`,
-          params: { [key]: parseInt(val, 10) },
-        };
-      case 'not_equal':
-        return {
-          query: `e.${attr} != :${key}`,
-          params: { [key]: parseInt(val, 10) },
-        };
-      case 'greater_than':
-        return {
-          query: `e.${attr} > :${key}`,
-          params: { [key]: parseInt(val, 10) },
-        };
-      case 'less_than':
-        return {
-          query: `e.${attr} < :${key}`,
-          params: { [key]: parseInt(val, 10) },
-        };
-      default:
-        throw new BadRequestException(`Unsupported operator for year: ${op}`);
-    }
-  }
-}
+import { BadRequestException, Inject, Injectable } from '@nestjs/common';
+import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
+import { EntityMasterService } from 'src/module/meta/service/entity-master.service';
+import { EntityTableColumnService } from 'src/module/meta/service/entity-table-column.service';
+import { EntityTableService } from 'src/module/meta/service/entity-table.service';
+import { DataSource } from 'typeorm';
+import { FilterCondition, FilterRequestDto } from '../dto/filter-request.dto';
+import { SavedFilterService } from './saved-filter.service';
+
+import * as moment from 'moment';
+import { EntityRelationService } from 'src/module/meta/service/entity-relation.service';
+import { ResolverService } from 'src/module/meta/service/resolver.service';
+import { LoggingService } from 'src/utils/service/loggingUtil.service';
+
+@Injectable()
+export class FilterService {
+  constructor(
+    private dataSource: DataSource,
+    private readonly attributeMasterService: AttributeMasterService,
+    private readonly entityMasterService: EntityMasterService,
+    @Inject('SavedFilterService')
+    private readonly savedFilterService: SavedFilterService,
+    @Inject('EntityRelationService')
+    private readonly entityRelationService: EntityRelationService,
+    private readonly resolverService: ResolverService,
+    @Inject() protected readonly loggingService: LoggingService,
+  ) {}
+  private readonly skipAppCodeFilterEntities = ['ORGP'];
+  private readonly skipOrgFilterEntities = ['ORGP'];
+
+  private async gettab_value_counts(
+    tableName: string,
+    column: string | undefined,
+    whereClauses: { query: string; params: Record<string, any> }[],
+  ) {
+    if (!column) return [];
+
+    let whereSQL = '';
+    const values: any[] = [];
+
+    // Convert whereClauses to SQL
+    if (whereClauses.length > 0) {
+      const clauseParts = whereClauses.map((clause) => {
+        let parsedQuery = clause.query.replace(/\be\./g, ''); // removes e. prefix
+        Object.entries(clause.params).forEach(([key, val]) => {
+          parsedQuery = parsedQuery.replace(new RegExp(`:${key}`, 'g'), '?');
+          values.push(val);
+        });
+        return parsedQuery;
+      });
+
+      whereSQL = `WHERE ${clauseParts.join(' AND ')}`;
+    }
+
+    // Construct raw SQL
+    const rawSQL = `
+  SELECT ${column} AS tab_value, COUNT(*) AS tab_value_count
+  FROM ${tableName}
+  ${whereSQL}
+  GROUP BY ${column}
+`;
+
+    const rows = await this.dataSource.query(rawSQL, values);
+
+    const total = rows.reduce(
+      (sum, r) => sum + parseInt(r.tab_value_count, 10),
+      0,
+    );
+
+    return [
+      { tab_value: 'All', tab_value_count: total },
+      ...rows.map((r) => ({
+        tab_value: r.tab_value ?? 'UNKNOWN',
+        tab_value_count: parseInt(r.tab_value_count, 10),
+      })),
+    ];
+  }
+
+  async applyFilterWrapper(dto: FilterRequestDto) {
+    const {
+      entity_type,
+      quickFilter = [],
+      savedFilterCode,
+      attributeFilter = [],
+      loggedInUser,
+    } = dto;
+  
+  
+    // 🔹 Step 1: Collect all filters (from body + savedFilter)
+    const savedFilters = await this.getSavedFilters(savedFilterCode ?? undefined);
+    const allFilters = [...quickFilter, ...attributeFilter, ...savedFilters].filter(
+      (f) => f.filter_value !== '',
+    );
+
+  
+    // 🔹 Step 2: Group filters by filter_entity_type
+    const grouped = allFilters.reduce(
+      (acc, f) => {
+        if (!acc[f.filter_entity_type]) acc[f.filter_entity_type] = [];
+        acc[f.filter_entity_type].push(f);
+        return acc;
+      },
+      {} as Record<string, any[]>,
+    );
+  
+    console.log('🟠 [FilterService] Grouped filters by entity type:', grouped);
+  
+    // 🔹 Step 3: Handle sub-entities first
+    let intersectionIds: number[] | null = null;
+    for (const [subEntityType, filters] of Object.entries(grouped)) {
+      if (subEntityType === entity_type) continue; // skip main entity for now
+  
+      let { queryParams, tabs, ...newDto } = dto;
+  
+      const subDto: FilterRequestDto = {
+        ...newDto,
+        entity_type: subEntityType,
+        quickFilter: filters as FilterCondition[],
+        savedFilterCode: null, // already merged
+        attributeFilter: [],
+      };
+  
+      const subResult = await this.applyFilter(subDto);
+      const subEntityIds = subResult.data.entity_list.map((row) => row.id);
+  
+      console.log(`🧩 [FilterService] Sub-entity ${subEntityType} returned IDs:`, subEntityIds);
+  
+      if (!subEntityIds.length) {
+        console.log(`ℹ️ [FilterService] No records for sub-entity ${subEntityType}, returning empty result`);
+        return {
+          success: true,
+          data: { entity_tabs: [], entity_list: [], pagination: {} },
+        };
+      }
+  
+      const relatedIds = await this.entityRelationService.getRelatedEntityIds(
+        entity_type,
+        subEntityType,
+        subEntityIds,
+        dto.loggedInUser.organization_id,
+      );
+  
+      intersectionIds =
+        intersectionIds === null
+          ? relatedIds
+          : intersectionIds.filter((id) => relatedIds.includes(id));
+  
+
+      if (intersectionIds.length === 0) {
+        console.log('🚫 [FilterService] No intersection IDs left, returning empty result');
+        return {
+          success: true,
+          data: { entity_tabs: [], entity_list: [], pagination: {} },
+        };
+      }
+    }
+  
+    // 🔹 Step 4: Call applyFilter for main entity
+    const mainFilters = grouped[entity_type] || [];
+    const mainDto: FilterRequestDto = {
+      ...dto,
+      quickFilter: [...mainFilters],
+      savedFilterCode: null,
+      attributeFilter: [],
+    };
+  
+    if (intersectionIds && intersectionIds.length > 0) {
+      (mainDto.quickFilter ??= []).push({
+        filter_attribute: 'id',
+        filter_operator: 'equal',
+        filter_value: intersectionIds,
+        filter_entity_type: entity_type,
+      });
+    }
+  
+    return this.applyFilter(mainDto);
+  }
+  
+  async applyFilter(dto: FilterRequestDto) {
+    const {
+      entity_type,
+      quickFilter,
+      savedFilterCode,
+      attributeFilter,
+      tabs,
+      sortby,
+      loggedInUser,
+      queryParams,
+      customLevelType,
+      customLevelId,
+      customAppCode,
+    } = dto;
+  
+    // abstract user details
+    const {
+      level_type,
+      level_id,
+      id: user_id,
+      appcode,
+      organization_id,
+    } = loggedInUser || {};
+  
+    // Fetch meta from entity table service
+    const entityMeta = await this.entityMasterService.getEntityData(
+      entity_type,
+      loggedInUser,
+    );
+    const tableName = entityMeta?.data_source; // data_source is the table name
+  
+    if (!tableName) {
+      console.error(`❌ [FilterService] Invalid entity_type: ${entity_type}`);
+      throw new BadRequestException(`Invalid entity_type: ${entity_type}`);
+    }
+  
+    const getAttributeColumnMeta =
+      await this.attributeMasterService.findAttributesByMappedEntityType(
+        entity_type,
+        loggedInUser,
+      );
+  
+    const attributeMetaMap = getAttributeColumnMeta.reduce(
+      (acc, attr) => {
+        acc[attr.attribute_key] = attr;
+        return acc;
+      },
+      {} as Record<string, any>,
+    );
+  
+    // Get and parse saved filters
+    const savedFilters = await this.getSavedFilters(
+      savedFilterCode ?? undefined,
+    );
+    const savedFiltersNormalized = savedFilters.map((f) => ({
+      filter_attribute: f.filter_attribute,
+      filter_operator: f.filter_operator,
+      filter_value: f.filter_value,
+    }));
+
+    const baseFilters = [
+      ...(quickFilter || []).filter(
+        (f) => f.filter_value != null && f.filter_value !== '',
+      ),
+      ...savedFiltersNormalized.filter(
+        (f) => f.filter_value != null && f.filter_value !== '',
+      ),
+      ...(attributeFilter || []).filter(
+        (f) => f.filter_value != null && f.filter_value !== '',
+      ),
+    ];
+  
+  
+    // Build where clauses
+    const baseWhere = this.buildWhereClauses(baseFilters, attributeMetaMap);
+  
+    // check level_id and level_type
+    if (
+      entity_type != 'ORGP' &&
+      level_type &&
+      level_id &&
+      organization_id &&
+      !customLevelType &&
+      !customLevelId
+    ) {
+      baseWhere.push({
+        query:
+          'e.organization_id = :organization_id AND e.level_type = :level_type AND e.level_id = :level_id',
+        params: { organization_id, level_type, level_id },
+      });
+    }
+  
+    if (customLevelType && customLevelId && customAppCode) {
+      baseWhere.push({
+        query:
+          'e.organization_id = :organization_id AND e.level_type = :customLevelType AND e.level_id = :customLevelId AND e.appcode = :customAppCode',
+        params: { organization_id, customLevelType, customLevelId, customAppCode },
+      });
+    }
+  
+    // Handle queryParams filters
+    if (queryParams) {
+      Object.entries(queryParams).forEach(([key, value]) => {
+        if (!value) return;
+  
+        if (key === 'attributeName' && queryParams['attributeValue']) {
+          const attrName = value;
+          const attrValue = queryParams['attributeValue'];
+          baseWhere.push({
+            query: `e.${attrName} = :${attrName}`,
+            params: { [attrName]: attrValue },
+          });
+        } else if (key !== 'attributeValue') {
+          baseWhere.push({
+            query: `e.${key} = :${key}`,
+            params: { [key]: value },
+          });
+        }
+      });
+    }
+  
+    console.log('🟠 [FilterService] Constructed baseWhere clauses:', baseWhere);
+  
+    // layout preference query
+    const layoutPreference = await this.dataSource.query(
+      `SELECT mapped_json 
+       FROM cr_entity_layout_pref
+       WHERE user_id = ? AND mapped_entity_type = ? AND mapped_level_id = ? AND mapped_level_type = ? AND type = 'layout'`,
+      [user_id, entity_type, level_id, level_type],
+    );
+  
+    // Extract layout preference
+    const layout = layoutPreference?.[0]?.mapped_json?.quick_tab || {};
+    const showList = layout?.show_list?.map((val) => val.toLowerCase()) || [];
+  
+    let allTabs;
+    if (layout.attribute) {
+      allTabs = await this.gettab_value_counts(
+        entityMeta?.data_source,
+        layout.attribute,
+        baseWhere,
+      );
+    } else {
+      allTabs = await this.gettab_value_counts(
+        entityMeta?.data_source,
+        tabs?.columnName,
+        baseWhere,
+      );
+    }
+
+    let filteredTabs;
+  
+    if (showList?.length > 0) {
+      const isAllNeeded = layout?.isAllSelected && !showList.includes('all');
+      if (isAllNeeded) showList.push('all');
+  
+      filteredTabs = allTabs.filter((tab) =>
+        showList.includes(tab.tab_value.toLowerCase()),
+      );
+  
+      const allTab = filteredTabs.find(
+        (tab) => tab.tab_value?.toLowerCase() === 'all',
+      );
+      filteredTabs = filteredTabs.filter(
+        (tab) => tab.tab_value?.toLowerCase() !== 'all',
+      );
+  
+      // SORTING LOGIC
+      if (layout.sorting === 'asc') {
+        filteredTabs.sort((a, b) =>
+          a.tab_value.toLowerCase().localeCompare(b.tab_value.toLowerCase()),
+        );
+      } else if (layout.sorting === 'dsc') {
+        filteredTabs.sort((a, b) =>
+          b.tab_value.toLowerCase().localeCompare(a.tab_value.toLowerCase()),
+        );
+      } else if (layout.sorting === 'count_asc') {
+        filteredTabs.sort((a, b) => a.tab_value_count - b.tab_value_count);
+      } else if (layout.sorting === 'count_dsc') {
+        filteredTabs.sort((a, b) => b.tab_value_count - a.tab_value_count);
+      } else if (layout.sorting === 'custom') {
+        const orderMap = new Map<string, number>(
+          showList.map((val, index) => [val.toLowerCase(), index]),
+        );
+        filteredTabs.sort((a, b) => {
+          const aIndex = orderMap.get(a.tab_value.toLowerCase()) ?? Infinity;
+          const bIndex = orderMap.get(b.tab_value.toLowerCase()) ?? Infinity;
+          return aIndex - bIndex;
+        });
+      }
+  
+      if (allTab) filteredTabs.unshift(allTab);
+  
+      if (layout?.isCombineOther) {
+        const originalAllTab = allTabs.find(
+          (tab) => tab.tab_value.toLowerCase() === 'all',
+        );
+        const allCount = originalAllTab?.tab_value_count ?? 0;
+        const knownTabCountSum = filteredTabs
+          .filter((tab) => tab.tab_value.toLowerCase() !== 'all')
+          .reduce((acc, tab) => acc + tab.tab_value_count, 0);
+  
+        const othersCount = allCount - knownTabCountSum;
+        filteredTabs.push({
+          tab_value: 'OTHERS',
+          tab_value_count: othersCount < 0 ? 0 : othersCount,
+        });
+      }
+    } else {
+      filteredTabs = allTabs;
+    }
+  
+  
+    const dataWhere = [...baseWhere];
+  
+    if (tabs?.columnName && tabs?.value) {
+      const tabAttrMeta = attributeMetaMap[tabs.columnName];
+      const tabValue = tabs.value.toLowerCase();
+  
+      if (tabValue === 'others') {
+        const valuesToExclude = showList.filter((v) => v !== 'all');
+        if (valuesToExclude.length > 0) {
+          for (const value of valuesToExclude) {
+            const resolvedId = await this.resolverService.getResolvedId(
+              loggedInUser,
+              tabs.columnName,
+              value,
+              entity_type,
+            );
+            if (resolvedId) {
+              const tabCondition = this.buildCondition(
+                {
+                  filter_attribute: tabs.columnName,
+                  filter_operator: 'not_equal',
+                  filter_value: [resolvedId],
+                  skip_id: true,
+                },
+                tabAttrMeta,
+              );
+              if (tabCondition) dataWhere.push(tabCondition);
+            }
+          }
+        }
+      } else if (tabValue !== 'all') {
+        const resolvedId = await this.resolverService.getResolvedId(
+          loggedInUser,
+          tabs.columnName,
+          tabs.value,
+          entity_type,
+        );
+  
+        if (resolvedId) {
+          const tabCondition = this.buildCondition(
+            {
+              filter_attribute: tabs.columnName,
+              filter_operator: 'equal',
+              filter_value: [resolvedId],
+              skip_id: true,
+            },
+            tabAttrMeta,
+          );
+          if (tabCondition) dataWhere.push(tabCondition);
+        }
+      }
+    }
+  
+    const qb = this.dataSource.createQueryBuilder().select('e.*').from(tableName, 'e');
+    dataWhere.forEach((clause) => qb.andWhere(clause.query, clause.params));
+  
+    if (layoutPreference && layoutPreference[0]?.mapped_json?.sorting) {
+      if (Array.isArray(layoutPreference[0]?.mapped_json?.sorting?.tabs)) {
+        const preferenceTabArray = layoutPreference[0]?.mapped_json?.sorting?.tabs;
+        const tabFilter = preferenceTabArray.find(
+          (tabData) => tabData.tab_name === tabs?.value,
+        );
+        tabFilter?.sortby.forEach(({ column, order }) => {
+          qb.addOrderBy(`e.${column}`, order?.toUpperCase() === 'DSC' ? 'DESC' : 'ASC');
+        });
+      } else if (Array.isArray(layoutPreference[0]?.mapped_json?.sorting?.sortby)) {
+        layoutPreference[0]?.mapped_json?.sorting?.sortby?.forEach(({ column, order }) => {
+          qb.addOrderBy(`e.${column}`, order?.toUpperCase() === 'DSC' ? 'DESC' : 'ASC');
+        });
+      }
+    }
+  
+    qb.addOrderBy('e.created_date', 'DESC');
+  
+    const page = dto.page && dto.page > 0 ? dto.page : 1;
+    const size = dto.size && dto.size > 0 ? dto.size : 10;
+    qb.skip((page - 1) * size).take(size);
+  
+    const entity_list = await qb.getRawMany();
+  
+    console.log(`📦 [FilterService] Fetched ${entity_list.length} records`);
+  
+    const dateAttributes = Object.entries(attributeMetaMap)
+      .filter(([_, attr]) => attr.data_type === 'date')
+      .map(([key]) => key);
+  
+    const formatDate = (dateStr: string | null): string | null =>
+      dateStr ? moment(dateStr).format('DD-MM-YYYY') : '';
+  
+    const formatDatesInRow = (row: any): any => {
+      const formattedRow = { ...row };
+      for (const key of dateAttributes) {
+        if (formattedRow[key]) formattedRow[key] = formatDate(formattedRow[key]);
+      }
+      return formattedRow;
+    };
+  
+    const formattedEntityList = entity_list.map(formatDatesInRow);
+  
+    const resolvedEntityList = await Promise.all(
+      formattedEntityList.map((row) =>
+        this.resolverService.getResolvedData(loggedInUser, row, entity_type),
+      ),
+    );
+
+    const resolvedTabs = await Promise.all(
+      filteredTabs.map(async (tab) => {
+        const tabAttrKey = layout?.attribute || tabs?.columnName;
+  
+        if (
+          !tabAttrKey ||
+          tab.tab_value?.toLowerCase() === 'all' ||
+          tab.tab_value?.toLowerCase() === 'others'
+        ) {
+          return tab;
+        }
+  
+        const resolvedVal = await this.resolverService.getResolvedValue(
+          loggedInUser,
+          tabAttrKey,
+          tab.tab_value,
+          entity_type,
+        );
+  
+        return { ...tab, tab_value: resolvedVal ?? tab.tab_value };
+      }),
+    );
+  
+  
+    const countQb = this.dataSource
+      .createQueryBuilder()
+      .select('COUNT(*)', 'count')
+      .from(tableName, 'e');
+    dataWhere.forEach((clause) => countQb.andWhere(clause.query, clause.params));
+    const countResult = await countQb.getRawOne();
+    const total = parseInt(countResult.count, 10);
+  
+    console.log('📊 [FilterService] Returning final result with total:', total);
+  
+    return {
+      success: true,
+      data: {
+        entity_tabs: resolvedTabs,
+        entity_list: resolvedEntityList,
+        pagination: {
+          total,
+          page,
+          size,
+          totalPages: Math.ceil(total / size),
+          hasNextPage: page * size < total,
+          hasPreviousPage: page > 1,
+        },
+      },
+    };
+  }
+  
+  private parseFilters(raw: any, isSingle = false): any[] {
+    if (!raw) return [];
+
+    if (typeof raw === 'string') {
+      try {
+        const parsed = JSON.parse(raw);
+        return isSingle ? [parsed] : parsed;
+      } catch {
+        throw new BadRequestException('Invalid JSON in filter input');
+      }
+    }
+
+    return isSingle ? [raw] : Array.isArray(raw) ? raw : [];
+  }
+
+  private async getSavedFilters(code?: string): Promise<any[]> {
+    if (!code) return [];
+
+    const savedFilter = await this.savedFilterService.getDetailsByCode(code);
+    if (!savedFilter) {
+      throw new BadRequestException(`Saved filter not found for code: ${code}`);
+    }
+    return savedFilter;
+  }
+
+  private buildWhereClauses(
+    filters: any[],
+    attributeMeta: Record<string, any>,
+  ) {
+    return filters
+      .map((f) => this.buildCondition(f, attributeMeta[f.filter_attribute]))
+      .filter(
+        (clause): clause is { query: string; params: any } => clause !== null,
+      );
+  }
+
+  private buildCondition(
+    filter: any,
+    meta: any,
+  ): { query: string; params: any } | null {
+    if (!meta) return null;
+
+    let attr = filter.filter_attribute;
+    const val = filter.filter_value;
+    const op = filter.filter_operator;
+    const key = `param_${attr}_${Math.random().toString(36).substring(2, 8)}`;
+
+    // if (
+    //   (meta.data_source_type === 'entity' ||
+    //     meta.data_source_type === 'master') &&
+    //   !filter.skip_id
+    // ) {
+    //   attr = `${attr}_id`;
+    // }
+
+    switch (meta.data_type) {
+      case 'text':
+        return this.buildTextCondition(attr, op, val, key);
+      case 'number':
+        return this.buildNumberCondition(attr, op, val, key);
+      case 'date':
+        return this.buildDateCondition(attr, op, val, key);
+      case 'select':
+        return this.buildMultiSelectCondition(attr, op, val, key);
+      case 'multiselect':
+        return this.buildMultiSelectCondition(attr, op, val, key);
+      case 'checkbox':
+        return this.buildMultiSelectCondition(attr, op, val, key);
+      case 'radio':
+        return this.buildMultiSelectCondition(attr, op, val, key);
+      case 'year':
+        return this.buildYearCondition(attr, op, val, key);
+      default:
+        return null;
+    }
+  }
+
+  private buildTextCondition(attr: string, op: string, val: any, key: string) {
+    switch (op) {
+      case 'contains':
+        return {
+          query: `LOWER(e.${attr}) LIKE :${key}`,
+          params: { [key]: `%${val ? val.toLowerCase() : ''}%` },
+        };
+      case 'equal':
+        return {
+          query: `e.${attr} = :${key}`,
+          params: { [key]: val },
+        };
+      case 'not_equal':
+        return {
+          query: `e.${attr} != :${key}`,
+          params: { [key]: val },
+        };
+      case 'empty':
+        return {
+          query: `e.${attr} IS NULL`,
+          params: {},
+        };
+      case 'not_empty':
+        return {
+          query: `e.${attr} IS NOT NULL`,
+          params: {},
+        };
+      default:
+        throw new BadRequestException(`Unsupported operator for text: ${op}`);
+    }
+  }
+
+  private buildNumberCondition(
+    attr: string,
+    op: string,
+    val: any,
+    key: string,
+  ) {
+    switch (op) {
+      case 'equal':
+        return { query: `e.${attr} = :${key}`, params: { [key]: val } };
+      case 'not_equal':
+        return { query: `e.${attr} != :${key}`, params: { [key]: val } };
+      case 'greater_than':
+        return { query: `e.${attr} > :${key}`, params: { [key]: val } };
+      case 'less_than':
+        return { query: `e.${attr} < :${key}`, params: { [key]: val } };
+      case 'less_than_qual_to':
+        return { query: `e.${attr} <= :${key}`, params: { [key]: val } };
+      case 'greater_than_qual_to':
+        return { query: `e.${attr} >= :${key}`, params: { [key]: val } };
+      case 'empty':
+        return { query: `e.${attr} IS NULL`, params: {} };
+      case 'not_empty':
+        return { query: `e.${attr} IS NOT NULL`, params: {} };
+
+      default:
+        throw new BadRequestException(`Unsupported operator for number: ${op}`);
+    }
+  }
+
+  private buildDateCondition(attr: string, op: string, val: any, key: string) {
+    switch (op) {
+      case 'equal':
+        return { query: `e.${attr} = :${key}`, params: { [key]: val } };
+      case 'before':
+        return { query: `e.${attr} < :${key}`, params: { [key]: val } };
+      case 'after':
+        return { query: `e.${attr} > :${key}`, params: { [key]: val } };
+      case 'between': {
+        if (typeof val === 'string') {
+          val = val.split(',').map((v) => v.trim());
+        }
+
+        if (
+          !Array.isArray(val) ||
+          val.length !== 2 ||
+          val[0] === '' ||
+          val[1] === ''
+        ) {
+          // throw new BadRequestException(`Invalid value for in_between: ${val}`);
+          console.log(`Invalid value for in_between: ${val}`);
+          return null;
+        }
+        return {
+          query: `e.${attr} BETWEEN :${key}_start AND :${key}_end`,
+          params: {
+            [`${key}_start`]: val[0],
+            [`${key}_end`]: val[1],
+          },
+        };
+      }
+
+      case 'today': {
+        const today = new Date().toISOString().split('T')[0]; // 'YYYY-MM-DD'
+
+        return {
+          query: `DATE(e.${attr}) = :today`,
+          params: {
+            today,
+          },
+        };
+      }
+
+      case 'empty': {
+        return {
+          query: `e.${attr} IS NULL`,
+          params: {},
+        };
+      }
+
+      case 'not_empty': {
+        return {
+          query: `e.${attr} IS NOT NULL`,
+          params: {},
+        };
+      }
+      default:
+        throw new BadRequestException(`Unsupported operator for date: ${op}`);
+    }
+  }
+
+  private buildSelectCondition(
+    attr: string,
+    op: string,
+    val: any,
+    key: string,
+  ) {
+    switch (op) {
+      case 'equal':
+        return { query: `e.${attr} = :${key}`, params: { [key]: val } };
+      case 'not_equal':
+        return { query: `e.${attr} != :${key}`, params: { [key]: val } };
+      case 'empty':
+        return { query: `e.${attr} IS NULL`, params: {} };
+      case 'not_empty':
+        return { query: `e.${attr} IS NOT NULL`, params: {} };
+      default:
+        throw new BadRequestException(`Unsupported operator for select: ${op}`);
+    }
+  }
+
+  private buildMultiSelectCondition(
+    attr: string,
+    op: string,
+    val: any,
+    key: string,
+  ) {
+    if (Array.isArray(val) && val.length === 0) {
+      return { query: '1=1', params: {} };
+    }
+
+    if ((op === 'equal' || op === 'not_equal') && !Array.isArray(val)) {
+      throw new BadRequestException(
+        `Value for multi-select must be an array for operator: ${op}`,
+      );
+    }
+
+    switch (op) {
+      case 'equal':
+        return {
+          query: `e.${attr} IN (:${key})`,
+          params: { [key]: val },
+        };
+      case 'not_equal':
+        return {
+          query: `e.${attr} NOT IN (:${key})`,
+          params: { [key]: val },
+        };
+      case 'contains':
+        return {
+          query: `e.${attr} LIKE :${key}`,
+          params: { [key]: `%${val}%` },
+        };
+      case 'not_contains':
+        return {
+          query: `e.${attr} NOT LIKE :${key}`,
+          params: { [key]: `%${val}%` },
+        };
+      case 'empty':
+        return { query: `e.${attr} IS NULL`, params: {} };
+      case 'not_empty':
+        return { query: `e.${attr} IS NOT NULL`, params: {} };
+      default:
+        throw new BadRequestException(
+          `Unsupported operator for multiselect: ${op}`,
+        );
+    }
+  }
+
+  private buildYearCondition(attr: string, op: string, val: any, key: string) {
+    switch (op) {
+      case 'equal':
+        return {
+          query: `e.${attr} = :${key}`,
+          params: { [key]: parseInt(val, 10) },
+        };
+      case 'not_equal':
+        return {
+          query: `e.${attr} != :${key}`,
+          params: { [key]: parseInt(val, 10) },
+        };
+      case 'greater_than':
+        return {
+          query: `e.${attr} > :${key}`,
+          params: { [key]: parseInt(val, 10) },
+        };
+      case 'less_than':
+        return {
+          query: `e.${attr} < :${key}`,
+          params: { [key]: parseInt(val, 10) },
+        };
+      default:
+        throw new BadRequestException(`Unsupported operator for year: ${op}`);
+    }
+  }
+}