rez_core 4.0.188 → 4.0.190

package/package.json

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

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

@@ -3,9 +3,11 @@ import { EntityModule } from '../meta/entity.module';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { EntityJSONService } from './service/entity_json.service';
 import { EntityJSONController } from './controller/entity_json.controller';
+import { FilterModule } from '../filter/filter.module';
+import { UtilsModule } from 'src/utils/utils.module';
 
 @Module({
-  imports: [EntityModule, TypeOrmModule.forFeature([])],
+  imports: [EntityModule, TypeOrmModule.forFeature([]),FilterModule,UtilsModule],
   controllers: [EntityJSONController],
   providers: [EntityJSONService],
   exports: [],

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

@@ -1,12 +1,18 @@
 import { Injectable } from '@nestjs/common';
+import { FilterService } from 'src/module/filter/service/filter.service';
 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';
 
 @Injectable()
 export class EntityJSONService extends EntityServiceImpl {
-  constructor(private readonly dataSource: DataSource) {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly filterService: FilterService,
+    private readonly loggerService: LoggingService, // <-- inject logging service
+  ) {
     super();
   }
 
@@ -16,10 +22,13 @@ export class EntityJSONService extends EntityServiceImpl {
     flag?: 'flat_json' | 'dropdown',
   ) {
     const orgId = loggedInUser.organization_id;
+    await this.loggerService.log(
+      'info',
+      'EntityJSONService',
+      'getAttributeForFlatJSON',
+      `Loading attributes for entity: ${entityType}, org: ${orgId}`,
+    );
 
-    // --------------------------------------------
-    // 1. Load Main Entity Attributes
-    // --------------------------------------------
     const mainAttributes = await this.dataSource
       .getRepository(AttributeMaster)
       .createQueryBuilder('attr')
@@ -28,47 +37,46 @@ export class EntityJSONService extends EntityServiceImpl {
       .andWhere('attr.organization_id = :orgId', { orgId })
       .getMany();
 
-    // --------------------------------------------
-    // 2. Load Related Entity Types Once
-    // --------------------------------------------
+    await this.loggerService.log(
+      'debug',
+      'EntityJSONService',
+      'getAttributeForFlatJSON',
+      `Loaded ${mainAttributes.length} main attributes`,
+    );
+
     const relatedEntityTypes = await this.dataSource
       .getRepository(EntityRelation)
       .createQueryBuilder('rel')
       .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,
+    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`,
     );
 
-    // --------------------------------------------
-    // 3. Fetch All Related Attributes
-    // --------------------------------------------
     const relatedAttributes = relatedTypesList.length
       ? await this.dataSource
           .getRepository(AttributeMaster)
           .createQueryBuilder('attr')
-          .select([
-            'attr.id',
-            'attr.name',
-            'attr.attribute_key',
-            'attr.mapped_entity_type',
-          ])
-          .where('attr.mapped_entity_type IN (:...types)', {
-            types: relatedTypesList,
-          })
+          .select(['attr.id', 'attr.name', 'attr.attribute_key', 'attr.mapped_entity_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`,
+    );
 
-    // --------------------------------------------
-    // 4. Fetch Linked Attributes
-    // --------------------------------------------
     const linkedAttributes = await this.dataSource
       .getRepository('frm_linked_attribute')
       .createQueryBuilder('fla')
@@ -85,78 +93,173 @@ export class EntityJSONService extends EntityServiceImpl {
       ])
       .where('attr.organization_id = :orgId', { orgId })
       .getRawMany();
-
-    // ------------------------------------------------------------------
-    // ---------------   RETURN FORMAT BASED ON FLAG   ------------------
-    // ------------------------------------------------------------------
-
-    // ============================================================
-    // MODE 1: flat_json -> return objects grouped by entity_type
-    // ============================================================
+    await this.loggerService.log(
+      'debug',
+      'EntityJSONService',
+      'getAttributeForFlatJSON',
+      `Loaded ${linkedAttributes.length} linked attributes`,
+    );
 
     if (flag === 'flat_json') {
       const result: Record<string, null> = {};
+      mainAttributes.forEach(attr => { if (attr.attribute_key) result[attr.attribute_key] = null; });
+      relatedAttributes.forEach(attr => { if (attr.attribute_key) result[attr.attribute_key] = null; });
+      linkedAttributes.forEach(link => { if (link.applicable_attribute_key) result[link.applicable_attribute_key] = null; });
+      return result;
+    }
 
-      // MAIN ENTITY ATTRIBUTES
-      mainAttributes.forEach((attr) => {
-        if (attr.attribute_key) {
-          result[attr.attribute_key] = null;
-        }
-      });
-
-      // RELATED ENTITY TYPES
-      for (const type of relatedTypesList) {
-        const attrs = relatedAttributes.filter(
-          (a) => a.mapped_entity_type === type,
-        );
-
-        attrs.forEach((attr) => {
-          if (attr.attribute_key) {
-            result[attr.attribute_key] = null;
-          }
-        });
-      }
+    const dropdown: any[] = [];
+    dropdown.push(...mainAttributes.map(a => ({ label: a.name, value: a.attribute_key })));
+    dropdown.push(...relatedAttributes.map(a => ({ label: a.name, value: a.attribute_key })));
+    dropdown.push({
+      linked_attributes: linkedAttributes.map(a => ({ label: a.attr_name, value: a.attr_attribute_key })),
+    });
+    return dropdown;
+  }
 
-      // LINKED ATTRIBUTES
-      linkedAttributes.forEach((link) => {
-        if (link.applicable_attribute_key) {
-          result[link.applicable_attribute_key] = null;
-        }
-      });
+  async updateEntityJSON(
+    entityType: string,
+    entityId: number,
+    loggedInUser,
+  ) {
+    await this.loggerService.log(
+      'info',
+      'EntityJSONService',
+      'updateEntityJSON',
+      `Building flat JSON for entity: ${entityType}#${entityId}`,
+    );
 
-      return result;
+    const flatJson = await this.getAttributeForFlatJSON(entityType, loggedInUser, 'flat_json');
+    if (!flatJson) {
+      await this.loggerService.log(
+        'error',
+        'EntityJSONService',
+        'updateEntityJSON',
+        `Flat JSON template not found for entity: ${entityType}`,
+      );
+      throw new Error(`Flat JSON template not found for ${entityType}`);
     }
 
-    // ============================================================
-    // MODE 2: dropdown -> return label/value format
-    // ============================================================
+    const mainData = await this.getResolvedEntityData(entityType, entityId, loggedInUser);
+    this.mergeIntoFlatJson(flatJson, mainData);
+    await this.loggerService.log(
+      'debug',
+      'EntityJSONService',
+      'updateEntityJSON',
+      'Merged main entity data into flat JSON',
+    );
+
+    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();
+    await this.loggerService.log(
+      'debug',
+      'EntityJSONService',
+      'updateEntityJSON',
+      `Found ${relations.length} ONE-TO-ONE relations`,
+    );
 
-    const dropdown: any[] = [];
+    for (const rel of relations) {
+      const related = await this.getResolvedEntityData(rel.target_entity_type, rel.target_entity_id, loggedInUser);
+      this.mergeIntoFlatJson(flatJson, related);
+      await this.loggerService.log(
+        'debug',
+        'EntityJSONService',
+        'updateEntityJSON',
+        `Merged related entity ${rel.target_entity_type}#${rel.target_entity_id}`,
+      );
+    }
 
-    // main entity
-    dropdown.push(
-      ...mainAttributes.map((a) => ({
-        label: a.name,
-        value: a.attribute_key,
-      })),
+    const linkedAttrs = await this.dataSource
+      .getRepository('frm_linked_attributes_table')
+      .createQueryBuilder('la')
+      .where('la.entity_type = :entityType', { entityType })
+      .getMany();
+    await this.loggerService.log(
+      'debug',
+      'EntityJSONService',
+      'updateEntityJSON',
+      `Found ${linkedAttrs.length} linked attributes`,
     );
 
-    // related entities
-    dropdown.push(
-      ...relatedAttributes.map((a) => ({
-        label: a.name,
-        value: a.attribute_key,
-      })),
+    for (const la of linkedAttrs) {
+      const mappingValue = flatJson[la.mapping_attribute];
+      const result = await this.applyLinkedFilterUsingSavedFilter(
+        la.child_entity_type,
+        la.saved_filter_code,
+        la.filter_attribute,
+        mappingValue,
+        la.target_attribute,
+        loggedInUser
+      );
+      flatJson[la.target_attribute] = result;
+      await this.loggerService.log(
+        'debug',
+        'EntityJSONService',
+        'updateEntityJSON',
+        `Linked attribute ${la.target_attribute} set from child entity ${la.child_entity_type}`,
+      );
+    }
+
+    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]
+    );
+    await this.loggerService.log(
+      'info',
+      'EntityJSONService',
+      'updateEntityJSON',
+      `Flat JSON saved for entity: ${entityType}#${entityId}`,
     );
 
-    // linked attributes
-    dropdown.push({
-      linked_attributes: linkedAttributes.map((a) => ({
-        label: a.attr_name,
-        value: a.attr_attribute_key,
-      })),
-    });
+    return flatJson;
+  }
 
-    return dropdown;
+  private mergeIntoFlatJson(flatJson, entityData) {
+    for (const key of Object.keys(entityData)) {
+      if (flatJson.hasOwnProperty(key)) {
+        flatJson[key] = entityData[key];
+      }
+    }
+  }
+
+  private async applyLinkedFilterUsingSavedFilter(
+    childEntityType: string,
+    savedFilterCode: string,
+    childFilterAttribute: string,
+    mappingValue: any,
+    targetAttribute: string,
+    loggedInUser,
+  ) {
+    if (!savedFilterCode && (mappingValue === null || mappingValue === undefined)) return null;
+
+    const dto: any = {
+      entity_type: childEntityType,
+      loggedInUser,
+      savedFilterCode,
+      page: 1,
+      size: 1,
+    };
+
+    if (mappingValue !== null && mappingValue !== undefined && mappingValue !== '') {
+      dto.quickFilter = [
+        {
+          filter_attribute: childFilterAttribute,
+          filter_operator: 'equal',
+          filter_value: mappingValue,
+        }
+      ];
+    }
+
+    const result = await this.filterService.applyFilter(dto);
+    const rows = result?.data?.entity_list || [];
+    return rows.length ? rows[0][targetAttribute] ?? null : null;
   }
 }

package/src/module/workflow-automation/workflow-automation.module.ts

@@ -24,8 +24,8 @@ import { WorkflowScheduleModule } from '../workflow-schedule/workflow-schedule.m
     ]),
     FilterModule,
     forwardRef(() => EntityModule),
-    DiscoveryModule,
-    WorkflowScheduleModule
+    forwardRef(() => WorkflowScheduleModule),
+    DiscoveryModule, // 👈 enables provider scanning
   ],
   providers: [
     WorkflowAutomationEngineService,