rez_core 6.5.55 → 6.5.57

package/dist/module/filter/service/filter.service.js

@@ -0,0 +1,921 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterService = void 0;
+const common_1 = require("@nestjs/common");
+const attribute_master_service_1 = require("../../meta/service/attribute-master.service");
+const entity_master_service_1 = require("../../meta/service/entity-master.service");
+const saved_filter_service_1 = require("./saved-filter.service");
+const moment = require("moment");
+const entity_relation_service_1 = require("../../meta/service/entity-relation.service");
+const resolver_service_1 = require("../../meta/service/resolver.service");
+const loggingUtil_service_1 = require("../../../utils/service/loggingUtil.service");
+const config_1 = require("@nestjs/config");
+const reflection_helper_service_1 = require("../../../utils/service/reflection-helper.service");
+const typeorm_1 = require("typeorm");
+let FilterService = class FilterService {
+    constructor(entityManager, attributeMasterService, entityMasterService, savedFilterService, entityRelationService, resolverService, loggingService, configService, reflectionHelper) {
+        this.entityManager = entityManager;
+        this.attributeMasterService = attributeMasterService;
+        this.entityMasterService = entityMasterService;
+        this.savedFilterService = savedFilterService;
+        this.entityRelationService = entityRelationService;
+        this.resolverService = resolverService;
+        this.loggingService = loggingService;
+        this.configService = configService;
+        this.reflectionHelper = reflectionHelper;
+        this.schema = this.configService.get('DB_SCHEMA');
+    }
+    async gettab_value_counts(tableName, column, whereClauses) {
+        if (!column)
+            return [];
+        let whereSQL = '';
+        const values = [];
+        let paramIndex = 1;
+        if (whereClauses.length > 0) {
+            const clauseParts = whereClauses.map((clause) => {
+                let parsedQuery = clause.query.replace(/\be\./g, '');
+                Object.entries(clause.params).forEach(([key, val]) => {
+                    if (Array.isArray(val)) {
+                        const placeholders = val.map(() => `$${paramIndex++}`).join(', ');
+                        parsedQuery = parsedQuery.replace(new RegExp(`:${key}`, 'g'), `(${placeholders})`);
+                        values.push(...val.map((v) => String(v)));
+                    }
+                    else {
+                        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 ${this.schema}.${tableName} ${whereSQL}
+        GROUP BY ${column}
+    `;
+        const rows = await this.entityManager.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) {
+        const { entity_type, quickFilter = [], savedFilterCode, attributeFilter = [], loggedInUser, } = dto;
+        const savedFilters = await this.getSavedFilters(savedFilterCode ?? undefined);
+        const allFilters = [
+            ...quickFilter,
+            ...attributeFilter,
+            ...savedFilters,
+        ].filter((f) => f.filter_value !== '');
+        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;
+        }, {});
+        console.log('🟠 [FilterService] Grouped filters by entity type:', grouped);
+        let intersectionIds = null;
+        for (const [subEntityType, filters] of Object.entries(grouped)) {
+            if (subEntityType === entity_type)
+                continue;
+            let { queryParams, tabs, ...newDto } = dto;
+            const subDto = {
+                ...newDto,
+                entity_type: subEntityType,
+                quickFilter: filters,
+                savedFilterCode: null,
+                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.enterprise_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: {} },
+                };
+            }
+        }
+        const mainFilters = grouped[entity_type] || [];
+        const mainDto = {
+            ...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) {
+        const { entity_type, quickFilter, savedFilterCode, attributeFilter, tabs, sortby, loggedInUser, queryParams, customLevelType, customLevelId, customAppCode, } = dto;
+        const { level_type, level_id, id: user_id, enterprise_id, } = loggedInUser || {};
+        const entityMeta = await this.entityMasterService.getEntityData(entity_type, loggedInUser);
+        const tableName = entityMeta?.data_source;
+        if (!tableName) {
+            console.error(`❌ [FilterService] Invalid entity_type: ${entity_type}`);
+            throw new common_1.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;
+        }, {});
+        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 !== ''),
+        ];
+        const baseWhere = this.buildWhereClauses(baseFilters, attributeMetaMap);
+        if (entity_type === 'TEMP' || entity_type === 'TEM') {
+            if (level_type === 'ORG') {
+                baseWhere.push({
+                    query: `  ((e.level_type = 'ORG' AND e.level_id = '${loggedInUser.enterprise_id}'))`,
+                    params: {},
+                });
+            }
+            else if (level_type === 'SCH') {
+                baseWhere.push({
+                    query: `
+        (
+          (e.level_type = 'SCH' AND e.level_id = '${loggedInUser.level_id}')
+          OR 
+          (
+            e.level_type = 'ORG'
+            AND e.level_id = '${loggedInUser.enterprise_id}'
+            AND e.enterprise_id = '${loggedInUser.enterprise_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: {},
+                });
+            }
+        }
+        if (entity_type !== 'ORGP' &&
+            entity_type !== 'TEMP' &&
+            entity_type !== 'TEM' &&
+            level_type &&
+            level_id &&
+            enterprise_id &&
+            !customLevelType &&
+            !customLevelId) {
+            baseWhere.push({
+                query: 'e.level_type = :level_type AND e.level_id = :level_id',
+                params: {
+                    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.level_type = :customLevelType AND e.level_id = :customLevelId AND e.appcode = :customAppCode',
+                params: {
+                    customLevelType,
+                    customLevelId: String(customLevelId),
+                    customAppCode,
+                },
+            });
+        }
+        if (queryParams) {
+            Object.entries(queryParams).forEach(([key, value]) => {
+                if (!value)
+                    return;
+                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 },
+                    });
+                }
+                else if (key !== 'attributeValue') {
+                    baseWhere.push({
+                        query: `e.${key} = :${key}`,
+                        params: { [key]: strValue },
+                    });
+                }
+            });
+        }
+        console.log('🟠 [FilterService] Constructed baseWhere clauses:', baseWhere);
+        let layoutPreferenceRepo = this.reflectionHelper.getRepoService('LayoutPreference');
+        const layoutPreference = await layoutPreferenceRepo.findOne({
+            where: {
+                user_id: user_id,
+                mapped_entity_type: entity_type,
+                mapped_level_id: level_id,
+                mapped_level_type: level_type,
+                type: 'layout',
+            },
+        });
+        const layout = layoutPreference?.mapped_json?.quick_tab || {};
+        const showList = layout?.show_list?.map((val) => {
+            if (typeof val === 'string') {
+                return val.toLowerCase();
+            }
+            if (val && typeof val === 'object' && val.value !== undefined) {
+                return String(val.value).toLowerCase();
+            }
+            return '';
+        }) || [];
+        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') {
+                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.entityManager
+            .createQueryBuilder()
+            .select('e.*')
+            .from(`${this.schema}.${tableName}`, 'e');
+        dataWhere.forEach((clause) => qb.andWhere(clause.query, clause.params));
+        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;
+        if (dto.page && dto.size) {
+            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) => dateStr ? moment(dateStr).format('DD-MM-YYYY') : '';
+        const formatDatesInRow = (row) => {
+            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.entityManager
+            .createQueryBuilder()
+            .select('COUNT(*)', 'count')
+            .from(`${this.schema}.${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,
+                },
+            },
+        };
+    }
+    async getFilteredTabs(layout, showList, entityMeta, baseWhere, tabs, loggedInUser) {
+        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 showValues = (showList || []).map((item) => {
+                const val = typeof item === 'object' ? item.value : item;
+                return val ? String(val).toLowerCase() : '';
+            });
+            const isAllNeeded = layout?.isAllSelected && !showValues.includes('all');
+            if (isAllNeeded) {
+                showList.push({ label: 'All', value: 'all' });
+                showValues.push('all');
+            }
+            filteredTabs = allTabs.filter((tab) => {
+                const tabValueStr = tab.tab_value
+                    ? String(tab.tab_value).toLowerCase()
+                    : '';
+                return showValues.includes(tabValueStr);
+            });
+            const allTab = filteredTabs.find((tab) => tab.tab_value?.toString().toLowerCase() === 'all');
+            filteredTabs = filteredTabs.filter((tab) => tab.tab_value?.toString().toLowerCase() !== 'all');
+            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') {
+                const orderMap = new Map(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;
+                });
+            }
+            if (allTab)
+                filteredTabs.unshift(allTab);
+            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;
+    }
+    async sortTabsByShowList(qb, sortby, layoutPreference, tabs) {
+        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 {
+            qb.addOrderBy('e.created_date', 'DESC');
+        }
+        return qb;
+    }
+    parseFilters(raw, isSingle = false) {
+        if (!raw)
+            return [];
+        if (typeof raw === 'string') {
+            try {
+                const parsed = JSON.parse(raw);
+                return isSingle ? [parsed] : parsed;
+            }
+            catch {
+                throw new common_1.BadRequestException('Invalid JSON in filter input');
+            }
+        }
+        return isSingle ? [raw] : Array.isArray(raw) ? raw : [];
+    }
+    async getSavedFilters(code) {
+        if (!code)
+            return [];
+        const savedFilter = await this.savedFilterService.getDetailsByCode(code);
+        if (!savedFilter) {
+            throw new common_1.BadRequestException(`Saved filter not found for code: ${code}`);
+        }
+        return savedFilter;
+    }
+    buildWhereClauses(filters, attributeMeta) {
+        return filters
+            .map((f) => {
+            const clause = this.buildCondition(f, attributeMeta[f.filter_attribute]);
+            if (!clause)
+                return null;
+            if (clause.params) {
+                Object.keys(clause.params).forEach((k) => {
+                    const val = clause.params[k];
+                    if (!Array.isArray(val)) {
+                        clause.params[k] = String(val);
+                    }
+                });
+            }
+            return clause;
+        })
+            .filter((clause) => clause !== null);
+    }
+    buildCondition(filter, meta) {
+        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)}`;
+        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;
+        }
+    }
+    buildTextCondition(attr, op, val, key) {
+        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 common_1.BadRequestException(`Unsupported operator for text: ${op}`);
+        }
+    }
+    buildNumberCondition(attr, op, val, key) {
+        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 common_1.BadRequestException(`Unsupported operator for number: ${op}`);
+        }
+    }
+    buildDateCondition(attr, op, val, key) {
+        const dateColumn = `DATE(e.${attr})`;
+        const monthColumn = `DATE_TRUNC('month', e.${attr})`;
+        const numVal = Number(val);
+        const subtractBusinessDays = (days) => {
+            let d = new Date();
+            let count = 0;
+            while (count < days) {
+                d.setDate(d.getDate() - 1);
+                const day = d.getDay();
+                if (day !== 0 && day !== 6) {
+                    count++;
+                }
+            }
+            return d.toISOString().split('T')[0];
+        };
+        switch (op) {
+            case 'equal':
+            case 'is':
+                return {
+                    query: `${dateColumn} = :${key}`,
+                    params: { [key]: val },
+                };
+            case 'before':
+            case 'is_before':
+                return {
+                    query: `${dateColumn} < :${key}`,
+                    params: { [key]: val },
+                };
+            case 'after':
+            case 'is_after':
+                return {
+                    query: `${dateColumn} > :${key}`,
+                    params: { [key]: val },
+                };
+            case 'is_on_or_before':
+                return {
+                    query: `${dateColumn} <= :${key}`,
+                    params: { [key]: val },
+                };
+            case 'is_on_or_after':
+                return {
+                    query: `${dateColumn} >= :${key}`,
+                    params: { [key]: val },
+                };
+            case 'empty':
+                return {
+                    query: `e.${attr} IS NULL`,
+                    params: {},
+                };
+            case 'not_empty':
+                return {
+                    query: `e.${attr} IS NOT NULL`,
+                    params: {},
+                };
+            case 'is_day_before':
+                if (isNaN(numVal)) {
+                    throw new common_1.BadRequestException('Value must be a number for is_day_before');
+                }
+                const dayBefore = (() => {
+                    const d = new Date();
+                    d.setDate(d.getDate() - numVal);
+                    return d.toLocaleDateString('en-CA', { timeZone: 'Asia/Kolkata' });
+                })();
+                return {
+                    query: `${dateColumn} <= :${key}`,
+                    params: { [key]: dayBefore },
+                };
+            case 'is_day_after':
+                if (isNaN(numVal)) {
+                    throw new common_1.BadRequestException('Value must be a number for is_day_after');
+                }
+                const dayAfter = (() => {
+                    const d = new Date();
+                    d.setDate(d.getDate() - 1 + numVal);
+                    return d.toISOString().split('T')[0];
+                })();
+                return {
+                    query: `${dateColumn} > :${key}`,
+                    params: { [key]: dayAfter },
+                };
+            case 'is_month_before':
+                if (isNaN(numVal)) {
+                    throw new common_1.BadRequestException('Value must be a number for is_month_before');
+                }
+                const monthBefore = (() => {
+                    const d = new Date();
+                    d.setMonth(d.getMonth() - numVal);
+                    d.setDate(1);
+                    d.setDate(d.getDate() - 1);
+                    return d.toISOString().split('T')[0];
+                })();
+                return {
+                    query: `${monthColumn} < DATE_TRUNC('month', (:${key})::date)`,
+                    params: { [key]: monthBefore },
+                };
+            case 'is_month_after':
+                if (isNaN(numVal)) {
+                    throw new common_1.BadRequestException('Value must be a number for is_month_after');
+                }
+                const monthAfter = (() => {
+                    const d = new Date();
+                    d.setMonth(d.getMonth() + numVal);
+                    d.setDate(1);
+                    d.setDate(d.getDate() - 1);
+                    return d.toISOString().split('T')[0];
+                })();
+                return {
+                    query: `${monthColumn} > DATE_TRUNC('month', (:${key})::date)`,
+                    params: { [key]: monthAfter },
+                };
+            case 'between': {
+                if (typeof val === 'string') {
+                    val = val.split(',').map((v) => v.trim());
+                }
+                if (!Array.isArray(val) ||
+                    val.length !== 2 ||
+                    val[0] === '' ||
+                    val[1] === '') {
+                    console.log(`Invalid value for between: ${val}`);
+                    return null;
+                }
+                return {
+                    query: `${dateColumn} BETWEEN :${key}_start AND :${key}_end`,
+                    params: {
+                        [`${key}_start`]: val[0],
+                        [`${key}_end`]: val[1],
+                    },
+                };
+            }
+            case 'today': {
+                const today = moment().format('YYYY-MM-DD');
+                return {
+                    query: `${dateColumn} = :today`,
+                    params: { today },
+                };
+            }
+            case 'is_before_business_days': {
+                if (isNaN(numVal)) {
+                    throw new common_1.BadRequestException('Value must be a number');
+                }
+                const targetDate = subtractBusinessDays(numVal);
+                return {
+                    query: `${dateColumn} <= :${key} AND EXTRACT(DOW FROM ${dateColumn}) NOT IN (0, 6)`,
+                    params: { [key]: targetDate },
+                };
+            }
+            case 'is_after_business_days': {
+                if (isNaN(numVal)) {
+                    throw new common_1.BadRequestException('Value must be a number for is_after_business_days');
+                }
+                const businessAfter = (() => {
+                    let d = new Date();
+                    let count = 0;
+                    while (count < numVal) {
+                        d.setDate(d.getDate() + 1);
+                        const day = d.getDay();
+                        if (day !== 0 && day !== 6)
+                            count++;
+                    }
+                    d.setDate(d.getDate() - 1);
+                    return d.toISOString().split('T')[0];
+                })();
+                return {
+                    query: `${dateColumn} > :${key}`,
+                    params: { [key]: businessAfter },
+                };
+            }
+            case 'in_last_day': {
+                if (isNaN(numVal)) {
+                    throw new common_1.BadRequestException('Value must be a number for in_last_day');
+                }
+                const today = (() => {
+                    const d = new Date();
+                    return d.toISOString().split('T')[0];
+                })();
+                const lastN = (() => {
+                    const d = new Date();
+                    d.setDate(d.getDate() - numVal);
+                    return d.toISOString().split('T')[0];
+                })();
+                return {
+                    query: `${dateColumn} BETWEEN :${key}_start AND :${key}_end`,
+                    params: {
+                        [`${key}_start`]: lastN,
+                        [`${key}_end`]: today,
+                    },
+                };
+            }
+            case 'in_next_day': {
+                if (isNaN(numVal)) {
+                    throw new common_1.BadRequestException('Value must be a number for in_next_day');
+                }
+                const today = (() => {
+                    const d = new Date();
+                    return d.toISOString().split('T')[0];
+                })();
+                const nextN = (() => {
+                    const d = new Date();
+                    d.setDate(d.getDate() + numVal);
+                    return d.toISOString().split('T')[0];
+                })();
+                return {
+                    query: `${dateColumn} BETWEEN :${key}_start AND :${key}_end`,
+                    params: {
+                        [`${key}_start`]: today,
+                        [`${key}_end`]: nextN,
+                    },
+                };
+            }
+            default:
+                throw new common_1.BadRequestException(`Unsupported operator for date: ${op}`);
+        }
+    }
+    buildSelectCondition(attr, op, val, key) {
+        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 common_1.BadRequestException(`Unsupported operator for select: ${op}`);
+        }
+    }
+    buildMultiSelectCondition(attr, op, val, key) {
+        let arr = [];
+        if (Array.isArray(val)) {
+            arr = val.map((v) => String(v));
+        }
+        else if (typeof val === 'string') {
+            arr = val.split(',').map((v) => v.trim());
+        }
+        else {
+            throw new common_1.BadRequestException(`Invalid multiselect value`);
+        }
+        if (arr.length === 0) {
+            return { query: '1=1', params: {} };
+        }
+        if (op === 'equal') {
+            return {
+                query: `e.${attr}::text IN (:...${key})`,
+                params: { [key]: arr },
+            };
+        }
+        if (op === 'not_equal') {
+            return {
+                query: `e.${attr}::text NOT IN (:...${key})`,
+                params: { [key]: arr },
+            };
+        }
+        if (op === 'contains') {
+            return {
+                query: `e.${attr}::text LIKE :${key}`,
+                params: { [key]: `%${val}%` },
+            };
+        }
+        if (op === 'not_contains') {
+            return {
+                query: `e.${attr}::text NOT LIKE :${key}`,
+                params: { [key]: `%${val}%` },
+            };
+        }
+        if (op === 'empty')
+            return { query: `e.${attr} IS NULL`, params: {} };
+        if (op === 'not_empty')
+            return { query: `e.${attr} IS NOT NULL`, params: {} };
+        throw new common_1.BadRequestException(`Unsupported operator: ${op}`);
+    }
+    buildYearCondition(attr, op, val, key) {
+        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 common_1.BadRequestException(`Unsupported operator for year: ${op}`);
+        }
+    }
+    async queryWithSchema(sql, params = []) {
+        await this.entityManager.query('BEGIN');
+        await this.entityManager.query(`SET LOCAL search_path TO ${this.schema}`);
+        const result = await this.entityManager.query(sql, params);
+        await this.entityManager.query('COMMIT');
+        return result;
+    }
+};
+exports.FilterService = FilterService;
+exports.FilterService = FilterService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(3, (0, common_1.Inject)('SavedFilterService')),
+    __param(4, (0, common_1.Inject)('EntityRelationService')),
+    __param(6, (0, common_1.Inject)()),
+    __metadata("design:paramtypes", [typeorm_1.EntityManager,
+        attribute_master_service_1.AttributeMasterService,
+        entity_master_service_1.EntityMasterService,
+        saved_filter_service_1.SavedFilterService,
+        entity_relation_service_1.EntityRelationService,
+        resolver_service_1.ResolverService,
+        loggingUtil_service_1.LoggingService,
+        config_1.ConfigService,
+        reflection_helper_service_1.ReflectionHelper])
+], FilterService);
+//# sourceMappingURL=filter.service.js.map