refactor: use API for creating quote request from quote request (#488)

e2e/cypress/integration/specs/quoting/quote-handling.b2b.e2e-spec.ts

@@ -86,13 +86,12 @@ describe('Quote Handling', () => {
     });
   });
 
-  it('user adds one product from product list page to quote and submit it, afterwards copying it', () => {
+  it('user adds one product from product list page to quote and submit it', () => {
     at(MyAccountPage, page => page.header.gotoCategoryPage(_.catalog));
     at(CategoryPage, page => page.gotoSubCategory(_.categoryId));
     at(FamilyPage, page => page.productList.addProductToQuoteRequest(_.product.sku));
     at(QuoteRequestDialog, dialog => {
       dialog.submitQuoteRequest().then(quoteId => {
-        dialog.copyQuoteRequest();
         dialog.hide();
         at(FamilyPage, page => page.header.goToMyAccount());
         at(MyAccountPage, page => page.navigateToQuoting());
@@ -108,8 +107,16 @@ describe('Quote Handling', () => {
     });
   });
 
+  it('user copies quote request', () => {
+    at(QuoteDetailPage, page => {
+      page.copyQuoteRequest();
+      page.quoteState.should('have.text', 'New');
+      page.totalPrice.should('contain', _.product.price);
+    });
+  });
+
   it('user adds product to quote request from family page', () => {
-    at(MyAccountPage, page => page.header.gotoCategoryPage(_.catalog));
+    at(QuoteDetailPage, page => page.header.gotoCategoryPage(_.catalog));
     at(CategoryPage, page => page.gotoSubCategory(_.categoryId));
     at(FamilyPage, page => page.productList.addProductToQuoteRequest(_.product.sku));
     at(QuoteRequestDialog, dialog => {

src/app/extensions/quoting/facades/quote-context.facade.ts

@@ -123,7 +123,7 @@ export abstract class QuoteContextFacade
     if (this.get('entity', 'type') === 'Quote') {
       this.store.dispatch(createQuoteRequestFromQuote({ id: this.get('entity', 'id') }));
     } else {
-      this.store.dispatch(createQuoteRequestFromQuoteRequest({ entity: this.get('entity') }));
+      this.store.dispatch(createQuoteRequestFromQuoteRequest({ id: this.get('entity', 'id') }));
     }
   }
 

src/app/extensions/quoting/services/quoting/quoting.service.spec.ts

@@ -2,11 +2,10 @@ import { TestBed } from '@angular/core/testing';
 import { of } from 'rxjs';
 import { anything, capture, instance, mock, verify, when } from 'ts-mockito';
 
-import { Link } from 'ish-core/models/link/link.model';
 import { ApiService } from 'ish-core/services/api/api.service';
 
 import { QuoteData } from '../../models/quoting/quoting.interface';
-import { QuoteRequest, QuoteRequestItem, QuoteStub } from '../../models/quoting/quoting.model';
+import { QuoteStub } from '../../models/quoting/quoting.model';
 
 import { QuotingService } from './quoting.service';
 
@@ -173,20 +172,18 @@ describe('Quoting Service', () => {
 
   describe('createQuoteRequestFromQuote', () => {
     beforeEach(() => {
-      when(apiService.post(anything(), anything())).thenReturn(of({ type: 'QuoteRequest' }));
+      when(apiService.post(anything(), anything(), anything())).thenReturn(of({ type: 'QuoteRequest' }));
     });
 
     it('should use quote request API for creating quoterequest from quote', done => {
       quotingService.createQuoteRequestFromQuote('quoteID').subscribe(
         () => {
-          verify(apiService.post(anything(), anything())).once();
+          verify(apiService.post(anything(), anything(), anything())).once();
           const args = capture(apiService.post).last();
           expect(args?.[0]).toMatchInlineSnapshot(`"quoterequests"`);
-          expect(args?.[1]).toMatchInlineSnapshot(`
-            Object {
-              "quoteID": "quoteID",
-            }
-          `);
+          expect(args?.[1]).toMatchInlineSnapshot(`undefined`);
+          // tslint:disable-next-line: no-string-literal
+          expect(args?.[2]?.['params']?.toString()).toMatchInlineSnapshot(`"quoteID=quoteID"`);
         },
         fail,
         done
@@ -196,56 +193,22 @@ describe('Quoting Service', () => {
 
   describe('createQuoteRequestFromQuoteRequest', () => {
     beforeEach(() => {
-      when(apiService.post(anything())).thenReturn(of({ type: 'Link', title: 'NEW' } as Link));
-      when(apiService.put(anything(), anything())).thenReturn(of({}));
+      when(apiService.post(anything(), anything(), anything())).thenReturn(of({ type: 'QuoteRequest' }));
     });
 
     it('should use quote request API for creating quote request from quote request', done => {
-      quotingService
-        .createQuoteRequestFromQuoteRequest({
-          type: 'QuoteRequest',
-          items: [
-            { productSKU: 'SKU1', quantity: { value: 1 } },
-            { productSKU: 'SKU2', quantity: { value: 3 } },
-          ] as QuoteRequestItem[],
-        } as QuoteRequest)
-        .subscribe(
-          id => {
-            verify(apiService.post(anything())).once();
-            expect(capture(apiService.post).last()).toMatchInlineSnapshot(`
-              Array [
-                "quoterequests",
-              ]
-            `);
-
-            verify(apiService.put(anything(), anything())).once();
-            expect(capture(apiService.put).last()).toMatchInlineSnapshot(`
-              Array [
-                "quoterequests/NEW/items",
-                Object {
-                  "elements": Array [
-                    Object {
-                      "productSKU": "SKU1",
-                      "quantity": Object {
-                        "value": 1,
-                      },
-                    },
-                    Object {
-                      "productSKU": "SKU2",
-                      "quantity": Object {
-                        "value": 3,
-                      },
-                    },
-                  ],
-                },
-              ]
-            `);
-
-            expect(id).toMatchInlineSnapshot(`"NEW"`);
-          },
-          fail,
-          done
-        );
+      quotingService.createQuoteRequestFromQuoteRequest('quoteRequestID').subscribe(
+        () => {
+          verify(apiService.post(anything(), anything(), anything())).once();
+          const args = capture(apiService.post).last();
+          expect(args?.[0]).toMatchInlineSnapshot(`"quoterequests"`);
+          expect(args?.[1]).toMatchInlineSnapshot(`undefined`);
+          // tslint:disable-next-line: no-string-literal
+          expect(args?.[2]?.['params']?.toString()).toMatchInlineSnapshot(`"quoteRequestID=quoteRequestID"`);
+        },
+        fail,
+        done
+      );
     });
   });
 

src/app/extensions/quoting/services/quoting/quoting.service.ts

@@ -14,7 +14,6 @@ import { QuotingMapper } from '../../models/quoting/quoting.mapper';
 import {
   QuoteCompletenessLevel,
   QuoteRequest,
-  QuoteRequestItem,
   QuoteStub,
   QuoteStubFromAttributes,
   QuotingEntity,
@@ -103,30 +102,21 @@ export class QuotingService {
   createQuoteRequestFromQuote(quoteID: string) {
     return this.apiService
       .b2bUserEndpoint()
-      .post<Link>('quoterequests', { quoteID })
+      .post<Link>('quoterequests', undefined, { params: new HttpParams().set('quoteID', quoteID) })
       .pipe(map(data => this.quoteMapper.fromData(data, 'QuoteRequest')));
   }
 
-  createQuoteRequestFromQuoteRequest(quoteRequest: QuoteRequest) {
-    return this.createQuoteRequest().pipe(
-      concatMap(stub =>
-        this.apiService
-          .b2bUserEndpoint()
-          .put<Link>(`quoterequests/${stub.id}/items`, {
-            elements: quoteRequest.items.map((item: QuoteRequestItem) => ({
-              productSKU: item.productSKU,
-              quantity: { value: item.quantity.value },
-            })),
-          })
-          .pipe(mapTo(stub.id))
-      )
-    );
+  createQuoteRequestFromQuoteRequest(quoteRequestID: string) {
+    return this.apiService
+      .b2bUserEndpoint()
+      .post<Link>('quoterequests', undefined, { params: new HttpParams().set('quoteRequestID', quoteRequestID) })
+      .pipe(map(data => this.quoteMapper.fromData(data, 'QuoteRequest')));
   }
 
   createQuoteRequestFromBasket(basketID: string) {
     return this.apiService
       .b2bUserEndpoint()
-      .post<Link>('quoterequests', { basketID })
+      .post<Link>('quoterequests', undefined, { params: new HttpParams().set('basketID', basketID) })
       .pipe(map(data => this.quoteMapper.fromData(data, 'QuoteRequest')));
   }
 

src/app/extensions/quoting/store/quoting/quoting.actions.ts

@@ -71,7 +71,7 @@ export const createQuoteRequestFromQuoteSuccess = createAction(
 
 export const createQuoteRequestFromQuoteRequest = createAction(
   '[Quoting] Create Quote Request From Quote Request',
-  payload<EntityPayloadType>()
+  payload<IdPayloadType>()
 );
 
 export const createQuoteRequestFromQuoteRequestSuccess = createAction(

src/app/extensions/quoting/store/quoting/quoting.effects.spec.ts

@@ -144,14 +144,16 @@ describe('Quoting Effects', () => {
 
   describe('createQuoteRequestFromQuote$', () => {
     it('should create quote request from quote via quoting service when triggered', done => {
-      when(quotingService.createQuoteRequestFromQuote(anything())).thenCall(({ id }) => of(id));
+      when(quotingService.createQuoteRequestFromQuote(anything())).thenCall(id =>
+        of({ type: 'QuoteRequest', id } as QuoteRequest)
+      );
       actions$ = of(createQuoteRequestFromQuote({ id: 'ID' }));
 
       effects.createQuoteRequestFromQuote$.subscribe(action => {
         verify(quotingService.createQuoteRequestFromQuote(anything())).once();
         expect(action).toMatchInlineSnapshot(`
           [Quoting API] Create Quote Request From Quote Success:
-            entity: undefined
+            entity: {"type":"QuoteRequest","id":"ID"}
         `);
         done();
       });
@@ -160,17 +162,19 @@ describe('Quoting Effects', () => {
 
   describe('createQuoteRequestFromQuoteRequest$', () => {
     it('should create quote request from quote request via quoting service when triggered', done => {
-      when(quotingService.createQuoteRequestFromQuoteRequest(anything())).thenReturn(of('NEW'));
+      when(quotingService.createQuoteRequestFromQuoteRequest(anything())).thenCall(id =>
+        of({ type: 'QuoteRequest', id } as QuoteRequest)
+      );
       when(quotingService.getQuoteDetails(anything(), anything(), anything())).thenCall((id, type) =>
         of({ id, type, completenessLevel: 'Detail' } as QuoteStub)
       );
-      actions$ = of(createQuoteRequestFromQuoteRequest({ entity: { id: 'ID' } as QuoteRequest }));
+      actions$ = of(createQuoteRequestFromQuoteRequest({ id: 'ID' }));
 
       effects.createQuoteRequestFromQuoteRequest$.subscribe(action => {
         verify(quotingService.createQuoteRequestFromQuoteRequest(anything())).once();
         expect(action).toMatchInlineSnapshot(`
           [Quoting API] Create Quote Request From Quote Request Success:
-            entity: {"id":"NEW","type":"QuoteRequest","completenessLevel":"Detai...
+            entity: {"type":"QuoteRequest","id":"ID"}
         `);
         done();
       });

src/app/extensions/quoting/store/quoting/quoting.effects.ts

@@ -146,11 +146,10 @@ export class QuotingEffects {
   createQuoteRequestFromQuoteRequest$ = createEffect(() =>
     this.actions$.pipe(
       ofType(createQuoteRequestFromQuoteRequest),
-      mapToPayloadProperty('entity'),
-      map(QuotingHelper.asQuoteRequest),
-      concatMap(quoteRequest =>
-        this.quotingService.createQuoteRequestFromQuoteRequest(quoteRequest).pipe(
-          concatMap(id => this.quotingService.getQuoteDetails(id, 'QuoteRequest', 'List')),
+      mapToPayloadProperty('id'),
+      concatMap(quoteRequestId =>
+        this.quotingService.createQuoteRequestFromQuoteRequest(quoteRequestId).pipe(
+          // concatMap(id => this.quotingService.getQuoteDetails(id, 'QuoteRequest', 'List')),
           map(entity => createQuoteRequestFromQuoteRequestSuccess({ entity })),
           mapErrorToAction(loadQuotingFail)
         )