@xsolla/payment-client-core 0.2.20 → 0.2.21

package/esm2020/lib/core/sdk-payment-systems/apple-pay/apple-pay.service.mjs

@@ -0,0 +1,268 @@
+import { Subject } from 'rxjs';
+import { Inject, Injectable } from '@angular/core';
+import { applePayVersion, safariVersionForIframeIntegration, } from './apple-pay.const';
+import { agreementsGroup } from '../../agreementsGroup.const';
+import { windowToken } from '../../window.token';
+import { FieldNames } from '../../payment/field-names.enum';
+import { ApplePayErrors } from './apple-pay.errors.enum';
+import { pagesRoutes } from '../../payment/actions/redirect/ps4-pages/pages-routes.const';
+import { applePayId } from '../../payment/actions/redirect/ps4-pages/pages-payment-methods-id.const';
+import { payStation4Url, sandboxPayStationUrl, } from '../../payment/actions/redirect/pay-station4-url.const';
+import * as i0 from "@angular/core";
+import * as i1 from "../../user-agent/user-agent.service";
+import * as i2 from "../../payment/finance-details/summary/summary-finance-details-adapter.service";
+export class ApplePayService {
+    get paymentParameters() {
+        return this.applePayParams;
+    }
+    get payment$() {
+        return this.payment.asObservable();
+    }
+    get error$() {
+        return this.error.asObservable();
+    }
+    get integrationType$() {
+        return this.integrationType.asObservable();
+    }
+    constructor(window, userAgentService, summaryFinanceDetailsAdapterService) {
+        this.window = window;
+        this.userAgentService = userAgentService;
+        this.summaryFinanceDetailsAdapterService = summaryFinanceDetailsAdapterService;
+        this.agreementFieldsNames = agreementsGroup;
+        this.payment = new Subject();
+        this.error = new Subject();
+        this.integrationType = new Subject();
+        this.paymentClient = null;
+        this.applePayParams = null;
+        this.order = null;
+        this.api = this.loadBraintree();
+    }
+    setApplePayParams(data) {
+        const formFields = data?.paymentForm?.fields;
+        const summary = data?.paymentForm?.summary;
+        if (!formFields || !summary) {
+            return;
+        }
+        const fields = formFields.reduce((acc, field) => {
+            if (this.agreementFieldsNames.includes(field.name) &&
+                field.isVisible === '1') {
+                acc[field.name] = field.title;
+            }
+            else {
+                acc[field.name] = field.value;
+            }
+            return acc;
+        }, {});
+        const agreements = this.agreementFieldsNames
+            .map((fieldName) => fields[fieldName])
+            .filter(Boolean);
+        this.applePayParams = {
+            tokenKey: this.getAppleToken(formFields),
+            totalLabel: fields['label_applePay'] ?? '',
+            totalAmount: this.getTotalAmount(summary),
+            currencyCode: this.getTotalCurrency(summary),
+            countryCode: fields['countryCode'] ?? '',
+            merchantCapabilities: this.getJsonValueFromField(fields, 'merchantCapabilities'),
+            supportedNetworks: this.getJsonValueFromField(fields, 'supportedNetworks'),
+            agreements: agreements,
+        };
+    }
+    async initLibrary(tokenKey) {
+        try {
+            const api = await this.api;
+            const clientInstance = await api.client.create({
+                authorization: tokenKey,
+            });
+            this.paymentClient = await api.applePay.create({
+                client: clientInstance,
+            });
+        }
+        catch (error) {
+            console.error('apple pay: initialize failed', error);
+        }
+        this.emitIntegrationType();
+        if (!this.paymentClient || !this.isDeviceCapable()) {
+            this.emitError(ApplePayErrors.deviceIsNotCapableError);
+        }
+    }
+    redirectToPaymentPage(parameters, token, isSandbox) {
+        const route = pagesRoutes.get(applePayId);
+        if (!route) {
+            return;
+        }
+        const query = new URLSearchParams({
+            ...parameters,
+            merchantCapabilities: JSON.stringify(parameters.merchantCapabilities),
+            supportedNetworks: JSON.stringify(parameters.supportedNetworks),
+            token,
+            agreements: JSON.stringify(parameters.agreements),
+        });
+        if (this.order) {
+            query.append('order', this.order);
+        }
+        const payStationUrl = isSandbox ? sandboxPayStationUrl : payStation4Url;
+        return `${payStationUrl}/en${route}?${query.toString()}`;
+    }
+    setOrder(data) {
+        const summary = data?.paymentForm?.summary;
+        if (!summary) {
+            return;
+        }
+        const financeDetails = this.summaryFinanceDetailsAdapterService.getFinanceDetails(summary);
+        if (financeDetails?.purchase && financeDetails?.finance) {
+            const cartItems = financeDetails.cartItems;
+            this.order = cartItems?.reduce((curr, item) => {
+                if (curr) {
+                    return curr + `; ${item.title}`;
+                }
+                return curr + item.title;
+            }, '');
+        }
+    }
+    proceedCheckout(parameters) {
+        if (!parameters) {
+            return;
+        }
+        if (!this.paymentClient || !this.isDeviceCapable()) {
+            console.warn('apple pay: device is not capable', this.paymentClient);
+            this.emitError(ApplePayErrors.deviceIsNotCapableError);
+            return;
+        }
+        try {
+            const paymentRequest = this.paymentClient.createPaymentRequest({
+                total: {
+                    label: parameters.totalLabel,
+                    amount: parameters.totalAmount,
+                },
+                currencyCode: parameters.currencyCode,
+                countryCode: parameters.countryCode,
+                merchantCapabilities: parameters.merchantCapabilities,
+                supportedNetworks: parameters.supportedNetworks,
+            });
+            const session = new this.window.ApplePaySession(applePayVersion, paymentRequest);
+            session.onvalidatemerchant = (event) => {
+                console.info('apple pay: merchant validation', event);
+                this.paymentClient
+                    ?.performValidation({
+                    validationURL: event.validationURL,
+                    displayName: parameters?.totalLabel,
+                })
+                    .then((merchantSession) => {
+                    session.completeMerchantValidation(merchantSession);
+                })
+                    .catch((error) => {
+                    console.error('apple pay: merchant validation error', error);
+                    this.emitError(ApplePayErrors.paymentError);
+                    session.abort();
+                });
+            };
+            session.onpaymentauthorized = (event) => {
+                console.info('apple pay: payment authorization', event);
+                this.paymentClient
+                    ?.tokenize({
+                    token: event.payment.token,
+                })
+                    .then((authorizationResponse) => {
+                    this.payment.next(authorizationResponse?.nonce ?? '');
+                    session.completePayment(this.window.ApplePaySession.STATUS_SUCCESS);
+                })
+                    .catch((error) => {
+                    console.error('apple pay: payment authorization error', error);
+                    this.emitError(ApplePayErrors.paymentError);
+                    session.completePayment(this.window.ApplePaySession.STATUS_FAILURE);
+                });
+            };
+            session.oncancel = (event) => {
+                this.emitError(ApplePayErrors.paymentError);
+                console.error('apple pay: user cancel payment', event);
+            };
+            session.begin();
+        }
+        catch (error) {
+            console.error('apple pay: checkout error', error);
+            this.emitError(ApplePayErrors.paymentError);
+        }
+    }
+    isDeviceCapable() {
+        try {
+            return Boolean(this.window.ApplePaySession?.supportsVersion(applePayVersion) &&
+                this.window.ApplePaySession?.canMakePayments());
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    getTokenNonceFieldData(tokenNonce) {
+        const name = FieldNames.tokenApplePay;
+        const value = btoa(tokenNonce);
+        return { name, value };
+    }
+    updateApplePayParams(data) {
+        const summary = data?.summary;
+        if (!this.applePayParams || !summary) {
+            return;
+        }
+        this.applePayParams.totalAmount = this.getTotalAmount(summary);
+        this.applePayParams.currencyCode = this.getTotalCurrency(summary);
+    }
+    async loadBraintree() {
+        const api = await import('braintree-web');
+        return api;
+    }
+    getAppleToken(formFields) {
+        const appleTokenField = formFields.find((field) => {
+            return field.name === 'token_key';
+        });
+        if (!appleTokenField) {
+            return '';
+        }
+        return appleTokenField.value;
+    }
+    getTotalAmount(summary) {
+        const finance = summary?.finance;
+        const total = finance?.grand_total?.amount ?? finance?.total.amount;
+        return total?.toString() ?? '';
+    }
+    getTotalCurrency(summary) {
+        const finance = summary?.finance;
+        return finance?.grand_total?.currency ?? finance?.total?.currency ?? '';
+    }
+    getJsonValueFromField(fields, fieldName) {
+        const field = fields[fieldName];
+        try {
+            return field ? JSON.parse(field) : undefined;
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    emitError(error) {
+        this.error.next(error);
+    }
+    emitIntegrationType() {
+        let integrationType;
+        if (this.paymentClient && this.isDeviceCapable()) {
+            integrationType = 'redirect';
+        }
+        else {
+            integrationType = 'none';
+        }
+        this.integrationType.next(integrationType);
+    }
+    canUseSdk() {
+        return !!(this.userAgentService.safariVersion &&
+            this.userAgentService.safariVersion >= safariVersionForIframeIntegration);
+    }
+}
+ApplePayService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ApplePayService, deps: [{ token: windowToken }, { token: i1.UserAgentService }, { token: i2.SummaryFinanceDetailsAdapterService }], target: i0.ɵɵFactoryTarget.Injectable });
+ApplePayService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ApplePayService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ApplePayService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [windowToken]
+                }] }, { type: i1.UserAgentService }, { type: i2.SummaryFinanceDetailsAdapterService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"apple-pay.service.js","sourceRoot":"","sources":["../../../../../../../packages/payment-client-core/src/lib/core/sdk-payment-systems/apple-pay/apple-pay.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApplePay, applePay, client } from 'braintree-web';\nimport { Observable, Subject } from 'rxjs';\nimport { Inject, Injectable } from '@angular/core';\nimport {\n  applePayVersion,\n  safariVersionForIframeIntegration,\n} from './apple-pay.const';\nimport { agreementsGroup } from '../../agreementsGroup.const';\nimport { ApplePayParams } from './apple-pay-params.interface';\nimport { Field } from '../../payment/field.interface';\nimport { ExtendedWindow } from '../../extended-window.interface';\nimport { windowToken } from '../../window.token';\nimport { XpsResponse } from '../../payment/xps-response.interface';\nimport { FieldNames } from '../../payment/field-names.enum';\nimport { ApplePayErrors } from './apple-pay.errors.enum';\nimport { UserAgentService } from '../../user-agent/user-agent.service';\nimport { ApplePayIntegration } from './apple-pay-integration.type';\nimport { pagesRoutes } from '../../payment/actions/redirect/ps4-pages/pages-routes.const';\nimport { applePayId } from '../../payment/actions/redirect/ps4-pages/pages-payment-methods-id.const';\nimport { InitializeResponse } from '../../payment/initialize/response/initialize-response.class';\nimport { SummaryFinanceDetailsAdapterService } from '../../payment/finance-details/summary/summary-finance-details-adapter.service';\nimport {\n  payStation4Url,\n  sandboxPayStationUrl,\n} from '../../payment/actions/redirect/pay-station4-url.const';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ApplePayService {\n  private readonly agreementFieldsNames: string[] = agreementsGroup;\n  private readonly payment: Subject<string> = new Subject();\n  private readonly error: Subject<ApplePayErrors> = new Subject();\n  private readonly integrationType: Subject<ApplePayIntegration> =\n    new Subject();\n\n  private paymentClient: ApplePay | null = null;\n\n  private readonly api: Promise<{\n    applePay: typeof applePay;\n    client: typeof client;\n  }>;\n  private applePayParams: ApplePayParams | null = null;\n  private order?: string | null = null;\n\n  public get paymentParameters(): ApplePayParams | null {\n    return this.applePayParams;\n  }\n\n  public get payment$(): Observable<string> {\n    return this.payment.asObservable();\n  }\n\n  public get error$(): Observable<ApplePayErrors> {\n    return this.error.asObservable();\n  }\n\n  public get integrationType$(): Observable<ApplePayIntegration> {\n    return this.integrationType.asObservable();\n  }\n\n  public constructor(\n    @Inject(windowToken) private readonly window: ExtendedWindow,\n    private readonly userAgentService: UserAgentService,\n    private readonly summaryFinanceDetailsAdapterService: SummaryFinanceDetailsAdapterService\n  ) {\n    this.api = this.loadBraintree();\n  }\n\n  public setApplePayParams(data: unknown): void {\n    const formFields = (data as InitializeResponse)?.paymentForm?.fields;\n    const summary = (data as InitializeResponse)?.paymentForm?.summary;\n\n    if (!formFields || !summary) {\n      return;\n    }\n    const fields = formFields.reduce(\n      (acc: { [key: string]: string }, field) => {\n        if (\n          this.agreementFieldsNames.includes(field.name) &&\n          field.isVisible === '1'\n        ) {\n          acc[field.name] = field.title;\n        } else {\n          acc[field.name] = field.value;\n        }\n\n        return acc;\n      },\n      {}\n    );\n\n    const agreements = this.agreementFieldsNames\n      .map((fieldName) => fields[fieldName as keyof typeof fields] as string)\n      .filter(Boolean);\n\n    this.applePayParams = {\n      tokenKey: this.getAppleToken(formFields),\n      totalLabel: fields['label_applePay'] ?? '',\n      totalAmount: this.getTotalAmount(summary),\n      currencyCode: this.getTotalCurrency(summary),\n      countryCode: fields['countryCode'] ?? '',\n      merchantCapabilities: this.getJsonValueFromField(\n        fields,\n        'merchantCapabilities'\n      ),\n      supportedNetworks: this.getJsonValueFromField(\n        fields,\n        'supportedNetworks'\n      ),\n      agreements: agreements,\n    };\n  }\n\n  public async initLibrary(tokenKey: string): Promise<void> {\n    try {\n      const api = await this.api;\n      const clientInstance = await api.client.create({\n        authorization: tokenKey,\n      });\n\n      this.paymentClient = await api.applePay.create({\n        client: clientInstance,\n      });\n    } catch (error: unknown) {\n      console.error('apple pay: initialize failed', error);\n    }\n\n    this.emitIntegrationType();\n\n    if (!this.paymentClient || !this.isDeviceCapable()) {\n      this.emitError(ApplePayErrors.deviceIsNotCapableError);\n    }\n  }\n\n  public redirectToPaymentPage(\n    parameters: ApplePayParams,\n    token: string,\n    isSandbox?: boolean\n  ): string | undefined {\n    const route = pagesRoutes.get(applePayId);\n    if (!route) {\n      return;\n    }\n\n    const query = new URLSearchParams({\n      ...parameters,\n      merchantCapabilities: JSON.stringify(parameters.merchantCapabilities),\n      supportedNetworks: JSON.stringify(parameters.supportedNetworks),\n      token,\n      agreements: JSON.stringify(parameters.agreements),\n    });\n\n    if (this.order) {\n      query.append('order', this.order);\n    }\n\n    const payStationUrl = isSandbox ? sandboxPayStationUrl : payStation4Url;\n    return `${payStationUrl}/en${route}?${query.toString()}`;\n  }\n\n  public setOrder(data: unknown): void {\n    const summary = (data as InitializeResponse)?.paymentForm?.summary;\n    if (!summary) {\n      return;\n    }\n    const financeDetails =\n      this.summaryFinanceDetailsAdapterService.getFinanceDetails(summary);\n\n    if (financeDetails?.purchase && financeDetails?.finance) {\n      const cartItems = financeDetails.cartItems;\n      this.order = cartItems?.reduce((curr, item) => {\n        if (curr) {\n          return curr + `; ${item.title}`;\n        }\n\n        return curr + item.title;\n      }, '');\n    }\n  }\n\n  public proceedCheckout(parameters?: ApplePayParams): void {\n    if (!parameters) {\n      return;\n    }\n\n    if (!this.paymentClient || !this.isDeviceCapable()) {\n      console.warn('apple pay: device is not capable', this.paymentClient);\n      this.emitError(ApplePayErrors.deviceIsNotCapableError);\n      return;\n    }\n\n    try {\n      const paymentRequest = this.paymentClient.createPaymentRequest({\n        total: {\n          label: parameters.totalLabel,\n          amount: parameters.totalAmount,\n        },\n        currencyCode: parameters.currencyCode,\n        countryCode: parameters.countryCode,\n        merchantCapabilities: parameters.merchantCapabilities,\n        supportedNetworks: parameters.supportedNetworks,\n      });\n\n      const session = new this.window.ApplePaySession(\n        applePayVersion,\n        paymentRequest\n      );\n\n      session.onvalidatemerchant = (event: { validationURL: string }) => {\n        console.info('apple pay: merchant validation', event);\n        this.paymentClient\n          ?.performValidation({\n            validationURL: event.validationURL,\n            displayName: parameters?.totalLabel,\n          })\n          .then((merchantSession) => {\n            session.completeMerchantValidation(merchantSession);\n          })\n          .catch((error) => {\n            console.error('apple pay: merchant validation error', error);\n            this.emitError(ApplePayErrors.paymentError);\n            session.abort();\n          });\n      };\n\n      session.onpaymentauthorized = (event: { payment: { token: string } }) => {\n        console.info('apple pay: payment authorization', event);\n        this.paymentClient\n          ?.tokenize({\n            token: event.payment.token,\n          })\n          .then((authorizationResponse) => {\n            this.payment.next(authorizationResponse?.nonce ?? '');\n            session.completePayment(this.window.ApplePaySession.STATUS_SUCCESS);\n          })\n          .catch((error) => {\n            console.error('apple pay: payment authorization error', error);\n            this.emitError(ApplePayErrors.paymentError);\n            session.completePayment(this.window.ApplePaySession.STATUS_FAILURE);\n          });\n      };\n\n      session.oncancel = (event: unknown) => {\n        this.emitError(ApplePayErrors.paymentError);\n        console.error('apple pay: user cancel payment', event);\n      };\n\n      session.begin();\n    } catch (error: unknown) {\n      console.error('apple pay: checkout error', error);\n      this.emitError(ApplePayErrors.paymentError);\n    }\n  }\n\n  public isDeviceCapable(): boolean {\n    try {\n      return Boolean(\n        this.window.ApplePaySession?.supportsVersion(applePayVersion) &&\n          this.window.ApplePaySession?.canMakePayments()\n      );\n    } catch (error: unknown) {\n      return false;\n    }\n  }\n\n  public getTokenNonceFieldData(tokenNonce: string): {\n    name: string;\n    value: string;\n  } {\n    const name = FieldNames.tokenApplePay;\n    const value = btoa(tokenNonce);\n    return { name, value };\n  }\n\n  public updateApplePayParams(data: unknown): void {\n    const summary = (data as XpsResponse)?.summary;\n    if (!this.applePayParams || !summary) {\n      return;\n    }\n\n    this.applePayParams.totalAmount = this.getTotalAmount(summary);\n    this.applePayParams.currencyCode = this.getTotalCurrency(summary);\n  }\n\n  private async loadBraintree(): Promise<{\n    applePay: typeof applePay;\n    client: typeof client;\n  }> {\n    const api = await import('braintree-web');\n\n    return api;\n  }\n\n  private getAppleToken(formFields: Field[]): string {\n    const appleTokenField = formFields.find((field) => {\n      return field.name === 'token_key';\n    });\n\n    if (!appleTokenField) {\n      return '';\n    }\n\n    return appleTokenField.value;\n  }\n\n  private getTotalAmount(summary: XpsResponse['summary']): string {\n    const finance = summary?.finance;\n    const total = finance?.grand_total?.amount ?? finance?.total.amount;\n\n    return total?.toString() ?? '';\n  }\n\n  private getTotalCurrency(summary: XpsResponse['summary']): string {\n    const finance = summary?.finance;\n    return finance?.grand_total?.currency ?? finance?.total?.currency ?? '';\n  }\n\n  private getJsonValueFromField(\n    fields: {\n      [key: string]: string;\n    },\n    fieldName: string\n  ): string[] | undefined {\n    const field = fields[fieldName];\n\n    try {\n      return field ? (JSON.parse(field) as string[]) : undefined;\n    } catch (error: unknown) {\n      return undefined;\n    }\n  }\n\n  private emitError(error: ApplePayErrors): void {\n    this.error.next(error);\n  }\n\n  private emitIntegrationType(): void {\n    let integrationType: ApplePayIntegration;\n\n    if (this.paymentClient && this.isDeviceCapable()) {\n      integrationType = 'redirect';\n    } else {\n      integrationType = 'none';\n    }\n\n    this.integrationType.next(integrationType);\n  }\n\n  private canUseSdk(): boolean {\n    return !!(\n      this.userAgentService.safariVersion &&\n      this.userAgentService.safariVersion >= safariVersionForIframeIntegration\n    );\n  }\n}\n"]}

