solidus_paypal_braintree 0.4.0 → 1.0.0

data/app/assets/javascripts/solidus_paypal_braintree/paypal_messaging.js

@@ -0,0 +1,22 @@
+//= require solidus_paypal_braintree/constants
+
+SolidusPaypalBraintree.PaypalMessaging = function(paypalOptions) {
+  this._paypalOptions = paypalOptions || {};
+
+  this._client = null;
+};
+
+SolidusPaypalBraintree.PaypalMessaging.prototype.initialize = function() {
+  this._client = new SolidusPaypalBraintree.createClient({usePaypal: true});
+
+  return this._client.initialize().then(this.initializeCallback.bind(this));
+};
+
+SolidusPaypalBraintree.PaypalMessaging.prototype.initializeCallback = function() {
+  this._paymentMethodId = this._client.paymentMethodId;
+
+  this._client.getPaypalInstance().loadPayPalSDK({
+    currency: this._paypalOptions.currency,
+    components: "messages"
+  })
+};

data/app/decorators/controllers/solidus_paypal_braintree/admin_payments_controller_decorator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SolidusPaypalBraintree
+  module AdminPaymentsControllerDecorator
+    def self.prepended(base)
+      base.helper ::SolidusPaypalBraintree::BraintreeAdminHelper
+    end
+
+    ::Spree::Admin::PaymentsController.prepend(self)
+  end
+end

data/app/decorators/controllers/solidus_paypal_braintree/checkout_controller_decorator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SolidusPaypalBraintree
+  module CheckoutControllerDecorator
+    def self.prepended(base)
+      base.helper ::SolidusPaypalBraintree::BraintreeCheckoutHelper
+    end
+
+    ::Spree::CheckoutController.prepend(self)
+  end
+end

data/app/decorators/controllers/solidus_paypal_braintree/client_tokens_controller.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module SolidusPaypalBraintree
+  class ClientTokensController < ::Spree::Api::BaseController
+    skip_before_action :authenticate_user
+
+    before_action :load_gateway
+
+    def create
+      token = @gateway.generate_token
+      if token
+        render json: { client_token: token, payment_method_id: @gateway.id }
+      else
+        render json: { error: Gateway::TOKEN_GENERATION_DISABLED_MESSAGE }, status: :unprocessable_entity
+      end
+    end
+
+    private
+
+    def load_gateway
+      if params[:payment_method_id]
+        @gateway = ::SolidusPaypalBraintree::Gateway.find(params[:payment_method_id])
+      else
+        store_payment_methods_scope =
+          if current_store.payment_methods.empty?
+            ::SolidusPaypalBraintree::Gateway.all
+          else
+            ::SolidusPaypalBraintree::Gateway.where(id: current_store.payment_method_ids)
+          end
+        @gateway = ::SolidusPaypalBraintree::Gateway.where(active: true).merge(store_payment_methods_scope).first!
+      end
+    end
+
+    def generate_token
+      @gateway.generate_token
+    rescue ::SolidusPaypalBraintree::Gateway::TokenGenerationDisabledError => e
+      Rails.logger.error e
+      nil
+    end
+  end
+end

data/app/decorators/controllers/solidus_paypal_braintree/orders_controller_decorator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SolidusPaypalBraintree
+  module OrdersControllerDecorator
+    def self.prepended(base)
+      base.helper ::SolidusPaypalBraintree::BraintreeCheckoutHelper
+    end
+
+    ::Spree::OrdersController.prepend(self)
+  end
+end

data/app/decorators/models/solidus_paypal_braintree/spree/store_decorator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SolidusPaypalBraintree
+  module Spree
+    module StoreDecorator
+      def self.prepended(base)
+        base.has_one :braintree_configuration, class_name: "SolidusPaypalBraintree::Configuration", dependent: :destroy
+        base.before_create :build_default_configuration
+      end
+
+      private
+
+      def build_default_configuration
+        build_braintree_configuration unless braintree_configuration
+      end
+
+      ::Spree::Store.prepend self
+    end
+  end
+end

