rez_core 6.6.6 → 7.0.0

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

@@ -1,486 +1,492 @@
-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';
-import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
-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  {
-  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
-  ) {
-  }
-
-  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
-    const mainAttributes = await this.dataSource
-      .getRepository(AttributeMaster)
-      .createQueryBuilder('attr')
-      .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 })
-      .andWhere('attr.data_type != :uploadType', { uploadType: 'upload' })
-      .getMany();
-
-    await this.loggerService.log(
-      'debug',
-      'EntityJSONService',
-      'getAttributeForFlatJSON',
-      `Loaded ${mainAttributes.length} main attributes`,
-    );
-
-    // RELATED ENTITY TYPES
-    const relatedEntityTypes = await this.dataSource
-      .getRepository(EntityRelation)
-      .createQueryBuilder('rel')
-      .select(['rel.target_entity_type'])
-      .where('rel.source_entity_type = :entityType', { entityType })
-      .andWhere('rel.enterprise_id = :entId', { entId })
-      .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`,
-    );
-
-    // 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 })
-          .andWhere('attr.data_type != :uploadType', { uploadType: 'upload' })
-          .getMany()
-      : [];
-
-    await this.loggerService.log(
-      'debug',
-      'EntityJSONService',
-      'getAttributeForFlatJSON',
-      `Loaded ${relatedAttributes.length} related attributes`,
-    );
-
-    // LINKED ATTRIBUTES
-    const linkedAttributes = await this.dataSource
-      .getRepository(LinkedAttributes)
-      .createQueryBuilder('fla')
-      .innerJoin(
-        AttributeMaster,
-        'attr',
-        'fla.applicable_entity_type = attr.mapped_entity_type AND fla.applicable_attribute_key = attr.attribute_key',
-      )
-      .select([
-        'fla.applicable_entity_type AS applicable_entity_type',
-        'fla.applicable_attribute_key AS applicable_attribute_key',
-        'fla.attribute_key AS target_attribute_key',
-        '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 })
-      .andWhere('attr.data_type != :uploadType', { uploadType: 'upload' })
-      .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;
-    }
-
-    // -------------------------------------------------------------------------
-    // 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 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.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`,
-      );
-      return null;
-    }
-
-    const { flat_json: flatJson, attributes } = response;
-    if (!flatJson) return null;
-
-    const safeAttributes = {
-      mainAttributes: attributes.mainAttributes || [],
-      relatedAttributes: attributes.relatedAttributes || [],
-      linkedAttributes: attributes.linkedAttributes || [],
-    };
-
-    const attrMap: Record<string, string> = {};
-    const dataTypeMap: Record<string, string> = {};
-    const allAttrs = [
-      ...safeAttributes.mainAttributes,
-      ...safeAttributes.relatedAttributes,
-    ];
-    allAttrs.forEach((attr) => {
-      if (attr.attribute_key) {
-        const flatKey = attr.flat_json_key || attr.attribute_key;
-        attrMap[attr.attribute_key] = flatKey;
-        if (attr.data_type) {
-          dataTypeMap[flatKey] = attr.data_type;
-        }
-      }
-    });
-
-    const mainData = await this.entityServiceImpl.getResolvedEntityData(
-      entityType,
-      entityId,
-      loggedInUser,
-      true
-    );
-    this.mergeEntityDataIntoFlatJson(flatJson, mainData, attrMap, dataTypeMap);
-
-    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',
-      ])
-      .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
-      );
-      this.mergeEntityDataIntoFlatJson(flatJson, relatedData, attrMap, dataTypeMap);
-    }
-
-    for (const linkAttr of safeAttributes.linkedAttributes) {
-      const childEntityType = linkAttr.applicable_entity_type;
-      const sourceKey = linkAttr.applicable_attribute_key;
-      const targetKey = linkAttr.target_attribute_key;
-
-      if (!childEntityType || !sourceKey || !targetKey) continue;
-
-      const mappingValue = mainData?.[sourceKey] ?? null;
-
-      const value = await this.applyLinkedFilterUsingSavedFilter(
-        childEntityType,
-        linkAttr.saved_filter_code,
-        sourceKey,
-        mappingValue,
-        targetKey,
-        loggedInUser,
-        entityId,
-      );
-
-      if (value !== null && value !== undefined) {
-        let processedValue = typeof value === 'string' ? value.toLowerCase() : value;
-        
-        // Convert date/datetime to milliseconds for linked attributes
-        const dataType = linkAttr.data_type?.toLowerCase();
-        if (dataType === 'date' || dataType === 'datetime') {
-          processedValue = this.convertToMilliseconds(processedValue);
-        }
-        
-        flatJson[targetKey] = processedValue;
-      }
-    }
-
-    await this.loggerService.log(
-      'info',
-      'EntityJSONService',
-      'updateEntityJSON',
-      `Saving flat JSON for entity: ${entityType}#${entityId}`,
-    );
-    let JsonData = {
-      entity_type: entityType,
-      entity_id: entityId,
-      json_data: flatJson,
-      created_by: loggedInUser.id,
-    };
-
-    await this.EntityJSONRepository.create(JsonData);
-
-    return flatJson;
-  }
-
-  private mergeEntityDataIntoFlatJson(
-    flatJson: Record<string, any>,
-    entityData: any | any[],
-    attrMap: Record<string, string>,
-    dataTypeMap: Record<string, string> = {},
-  ) {
-    const records = Array.isArray(entityData) ? entityData : [entityData];
-
-    for (const record of records) {
-      if (!record || typeof record !== 'object') continue;
-      for (const key of Object.keys(record)) {
-        const flatKey = attrMap[key] || key;
-        if (flatJson.hasOwnProperty(flatKey)) {
-          let value = record[key];
-          
-          // Convert date/datetime to milliseconds
-          const dataType = dataTypeMap[flatKey]?.toLowerCase();
-          if (dataType === 'date' || dataType === 'datetime') {
-            value = this.convertToMilliseconds(value);
-          } else if (typeof value === 'string') {
-            // Convert string values to lowercase (only for non-date fields)
-            value = value.toLowerCase();
-          }
-          
-          flatJson[flatKey] = value;
-        }
-      }
-    }
-  }
-
-  private async applyLinkedFilterUsingSavedFilter(
-    childEntityType: string,
-    savedFilterCode: string,
-    childFilterAttribute: string,
-    mappingValue: any,
-    targetAttribute: string,
-    loggedInUser,
-    entity_id,
-  ) {
-    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 !== ''
-    ) {
-      dto.quickFilter = [
-        {
-          filter_attribute: childFilterAttribute,
-          filter_operator: 'equal',
-          filter_value: mappingValue,
-        },
-      ];
-    }
-
-    dto.quickFilter = [
-      {
-        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;
-  }
-
-  /**
-   * Converts date/datetime values to milliseconds timestamp
-   * @param value - The value to convert (can be Date, string, number, or null/undefined)
-   * @returns milliseconds timestamp or null if invalid
-   */
-  private convertToMilliseconds(value: any): number | null {
-    if (value === null || value === undefined) {
-      return null;
-    }
-
-    // If already a number, assume it's already in milliseconds
-    if (typeof value === 'number') {
-      return value;
-    }
-
-    // If it's a Date object
-    if (value instanceof Date) {
-      return value.getTime();
-    }
-
-    // If it's a string, try to parse it
-    if (typeof value === 'string') {
-      const parsed = new Date(value);
-      if (!isNaN(parsed.getTime())) {
-        return parsed.getTime();
-      }
-    }
-
-    // If we can't convert, return null
-    return null;
-  }
-
-}
+import { BadRequestException, forwardRef, Inject, Injectable } 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';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+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 { EntityMasterService } from '../../meta/service/entity-master.service';
+import { EntityDynamicService } from '../../meta/service/entity-dynamic.service';
+
+import { EntityRelationService } from '../../meta/service/entity-relation.service';
+
+@Injectable()
+export class EntityJSONService {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly loggerService: LoggingService,
+    private readonly EntityJSONRepository: EntityJSONRepository,
+    @Inject(forwardRef(() => FilterService))
+    private readonly filterService: FilterService,
+    private readonly entityServiceImpl: EntityServiceImpl,
+    @Inject('EntityMasterService')
+    private readonly entityMasterService: EntityMasterService,
+    @Inject('EntityDynamicService')
+    private readonly entityDynamicService: EntityDynamicService,
+    @Inject('AttributeMasterService')
+    private readonly attributeMasterService: AttributeMasterService,
+    @Inject('EntityRelationService')
+    private readonly entityRelationService: EntityRelationService,
+  ) {
+  }
+
+  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
+    const mainAttributes = await this.dataSource
+      .getRepository(AttributeMaster)
+      .createQueryBuilder('attr')
+      .select([
+        'attr.id',
+        'attr.name',
+        'attr.attribute_key',
+        'attr.db_datatype',
+      ])
+      .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`,
+    );
+
+    // RELATED ENTITY TYPES
+    const relatedEntityTypes = await this.dataSource
+      .getRepository(EntityRelation)
+      .createQueryBuilder('rel')
+      .select(['rel.target_entity_type'])
+      .where('rel.source_entity_type = :entityType', { entityType })
+      .andWhere('rel.enterprise_id = :entId', { entId })
+      .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`,
+    );
+
+    // RELATED ATTRIBUTES
+    const relatedAttributes = relatedTypesList.length
+      ? await this.dataSource
+        .getRepository(AttributeMaster)
+        .createQueryBuilder('attr')
+        .select([
+          'attr.id',
+          'attr.name',
+          '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`,
+    );
+
+    // LINKED ATTRIBUTES
+    const linkedAttributes = await this.dataSource
+      .getRepository(LinkedAttributes)
+      .createQueryBuilder('fla')
+      .innerJoin(
+        AttributeMaster,
+        'attr',
+        'fla.applicable_entity_type = attr.mapped_entity_type AND fla.applicable_attribute_key = attr.attribute_key',
+      )
+      .select([
+        'fla.applicable_entity_type AS applicable_entity_type',
+        'fla.applicable_attribute_key AS applicable_attribute_key',
+        'fla.attribute_key AS target_attribute_key',
+        '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`,
+    );
+
+    // Return filter attributes (linked attributes only)
+    if (flag === 'filter_attribute') {
+      return linkedAttributes.map((l) => ({
+        id: l.id,
+        name: l.name,
+        data_type: l.data_type,
+        attribute_key: l.target_attribute_key,
+        source: 'linked',
+      }));
+    }
+
+    // Return flat JSON structure
+    if (flag === 'flat_json' || flag === 'all') {
+      const result: Record<string, 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 result;
+    }
+
+    // Return dropdown options (default case)
+    return linkedAttributes.map((a) => ({
+      label: a.name,
+      value: a.target_attribute_key,
+    }));
+  }
+
+  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`,
+      );
+      return null;
+    }
+
+    const { flat_json: flatJson, attributes } = response;
+    if (!flatJson) return null;
+
+    const safeAttributes = {
+      mainAttributes: attributes.mainAttributes || [],
+      relatedAttributes: attributes.relatedAttributes || [],
+      linkedAttributes: attributes.linkedAttributes || [],
+    };
+
+    // Build attribute map for main and related attributes
+    const attrMap: Record<string, string> = {};
+    const allAttrs = [
+      ...safeAttributes.mainAttributes,
+      ...safeAttributes.relatedAttributes,
+    ];
+
+    allAttrs.forEach((attr) => {
+      if (attr.attribute_key) {
+        attrMap[attr.attribute_key] = attr.attribute_key;
+      }
+    });
+
+    // Merge main entity data
+    const mainData = await this.entityServiceImpl.getResolvedEntityData(
+      entityType,
+      entityId,
+      loggedInUser,
+    );
+    this.mergeEntityDataIntoFlatJson(flatJson, mainData, attrMap);
+
+    // Fetch and merge related entity data (ONE-TO-ONE relations)
+    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',
+      ])
+      .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,
+      );
+      this.mergeEntityDataIntoFlatJson(flatJson, relatedData, attrMap);
+    }
+
+    // Process linked attributes
+    for (const linkAttr of safeAttributes.linkedAttributes) {
+      const { applicable_entity_type, applicable_attribute_key, target_attribute_key, saved_filter_code } = linkAttr;
+
+      if (!applicable_entity_type || !applicable_attribute_key || !target_attribute_key) {
+        continue;
+      }
+
+      const mappingValue = mainData?.[applicable_attribute_key] ?? null;
+
+      const value = await this.applyLinkedFilterUsingSavedFilter(
+        applicable_entity_type,
+        saved_filter_code,
+        applicable_attribute_key,
+        mappingValue,
+        target_attribute_key,
+        loggedInUser,
+        entityId,
+      );
+
+      if (value !== null && value !== undefined) {
+        flatJson[target_attribute_key] =
+          typeof value === 'string' ? value.toLowerCase() : value;
+      }
+    }
+
+    // Save flat JSON to repository
+    await this.loggerService.log(
+      'info',
+      'EntityJSONService',
+      'updateEntityJSON',
+      `Saving flat JSON for entity: ${entityType}#${entityId}`,
+    );
+
+    const jsonData = {
+      entity_type: entityType,
+      entity_id: entityId,
+      json_data: flatJson,
+      created_by: loggedInUser.id,
+    };
+
+    await this.EntityJSONRepository.create(jsonData);
+
+    return flatJson;
+  }
+
+  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) {
+      if (!record || typeof record !== 'object') continue;
+      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;
+        }
+      }
+    }
+  }
+
+  private async applyLinkedFilterUsingSavedFilter(
+    childEntityType: string,
+    savedFilterCode: string,
+    childFilterAttribute: string,
+    mappingValue: any,
+    targetAttribute: string,
+    loggedInUser,
+    entity_id,
+  ) {
+    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 !== ''
+    ) {
+      dto.quickFilter = [
+        {
+          filter_attribute: childFilterAttribute,
+          filter_operator: 'equal',
+          filter_value: mappingValue,
+        },
+      ];
+    }
+
+    dto.quickFilter = [
+      {
+        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;
+  }
+
+  async computeFlatJson(entityType: string, entityId: number, loggedInUser: any) {
+    const entityMaster = await this.entityMasterService.getEntityData(
+      entityType,
+      loggedInUser,
+    );
+
+    if (entityMaster && !entityMaster.is_flat_json) {
+      throw new BadRequestException(
+        'Flat Json is not enabled for this entity type',
+      );
+    }
+
+    // Fetch Entity Data with relations
+    const entityData = await this.entityDynamicService.getEntityData(
+      entityType,
+      entityId,
+      loggedInUser,
+      true
+    );
+
+    if (!entityData) {
+      throw new BadRequestException('Entity data not found');
+    }
+
+    const entId = loggedInUser.enterprise_id;
+    const allowedElementTypes = [
+      'label',
+      'text',
+      'textarea',
+      'select',
+      'number',
+      'decimal',
+      'date',
+      'time',
+      'datetime',
+      'phone',
+      'email',
+      'checkbox',
+      'multicheckbox',
+      'radio',
+    ];
+
+    // Main Attributes
+    const mainAttributes = await this.attributeMasterService.getAttributesForFlatJson(
+      entityType,
+      entId,
+      allowedElementTypes,
+    );
+
+    // Related Entity Types (ONE_TO_ONE)
+    const relatedRelations = await this.entityRelationService.getOneToOneRelations(
+      entityType,
+      entId,
+    );
+
+    const relatedEntityTypes = relatedRelations.map(
+      (r) => r.target_entity_type,
+    );
+
+    let relatedAttributes: AttributeMaster[] = [];
+    if (relatedEntityTypes.length > 0) {
+      for (const type of relatedEntityTypes) {
+        const attrs = await this.attributeMasterService.getAttributesForFlatJson(
+          type,
+          entId,
+          allowedElementTypes,
+        );
+        relatedAttributes.push(...attrs);
+      }
+    }
+
+    // Construct Flat JSON
+    const flatJson: Record<string, any> = {};
+
+    // Helper to format value
+    const transformValue = (value: any, dataType: string) => {
+      if (value === null || value === undefined) return null;
+      if (['date', 'time', 'timestamp'].includes(dataType)) {
+        const date = new Date(value);
+        return isNaN(date.getTime()) ? null : date.getTime();
+      }
+      return value;
+    };
+
+    // Main attributes
+    for (const attr of mainAttributes) {
+      const key = `${entityType}__${attr.attribute_key}`;
+      const rawValue = entityData[attr.attribute_key];
+      flatJson[key] = transformValue(rawValue, attr.db_datatype);
+    }
+
+    // Related attributes
+    for (const attr of relatedAttributes) {
+      const key = `${attr.mapped_entity_type}__${attr.attribute_key}`;
+      const childEntityList = entityData.mappedEntities?.[attr.mapped_entity_type];
+      if (childEntityList && childEntityList.length > 0) {
+        const rawValue = childEntityList[0][attr.attribute_key];
+        flatJson[key] = transformValue(rawValue, attr.db_datatype);
+      } else {
+        flatJson[key] = null;
+      }
+    }
+
+    return flatJson;
+  }
+
+
+}