package/esm2020/lib/core/sdk-payment-systems/google-pay/google-pay.service.mjs

@@ -0,0 +1,177 @@
+import { Inject, Injectable } from '@angular/core';
+import { BehaviorSubject, filter, take } from 'rxjs';
+import { windowToken } from '../../window.token';
+import { AppError } from '../../exceptions-handling/errors/app-error.class';
+import { CheckStatusActionCreator } from '../../payment/actions/check-status/check-status.action.class';
+import * as i0 from "@angular/core";
+import * as i1 from "../payment-systems/payment-system-processing.service";
+export class GooglePayService {
+    get libraryWasInitialized() {
+        return !!this.window.google;
+    }
+    get googlePaymentClientWasInitialized() {
+        return !!this.googlePaymentClient;
+    }
+    constructor(window, paymentSystemProcessingService, injector) {
+        this.window = window;
+        this.paymentSystemProcessingService = paymentSystemProcessingService;
+        this.injector = injector;
+        this.googlePayScriptUrl = 'https://pay.google.com/gp/p/js/pay.js';
+        this.readyToPay = new BehaviorSubject(null);
+        this.checkout = null;
+        this.googlePaymentClient = null;
+    }
+    get readyToPay$() {
+        return this.readyToPay.asObservable();
+    }
+    isReadyToPay() {
+        return this.readyToPay.getValue();
+    }
+    initGooglePayLibrary(data) {
+        this.isSandbox = data.isSandbox;
+        this.country = data.country;
+        if (this.libraryWasInitialized && this.googlePaymentClientWasInitialized) {
+            return;
+        }
+        if (this.libraryWasInitialized && !this.googlePaymentClientWasInitialized) {
+            this.setupGooglePayClient();
+            return;
+        }
+        this.paymentSystemProcessingService.loadScript(this.googlePayScriptUrl, this.onLoadScript.bind(this));
+    }
+    checkPaymentDevice(base64checkoutData) {
+        this.paymentSystemProcessingService.initialize$
+            .pipe(filter(Boolean), take(1))
+            .subscribe(() => {
+            this.checkout =
+                this.paymentSystemProcessingService.getDecodedCheckout(base64checkoutData);
+            if (!this.checkout || !this.googlePaymentClient) {
+                throw new AppError(`Google Pay: no checkout or google payment client, checkout - ${Boolean(this.checkout).toString()}, client - ${Boolean(this.googlePaymentClient).toString()}`);
+            }
+            const checkoutData = this.checkout.request.form.fields;
+            const isReadyToPayRequest = JSON.parse(checkoutData.isReadyToPayRequest);
+            this.googlePaymentClient
+                .isReadyToPay(isReadyToPayRequest)
+                .then((response) => {
+                if (response.result && this.googlePaymentClient) {
+                    this.googlePaymentClient.prefetchPaymentData(JSON.parse(checkoutData.paymentDataRequest));
+                    return this.readyToPay.next(true);
+                }
+                this.readyToPay.next(false);
+                const result = response.result?.toString() ?? '';
+                const isHavePaymentClient = Boolean(this.googlePaymentClient).toString();
+                throw new Error(`Google Pay: possibly no response.result or googlePaymentClient is missing, result - ${result}, isHavePaymentClient - ${isHavePaymentClient}`);
+            })
+                .catch((error) => {
+                this.readyToPay.next(false);
+                let message = error ?? '';
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                throw new AppError(`Google Pay: device is not ready to pay, ${message}`);
+            });
+        });
+    }
+    async proceedCheckout() {
+        if (!this.checkout || !this.googlePaymentClient) {
+            const isHaveCheckout = !!this.checkout;
+            const isHaveClient = !!this.googlePaymentClient;
+            throw new AppError(`Google Pay: no checkout or google payment client, checkout - ${isHaveCheckout.toString()}, client - ${isHaveClient.toString()}`);
+        }
+        const checkoutData = this.checkout.request.form.fields;
+        const paymentDataRequest = JSON.parse(checkoutData.paymentDataRequest);
+        paymentDataRequest.transactionInfo = {
+            currencyCode: checkoutData.currency,
+            totalPriceStatus: 'FINAL',
+            totalPrice: checkoutData.sum,
+            countryCode: this.country,
+        };
+        const checkStatusAction = this.injector
+            .get(CheckStatusActionCreator)
+            .getActionData();
+        try {
+            const paymentData = await this.googlePaymentClient.loadPaymentData(paymentDataRequest);
+            if (!paymentData?.paymentMethodData?.tokenizationData?.token) {
+                throw new AppError('Google Pay: token is missing');
+            }
+            if (!this.checkout) {
+                throw new AppError('Google Pay: no checkout data in then');
+            }
+            let returnUrl = this.checkout.request.form.fields.returnSuccessUrl;
+            const data = this.checkout.request.form.fields;
+            returnUrl += `&cpf_number=${data.cpf_number}&descriptor=${data.descriptor}&paymentData=${JSON.stringify(paymentData)}`;
+            this.paymentSystemProcessingService.emitStatusUrl(returnUrl);
+            return checkStatusAction;
+        }
+        catch (error) {
+            if (!this.checkout) {
+                throw new AppError(`Google Pay: no checkout data`);
+            }
+            const statusCode = error
+                ?.statusCode;
+            const isStatusCanceled = statusCode && this.isCancelledStatus(statusCode);
+            if (isStatusCanceled) {
+                return null;
+            }
+            const returnUrl = this.checkout.request.form.fields.returnFailUrl;
+            this.paymentSystemProcessingService.emitStatusUrl(returnUrl);
+            return checkStatusAction;
+        }
+    }
+    createButton(onClickHandler, buttonColor = 'default') {
+        if (!this.checkout || !this.googlePaymentClient) {
+            return null;
+        }
+        const checkoutData = this.checkout.request.form.fields;
+        const paymentDataRequest = JSON.parse(checkoutData.paymentDataRequest);
+        return this.googlePaymentClient.createButton({
+            onClick: onClickHandler,
+            allowedPaymentMethods: paymentDataRequest.allowedPaymentMethods,
+            buttonSizeMode: 'fill',
+            buttonType: 'buy',
+            buttonColor,
+        });
+    }
+    setupGooglePayClient() {
+        if (!this.window.google) {
+            return;
+        }
+        const environment = this.isSandbox ? 'TEST' : 'PRODUCTION';
+        this.googlePaymentClient =
+            new this.window.google.payments.api.PaymentsClient({
+                environment,
+            });
+    }
+    onLoadScript() {
+        if (!this.window.google) {
+            const retryTimeout = 1000;
+            setTimeout(() => {
+                const isAvailableGoogleClient = !!this.window.google;
+                if (isAvailableGoogleClient) {
+                    this.setupGooglePayClient();
+                    this.paymentSystemProcessingService.emitInitialize(true);
+                }
+            }, retryTimeout);
+            throw new AppError('Google Pay: google library now is available');
+        }
+        else {
+            this.setupGooglePayClient();
+            this.paymentSystemProcessingService.emitInitialize(true);
+        }
+    }
+    isCancelledStatus(statusCode) {
+        return statusCode.toLowerCase() === 'canceled';
+    }
+}
+GooglePayService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: GooglePayService, deps: [{ token: windowToken }, { token: i1.PaymentSystemProcessingService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+GooglePayService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: GooglePayService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: GooglePayService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [windowToken]
+                }] }, { type: i1.PaymentSystemProcessingService }, { type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"google-pay.service.js","sourceRoot":"","sources":["../../../../../../../packages/payment-client-core/src/lib/core/sdk-payment-systems/google-pay/google-pay.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Injector } from '@angular/core';\nimport { GooglePayCheckout } from './google-pay-checkout.interface';\nimport {\n  GooglePayClient,\n  GooglePayPaymentRequest,\n} from './google-pay-library.interface';\nimport { BehaviorSubject, filter, Observable, take } from 'rxjs';\nimport { PaymentSystemProcessingService } from '../payment-systems/payment-system-processing.service';\nimport { windowToken } from '../../window.token';\nimport { ExtendedWindow } from '../../extended-window.interface';\nimport { AppError } from '../../exceptions-handling/errors/app-error.class';\nimport { GooglePayInitParams } from './google-pay-init-params.interface';\nimport { NextAction } from '../../payment/actions/next-action.interface';\nimport { CheckStatusActionCreator } from '../../payment/actions/check-status/check-status.action.class';\nimport { CheckStatusAction } from '../../payment/actions/check-status/check-status.action.type';\nimport { GooglePayButtonColorType } from './google-pay-button-color.type';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class GooglePayService {\n  private readonly googlePayScriptUrl = 'https://pay.google.com/gp/p/js/pay.js';\n\n  private readonly readyToPay = new BehaviorSubject<boolean | null>(null);\n\n  private checkout: GooglePayCheckout | null = null;\n  private googlePaymentClient: GooglePayClient | null = null;\n\n  private isSandbox!: boolean;\n  private country!: string;\n\n  private get libraryWasInitialized(): boolean {\n    return !!this.window.google;\n  }\n\n  private get googlePaymentClientWasInitialized(): boolean {\n    return !!this.googlePaymentClient;\n  }\n\n  public constructor(\n    @Inject(windowToken) private readonly window: ExtendedWindow,\n    public readonly paymentSystemProcessingService: PaymentSystemProcessingService,\n    public readonly injector: Injector\n  ) {}\n\n  public get readyToPay$(): Observable<boolean | null> {\n    return this.readyToPay.asObservable();\n  }\n\n  public isReadyToPay(): boolean | null {\n    return this.readyToPay.getValue();\n  }\n\n  public initGooglePayLibrary(data: GooglePayInitParams): void {\n    this.isSandbox = data.isSandbox;\n    this.country = data.country;\n\n    if (this.libraryWasInitialized && this.googlePaymentClientWasInitialized) {\n      return;\n    }\n\n    if (this.libraryWasInitialized && !this.googlePaymentClientWasInitialized) {\n      this.setupGooglePayClient();\n      return;\n    }\n\n    this.paymentSystemProcessingService.loadScript(\n      this.googlePayScriptUrl,\n      this.onLoadScript.bind(this)\n    );\n  }\n\n  public checkPaymentDevice(base64checkoutData: string): void {\n    this.paymentSystemProcessingService.initialize$\n      .pipe(filter(Boolean), take(1))\n      .subscribe(() => {\n        this.checkout =\n          this.paymentSystemProcessingService.getDecodedCheckout<GooglePayCheckout>(\n            base64checkoutData\n          );\n\n        if (!this.checkout || !this.googlePaymentClient) {\n          throw new AppError(\n            `Google Pay: no checkout or google payment client, checkout - ${Boolean(\n              this.checkout\n            ).toString()}, client - ${Boolean(\n              this.googlePaymentClient\n            ).toString()}`\n          );\n        }\n\n        const checkoutData = this.checkout.request.form.fields;\n        const isReadyToPayRequest = JSON.parse(\n          checkoutData.isReadyToPayRequest\n        );\n\n        this.googlePaymentClient\n          .isReadyToPay(isReadyToPayRequest)\n          .then((response) => {\n            if (response.result && this.googlePaymentClient) {\n              this.googlePaymentClient.prefetchPaymentData(\n                JSON.parse(checkoutData.paymentDataRequest)\n              );\n\n              return this.readyToPay.next(true);\n            }\n\n            this.readyToPay.next(false);\n            const result = response.result?.toString() ?? '';\n            const isHavePaymentClient = Boolean(\n              this.googlePaymentClient\n            ).toString();\n\n            throw new Error(\n              `Google Pay: possibly no response.result or googlePaymentClient is missing, result - ${result}, isHavePaymentClient - ${isHavePaymentClient}`\n            );\n          })\n          .catch((error) => {\n            this.readyToPay.next(false);\n\n            let message = (error as string) ?? '';\n\n            if (error instanceof Error) {\n              message = error.message;\n            }\n\n            throw new AppError(\n              `Google Pay: device is not ready to pay, ${message}`\n            );\n          });\n      });\n  }\n\n  public async proceedCheckout(): Promise<CheckStatusAction | null> {\n    if (!this.checkout || !this.googlePaymentClient) {\n      const isHaveCheckout = !!this.checkout;\n      const isHaveClient = !!this.googlePaymentClient;\n\n      throw new AppError(\n        `Google Pay: no checkout or google payment client, checkout - ${isHaveCheckout.toString()}, client - ${isHaveClient.toString()}`\n      );\n    }\n\n    const checkoutData = this.checkout.request.form.fields;\n\n    const paymentDataRequest = JSON.parse(\n      checkoutData.paymentDataRequest\n    ) as GooglePayPaymentRequest;\n\n    paymentDataRequest.transactionInfo = {\n      currencyCode: checkoutData.currency,\n      totalPriceStatus: 'FINAL',\n      totalPrice: checkoutData.sum,\n      countryCode: this.country,\n    };\n\n    const checkStatusAction: NextAction = this.injector\n      .get<CheckStatusActionCreator>(CheckStatusActionCreator)\n      .getActionData();\n\n    try {\n      const paymentData = await this.googlePaymentClient.loadPaymentData(\n        paymentDataRequest\n      );\n\n      if (!paymentData?.paymentMethodData?.tokenizationData?.token) {\n        throw new AppError('Google Pay: token is missing');\n      }\n\n      if (!this.checkout) {\n        throw new AppError('Google Pay: no checkout data in then');\n      }\n\n      let returnUrl = this.checkout.request.form.fields.returnSuccessUrl;\n\n      const data = this.checkout.request.form.fields;\n      returnUrl += `&cpf_number=${data.cpf_number}&descriptor=${\n        data.descriptor\n      }&paymentData=${JSON.stringify(paymentData)}`;\n\n      this.paymentSystemProcessingService.emitStatusUrl(returnUrl);\n\n      return checkStatusAction;\n    } catch (error: unknown) {\n      if (!this.checkout) {\n        throw new AppError(`Google Pay: no checkout data`);\n      }\n\n      const statusCode = (error as unknown as { statusCode?: string })\n        ?.statusCode;\n\n      const isStatusCanceled = statusCode && this.isCancelledStatus(statusCode);\n\n      if (isStatusCanceled) {\n        return null;\n      }\n\n      const returnUrl = this.checkout.request.form.fields.returnFailUrl;\n\n      this.paymentSystemProcessingService.emitStatusUrl(returnUrl);\n\n      return checkStatusAction;\n    }\n  }\n\n  public createButton(\n    onClickHandler: () => void,\n    buttonColor: GooglePayButtonColorType = 'default'\n  ): HTMLButtonElement | null {\n    if (!this.checkout || !this.googlePaymentClient) {\n      return null;\n    }\n\n    const checkoutData = this.checkout.request.form.fields;\n    const paymentDataRequest = JSON.parse(\n      checkoutData.paymentDataRequest\n    ) as GooglePayPaymentRequest;\n\n    return this.googlePaymentClient.createButton({\n      onClick: onClickHandler,\n      allowedPaymentMethods: paymentDataRequest.allowedPaymentMethods,\n      buttonSizeMode: 'fill',\n      buttonType: 'buy',\n      buttonColor,\n    });\n  }\n\n  private setupGooglePayClient(): void {\n    if (!this.window.google) {\n      return;\n    }\n\n    const environment = this.isSandbox ? 'TEST' : 'PRODUCTION';\n\n    this.googlePaymentClient =\n      new this.window.google.payments.api.PaymentsClient({\n        environment,\n      });\n  }\n\n  private onLoadScript(): void {\n    if (!this.window.google) {\n      const retryTimeout = 1000;\n\n      setTimeout(() => {\n        const isAvailableGoogleClient = !!this.window.google;\n\n        if (isAvailableGoogleClient) {\n          this.setupGooglePayClient();\n\n          this.paymentSystemProcessingService.emitInitialize(true);\n        }\n      }, retryTimeout);\n\n      throw new AppError('Google Pay: google library now is available');\n    } else {\n      this.setupGooglePayClient();\n\n      this.paymentSystemProcessingService.emitInitialize(true);\n    }\n  }\n\n  private isCancelledStatus(statusCode: string): boolean {\n    return statusCode.toLowerCase() === 'canceled';\n  }\n}\n"]}

