rez_core 5.0.155 → 5.0.157

package/src/module/entity_json/entity/entityJson.entity.ts

@@ -29,11 +29,14 @@ export class EntityJson {
   created_by: number;
 
   @Column({ type: 'int', nullable: true })
-  updated_by: number;
+  organization_id: number;
 
   @CreateDateColumn({ type: 'timestamp', nullable: true })
   created_at: Date;
 
   @UpdateDateColumn({ type: 'timestamp', nullable: true })
   updated_at: Date;
+
+  @UpdateDateColumn({ type: 'varchar', nullable: true })
+  updated_by: string;
 }

package/src/module/entity_json/entity_json.module.ts

@@ -1,4 +1,4 @@
-import { Module } from '@nestjs/common';
+import { Module, forwardRef } from '@nestjs/common';
 import { EntityModule } from '../meta/entity.module';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { EntityJSONService } from './service/entity_json.service';
@@ -10,9 +10,14 @@ import { EntityJSONRepository } from './service/entityJson.repository';
 
 
 @Module({
-  imports: [EntityModule, TypeOrmModule.forFeature([EntityJson]),FilterModule,UtilsModule],
+  imports: [
+    forwardRef(() => EntityModule),
+    TypeOrmModule.forFeature([EntityJson]),
+    forwardRef(() => FilterModule),
+    UtilsModule,
+  ],
   controllers: [EntityJSONController],
   providers: [EntityJSONService,EntityJSONRepository],
-  exports: [],
+  exports: [EntityJSONService],
 })
 export class EntityJSONModule {}

package/src/module/entity_json/service/entity_json.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable, forwardRef } from '@nestjs/common';
 import { LinkedAttributes } from 'src/module/linked_attributes/entity/linked_attribute.entity';
 import { AttributeMaster } from 'src/module/meta/entity/attribute-master.entity';
 import { EntityRelation } from 'src/module/meta/entity/entity-relation.entity';
