feat(payment): PI-2875 Google Pay coupons handling

packages/core/src/payment-integration/create-payment-integration-service.ts

@@ -45,6 +45,8 @@ import { SubscriptionsActionCreator, SubscriptionsRequestSender } from '../subsc
 import createPaymentIntegrationSelectors from './create-payment-integration-selectors';
 import DefaultPaymentIntegrationService from './default-payment-integration-service';
 import PaymentIntegrationStoreProjectionFactory from './payment-integration-store-projection-factory';
+import CouponActionCreator from '../coupon/coupon-action-creator';
+import CouponRequestSender from '../coupon/coupon-request-sender';
 
 export default function createPaymentIntegrationService(
     store: CheckoutStore,
@@ -112,6 +114,10 @@ export default function createPaymentIntegrationService(
         new StoreCreditRequestSender(requestSender),
     );
 
+    const applyCouponActionCreator = new CouponActionCreator(
+        new CouponRequestSender(requestSender),
+    );
+
     const spamProtection = createSpamProtection(createScriptLoader());
     const spamProtectionRequestSender = new SpamProtectionRequestSender(requestSender);
     const spamProtectionActionCreator = new SpamProtectionActionCreator(
@@ -150,6 +156,7 @@ export default function createPaymentIntegrationService(
         customerActionCreator,
         cartRequestSender,
         storeCreditActionCreator,
+        applyCouponActionCreator,
         spamProtectionActionCreator,
         paymentProviderCustomerActionCreator,
         shippingCountryActionCreator,

packages/core/src/payment-integration/default-payment-integration-service.spec.ts

@@ -41,6 +41,7 @@ import { StoreCreditActionCreator } from '../store-credit';
 
 import DefaultPaymentIntegrationService from './default-payment-integration-service';
 import PaymentIntegrationStoreProjectionFactory from './payment-integration-store-projection-factory';
+import CouponActionCreator from '../coupon/coupon-action-creator';
 
 describe('DefaultPaymentIntegrationService', () => {
     let subject: PaymentIntegrationService;
@@ -84,6 +85,7 @@ describe('DefaultPaymentIntegrationService', () => {
     let customerActionCreator: Pick<CustomerActionCreator, 'signInCustomer' | 'signOutCustomer'>;
     let cartRequestSender: CartRequestSender;
     let storeCreditActionCreator: Pick<StoreCreditActionCreator, 'applyStoreCredit'>;
+    let applyCouponActionCreator: Pick<CouponActionCreator, 'applyCoupon'>;
     let paymentProviderCustomerActionCreator: PaymentProviderCustomerActionCreator;
     let shippingCountryActionCreator: Pick<ShippingCountryActionCreator, 'loadCountries'>;
     let remoteCheckoutActionCreator: Pick<
@@ -226,6 +228,15 @@ describe('DefaultPaymentIntegrationService', () => {
             ),
         };
 
+        applyCouponActionCreator = {
+            // TODO: remove ts-ignore and update test with related type (PAYPAL-4383)
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            applyCoupon: jest.fn(
+                async () => () => createAction('APPLY_COUPON'),
+            ),
+        };
+
         spamProtectionActionCreator = {
             // TODO: remove ts-ignore and update test with related type (PAYPAL-4383)
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -295,6 +306,7 @@ describe('DefaultPaymentIntegrationService', () => {
             customerActionCreator as CustomerActionCreator,
             cartRequestSender,
             storeCreditActionCreator as StoreCreditActionCreator,
+            applyCouponActionCreator as CouponActionCreator,
             spamProtectionActionCreator as SpamProtectionActionCreator,
             paymentProviderCustomerActionCreator,
             shippingCountryActionCreator as ShippingCountryActionCreator,

packages/core/src/payment-integration/default-payment-integration-service.ts

@@ -35,6 +35,7 @@ import { PaymentHumanVerificationHandler, SpamProtectionActionCreator } from '..
 import { StoreCreditActionCreator } from '../store-credit';
 
 import PaymentIntegrationStoreProjectionFactory from './payment-integration-store-projection-factory';
+import CouponActionCreator from '../coupon/coupon-action-creator';
 
 export default class DefaultPaymentIntegrationService implements PaymentIntegrationService {
     private _storeProjection: DataStoreProjection<PaymentIntegrationSelectors>;
@@ -54,6 +55,7 @@ export default class DefaultPaymentIntegrationService implements PaymentIntegrat
         private _customerActionCreator: CustomerActionCreator,
         private _cartRequestSender: CartRequestSender,
         private _storeCreditActionCreator: StoreCreditActionCreator,
+        private _couponActionCreator: CouponActionCreator,
         private _spamProtectionActionCreator: SpamProtectionActionCreator,
         private _paymentProviderCustomerActionCreator: PaymentProviderCustomerActionCreator,
         private _shippingCountryActionCreator: ShippingCountryActionCreator,
@@ -215,6 +217,28 @@ export default class DefaultPaymentIntegrationService implements PaymentIntegrat
         return this._storeProjection.getState();
     }
 
+    async applyCoupon(
+        coupon: string,
+        options?: RequestOptions,
+    ): Promise<PaymentIntegrationSelectors> {
+        await this._store.dispatch(
+            this._couponActionCreator.applyCoupon(coupon, options),
+        );
+
+        return this._storeProjection.getState();
+    }
+
+    async removeCoupon(
+        coupon: string,
+        options?: RequestOptions,
+    ): Promise<PaymentIntegrationSelectors> {
+        await this._store.dispatch(
+            this._couponActionCreator.removeCoupon(coupon, options),
+        );
+
+        return this._storeProjection.getState();
+    }
+
     async verifyCheckoutSpamProtection(): Promise<PaymentIntegrationSelectors> {
         const { checkout } = this._store.getState();
         const { shouldExecuteSpamCheck } = checkout.getCheckoutOrThrow();

packages/google-pay-integration/src/gateways/google-pay-gateway.ts

@@ -20,18 +20,18 @@ import {
 import isGooglePayCardNetworkKey from '../guards/is-google-pay-card-network-key';
 import {
     CallbackIntentsType,
-    CallbackTriggerType,
+    CallbackTriggerType, ErrorReasonType,
     ExtraPaymentData,
     GooglePayCardDataResponse,
     GooglePayCardNetwork,
-    GooglePayCardParameters,
+    GooglePayCardParameters, GooglePayError,
     GooglePayFullBillingAddress,
     GooglePayGatewayParameters,
     GooglePayInitializationData,
-    GooglePayMerchantInfo,
+    GooglePayMerchantInfo, GooglePayPaymentDataRequest,
     GooglePayRequiredPaymentData,
     GooglePaySetExternalCheckoutData,
-    GooglePayTransactionInfo,
+    GooglePayTransactionInfo, IntermediatePaymentData,
     ShippingOptionParameters,
     TotalPriceStatusType,
 } from '../types';
@@ -142,19 +142,23 @@ export default class GooglePayGateway {
             CallbackTriggerType.INITIALIZE,
             CallbackTriggerType.SHIPPING_ADDRESS,
             CallbackTriggerType.SHIPPING_OPTION,
+            CallbackTriggerType.OFFER,
         ];
+
         const initializationTrigger = [CallbackTriggerType.INITIALIZE];
         const addressChangeTriggers = [
             CallbackTriggerType.INITIALIZE,
             CallbackTriggerType.SHIPPING_ADDRESS,
         ];
         const shippingOptionsChangeTriggers = [CallbackTriggerType.SHIPPING_OPTION];
+        const offerChangeTriggers = [CallbackTriggerType.OFFER];
 
         return {
             availableTriggers,
             initializationTrigger,
             addressChangeTriggers,
             shippingOptionsChangeTriggers,
+            offerChangeTriggers,
         };
     }
 
@@ -245,7 +249,7 @@ export default class GooglePayGateway {
         this._getPaymentMethodFn = getPaymentMethod;
         this._isBuyNowFlow = Boolean(isBuyNowFlow);
         this._currencyCode = currencyCode;
-
+        console.log('isBuyNowFlow', isBuyNowFlow);
         if (this._isBuyNowFlow) {
             this._getCurrencyCodeOrThrow();
         }
@@ -329,6 +333,126 @@ export default class GooglePayGateway {
         return totalPrice;
     }
 
+    async handleCoupons(
+        offerData: IntermediatePaymentData['offerData'],
+        isCartPage = false,
+    ) {
+        const { redemptionCodes = [] } = offerData || {};
+        const appliedCoupons = this.getAppliedCoupons();
+
+        let error = undefined;
+
+        if (!redemptionCodes.length) {
+            await this.removeAllCoupons(appliedCoupons, isCartPage);
+
+            return {
+                newOfferInfo: this.getAppliedCoupons(),
+                error,
+            }
+        }
+
+        // Validate for applied coupons to make sure we have only one applied
+        if (appliedCoupons.offers.length) {
+            error = {
+                reason: ErrorReasonType.OFFER_INVALID,
+                message: "You can only apply one coupon per order.",
+                intent: CallbackTriggerType.OFFER
+            };
+
+            return {
+                newOfferInfo: appliedCoupons,
+                error,
+            }
+        }
+
+        const code = redemptionCodes[redemptionCodes.length - 1];
+        const appliedCouponError = await this.applyCoupon(code, isCartPage);
+
+        if (appliedCouponError) {
+            error = appliedCouponError;
+        }
+
+        return {
+            newOfferInfo: this.getAppliedCoupons(),
+            error,
+        }
+    }
+
+    getAppliedCoupons(): GooglePayPaymentDataRequest['offerInfo'] {
+        const state = this._paymentIntegrationService.getState();
+        const { coupons } = state.getCheckout() || {};
+        console.log('state.getCheckout()', state.getCheckout());
+
+        // @ts-ignore
+        window.check = state.getCheckout
+        const offers = (coupons || []).map((coupon) => {
+            const { displayName, code } = coupon;
+            return {
+                redemptionCode: code,
+                description: displayName,
+            }
+        });
+
+        return {
+            offers,
+        }
+    }
+
+    protected async applyCoupon(code: string, isCartPage: boolean) {
+        let error: GooglePayError | undefined = undefined;
+
+        try {
+            await this._paymentIntegrationService.applyCoupon(code);
+        } catch (e) {
+            if (e instanceof Error) {
+                error = {
+                    reason: ErrorReasonType.OFFER_INVALID,
+                    message: e.message,
+                    intent: CallbackTriggerType.OFFER
+                };
+            }
+
+            return error;
+        }
+
+        if (isCartPage) {
+            const couponCodeInput = document.getElementById('couponcode') as HTMLInputElement;
+
+            if (couponCodeInput) {
+                couponCodeInput.value = code;
+
+                const form = document.querySelector('.coupon-form');
+
+                if (form) {
+                    try {
+                        form.dispatchEvent(new CustomEvent('submit', { cancelable: true }));
+                    } catch (error) {}
+                }
+            }
+        }
+    }
+
+    protected async removeAllCoupons(
+        appliedCoupons: GooglePayPaymentDataRequest['offerInfo'],
+        withClickOnTheCartPage: boolean
+    ) {
+        const { offers } = appliedCoupons;
+
+        const couponsPromise = offers.map((couponCode) => {
+            return this._paymentIntegrationService.removeCoupon(couponCode.redemptionCode);
+        });
+
+        await Promise.all(couponsPromise);
+
+        if (withClickOnTheCartPage) {
+            const removeCouponLink = document.querySelector('a[href*="/cart.php?action=removecoupon"]') as HTMLAnchorElement;
+
+            if (removeCouponLink) {
+                removeCouponLink.click()
+            }
+        }
+    }
+
     protected getGooglePayInitializationData(): GooglePayInitializationData {
         return guard(
             this.getPaymentMethod().initializationData,