package/esm2020/lib/core/sdk-payment-systems/payment-systems/payment-system-processing.service.mjs

@@ -0,0 +1,84 @@
+import { Inject, Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { filter } from 'rxjs/operators';
+import { windowToken } from '../../window.token';
+import { AppError } from '../../exceptions-handling/errors/app-error.class';
+import * as i0 from "@angular/core";
+export class PaymentSystemProcessingService {
+    constructor(window) {
+        this.window = window;
+        this.statusUrl = new BehaviorSubject('');
+        this.initialize = new BehaviorSubject(false);
+    }
+    get initialize$() {
+        return this.initialize.asObservable();
+    }
+    get status$() {
+        return this.statusUrl.asObservable().pipe(filter((status) => !!status));
+    }
+    emitStatusUrl(statusUrl) {
+        this.statusUrl.next(statusUrl);
+    }
+    emitInitialize(isInitialized) {
+        this.initialize.next(isInitialized);
+    }
+    getDecodedCheckout(base64checkoutData) {
+        try {
+            return JSON.parse(atob(base64checkoutData));
+        }
+        catch (error) {
+            throw new AppError('load script service: decode error');
+        }
+    }
+    loadScript(url, onLoad, addScriptCustomAttributes) {
+        this.initialize.next(false);
+        let script = this.window.document.createElement('script');
+        script.async = true;
+        script.src = url;
+        if (addScriptCustomAttributes) {
+            script = addScriptCustomAttributes(script);
+        }
+        this.window.document.body.append(script);
+        script.onload = () => {
+            try {
+                onLoad();
+            }
+            catch (error) {
+                let message = error;
+                if (error instanceof Error) {
+                    message = error.message;
+                }
+                throw new AppError(`Pages: error during script onload handler: ${message}, url - ${url}`);
+            }
+        };
+        script.onerror = (event, source, lineno, colno, error) => {
+            const errorMessage = error ? error.message : '';
+            let eventMessage = event;
+            if (typeof event === 'object') {
+                eventMessage = JSON.stringify(event);
+            }
+            throw new AppError(`Pages: error during script onerror handler:
+        url - ${url},
+        event - ${eventMessage},
+        source - ${source ?? ''},
+        lineno - ${lineno ?? ''},
+        colno - ${colno ?? ''},
+        error - ${errorMessage}`);
+        };
+    }
+    isInitialized() {
+        return this.initialize.getValue();
+    }
+}
+PaymentSystemProcessingService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentSystemProcessingService, deps: [{ token: windowToken }], target: i0.ɵɵFactoryTarget.Injectable });
+PaymentSystemProcessingService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentSystemProcessingService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: PaymentSystemProcessingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [windowToken]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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