rez_core 5.0.145 → 5.0.150

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/dto/entity-table.dto.ts

@@ -6,6 +6,5 @@ export class EntityTableDto extends EntityTable {
   operation_list: {};
   default_filter: {} | null;
   saved_filter: { label: string; value: number }[] | null;
-  // shared_filter: { label: string; value: number }[] | null;
-  shared_filter: any[] | null;
+  shared_filter: { label: string; value: number }[] | null;
 }

package/src/module/meta/service/media-data.service.ts

@@ -129,17 +129,6 @@ export class MediaDataService extends EntityServiceImpl {
       jpg: 'image/jpeg',
       jpeg: 'image/jpeg',
       png: 'image/png',
-      gif: 'image/gif',
-      webp: 'image/webp',
-      txt: 'text/plain',
-      html: 'text/html',
-      htm: 'text/html',
-      doc: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-      docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-      xls: 'application/vnd.ms-excel',
-      xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-      ppt: 'application/vnd.ms-powerpoint',
-      pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
     };
     return map[ext] || 'application/octet-stream';
   }
@@ -182,6 +171,7 @@ export class MediaDataService extends EntityServiceImpl {
     }
   }
 
+  // media-data.service.ts
   async getMediaInlineUrl(id: number, loggedInUser, expiresIn?: number) {
     try {
       const entityData = await this.getEntityData(
@@ -191,13 +181,6 @@ export class MediaDataService extends EntityServiceImpl {
       );
       const mediaData = entityData as MediaData;
       let fileSize: number | undefined;
-
-      if (!mediaData) {
-        throw new Error('Media not found');
-      }
-
-      const ext = mediaData.file_name.split('.').pop()?.toLowerCase() || '';
-
       if (this.bucketName) {
         const head = await this.s3
           .headObject({
@@ -208,23 +191,22 @@ export class MediaDataService extends EntityServiceImpl {
         fileSize = head.ContentLength;
       }
 
+      if (!mediaData) {
+        throw new Error('Media not found');
+      }
+
       const signedUrl = await this.s3.getSignedUrlPromise('getObject', {
         Bucket: this.bucketName,
         Key: mediaData.media_url,
         Expires: Number(expiresIn) || 60 * 5,
         ResponseContentDisposition: 'inline',
-        ResponseContentType: this.getContentType(ext),
+        ResponseContentType: this.getContentType(
+          mediaData.file_name.split('.').pop() || '',
+        ),
       });
 
-      let previewUrl = signedUrl;
-      // if (ext === 'doc' || ext === 'docx') {
-      //   previewUrl =
-      //     `https://view.officeapps.live.com/op/embed.aspx?src=` +
-      //     encodeURIComponent(signedUrl);
-      // }
-
       return {
-        signedUrl: previewUrl,
+        signedUrl,
         fileName: mediaData.file_name,
         id: mediaData.id,
         size: fileSize,