rez_core 4.0.196 → 4.0.197

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

@@ -1,1051 +1,1005 @@
-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 { 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';
-import { ConfigService } from '@nestjs/config';
-
-@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 configService: ConfigService,
-  ) {}
-  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[] = [];
-    let paramIndex = 1; // PostgreSQL placeholders start at $1
-
-    if (whereClauses.length > 0) {
-      const clauseParts = whereClauses.map((clause) => {
-        let parsedQuery = clause.query.replace(/\be\./g, ''); // remove e.
-
-        Object.entries(clause.params).forEach(([key, val]) => {
-          if (Array.isArray(val)) {
-            // Create ($1,$2,$3)
-            const placeholders = val
-              .map(() => `$${paramIndex++}`)
-              .join(', ');
-
-            parsedQuery = parsedQuery.replace(
-              new RegExp(`:${key}`, 'g'),
-              `(${placeholders})`,
-            );
-
-            values.push(...val.map((v) => String(v)));
-          } else {
-            // Create $1
-            const placeholder = `$${paramIndex++}`;
-
-            parsedQuery = parsedQuery.replace(
-              new RegExp(`:${key}`, 'g'),
-              placeholder,
-            );
-
-            values.push(String(val));
-          }
-        });
-
-        return parsedQuery;
-      });
-
-      whereSQL = `WHERE ${clauseParts.join(' AND ')}`;
-    }
-
-    const rawSQL = `
-    SELECT ${column} AS tab_value, COUNT(*) AS tab_value_count
-    FROM ${tableName}
-    ${whereSQL}
-    GROUP BY ${column}
-  `;
-
-    const rows = await this.queryWithSchema(rawSQL, values);
-    // 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 ?? 'BLANK',
-        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 await 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);
-
-    // Handle TEMPLATE entity special condition
-    if (entity_type === 'TEMP' || entity_type === 'TEM') {
-      const templateTable = entityMeta?.data_source || 'frm_wf_comm_template';
-
-      if (level_type === 'ORG') {
-        baseWhere.push({
-          query: `  ((e.level_type = 'ORG' AND e.level_id = '${loggedInUser.organization_id}' AND e.organization_id = '${loggedInUser.organization_id}'))`,
-          params: {},
-        });
-      } else if (level_type === 'SCH') {
-        baseWhere.push({
-          query: `
-        (
-          (e.level_type = 'SCH' AND e.level_id = '${loggedInUser.level_id}' AND e.organization_id = '${loggedInUser.organization_id}')
-          OR 
-          (
-            e.level_type = 'ORG'
-            AND e.level_id = '${loggedInUser.organization_id}'
-            AND e.organization_id = '${loggedInUser.organization_id}'
-            AND e.code NOT IN (
-              SELECT sub.code 
-              FROM frm_wf_comm_template AS sub 
-              WHERE sub.level_type = 'SCH' AND sub.level_id = '${loggedInUser.level_id}'
-            )
-          )
-        )
-      `,
-          params: {},
-        });
-      }
-    }
-
-    // Default org/level clause — skip TEMPLATE entity
-    if (
-      entity_type !== 'ORGP' &&
-      entity_type !== 'TEMP' &&
-      entity_type !== 'TEM' && // ✅ skip TEMPLATE
-      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 : String(organization_id), level_type, level_id },
-      });
-    }
-
-    if (entity_type == 'USR' || entity_type == 'UPR') {
-      baseWhere.push({
-        query: 'e.is_customer is NULL',
-        params: {},
-      });
-    }
-
-    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: String(organization_id),
-          customLevelType,
-          customLevelId: String(customLevelId),
-          customAppCode,
-        },
-      });
-    }
-
-    // Handle queryParams filters
-    if (queryParams) {
-      Object.entries(queryParams).forEach(([key, value]) => {
-        if (!value) return;
-
-        // Always convert to string
-        const strValue = String(value);
-
-        if (key === 'attributeName' && queryParams['attributeValue']) {
-          const attrName = strValue;
-          const attrValue = String(queryParams['attributeValue']);
-
-          baseWhere.push({
-            query: `e.${attrName} = :${attrName}`,
-            params: { [attrName]: attrValue }, // <-- string
-          });
-        }
-        else if (key !== 'attributeValue') {
-          baseWhere.push({
-            query: `e.${key} = :${key}`,
-            params: { [key]: strValue }, // <-- string
-          });
-        }
-      });
-    }
-
-    console.log('🟠 [FilterService] Constructed baseWhere clauses:', baseWhere);
-
-    // layout preference query
-    const layoutPreference = await this.dataSource.query(
-      `SELECT mapped_json 
-       FROM frm_entity_layout_pref
-       WHERE user_id = $1 AND mapped_entity_type = $2 AND mapped_level_id = $3 AND mapped_level_type = $4 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) => {
-        if (typeof val === 'string') {
-          // legacy case — old format like ['Active', 'Inactive']
-          return val.toLowerCase();
-        }
-
-        if (val && typeof val === 'object' && val.value !== undefined) {
-          // new format — [{ label: 'Active', value: '13023' }]
-          return String(val.value).toLowerCase();
-        }
-
-        return ''; // fallback safety
-      }) || [];
-
-    let filteredTabs = await this.getFilteredTabs(
-      layout,
-      showList,
-      entityMeta,
-      baseWhere,
-      tabs,
-      loggedInUser,
-    );
-
-    const dataWhere = [...baseWhere];
-
-    if (tabs?.columnName && tabs?.value) {
-      const tabAttrMeta = attributeMetaMap[tabs.columnName];
-      const tabValue = tabs.value.toLowerCase();
-
-      if (tabValue === 'others') {
-        // Extract 'value' (IDs) from showList, ignore 'all'
-        const valuesToExclude = showList
-          .filter((v) => v.label.toLowerCase() !== 'all')
-          .map((v) => v.value);
-
-        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);
-        }
-      }
-    }
-
-    let qb = this.dataSource
-      .createQueryBuilder()
-      .select('e.*')
-      .from(tableName, 'e');
-    dataWhere.forEach((clause) => qb.andWhere(clause.query, clause.params));
-
-    // Apply sorting
-    qb = await this.sortTabsByShowList(qb, sortby, layoutPreference, tabs);
-
-    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);
-
-    let query = await qb.getQuery();
-
-    console.log('------------------------------------------------------\n')
-    console.log(query);
-    console.log('\n------------------------------------------------------')
-    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,
-        },
-      },
-    };
-  }
-
-  // GET FILTERED TABS LOGIC
-  private async getFilteredTabs(
-    layout: any,
-    showList: any,
-    entityMeta: any,
-    baseWhere: any,
-    tabs: any,
-    loggedInUser: any,
-  ) {
-    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: any[] = [];
-
-    if (showList?.length > 0) {
-      // Extract tab IDs (values)
-      const showValues = (showList || []).map((item) => {
-        const val = typeof item === 'object' ? item.value : item;
-        return val ? String(val).toLowerCase() : '';
-      });
-
-      // Handle "all" logic
-      const isAllNeeded = layout?.isAllSelected && !showValues.includes('all');
-      if (isAllNeeded) {
-        showList.push({ label: 'All', value: 'all' });
-        showValues.push('all');
-      }
-
-      // Filter by value IDs (not labels)
-      filteredTabs = allTabs.filter((tab) => {
-        const tabValueStr = tab.tab_value
-          ? String(tab.tab_value).toLowerCase()
-          : '';
-        return showValues.includes(tabValueStr);
-      });
-
-      // Handle "all" tab
-      const allTab = filteredTabs.find(
-        (tab) => tab.tab_value?.toString().toLowerCase() === 'all',
-      );
-      filteredTabs = filteredTabs.filter(
-        (tab) => tab.tab_value?.toString().toLowerCase() !== 'all',
-      );
-
-      // SORTING LOGIC
-      if (layout.sorting === 'asc') {
-        filteredTabs.sort((a, b) =>
-          a.tab_value.toString().localeCompare(b.tab_value.toString()),
-        );
-      } else if (layout.sorting === 'dsc') {
-        filteredTabs.sort((a, b) =>
-          b.tab_value.toString().localeCompare(a.tab_value.toString()),
-        );
-      } 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') {
-        // Keep order same as showList
-        const orderMap = new Map<string, number>(
-          showList.map((item, index) => [
-            item.value?.toString().toLowerCase(),
-            index,
-          ]),
-        );
-        filteredTabs.sort((a, b) => {
-          const aIndex =
-            orderMap.get(a.tab_value?.toString().toLowerCase()) ?? Infinity;
-          const bIndex =
-            orderMap.get(b.tab_value?.toString().toLowerCase()) ?? Infinity;
-          return aIndex - bIndex;
-        });
-      }
-
-      // Re-add "all" tab at beginning if needed
-      if (allTab) filteredTabs.unshift(allTab);
-
-      // Combine others if enabled
-      if (layout?.isCombineOther) {
-        const originalAllTab = allTabs.find(
-          (tab) => tab.tab_value?.toString().toLowerCase() === 'all',
-        );
-        const allCount = originalAllTab?.tab_value_count ?? 0;
-        const knownTabCountSum = filteredTabs
-          .filter((tab) => tab.tab_value?.toString().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;
-    }
-
-    return filteredTabs;
-  }
-
-  // SORTING LOGIC FOR TABS
-  private async sortTabsByShowList(
-    qb: any,
-    sortby: any,
-    layoutPreference: any,
-    tabs: any,
-  ) {
-    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',
-            );
-          },
-        );
-      }
-    }
-
-    if (Array.isArray(sortby) && sortby.length > 0) {
-      sortby.forEach(({ sortColum, sortType }) => {
-        if (sortColum) {
-          qb.addOrderBy(
-            `e.${sortColum}`,
-            sortType?.toUpperCase() === 'DSC' ? 'DESC' : 'ASC',
-          );
-        }
-      });
-    } else {
-      // fallback if no explicit sortby sent
-      qb.addOrderBy('e.created_date', 'DESC');
-    }
-
-    return qb;
-  }
-
-  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) => {
-        const clause = this.buildCondition(f, attributeMeta[f.filter_attribute]);
-
-        if (!clause) return null;
-
-        // Force every param to be a string
-        if (clause.params) {
-          Object.keys(clause.params).forEach((k) => {
-            clause.params[k] = String(clause.params[k]);
-          });
-        }
-
-        return clause;
-      })
-      .filter(
-        (clause): clause is { query: string; params: Record<string, string> } =>
-          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}`);
-    }
-  }
-
-  async queryWithSchema(sql: string, params: any[] = []) {
-    await this.dataSource.query('BEGIN');
-    const schema = this.configService.get<string>('DB_SCHEMA')
-    await this.dataSource.query(`SET LOCAL search_path TO ${schema}`);
-    const result = await this.dataSource.query(sql, params);
-    await this.dataSource.query('COMMIT');
-    return result;
-  }
-}
+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[] = [];
+
+    if (whereClauses.length > 0) {
+      const clauseParts = whereClauses.map((clause) => {
+        let parsedQuery = clause.query.replace(/\be\./g, ''); // remove e.
+
+        Object.entries(clause.params).forEach(([key, val]) => {
+          if (Array.isArray(val)) {
+            // if it's an array → expand placeholders (?, ?, ?)
+            const placeholders = val.map(() => '?').join(', ');
+            parsedQuery = parsedQuery.replace(
+              new RegExp(`:${key}`, 'g'),
+              `(${placeholders})`,
+            );
+            values.push(...val); // flatten values
+          } else {
+            parsedQuery = parsedQuery.replace(new RegExp(`:${key}`, 'g'), '?');
+            values.push(val);
+          }
+        });
+
+        return parsedQuery;
+      });
+
+      whereSQL = `WHERE ${clauseParts.join(' AND ')}`;
+    }
+
+    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 ?? 'BLANK',
+        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 await 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);
+
+    // Handle TEMPLATE entity special condition
+    if (entity_type === 'TEMP' || entity_type === 'TEM') {
+      const templateTable = entityMeta?.data_source || 'frm_wf_comm_template';
+
+      if (level_type === 'ORG') {
+        baseWhere.push({
+          query: `  ((e.level_type = 'ORG' AND e.level_id = ${loggedInUser.organization_id} AND e.organization_id = ${loggedInUser.organization_id}))`,
+          params: {},
+        });
+      } else if (level_type === 'SCH') {
+        baseWhere.push({
+          query: `
+        (
+          (e.level_type = 'SCH' AND e.level_id = ${loggedInUser.level_id} AND e.organization_id = ${loggedInUser.organization_id})
+          OR 
+          (
+            e.level_type = 'ORG'
+            AND e.level_id = ${loggedInUser.organization_id}
+            AND e.organization_id = ${loggedInUser.organization_id}
+            AND e.code NOT IN (
+              SELECT sub.code 
+              FROM frm_wf_comm_template AS sub 
+              WHERE sub.level_type = 'SCH' AND sub.level_id = ${loggedInUser.level_id}
+            )
+          )
+        )
+      `,
+          params: {},
+        });
+      }
+    }
+
+    // Default org/level clause — skip TEMPLATE entity
+    if (
+      entity_type !== 'ORGP' &&
+      entity_type !== 'TEMP' &&
+      entity_type !== 'TEM' && // ✅ skip TEMPLATE
+      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 (entity_type == 'USR' || entity_type == 'UPR') {
+      baseWhere.push({
+        query: 'e.is_customer is NULL',
+        params: {},
+      });
+    }
+
+    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 frm_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) => {
+        if (typeof val === 'string') {
+          // legacy case — old format like ['Active', 'Inactive']
+          return val.toLowerCase();
+        }
+
+        if (val && typeof val === 'object' && val.value !== undefined) {
+          // new format — [{ label: 'Active', value: '13023' }]
+          return String(val.value).toLowerCase();
+        }
+
+        return ''; // fallback safety
+      }) || [];
+
+    let filteredTabs = await this.getFilteredTabs(
+      layout,
+      showList,
+      entityMeta,
+      baseWhere,
+      tabs,
+      loggedInUser,
+    );
+
+    const dataWhere = [...baseWhere];
+
+    if (tabs?.columnName && tabs?.value) {
+      const tabAttrMeta = attributeMetaMap[tabs.columnName];
+      const tabValue = tabs.value.toLowerCase();
+
+      if (tabValue === 'others') {
+        // Extract 'value' (IDs) from showList, ignore 'all'
+        const valuesToExclude = showList
+          .filter((v) => v.label.toLowerCase() !== 'all')
+          .map((v) => v.value);
+
+        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);
+        }
+      }
+    }
+
+    let qb = this.dataSource
+      .createQueryBuilder()
+      .select('e.*')
+      .from(tableName, 'e');
+    dataWhere.forEach((clause) => qb.andWhere(clause.query, clause.params));
+
+    // Apply sorting
+    qb = await this.sortTabsByShowList(qb, sortby, layoutPreference, tabs);
+
+    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,
+        },
+      },
+    };
+  }
+
+  // GET FILTERED TABS LOGIC
+  private async getFilteredTabs(
+    layout: any,
+    showList: any,
+    entityMeta: any,
+    baseWhere: any,
+    tabs: any,
+    loggedInUser: any,
+  ) {
+    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: any[] = [];
+
+    if (showList?.length > 0) {
+      // Extract tab IDs (values)
+      const showValues = (showList || []).map((item) => {
+        const val = typeof item === 'object' ? item.value : item;
+        return val ? String(val).toLowerCase() : '';
+      });
+
+      // Handle "all" logic
+      const isAllNeeded = layout?.isAllSelected && !showValues.includes('all');
+      if (isAllNeeded) {
+        showList.push({ label: 'All', value: 'all' });
+        showValues.push('all');
+      }
+
+      // Filter by value IDs (not labels)
+      filteredTabs = allTabs.filter((tab) => {
+        const tabValueStr = tab.tab_value
+          ? String(tab.tab_value).toLowerCase()
+          : '';
+        return showValues.includes(tabValueStr);
+      });
+
+      // Handle "all" tab
+      const allTab = filteredTabs.find(
+        (tab) => tab.tab_value?.toString().toLowerCase() === 'all',
+      );
+      filteredTabs = filteredTabs.filter(
+        (tab) => tab.tab_value?.toString().toLowerCase() !== 'all',
+      );
+
+      // SORTING LOGIC
+      if (layout.sorting === 'asc') {
+        filteredTabs.sort((a, b) =>
+          a.tab_value.toString().localeCompare(b.tab_value.toString()),
+        );
+      } else if (layout.sorting === 'dsc') {
+        filteredTabs.sort((a, b) =>
+          b.tab_value.toString().localeCompare(a.tab_value.toString()),
+        );
+      } 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') {
+        // Keep order same as showList
+        const orderMap = new Map<string, number>(
+          showList.map((item, index) => [
+            item.value?.toString().toLowerCase(),
+            index,
+          ]),
+        );
+        filteredTabs.sort((a, b) => {
+          const aIndex =
+            orderMap.get(a.tab_value?.toString().toLowerCase()) ?? Infinity;
+          const bIndex =
+            orderMap.get(b.tab_value?.toString().toLowerCase()) ?? Infinity;
+          return aIndex - bIndex;
+        });
+      }
+
+      // Re-add "all" tab at beginning if needed
+      if (allTab) filteredTabs.unshift(allTab);
+
+      // Combine others if enabled
+      if (layout?.isCombineOther) {
+        const originalAllTab = allTabs.find(
+          (tab) => tab.tab_value?.toString().toLowerCase() === 'all',
+        );
+        const allCount = originalAllTab?.tab_value_count ?? 0;
+        const knownTabCountSum = filteredTabs
+          .filter((tab) => tab.tab_value?.toString().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;
+    }
+
+    return filteredTabs;
+  }
+
+  // SORTING LOGIC FOR TABS
+  private async sortTabsByShowList(
+    qb: any,
+    sortby: any,
+    layoutPreference: any,
+    tabs: any,
+  ) {
+    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',
+            );
+          },
+        );
+      }
+    }
+
+    if (Array.isArray(sortby) && sortby.length > 0) {
+      sortby.forEach(({ sortColum, sortType }) => {
+        if (sortColum) {
+          qb.addOrderBy(
+            `e.${sortColum}`,
+            sortType?.toUpperCase() === 'DSC' ? 'DESC' : 'ASC',
+          );
+        }
+      });
+    } else {
+      // fallback if no explicit sortby sent
+      qb.addOrderBy('e.created_date', 'DESC');
+    }
+
+    return qb;
+  }
+
+  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}`);
+    }
+  }
+}