feat: Move report stats call to platform in dashboard

src/app/core/mock-data/report-stats.data.ts

@@ -3,45 +3,95 @@ import { ReportStats } from '../models/report-stats.model';
 export const expectedReportStats: ReportStats = {
   draft: {
     count: 6,
-    sum: 93165.91,
+    failed_amount: null,
+    failed_count: null,
+    processing_amount: null,
+    processing_count: null,
+    reimbursable_amount: null,
+    total_amount: 93165.91,
   },
   report: {
     count: 45,
-    sum: 5177243929.65219,
+    total_amount: 5177243929.65219,
+    failed_amount: null,
+    failed_count: null,
+    processing_amount: null,
+    processing_count: null,
+    reimbursable_amount: null,
   },
   approved: {
     count: 56,
-    sum: 28758273650702.816,
+    total_amount: 28758273650702.816,
+    failed_amount: null,
+    failed_count: null,
+    processing_amount: null,
+    processing_count: null,
+    reimbursable_amount: null,
   },
   paymentPending: {
     count: 4,
-    sum: 501602.12,
+    total_amount: 501602.12,
+    failed_amount: null,
+    failed_count: null,
+    processing_amount: null,
+    processing_count: null,
+    reimbursable_amount: null,
   },
   processing: {
     count: 7,
-    sum: 5012.12,
+    total_amount: 5012.12,
+    failed_amount: null,
+    failed_count: null,
+    processing_amount: null,
+    processing_count: null,
+    reimbursable_amount: null,
   },
 };
 
 export const expectedEmptyReportStats: ReportStats = {
   draft: {
-    sum: 0,
+    total_amount: 0,
     count: 0,
+    failed_amount: null,
+    failed_count: null,
+    processing_amount: null,
+    processing_count: null,
+    reimbursable_amount: null,
   },
   report: {
-    sum: 0,
+    total_amount: 0,
     count: 0,
+    failed_amount: null,
+    failed_count: null,
+    processing_amount: null,
+    processing_count: null,
+    reimbursable_amount: null,
   },
   approved: {
-    sum: 0,
+    total_amount: 0,
     count: 0,
+    failed_amount: null,
+    failed_count: null,
+    processing_amount: null,
+    processing_count: null,
+    reimbursable_amount: null,
   },
   paymentPending: {
-    sum: 0,
+    total_amount: 0,
     count: 0,
+    failed_amount: null,
+    failed_count: null,
+    processing_amount: null,
+    processing_count: null,
+    reimbursable_amount: null,
   },
   processing: {
-    sum: 0,
+    total_amount: 0,
     count: 0,
+    failed_amount: null,
+    failed_count: null,
+    processing_amount: null,
+    processing_count: null,
+    reimbursable_amount: null,
   },
 };

src/app/core/models/platform/v1/platform-stats-request-param.model.ts

@@ -0,0 +1,3 @@
+export interface PlatformStatsRequestParams {
+  state: string;
+}

src/app/core/models/platform/v1/report-stats-response.model.ts

@@ -0,0 +1,9 @@
+export interface ReportsStatsResponsePlatform {
+  count: number;
+  failed_amount: number;
+  failed_count: number;
+  processing_amount: number;
+  processing_count: number;
+  reimbursable_amount: number;
+  total_amount: number;
+}

src/app/core/models/platform/v1/reports-query-params.model.ts

@@ -3,4 +3,5 @@ export interface ReportsQueryParams {
   offset?: number;
   limit?: number;
   order?: string;
+  id?: string;
 }

src/app/core/models/report-stats.model.ts

@@ -1,9 +1,10 @@
-import { Stats } from './stats.model';
+import { ReportsStatsResponsePlatform } from './platform/v1/report-stats-response.model';
+import { StatsResponse } from './platform/v1/stats-response.model';
 
 export interface ReportStats {
-  draft: Stats;
-  report: Stats;
-  approved: Stats;
-  paymentPending: Stats;
-  processing: Stats;
+  draft: ReportsStatsResponsePlatform;
+  report: ReportsStatsResponsePlatform;
+  approved: ReportsStatsResponsePlatform;
+  paymentPending: ReportsStatsResponsePlatform;
+  processing: ReportsStatsResponsePlatform;
 }

src/app/core/services/platform/v1/approver/reports.service.spec.ts

@@ -2,19 +2,36 @@ import { TestBed } from '@angular/core/testing';
 import { ApproverReportsService } from './reports.service';
 import { ApproverPlatformApiService } from '../../../approver-platform-api.service';
 import { of } from 'rxjs';
