rez_core 3.1.30 → 3.1.32

package/package.json

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

package/src/core.module.ts

@@ -15,6 +15,7 @@ import { LeadModule } from './module/lead/lead.module';
 import { LayoutPreferenceModule } from './module/layout_preference/layout_preference.module';
 import { WorkflowModule } from './module/workflow/workflow.module';
 import { WorkflowAutomationModule } from './module/workflow-automation/workflow-automation.module';
+import { MapperModule } from './module/mapper/mapper.module';
 
 @Global()
 @Module({})
@@ -36,7 +37,8 @@ export class CoreModule {
       LeadModule,
       LayoutPreferenceModule,
       WorkflowModule,
-      WorkflowAutomationModule
+      WorkflowAutomationModule,
+      MapperModule
     ];
 
     const exportsArray = [
@@ -51,7 +53,8 @@ export class CoreModule {
       LeadModule,
       LayoutPreferenceModule,
       WorkflowModule,
-      WorkflowAutomationModule
+      WorkflowAutomationModule,
+      MapperModule
     ];
 
     if (isSso) {

package/src/module/mapper/controller/field-mapper.controller.ts

@@ -16,4 +16,6 @@ export class FieldMapperController {
     return this.fieldMapperService.resolveData(integration_component, parent_type, parent_id, loggedInUser);
   }
 
+
+
 }

package/src/module/mapper/controller/mapper.controller.ts

@@ -0,0 +1,12 @@
+import { Controller, Get, Inject, Query } from '@nestjs/common';
+import { MapperService } from '../service/mapper.service';
+
+@Controller('mapper')
+export class MapperController {
+  constructor(@Inject('MapperService') private readonly mapperService: MapperService) {}
+
+  @Get('')
+  async getByMappedEntityType(@Query('mapped_entity_type') mappedEntityType: string) {
+    return this.mapperService.getByMappedEntityType(mappedEntityType);
+  }
+}

package/src/module/mapper/entity/field-mapper.entity.ts

@@ -27,7 +27,7 @@ export class FieldMapper extends BaseEntity {
   @Column({ name: 'mapped_entity_type', type: 'varchar', length: 30, nullable: true })
   mapped_entity_type: string;
 
-  @Column({ name: 'filter_code', type: 'varchar', length: 30, default: 'default' })
+  @Column({ name: 'filter_code', type: 'varchar', length: 30, default: 'default', nullable: true })
   filter_code: string;
 
   @Column({ name: 'is_lov_present', type: 'tinyint' })

package/src/module/mapper/mapper.module.ts

@@ -10,6 +10,7 @@ import { FieldLovMapper } from './entity/field-lovs.entity';
 import { FieldLovsRepository } from './repository/field-lovs.repository';
 import { MapperService } from './service/mapper.service';
 import { Mapper } from './entity/mapper.entity';
+import { MapperController } from './controller/mapper.controller';
 
 @Module({
   imports: [
@@ -23,7 +24,7 @@ import { Mapper } from './entity/mapper.entity';
     FieldMapperRepository,
     FieldLovsRepository,
   ],
-  controllers: [FieldMapperController],
+  controllers: [FieldMapperController,MapperController],
 })
 export class MapperModule {
 }

package/src/module/mapper/service/field-mapper.service.ts

@@ -5,20 +5,28 @@ import { EntityServiceImpl } from '../../meta/service/entity-service-impl.servic
 import { UserData } from '../../user/entity/user.entity';
 import { SavedFilterService } from '../../filter/service/saved-filter.service';
 import { FieldLovsRepository } from '../repository/field-lovs.repository';
+import { DataSource } from 'typeorm';
+import { FilterService } from 'src/module/filter/service/filter.service';
 
 @Injectable()
 export class FieldMapperService extends EntityServiceImpl {
   constructor(
     private readonly fieldMapperRepository: FieldMapperRepository,
-    @Inject('SavedFilterService') private readonly savedFilterService: SavedFilterService,
+    @Inject('SavedFilterService')
+    private readonly savedFilterService: SavedFilterService,
     private readonly fieldLovsRepository: FieldLovsRepository,
+    private readonly datasource: DataSource,
+    private readonly filterService: FilterService,
   ) {
     super();
   }
 
   async createEntity(dto: FieldMapperDto, loggedInUser: UserData) {
     if (dto.filter_json) {
-      const savedFilter = await this.savedFilterService.createEntity(dto.filter_json, loggedInUser);
+      const savedFilter = await this.savedFilterService.createEntity(
+        dto.filter_json,
+        loggedInUser,
+      );
       dto.filter_code = savedFilter.code;
     }
     return super.createEntity(dto, loggedInUser);
@@ -26,7 +34,10 @@ export class FieldMapperService extends EntityServiceImpl {
 
   async updateEntity(dto: FieldMapperDto, loggedInUser: UserData) {
     if (dto.filter_json) {
-      const savedFilter = await this.savedFilterService.createEntity(dto.filter_json, loggedInUser);
+      const savedFilter = await this.savedFilterService.createEntity(
+        dto.filter_json,
+        loggedInUser,
+      );
       dto.filter_code = savedFilter.code;
     }
     return super.updateEntity(dto, loggedInUser);
@@ -47,37 +58,106 @@ export class FieldMapperService extends EntityServiceImpl {
         integration_component,
         parent_type,
       );
-    const result: Record<string, any> = {};
 
+    const result: Record<string, any> = {};
     const inMemory: Record<string, Record<string, any>> = {};
 
     for (const field of fieldMappers) {
-      const entityType = field.mapped_entity_type ? field.mapped_entity_type : field.destination_entity_type;
+      const entityType = field.mapped_entity_type
+        ? field.mapped_entity_type
+        : field.destination_entity_type;
       const filterCode = field.filter_code || 'default';
+
       if (!inMemory[entityType]) {
         inMemory[entityType] = {};
       }
-      if (!inMemory[entityType][filterCode] && !field.mapped_entity_type) {
+
+      // Case 1️⃣ direct mapping (no mapped_entity_type or equal)
+      if (
+        !inMemory[entityType][filterCode] &&
+        field.mapped_entity_type == field.destination_entity_type
+      ) {
         inMemory[entityType][filterCode] = await super.getResolvedEntityData(
           entityType,
           parent_id,
           userData,
         );
-      } else {
-        // TODO: Handle mapped_entity_type with filterCode
-        inMemory[entityType][filterCode] = {};
+
+        // Case 2️⃣ mapped_entity_type
+      } else if (
+        field.mapped_entity_type &&
+        !inMemory[entityType][filterCode]
+      ) {
+        // Step 1: get related target entity ids
+        const relations = await this.datasource.query(
+          `SELECT target_entity_id 
+           FROM cr_entity_relation_data 
+           WHERE source_entity_type = ? 
+             AND source_entity_id = ? 
+             AND target_entity_type = ? 
+             AND organization_id = ?`,
+          [
+            parent_type,
+            parent_id,
+            field.mapped_entity_type,
+            userData.organization_id,
+          ],
+        );
+
+        const targetEntityIds = relations.map((r) => r.target_entity_id);
+
+        if (targetEntityIds.length > 0) {
+          if (filterCode && filterCode !== 'default') {
+            // Step 2a: filtered fetch with IN clause using applyFilterWrapper
+            inMemory[entityType][filterCode] = inMemory[entityType][
+              filterCode
+            ] = await this.filterService.applyFilterWrapper({
+              entity_type: entityType,
+              savedFilterCode: filterCode,
+              quickFilter: [
+                {
+                  filter_attribute: 'id',
+                  filter_operator: 'equal',
+                  filter_value: targetEntityIds,
+                  filter_entity_type: entityType,
+                },
+              ],
+              attributeFilter: [],
+              loggedInUser: userData,
+              queryParams: {},
+            });
+          } else {
+            // Step 2b: no filter → just pick first related entity
+            const firstId = targetEntityIds[0];
+            inMemory[entityType][filterCode] =
+              await super.getResolvedEntityData(entityType, firstId, userData);
+          }
+        } else {
+          inMemory[entityType][filterCode] = null;
+        }
       }
+
+      // Fetch mapped attribute values
       const entityData = inMemory[entityType][filterCode];
       if (entityData) {
         let value = entityData[field.destination_attribute];
+
         if (field.is_lov_present) {
           if (field.action === 'LOOKUP') {
-            let fieldLovMapper = await this.fieldLovsRepository.findByMapperFieldIdAndDestinationAttributeValue(field.id, value);
+            const fieldLovMapper =
+              await this.fieldLovsRepository.findByMapperFieldIdAndDestinationAttributeValue(
+                field.id,
+                value,
+              );
             if (fieldLovMapper) {
               value = fieldLovMapper.source_attribute_value;
             }
           } else {
-            let fieldLovMapper = await this.fieldLovsRepository.findByMapperFieldIdAndSourceAttributeValue(field.id, value);
+            const fieldLovMapper =
+              await this.fieldLovsRepository.findByMapperFieldIdAndSourceAttributeValue(
+                field.id,
+                value,
+              );
             if (fieldLovMapper) {
               value = fieldLovMapper.destination_attribute_value;
             }
@@ -86,6 +166,7 @@ export class FieldMapperService extends EntityServiceImpl {
         result[field.source_attribute] = value;
       }
     }
+
     return result;
   }
 }

package/src/module/mapper/service/mapper.service.ts

@@ -1,8 +1,31 @@
 import { Injectable } from "@nestjs/common";
 import { EntityServiceImpl } from "src/module/meta/service/entity-service-impl.service";
+import { DataSource } from "typeorm";
 
 
 @Injectable()
 export class MapperService extends EntityServiceImpl{
 
+    constructor(private readonly dataSource: DataSource) {
+        super();
+    }
+
+    async getByMappedEntityType(mappedEntityType: string) {
+        if (!mappedEntityType) return [];
+    
+        const mappers = await this.dataSource.query(
+          `SELECT id, name, code 
+           FROM cr_mapper
+           WHERE mapped_entity_type = ?`,
+          [mappedEntityType],
+        );
+    
+        return mappers.map((m) => ({
+          id: m.id,
+          name: m.name,
+          value: m.id,
+          code: m.code,
+        }));
+      }
+   
 }

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

@@ -26,4 +26,7 @@ export class WorkflowAutomation extends BaseEntity {
 
   @Column({ type: 'varchar', nullable: true })
   trigger_type: string;
+
+  @Column({ type: 'json', nullable: true })
+  schedule: JSON;
 }