data/app/decorators/models/solidus_paypal_braintree/spree/user_decorator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SolidusPaypalBraintree
+  module Spree
+    module UserDecorator
+      def self.prepended(base)
+        base.has_one :braintree_customer, class_name: 'SolidusPaypalBraintree::Customer', inverse_of: :user
+      end
+
+      ::Spree.user_class.prepend self
+    end
+  end
+end

data/app/helpers/solidus_paypal_braintree/braintree_admin_helper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SolidusPaypalBraintree
+  module BraintreeAdminHelper
+    # Returns a link to the Braintree web UI for the given Braintree payment
+    def braintree_transaction_link(payment)
+      environment = payment.payment_method.preferred_environment == 'sandbox' ? 'sandbox' : 'www'
+      merchant_id = payment.payment_method.preferred_merchant_id
+      response_code = payment.response_code
+
+      return if response_code.blank?
+      return response_code if merchant_id.blank?
+
+      link_to(
+        response_code,
+        "https://#{environment}.braintreegateway.com/merchants/#{merchant_id}/transactions/#{response_code}",
+        title: 'Show payment on Braintree',
+        target: '_blank',
+        rel: 'noopener'
+      )
+    end
+  end
+end

data/app/helpers/solidus_paypal_braintree/braintree_checkout_helper.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module SolidusPaypalBraintree
+  module BraintreeCheckoutHelper
+    def braintree_3ds_options_for(order)
+      ship_address = order.ship_address
+      bill_address = order.bill_address
+
+      {
+        nonce: nil, # populated after tokenization
+        bin: nil, # populated after tokenization
+        onLookupComplete: nil, # populated after tokenization
+        amount: order.total,
+        email: order.email,
+        billingAddress: {
+          givenName: bill_address.firstname,
+          surname: bill_address.lastname,
+          phoneNumber: bill_address.phone,
+          streetAddress: bill_address.address1,
+          extendedAddress: bill_address.address2,
+          locality: bill_address.city,
+          region: bill_address.state&.name,
+          postalCode: bill_address.zipcode,
+          countryCodeAlpha2: bill_address.country&.iso,
+        },
+        additionalInformation: {
+          shippingGivenName: ship_address.firstname,
+          shippingSurname: ship_address.lastname,
+          shippingPhone: ship_address.phone,
+          shippingAddress: {
+            streedAddress: ship_address.address1,
+            extendedAddress: ship_address.address2,
+            locality: ship_address.city,
+            region: ship_address.state&.name,
+            postalCode: ship_address.zipcode,
+            countryCodeAlpha2: ship_address.country&.iso,
+          }
+        }
+      }
+    end
+
+    def paypal_button_preference(key, store:)
+      store.braintree_configuration.preferences[key]
+    end
+  end
+end

data/app/models/application_record.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class ApplicationRecord < ActiveRecord::Base
   self.abstract_class = true
 end

data/app/models/solidus_paypal_braintree/address.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SolidusPaypalBraintree
+  class Address
+    def initialize(spree_address)
+      @spree_address = spree_address
+    end
+
+    def to_json(*_args)
+      address_hash = {
+        line1: spree_address.address1,
+        line2: spree_address.address2,
+        city: spree_address.city,
+        postalCode: spree_address.zipcode,
+        countryCode: spree_address.country.iso,
+        phone: spree_address.phone,
+        recipientName: spree_address.full_name
+      }
+
+      if ::Spree::Config.address_requires_state && spree_address.country.states_required
+        address_hash[:state] = spree_address.state.name
+      end
+      address_hash.to_json
+    end
+
+    private
+
+    attr_reader :spree_address
+  end
+end

data/app/models/solidus_paypal_braintree/configuration.rb

@@ -1,5 +1,28 @@
-class SolidusPaypalBraintree::Configuration < ApplicationRecord
-  belongs_to :store, class_name: 'Spree::Store'
+# frozen_string_literal: true
 