@@ -14,6 +14,7 @@ export class EntityJSONService extends EntityServiceImpl {
     private readonly dataSource: DataSource,
     private readonly loggerService: LoggingService,
     private readonly EntityJSONRepository: EntityJSONRepository,
+    @Inject(forwardRef(() => FilterService))
     private readonly filterService: FilterService,
   ) {
     super();
@@ -22,22 +23,40 @@ export class EntityJSONService extends EntityServiceImpl {
   async getAttributeForFlatJSON(
     entityType: string,
     loggedInUser: any,
-    flag?: 'flat_json' | 'dropdown' | 'all',
-  ) {
+    flag?: 'flat_json' | 'dropdown' | 'all' | 'filter_attribute',
+  ) : Promise<any> {
     const orgId = loggedInUser.organization_id;
-
-    await this.loggerService.log('info', 'EntityJSONService', 'getAttributeForFlatJSON', `Loading attributes for entity: ${entityType}, org: ${orgId}`);
-
+  
+    await this.loggerService.log(
+      'info',
+      'EntityJSONService',
+      'getAttributeForFlatJSON',
+      `Loading attributes for entity: ${entityType}, org: ${orgId}`,
+    );
+  
+    // MAIN ATTRIBUTES
     const mainAttributes = await this.dataSource
       .getRepository(AttributeMaster)
       .createQueryBuilder('attr')
-      .select(['attr.id', 'attr.name', 'attr.flat_json_key', 'attr.attribute_key'])
+      .select([
+        'attr.id',
+        'attr.name',
+        'attr.flat_json_key',
+        'attr.attribute_key',
+        'attr.data_type',
+      ])
       .where('attr.mapped_entity_type = :entityType', { entityType })
       .andWhere('attr.organization_id = :orgId', { orgId })
       .getMany();
-
-    await this.loggerService.log('debug', 'EntityJSONService', 'getAttributeForFlatJSON', `Loaded ${mainAttributes.length} main attributes`);
-
+  
+    await this.loggerService.log(
+      'debug',
+      'EntityJSONService',
+      'getAttributeForFlatJSON',
+      `Loaded ${mainAttributes.length} main attributes`,
+    );
+  
+    // RELATED ENTITY TYPES
     const relatedEntityTypes = await this.dataSource
       .getRepository(EntityRelation)
       .createQueryBuilder('rel')
@@ -46,23 +65,42 @@ export class EntityJSONService extends EntityServiceImpl {
       .andWhere('rel.organization_id = :orgId', { orgId })
       .andWhere('rel.relation_type = :relationType', { relationType: 'ONE_TO_ONE' })
       .getRawMany();
-
+  
     const relatedTypesList = relatedEntityTypes.map(x => x.rel_target_entity_type);
-
-    await this.loggerService.log('debug', 'EntityJSONService', 'getAttributeForFlatJSON', `Found ${relatedTypesList.length} ONE-TO-ONE related entity types`);
-
+  
+    await this.loggerService.log(
+      'debug',
+      'EntityJSONService',
+      'getAttributeForFlatJSON',
+      `Found ${relatedTypesList.length} ONE-TO-ONE related entity types`,
+    );
+  
+    // RELATED ATTRIBUTES
     const relatedAttributes = relatedTypesList.length
       ? await this.dataSource
-        .getRepository(AttributeMaster)
-        .createQueryBuilder('attr')
-        .select(['attr.id', 'attr.name', 'attr.flat_json_key', 'attr.mapped_entity_type', 'attr.attribute_key'])
-        .where('attr.mapped_entity_type IN (:...types)', { types: relatedTypesList })
-        .andWhere('attr.organization_id = :orgId', { orgId })
-        .getMany()
+          .getRepository(AttributeMaster)
+          .createQueryBuilder('attr')
+          .select([
+            'attr.id',
+            'attr.name',
+            'attr.flat_json_key',
+            'attr.mapped_entity_type',
+            'attr.attribute_key',
+            'attr.data_type',
+          ])
+          .where('attr.mapped_entity_type IN (:...types)', { types: relatedTypesList })
+          .andWhere('attr.organization_id = :orgId', { orgId })
+          .getMany()
       : [];
-
-    await this.loggerService.log('debug', 'EntityJSONService', 'getAttributeForFlatJSON', `Loaded ${relatedAttributes.length} related attributes`);
-
+  
+    await this.loggerService.log(
+      'debug',
+      'EntityJSONService',
+      'getAttributeForFlatJSON',
+      `Loaded ${relatedAttributes.length} related attributes`,
+    );
+  
+    // LINKED ATTRIBUTES
     const linkedAttributes = await this.dataSource
       .getRepository(LinkedAttributes)
       .createQueryBuilder('fla')
@@ -78,40 +116,109 @@ export class EntityJSONService extends EntityServiceImpl {
         'fla.saved_filter_code AS saved_filter_code',
         'attr.name AS name',
         'attr.id AS id',
+        'attr.data_type AS data_type',
       ])
       .where('attr.organization_id = :orgId', { orgId })
       .getRawMany();
-
-    await this.loggerService.log('debug', 'EntityJSONService', 'getAttributeForFlatJSON', `Loaded ${linkedAttributes.length} linked attributes`);
-
+  
+    await this.loggerService.log(
+      'debug',
+      'EntityJSONService',
+      'getAttributeForFlatJSON',
+      `Loaded ${linkedAttributes.length} linked attributes`,
+    );
+  
+    // -------------------------------------------------------------------------
+    // ✅ FLAG: filter_attribute (NEW)
+    // -------------------------------------------------------------------------
+    if (flag === 'filter_attribute') {
+      const filterAttributes: any[] = [];
+  
+      // MAIN
+      filterAttributes.push(
+        ...mainAttributes.map(a => ({
+          id: a.id,
+          name: a.name,
+          data_type: a.data_type,
+          flat_json_key: a.flat_json_key,
+          source: 'main',
+        })),
+      );
+  
+      // RELATED
+      filterAttributes.push(
+        ...relatedAttributes.map(a => ({
+          id: a.id,
+          name: a.name,
+          data_type: a.data_type,
+          flat_json_key: a.flat_json_key,
+          source: 'related',
+        })),
+      );
+  
+      // LINKED
+      filterAttributes.push(
+        ...linkedAttributes.map(l => ({
+          id: l.id,
+          name: l.name,
+          data_type: l.data_type,
+          flat_json_key: l.target_attribute_key, // attribute_key
+          source: 'linked',
+        })),
+      );
+  
+      return filterAttributes;
+    }
+  
+    // -------------------------------------------------------------------------
+    // ORIGINAL flat_json FLAG (unchanged)
+    // -------------------------------------------------------------------------
     if (flag === 'flat_json' || flag === 'all') {
       const result: Record<string, null> = {};
+  
       mainAttributes.forEach(attr => {
         if (attr.flat_json_key) result[attr.flat_json_key] = null;
       });
+  
       relatedAttributes.forEach(attr => {
         if (attr.flat_json_key) result[attr.flat_json_key] = null;
       });
+  
       linkedAttributes.forEach(link => {
         if (link.target_attribute_key) result[link.target_attribute_key] = null;
       });
-
+  
       if (flag === 'all') {
-        return { flat_json: result, attributes: { mainAttributes, relatedAttributes, linkedAttributes } };
+        return {
+          flat_json: result,
+          attributes: {
+            mainAttributes,
+            relatedAttributes,
+            linkedAttributes,
+          },
+        };
       }
-
+  
       return result;
     }
-
+  
+    // -------------------------------------------------------------------------
+    // ORIGINAL dropdown FLAG (unchanged)
+    // -------------------------------------------------------------------------
     const dropdown: any[] = [];
+  
     dropdown.push(...mainAttributes.map(a => ({ label: a.name, value: a.flat_json_key })));
     dropdown.push(...relatedAttributes.map(a => ({ label: a.name, value: a.flat_json_key })));
+  
     if (linkedAttributes.length > 0) {
-      dropdown.push(...linkedAttributes.map(a => ({ label: a.name, value: a.attribute_key })));
+      dropdown.push(
+        ...linkedAttributes.map(a => ({ label: a.name, value: a.target_attribute_key })),
+      );
     }
-
+  
     return dropdown;
   }
+  
 
   async updateEntityJSON(entityType: string, entityId: number, loggedInUser) {
     await this.loggerService.log('info', 'EntityJSONService', 'updateEntityJSON', `Building flat JSON for entity: ${entityType}#${entityId}`);

package/src/module/filter/controller/filter.controller.ts

@@ -48,9 +48,7 @@ export class FilterController {
       sortby,
     } = body;
 
-    
-
-    return this.filterService.applyFilterWrapper({
+    return this.filterService.applyFilterWithRouting({
       entity_type,
       quickFilter,
       savedFilterCode,

package/src/module/filter/entity/saved-filter-master.entity.ts

@@ -24,9 +24,6 @@ export class SavedFilterMaster extends BaseEntity {
   @Column({ type: 'boolean', default: false, nullable: true })
   is_shared: boolean;
 
-  @Column({ type: 'boolean', default: false, nullable: true })
-  is_editable: boolean;
-
-  @Column({ type: 'varchar', length: 200, nullable: true })
-  description: string;
+  @Column({ type: 'varchar', length: 100, nullable: true })
+  is_editable: string;
 }

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

@@ -5,15 +5,22 @@ import { SavedFilterDetail } from './entity/saved-filter-detail.entity';
 import { SavedFilterMaster } from './entity/saved-filter-master.entity';
 import { SavedFilterRepositoryService } from './repository/saved-filter.repository';
 import { EntityModule } from '../meta/entity.module';
+import { EntityJSONModule } from '../entity_json/entity_json.module';
 import { FilterService } from './service/filter.service';
 import { FilterController } from './controller/filter.controller';
 import { FilterEvaluatorService } from './service/filter-evaluator.service';
 import { SavedFilterDetailRepository } from './repository/saved.filter-detail.repository';
+import { FlatjsonFilterService } from './service/flatjson-filter.service';
+import { ConfigModule } from '@nestjs/config';
+import { UtilsModule } from 'src/utils/utils.module';
 
 @Module({
   imports: [
     TypeOrmModule.forFeature([SavedFilterDetail, SavedFilterMaster]),
-    forwardRef(() => EntityModule)
+    forwardRef(() => EntityModule),
+    forwardRef(() => EntityJSONModule),
+    ConfigModule,
+    UtilsModule,
   ],
   controllers: [FilterController],
   providers: [
@@ -21,13 +28,15 @@ import { SavedFilterDetailRepository } from './repository/saved.filter-detail.re
     SavedFilterRepositoryService,
     FilterService,
     FilterEvaluatorService,
-    SavedFilterDetailRepository
+    SavedFilterDetailRepository,
+    FlatjsonFilterService,
   ],
   exports: [
     'SavedFilterService',
     SavedFilterRepositoryService,
     FilterService,
     FilterEvaluatorService,
+    FlatjsonFilterService,
   ],
 })
 export class FilterModule {}

package/src/module/filter/repository/saved-filter.repository.ts

@@ -107,7 +107,6 @@ export class SavedFilterRepositoryService {
       value: filter.id,
       code: filter.code,
     }));
-    // return filters;
   }
 
   async getSharedFiltersByLevelTypeAndLevelId(
@@ -128,14 +127,11 @@ export class SavedFilterRepositoryService {
       },
     });
 
-    return filters;
-
-    // return filters.map((filter) => ({
-    //   label: filter.name,
-    //   value: filter.id,
-    //   code: filter.code,
-
-    // }));
+    return filters.map((filter) => ({
+      label: filter.name,
+      value: filter.id,
+      code: filter.code,
+    }));
   }
 
   async getFilterById(id: number): Promise<

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

@@ -11,6 +11,7 @@ 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 {
@@ -26,6 +27,7 @@ export class FilterService {
     @Inject() protected readonly loggingService: LoggingService,
     private readonly configService: ConfigService,
     private readonly reflectionHelper: ReflectionHelper,
+    private readonly flatjsonFilterService: FlatjsonFilterService,
   ) {}
 
   private async gettab_value_counts(
@@ -96,6 +98,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,
@@ -421,60 +468,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 +564,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 +582,15 @@ 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 +610,7 @@ export class FilterService {
       success: true,
       data: {
         entity_tabs: resolvedTabs,
-        entity_list: resolvedEntityList,
+        entity_list: formattedEntityList,
         pagination: {
           total,
           page,