rez_core 5.0.211 → 6.1.0

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/linked_attributes/controller/linked_attributes.controller.ts

@@ -7,10 +7,14 @@ import {
   Post,
   Req,
   UseGuards,
+  Query,
 } from '@nestjs/common';
+import { ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
 import { LinkedAttributesService } from '../service/linked_attributes.service';
 import { JwtAuthGuard } from 'src/module/auth/guards/jwt.guard';
+import { CreateLinkedAttributeSmartDto } from '../dto/create-linked-attribute-smart.dto';
 
+@ApiTags('Linked Attributes')
 @Controller('linked-attributes')
 export class LinkedAttributesController {
   constructor(
@@ -49,4 +53,85 @@ export class LinkedAttributesController {
       loggedInUser,
     );
   }
+
+  @Post('smart')
+  @UseGuards(JwtAuthGuard)
+  @ApiOperation({ summary: 'Create linked attribute with auto-generation' })
+  @ApiResponse({
+    status: 201,
+    description: 'Linked attribute created successfully',
+  })
+  @ApiResponse({ status: 400, description: 'Validation failed' })
+  async createSmart(
+    @Body() dto: CreateLinkedAttributeSmartDto,
+    @Req() req: any,
+  ) {
+    const loggedInUser = req.user?.userData;
+    return await this.linkedAttributesService.createLinkedAttributeSmart(
+      dto,
+      loggedInUser,
+    );
+  }
+
+  @Post(':id/backfill')
+  @UseGuards(JwtAuthGuard)
+  @ApiOperation({
+    summary: 'Backfill existing entities with new linked attribute',
+  })
+  @ApiResponse({ status: 200, description: 'Backfill completed' })
+  @ApiResponse({ status: 404, description: 'Linked attribute not found' })
+  async backfill(@Param('id') id: number, @Req() req: any) {
+    const loggedInUser = req.user?.userData;
+    return await this.linkedAttributesService.backfillLinkedAttribute(
+      id,
+      loggedInUser,
+    );
+  }
+
+  @Post('backfill-all')
+  @UseGuards(JwtAuthGuard)
+  @ApiOperation({ summary: 'Backfill all entities of a given type' })
+  @ApiResponse({ status: 200, description: 'Backfill completed' })
+  async backfillAll(
+    @Query('entity_type') entity_type: string,
+    @Req() req: any,
+  ) {
+    const loggedInUser = req.user?.userData;
+    return await this.linkedAttributesService.backfillAllForEntity(
+      entity_type,
+      loggedInUser,
+    );
+  }
+
+  @Get('preview-key')
+  @UseGuards(JwtAuthGuard)
+  @ApiOperation({
+    summary: 'Preview generated attribute key before creation',
+  })
+  @ApiResponse({ status: 200, description: 'Preview generated successfully' })
+  async previewKey(
+    @Query('mapped_entity_type') mapped_entity_type: string,
+    @Query('entity_type') entity_type: string,
+    @Query('attribute_key') attribute_key: string,
+    @Query('organization_id') organization_id: number,
+    @Req() req: any,
+  ) {
+    const loggedInUser = req.user?.userData;
+
+    const sequence =
+      await this.linkedAttributesService['generateNextSequence'](
+        mapped_entity_type,
+        entity_type,
+        attribute_key,
+        organization_id,
+      );
+
+    const generated_key = this.linkedAttributesService.generateAttributeKey(
+      entity_type,
+      attribute_key,
+      sequence,
+    );
+
+    return { generated_key, sequence };
+  }
 }

package/src/module/linked_attributes/dto/create-linked-attribute-smart.dto.ts

@@ -0,0 +1,54 @@
+import {
+  IsString,
+  IsNotEmpty,
+  IsArray,
+  IsOptional,
+  IsBoolean,
+  ValidateNested,
+} from 'class-validator';
+import { Type } from 'class-transformer';
+
+export class FilterConditionDto {
+  @IsString()
+  @IsNotEmpty()
+  filter_attribute: string;
+
+  @IsString()
+  @IsNotEmpty()
+  filter_operator: string;
+
+  @IsNotEmpty()
+  filter_value: any;
+}
+
+export class CreateLinkedAttributeSmartDto {
+  @IsString()
+  @IsNotEmpty()
+  field_name: string;
+
+  @IsString()
+  @IsNotEmpty()
+  mapped_entity_type: string;
+
+  @IsString()
+  @IsNotEmpty()
+  applicable_entity_type: string;
+
+  @IsString()
+  @IsNotEmpty()
+  applicable_attribute_key: string;
+
+  @IsString()
+  @IsNotEmpty()
+  saved_filter_code: string;
+
+  // @IsArray()
+  // @IsOptional()
+  // @ValidateNested({ each: true })
+  // @Type(() => FilterConditionDto)
+  // filter_conditions?: FilterConditionDto[];
+
+  @IsBoolean()
+  @IsOptional()
+  backfill?: boolean;
+}

package/src/module/linked_attributes/linked_attributes.module.ts

@@ -1,16 +1,18 @@
-import { Module } from '@nestjs/common';
+import { Module, forwardRef } from '@nestjs/common';
 import { EntityModule } from '../meta/entity.module';
+import { FilterModule } from '../filter/filter.module';
+import { EntityJSONModule } from '../entity_json/entity_json.module';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { LinkedAttributes } from './entity/linked_attribute.entity';
 import { LinkedAttributesController } from './controller/linked_attributes.controller';
 import { LinkedAttributesService } from './service/linked_attributes.service';
-import { FilterModule } from '../filter/filter.module';
 
 @Module({
   imports: [
     EntityModule,
+    forwardRef(() => FilterModule),
+    forwardRef(() => EntityJSONModule),
     TypeOrmModule.forFeature([LinkedAttributes]),
-    FilterModule,
   ],
   controllers: [LinkedAttributesController],
   providers: [