rez_core 7.1.21 → 7.1.22

package/src/module/entity/linked_attributes/test/linked-attributes.service.spec.ts

@@ -0,0 +1,244 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { LinkedAttributesService } from '../service/linked_attributes.service';
+import { DataSource } from 'typeorm';
+import { EntityMasterService } from 'src/module/entity/meta/service/entity-master.service';
+import { AttributeMasterService } from 'src/module/entity/meta/service/attribute-master.service';
+import { SavedFilterService } from 'src/module/entity/filter/service/saved-filter.service';
+import { SavedFilterDetailRepository } from 'src/module/entity/filter/repository/saved.filter-detail.repository';
+import { EntityJSONService } from 'src/module/entity/entity_json/service/entity_json.service';
+
+describe('LinkedAttributesService - Phase 1 Tests', () => {
+  let service: LinkedAttributesService;
+  let dataSource: DataSource;
+  let entityMasterService: EntityMasterService;
+  let attributeMasterService: AttributeMasterService;
+
+  const mockDataSource = {
+    getRepository: jest.fn(),
+    transaction: jest.fn(),
+  };
+
+  const mockEntityMasterService = {
+    getEntityData: jest.fn(),
+  };
+
+  const mockAttributeMasterService = {
+    findAttributesByMappedEntityType: jest.fn(),
+  };
+
+  const mockSavedFilterService = {
+    createEntity: jest.fn(),
+  };
+
+  const mockSavedFilterDetailRepository = {
+    findByMappedFilterCode: jest.fn(),
+  };
+
+  const mockEntityJSONService = {
+    updateEntityJSON: jest.fn(),
+  };
+
+  const mockLoggedInUser = {
+    id: 1,
+    organization_id: 100,
+    level_type: 'ORG',
+    level_id: 100,
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        LinkedAttributesService,
+        { provide: DataSource, useValue: mockDataSource },
+        { provide: EntityMasterService, useValue: mockEntityMasterService },
+        {
+          provide: AttributeMasterService,
+          useValue: mockAttributeMasterService,
+        },
+        { provide: 'SavedFilterService', useValue: mockSavedFilterService },
+        {
+          provide: SavedFilterDetailRepository,
+          useValue: mockSavedFilterDetailRepository,
+        },
+        { provide: EntityJSONService, useValue: mockEntityJSONService },
+      ],
+    }).compile();
+
+    service = module.get<LinkedAttributesService>(LinkedAttributesService);
+    dataSource = module.get<DataSource>(DataSource);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('Task 1.1: generateAttributeKey', () => {
+    it('should generate correct attribute key format', () => {
+      const result = service.generateAttributeKey('LFMG', 'name', 1);
+      expect(result).toBe('LFMG__name__1');
+    });
+
+    it('should handle different sequences', () => {
+      expect(service.generateAttributeKey('LFMG', 'name', 1)).toBe(
+        'LFMG__name__1',
+      );
+      expect(service.generateAttributeKey('LFMG', 'name', 2)).toBe(
+        'LFMG__name__2',
+      );
+      expect(service.generateAttributeKey('LFMG', 'name', 99)).toBe(
+        'LFMG__name__99',
+      );
+    });
+
+    it('should throw error for empty entity_type', () => {
+      expect(() => service.generateAttributeKey('', 'name', 1)).toThrow(
+        'applicable_entity_type is required and cannot be empty',
+      );
+    });
+
+    it('should throw error for empty attribute_key', () => {
+      expect(() => service.generateAttributeKey('LFMG', '', 1)).toThrow(
+        'applicable_attribute_key is required and cannot be empty',
+      );
+    });
+
+    it('should throw error for invalid sequence', () => {
+      expect(() => service.generateAttributeKey('LFMG', 'name', 0)).toThrow(
+        'sequence must be a positive integer greater than 0',
+      );
+      expect(() => service.generateAttributeKey('LFMG', 'name', -1)).toThrow(
+        'sequence must be a positive integer greater than 0',
+      );
+      expect(() => service.generateAttributeKey('LFMG', 'name', 1.5)).toThrow(
+        'sequence must be a positive integer greater than 0',
+      );
+    });
+
+    it('should trim whitespace from inputs', () => {
+      expect(() =>
+        service.generateAttributeKey('  ', 'name', 1),
+      ).toThrow();
+      expect(() =>
+        service.generateAttributeKey('LFMG', '  ', 1),
+      ).toThrow();
+    });
+  });
+
+  describe('Task 1.2: Validation Engine', () => {
+    it('should validate required fields', async () => {
+      const payload = {
+        field_name: '',
+        mapped_entity_type: 'LEAD',
+        applicable_entity_type: 'LFMG',
+        applicable_attribute_key: 'name',
+        organization_id: 100,
+      };
+
+      const result = await service.validateLinkedAttribute(
+        payload,
+        mockLoggedInUser,
+      );
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain(
+        "Required field 'field_name' is missing or empty",
+      );
+    });
+
+    it('should validate entity type exists', async () => {
+      mockEntityMasterService.getEntityData.mockRejectedValue(
+        new Error('Not found'),
+      );
+
+      const payload = {
+        field_name: 'Father Name',
+        mapped_entity_type: 'INVALID',
+        applicable_entity_type: 'LFMG',
+        applicable_attribute_key: 'name',
+        organization_id: 100,
+      };
+
+      const result = await service.validateLinkedAttribute(
+        payload,
+        mockLoggedInUser,
+      );
+
+      expect(result.valid).toBe(false);
+      expect(
+        result.errors.some((e) => e.includes('does not exist')),
+      ).toBe(true);
+    });
+
+    it('should pass validation for valid payload', async () => {
+      // Mock successful validations
+      mockEntityMasterService.getEntityData
+        .mockResolvedValueOnce({ id: 1 }) // mapped_entity_type
+        .mockResolvedValueOnce({ id: 2 }); // applicable_entity_type
+
+      mockAttributeMasterService.findAttributesByMappedEntityType.mockResolvedValue(
+        [{ attribute_key: 'name' }],
+      );
+
+      const mockRepository = {
+        createQueryBuilder: jest.fn().mockReturnValue({
+          where: jest.fn().mockReturnThis(),
+          andWhere: jest.fn().mockReturnThis(),
+          getOne: jest.fn().mockResolvedValue(null), // No duplicate
+        }),
+      };
+
+      mockDataSource.getRepository.mockReturnValue(mockRepository);
+
+      const payload = {
+        field_name: 'Father Name',
+        mapped_entity_type: 'LEAD',
+        applicable_entity_type: 'LFMG',
+        applicable_attribute_key: 'name',
+        organization_id: 100,
+      };
+
+      const result = await service.validateLinkedAttribute(
+        payload,
+        mockLoggedInUser,
+      );
+
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+  });
+
+  describe('Task 1.4: Smart Create Method', () => {
+    it('should throw BadRequestException on validation failure', async () => {
+      // Mock validation failure
+      mockEntityMasterService.getEntityData.mockRejectedValue(
+        new Error('Not found'),
+      );
+
+      const dto = {
+        field_name: 'Father Name',
+        mapped_entity_type: 'INVALID',
+        applicable_entity_type: 'LFMG',
+        applicable_attribute_key: 'name',
+      };
+
+      await expect(
+        service.createLinkedAttributeSmart(dto, mockLoggedInUser),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('Integration Tests', () => {
+    it('should handle end-to-end attribute key generation', () => {
+      // Test the full flow: sequence 1, 2, 3
+      expect(service.generateAttributeKey('LFMG', 'name', 1)).toBe(
+        'LFMG__name__1',
+      );
+      expect(service.generateAttributeKey('LFMG', 'email', 1)).toBe(
+        'LFMG__email__1',
+      );
+      expect(service.generateAttributeKey('CONTACT', 'phone', 1)).toBe(
+        'CONTACT__phone__1',
+      );
+    });
+  });
+});

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

@@ -0,0 +1,76 @@
+import {
+  Body,
+  Controller,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Inject,
+  Param,
+  Post,
+  Query,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { FieldMapperService } from '../service/field-mapper.service';
+import { JwtAuthGuard } from '../../../auth/guards/jwt.guard';
+import { FieldMapperDto } from '../dto/field-mapper.dto';
+
+@Controller('field-mapper')
+@UseGuards(JwtAuthGuard)
+export class FieldMapperController {
+  constructor(
+    @Inject('FieldMapperService')
+    private readonly fieldMapperService: FieldMapperService,
+  ) {}
+
+  @Post('resolve')
+  async resolve(
+    @Req() req: any,
+    @Query('integration_component') integration_component: number,
+    @Query('action') action: 'LOOKUP' | 'LOAD',
+    @Query('entity_type') entity_type: string,
+    @Query('entity_id') entity_id: number,
+    @Body() inputJson,
+  ) {
+    const loggedInUser = req.user.userData;
+    return await this.fieldMapperService.resolveData(
+      integration_component,
+      action,
+      entity_type,
+      entity_id,
+      loggedInUser,
+      inputJson,
+      inputJson['mapped_entities'],
+    );
+  }
+
+  @Post('bulk')
+  @HttpCode(HttpStatus.OK)
+  async createBulk(@Req() req: any, @Body() dtos: FieldMapperDto[]) {
+    const loggedInUser = req.user.userData;
+    return this.fieldMapperService.createFieldMappers(dtos, loggedInUser);
+  }
+
+  @Post('bulk-update')
+  @HttpCode(HttpStatus.OK)
+  async updateBulk(@Req() req: any, @Body() dtos: FieldMapperDto[]) {
+    const loggedInUser = req.user.userData;
+    return this.fieldMapperService.updateFieldMappers(dtos, loggedInUser);
+  }
+
+  @Get('getFields/:mapperId')
+  async getFieldsByMapper(
+    @Param('mapperId') mapperId: number,
+    @Query('mapper_entity_type') mapper_entity_type: string,
+  ) {
+    return this.fieldMapperService.getMapperFields(
+      mapperId,
+      mapper_entity_type,
+    );
+  }
+
+  @Get('getLovs/:mapperFieldId')
+  async getLovsByMapperField(@Param('mapperFieldId') mapperFieldId: number) {
+    return this.fieldMapperService.getFieldLovs(mapperFieldId);
+  }
+}

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

@@ -0,0 +1,20 @@
+import { Controller, Get, Inject, Query, Req, Res, UseGuards } from '@nestjs/common';
+import { MapperService } from '../service/mapper.service';
+import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { Response } from 'express';
+
+@Controller('mapper')
+@UseGuards(JwtAuthGuard)
+export class MapperController {
+  constructor(@Inject('MapperService') private readonly mapperService: MapperService) {}
+
+  @Get('all')
+  async getByMappedEntityType(@Query('mapped_entity_type') mappedEntityType: string,
+  @Req() req: Request & { user: any },
+                              @Query('filter') filter?: string,
+                              @Query('status') status?: string,
+                              ) {
+                                const loggedInUser = req.user.userData;
+    return this.mapperService.getByMappedEntityType(mappedEntityType,loggedInUser, filter, status);
+  }
+}

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

@@ -0,0 +1,14 @@
+import { BaseEntity } from '../../meta/entity/base-entity.entity';
+import { FieldLovMapper } from '../entity/field-lovs.entity';
+
+export class FieldMapperDto extends BaseEntity {
+  action: string;
+  mapper_id: number;
+  source_attribute: string;
+  attribute_key: string;
+  mapper_entity_type: string;
+  mapped_entity_type: string;
+  filter_code?: string;
+  field_lovs?: FieldLovMapper[];
+}
+

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

@@ -0,0 +1,15 @@
+import { Column, Entity } from 'typeorm';
+import { BaseEntity } from '../../meta/entity/base-entity.entity';
+
+@Entity({ name: 'frm_mapper_field_lov' })
+export class FieldLovMapper extends BaseEntity {
+
+  @Column({ name: 'mapper_field_id' })
+  mapper_field_id: number; //1
+
+  @Column({ name: 'destination_attribute_value', type: 'varchar', length: 30 })
+  destination_attribute_value: string; //INDIA
+
+  @Column({ name: 'source_attribute_value', type: 'varchar', length: 30 })
+  source_attribute_value: string; //IND
+}

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

@@ -0,0 +1,49 @@
+import { Column, Entity } from 'typeorm';
+import { BaseEntity } from '../../meta/entity/base-entity.entity';
+
+@Entity({ name: 'frm_mapper_field' })
+export class FieldMapper extends BaseEntity {
+
+  @Column({ name: 'mapper_id', type: 'bigint', nullable: true })
+  mapper_id: number;
+
+  @Column({ name: 'action', type: 'varchar', length: 30, nullable: true })
+  action: string;
+
+  @Column({ name: 'source_attribute', type: 'varchar', length: 30, nullable: true })
+  source_attribute: string;
+
+  @Column({ name: 'attribute_key', type: 'varchar', length: 30, nullable: true })
+  attribute_key: string;
+
+  @Column({ name: 'mapper_entity_type', type: 'varchar', length: 30,  nullable: true })
+  mapper_entity_type: string;
+
+  @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',
+    nullable: true,
+  })
+  filter_code: string;
+
+  @Column({
+    name: 'is_lov_present',
+    type: 'boolean',
+    nullable: true,
+    default: false,
+  })
+  is_lov_present: boolean;
+
+  @Column({ name: 'seq', type: 'int', nullable: true })
+  seq: number;
+}

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

@@ -0,0 +1,9 @@
+import { Column, Entity } from 'typeorm';
+import { BaseEntity } from '../../meta/entity/base-entity.entity';
+
+@Entity({ name: 'frm_mapper_master' })
+export class Mapper extends BaseEntity {
+
+  @Column({ nullable: true, type: 'varchar', length: 100 })
+  mapped_entity_type: string;
+}

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

@@ -0,0 +1,36 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { FieldMapper } from './entity/field-mapper.entity';
+import { FieldMapperService } from './service/field-mapper.service';
+import { FieldMapperRepository } from './repository/field-mapper.repository';
+import { FilterModule } from '../filter/filter.module';
+import { EntityModule } from '../meta/entity.module';
+import { FieldMapperController } from './controller/field-mapper.controller';
+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';
+import { MapperRepository } from './repository/mapper.repository';
+import { ListMasterItems } from '../../listmaster/entity/list-master-items.entity';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([FieldMapper, FieldLovMapper,Mapper,ListMasterItems]),
+    FilterModule,
+    EntityModule
+  ],
+  providers: [
+    { provide: 'FieldMapperService', useClass: FieldMapperService },
+    { provide: 'MapperService', useClass: MapperService },
+    FieldMapperRepository,
+    FieldLovsRepository,
+    MapperRepository
+  ],
+  exports: [
+    { provide: 'FieldMapperService', useClass: FieldMapperService },
+  ],
+  controllers: [FieldMapperController,MapperController],
+})
+export class MapperModule {
+}

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

@@ -0,0 +1,36 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { FieldLovMapper } from '../entity/field-lovs.entity';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class FieldLovsRepository {
+  constructor(@InjectRepository(FieldLovMapper) private readonly fieldLovMapperRepository: Repository<FieldLovMapper>) {
+  }
+
+  async saveBulk(dtos: FieldLovMapper[]) {
+    return await this.fieldLovMapperRepository.save(dtos)
+  }
+
+  async findByMapperFieldIdAndSourceAttributeValue(mapper_field_id: number, source_attribute_value: string) {
+    return await this.fieldLovMapperRepository.findOne({
+      where: { mapper_field_id, source_attribute_value },
+    });
+  }
+
+  async findByMapperFieldIdAndDestinationAttributeValue(mapper_field_id: number, destination_attribute_value: string) {
+    return await this.fieldLovMapperRepository.findOne({
+      where: { mapper_field_id, destination_attribute_value },
+    })
+  }
+
+  async findByMapperFieldId(mapper_field_id: number) {
+    return await this.fieldLovMapperRepository.find({
+      where: { mapper_field_id },
+    })
+  }
+
+  async deleteByMapperFieldId(mapper_field_id: number) {
+    return await this.fieldLovMapperRepository.delete({ mapper_field_id });
+  }
+}

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

@@ -0,0 +1,43 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { FieldMapper } from '../entity/field-mapper.entity';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class FieldMapperRepository {
+  constructor(
+    @InjectRepository(FieldMapper)
+    private readonly fieldMapperRepository: Repository<FieldMapper>,
+  ) {
+  }
+
+  async findByMapperIdAndMappedEntityType(mapper_id: number, mapped_entity_type: string) {
+    return await this.fieldMapperRepository.find({
+      where: { mapper_id, mapped_entity_type },
+    });
+  }
+
+  async save(dto: Partial<FieldMapper>) {
+    return await this.fieldMapperRepository.save(dto);
+  }
+
+  async findByMapperId(mapper_id: number) {
+    return await this.fieldMapperRepository.find({
+        where: {mapper_id},
+        order: {seq : 'ASC'}
+      },
+    );
+  }
+
+  async findByMapperIdAndMapperEntityType(mapper_id: number, mapper_entity_type: string) {
+    return await this.fieldMapperRepository.find({
+        where: {mapper_id, mapper_entity_type},
+        order: {seq : 'ASC'}
+      },
+    );
+  }
+
+  async deleteByMapperId(mapper_id: number) {
+    return await this.fieldMapperRepository.delete({ mapper_id });
+  }
+}

package/src/module/entity/mapper/repository/mapper.repository.ts

@@ -0,0 +1,33 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Mapper } from '../entity/mapper.entity';
+import { Repository } from 'typeorm';
+
+@Injectable()
+export class MapperRepository {
+  constructor(
+    @InjectRepository(Mapper) private readonly mapperRepository: Repository<Mapper>,
+  ) {
+  }
+
+  async findByMappedEntityType(
+    mapped_entity_type: string,
+    enterprise_id: number,
+    filter?: string,
+  ) {
+    const qb = this.mapperRepository
+      .createQueryBuilder('m')
+      .select('m.*')
+      .where('m.mapped_entity_type = :mapped_entity_type', {
+        mapped_entity_type,
+      })
+      .andWhere('m.enterprise_id = :enterprise_id', { enterprise_id });
+
+    if (filter && filter.trim() !== '') {
+      qb.andWhere('(m.name ILIKE :filter OR m.code ILIKE :filter)', {
+        filter: `%${filter}%`,
+      });
+    }
+    return await qb.getRawMany();
+  }
+}