Merge pull request #96 from catenax-ng/TRACEFOSS-582-investigation-mock-update

TRACEFOSS-582 - prepare investigation mock for feature implementation

Author: fbedarf

src/app/mocks/services/investigations-mock/investigations.handler.ts

@@ -18,28 +18,29 @@
  ********************************************************************************/
 
 import { environment } from '@env';
+import { InvestigationStatus } from '@shared/model/investigations.model';
 import { rest } from 'msw';
 import { applyPagination, extractPagination } from '../pagination.helper';
-import { buildMockInvestigations } from './investigations.model';
+import { buildMockInvestigations, getInvestigationById, InvestigationIdPrefix } from './investigations.model';
 
 export const investigationsHandlers = [
-  rest.get(`${environment.apiUrl}/investigations/received`, (req, res, ctx) => {
+  rest.get(`${environment.apiUrl}/investigations`, (req, res, ctx) => {
     const pagination = extractPagination(req);
-    return res(ctx.status(200), ctx.json(applyPagination(buildMockInvestigations(['received']), pagination)));
-  }),
+    const status = req.url.searchParams.get('status') ?? '';
 
-  rest.get(`${environment.apiUrl}/investigations/queued-and-requested`, (req, res, ctx) => {
-    const pagination = extractPagination(req);
-    return res(
-      ctx.status(200),
-      ctx.json(applyPagination(buildMockInvestigations(['requested', 'queued']), pagination)),
-    );
+    const currentStatus = status.split(',') as InvestigationStatus[];
+    return res(ctx.status(200), ctx.json(applyPagination(buildMockInvestigations(currentStatus), pagination)));
   }),
 
   rest.post(`${environment.apiUrl}/investigations`, (_, res, ctx) => {
-    const investigations = buildMockInvestigations(['queued']);
+    return res(ctx.status(200), ctx.json({ id: InvestigationIdPrefix + 1 }));
+  }),
+
+  rest.put(`${environment.apiUrl}/investigations/:investigationId/status`, (req, res, ctx) => {
+    const { investigationId } = req.params;
+    const { status } = req.body as Record<string, unknown>;
 
-    const response = { investigationId: investigations[0].id };
-    return res(ctx.status(200), ctx.json(response));
+    const investigation = getInvestigationById(investigationId as string);
+    return res(ctx.status(200), ctx.json({ ...investigation, status }));
   }),
 ];

src/app/mocks/services/investigations-mock/investigations.model.ts

@@ -18,14 +18,32 @@
  ********************************************************************************/
 
 import type { InvestigationResponse } from '@shared/model/investigations.model';
+import { InvestigationStatus } from '@shared/model/investigations.model';
+import { getRandomAsset } from '../parts-mock/parts.model';
 
-export const buildMockInvestigations = (statuses: string[]): InvestigationResponse[] =>
+export const InvestigationIdPrefix = 'id-';
+export const buildMockInvestigations = (statuses: InvestigationStatus[]): InvestigationResponse[] =>
   new Array(25).fill(null).map((_, index) => {
     const status = statuses[index % statuses.length];
     return {
-      id: `id-${index + 1}`,
+      id: `${InvestigationIdPrefix}${index + 1}`,
       description: `Investigation No ${index + 1}`,
-      createDate: `2022-05-${(index + 1).toString().padStart(2, '0')}T12:34:12`,
       status,
+      createdBy: 'OEM A',
+      createDate: `2022-05-${(index + 1).toString().padStart(2, '0')}T12:34:12`,
+      parts: [getRandomAsset().id, getRandomAsset().id, getRandomAsset().id],
     };
   });
+
+const MockEmptyInvestigation: InvestigationResponse = {
+  id: `${InvestigationIdPrefix}000`,
+  description: `Investigation No 000`,
+  status: InvestigationStatus.CREATED,
+  createdBy: 'OEM A',
+  createDate: `2022-05-01T12:34:12`,
+  parts: [getRandomAsset().id],
+};
+
+export const getInvestigationById = (id: string) => {
+  return [].find(investigation => investigation.id === id) || { ...MockEmptyInvestigation, id };
+};

src/app/mocks/services/parts-mock/parts.handler.ts

@@ -34,6 +34,12 @@ export const partsHandlers = [
     return res(ctx.status(200), ctx.json(mockAssetsCountriesMap));
   }),
 
+  rest.get(`${environment.apiUrl}/assets/my`, (req, res, ctx) => {
+    const pagination = extractPagination(req);
+
+    return res(ctx.status(200), ctx.json(applyPagination(mockBmwAssets, pagination)));
+  }),
+
   rest.get(`${environment.apiUrl}/assets/:partId`, (req, res, ctx) => {
     const { partId } = req.params;
     const currentAsset = getAssetById(partId as string);
@@ -62,6 +68,10 @@ export const partsHandlersTest = [
     return res(ctx.status(200), ctx.json(mockAssetsCountriesMap));
   }),
 
+  rest.get(`${environment.apiUrl}/assets/my`, (req, res, ctx) => {
+    return res(ctx.status(200), ctx.json(mockAssets));
+  }),
+
   rest.get(`${environment.apiUrl}/assets/:partId`, (req, res, ctx) => {
     const { partId } = req.params;
     const currentAsset = mockAssetList[partId as string];

src/app/mocks/services/parts-mock/parts.model.ts

@@ -335,3 +335,8 @@ const MockEmptyPart: PartResponse = {
 export const getAssetById = (id: string) => {
   return [...mockBmwAssets, ...otherPartsAssets].find(asset => asset.id === id) || { ...MockEmptyPart, id };
 };
+
+export const getRandomAsset = () => {
+  const parts = [...mockBmwAssets, ...otherPartsAssets];
+  return parts[Math.floor(Math.random() * parts.length)];
+};

src/app/modules/core/model/pagination.model.ts

@@ -32,3 +32,5 @@ export interface PaginationResponse<T> {
   totalItems: number;
   content: T[];
 }
+
+export const EmptyPagination = { page: 0, pageCount: 0, pageSize: 0, totalItems: 0, content: [] };

src/app/modules/core/pagination/pagination.assembler.ts

@@ -17,13 +17,18 @@
  * SPDX-License-Identifier: Apache-2.0
  ********************************************************************************/
 
-import { Pagination, PaginationResponse } from '@core/model/pagination.model';
+import { EmptyPagination, Pagination, PaginationResponse } from '@core/model/pagination.model';
 
 export class PaginationAssembler {
   public static assemblePagination<ResponseItem, Item>(
-    { page, pageCount, pageSize, totalItems, content }: PaginationResponse<ResponseItem>,
+    response: PaginationResponse<ResponseItem>,
     contentMapper: (item: ResponseItem) => Item,
   ): Pagination<Item> {
+    if (!response || !response.content.length) {
+      return EmptyPagination;
+    }
+
+    const { page, pageCount, pageSize, totalItems, content } = response;
     return { page, pageCount, pageSize, totalItems, content: content.map(contentMapper) };
   }
 }

src/app/modules/page/dashboard/abstraction/dashboard.facade.ts

@@ -20,7 +20,7 @@
 import { Injectable } from '@angular/core';
 import { RoleService } from '@core/user/role.service';
 import { CountryLocationMap, PartsCoordinates } from '@page/dashboard/presentation/map/map.model';
-import { Investigations, InvestigationStatusGroup } from '@shared/model/investigations.model';
+import { Investigations, InvestigationStatus } from '@shared/model/investigations.model';
 import { View } from '@shared/model/view.model';
 import { InvestigationsService } from '@shared/service/investigations.service';
 import { PartsService } from '@shared/service/parts.service';
@@ -122,7 +122,7 @@ export class DashboardFacade {
   private setInvestigations(): void {
     this.investigationSubscription?.unsubscribe();
     this.investigationSubscription = this.investigationsService
-      .getInvestigationsByType(InvestigationStatusGroup.RECEIVED, 0, 5)
+      .getInvestigationsByType([InvestigationStatus.RECEIVED], 0, 5)
       .subscribe({
         next: data => this.dashboardState.setInvestigation({ data }),
         error: (error: Error) => this.dashboardState.setInvestigation({ error }),

src/app/modules/page/investigations/core/investigations.facade.ts

@@ -18,7 +18,7 @@
  ********************************************************************************/
 
 import { Injectable } from '@angular/core';
-import { Investigations, InvestigationStatusGroup } from '@shared/model/investigations.model';
+import { Investigations, InvestigationStatus } from '@shared/model/investigations.model';
 import { View } from '@shared/model/view.model';
 import { InvestigationsService } from '@shared/service/investigations.service';
 import { Observable, Subscription } from 'rxjs';
@@ -45,7 +45,7 @@ export class InvestigationsFacade {
   public setReceivedInvestigation(page = 0, pageSize = 5): void {
     this.investigationReceivedSubscription?.unsubscribe();
     this.investigationReceivedSubscription = this.investigationsService
-      .getInvestigationsByType(InvestigationStatusGroup.RECEIVED, page, pageSize)
+      .getInvestigationsByType([InvestigationStatus.RECEIVED], page, pageSize)
       .subscribe({
         next: data => (this.investigationsState.investigationsReceived = { data }),
         error: (error: Error) => (this.investigationsState.investigationsReceived = { error }),
@@ -55,7 +55,7 @@ export class InvestigationsFacade {
   public setQueuedAndRequestedInvestigations(page = 0, pageSize = 5): void {
     this.investigationQueuedAndRequestedSubscription?.unsubscribe();
     this.investigationQueuedAndRequestedSubscription = this.investigationsService
-      .getInvestigationsByType(InvestigationStatusGroup.QUEUED_AND_REQUESTED, page, pageSize)
+      .getInvestigationsByType([InvestigationStatus.CREATED, InvestigationStatus.SENT], page, pageSize)
       .subscribe({
         next: data => (this.investigationsState.investigationsQueuedAndRequested = { data }),
         error: (error: Error) => (this.investigationsState.investigationsQueuedAndRequested = { error }),

src/app/modules/page/parts/core/parts.facade.spec.ts

@@ -39,7 +39,8 @@ describe('Parts facade', () => {
   beforeEach(() => {
     partsServiceMok = {
       getPart: id => new BehaviorSubject(mockAssetList[id]).pipe(map(part => PartsAssembler.assemblePart(part))),
-      getParts: (_page, _pageSize, _sorting) => of(mockAssets).pipe(map(parts => PartsAssembler.assembleParts(parts))),
+      getMyParts: (_page, _pageSize, _sorting) =>
+        of(mockAssets).pipe(map(parts => PartsAssembler.assembleParts(parts))),
     } as PartsService;
 
     partsState = new PartsState();
@@ -48,24 +49,24 @@ describe('Parts facade', () => {
 
   describe('setParts', () => {
     it('should set parts if request is successful', async () => {
-      const serviceSpy = jest.spyOn(partsServiceMok, 'getParts');
-      partsFacade.setParts(0, 10);
+      const serviceSpy = jest.spyOn(partsServiceMok, 'getMyParts');
+      partsFacade.setMyParts(0, 10);
 
       await waitFor(() => expect(serviceSpy).toHaveBeenCalledTimes(1));
       await waitFor(() => expect(serviceSpy).toHaveBeenCalledWith(0, 10, null));
 
-      const parts = await firstValueFrom(partsState.parts$);
+      const parts = await firstValueFrom(partsState.myParts$);
       await waitFor(() => expect(parts).toEqual({ data: PartsAssembler.assembleParts(mockAssets) }));
     });
 
     it('should not set parts if request fails', async () => {
-      const serviceSpy = jest.spyOn(partsServiceMok, 'getParts');
+      const serviceSpy = jest.spyOn(partsServiceMok, 'getMyParts');
       const spyData = new BehaviorSubject(null).pipe(switchMap(_ => throwError(() => new Error('error'))));
 
       serviceSpy.mockReturnValue(spyData);
-      partsFacade.setParts(0, 10);
+      partsFacade.setMyParts(0, 10);
 
-      const parts = await firstValueFrom(partsState.parts$);
+      const parts = await firstValueFrom(partsState.myParts$);
       await waitFor(() => expect(parts).toEqual({ error: new Error('error') }));
     });
   });

src/app/modules/page/parts/core/parts.facade.ts

@@ -30,25 +30,25 @@ import { catchError, delay, map, takeUntil } from 'rxjs/operators';
 @Injectable()
 export class PartsFacade {
   private subjectList: Record<string, Subject<void>> = {};
-  private partsSubscription: Subscription;
+  private myPartsSubscription: Subscription;
   private readonly unsubscribeTrigger = new Subject<void>();
 
   constructor(private readonly partsService: PartsService, private readonly partsState: PartsState) {}
 
   public get parts$(): Observable<View<Pagination<Part>>> {
-    return this.partsState.parts$;
+    return this.partsState.myParts$;
   }
 
-  public setParts(page = 0, pageSize = 5, sorting: TableHeaderSort = null): void {
-    this.partsSubscription?.unsubscribe();
-    this.partsSubscription = this.partsService.getParts(page, pageSize, sorting).subscribe({
-      next: data => (this.partsState.parts = { data }),
-      error: error => (this.partsState.parts = { error }),
+  public setMyParts(page = 0, pageSize = 5, sorting: TableHeaderSort = null): void {
+    this.myPartsSubscription?.unsubscribe();
+    this.myPartsSubscription = this.partsService.getMyParts(page, pageSize, sorting).subscribe({
+      next: data => (this.partsState.myParts = { data }),
+      error: error => (this.partsState.myParts = { error }),
     });
   }
 
   public unsubscribeParts(): void {
-    this.partsSubscription?.unsubscribe();
+    this.myPartsSubscription?.unsubscribe();
     this.unsubscribeTrigger.next();
   }