+import { PAGINATION_SIZE } from 'src/app/constants';
+import {
+  allReportsPaginated1,
+  allReportsPaginated2,
+  expectedReportsPaginated,
+  expectedReportsSinglePage,
+  mockQueryParams,
+  platformReportCountData,
+} from 'src/app/core/mock-data/platform-report.data';
+import { ReportsQueryParams } from 'src/app/core/models/platform/v1/reports-query-params.model';
+import { StatsResponse } from 'src/app/core/models/platform/v1/stats-response.model';
+import { expectedReportStats } from 'src/app/core/mock-data/report-stats.data';
 
 describe('ApproverReportsService', () => {
   let approverReportsService: ApproverReportsService;
-  const approverPlatformApiService = jasmine.createSpyObj('ApproverPlatformApiService', ['post']);
+  let approverPlatformApiService: jasmine.SpyObj<ApproverPlatformApiService>;
 
   beforeEach(() => {
+    const approverPlatformApiServiceSpy = jasmine.createSpyObj('ApproverPlatformApiService', ['post', 'get']);
     TestBed.configureTestingModule({
       providers: [
         ApproverReportsService,
-        { provide: ApproverPlatformApiService, useValue: approverPlatformApiService },
+        { provide: PAGINATION_SIZE, useValue: 2 },
+        { provide: ApproverPlatformApiService, useValue: approverPlatformApiServiceSpy },
       ],
     });
     approverReportsService = TestBed.inject(ApproverReportsService);
+    approverPlatformApiService = TestBed.inject(
+      ApproverPlatformApiService
+    ) as jasmine.SpyObj<ApproverPlatformApiService>;
   });
 
   it('should be created', () => {
@@ -39,4 +56,124 @@ describe('ApproverReportsService', () => {
       done();
     });
   });
+
+  it('getReportsCount(): should get a count of reports', (done) => {
+    // Mock the response of getReportsByParams
+    spyOn(approverReportsService, 'getReportsByParams').and.returnValue(of(platformReportCountData));
+
+    const expectedParams: ReportsQueryParams = {
+      ...mockQueryParams,
+      limit: 1,
+      offset: 0,
+    };
+
+    approverReportsService.getReportsCount(mockQueryParams).subscribe((res) => {
+      // Verify
+      expect(res).toEqual(4); // Check if the count is as expected
+      expect(approverReportsService.getReportsByParams).toHaveBeenCalledWith(expectedParams); // Check if the method is called with the expected params
+      done(); // Call 'done' to indicate the end of the asynchronous test
+    });
+  });
+
+  it('getAllReportsByParams(): should get all reports multiple pages', (done) => {
+    const getReportsByParams = spyOn(approverReportsService, 'getReportsByParams');
+    spyOn(approverReportsService, 'getReportsCount').and.returnValue(of(4));
+
+    const expectedParams1: ReportsQueryParams = {
+      ...mockQueryParams,
+      limit: 2,
+      offset: 0,
+    };
+    const expectedParams2: ReportsQueryParams = {
+      ...mockQueryParams,
+      limit: 2,
+      offset: 2,
+    };
+
+    getReportsByParams.withArgs(expectedParams1).and.returnValue(of(allReportsPaginated1));
+    getReportsByParams.withArgs(expectedParams2).and.returnValue(of(allReportsPaginated2));
+
+    approverReportsService.getAllReportsByParams(mockQueryParams).subscribe((res) => {
+      expect(res).toEqual(expectedReportsPaginated);
+      expect(approverReportsService.getReportsCount).toHaveBeenCalledOnceWith({
+        state: 'in.(DRAFT,APPROVER_PENDING,APPROVER_INQUIRY)',
+      });
+      expect(getReportsByParams).toHaveBeenCalledWith(expectedParams1);
+      expect(getReportsByParams).toHaveBeenCalledWith(expectedParams2);
+      expect(getReportsByParams).toHaveBeenCalledTimes(2);
+      done();
+    });
+  });
+
+  it('getAllReportsByParams(): should get all reports single page', (done) => {
+    const getReportsByParams = spyOn(approverReportsService, 'getReportsByParams');
+    spyOn(approverReportsService, 'getReportsCount').and.returnValue(of(1));
+
+    const expectedParams: ReportsQueryParams = {
+      ...mockQueryParams,
+      offset: 0,
+      limit: 2,
+    };
+
+    getReportsByParams.withArgs(expectedParams).and.returnValue(of(allReportsPaginated1));
+
+    approverReportsService.getAllReportsByParams(mockQueryParams).subscribe((res) => {
+      expect(res).toEqual(expectedReportsSinglePage);
+      expect(approverReportsService.getReportsCount).toHaveBeenCalledOnceWith(mockQueryParams);
+      expect(getReportsByParams).toHaveBeenCalledOnceWith(expectedParams);
+      done();
+    });
+  });
+
+  it('should get reports with specified parameters', (done) => {
+    const queryParams = {
+      state: 'DRAFT',
+      offset: 0,
+      limit: 2,
+    };
+    const expectedConfig = {
+      params: {
+        ...queryParams,
+      },
+    };
+    approverPlatformApiService.get.and.returnValue(of(allReportsPaginated1));
+    approverReportsService.getReportsByParams(queryParams).subscribe((response) => {
+      expect(response).toEqual(allReportsPaginated1);
+      expect(approverPlatformApiService.get).toHaveBeenCalledOnceWith('/reports', expectedConfig);
+      done();
+    });
+  });
+
+  it('getReport(): should get a report by id', () => {
+    spyOn(approverReportsService, 'getReportsByParams').and.returnValue(of(allReportsPaginated1));
+    const queryParams = {
+      id: 'eq.rpvcIMRMyM3A',
+    };
+    approverReportsService.getReport('rpvcIMRMyM3A').subscribe((res) => {
+      console.log(res);
+      expect(approverReportsService.getReportsByParams).toHaveBeenCalledOnceWith(queryParams);
+    });
+  });
+
+  it('getReportsStats(): should get advance request stats', (done) => {
+    const statsResponse: StatsResponse = {
+      count: 2,
+      total_amount: 1200,
+    };
+    approverPlatformApiService.post.and.returnValue(of({ data: expectedReportStats.draft }));
+
+    const params = {
+      state: 'eq.DRAFT',
+    };
+
+    approverReportsService.getReportsStats(params).subscribe((res) => {
+      expect(res).toEqual(expectedReportStats.draft);
+      expect(approverPlatformApiService.post).toHaveBeenCalledOnceWith('/reports/stats', {
+        data: {
+          query_params: `state=${params.state}`,
+        },
+      });
+      done();
+    });
+  });
 });

