rez_core 6.5.23 → 6.5.26

package/src/module/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/meta/service/entity-master.service';
+import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
+import { SavedFilterService } from 'src/module/filter/service/saved-filter.service';
+import { SavedFilterDetailRepository } from 'src/module/filter/repository/saved.filter-detail.repository';
+import { EntityJSONService } from 'src/module/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/listmaster/service/list-master.service.ts

@@ -212,6 +212,14 @@ export class ListMasterService {
         });
       }
 
+      if (loggedInUser?.appcode && sourceList === 'ROL') {
+        if (!this.skipLevelFilterEntities.includes(sourceList)) {
+          qb.andWhere(`${tableName}.appcode = :appcode`, {
+            appcode: loggedInUser.appcode,
+          });
+        }
+      }
+
       // ✅ Apply dynamic params
       for (const key in params) {
         qb.andWhere(`${tableName}.${key} = :${key}`, {
@@ -251,7 +259,7 @@ export class ListMasterService {
 
     const resolveInactiveStatus = await this.getResolvedListCode(
       STATUS_INACTIVE,
-      loggedInUser?.enterprise_id || 0,
+      loggedInUser?.organization_id || 0,
     );
 
     // Fetch inactive records (with same filters but without status condition)

package/src/module/meta/controller/meta.controller.ts

@@ -1,7 +1,17 @@
-import { Body, Controller, HttpCode, HttpStatus, Post, Query, Req, Res, UseGuards } from '@nestjs/common';
+import {
+  Body,
+  Controller, HttpCode,
+  HttpStatus,
+  Post,
+  Query,
+  Req,
+  Res,
+  UseGuards,
+} from '@nestjs/common';
 import { EntityTableService } from '../service/entity-table.service';
 import { Response } from 'express';
 import { JwtAuthGuard } from '../../auth/guards/jwt.guard';
+import { PopulateMetaService } from '../service/populate-meta.service';
 import { EntityMasterService } from '../service/entity-master.service';
 
 @Controller('meta')
@@ -9,9 +19,9 @@ import { EntityMasterService } from '../service/entity-master.service';
 export class MetaController {
   constructor(
     private readonly entityTableService: EntityTableService,
+    private readonly populateMetaService: PopulateMetaService,
     private readonly entityMaster: EntityMasterService,
-  ) {
-  }
+  ) {}
 
   @Post('get-table-data')
   @HttpCode(HttpStatus.OK)
@@ -54,6 +64,18 @@ export class MetaController {
     });
   }
 
+  @Post('populate')
+  @HttpCode(HttpStatus.OK)
+  async populateMetaData(
+    @Query('organization_id') organizationId: number,
+    @Res() response: Response,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+    const result =
+      await this.populateMetaService.populateMetaData(organizationId);
+    return response.status(HttpStatus.OK).json(result);
+  }
 
   @Post('operation-list')
   @HttpCode(HttpStatus.OK)

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

@@ -1,31 +1,15 @@
 import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+import { BaseEntity } from './base-entity.entity';
 
 @Entity({ name: 'sso_app_master' })
-export class AppMaster {
+export class AppMaster extends BaseEntity {
+  constructor() {
+    super();
+    this.entity_type = 'APM';
+  }
 
   @PrimaryGeneratedColumn()
   id: number;
-  
-  @Column({ name: 'name', type: 'varchar', length: 100, nullable: true })
-  name: string;
-
-  @Column({ name: 'status', type: 'varchar', nullable: true, length: 100 })
-  status: string;
-
-  @Column({ name: 'code', type: 'varchar', length: 100, nullable: true })
-  code: string;
-
-  @Column({ name: 'created_by', type: 'bigint', nullable: true })
-  created_by: number;
-
-  @Column({ name: 'created_date',nullable: true })
-  created_date: Date;
-
-  @Column({ name: 'modified_by', type: 'bigint', nullable: true })
-  modified_by: number;
-
-  @Column({ name: 'modified_date', nullable: true })
-  modified_date: Date;
 
   @Column({ name: 'type', type: 'varchar', nullable: true })
   type: string;
@@ -47,4 +31,7 @@ export class AppMaster {
 
   @Column({ name: 'version', type: 'varchar', nullable: true })
   version: string;
+
+   @Column({ name: 'show_in_ui', type: 'boolean', nullable: true })
+  show_in_ui: string;
 }

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

@@ -3,7 +3,10 @@ import { ENTITYTYPE_ENTITYMASTER } from '../../../constant/global.constant';
 import { Column, Entity, Index } from 'typeorm';
 
 @Entity({ name: 'frm_entity_master' })
-@Index('idx_entity_master_mapped_type_org', ['mapped_entity_type', 'organization_id'])
+@Index('idx_entity_master_mapped_type_org', [
+  'mapped_entity_type',
+  'organization_id',
+])
 export class EntityMaster extends BaseEntity {
   constructor() {
     super();
@@ -77,9 +80,12 @@ export class EntityMaster extends BaseEntity {
   @Column({ name: 'is_workflow', nullable: true })
   is_workflow: boolean;
 
-  @Column({ name: 'doc_upload_path', nullable: true, length:50 })
+  @Column({ name: 'doc_upload_path', nullable: true, length: 50 })
   doc_upload_path: string;
 
-  @Column({name: 'overwrite_path', type: 'int', nullable: true})
+  @Column({ name: 'overwrite_path', type: 'int', nullable: true })
   overwrite_path: number;
+
+  @Column({ name: 'is_flag_json', nullable: true })
+  is_flag_json: boolean;
 }

package/src/module/meta/entity.module.ts

@@ -44,6 +44,7 @@ import { UserRoleMapping } from '../user/entity/user-role-mapping.entity';
 import { AppMasterService } from './service/app-master.service';
 import { AppMasterRespository } from './repository/app-master.repository';
 import { AppMaster } from './entity/app-master.entity';
+import { PopulateMetaService } from './service/populate-meta.service';
 import { AttributeMasterController } from './controller/attribute-master.controller';
 import { EntityDynamicController } from './controller/entity-dynamic.controller';
 import { EntityDynamicService } from './service/entity-dynamic.service';
@@ -79,6 +80,7 @@ import { EntityRelationRepository } from './repository/entity-relation.repositor
     ]),
     forwardRef(() => ListMasterModule),
     forwardRef(() => FilterModule),
+    forwardRef(() => require('../entity_json/entity_json.module').EntityJSONModule),
     UtilsModule,
     forwardRef(() => WorkflowAutomationModule),
 
@@ -95,6 +97,7 @@ import { EntityRelationRepository } from './repository/entity-relation.repositor
     MasterService,
     EntityTableRepository,
     EntityTableService,
+    PopulateMetaService,
     EntityTableColumnRepository,
     EntityTableColumnService,
     MediaDataRepository,
@@ -119,7 +122,7 @@ import { EntityRelationRepository } from './repository/entity-relation.repositor
     AppMasterService,
     ResolverService,
     EntityMasterRepository,
-    EntityRelationRepository,
+    EntityRelationRepository
   ],
   exports: [
     EntityMasterService,
@@ -127,6 +130,7 @@ import { EntityRelationRepository } from './repository/entity-relation.repositor
     PreferenceService,
     EntityValidationService,
     EntityTableService,
+    PopulateMetaService,
     EntityTableColumnService,
     MediaDataService,
     EntityUpdateService,
@@ -143,7 +147,6 @@ import { EntityRelationRepository } from './repository/entity-relation.repositor
     EntityDynamicService,
     'CommonService',
     'EntityRelationService',
-    AppMasterRespository,
   ],
   controllers: [
     EntityController,
@@ -157,8 +160,6 @@ import { EntityRelationRepository } from './repository/entity-relation.repositor
     EntityRelationController,
     EntityMasterController,
     EntityPublicController,
-
   ],
 })
-export class EntityModule {
-}
+export class EntityModule {}

package/src/module/meta/repository/app-master.repository.ts

@@ -14,7 +14,7 @@ export class AppMasterRespository {
     appCode: string,
   ): Promise<AppMaster[] | null> {
     return await this.AppMasterRespository.find({
-      where: { code: appCode },
+      where: { appcode: appCode },
     });
   }
 }

