rez_core 5.0.211 → 6.1.0

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/meta/controller/attribute-master.controller.ts

@@ -81,4 +81,16 @@ export class AttributeMasterController {
       loggedInUser,
     );
   }
+  
+  @Get('getAll/:entityType')
+  async getAttributes(
+    @Param('entityType') entityType: string,
+    @Req() req: Request & { user: any },
+  ) {
+    const loggedInUser = req.user.userData;
+    return await this.attributeMasterService.getAttributes(
+      entityType,
+      loggedInUser,
+    );
+  }
 }

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

@@ -77,13 +77,13 @@ import { EntityRelationRepository } from './repository/entity-relation.repositor
       AppMaster,
       EntityRelation,
       EntityRelationData,
-      EntityUpdateService
     ]),
     forwardRef(() => ListMasterModule),
     forwardRef(() => FilterModule),
+    forwardRef(() => require('../entity_json/entity_json.module').EntityJSONModule),
     UtilsModule,
-    WorkflowAutomationModule,
-    
+    forwardRef(() => WorkflowAutomationModule),
+
   ],
   providers: [
     EntityMasterService,

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,
   ) {
   }
 
@@ -129,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

@@ -344,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,
@@ -361,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(

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

@@ -5,18 +5,22 @@ import { EntityTableDto } from '../dto/entity-table.dto';
 import { DISPLAY_LIST } from '../../../constant/global.constant';
 import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
 import { SavedFilterRepositoryService } from 'src/module/filter/repository/saved-filter.repository';
+import { AttributeMasterService } from './attribute-master.service';
 
 @Injectable()
 export class EntityTableService {
   constructor(
     private entityTableRepository: EntityTableRepository,
     private readonly entityTableColumnRepository: EntityTableColumnRepository,
+    // private readonly entityJSONService: EntityJSONService,
 
     @Inject(forwardRef(() => 'ListMasterService'))
     @Inject('ListMasterService')
     private readonly listMasterService: ListMasterService,
 
+    @Inject(forwardRef(() => SavedFilterRepositoryService))
     private readonly savedFilterRepoService: SavedFilterRepositoryService,
+    private readonly attributeMasterService: AttributeMasterService,
   ) {}
 
   async getEntityData(mappedEntityType: string | null, loggedInUser) {
@@ -79,77 +83,87 @@ export class EntityTableService {
     displayType: string,
     loggedInUser: any,
   ) {
-    const entityTable = await this.findByEntityTypeAndListTypeAndDisplayType(
-      entityType,
-      listType,
-      displayType,
-      loggedInUser?.enterprise_id,
-    );
-    const entityTableDto = entityTable as EntityTableDto;
-    if (entityTable) {
-      entityTableDto.column_list =
-        await this.entityTableColumnRepository.findByParentIdAndParentType(
-          entityTable.id,
-          entityTable.entity_type,
-          loggedInUser.enterprise_id,
+    let entityTableDto: any = {};
+
+    entityTableDto.column_list = [
+      {
+        name:'Code',
+        attribute_key:'code',
+        data_type:'text'
+      },
+      {
+        name:'name',
+        attribute_key:'name',
+        data_type:'text'
+      },
+      {
+        name:'status',
+        attribute_key:'status',
+        data_type:'select'
+      },
+      {
+        name:'description',
+        attribute_key:'description',
+        data_type:'text'
+      }
+    ];
+
+    entityTableDto.operation_list = {
+      text: await this.listMasterService.getDropdownOptions(
+        'OPT',
+        {},
+        [],
+        loggedInUser,
+      ),
+      number: await this.listMasterService.getDropdownOptions(
+        'OPN',
+        {},
+        [],
+        loggedInUser,
+      ),
+      date: await this.listMasterService.getDropdownOptions(
+        'OPD',
+        {},
+        [],
+        loggedInUser,
+      ),
+      select: await this.listMasterService.getDropdownOptions(
+        'OPS',
+        {},
+        [],
+        loggedInUser,
+      ),
+      multiselect: await this.listMasterService.getDropdownOptions(
+        'OPM',
+        {},
+        [],
+        loggedInUser,
+      ),
+      year: await this.listMasterService.getDropdownOptions(
+        'OPY',
+        {},
+        [],
+        loggedInUser,
+      ),
+      // Add any other operations you want to include
+    };
+    entityTableDto.default_filter =
+      await this.savedFilterRepoService.getDefaultFilterByEntityType(
+        entityType,
+      );
+    if (loggedInUser.id) {
+      entityTableDto.saved_filter =
+        await this.savedFilterRepoService.getSavedFiltersByUserIdAndEntityType(
+          loggedInUser.id,
+          entityType,
         );
-      entityTableDto.operation_list = {
-        text: await this.listMasterService.getDropdownOptions(
-          'OPT',
-          {},
-          [],
-          loggedInUser,
-        ),
-        number: await this.listMasterService.getDropdownOptions(
-          'OPN',
-          {},
-          [],
-          loggedInUser,
-        ),
-        date: await this.listMasterService.getDropdownOptions(
-          'OPD',
-          {},
-          [],
-          loggedInUser,
-        ),
-        select: await this.listMasterService.getDropdownOptions(
-          'OPS',
-          {},
-          [],
-          loggedInUser,
-        ),
-        multiselect: await this.listMasterService.getDropdownOptions(
-          'OPM',
-          {},
-          [],
-          loggedInUser,
-        ),
-        year: await this.listMasterService.getDropdownOptions(
-          'OPY',
-          {},
-          [],
+    }
+    if (loggedInUser.id) {
+      entityTableDto.shared_filter =
+        await this.savedFilterRepoService.getSharedFiltersByLevelTypeAndLevelId(
           loggedInUser,
-        ),
-        // Add any other operations you want to include
-      };
-      entityTableDto.default_filter =
-        await this.savedFilterRepoService.getDefaultFilterByEntityType(
-          entityTable.list_type,
+          entityType,
         );
-      if (loggedInUser.id) {
-        entityTableDto.saved_filter =
-          await this.savedFilterRepoService.getSavedFiltersByUserIdAndEntityType(
-            loggedInUser,
-            entityTable.list_type,
-          );
-      }
-      if (loggedInUser.id) {
-        entityTableDto.shared_filter =
-          await this.savedFilterRepoService.getSharedFiltersByLevelTypeAndLevelId(
-            loggedInUser,
-            entityTable.list_type,
-          );
-      }
     }
 
     return entityTableDto;

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

@@ -2,7 +2,6 @@ import { UserData } from '../../user/entity/user.entity';
 import { BaseEntity } from '../entity/base-entity.entity';
 import { EntityListData } from '../dto/entity-list-data.dto';
 import { EntityManager } from 'typeorm';
-import { FilterRequestDto } from '../../filter/dto/filter-request.dto';
 
 export interface EntityService<T extends BaseEntity> {
   createEntity(

package/src/module/meta/service/resolver.service.ts

@@ -1,4 +1,4 @@
-import { Inject, Injectable } from '@nestjs/common';
+import { Inject, Injectable, forwardRef } from '@nestjs/common';
 import { UserData } from '../../user/entity/user.entity';
 import * as moment from 'moment';
 import { ListMasterService } from 'src/module/listmaster/service/list-master.service';
@@ -17,7 +17,9 @@ export class ResolverService {
     private readonly listMasterService: ListMasterService,
     private readonly moduleRef: ModuleRef,
     private readonly attributeMasterRepo: AttributeMasterRepository,
+    @Inject(forwardRef(() => ReflectionHelper))
     private readonly reflectionHelper: ReflectionHelper,
+    @Inject(forwardRef(() => EntityMasterRepository))
     private readonly entityMasterRepo: EntityMasterRepository,
     private readonly entityManger: EntityManager,
   ) {}
@@ -36,6 +38,7 @@ export class ResolverService {
     loggedInUser: any,
     entityData: any,
     entityType: string,
+    format_disable?: boolean,
   ): Promise<any> {
     const attributeItems =
       await this.attributeMasterRepo.findAttributesByMappedEntityType(
@@ -109,7 +112,7 @@ export class ResolverService {
       // -------- DATE / DATETIME --------
       else if (
         attr.element_type === 'date' ||
-        attr.element_type === 'datetime'
+        (attr.element_type === 'datetime' && !format_disable)
       ) {
         const dateFormat =
           attr.element_type === 'date' ? 'DD-MM-YYYY' : 'DD-MM-YYYY HH:mm:ss';
@@ -128,7 +131,8 @@ export class ResolverService {
       // --------UPLOAD / IMAGE --------
       else if (
         (attr.element_type === 'upload' || attr.element_type === 'image') &&
-        typeof resolvedEntityData[field] !== 'object'
+        typeof resolvedEntityData[field] !== 'object' &&
+        !format_disable
       ) {
         const mediaService = await this.getMediaDataService();
         const uploadData = await mediaService.getMediaDownloadUrl(

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

@@ -112,8 +112,7 @@ export class WorkflowAutomationService extends EntityServiceImpl {
           this.logger.debug(
             `Existing event filter found: ${workflow.condition_filter_code}`,
           );
-          const existing = await this.savedFilterService.getEntityDataByCode(
-            ENTITYTYPE_SAVEDFILTERMASTER,
+          const existing = await this.savedFilterService.getSavedFilterByCode(
             workflow.condition_filter_code,
             loggedInUser,
           );
@@ -259,8 +258,7 @@ export class WorkflowAutomationService extends EntityServiceImpl {
     if (workflowAutomation.trigger_type === 'on_event') {
       if (workflowAutomation.condition_filter_code) {
         const eventFilterMaster: any =
-          await this.savedFilterService.getEntityDataByCode(
-            ENTITYTYPE_SAVEDFILTERMASTER,
+          await this.savedFilterService.getSavedFilterByCode(
             workflowAutomation.condition_filter_code,
             loggedInUser,
           );