rez_core 5.0.211 → 6.1.0

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

@@ -1,4 +1,9 @@
-import { BadRequestException, Inject, Injectable } from '@nestjs/common';
+import {
+  BadRequestException,
+  forwardRef,
+  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 { FilterCondition, FilterRequestDto } from '../dto/filter-request.dto';
@@ -11,21 +16,29 @@ import { LoggingService } from 'src/utils/service/loggingUtil.service';
 import { ConfigService } from '@nestjs/config';
 import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
 import { EntityManager } from 'typeorm';
+import { FlatjsonFilterService } from './flatjson-filter.service';
 
 @Injectable()
 export class FilterService {
   constructor(
     private entityManager: EntityManager,
+    @Inject(forwardRef(() => AttributeMasterService))
     private readonly attributeMasterService: AttributeMasterService,
+    @Inject(forwardRef(() => EntityMasterService))
     private readonly entityMasterService: EntityMasterService,
-    @Inject('SavedFilterService')
-    private readonly savedFilterService: SavedFilterService,
     @Inject('EntityRelationService')
     private readonly entityRelationService: EntityRelationService,
+    @Inject('SavedFilterService')
+    private readonly savedFilterService: SavedFilterService,
+    @Inject(forwardRef(() => ResolverService))
     private readonly resolverService: ResolverService,
-    @Inject() protected readonly loggingService: LoggingService,
+    @Inject(forwardRef(() => LoggingService))
+    protected readonly loggingService: LoggingService,
     private readonly configService: ConfigService,
+    @Inject(forwardRef(() => ReflectionHelper))
     private readonly reflectionHelper: ReflectionHelper,
+    @Inject(forwardRef(() => FlatjsonFilterService))
+    private readonly flatjsonFilterService: FlatjsonFilterService,
   ) {}
 
   schema = this.configService.get('DB_SCHEMA');
@@ -97,6 +110,51 @@ export class FilterService {
     ];
   }
 
+  /**
+   * Route to flatjson or traditional filtering based on configuration
+   */
+  async applyFilterWithRouting(dto: FilterRequestDto) {
+    // Check if flatjson filtering is enabled via config or query param
+    const useFlatjson = dto.queryParams?.use_flatjson === 'true';
+
+    if (useFlatjson) {
+      await this.loggingService.log(
+        'info',
+        'FilterService',
+        'applyFilterWithRouting',
+        `Using FLATJSON filtering for ${dto.entity_type}`,
+      );
+
+      // Use new flatjson filtering service
+      const result = await this.flatjsonFilterService.applyFlatjsonFilter(dto);
+
+      // Transform to match existing response format
+      return {
+        success: true,
+        data: {
+          entity_tabs: result.tabCounts || [],
+          entity_list: result.data,
+          pagination: {
+            total: result.total,
+            page: result.page,
+            size: result.size,
+            totalPages: result.totalPages,
+          },
+        },
+      };
+    } else {
+      await this.loggingService.log(
+        'info',
+        'FilterService',
+        'applyFilterWithRouting',
+        `Using TRADITIONAL filtering for ${dto.entity_type}`,
+      );
+
+      // Use traditional filtering
+      return this.applyFilterWrapper(dto);
+    }
+  }
+
   async applyFilterWrapper(dto: FilterRequestDto) {
     const {
       entity_type,
@@ -227,6 +285,7 @@ export class FilterService {
       id: user_id,
       appcode,
       organization_id,
+      enterprise_id,
     } = loggedInUser || {};
 
     // Fetch meta from entity table service
@@ -417,60 +476,60 @@ export class FilterService {
 
     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);
-        }
-      }
-    }
+    // 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.entityManager
       .createQueryBuilder()
@@ -513,11 +572,11 @@ export class FilterService {
 
     const formattedEntityList = entity_list.map(formatDatesInRow);
 
-    const resolvedEntityList = await Promise.all(
-      formattedEntityList.map((row) =>
-        this.resolverService.getResolvedData(loggedInUser, row, entity_type),
-      ),
-    );
+    // const resolvedEntityList = await Promise.all(
+    //   formattedEntityList.map((row) =>
+    //     this.resolverService.getResolvedData(loggedInUser, row, entity_type),
+    //   ),
+    // );
 
     const resolvedTabs = await Promise.all(
       filteredTabs.map(async (tab) => {
@@ -531,14 +590,14 @@ export class FilterService {
           return tab;
         }
 
-        const resolvedVal = await this.resolverService.getResolvedValue(
-          loggedInUser,
-          tabAttrKey,
-          tab.tab_value,
-          entity_type,
-        );
+        // const resolvedVal = await this.resolverService.getResolvedValue(
+        //   loggedInUser,
+        //   tabAttrKey,
+        //   tab.tab_value,
+        //   entity_type,
+        // );
 
-        return { ...tab, tab_value: resolvedVal ?? tab.tab_value };
+        return { ...tab, tab_value: tab.tab_value ?? tab.tab_value };
       }),
     );
 
@@ -558,7 +617,7 @@ export class FilterService {
       success: true,
       data: {
         entity_tabs: resolvedTabs,
-        entity_list: resolvedEntityList,
+        entity_list: formattedEntityList,
         pagination: {
           total,
           page,