fix: Remove some duplicate code in file and util service (#4087)

Author: arjunaj5

src/app/core/constants.ts

@@ -1 +1 @@
-export const MAX_FILE_SIZE = 11 * 1024 * 1024;
+export const MAX_FILE_SIZE = 11 * 1024 * 1024; // 11MB

src/app/core/models/receipt-detail.model.ts

@@ -1,5 +1,4 @@
 export type ReceiptDetail = {
   dataUrl: string;
   type: string;
-  actionSource: string;
 };

src/app/core/services/file.service.spec.ts

@@ -93,6 +93,7 @@ describe('FileService', () => {
       expect(res.content).toBe('dGVzdCBjb250ZW50');
       expect(spenderFileService.generateUrlsBulk).toHaveBeenCalledOnceWith([fileId]);
       expect(globalThis.fetch).toHaveBeenCalledOnceWith(mockDownloadUrl);
+      expect(fileService.getDataUrlFromBlob).toHaveBeenCalledOnceWith(mockBlob);
       done();
     });
   });
@@ -422,65 +423,52 @@ describe('FileService', () => {
       const mockBlob = new Blob(['test content'], { type: 'image/jpeg' });
       const mockDataUrl = 'data:image/jpeg;base64,dGVzdCBjb250ZW50';
 
-      // Mock the FileReader to work properly
-      const mockFileReader = {
-        readAsDataURL: jasmine.createSpy('readAsDataURL'),
-        result: mockDataUrl,
-        onload: null as any,
-        onerror: null as any,
-      };
-
-      spyOn(window, 'FileReader').and.returnValue(mockFileReader as any);
       spyOn(fileService, 'getDataUrlFromBlob').and.resolveTo(mockDataUrl);
 
-      const resultPromise = fileService.readFile(mockBlob);
-
-      // Simulate the FileReader success
-      mockFileReader.onload();
+      const result = await fileService.readFile(mockBlob);
 
-      const result = await resultPromise;
       expect(result).toBe(mockDataUrl);
-      expect(mockFileReader.readAsDataURL).toHaveBeenCalledWith(mockBlob);
+      expect(fileService.getDataUrlFromBlob).toHaveBeenCalledWith(mockBlob);
     });
 
-    it('should read a HEIC file and convert to JPEG', async () => {
-      const mockHeicBlob = new Blob(['heic content'], { type: 'image/heic' });
+    it('should reject when getDataUrlFromBlob fails', async () => {
+      const mockBlob = new Blob(['test content'], { type: 'text/plain' });
+      const mockError = new Error('Read error');
 
-      // Since heic2any is an external library that's hard to mock in tests,
-      // let's test the method structure and behavior without triggering the actual conversion
-      // We'll verify that the method exists and can handle HEIC files
+      spyOn(fileService, 'getDataUrlFromBlob').and.rejectWith(mockError);
 
-      // Mock the getDataUrlFromBlob method to avoid the actual conversion
+      await expectAsync(fileService.readFile(mockBlob)).toBeRejectedWith(mockError);
+      expect(fileService.getDataUrlFromBlob).toHaveBeenCalledWith(mockBlob);
+    });
+
+    it('should read a HEIC file and return data URL via heic2any and getDataUrlFromBlob', async () => {
+      const mockHeicBlob = new Blob(['heic content'], { type: 'image/heic' });
+      const mockJpegBlob = new Blob(['jpeg content'], { type: 'image/jpeg' });
       const mockDataUrl = 'data:image/jpeg;base64,Y29udmVydGVkIGNvbnRlbnQ=';
+
+      spyOn(fileService as any, 'heic2any').and.resolveTo(mockJpegBlob);
       spyOn(fileService, 'getDataUrlFromBlob').and.resolveTo(mockDataUrl);
 
-      // Test that the method exists and is callable
-      expect(typeof fileService.readFile).toBe('function');
+      const result = await fileService.readFile(mockHeicBlob);
 
-      // The actual heic2any call will fail in tests due to missing native libraries,
-      // but we can verify the method structure and that it's designed to handle HEIC files
-      expect(mockHeicBlob.type).toBe('image/heic');
+      expect(result).toBe(mockDataUrl);
+      expect((fileService as any).heic2any).toHaveBeenCalledWith({
+        blob: mockHeicBlob,
+        toType: 'image/jpeg',
+        quality: 50,
+      });
+      expect(fileService.getDataUrlFromBlob).toHaveBeenCalledWith(mockJpegBlob);
     });
 
-    it('should handle FileReader errors', async () => {
-      const mockBlob = new Blob(['test content'], { type: 'text/plain' });
-      const mockError = new Error('FileReader error');
-
-      // Create a mock FileReader that will trigger the error
-      const mockFileReader = {
-        readAsDataURL: jasmine.createSpy('readAsDataURL'),
-        onload: null as any,
-        onerror: null as any,
-      };
-
-      spyOn(window, 'FileReader').and.returnValue(mockFileReader as any);
-
-      const resultPromise = fileService.readFile(mockBlob);
+    it('should reject when heic2any fails for HEIC image', async () => {
+      const mockHeicBlob = new Blob(['heic content'], { type: 'image/heic' });
+      const heicError = new Error('HEIC conversion failed');
 
-      // Simulate the error
-      mockFileReader.onerror(mockError);
+      spyOn(fileService as any, 'heic2any').and.rejectWith(heicError);
+      spyOn(fileService, 'getDataUrlFromBlob');
 
-      await expectAsync(resultPromise).toBeRejectedWith(mockError);
+      await expectAsync(fileService.readFile(mockHeicBlob)).toBeRejectedWith(heicError);
+      expect(fileService.getDataUrlFromBlob).not.toHaveBeenCalled();
     });
   });
 });

