rez_core 5.0.145 → 5.0.150

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/wrapper.service.ts

@@ -3,8 +3,6 @@ import { GenericMessageDto, IntegrationService } from './integration.service';
 import { IcsMeetingService } from 'src/module/ics/service/ics.service';
 import { LoggingService } from 'src/utils/service/loggingUtil.service';
 import { ReflectionHelper } from '../../../utils/service/reflection-helper.service';
-import { MediaDataService } from 'src/module/meta/service/media-data.service';
-import axios from 'axios';
 
 @Injectable()
 export class WrapperService {
@@ -15,7 +13,6 @@ export class WrapperService {
     private readonly icsService: IcsMeetingService,
     private readonly loggingService: LoggingService,
     private readonly reflectionHelper: ReflectionHelper,
-    private readonly mediaService: MediaDataService,
   ) {}
 
   /**
@@ -408,40 +405,6 @@ export class WrapperService {
         [],
       );
 
-      // attachments: [1, 2, 3, 4]
-
-      if (entity.attachments && entity.attachments.length > 0) {
-        mailPayload.attachments = [];
-
-        for (const attachmentId of entity.attachments) {
-          // Step 1: Download or get media file
-          const url = await this.mediaService.getMediaDownloadUrl(
-            attachmentId,
-            {},
-            60000,
-          );
-
-          if (!url?.signedUrl) continue;
-
-          // Step 2: Fetch file content
-          const response = await axios.get(url.signedUrl, {
-            responseType: 'arraybuffer',
-          });
-
-          // Step 3: Convert to base64
-          const base64Content = Buffer.from(response.data).toString('base64');
-
-          // Step 4: Push formatted attachment
-          mailPayload.attachments.push({
-            content: base64Content,
-            type:
-              response.headers['content-type'] || 'application/octet-stream',
-            filename: `attachment-${attachmentId}`,
-            disposition: 'attachment',
-          });
-        }
-      }
-
       // Step 5️⃣ Send via Integration Service
       const result =
         await this.integrationService.sendGenericMessage(mailPayload);

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

@@ -6,10 +6,15 @@ import {
   Post,
   Req,
   UseGuards,
+  Param,
+  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(
@@ -34,4 +39,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,12 +1,19 @@
-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';
 
 @Module({
-  imports: [EntityModule, TypeOrmModule.forFeature([LinkedAttributes])],
+  imports: [
+    EntityModule,
+    forwardRef(() => FilterModule),
+    forwardRef(() => EntityJSONModule),
+    TypeOrmModule.forFeature([LinkedAttributes]),
+  ],
   controllers: [LinkedAttributesController],
   providers: [
     { provide: 'LinkedAttributesService', useClass: LinkedAttributesService },