rez_core 6.5.23 → 6.5.25

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';
@@ -8,11 +8,15 @@ import { UtilsModule } from 'src/utils/utils.module';
 import { EntityJson } from './entity/entityJson.entity';
 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: [],
+  providers: [EntityJSONService, EntityJSONRepository],
+  exports: [EntityJSONService],
 })
 export class EntityJSONModule {}

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

@@ -7,38 +7,57 @@ import { LoggingService } from 'src/utils/service/loggingUtil.service';
 import { DataSource } from 'typeorm';
 import { EntityJSONRepository } from './entityJson.repository';
 import { FilterService } from '../../filter/service/filter.service';
+import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
+import { ResolverService } from 'src/module/meta/service/resolver.service';
 
 @Injectable()
-export class EntityJSONService {
+export class EntityJSONService  {
   constructor(
     private readonly dataSource: DataSource,
     private readonly loggerService: LoggingService,
     private readonly EntityJSONRepository: EntityJSONRepository,
-    @Inject(forwardRef(() => FilterService))
-    private readonly filterService: FilterService,
-    @Inject(forwardRef(() => EntityServiceImpl))
-    private readonly entityServiceImpl: EntityServiceImpl,
-  ) {}
+    @Inject(forwardRef(() => FilterService)) private readonly filterService: FilterService,
+    @Inject(forwardRef(() => EntityServiceImpl)) private readonly entityServiceImpl: EntityServiceImpl
+  ) {
+  }
 
   async getAttributeForFlatJSON(
     entityType: string,
     loggedInUser: any,
-    flag?: 'flat_json' | 'dropdown' | 'all',
-  ) {
-    const entId = loggedInUser.entId;
-
-    await this.loggerService.log('info', 'EntityJSONService', 'getAttributeForFlatJSON', `Loading attributes for entity: ${entityType}, ent: ${entId}`);
-
+    flag?: 'flat_json' | 'dropdown' | 'all' | 'filter_attribute',
+  ): Promise<any> {
+    const entId = loggedInUser.enterprise_id;
+
+    await this.loggerService.log(
+      'info',
+      'EntityJSONService',
+      'getAttributeForFlatJSON',
+      `Loading attributes for entity: ${entityType}, org: ${entId}`,
+    );
+
+    // 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.enterprise_id = :entId', { entId })
       .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')
@@ -48,22 +67,45 @@ export class EntityJSONService {
       .andWhere('rel.relation_type = :relationType', { relationType: 'ONE_TO_ONE' })
       .getRawMany();
 
-    const relatedTypesList = relatedEntityTypes.map(x => x.rel_target_entity_type);
+    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.enterprise_id = :entId', { entId })
-        .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.enterprise_id = :entId', { entId })
+          .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')
@@ -79,48 +121,145 @@ export class EntityJSONService {
         'fla.saved_filter_code AS saved_filter_code',
         'attr.name AS name',
         'attr.id AS id',
+        'attr.data_type AS data_type',
       ])
       .where('attr.enterprise_id = :entId', { entId })
       .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 => {
+
+      mainAttributes.forEach((attr) => {
         if (attr.flat_json_key) result[attr.flat_json_key] = null;
       });
-      relatedAttributes.forEach(attr => {
+
+      relatedAttributes.forEach((attr) => {
         if (attr.flat_json_key) result[attr.flat_json_key] = null;
       });
-      linkedAttributes.forEach(link => {
+
+      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 })));
+
+    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}`);
-
-    const response = await this.getAttributeForFlatJSON(entityType, loggedInUser, 'all');
-
-    if (!response || !('flat_json' in response) || !('attributes' in response) || !response.attributes) {
-      await this.loggerService.log('error', 'EntityJSONService', 'updateEntityJSON', `getAttributeForFlatJSON() did not return expected structure`);
+    await this.loggerService.log(
+      'info',
+      'EntityJSONService',
+      'updateEntityJSON',
+      `Building flat JSON for entity: ${entityType}#${entityId}`,
+    );
+
+    const response = await this.getAttributeForFlatJSON(
+      entityType,
+      loggedInUser,
+      'all',
+    );
+
+    if (
+      !response ||
+      !('flat_json' in response) ||
+      !('attributes' in response) ||
+      !response.attributes
+    ) {
+      await this.loggerService.log(
+        'error',
+        'EntityJSONService',
+        'updateEntityJSON',
+        `getAttributeForFlatJSON() did not return expected structure`,
+      );
       return null;
     }
 
@@ -134,25 +273,42 @@ export class EntityJSONService {
     };
 
     const attrMap: Record<string, string> = {};
-    const allAttrs = [...safeAttributes.mainAttributes, ...safeAttributes.relatedAttributes];
-    allAttrs.forEach(attr => {
-      if (attr.attribute_key) attrMap[attr.attribute_key] = attr.flat_json_key || attr.attribute_key;
+    const allAttrs = [
+      ...safeAttributes.mainAttributes,
+      ...safeAttributes.relatedAttributes,
+    ];
+    allAttrs.forEach((attr) => {
+      if (attr.attribute_key)
+        attrMap[attr.attribute_key] = attr.flat_json_key || attr.attribute_key;
     });
 
-    const mainData = await this.entityServiceImpl.getResolvedEntityData(entityType, entityId, loggedInUser);
+    const mainData = await this.entityServiceImpl.getResolvedEntityData(
+      entityType,
+      entityId,
+      loggedInUser,
+      true
+    );
     this.mergeEntityDataIntoFlatJson(flatJson, mainData, attrMap);
 
     const relations = await this.dataSource
       .getRepository('frm_entity_relation_data')
       .createQueryBuilder('erd')
-      .select(['erd.target_entity_id AS target_entity_id', 'erd.target_entity_type AS target_entity_type'])
+      .select([
+        'erd.target_entity_id AS target_entity_id',
+        'erd.target_entity_type AS target_entity_type',
+      ])
       .where('erd.source_entity_type = :entityType', { entityType })
       .andWhere('erd.source_entity_id = :entityId', { entityId })
       .andWhere('erd.relation_type = :rt', { rt: 'ONE_TO_ONE' })
       .getRawMany();
 
     for (const rel of relations) {
-      const relatedData = await this.entityServiceImpl.getResolvedEntityData(rel.target_entity_type, rel.target_entity_id, loggedInUser);
+      const relatedData = await this.entityServiceImpl.getResolvedEntityData(
+        rel.target_entity_type,
+        rel.target_entity_id,
+        loggedInUser,
+        true
+      );
       this.mergeEntityDataIntoFlatJson(flatJson, relatedData, attrMap);
     }
 
@@ -180,7 +336,12 @@ export class EntityJSONService {
       }
     }
 
-    await this.loggerService.log('info', 'EntityJSONService', 'updateEntityJSON', `Saving flat JSON for entity: ${entityType}#${entityId}`);
+    await this.loggerService.log(
+      'info',
+      'EntityJSONService',
+      'updateEntityJSON',
+      `Saving flat JSON for entity: ${entityType}#${entityId}`,
+    );
     let JsonData = {
       entity_type: entityType,
       entity_id: entityId,
@@ -193,7 +354,11 @@ export class EntityJSONService {
     return flatJson;
   }
 
-  private mergeEntityDataIntoFlatJson(flatJson: Record<string, any>, entityData: any | any[], attrMap: Record<string, string>) {
+  private mergeEntityDataIntoFlatJson(
+    flatJson: Record<string, any>,
+    entityData: any | any[],
+    attrMap: Record<string, string>,
+  ) {
     const records = Array.isArray(entityData) ? entityData : [entityData];
 
     for (const record of records) {
@@ -216,7 +381,11 @@ export class EntityJSONService {
     loggedInUser,
     entity_id,
   ) {
-    if (!savedFilterCode && (mappingValue === null || mappingValue === undefined)) return null;
+    if (
+      !savedFilterCode &&
+      (mappingValue === null || mappingValue === undefined)
+    )
+      return null;
 
     const dto: any = {
       entity_type: childEntityType,
@@ -225,18 +394,32 @@ export class EntityJSONService {
       size: 1,
     };
 
-    if (mappingValue !== null && mappingValue !== undefined && mappingValue !== '') {
+    if (
+      mappingValue !== null &&
+      mappingValue !== undefined &&
+      mappingValue !== ''
+    ) {
       dto.quickFilter = [
-        { filter_attribute: childFilterAttribute, filter_operator: 'equal', filter_value: mappingValue },
+        {
+          filter_attribute: childFilterAttribute,
+          filter_operator: 'equal',
+          filter_value: mappingValue,
+        },
       ];
     }
 
     dto.quickFilter = [
-      { filter_attribute: 'parent_id', filter_operator: 'equal', filter_value: [entity_id] },
+      {
+        filter_attribute: 'parent_id',
+        filter_operator: 'equal',
+        filter_value: [entity_id],
+      },
     ];
 
     const result = await this.filterService.applyFilter(dto);
     const rows = result?.data?.entity_list || [];
     return rows.length ? (rows[0][childFilterAttribute] ?? null) : null;
   }
+
+
 }

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

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

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 {}
+export class FilterModule {}