rez_core 5.0.210 → 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,23 +16,30 @@ 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');
 
@@ -82,7 +94,6 @@ export class FilterService {
         GROUP BY ${column}
     `;
 
-
     const rows = await this.entityManager.query(rawSQL, values);
 
     const total = rows.reduce(
@@ -99,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,
@@ -229,6 +285,7 @@ export class FilterService {
       id: user_id,
       appcode,
       organization_id,
+      enterprise_id,
     } = loggedInUser || {};
 
     // Fetch meta from entity table service
@@ -284,7 +341,6 @@ export class FilterService {
 
     // Handle TEMPLATE entity special condition
     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}'))`,
@@ -325,8 +381,7 @@ export class FilterService {
       !customLevelId
     ) {
       baseWhere.push({
-        query:
-          'e.level_type = :level_type AND e.level_id = :level_id',
+        query: 'e.level_type = :level_type AND e.level_id = :level_id',
         params: {
           level_type,
           level_id,
@@ -421,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()
@@ -517,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) => {
@@ -535,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 };
       }),
     );
 
@@ -562,7 +617,7 @@ export class FilterService {
       success: true,
       data: {
         entity_tabs: resolvedTabs,
-        entity_list: resolvedEntityList,
+        entity_list: formattedEntityList,
         pagination: {
           total,
           page,
@@ -694,30 +749,28 @@ export class FilterService {
     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 sorting = layoutPreference?.mapped_json?.sorting;
+
+    if (sorting) {
+      if (Array.isArray(sorting?.tabs)) {
+        const preferenceTabArray = sorting?.tabs;
         const tabFilter = preferenceTabArray.find(
-          (tabData) => tabData.tab_name === tabs?.value,
+          (tabData) => tabData.tab_name?.value === tabs?.value,
         );
-        tabFilter?.sortby.forEach(({ column, order }) => {
+
+        tabFilter?.sortby?.forEach(({ column, order }) => {
+          qb.addOrderBy(
+            `e.${column}`,
+            order?.toUpperCase() === 'DSC' ? 'DESC' : 'ASC',
+          );
+        });
+      } else if (Array.isArray(sorting.sortby)) {
+        sorting?.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',
-            );
-          },
-        );
       }
     }