rez_core 7.1.21 → 7.1.22

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

@@ -0,0 +1,264 @@
+import { Inject, Injectable } 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 'src/module/auth/dto/user.dto';
+import { FieldLovsRepository } from '../repository/field-lovs.repository';
+import { BaseEntity } from '../../meta/entity/base-entity.entity';
+import { LoggingService } from 'src/utils/service/loggingUtil.service';
+import { EntityFilterService } from '../../filter/service/entity-filter.service';
+
+@Injectable()
+export class FieldMapperService extends EntityServiceImpl {
+  constructor(
+    private readonly fieldMapperRepository: FieldMapperRepository,
+    private readonly fieldLovsRepository: FieldLovsRepository,
+    private readonly filterService: EntityFilterService,
+    @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;
+      }
+      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 relationDataRepo = this.reflectionHelper.getRepoService('EntityRelationData');
+              const relations = await relationDataRepo.find({
+                where: {
+                  source_entity_type: parent_type,
+                  source_entity_id: parent_id,
+                  target_entity_type: field.mapped_entity_type,
+                },
+              });
+
+              const targetEntityIds = relations.map((r) => r.target_entity_id);
+
+              this.loggingService.log(
+                'debug',
+                'fieldMapperService',
+                'resolveData',
+                `Resolved targetEntityIds: ${targetEntityIds} for entityType: ${entityType}`,
+                [parent_type, parent_id, field.mapped_entity_type],
+                [],
+              );
+              if (targetEntityIds.length > 0) {
+                if (filterCode && filterCode !== 'default') {
+                  let filterResponse =
+                    await this.filterService.getFilterDataInternal(
+                      entityType, filterCode,
+                      [
+                        {
+                          filter_attribute: 'id',
+                          filter_operator: 'equal',
+                          filter_value: targetEntityIds,
+                          filter_entity_type: entityType,
+                        },
+                      ], [], [], userData,
+                    );
+
+                  this.loggingService.log(
+                    'debug',
+                    'fieldMapperService',
+                    'resolveData',
+                    `Filter response for filterCode: ${filterCode} is ${JSON.stringify(
+                      filterResponse,
+                    )}`,
+                    [entityType, filterCode, targetEntityIds],
+                    [],
+                  );
+
+                  inMemory[entityType][filterCode] =
+                    filterResponse?.entity_list[0];
+                } else {
+                  let firstId = targetEntityIds[0];
+
+                  if (
+                    mappedEntities &&
+                    entityType in 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/entity/mapper/service/mapper.service.ts

@@ -0,0 +1,80 @@
+import { Injectable } from '@nestjs/common';
+import { EntityServiceImpl } from 'src/module/entity/meta/service/entity-service-impl.service';
+import { In, Repository } from 'typeorm';
+import { MapperRepository } from '../repository/mapper.repository';
+import { FieldMapperRepository } from '../repository/field-mapper.repository';
+import { FieldLovsRepository } from '../repository/field-lovs.repository';
+import { InjectRepository } from '@nestjs/typeorm';
+import { ListMasterItems } from '../../../listmaster/entity/list-master-items.entity';
+
+@Injectable()
+export class MapperService extends EntityServiceImpl {
+  constructor(
+    private mapperRepository: MapperRepository,
+    private fieldMapperRepository: FieldMapperRepository,
+    private fieldLovsRepository: FieldLovsRepository,
+    @InjectRepository(ListMasterItems)
+    private readonly listMasterItemsRepo: Repository<ListMasterItems>,
+  ) {
+    super();
+  }
+
+  async getByMappedEntityType(mappedEntityType: string, loggedInUser, filter?: string, status?: string) {
+    if (!mappedEntityType) return [];
+
+    const mappers = await this.mapperRepository.findByMappedEntityType(mappedEntityType, loggedInUser.enterprise_id, 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.listMasterItemsRepo.find({
+        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.`,
+    };
+  }
+}

package/src/module/entity/meta/controller/attribute-master.controller.ts

@@ -0,0 +1,83 @@
+import { Body, Controller, Get, Inject, Param, Post, Query, Req, UseGuards } from '@nestjs/common';
+import { Request } from 'express';
+import { AttributeMasterService } from '../service/attribute-master.service';
+import { JwtAuthGuard } from '../../../auth/guards/jwt.guard';
+
+@Controller('attribute-master')
+@UseGuards(JwtAuthGuard)
+export class AttributeMasterController {
+  constructor(
+    @Inject('AttributeMasterService')
+    private readonly attributeMasterService: AttributeMasterService,
+  ) {
+  }
+
+  @Post('/create')
+  async createAttribute(
+    @Body() attributeData: any,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+    return await this.attributeMasterService.createAttribute(
+      attributeData,
+      loggedInUser,
+    );
+  }
+
+
+  @Post('update/:id')
+  async updateAttribute(
+    @Body() attributeData: any,
+    @Param('id') id: number,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+    return await this.attributeMasterService.updateAttribute(
+      attributeData,
+      id,
+      loggedInUser,
+    );
+  }
+
+  @Get('getById/:id')
+  async getAttributeById(
+    @Param('id') id: number,
+    @Req() req: Request & { user: any },
+  ) {
+    return await this.attributeMasterService.getAttributeById(id);
+  }
+
+  @Get('getAttributeDropdownByEntity/:entity_type')
+  async getAttributeByEntity(
+    @Param('entity_type') entity_type: string,
+    @Req() req: Request & { user: any },
+  ) {
+
+    const loggedInUser = req.user.userData;
+
+    return await this.attributeMasterService.getAttributesByEntityType(entity_type, loggedInUser);
+  }
+
+
+  @Get('getDropdownList/:entityType')
+  async getAttributesDropdownList(
+    @Param('entityType') entityType: string,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+    return await this.attributeMasterService.getAttributesDropdownList(
+      entityType,
+      loggedInUser,
+    );
+  }
+
+  @Get('getAttributes')
+  async getAttributes(
+    @Query('entity_type') entityType: string,
+    @Req() req: Request & { user: any },
+    @Query('direct') direct: boolean = false,
+  ) {
+    const loggedInUser = req.user.userData;
+    return await this.attributeMasterService.getEntityAttributes(entityType, loggedInUser, direct);
+  }
+}

package/src/module/entity/meta/controller/entity-dynamic.controller.ts

@@ -0,0 +1,124 @@
+import {
+  Body,
+  Controller,
+  Get,
+  Param,
+  Post,
+  Query,
+  Req,
+  BadRequestException,
+  NotFoundException,
+  HttpCode,
+  HttpStatus,
+  UseGuards,
+} from '@nestjs/common';
+import { Request } from 'express';
+import { EntityDynamicService } from '../service/entity-dynamic.service';
+import { JwtAuthGuard } from '../../../auth/guards/jwt.guard';
+
+@UseGuards(JwtAuthGuard)
+@Controller('dynamic-entity')
+export class EntityDynamicController {
+  constructor(private readonly entityDynamicService: EntityDynamicService) {}
+
+  @Post('create')
+  @HttpCode(HttpStatus.OK)
+  async createEntity(
+    @Body() data: Record<string, any>,
+    @Query('entity_type') entityType: string,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+
+    if (!entityType) {
+      throw new BadRequestException(`Query param "entity_type" is required`);
+    }
+    data['entity_type'] = entityType;
+    return await this.entityDynamicService.createEntity(
+      data,
+      loggedInUser,
+    );
+  }
+
+  @Post('update/:id')
+  @HttpCode(HttpStatus.OK)
+  async updateEntity(
+    @Param('id') id: number,
+    @Body() data: Record<string, any>,
+    @Query('entity_type') entityType: string,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+
+    if (!entityType) {
+      throw new BadRequestException(`Query param "entity_type" is required`);
+    }
+
+    const existingEntity = await this.entityDynamicService.getEntity(
+      entityType,
+      id,
+      loggedInUser,
+    );
+    if (!existingEntity) {
+      throw new NotFoundException(`No entity found for id "${id}"`);
+    }
+    data['id'] = id;
+    data['entity_type'] = entityType;
+    return await this.entityDynamicService.updateEntity(
+      data,
+      loggedInUser,
+    );
+  }
+
+  @Get('get/:id')
+  @HttpCode(HttpStatus.OK)
+  async getEntity(
+    @Param('id') id: number,
+    @Query('entity_type') entityType: string,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+
+    if (!entityType) {
+      throw new BadRequestException(`Query param "entity_type" is required`);
+    }
+
+    const entity = await this.entityDynamicService.getEntityData(
+      entityType,
+      id,
+      loggedInUser,
+    );
+    if (!entity) {
+      throw new NotFoundException(`No entity found for id "${id}"`);
+    }
+
+    return entity;
+  }
+
+  @Get('getDropdownList')
+  async getAttributesDropdownList(
+    @Req() req: Request & { user: any },
+    @Query('appcode') appcode?: string,
+  ) {
+    const loggedInUser = req.user.userData;
+    return await this.entityDynamicService.getEntitiesDropdownList(
+      loggedInUser,
+      appcode,
+    );
+  }
+
+  @Get('getResolvedEntity/:id')
+  async getResolvedEntity(
+    @Param('id') id: number,
+    @Query('entity_type') entityType: string,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+    return await this.entityDynamicService.getEntityData(
+      entityType,
+      id,
+      loggedInUser,
+      true
+    );
+  }
+}

package/src/module/entity/meta/controller/entity-master.controller.ts

@@ -0,0 +1,41 @@
+import {
+  Controller,
+  Post,
+  Body,
+  Param,
+  Req,
+  UseGuards,
+  Get, Inject,
+} from '@nestjs/common';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { EntityMasterService } from '../service/entity-master.service';
+import { HttpCode } from '@nestjs/common';
+import { HttpStatus } from '@nestjs/common';
+
+@Controller('entity-master')
+@UseGuards(JwtAuthGuard)
+export class EntityMasterController {
+  constructor(@Inject('EntityMasterService') private readonly entityMasterService: EntityMasterService) {}
+
+  @Get('getById/:id')
+  @HttpCode(HttpStatus.OK)
+  async getEntityById(
+    @Param('id') id: number,
+    @Req() req: Request & { user: any },
+  ) {
+    return await this.entityMasterService.getEntityById(id);
+  }
+
+  @Get('getAllEntityRealationDropdown/:entity_type')
+  @HttpCode(HttpStatus.OK)
+  async getAllEntity(
+    @Param('entity_type') entity_type: string,
+    @Req() req: Request & { user: any },
+  ) {
+
+    const loggedInUser = req.user.userData;
+
+    // console.log(loggedInUser);
+    return await this.entityMasterService.getAllEntityDropDown(entity_type,loggedInUser)
+  }
+}

package/src/module/entity/meta/controller/entity-relation.controller.ts

@@ -0,0 +1,36 @@
+import {
+  Controller,
+  Get,
+  Inject,
+  Param,
+  Query,
+  Request,
+  UseGuards,
+} from '@nestjs/common';
+import { JwtAuthGuard } from '../../../auth/guards/jwt.guard';
+import { EntityRelationService } from '../service/entity-relation.service';
+
+@UseGuards(JwtAuthGuard)
+@Controller('entity-relation')
+export class EntityRelationController {
+  constructor(
+    @Inject('EntityRelationService')
+    private readonly entityRelationService: EntityRelationService,
+  ) {}
+
+  @Get(':source_entity_type')
+  async getEntityRelations(
+    @Param('source_entity_type') sourceEntityType: string,
+    @Query('include') include: string, // <-- new param
+    @Request() req: any,
+  ): Promise<any> {
+    const loggedInUser = req.user.userData;
+    const shouldIncludeSelf = include === 'true';
+
+    return this.entityRelationService.getEntityRelations(
+      sourceEntityType,
+      loggedInUser,
+      shouldIncludeSelf,
+    );
+  }
+}