rez_core 4.0.86 → 4.0.87

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

@@ -1,254 +1,254 @@
-import { Inject, Injectable, Logger, LoggerService } from '@nestjs/common';
-import { FieldMapperRepository } from '../repository/field-mapper.repository';
-import { FieldMapperDto } from '../dto/field-mapper.dto';
-import { EntityServiceImpl } from '../../meta/service/entity-service-impl.service';
-import { UserData } from '../../user/entity/user.entity';
-import { FieldLovsRepository } from '../repository/field-lovs.repository';
-import { DataSource } from 'typeorm';
-import { FilterService } from 'src/module/filter/service/filter.service';
-import { BaseEntity } from '../../meta/entity/base-entity.entity';
-import { LoggingService } from 'src/utils/service/loggingUtil.service';
-
-@Injectable()
-export class FieldMapperService extends EntityServiceImpl {
-  constructor(
-    private readonly fieldMapperRepository: FieldMapperRepository,
-    private readonly fieldLovsRepository: FieldLovsRepository,
-    private readonly datasource: DataSource,
-    private readonly filterService: FilterService,
-    @Inject() protected readonly loggingService: LoggingService,
-  ) {
-    super();
-  }
-
-  async createEntity(dto: FieldMapperDto, loggedInUser: UserData) {
-    let savedEntity = await super.createEntity(dto, loggedInUser);
-
-    if (dto.field_lovs) {
-      for (const lov of dto.field_lovs) {
-        lov.mapper_field_id = savedEntity.id;
-        lov.entity_type = 'FLOV';
-      }
-      await this.fieldLovsRepository.saveBulk(dto.field_lovs);
-    }
-    return savedEntity;
-  }
-
-  async updateEntity(dto: FieldMapperDto, loggedInUser: UserData) {
-    return super.updateEntity(dto, loggedInUser);
-  }
-
-  async createFieldMappers(dtos: FieldMapperDto[], loggedInUser: UserData) {
-    let mapperId = dtos[0].mapper_id;
-
-    let existingMappers =
-      await this.fieldMapperRepository.findByMapperId(mapperId);
-
-    for (const mapper of existingMappers) {
-      await this.fieldLovsRepository.deleteByMapperFieldId(mapper.id);
-    }
-
-    await this.fieldMapperRepository.deleteByMapperId(mapperId);
-
-    let result: BaseEntity[] = [];
-    for (const dto of dtos) {
-      const fieldMapper = await this.createEntity(dto, loggedInUser);
-      result.push(fieldMapper);
-    }
-    return result;
-  }
-
-  async updateFieldMappers(dtos: FieldMapperDto[], loggedInUser: UserData) {
-    let result: BaseEntity[] = [];
-    for (const dto of dtos) {
-      const fieldMapper = await super.updateEntity(dto, loggedInUser);
-      result.push(fieldMapper);
-    }
-    return result;
-  }
-
-  async getMapperFields(mapperId: number, mapper_entity_type: string) {
-    let fieldMappers =
-      await this.fieldMapperRepository.findByMapperIdAndMapperEntityType(
-        mapperId,
-        mapper_entity_type,
-      );
-    const fieldMapperDtos = fieldMappers as unknown as FieldMapperDto[];
-    for (const fieldMapper of fieldMapperDtos) {
-      fieldMapper.field_lovs =
-        await this.fieldLovsRepository.findByMapperFieldId(fieldMapper.id);
-    }
-    return fieldMapperDtos;
-  }
-
-  async getFieldLovs(mapperFieldId: number) {
-    return await this.fieldLovsRepository.findByMapperFieldId(mapperFieldId);
-  }
-
-  async resolveData(
-    mapper_id: number,
-    action: 'LOOKUP' | 'LOAD',
-    parent_type: string,
-    parent_id: number,
-    userData: UserData,
-    inputJson?: Record<string, any>,
-    mappedEntities?: Record<string, any>,
-    overwrite?: boolean,
-    entity_data?: any
-  ) {
-    // Fetch field mappings for this mapper
-    const fieldMappers =
-      await this.fieldMapperRepository.findByMapperId(mapper_id);
-
-    // Initialize the final response (generic)
-    let result: any;
-
-    if (action === 'LOOKUP') result = new Map<string, any>();
-    else if (action === 'LOAD')
-      result = {
-        entity_type: parent_type,
-        mappedEntities: {},
-      };
-
-    const inMemory: Record<string, Record<string, any>> = {}; // cache per entity-type + filter
-
-    for (const field of fieldMappers) {
-      const entityType = field.mapped_entity_type || field.mapper_entity_type;
-      const filterCode = field.filter_code || 'default';
-
-      // ----------------------------------------------------------------
-      // LOOKUP (System → External)
-      // ----------------------------------------------------------------
-      if (action === 'LOOKUP') {
-        if (!inMemory[entityType]) inMemory[entityType] = {};
-
-        if (!inMemory[entityType][filterCode]) {
-          if (field.mapped_entity_type === field.mapper_entity_type) {
-            inMemory[entityType][filterCode] =
-              await super.getResolvedEntityDataByDataSource(
-                entityType,
-                parent_id,
-                userData,
-              );
-          } else {
-            if (overwrite && entity_data && entity_data[field.mapped_entity_type]) {
-              inMemory[entityType][filterCode] = entity_data[field.mapped_entity_type];
-            } else {
-              const relations = await this.datasource.query(
-                `SELECT target_entity_id
-                 FROM frm_entity_relation_data
-                 WHERE source_entity_type = ?
-                   AND source_entity_id = ?
-                   AND target_entity_type = ?`,
-                [parent_type, parent_id, field.mapped_entity_type],
-              );
-
-              const targetEntityIds = relations.map((r) => r.target_entity_id);
-
-              this.loggingService.log(
-                'package',
-                'fieldMapperService',
-                'targetEntityIds',
-                targetEntityIds,
-              );
-
-              if (targetEntityIds.length > 0) {
-                if (filterCode && filterCode !== 'default') {
-                  let filterResponse =
-                    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: {},
-                    });
-
-                  this.loggingService.log(
-                    'package',
-                    'fieldMapperService',
-                    'filterResponse',
-                    `${filterResponse}`,
-                  );
-
-                  inMemory[entityType][filterCode] =
-                    filterResponse?.data?.entity_list[0];
-                } else {
-                  let firstId = targetEntityIds[0];
-                  if (mappedEntities && mappedEntities[entityType])
-                    firstId = mappedEntities[entityType];
-                  inMemory[entityType][filterCode] =
-                    await super.getResolvedEntityData(
-                      entityType,
-                      firstId,
-                      userData,
-                    );
-                }
-              } else {
-                inMemory[entityType][filterCode] = null;
-              }
-            }
-          }
-        }
-
-        // Extract and transform values
-        const entityData = inMemory[entityType][filterCode];
-        if (entityData) {
-          let value = entityData[field.attribute_key];
-
-          // Apply LOV mapping (System → External)
-          if (field.is_lov_present) {
-            const fieldLovMapper =
-              await this.fieldLovsRepository.findByMapperFieldIdAndDestinationAttributeValue(
-                field.id,
-                value,
-              );
-            if (fieldLovMapper) {
-              value = fieldLovMapper.source_attribute_value;
-            }
-          }
-
-          // Add to result
-          result.set(field.source_attribute, value);
-        }
-      }
-
-      // ----------------------------------------------------------------
-      // LOAD (External → System)
-      // ----------------------------------------------------------------
-      else if (action === 'LOAD' && inputJson) {
-        let value = inputJson[field.source_attribute];
-
-        if (field.is_lov_present && value !== undefined && value !== null) {
-          const fieldLovMapper =
-            await this.fieldLovsRepository.findByMapperFieldIdAndSourceAttributeValue(
-              field.id,
-              value,
-            );
-          if (fieldLovMapper)
-            value = fieldLovMapper.destination_attribute_value;
-        }
-
-        // If field belongs to main entity type → put at top level
-        if (entityType === parent_type) {
-          result[field.attribute_key] = value;
-        } else {
-          if (!result.mappedEntities[entityType])
-            result.mappedEntities[entityType] = [{}];
-          result.mappedEntities[entityType][0][field.attribute_key] = value;
-        }
-      }
-    }
-    if (action === 'LOOKUP') {
-      return Object.fromEntries(result);
-    }
-    return result;
-  }
-}
+import { Inject, Injectable, Logger, LoggerService } from '@nestjs/common';
+import { FieldMapperRepository } from '../repository/field-mapper.repository';
+import { FieldMapperDto } from '../dto/field-mapper.dto';
+import { EntityServiceImpl } from '../../meta/service/entity-service-impl.service';
+import { UserData } from '../../user/entity/user.entity';
+import { FieldLovsRepository } from '../repository/field-lovs.repository';
+import { DataSource } from 'typeorm';
+import { FilterService } from 'src/module/filter/service/filter.service';
+import { BaseEntity } from '../../meta/entity/base-entity.entity';
+import { LoggingService } from 'src/utils/service/loggingUtil.service';
+
+@Injectable()
+export class FieldMapperService extends EntityServiceImpl {
+  constructor(
+    private readonly fieldMapperRepository: FieldMapperRepository,
+    private readonly fieldLovsRepository: FieldLovsRepository,
+    private readonly datasource: DataSource,
+    private readonly filterService: FilterService,
+    @Inject() protected readonly loggingService: LoggingService,
+  ) {
+    super();
+  }
+
+  async createEntity(dto: FieldMapperDto, loggedInUser: UserData) {
+    let savedEntity = await super.createEntity(dto, loggedInUser);
+
+    if (dto.field_lovs) {
+      for (const lov of dto.field_lovs) {
+        lov.mapper_field_id = savedEntity.id;
+        lov.entity_type = 'FLOV';
+      }
+      await this.fieldLovsRepository.saveBulk(dto.field_lovs);
+    }
+    return savedEntity;
+  }
+
+  async updateEntity(dto: FieldMapperDto, loggedInUser: UserData) {
+    return super.updateEntity(dto, loggedInUser);
+  }
+
+  async createFieldMappers(dtos: FieldMapperDto[], loggedInUser: UserData) {
+    let mapperId = dtos[0].mapper_id;
+
+    let existingMappers =
+      await this.fieldMapperRepository.findByMapperId(mapperId);
+
+    for (const mapper of existingMappers) {
+      await this.fieldLovsRepository.deleteByMapperFieldId(mapper.id);
+    }
+
+    await this.fieldMapperRepository.deleteByMapperId(mapperId);
+
+    let result: BaseEntity[] = [];
+    for (const dto of dtos) {
+      const fieldMapper = await this.createEntity(dto, loggedInUser);
+      result.push(fieldMapper);
+    }
+    return result;
+  }
+
+  async updateFieldMappers(dtos: FieldMapperDto[], loggedInUser: UserData) {
+    let result: BaseEntity[] = [];
+    for (const dto of dtos) {
+      const fieldMapper = await super.updateEntity(dto, loggedInUser);
+      result.push(fieldMapper);
+    }
+    return result;
+  }
+
+  async getMapperFields(mapperId: number, mapper_entity_type: string) {
+    let fieldMappers =
+      await this.fieldMapperRepository.findByMapperIdAndMapperEntityType(
+        mapperId,
+        mapper_entity_type,
+      );
+    const fieldMapperDtos = fieldMappers as unknown as FieldMapperDto[];
+    for (const fieldMapper of fieldMapperDtos) {
+      fieldMapper.field_lovs =
+        await this.fieldLovsRepository.findByMapperFieldId(fieldMapper.id);
+    }
+    return fieldMapperDtos;
+  }
+
+  async getFieldLovs(mapperFieldId: number) {
+    return await this.fieldLovsRepository.findByMapperFieldId(mapperFieldId);
+  }
+
+  async resolveData(
+    mapper_id: number,
+    action: 'LOOKUP' | 'LOAD',
+    parent_type: string,
+    parent_id: number,
+    userData: UserData,
+    inputJson?: Record<string, any>,
+    mappedEntities?: Record<string, any>,
+    overwrite?: boolean,
+    entity_data?: any
+  ) {
+    // Fetch field mappings for this mapper
+    const fieldMappers =
+      await this.fieldMapperRepository.findByMapperId(mapper_id);
+
+    // Initialize the final response (generic)
+    let result: any;
+
+    if (action === 'LOOKUP') result = new Map<string, any>();
+    else if (action === 'LOAD')
+      result = {
+        entity_type: parent_type,
+        mappedEntities: {},
+      };
+
+    const inMemory: Record<string, Record<string, any>> = {}; // cache per entity-type + filter
+
+    for (const field of fieldMappers) {
+      const entityType = field.mapped_entity_type || field.mapper_entity_type;
+      const filterCode = field.filter_code || 'default';
+
+      // ----------------------------------------------------------------
+      // LOOKUP (System → External)
+      // ----------------------------------------------------------------
+      if (action === 'LOOKUP') {
+        if (!inMemory[entityType]) inMemory[entityType] = {};
+
+        if (!inMemory[entityType][filterCode]) {
+          if (field.mapped_entity_type === field.mapper_entity_type) {
+            inMemory[entityType][filterCode] =
+              await super.getResolvedEntityDataByDataSource(
+                entityType,
+                parent_id,
+                userData,
+              );
+          } else {
+            if (overwrite && entity_data && entity_data[field.mapped_entity_type]) {
+              inMemory[entityType][filterCode] = entity_data[field.mapped_entity_type];
+            } else {
+              const relations = await this.datasource.query(
+                `SELECT target_entity_id
+                 FROM frm_entity_relation_data
+                 WHERE source_entity_type = ?
+                   AND source_entity_id = ?
+                   AND target_entity_type = ?`,
+                [parent_type, parent_id, field.mapped_entity_type],
+              );
+
+              const targetEntityIds = relations.map((r) => r.target_entity_id);
+
+              this.loggingService.log(
+                'package',
+                'fieldMapperService',
+                'targetEntityIds',
+                targetEntityIds,
+              );
+
+              if (targetEntityIds.length > 0) {
+                if (filterCode && filterCode !== 'default') {
+                  let filterResponse =
+                    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: {},
+                    });
+
+                  this.loggingService.log(
+                    'package',
+                    'fieldMapperService',
+                    'filterResponse',
+                    `${filterResponse}`,
+                  );
+
+                  inMemory[entityType][filterCode] =
+                    filterResponse?.data?.entity_list[0];
+                } else {
+                  let firstId = targetEntityIds[0];
+                  if (mappedEntities && mappedEntities[entityType])
+                    firstId = mappedEntities[entityType];
+                  inMemory[entityType][filterCode] =
+                    await super.getResolvedEntityData(
+                      entityType,
+                      firstId,
+                      userData,
+                    );
+                }
+              } else {
+                inMemory[entityType][filterCode] = null;
+              }
+            }
+          }
+        }
+
+        // Extract and transform values
+        const entityData = inMemory[entityType][filterCode];
+        if (entityData) {
+          let value = entityData[field.attribute_key];
+
+          // Apply LOV mapping (System → External)
+          if (field.is_lov_present) {
+            const fieldLovMapper =
+              await this.fieldLovsRepository.findByMapperFieldIdAndDestinationAttributeValue(
+                field.id,
+                value,
+              );
+            if (fieldLovMapper) {
+              value = fieldLovMapper.source_attribute_value;
+            }
+          }
+
+          // Add to result
+          result.set(field.source_attribute, value);
+        }
+      }
+
+      // ----------------------------------------------------------------
+      // LOAD (External → System)
+      // ----------------------------------------------------------------
+      else if (action === 'LOAD' && inputJson) {
+        let value = inputJson[field.source_attribute];
+
+        if (field.is_lov_present && value !== undefined && value !== null) {
+          const fieldLovMapper =
+            await this.fieldLovsRepository.findByMapperFieldIdAndSourceAttributeValue(
+              field.id,
+              value,
+            );
+          if (fieldLovMapper)
+            value = fieldLovMapper.destination_attribute_value;
+        }
+
+        // If field belongs to main entity type → put at top level
+        if (entityType === parent_type) {
+          result[field.attribute_key] = value;
+        } else {
+          if (!result.mappedEntities[entityType])
+            result.mappedEntities[entityType] = [{}];
+          result.mappedEntities[entityType][0][field.attribute_key] = value;
+        }
+      }
+    }
+    if (action === 'LOOKUP') {
+      return Object.fromEntries(result);
+    }
+    return result;
+  }
+}

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