package/src/module/meta/service/attribute-master.service.ts

@@ -1,12 +1,18 @@
-import { Injectable } from '@nestjs/common';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
 import { AttributeMasterRepository } from '../repository/attribute-master.repository';
 import { UserData } from 'src/module/user/entity/user.entity';
 import { AttributeMaster } from '../entity/attribute-master.entity';
+import { EntityMasterRepository } from '../repository/entity-master.repository';
+import { EntityJSONService } from 'src/module/entity_json/service/entity_json.service';
 
 @Injectable()
 export class AttributeMasterService {
   constructor(
     private readonly attributeMasterRepository: AttributeMasterRepository,
+    @Inject(forwardRef(() => EntityMasterRepository))
+    private readonly entityMasterRepository: EntityMasterRepository,
+    @Inject(forwardRef(() => EntityJSONService))
+    private readonly entityJSONService: EntityJSONService,
   ) {
   }
 
@@ -24,6 +30,7 @@ export class AttributeMasterService {
     attributeData: AttributeMaster,
     loggedInUser: UserData,
   ): Promise<AttributeMaster> {
+    attributeData.organization_id = loggedInUser.organization_id;
     attributeData.enterprise_id = loggedInUser.enterprise_id;
     attributeData.level_type = loggedInUser.level_type;
     attributeData.level_id = loggedInUser.level_id;
@@ -85,6 +92,7 @@ export class AttributeMasterService {
     id: number,
     loggedInUser: UserData,
   ): Promise<AttributeMaster | null> {
+    attributeData.organization_id = loggedInUser.organization_id;
     attributeData.enterprise_id = loggedInUser.enterprise_id;
     attributeData.level_type = loggedInUser.level_type;
     attributeData.level_id = loggedInUser.level_id;
@@ -127,4 +135,26 @@ export class AttributeMasterService {
       loggedInUser.enterprise_id
     );
   }
+
+    async getAttributes(entityType: string, loggedInUser: any) {
+
+
+    const entityData = await this.entityMasterRepository.getEntityByMappedEntityType(
+      entityType,
+      loggedInUser.enterprise_id,
+    );
+
+    if (entityData && entityData.is_flag_json) {
+      return this.entityJSONService.getAttributeForFlatJSON(
+        entityType,
+        loggedInUser,
+        'filter_attribute',
+      );
+    }
+
+    return await this.findAttributesByMappedEntityType(
+      entityType,
+      loggedInUser,
+    );
+  }
 }

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

@@ -17,6 +17,7 @@ export class EntityMasterService {
     private readonly dataSource: DataSource,
     @Inject('ListMasterService')
     private readonly listMasterService: ListMasterService,
+    @Inject(forwardRef(() => SavedFilterRepositoryService))
     private readonly savedFilterRepoService: SavedFilterRepositoryService,
   ) {}
 

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

@@ -1,14 +1,18 @@
-import { Injectable } from '@nestjs/common';
+import { Inject, Injectable, forwardRef } from '@nestjs/common';
 import { EntityServiceImpl } from './entity-service-impl.service';
 import { EntityMasterRepository } from '../repository/entity-master.repository';
+import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
 import { EntityRelationRepository } from '../repository/entity-relation.repository';
 
 @Injectable()
-export class EntityRelationService extends EntityServiceImpl {
-  constructor(private entityMasterRepo: EntityMasterRepository,
-              private entityRelationRepository: EntityRelationRepository) {
-    super();
-  }
+export class EntityRelationService {
+  constructor(
+    @Inject(forwardRef(() => EntityMasterRepository))
+    private entityMasterRepo: EntityMasterRepository,
+    @Inject(forwardRef(() => ReflectionHelper))
+    private readonly reflectionHelper: ReflectionHelper,
+       private entityRelationRepository: EntityRelationRepository
+  ) {}
 
   async getEntityRelations(
     entityType: string,

package/src/module/meta/service/entity-service-impl.service.ts

@@ -14,24 +14,14 @@ import { ResolverService } from './resolver.service';
 
 @Injectable()
 export class EntityServiceImpl implements EntityService<BaseEntity> {
-  @Inject(forwardRef(() => EntityMasterService))
-  protected readonly entityMasterService: EntityMasterService;
-
-  @Inject(forwardRef(() => EntityTableColumnService))
+  @Inject() protected readonly entityMasterService: EntityMasterService;
+  @Inject()
   protected readonly entityTableColumnService: EntityTableColumnService;
-
-  @Inject(forwardRef(() => EntityTableService))
-  protected readonly entityTableService: EntityTableService;
-
-  @Inject(forwardRef(() => ReflectionHelper))
-  protected readonly reflectionHelper: ReflectionHelper;
-
-  @Inject(forwardRef(() => LoggingService))
-  protected readonly loggingService: LoggingService;
-
-  @Inject(forwardRef(() => EntityValidationService))
+  @Inject() protected readonly entityTableService: EntityTableService;
+  @Inject() protected readonly reflectionHelper: ReflectionHelper;
+  @Inject() protected readonly loggingService: LoggingService;
+  @Inject()
   protected readonly entityValidationService: EntityValidationService;
-
   @Inject(forwardRef(() => ResolverService))
   protected readonly resolverService: ResolverService;
 
@@ -87,19 +77,21 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
     const statusList = await listMasterItemsRepo.findOne({
       where: {
         code: STATUS_ACTIVE,
-        enterprise_id: loggedInUser?.enterprise_id || 0,
+        organization_id: loggedInUser?.organization_id || 0,
       },
       select: ['id'],
     });
 
     console.log('Status List:', statusList); // Debug log
     console.log(
-      `status_code,${STATUS_ACTIVE},statusList, ${loggedInUser?.enterprise_id}`,
+      `status_code,${STATUS_ACTIVE},statusList, ${loggedInUser?.organization_id}`,
     ); // Debug log
 
     entityData.created_date = new Date();
     if (loggedInUser) {
       entityData.created_by = loggedInUser.id;
+      if (!entityData.organization_id)
+        entityData.organization_id = loggedInUser.organization_id;
       if (!entityData.enterprise_id)
         entityData.enterprise_id = loggedInUser.enterprise_id;
       if (!entityData.level_type)
@@ -299,6 +291,8 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
     entityData.modified_date = new Date();
     if (loggedInUser) {
       entityData.modified_by = loggedInUser.id;
+      if (!entityData.organization_id && entityData.entity_type !== 'ORG')
+        entityData.organization_id = loggedInUser.organization_id;
       if (!entityData.enterprise_id)
         entityData.enterprise_id = loggedInUser.enterprise_id;
     }
@@ -350,6 +344,7 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
     entityType: string,
     entityId: number,
     loggedInUser: UserData,
+    format_disable?: boolean,
   ): Promise<any> {
     const entityData = await this.entityMasterService.getEntityData(
       entityType,
@@ -367,7 +362,7 @@ export class EntityServiceImpl implements EntityService<BaseEntity> {
     }
     const data = await repoService.findOne({ where: { id: entityId } });
 
-    return this.resolverService.getResolvedData(loggedInUser, data, entityType);
+    return this.resolverService.getResolvedData(loggedInUser, data, entityType,format_disable);
   }
 
   async getResolvedEntityDataByDataSource(