-  validates :store, presence: true
+module SolidusPaypalBraintree
+  class Configuration < ::Spree::Base
+    PAYPAL_BUTTON_PREFERENCES = {
+      color: { availables: %w[gold blue silver white black], default: 'white' },
+      shape: { availables: %w[pill rect], default: 'rect' },
+      label: { availables: %w[checkout credit pay buynow paypal installment], default: 'checkout' },
+      tagline: { availables: %w[true false], default: 'false' },
+      layout: { availables: %w[horizontal vertical], default: 'horizontal' },
+      messaging: { availables: %w[true false], default: 'false' }
+    }.freeze
+
+    belongs_to :store, class_name: 'Spree::Store'
+
+    validates :store, presence: true
+
+    # Preferences for Paypal button
+    PAYPAL_BUTTON_PREFERENCES.each do |name, desc|
+      preference_name = "paypal_button_#{name}".to_sym
+      attribute_name = "preferred_#{preference_name}".to_sym
+
+      preference preference_name, :string, default: desc[:default]
+
+      validates attribute_name, inclusion: desc[:availables]
+    end
+  end
 end

data/app/models/solidus_paypal_braintree/customer.rb

@@ -1,4 +1,8 @@
-class SolidusPaypalBraintree::Customer < ApplicationRecord
-  belongs_to :user, class_name: Spree::UserClassHandle.new
-  has_many :sources, class_name: "SolidusPaypalBraintree::Source", inverse_of: :customer
+# frozen_string_literal: true
+
+module SolidusPaypalBraintree
+  class Customer < ApplicationRecord
+    belongs_to :user, class_name: ::Spree::UserClassHandle.new, optional: true
+    has_many :sources, class_name: "SolidusPaypalBraintree::Source", inverse_of: :customer, dependent: :destroy
+  end
 end

data/app/models/solidus_paypal_braintree/gateway.rb

@@ -1,22 +1,26 @@
+# frozen_string_literal: true
+
 require 'braintree'
 
 module SolidusPaypalBraintree
   class Gateway < ::Spree::PaymentMethod
     include RequestProtection
 
+    class TokenGenerationDisabledError < StandardError; end
+
     # Error message from Braintree that gets returned by a non voidable transaction
-    NON_VOIDABLE_STATUS_ERROR_REGEXP = /can only be voided if status is authorized/
+    NON_VOIDABLE_STATUS_ERROR_REGEXP = /can only be voided if status is authorized/.freeze
 
     TOKEN_GENERATION_DISABLED_MESSAGE = 'Token generation is disabled.' \
       ' To re-enable set the `token_generation_enabled` preference on the' \
-      ' gateway to `true`.'.freeze
+      ' gateway to `true`.'
 
     ALLOWED_BRAINTREE_OPTIONS = [
       :device_data,
       :device_session_id,
       :merchant_account_id,
       :order_id
-    ]
+    ].freeze
 
     VOIDABLE_STATUSES = [
       Braintree::Transaction::Status::SubmittedForSettlement,
@@ -35,9 +39,22 @@ module SolidusPaypalBraintree
     preference(:merchant_id, :string, default: nil)
     preference(:public_key,  :string, default: nil)
     preference(:private_key, :string, default: nil)
+    preference(:http_open_timeout, :integer, default: 60)
+    preference(:http_read_timeout, :integer, default: 60)
     preference(:merchant_currency_map, :hash, default: {})
     preference(:paypal_payee_email_map, :hash, default: {})
 
+    # Which checkout flow to use (vault/checkout)
+    preference(:paypal_flow, :string, default: 'vault')
+
+    # A hash that gets passed to the `style` key when initializing the credit card fields.
+    # See https://developers.braintreepayments.com/guides/hosted-fields/styling/javascript/v3
+    preference(:credit_card_fields_style, :hash, default: {})
+
+    # A hash that gets its keys passed to the associated braintree field placeholder tag.
+    # Example: { number: "Enter card number", cvv: "Enter CVV", expirationDate: "mm/yy" }
+    preference(:placeholder_text, :hash, default: {})
+
     def partial_name
       "paypal_braintree"
     end
@@ -57,6 +74,8 @@ module SolidusPaypalBraintree
         merchant_id: preferred_merchant_id,
         public_key: preferred_public_key,
         private_key: preferred_private_key,
+        http_open_timeout: preferred_http_open_timeout,
+        http_read_timeout: preferred_http_read_timeout,
         logger: logger
       }
     end
