rez_core 6.5.61 → 6.5.62

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

@@ -7,57 +7,38 @@ 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' | '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
+    flag?: 'flat_json' | 'dropdown' | 'all',
+  ) {
+    const entId = loggedInUser.entId;
+
+    await this.loggerService.log('info', 'EntityJSONService', 'getAttributeForFlatJSON', `Loading attributes for entity: ${entityType}, ent: ${entId}`);
+
     const mainAttributes = await this.dataSource
       .getRepository(AttributeMaster)
       .createQueryBuilder('attr')
-      .select([
-        'attr.id',
-        'attr.name',
-        'attr.flat_json_key',
-        'attr.attribute_key',
-        'attr.data_type',
-      ])
+      .select(['attr.id', 'attr.name', 'attr.flat_json_key', 'attr.attribute_key'])
       .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')
@@ -67,45 +48,22 @@ 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',
-            'attr.data_type',
-          ])
-          .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'])
+        .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')
@@ -121,145 +79,48 @@ 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`,
-    );
-
-    // -------------------------------------------------------------------------
-    // ✅ 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,
-          attribute_key: a.flat_json_key,
-          source: 'main',
-        })),
-      );
-
-      // RELATED
-      filterAttributes.push(
-        ...relatedAttributes.map((a) => ({
-          id: a.id,
-          name: a.name,
-          data_type: a.data_type,
-          attribute_key: a.flat_json_key,
-          source: 'related',
-        })),
-      );
-
-      // LINKED
-      filterAttributes.push(
-        ...linkedAttributes.map((l) => ({
-          id: l.id,
-          name: l.name,
-          data_type: l.data_type,
-          attribute_key: l.target_attribute_key, // attribute_key
-          source: 'linked',
-        })),
-      );
-
-      return filterAttributes;
-    }
+    await this.loggerService.log('debug', 'EntityJSONService', 'getAttributeForFlatJSON', `Loaded ${linkedAttributes.length} linked attributes`);
 
-    // -------------------------------------------------------------------------
-    // 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.target_attribute_key,
-        })),
-      );
+      dropdown.push(...linkedAttributes.map(a => ({ label: a.name, value: a.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;
     }
 
@@ -273,42 +134,25 @@ 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,
-      true
-    );
+    const mainData = await this.entityServiceImpl.getResolvedEntityData(entityType, entityId, loggedInUser);
     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,
-        true
-      );
+      const relatedData = await this.entityServiceImpl.getResolvedEntityData(rel.target_entity_type, rel.target_entity_id, loggedInUser);
       this.mergeEntityDataIntoFlatJson(flatJson, relatedData, attrMap);
     }
 
@@ -332,16 +176,11 @@ export class EntityJSONService  {
       );
 
       if (value !== null && value !== undefined) {
-        flatJson[targetKey] = typeof value === 'string' ? value.toLowerCase() : value;
+        flatJson[targetKey] = value;
       }
     }
 
-    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,
@@ -354,11 +193,7 @@ 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) {
@@ -366,9 +201,7 @@ export class EntityJSONService  {
       for (const key of Object.keys(record)) {
         const flatKey = attrMap[key] || key;
         if (flatJson.hasOwnProperty(flatKey)) {
-          const value = record[key];
-          // Convert string values to lowercase
-          flatJson[flatKey] = typeof value === 'string' ? value.toLowerCase() : value;
+          flatJson[flatKey] = record[key];
         }
       }
     }
@@ -383,46 +216,27 @@ 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,
       savedFilterCode,
       page: 1,
       size: 1,
-      loggedInUser
     };
 
-    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,7 +49,9 @@ export class FilterController {
       sortby,
     } = body;
 
-    return this.filterService.applyFilterWithRouting({
+    
+
+    return this.filterService.applyFilterWrapper({
       entity_type,
       quickFilter,
       savedFilterCode,

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

@@ -5,22 +5,15 @@ 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(() => EntityJSONModule),
-    ConfigModule,
-    UtilsModule,
+    forwardRef(() => EntityModule)
   ],
   controllers: [FilterController],
   providers: [
@@ -28,15 +21,13 @@ import { UtilsModule } from 'src/utils/utils.module';
     SavedFilterRepositoryService,
     FilterService,
     FilterEvaluatorService,
-    SavedFilterDetailRepository,
-    FlatjsonFilterService,
+    SavedFilterDetailRepository
   ],
   exports: [
     'SavedFilterService',
     SavedFilterRepositoryService,
     FilterService,
     FilterEvaluatorService,
-    FlatjsonFilterService,
   ],
 })
-export class FilterModule {}
+export class FilterModule {}