rez_core 6.5.23 → 6.5.25

package/src/module/filter/service/saved-filter.service.ts

@@ -1,4 +1,4 @@
-import { BadRequestException, Injectable } from '@nestjs/common';
+import { BadRequestException, Inject, Injectable, forwardRef } from '@nestjs/common';
 import { EntityServiceImpl } from 'src/module/meta/service/entity-service-impl.service';
 import { BaseEntity } from '../../meta/entity/base-entity.entity';
 import { UserData } from '../../user/entity/user.entity';
@@ -7,10 +7,12 @@ import { ENTITYTYPE_SAVEDFILTERMASTER } from 'src/constant/global.constant';
 import { SavedFilterRepositoryService } from '../repository/saved-filter.repository';
 
 @Injectable()
-export class SavedFilterService extends EntityServiceImpl {
-  constructor(private readonly savedFilterRepo: SavedFilterRepositoryService) {
-    super();
-  }
+export class SavedFilterService {
+  constructor(
+    private readonly savedFilterRepo: SavedFilterRepositoryService,
+    @Inject(forwardRef(() => EntityServiceImpl))
+    private readonly entityServiceImpl: EntityServiceImpl,
+  ) {}
 
   async createEntity(
     entityData: any,
@@ -33,7 +35,7 @@ export class SavedFilterService extends EntityServiceImpl {
     entityData.user_id = loggedInUser?.id ?? null;
 
     // Save the master record without code
-    const savedMaster = await super.createEntity(master, loggedInUser);
+    const savedMaster = await this.entityServiceImpl.createEntity(master, loggedInUser);
 
     // Generate the code like SFM00001 using the saved ID
     const code = `SFM${savedMaster.id.toString().padStart(5, '0')}`;
@@ -74,7 +76,7 @@ export class SavedFilterService extends EntityServiceImpl {
   ): Promise<BaseEntity> {
     const master = entityData as SavedFilterMaster;
 
-    const existing = await this.getEntityData(
+    const existing = await this.entityServiceImpl.getEntityData(
       ENTITYTYPE_SAVEDFILTERMASTER,
       master.id,
       loggedInUser,
@@ -96,7 +98,7 @@ export class SavedFilterService extends EntityServiceImpl {
     }
 
     const { filterDetails, ...persistableData } = master as any;
-    const updated = await super.updateEntity(persistableData, loggedInUser);
+    const updated = await this.entityServiceImpl.updateEntity(persistableData, loggedInUser);
 
     if (filterDetails?.length) {
       await this.savedFilterRepo.deleteDetailsByCode(updated.code);
@@ -120,34 +122,22 @@ export class SavedFilterService extends EntityServiceImpl {
   }
 
   async deleteEntity(entityType: string, entityId: number, loggedInUser) {
-    const entityMaster = await this.entityMasterService.getEntityData(
+    // First get the entity data to retrieve the code
+    const entityData = await this.entityServiceImpl.getEntityData(
       entityType,
+      entityId,
       loggedInUser,
     );
 
-    const repoService = this.reflectionHelper.getRepoService(
-      entityMaster.entity_data_class,
-    );
-    if (!repoService) {
-      throw new Error(
-        `Repository service not found for entityType: ${entityType}`,
-      );
-    }
-
-    const entityData = await repoService.findOne({ where: { id: entityId } });
-
     if (!entityData) {
       throw new Error(`Entity not found for entityType: ${entityType}`);
     }
 
+    // Delete associated filter details
     await this.savedFilterRepo.deleteDetailsByCode(entityData.code);
 
-    await repoService.delete(entityId);
-
-    return {
-      success: true,
-      message: `Entity with id ${entityId} deleted successfully.`,
-    };
+    // Then delete the entity itself
+    return await this.entityServiceImpl.deleteEntity(entityType, entityId, loggedInUser);
   }
 
   async getDetailsByCode(code: string) {

package/src/module/filter/test/flatjson-filter.service.spec.ts

@@ -0,0 +1,415 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { FlatjsonFilterService } from '../service/flatjson-filter.service';
+import { EntityManager } from 'typeorm';
+import { EntityMasterService } from 'src/module/meta/service/entity-master.service';
+import { AttributeMasterService } from 'src/module/meta/service/attribute-master.service';
+import { ResolverService } from 'src/module/meta/service/resolver.service';
+import { LoggingService } from 'src/utils/service/loggingUtil.service';
+import { ConfigService } from '@nestjs/config';
+import { SavedFilterRepositoryService } from '../repository/saved-filter.repository';
+
+describe('FlatjsonFilterService - Phase 2 Tests', () => {
+  let service: FlatjsonFilterService;
+
+  const mockEntityManager = {
+    getRepository: jest.fn(),
+  };
+
+  const mockEntityMasterService = {};
+  const mockAttributeMasterService = {
+    findAttributesByMappedEntityType: jest.fn(),
+  };
+  const mockResolverService = {
+    resolveEntitiesByIds: jest.fn(),
+  };
+  const mockLoggingService = {
+    log: jest.fn(),
+  };
+  const mockConfigService = {};
+  const mockSavedFilterRepositoryService = {
+    getDetailsByCode: jest.fn(),
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        FlatjsonFilterService,
+        { provide: EntityManager, useValue: mockEntityManager },
+        { provide: EntityMasterService, useValue: mockEntityMasterService },
+        {
+          provide: AttributeMasterService,
+          useValue: mockAttributeMasterService,
+        },
+        { provide: ResolverService, useValue: mockResolverService },
+        { provide: LoggingService, useValue: mockLoggingService },
+        { provide: ConfigService, useValue: mockConfigService },
+        {
+          provide: SavedFilterRepositoryService,
+          useValue: mockSavedFilterRepositoryService,
+        },
+      ],
+    }).compile();
+
+    service = module.get<FlatjsonFilterService>(FlatjsonFilterService);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('Task 2.3: Text Conditions', () => {
+    it('should build equal condition for text', () => {
+      const condition = service['buildTextCondition'](
+        'LEAD__name',
+        'equal',
+        'John',
+        'param1',
+      );
+
+      expect(condition).not.toBeNull();
+      expect(condition?.query).toContain("json_data->>'LEAD__name'");
+      expect(condition?.query).toContain('=');
+      expect(condition?.params.param1).toBe('john'); // lowercase
+    });
+
+    it('should build contains condition with LIKE', () => {
+      const condition = service['buildTextCondition'](
+        'LEAD__name',
+        'contains',
+        'John',
+        'param1',
+      );
+
+      expect(condition?.query).toContain('LIKE');
+      expect(condition?.params.param1).toBe('%john%');
+    });
+
+    it('should build starts_with condition', () => {
+      const condition = service['buildTextCondition'](
+        'LEAD__name',
+        'starts_with',
+        'John',
+        'param1',
+      );
+
+      expect(condition?.params.param1).toBe('john%');
+    });
+
+    it('should build ends_with condition', () => {
+      const condition = service['buildTextCondition'](
+        'LEAD__name',
+        'ends_with',
+        'Smith',
+        'param1',
+      );
+
+      expect(condition?.params.param1).toBe('%smith');
+    });
+
+    it('should build empty condition', () => {
+      const condition = service['buildTextCondition'](
+        'LEAD__name',
+        'empty',
+        null,
+        'param1',
+      );
+
+      expect(condition?.query).toContain('IS NULL');
+      expect(Object.keys(condition?.params || {})).toHaveLength(0);
+    });
+  });
+
+  describe('Task 2.4: Number Conditions', () => {
+    it('should build equal condition for numbers', () => {
+      const condition = service['buildNumberCondition'](
+        'LEAD__age',
+        'equal',
+        25,
+        'param1',
+      );
+
+      expect(condition?.query).toContain('::numeric');
+      expect(condition?.query).toContain('=');
+      expect(condition?.params.param1).toBe(25);
+    });
+
+    it('should build greater_than condition', () => {
+      const condition = service['buildNumberCondition'](
+        'LEAD__age',
+        'greater_than',
+        18,
+        'param1',
+      );
+
+      expect(condition?.query).toContain('>');
+      expect(condition?.params.param1).toBe(18);
+    });
+
+    it('should build between condition with array', () => {
+      const condition = service['buildNumberCondition'](
+        'LEAD__age',
+        'between',
+        [18, 65],
+        'param1',
+      );
+
+      expect(condition?.query).toContain('BETWEEN');
+      expect(condition?.params.param1_min).toBe(18);
+      expect(condition?.params.param1_max).toBe(65);
+    });
+
+    it('should build between condition with string', () => {
+      const condition = service['buildNumberCondition'](
+        'LEAD__age',
+        'between',
+        '18, 65',
+        'param1',
+      );
+
+      expect(condition?.query).toContain('BETWEEN');
+      expect(condition?.params.param1_min).toBe(18);
+      expect(condition?.params.param1_max).toBe(65);
+    });
+  });
+
+  describe('Task 2.5: Date Conditions', () => {
+    it('should build equal condition for dates', () => {
+      const condition = service['buildDateCondition'](
+        'LEAD__created_date',
+        'equal',
+        '2024-01-01',
+        'param1',
+      );
+
+      expect(condition?.query).toContain('::bigint');
+      expect(condition?.query).toContain('=');
+      expect(typeof condition?.params.param1).toBe('number');
+    });
+
+    it('should build before condition', () => {
+      const condition = service['buildDateCondition'](
+        'LEAD__created_date',
+        'before',
+        '2024-12-31',
+        'param1',
+      );
+
+      expect(condition?.query).toContain('<');
+    });
+
+    it('should build between condition for dates', () => {
+      const condition = service['buildDateCondition'](
+        'LEAD__created_date',
+        'between',
+        ['2024-01-01', '2024-12-31'],
+        'param1',
+      );
+
+      expect(condition?.query).toContain('BETWEEN');
+      expect(condition?.params.param1_start).toBeDefined();
+      expect(condition?.params.param1_end).toBeDefined();
+    });
+
+    it('should build today condition', () => {
+      const condition = service['buildDateCondition'](
+        'LEAD__created_date',
+        'today',
+        null,
+        'param1',
+      );
+
+      expect(condition?.query).toContain('BETWEEN');
+      expect(condition?.params.param1_start).toBeDefined();
+      expect(condition?.params.param1_end).toBeDefined();
+    });
+
+    it('should build in_last_day condition', () => {
+      const condition = service['buildDateCondition'](
+        'LEAD__created_date',
+        'in_last_day',
+        7,
+        'param1',
+      );
+
+      expect(condition?.query).toContain('BETWEEN');
+    });
+  });
+
+  describe('Task 2.6: Select/Multiselect Conditions', () => {
+    it('should build equal condition for select', () => {
+      const condition = service['buildSelectCondition'](
+        'LEAD__status',
+        'equal',
+        'NEW',
+        'param1',
+      );
+
+      expect(condition?.query).toContain("json_data->>'LEAD__status'");
+      expect(condition?.params.param1).toBe('NEW');
+    });
+
+    it('should build IN condition for array values', () => {
+      const condition = service['buildSelectCondition'](
+        'LEAD__status',
+        'equal',
+        ['NEW', 'ACTIVE'],
+        'param1',
+      );
+
+      expect(condition?.query).toContain('ANY');
+      expect(Array.isArray(condition?.params.param1)).toBe(true);
+    });
+
+    it('should build contains condition for multiselect', () => {
+      const condition = service['buildMultiSelectCondition'](
+        'LEAD__languages',
+        'contains',
+        'hindi',
+        'param1',
+      );
+
+      expect(condition?.query).toContain('?');
+      expect(condition?.params.param1).toBe('hindi');
+    });
+
+    it('should build contains_all condition', () => {
+      const condition = service['buildMultiSelectCondition'](
+        'LEAD__languages',
+        'contains_all',
+        ['hindi', 'english'],
+        'param1',
+      );
+
+      expect(condition?.query).toContain('?&');
+      expect(Array.isArray(condition?.params.param1)).toBe(true);
+    });
+
+    it('should build contains_any condition', () => {
+      const condition = service['buildMultiSelectCondition'](
+        'LEAD__languages',
+        'contains_any',
+        ['hindi', 'english'],
+        'param1',
+      );
+
+      expect(condition?.query).toContain('?|');
+    });
+
+    it('should handle comma-separated string input', () => {
+      const condition = service['buildMultiSelectCondition'](
+        'LEAD__languages',
+        'contains_any',
+        'hindi, english, tamil',
+        'param1',
+      );
+
+      expect(Array.isArray(condition?.params.param1)).toBe(true);
+      expect(condition?.params.param1).toHaveLength(3);
+    });
+  });
+
+  describe('Task 2.9: Sorting', () => {
+    it('should apply numeric sorting for number fields', () => {
+      const mockQb = {
+        orderBy: jest.fn().mockReturnThis(),
+        addOrderBy: jest.fn().mockReturnThis(),
+      };
+
+      const attributeMetaMap = {
+        age: {
+          data_type: 'number',
+          flat_json_key: 'LEAD__age',
+          mapped_entity_type: 'LEAD',
+        },
+      };
+
+      const sortby = [{ sortColum: 'age', sortType: 'DESC' }];
+
+      service['applyJsonbSorting'](mockQb as any, sortby, attributeMetaMap);
+
+      expect(mockQb.orderBy).toHaveBeenCalled();
+      const call = mockQb.orderBy.mock.calls[0];
+      expect(call[0]).toContain('::numeric');
+      expect(call[1]).toBe('DESC');
+    });
+
+    it('should apply bigint sorting for date fields', () => {
+      const mockQb = {
+        orderBy: jest.fn().mockReturnThis(),
+      };
+
+      const attributeMetaMap = {
+        created_date: {
+          data_type: 'date',
+          flat_json_key: 'LEAD__created_date',
+          mapped_entity_type: 'LEAD',
+        },
+      };
+
+      const sortby = [{ sortColum: 'created_date', sortType: 'ASC' }];
+
+      service['applyJsonbSorting'](mockQb as any, sortby, attributeMetaMap);
+
+      const call = mockQb.orderBy.mock.calls[0];
+      expect(call[0]).toContain('::bigint');
+    });
+
+    it('should apply text sorting for text fields', () => {
+      const mockQb = {
+        orderBy: jest.fn().mockReturnThis(),
+      };
+
+      const attributeMetaMap = {
+        name: {
+          data_type: 'text',
+          flat_json_key: 'LEAD__name',
+          mapped_entity_type: 'LEAD',
+        },
+      };
+
+      const sortby = [{ sortColum: 'name', sortType: 'ASC' }];
+
+      service['applyJsonbSorting'](mockQb as any, sortby, attributeMetaMap);
+
+      const call = mockQb.orderBy.mock.calls[0];
+      expect(call[0]).not.toContain('::');
+      expect(call[0]).toContain("->>"); // Text extraction
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle NULL values in text conditions', () => {
+      const condition = service['buildTextCondition'](
+        'LEAD__name',
+        'equal',
+        null,
+        'param1',
+      );
+
+      expect(condition).not.toBeNull();
+      expect(condition?.params.param1).toBe('');
+    });
+
+    it('should return null for unsupported operators', () => {
+      const condition = service['buildTextCondition'](
+        'LEAD__name',
+        'invalid_operator',
+        'test',
+        'param1',
+      );
+
+      expect(condition).toBeNull();
+    });
+
+    it('should handle empty array in multiselect', () => {
+      const condition = service['buildMultiSelectCondition'](
+        'LEAD__languages',
+        'contains',
+        [],
+        'param1',
+      );
+
+      expect(condition?.query).toBe('1=1'); // Always true
+    });
+  });
+});

package/src/module/integration/service/integration.service.ts

@@ -58,6 +58,7 @@ export interface GenericMessageDto {
   entity_type?: string;
   entity_id?: number;
   organization_id?: number;
+  enterprise_id?: number;
   mapped_entities?: any;
 }
 
@@ -99,7 +100,7 @@ export class IntegrationService {
     @Inject('FieldMapperService')
     private readonly fieldMapperService: FieldMapperService,
     private readonly entityService: EntityServiceImpl,
-    private readonly reflectionHelper:ReflectionHelper,
+    private readonly reflectionHelper: ReflectionHelper,
     @Inject(forwardRef(() => IntegrationQueueService))
     private readonly queueService?: IntegrationQueueService,
   ) {}
@@ -219,7 +220,8 @@ export class IntegrationService {
     integration_type?: string,
   ): Promise<any[]> {
     try {
-      const integrationSourceRepo = this.reflectionHelper.getRepoService('IntegrationSource')
+      const integrationSourceRepo =
+        this.reflectionHelper.getRepoService('IntegrationSource');
 
       const allIntegrationData = await integrationSourceRepo.find();
 
@@ -892,6 +894,7 @@ export class IntegrationService {
         entity_id,
         entity_type,
         organization_id,
+        enterprise_id,
         mapped_entities,
       } = messageDto;
 
@@ -936,6 +939,7 @@ export class IntegrationService {
       const loggedInUser = {
         id: user_id || null,
         organization_id: organization_id || -1,
+        enterprise_id: enterprise_id || -1,
         level_id: levelId,
         level_type: levelType,
         app_code: app_code,

package/src/module/integration/service/wrapper.service.ts

@@ -397,6 +397,7 @@ export class WrapperService {
         attachments: entity.attachments,
         mediaUrl: entity.mediaUrl,
         organization_id: organization_id,
+        enterprise_id: loggedInUser.enterprise_id,
       } as any;
 
       this.loggingService.log(

package/src/module/layout/controller/layout.controller.ts

@@ -18,13 +18,20 @@ import { ENTITYTYPE_USER } from '../../../constant/global.constant';
 export class LayoutController {
   constructor(
     private readonly headerSectionService: HeaderSectionService,
+    @Inject('UserService') private readonly userService: UserService,
   ) {}
 
   @Get('header')
   async getHeader(@Req() req: Request & { user: any }, @Res() res: Response) {
     const userData = req.user.userData;
+    // const userData = await this.userService.getEntityData(
+    //   ENTITYTYPE_USER,
+    //   userId,
+    // );
     if (userData) {
-      const response = await this.headerSectionService.getHeader();
+      const response = await this.headerSectionService.findByOrganizationId(
+        userData.organization_id,
+      );
       return res.json({
         success: true,
         data: response,

package/src/module/layout/entity/header-section.entity.ts

@@ -5,6 +5,12 @@ export class HeaderSection {
   @PrimaryGeneratedColumn()
   id: number;
 
+  @Column({ name: 'enterprise_id', type: 'int', nullable: true })
+  enterprise_id: number;
+
+  @Column({ nullable: true, type: 'int' })
+  organization_id: number;
+
   @Column({ length: 50, type: 'varchar', nullable: true })
   section_name: string;
 

package/src/module/layout/layout.module.ts

@@ -9,7 +9,7 @@ import { UserModule } from '../user/user.module';
 import { HeaderSectionService } from './service/header-section.service';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([HeaderSection, HeaderItems])],
+  imports: [TypeOrmModule.forFeature([HeaderSection, HeaderItems]), UserModule],
   controllers: [LayoutController],
   providers: [
     HeaderItemsRepository,

package/src/module/layout/repository/header-section.repository.ts

@@ -10,6 +10,12 @@ export class HeaderSectionRepository {
     private readonly headerSectionRepository: Repository<HeaderSection>,
   ) {}
 
+  async findByOrganizationId(organizationId: number) {
+    return await this.headerSectionRepository.find({
+      where: { organization_id: organizationId },
+    });
+  }
+
   async getHeaders() {
     return await this.headerSectionRepository.find();
   }

package/src/module/layout/service/header-section.service.ts

@@ -9,7 +9,7 @@ export class HeaderSectionService {
     private readonly headerItemsRepository: HeaderItemsRepository,
   ) {}
 
-  async getHeader() {
+  async findByOrganizationId(organizationId: number) {
     const headerSections = await this.headerSectionRepository.getHeaders();
     const response = {};