rez_core 5.0.155 → 5.0.157

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,7 +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;
-  // saved_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,

package/src/module/workflow/service/action.service.ts

@@ -36,19 +36,23 @@ export class ActionService extends EntityServiceImpl {
     }
 
     let actionResourceMappingRepo = this.reflectionHelper.getRepoService('ActionResourcesMapping');
+    await actionResourceMappingRepo.find({
+      where: {},
+    });
 
     const result = await actionResourceMappingRepo
       .createQueryBuilder('arm')
-      .leftJoin(
-        'frm_wf_stage_action_mapping',
-        'sam',
-        'sam.id = arm.stg_act_mapping_id'
-      )
       .select([
         'arm.template_code AS template_code',
         'arm.form_id AS form_id',
       ])
-      .where('sam.action_id = :actionId', { actionId: actionData.id })
+      .where(`arm.stg_act_mapping_id IN (
+      SELECT sam.id 
+      FROM frm_wf_stage_action_mapping sam
+      WHERE sam.action_id = :actionId
+        AND sam.entity_type = 'WFSA'
+      )`)
+      .setParameter('actionId', actionData.id)
       .getRawMany();
 
     const templates = result

package/src/module/workflow/service/task.service.ts

@@ -154,13 +154,13 @@ export class TaskService extends EntityServiceImpl {
 
     const oldStatusRows = oldRow
       ? await listRepo.find({
-          where: {
-            id: oldRow.status,
-            organization_id: loggedInUser.organization_id,
-            listtype: 'TKST',
-          },
-          take: 1,
-        })
+        where: {
+          id: oldRow.status,
+          organization_id: loggedInUser.organization_id,
+          listtype: 'TKST',
+        },
+        take: 1,
+      })
       : [];
 
     const isStatusChanged =
@@ -284,9 +284,9 @@ export class TaskService extends EntityServiceImpl {
       .addSelect('sg.name', 'stage_group_name')
       .addSelect('s.name', 'stage_name')
       .addSelect('a.name', 'action_name')
-      .leftJoin('frm_wf_stage', 's', 't.stage_id::text = s.id::text')
-      .leftJoin('frm_wf_stage_group', 'sg', 's.stage_group_id = sg.id')
-      .leftJoin('frm_wf_action', 'a', 't.action_id::text = a.id::text')
+      .leftJoinAndSelect('frm_wf_stage', 's', 't.stage_id::text = s.id::text')
+      .leftJoinAndSelect('frm_wf_stage_group', 'sg', 's.stage_group_id = sg.id')
+      .leftJoinAndSelect('frm_wf_action', 'a', 't.action_id::text = a.id::text')
       .where('t.mapped_entity_type = :mapped_entity_type', {
         mapped_entity_type,
       })
@@ -309,8 +309,7 @@ export class TaskService extends EntityServiceImpl {
     }
 
     if (overdue) {
-      qb.andWhere(
-        `
+      qb.andWhere(`
       (
         t.due_date < CURRENT_DATE
         OR (
@@ -318,8 +317,8 @@ export class TaskService extends EntityServiceImpl {
           AND t.due_time::time < CURRENT_TIME
         )
       )
-    `,
-      ).andWhere('t.is_done = :is_done', { is_done: false });
+    `)
+        .andWhere('t.is_done = :is_done', { is_done: false });
     }
 
     qb.orderBy('t.created_date', 'DESC');

package/src/table.config.ts

@@ -3,6 +3,7 @@ import { WidgetMaster } from './module/dashboard/entity/widget_master.entity';
 import { EnterpriseData } from './module/enterprise/entity/enterprise.entity';
 import { OrganizationAppMapping } from './module/enterprise/entity/organization-app-mapping.entity';
 import { OrganizationData } from './module/enterprise/entity/organization.entity';
+import { EntityJson } from './module/entity_json/entity/entityJson.entity';
 import { SavedFilterDetail } from './module/filter/entity/saved-filter-detail.entity';
 import { SavedFilterMaster } from './module/filter/entity/saved-filter-master.entity';
 import { IntegrationConfig } from './module/integration/entity/integration-config.entity';
@@ -87,6 +88,7 @@ export const frameworkTables = [
   UserIntegration,
   ViewMaster,
   LinkedAttributes,
+  EntityJson
 ];
 
 export const workflowTables = [