@@ -73,7 +92,7 @@ module SolidusPaypalBraintree
       protected_request do
         result = braintree.transaction.sale(
           amount: dollars(money_cents),
-          **transaction_options(source, gateway_options, true)
+          **transaction_options(source, gateway_options, submit_for_settlement: true)
         )
 
         Response.build(result)
@@ -200,7 +219,7 @@ module SolidusPaypalBraintree
       return if source.token.present? || source.customer.present? || source.nonce.nil?
 
       result = braintree.customer.create(customer_profile_params(payment))
-      fail Spree::Core::GatewayError, result.message unless result.success?
+      fail ::Spree::Core::GatewayError, result.message unless result.success?
 
       customer = result.customer
 
@@ -213,12 +232,12 @@ module SolidusPaypalBraintree
       end
     end
 
+    # @raise [TokenGenerationDisabledError]
+    #   If `preferred_token_generation_enabled` is false
+    #
     # @return [String]
     #   The token that should be used along with the Braintree js-client sdk.
     #
-    #   returns an error message if `preferred_token_generation_enabled` is
-    #   set to false.
-    #
     # @example
     #   <script>
     #     var token = #{Spree::Braintree::Gateway.first!.generate_token}
@@ -233,7 +252,10 @@ module SolidusPaypalBraintree
     #     );
     #   </script>
     def generate_token
-      return TOKEN_GENERATION_DISABLED_MESSAGE unless preferred_token_generation_enabled
+      unless preferred_token_generation_enabled
+        raise TokenGenerationDisabledError, TOKEN_GENERATION_DISABLED_MESSAGE
+      end
+
       braintree.client_token.generate
     end
 
@@ -261,6 +283,12 @@ module SolidusPaypalBraintree
 
     private
 
+    # Whether to store this payment method in the PayPal Vault. This only works when the checkout
+    # flow is "vault", so make sure to call +super+ if you override it.
+    def store_in_vault
+      preferred_paypal_flow == 'vault'
+    end
+
     def logger
       Braintree::Configuration.logger.clone.tap do |logger|
         logger.level = Rails.logger.level
@@ -279,20 +307,24 @@ module SolidusPaypalBraintree
       JSON.parse(preference_string.gsub("=>", ":"))
     end
 
-    def convert_preference_value(value, type)
+    def convert_preference_value(value, type, preference_encryptor = nil)
       if type == :hash && value.is_a?(String)
         value = to_hash(value)
       end
-      super
+      if method(__method__).super_method.arity == 3
+        super
+      else
+        super(value, type)
+      end
     end
 
-    def transaction_options(source, options, submit_for_settlement = false)
+    def transaction_options(source, options, submit_for_settlement: false)
       params = options.select do |key, _|
         ALLOWED_BRAINTREE_OPTIONS.include?(key)
       end
 
       params[:channel] = "Solidus"
-      params[:options] = { store_in_vault_on_success: true }
+      params[:options] = { store_in_vault_on_success: store_in_vault }
 
       if submit_for_settlement
         params[:options][:submit_for_settlement] = true
@@ -349,21 +381,21 @@ module SolidusPaypalBraintree
     end
 
     def merchant_account_for(_source, options)
-      if options[:currency]
-        preferred_merchant_currency_map[options[:currency]]
-      end
+      return unless options[:currency]
+
+      preferred_merchant_currency_map[options[:currency]]
     end
 
     def paypal_payee_email_for(source, options)
-      if source.paypal?
-        preferred_paypal_payee_email_map[options[:currency]]
-      end
+      return unless source.paypal?
+
+      preferred_paypal_payee_email_map[options[:currency]]
     end
 
     def customer_profile_params(payment)
       params = {}
 
-      if payment.source.try(:nonce)
+      if store_in_vault && payment.source.try(:nonce)
         params[:payment_method_nonce] = payment.source.nonce
       end