src/app/core/services/file.service.ts

@@ -23,6 +23,8 @@ export class FileService {
 
   private approverService = inject(ApproverService);
 
+  private heic2any = heic2any;
+
   private findByAdvanceRequestIdWithService(
     advanceRequestId: string,
     service: SpenderService | ApproverService,
@@ -177,26 +179,14 @@ export class FileService {
   readFile(file: Blob): Promise<string> {
     return new Promise((resolve, reject) => {
       if (file.type === 'image/heic') {
-        heic2any({
+        this.heic2any({
           blob: file,
           toType: 'image/jpeg',
           quality: 50,
         })
-          .then((result) => {
-            this.getDataUrlFromBlob(result as Blob).then((dataUrl) => {
-              resolve(dataUrl);
-            });
-          })
-          .catch((err) => {
-            reject(err);
-          });
+          .then((result: Blob) => this.getDataUrlFromBlob(result)).then(resolve).catch(reject);
       } else {
-        const fileReader = new FileReader();
-        fileReader.onload = async (): Promise<void> => {
-          return resolve(fileReader.result.toString());
-        };
-        fileReader.readAsDataURL(file);
-        fileReader.onerror = (error): void => reject(error);
+        this.getDataUrlFromBlob(file).then(resolve).catch(reject);
       }
     });
   }

src/app/core/services/utility.service.spec.ts

@@ -15,7 +15,8 @@ import { cloneDeep } from 'lodash';
 import { TokenService } from './token.service';
 import { AuthService } from './auth.service';
 import { FeatureConfigService } from './platform/v1/spender/feature-config.service';
-import { BehaviorSubject, of, throwError } from 'rxjs';
+import { FileService } from './file.service';
+import { BehaviorSubject, of } from 'rxjs';
 import { apiEouRes } from '../mock-data/extended-org-user.data';
 import { featureConfigOptInData } from '../mock-data/feature-config.data';
 import { txnCustomPropertiesData } from '../mock-data/txn-custom-properties.data';
@@ -26,11 +27,13 @@ describe('UtilityService', () => {
   let tokenService: jasmine.SpyObj<TokenService>;
   let authService: jasmine.SpyObj<AuthService>;
   let featureConfigService: jasmine.SpyObj<FeatureConfigService>;
+  let fileService: jasmine.SpyObj<FileService>;
 
   beforeEach(() => {
     const tokenServiceSpy = jasmine.createSpyObj('TokenService', ['getClusterDomain']);
     const authServiceSpy = jasmine.createSpyObj('AuthService', ['getEou']);
     const featureConfigServiceSpy = jasmine.createSpyObj('FeatureConfigService', ['getConfiguration']);
+    const fileServiceSpy = jasmine.createSpyObj('FileService', ['getDataUrlFromBlob']);
 
     TestBed.configureTestingModule({
       providers: [
@@ -47,12 +50,17 @@ describe('UtilityService', () => {
           provide: FeatureConfigService,
           useValue: featureConfigServiceSpy,
         },
+        {
+          provide: FileService,
+          useValue: fileServiceSpy,
+        },
       ],
     });
     utilityService = TestBed.inject(UtilityService);
     tokenService = TestBed.inject(TokenService) as jasmine.SpyObj<TokenService>;
     authService = TestBed.inject(AuthService) as jasmine.SpyObj<AuthService>;
     featureConfigService = TestBed.inject(FeatureConfigService) as jasmine.SpyObj<FeatureConfigService>;
+    fileService = TestBed.inject(FileService) as jasmine.SpyObj<FileService>;
   });
 
   it('should be created', () => {
@@ -610,16 +618,18 @@ describe('UtilityService', () => {
   describe('webPathToBase64():', () => {
     it('should convert webPath to base64 string', async () => {
       const mockBlob = new Blob(['test content'], { type: 'image/png' });
+      const mockDataUrl = 'data:image/png;base64,dGVzdCBjb250ZW50';
       spyOn(window, 'fetch').and.resolveTo({
         blob: () => Promise.resolve(mockBlob),
         ok: true,
       } as Response);
+      fileService.getDataUrlFromBlob.and.resolveTo(mockDataUrl);
 
       const result = await utilityService.webPathToBase64('https://example.com/image.png');
 
-      expect(result).toContain('data:');
-      expect(result).toContain('base64,');
+      expect(result).toBe(mockDataUrl);
       expect(window.fetch).toHaveBeenCalledWith('https://example.com/image.png');
+      expect(fileService.getDataUrlFromBlob).toHaveBeenCalledWith(mockBlob);
     });
 
     it('should reject on fetch error', async () => {
@@ -629,34 +639,16 @@ describe('UtilityService', () => {
       await expectAsync(utilityService.webPathToBase64('https://example.com/image.png')).toBeRejectedWith(error);
     });
 
-    it('should reject on FileReader error', async () => {
+    it('should reject when getDataUrlFromBlob fails', async () => {
       const mockBlob = new Blob(['test'], { type: 'image/png' });
+      const readError = new Error('Read error');
       spyOn(window, 'fetch').and.resolveTo({
         blob: () => Promise.resolve(mockBlob),
         ok: true,
       } as Response);
+      fileService.getDataUrlFromBlob.and.rejectWith(readError);
 
-      // Mock FileReader to simulate error
-      const originalFileReader = window.FileReader;
-      const mockFileReader = jasmine.createSpy('FileReader').and.returnValue({
-        readAsDataURL: function (blob: Blob) {
-          setTimeout(() => {
-            if (this.onerror) {
-              this.onerror(new Error('Read error') as unknown as ProgressEvent);
-            }
-          }, 0);
-        },
-      } as unknown as FileReader);
-      (window as unknown as { FileReader: typeof FileReader }).FileReader = mockFileReader as unknown as typeof FileReader;
-
-      try {
-        await utilityService.webPathToBase64('https://example.com/image.png');
-        fail('Should have thrown an error');
-      } catch (error) {
-        expect(error).toBeDefined();
-      } finally {
-        (window as unknown as { FileReader: typeof FileReader }).FileReader = originalFileReader;
-      }
+      await expectAsync(utilityService.webPathToBase64('https://example.com/image.png')).toBeRejectedWith(readError);
     });
   });
 

src/app/core/services/utility.service.ts

@@ -252,7 +252,6 @@ export function TestCases4(getTestBed) {
         expect(component.attachReceipts).toHaveBeenCalledOnceWith({
           type: file.type,
           dataUrl: 'base',
-          actionSource: 'gallery_upload',
         });
       }));
 
@@ -360,7 +359,6 @@ export function TestCases4(getTestBed) {
         expect(component.attachReceipts).toHaveBeenCalledOnceWith({
           dataUrl: 'data-url',
           type: 'png',
-          actionSource: 'camera',
         });
         expect(component.showSnackBarToast).toHaveBeenCalledOnceWith(
           { message: 'Receipt added to expense successfully' },

src/app/fyle/add-edit-expense/add-edit-expense-4.spec.ts

@@ -4924,7 +4924,7 @@ export class AddEditExpensePage implements OnInit {
       });
   }
 
-  attachReceipts(data: { type: string; dataUrl: string | ArrayBuffer; actionSource?: string }): void {
+  attachReceipts(data: { type: string; dataUrl: string | ArrayBuffer }): void {
     if (data) {
       const fileInfo = {
         type: data.type,
@@ -5033,7 +5033,7 @@ export class AddEditExpensePage implements OnInit {
   }
 
   async uploadFileCallback(file: File): Promise<void> {
-    let fileData: { type: string; dataUrl: string | ArrayBuffer; actionSource: string };
+    let fileData: { type: string; dataUrl: string | ArrayBuffer };
     if (file) {
       if (file.size < MAX_FILE_SIZE) {
         const fileRead$ = from(this.fileService.readFile(file));
@@ -5049,7 +5049,6 @@ export class AddEditExpensePage implements OnInit {
               fileData = {
                 type: file.type,
                 dataUrl,
-                actionSource: 'gallery_upload',
               };
               this.attachReceipts(fileData);
               this.trackingService.addAttachment({ type: file.type });
@@ -5095,7 +5094,6 @@ export class AddEditExpensePage implements OnInit {
           option?: string;
           type: string;
           dataUrl: string;
-          actionSource?: string;
         };
       };
 
@@ -5124,7 +5122,6 @@ export class AddEditExpensePage implements OnInit {
           receiptDetails = {
             type: this.fileService.getImageTypeFromDataUrl(data.dataUrl),
             dataUrl: data.dataUrl,
-            actionSource: 'camera',
           };
         }
       }