rez_core 4.0.242 → 4.0.244

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rez_core",
-  "version": "4.0.242",
+  "version": "4.0.244",
   "description": "",
   "author": "",
   "private": false,

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

@@ -0,0 +1,16 @@
+import { Injectable } from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm";
+import { Repository } from "typeorm";
+import { EntityJson } from "../entity/entityJson.entity";
+import { create } from "domain";
+
+
+@Injectable()
+export class EntityJSONRepository {
+  constructor(
+    @InjectRepository(EntityJson) private readonly entityJSONRepository: Repository<EntityJson>,
+  ) {}
+async create(flatJson: Partial<EntityJson>) {
+  return this.entityJSONRepository.save(flatJson);
+}
+}

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

@@ -6,13 +6,15 @@ 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';
 
 @Injectable()
 export class EntityJSONService extends EntityServiceImpl {
   constructor(
     private readonly dataSource: DataSource,
     private readonly filterService: FilterService,
-    private readonly loggerService: LoggingService, // <-- inject logging service
+    private readonly loggerService: LoggingService,
+    private readonly EntityJSONRepository:EntityJSONRepository
   ) {
     super();
   }
@@ -23,27 +25,18 @@ export class EntityJSONService extends EntityServiceImpl {
     flag?: 'flat_json' | 'dropdown' | 'all',
   ) {
     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}`);
 
     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'])
       .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`);
 
     const relatedEntityTypes = await this.dataSource
       .getRepository(EntityRelation)
@@ -51,44 +44,24 @@ export class EntityJSONService extends EntityServiceImpl {
       .select(['rel.target_entity_type'])
       .where('rel.source_entity_type = :entityType', { entityType })
       .andWhere('rel.organization_id = :orgId', { orgId })
-      .andWhere('rel.relation_type = :relationType', {
-        relationType: 'ONE_TO_ONE',
-      })
+      .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`,
-    );
+    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`);
 
     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,
-          })
+          .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()
       : [];
-    await this.loggerService.log(
-      'debug',
-      'EntityJSONService',
-      'getAttributeForFlatJSON',
-      `Loaded ${relatedAttributes.length} related attributes`,
-    );
+
+    await this.loggerService.log('debug', 'EntityJSONService', 'getAttributeForFlatJSON', `Loaded ${relatedAttributes.length} related attributes`);
 
     const linkedAttributes = await this.dataSource
       .getRepository(LinkedAttributes)
@@ -100,110 +73,66 @@ export class EntityJSONService extends EntityServiceImpl {
       )
       .select([
         'fla.applicable_entity_type AS applicable_entity_type',
-        'fla.applicable_attribute_key AS applicable_attribute_key',  // SOURCE KEY (middle_name)
-        'fla.attribute_key AS target_attribute_key',                 // TARGET KEY (father_middle_name)
+        '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.id AS id',
+      ])
       .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`);
 
     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) => {
-        // Use target_attribute_key instead of applicable_attribute_key
-        if (link.target_attribute_key) result[link.target_attribute_key] = null;
-      });
-    
-      if(flag === 'all') {
-        return { 
-          flat_json: result, 
-          attributes: { mainAttributes, relatedAttributes, linkedAttributes } 
-        };
+      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;
     }
-    
 
     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.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}`,
-    );
-  
-    // 1. Load flat JSON template + attributes
+    await this.loggerService.log('info', 'EntityJSONService', 'updateEntityJSON', `Building flat JSON for entity: ${entityType}#${entityId}`);
+
     const response = await this.getAttributeForFlatJSON(entityType, loggedInUser, 'all');
-  
-    // ---- Structural validation ----
+
     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('error', 'EntityJSONService', 'updateEntityJSON', `getAttributeForFlatJSON() did not return expected structure`);
       return null;
     }
-  
+
     const { flat_json: flatJson, attributes } = response;
     if (!flatJson) return null;
-  
-    // ---- Strong safety fix ----
+
     const safeAttributes = {
       mainAttributes: attributes.mainAttributes || [],
       relatedAttributes: attributes.relatedAttributes || [],
       linkedAttributes: attributes.linkedAttributes || [],
     };
-  
-    // 2. Build attribute_key → flat_json_key map
+
     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;
-    });
-  
-    // 3. Merge main entity data
+    allAttrs.forEach(attr => { if (attr.attribute_key) attrMap[attr.attribute_key] = attr.flat_json_key || attr.attribute_key; });
+
     const mainData = await this.getResolvedEntityData(entityType, entityId, loggedInUser);
     this.mergeEntityDataIntoFlatJson(flatJson, mainData, attrMap);
-  
-    // 4. Merge ONE-TO-ONE related entities
+
     const relations = await this.dataSource
       .getRepository('frm_entity_relation_data')
       .createQueryBuilder('erd')
@@ -212,77 +141,62 @@ export class EntityJSONService extends EntityServiceImpl {
       .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.getResolvedEntityData(rel.target_entity_type, rel.target_entity_id, loggedInUser);
       this.mergeEntityDataIntoFlatJson(flatJson, relatedData, attrMap);
     }
-  
-    // 5. Merge linked attributes using saved filters
-// 5. Merge linked attributes using saved filters
-for (const linkAttr of safeAttributes.linkedAttributes) {
-   
-  
-  const childEntityType = linkAttr.applicable_entity_type;  // was undefined
-const sourceKey = linkAttr.applicable_attribute_key;      // already correct
-const targetKey = linkAttr.target_attribute_key;          // was undefined
-// final JSON key = father_middle_name
-
-  if (!childEntityType || !sourceKey || !targetKey) continue;
-
-  // value must be taken from applicable_attribute_key
-  const mappingValue = mainData?.[sourceKey] ?? null;
-
-  const value = await this.applyLinkedFilterUsingSavedFilter(
-    childEntityType,
-    linkAttr.saved_filter_code,
-    sourceKey,
-    mappingValue,
-    targetKey, // IMPORTANT → write to father_middle_name
-    loggedInUser,
-    entityId
-  );
 
-  if (value !== null && value !== undefined) {
-    const flatKey = targetKey; // do NOT use childAttributeKey
-    flatJson[flatKey] = value;
-  }
-}
+    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) {
+        flatJson[targetKey] = value;
+      }
+    }
 
+    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);
 
-    // 6. Save JSON
-    await this.dataSource.query(
-      `INSERT INTO frm_entity_json (entity_type, entity_id, json_data, created_by)
-         VALUES (?, ?, ?, ?)
-         ON DUPLICATE KEY UPDATE json_data = VALUES(json_data), updated_by = VALUES(created_by)`,
-      [entityType, entityId, JSON.stringify(flatJson), loggedInUser.id],
-    );
-  
     return flatJson;
   }
-  
-  
-  // Helper: Merge entity data using attribute_key → flat_json_key mapping
-  private mergeEntityDataIntoFlatJson(
-    flatJson: Record<string, any>,
-    entityData: any | any[], // accept both object or array
-    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) {
       if (!record || typeof record !== 'object') continue;
-  
       for (const key of Object.keys(record)) {
-        const flatKey = attrMap[key] || key; // map to flat_json_key if exists
+        const flatKey = attrMap[key] || key;
         if (flatJson.hasOwnProperty(flatKey)) {
           flatJson[flatKey] = record[key];
         }
       }
     }
   }
-  
-  
 
   private async applyLinkedFilterUsingSavedFilter(
     childEntityType: string,
@@ -293,11 +207,7 @@ const targetKey = linkAttr.target_attribute_key;          // was undefined
     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,
@@ -307,31 +217,18 @@ const targetKey = linkAttr.target_attribute_key;          // was undefined
       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;
-
   }
 }