src/app/core/services/platform/v1/approver/reports.service.ts

@@ -1,12 +1,72 @@
-import { Injectable } from '@angular/core';
-import { Observable } from 'rxjs';
+import { Inject, Injectable } from '@angular/core';
+import { Observable, concatMap, map, range, reduce, switchMap } from 'rxjs';
 import { ApproverPlatformApiService } from '../../../approver-platform-api.service';
+import { PlatformApiResponse } from 'src/app/core/models/platform/platform-api-response.model';
+import { ReportsQueryParams } from 'src/app/core/models/platform/v1/reports-query-params.model';
+import { PAGINATION_SIZE } from 'src/app/constants';
+import { Report } from 'src/app/core/models/platform/v1/report.model';
+import { PlatformStatsRequestParams } from 'src/app/core/models/platform/v1/platform-stats-request-param.model';
+import { StatsResponse } from 'src/app/core/models/platform/v1/stats-response.model';
+import { ReportsStatsResponsePlatform } from 'src/app/core/models/platform/v1/report-stats-response.model';
 
 @Injectable({
   providedIn: 'root',
 })
 export class ApproverReportsService {
-  constructor(private approverPlatformApiService: ApproverPlatformApiService) {}
+  constructor(
+    @Inject(PAGINATION_SIZE) private paginationSize: number,
+    private approverPlatformApiService: ApproverPlatformApiService
+  ) {}
+
+  getAllReportsByParams(queryParams: ReportsQueryParams): Observable<Report[]> {
+    return this.getReportsCount(queryParams).pipe(
+      switchMap((count) => {
+        count = count > this.paginationSize ? count / this.paginationSize : 1;
+        return range(0, count);
+      }),
+      concatMap((page) => {
+        let params = {
+          ...queryParams,
+          offset: this.paginationSize * page,
+          limit: this.paginationSize,
+        };
+        return this.getReportsByParams(params);
+      }),
+      reduce((acc, curr) => acc.concat(curr.data), [] as Report[])
+    );
+  }
+
+  getReportsCount(queryParams: ReportsQueryParams): Observable<number> {
+    let params = {
+      state: queryParams.state,
+      limit: 1,
+      offset: 0,
+    };
+    return this.getReportsByParams(params).pipe(map((res) => res.count));
+  }
+
+  getReportsByParams(queryParams: ReportsQueryParams = {}): Observable<PlatformApiResponse<Report>> {
+    const config = {
+      params: {
+        ...queryParams,
+      },
+    };
+    return this.approverPlatformApiService.get<PlatformApiResponse<Report>>('/reports', config);
+  }
+
+  getReportsStats(params: PlatformStatsRequestParams): Observable<ReportsStatsResponsePlatform> {
+    return this.approverPlatformApiService
+      .post<{ data: ReportsStatsResponsePlatform }>('/reports/stats', {
+        data: {
+          query_params: `state=${params.state}`,
+        },
+      })
+      .pipe(map((res) => res.data));
+  }
+
+  getReport(id: string): Observable<Report> {
+    return this.getReportsByParams({ id: `eq.${id}` }).pipe(map((res) => res.data[0]));
+  }
 
   ejectExpenses(rptId: string, expenseId: string, comment?: string[]): Observable<void> {
     const payload = {