'use strict';
var analytics = require('../lib/analytics');
var assign = require('../lib/assign').assign;
var convertMethodsToError = require('../lib/convert-methods-to-error');
var find = require('../lib/find');
var generateGooglePayConfiguration = require('../lib/generate-google-pay-configuration');
var BraintreeError = require('../lib/braintree-error');
var errors = require('./errors');
var methods = require('../lib/methods');
var Promise = require('../lib/promise');
var wrapPromise = require('@braintree/wrap-promise');
var DEFAULT_CARD_NETWORKS = ['AMEX', 'DISCOVER', 'MASTERCARD', 'VISA'];
/**
* @typedef {object} GooglePayment~tokenizePayload
* @property {string} nonce The payment method nonce.
* @property {object} details Additional account details.
* @property {string} details.cardType Type of card, ex: Visa, MasterCard.
* @property {string} details.lastFour Last four digits of card number.
* @property {string} details.lastTwo Last two digits of card number.
* @property {string} description A human-readable description.
* @property {string} type The payment method type, `CreditCard` or `AndroidPayCard`.
* @property {object} binData Information about the card based on the bin.
* @property {string} binData.commercial Possible values: 'Yes', 'No', 'Unknown'.
* @property {string} binData.countryOfIssuance The country of issuance.
* @property {string} binData.debit Possible values: 'Yes', 'No', 'Unknown'.
* @property {string} binData.durbinRegulated Possible values: 'Yes', 'No', 'Unknown'.
* @property {string} binData.healthcare Possible values: 'Yes', 'No', 'Unknown'.
* @property {string} binData.issuingBank The issuing bank.
* @property {string} binData.payroll Possible values: 'Yes', 'No', 'Unknown'.
* @property {string} binData.prepaid Possible values: 'Yes', 'No', 'Unknown'.
* @property {string} binData.productId The product id.
*/
/**
* @class GooglePayment
* @param {object} options Google Payment {@link module:braintree-web/google-payment.create create} options.
* @description <strong>Do not use this constructor directly. Use {@link module:braintree-web/google-payment.create|braintree-web.google-payment.create} instead.</strong>
* @classdesc This class represents a Google Payment component produced by {@link module:braintree-web/google-payment.create|braintree-web/google-payment.create}. Instances of this class have methods for initializing the Google Pay flow.
*/
function GooglePayment(options) {
this._client = options.client;
this._googlePayVersion = options.googlePayVersion || 1;
this._googleMerchantId = options.googleMerchantId;
}
GooglePayment.prototype._createV1PaymentDataRequest = function (defaultConfig, paymentDataRequest) {
var overrideCardNetworks = paymentDataRequest.cardRequirements && paymentDataRequest.cardRequirements.allowedCardNetworks;
var defaultConfigCardNetworks = defaultConfig.cardRequirements.allowedCardNetworks;
var allowedCardNetworks = overrideCardNetworks || defaultConfigCardNetworks;
paymentDataRequest = assign({}, defaultConfig, paymentDataRequest);
// this way we can preserve allowedCardNetworks from default integration
// if merchant did not pass any in `cardRequirements`
paymentDataRequest.cardRequirements.allowedCardNetworks = allowedCardNetworks;
return paymentDataRequest;
};
GooglePayment.prototype._createV2PaymentDataRequest = function (defaultConfig, paymentDataRequest) {
var newCardPaymentMethod, defaultConfigCardPaymentMethod, parameters;
var defaultConfigPaymentMethods = defaultConfig.allowedPaymentMethods;
// For the CARD allowed payment method, ensure allowedCardNetworks is set.
if (paymentDataRequest.allowedPaymentMethods) {
newCardPaymentMethod = find(paymentDataRequest.allowedPaymentMethods, 'type', 'CARD');
defaultConfigCardPaymentMethod = find(defaultConfigPaymentMethods, 'type', 'CARD');
if (newCardPaymentMethod) {
newCardPaymentMethod.parameters = assign({}, newCardPaymentMethod.parameters);
parameters = newCardPaymentMethod.parameters;
if (!parameters.allowedCardNetworks || (parameters.allowedCardNetworks && parameters.allowedCardNetworks.length === 0)) {
if (defaultConfigCardPaymentMethod &&
defaultConfigCardPaymentMethod.parameters &&
defaultConfigCardPaymentMethod.parameters.allowedCardNetworks
) {
parameters.allowedCardNetworks = defaultConfigCardPaymentMethod.parameters.allowedCardNetworks;
} else {
parameters.allowedCardNetworks = DEFAULT_CARD_NETWORKS;
}
}
}
}
paymentDataRequest = assign({}, defaultConfig, paymentDataRequest);
return paymentDataRequest;
};
/**
* Create a configuration object for use in the `loadPaymentData` method.
*
* **Note**: Version 1 of the Google Pay Api is deprecated and will become unsupported in a future version. Until then, version 1 will continue to be used by default, and version 1 schema parameters and overrides will remain functional on existing integrations. However, new integrations and all following examples will be presented in the GooglePay version 2 schema. See [Google Pay's upgrade guide](https://developers.google.com/pay/api/web/guides/resources/update-to-latest-version) to see how to update your integration.
*
* If `options.googlePayVersion === 2` was set during the initial {@link module:braintree-web/google-payment.create|create} call, overrides must match the Google Pay v2 schema to be valid.
*
* @public
* @param {object} overrides The supplied parameters for creating the PaymentDataRequest object. Required parameters are:
* @param {object} overrides.transactionInfo Object according to the [Google Pay Transaction Info](https://developers.google.com/pay/api/web/reference/object#TransactionInfo) spec.
* Optionally, any of the parameters in the [PaymentDataRequest](https://developers.google.com/pay/api/web/reference/object#PaymentDataRequest) parameters can be overridden, but note that it is recommended only to override top level parameters to avoid squashing deeply nested configuration objects. An example can be found below showing how to safely edit these deeply nested objects.
* @example
* var paymentDataRequest = googlePaymentInstance.createPaymentDataRequest({
* merchantInfo: {
* merchantId: 'my-merchant-id-from-google'
* },
* transactionInfo: {
* currencyCode: 'USD',
* totalPriceStatus: 'FINAL',
* totalPrice: '100.00'
* }
* });
*
* // Update all payment methods to require billing address
* paymentDataRequest.allowedPaymentMethods.map(function (paymentMethod) {
* paymentMethod.parameters.billingAddressRequired = true;
* paymentMethod.parameters.billingAddressParameters = {
* format: 'FULL',
* phoneNumberRequired: true
* };
*
* return paymentMethod;
* });
*
* var paymentsClient = new google.payments.api.PaymentsClient({
* environment: 'TEST' // or 'PRODUCTION'
* })
*
* paymentsClient.loadPaymentData(paymentDataRequest).then(function (response) {
* // handle response with googlePaymentInstance.parseResponse
* // (see below)
* });
* @returns {object} Returns a configuration object for Google PaymentDataRequest.
*/
GooglePayment.prototype.createPaymentDataRequest = function (overrides) {
var paymentDataRequest = assign({}, overrides);
var defaultConfig = generateGooglePayConfiguration(this._client.getConfiguration(), this._googlePayVersion, this._googleMerchantId);
// Default to using v1 config. If apiVersion is specifically set to 2, use v2 config.
if (this._googlePayVersion === 2) {
paymentDataRequest = this._createV2PaymentDataRequest(defaultConfig, paymentDataRequest);
analytics.sendEvent(this._client, 'google-payment.v2.createPaymentDataRequest');
} else {
paymentDataRequest = this._createV1PaymentDataRequest(defaultConfig, paymentDataRequest);
analytics.sendEvent(this._client, 'google-payment.v1.createPaymentDataRequest');
}
return paymentDataRequest;
};
/**
* Parse the response from the tokenization.
* @public
* @param {object} response The response back from the Google Pay tokenization.
* @param {callback} [callback] The second argument, <code>data</code>, is a {@link GooglePay~tokenizePayload|tokenizePayload}. If no callback is provided, `parseResponse` returns a promise that resolves with a {@link GooglePayment~tokenizePayload|tokenizePayload}.
* @example with callback
* var paymentsClient = new google.payments.api.PaymentsClient({
* environment: 'TEST' // or 'PRODUCTION'
* })
*
* paymentsClient.loadPaymentData(paymentDataRequestFromCreatePaymentDataRequest).then(function (response) {
* googlePaymentInstance.parseResponse(response, function (err, data) {
* if (err) {
* // handle errors
* }
* // send parsedResponse.nonce to your server
* });
* });
* @example with promise
* var paymentsClient = new google.payments.api.PaymentsClient({
* environment: 'TEST' // or 'PRODUCTION'
* })
*
* paymentsClient.loadPaymentData(paymentDataRequestFromCreatePaymentDataRequest).then(function (response) {
* return googlePaymentInstance.parseResponse(response);
* }).then(function (parsedResponse) {
* // send parsedResponse.nonce to your server
* }).catch(function (err) {
* // handle errors
* });
* @returns {Promise|void} Returns a promise that resolves the parsed response if no callback is provided.
*/
GooglePayment.prototype.parseResponse = function (response) {
var client = this._client;
return Promise.resolve().then(function () {
var payload;
var rawResponse = response.apiVersion === 2 ?
response.paymentMethodData.tokenizationData.token :
response.paymentMethodToken.token;
var parsedResponse = JSON.parse(rawResponse);
var error = parsedResponse.error;
if (error) {
return Promise.reject(error);
}
analytics.sendEvent(client, 'google-payment.parseResponse.succeeded');
if (parsedResponse.paypalAccounts) {
payload = parsedResponse.paypalAccounts[0];
analytics.sendEvent(client, 'google-payment.parseResponse.succeeded.paypal');
return Promise.resolve({
nonce: payload.nonce,
type: payload.type,
description: payload.description
});
}
payload = parsedResponse.androidPayCards[0];
analytics.sendEvent(client, 'google-payment.parseResponse.succeeded.google-payment');
return Promise.resolve({
nonce: payload.nonce,
type: payload.type,
description: payload.description,
details: {
cardType: payload.details.cardType,
lastFour: payload.details.lastFour,
lastTwo: payload.details.lastTwo
},
binData: payload.binData
});
}).catch(function (error) {
analytics.sendEvent(client, 'google-payment.parseResponse.failed');
return Promise.reject(new BraintreeError({
code: errors.GOOGLE_PAYMENT_GATEWAY_ERROR.code,
message: errors.GOOGLE_PAYMENT_GATEWAY_ERROR.message,
type: errors.GOOGLE_PAYMENT_GATEWAY_ERROR.type,
details: {
originalError: error
}
}));
});
};
/**
* Cleanly tear down anything set up by {@link module:braintree-web/google-payment.create|create}.
* @public
* @param {callback} [callback] Called once teardown is complete. No data is returned if teardown completes successfully.
* @example
* googlePaymentInstance.teardown();
* @example <caption>With callback</caption>
* googlePaymentInstance.teardown(function () {
* // teardown is complete
* });
* @returns {Promise|void} Returns a promise if no callback is provided.
*/
GooglePayment.prototype.teardown = function () {
convertMethodsToError(this, methods(GooglePayment.prototype));
return Promise.resolve();
};
module.exports = wrapPromise.wrapPrototype(GooglePayment);