@@ -1,79 +1,79 @@
-import { Injectable } from '@nestjs/common';
-import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
-import { DataSource } from 'typeorm';
-import { MapperRepository } from '../repository/mapper.repository';
-import { FieldMapperRepository } from '../repository/field-mapper.repository';
-import { FieldLovsRepository } from '../repository/field-lovs.repository';
-
-@Injectable()
-export class MapperService extends EntityServiceImpl {
-  constructor(
-    private readonly dataSource: DataSource,
-    private mapperRepository: MapperRepository,
-    private fieldMapperRepository: FieldMapperRepository,
-    private fieldLovsRepository: FieldLovsRepository,
-  ) {
-    super();
-  }
-
-  async getByMappedEntityType(mappedEntityType: string,loggedInUser, filter?: string, status?: string) {
-    if (!mappedEntityType) return [];
-
-    const mappers = await this.dataSource.query(
-      `SELECT id, name, code, status
-       FROM frm_mapper_master
-       WHERE mapped_entity_type = ? AND organization_id = ? AND (-1 = ? OR name LIKE ? OR code LIKE ?)`,
-      [mappedEntityType,loggedInUser.organization_id, filter || -1, `%${filter}%`, `%${filter}%`],
-    );
-
-    const distinctStatuses = [
-      ...new Set(mappers.map((m) => m.status).filter((s) => s !== null)),
-    ];
-
-    // get all statuses in one query
-    const statusMap = new Map();
-    if (distinctStatuses.length > 0) {
-      const statuses = await this.dataSource.query(
-        `SELECT id, name FROM frm_list_master_items WHERE id IN (?)`,
-        [distinctStatuses],
-      );
-      statuses.forEach((status) => {
-        statusMap.set(status.id, status.name);
-      });
-    }
-
-    // map status names to mappers
-
-    let mappersResolved =  mappers.map((m) => ({
-      id: m.id,
-      label: m.name,
-      value: m.id,
-      code: m.code,
-      status: statusMap.get(m.status) || null,
-    }));
-
-    if (status) {
-      mappersResolved = mappersResolved.filter(
-        (m) => m.status && m.status.toLowerCase() === status.toLowerCase(),
-      );
-    }
-    return mappersResolved;
-  }
-
-  async deleteEntity(entityType: string, entityId: number, loggedInUser) {
-    let fieldMappers =
-      await this.fieldMapperRepository.findByMapperId(entityId);
-
-    for (const fieldMapper of fieldMappers) {
-      await this.fieldLovsRepository.deleteByMapperFieldId(fieldMapper.id);
-    }
-
-    await this.fieldMapperRepository.deleteByMapperId(entityId);
-
-    await super.deleteEntity(entityType, entityId, loggedInUser);
-    return {
-      success: true,
-      message: `Mapper deleted successfully.`,
-    };
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
+import { DataSource } from 'typeorm';
+import { MapperRepository } from '../repository/mapper.repository';
+import { FieldMapperRepository } from '../repository/field-mapper.repository';
+import { FieldLovsRepository } from '../repository/field-lovs.repository';
+
+@Injectable()
+export class MapperService extends EntityServiceImpl {
+  constructor(
+    private readonly dataSource: DataSource,
+    private mapperRepository: MapperRepository,
+    private fieldMapperRepository: FieldMapperRepository,
+    private fieldLovsRepository: FieldLovsRepository,
+  ) {
+    super();
+  }
+
+  async getByMappedEntityType(mappedEntityType: string,loggedInUser, filter?: string, status?: string) {
+    if (!mappedEntityType) return [];
+
+    const mappers = await this.dataSource.query(
+      `SELECT id, name, code, status
+       FROM frm_mapper_master
+       WHERE mapped_entity_type = ? AND organization_id = ? AND (-1 = ? OR name LIKE ? OR code LIKE ?)`,
+      [mappedEntityType,loggedInUser.organization_id, filter || -1, `%${filter}%`, `%${filter}%`],
+    );
+
+    const distinctStatuses = [
+      ...new Set(mappers.map((m) => m.status).filter((s) => s !== null)),
+    ];
+
+    // get all statuses in one query
+    const statusMap = new Map();
+    if (distinctStatuses.length > 0) {
+      const statuses = await this.dataSource.query(
+        `SELECT id, name FROM frm_list_master_items WHERE id IN (?)`,
+        [distinctStatuses],
+      );
+      statuses.forEach((status) => {
+        statusMap.set(status.id, status.name);
+      });
+    }
+
+    // map status names to mappers
+
+    let mappersResolved =  mappers.map((m) => ({
+      id: m.id,
+      label: m.name,
+      value: m.id,
+      code: m.code,
+      status: statusMap.get(m.status) || null,
+    }));
+
+    if (status) {
+      mappersResolved = mappersResolved.filter(
+        (m) => m.status && m.status.toLowerCase() === status.toLowerCase(),
+      );
+    }
+    return mappersResolved;
+  }
+
+  async deleteEntity(entityType: string, entityId: number, loggedInUser) {
+    let fieldMappers =
+      await this.fieldMapperRepository.findByMapperId(entityId);
+
+    for (const fieldMapper of fieldMappers) {
+      await this.fieldLovsRepository.deleteByMapperFieldId(fieldMapper.id);
+    }
+
+    await this.fieldMapperRepository.deleteByMapperId(entityId);
+
+    await super.deleteEntity(entityType, entityId, loggedInUser);
+    return {
+      success: true,
+      message: `Mapper deleted successfully.`,
+    };
+  }
+}