solidus_paypal_braintree 0.4.0 → 1.1.1

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
+                                        ' To re-enable set the `token_generation_enabled` preference on the' \
+                                        ' 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,37 @@ 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: {})
+
+    # Wether to use the JS device data collector
+    preference(:use_data_collector, :boolean, default: true)
+
+    # Useful for testing purposes, as PayPal will show funding sources based on the buyer's country;
+    # usually retrieved by their  ip geolocation. I.e. Venmo will show for US buyers, but not European.
+    preference(:force_buyer_country, :string)
+
+    preference(:enable_venmo_funding, :boolean, default: false)
+
+    # When on mobile, paying with Venmo, the user may be returned to the same store tab
+    # depending on if their browser supports it, otherwise a new tab will be created
+    # However, returning to a new tab may break the payment checkout flow for some stores, for example,
+    # if they are single-page applications (SPA). Set this to false if this is the case
+    preference(:venmo_new_tab_support, :boolean, default: true)
+
     def partial_name
       "paypal_braintree"
     end
@@ -57,6 +89,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 +107,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 +234,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 +247,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 +267,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 +298,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 +322,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
@@ -302,6 +349,10 @@ module SolidusPaypalBraintree
         params[:options][:paypal] = { payee_email: paypal_email }
       end
 
+      if source.venmo? && venmo_business_profile_id
+        params[:options][:venmo] = { profile_id: venmo_business_profile_id }
+      end
+
       if merchant_account_id = merchant_account_for(source, options)
         params[:merchant_account_id] = merchant_account_id
       end
@@ -349,25 +400,33 @@ 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)
+      params[:email] = payment&.order&.email
+
+      if store_in_vault && payment.source.try(:nonce)
         params[:payment_method_nonce] = payment.source.nonce
       end
 
       params
     end
+
+    # override with the Venmo business profile that you want to use for transactions,
+    # or leave it to be nil if want Braintree to use your default account
+    def venmo_business_profile_id
+      nil
+    end
   end
 end

data/app/models/solidus_paypal_braintree/response.rb

@@ -27,7 +27,7 @@ module SolidusPaypalBraintree
         transaction = result.transaction
         options = response_options(transaction).update(
           # For error responses we want to have the CVV code
-          cvv_result: transaction.try!(:cvv_response_code)
+          cvv_result: transaction&.cvv_response_code
         )
         new(false, error_message(result), result.params, options)
       end
@@ -35,6 +35,7 @@ module SolidusPaypalBraintree
       def response_options(transaction)
         # Some error responses do not have a transaction
         return {} if transaction.nil?
+
         {
           authorization: transaction.id,
           avs_result: SolidusPaypalBraintree::AVSResult.build(transaction),
@@ -67,7 +68,7 @@ module SolidusPaypalBraintree
         when 'settlement_declined'
           I18n.t(transaction.processor_settlement_response_code,
             scope: 'solidus_paypal_braintree.processor_settlement_response_codes',
-            default: "#{transaction.processor_settlement_response_text} (#{transaction.processor_settlement_response_code})")
+            default: "#{transaction.processor_settlement_response_text} (#{transaction.processor_settlement_response_code})") # rubocop:disable Layout/LineLength
         else
           I18n.t(transaction.status,
             scope: 'solidus_paypal_braintree.transaction_statuses',

data/app/models/solidus_paypal_braintree/source.rb

@@ -1,24 +1,41 @@
+# frozen_string_literal: true
+
 module SolidusPaypalBraintree
   class Source < SolidusSupport.payment_source_parent_class
     include RequestProtection
 
     PAYPAL = "PayPalAccount"
     APPLE_PAY = "ApplePayCard"
+    VENMO = "VenmoAccount"
     CREDIT_CARD = "CreditCard"
 
-    belongs_to :user, class_name: Spree::UserClassHandle.new
+    enum paypal_funding_source: {
+      applepay: 0, bancontact: 1, blik: 2, boleto: 3, card: 4, credit: 5, eps: 6, giropay: 7, ideal: 8,
+      itau: 9, maxima: 10, mercadopago: 11, mybank: 12, oxxo: 13, p24: 14, paylater: 15, paypal: 16, payu: 17,
+      sepa: 18, sofort: 19, trustly: 20, venmo: 21, verkkopankki: 22, wechatpay: 23, zimpler: 24
+    }, _suffix: :funding
+
+    belongs_to :user, class_name: ::Spree::UserClassHandle.new, optional: true
     belongs_to :payment_method, class_name: 'Spree::PaymentMethod'
-    has_many :payments, as: :source, class_name: "Spree::Payment"
+    has_many :payments, as: :source, class_name: "Spree::Payment", dependent: :destroy
 
-    belongs_to :customer, class_name: "SolidusPaypalBraintree::Customer"
+    belongs_to :customer, class_name: "SolidusPaypalBraintree::Customer", optional: true
 
-    validates :payment_type, inclusion: [PAYPAL, APPLE_PAY, CREDIT_CARD]
+    validates :payment_type, inclusion: [PAYPAL, APPLE_PAY, VENMO, CREDIT_CARD]
+
+    before_save :clear_paypal_funding_source, unless: :paypal?
 
     scope(:with_payment_profile, -> { joins(:customer) })
     scope(:credit_card, -> { where(payment_type: CREDIT_CARD) })
 
-    delegate :last_4, :card_type, to: :braintree_payment_method, allow_nil: true
+    delegate :last_4, :card_type, :expiration_month, :expiration_year, :email,
+      :username, :source_description, to: :braintree_payment_method, allow_nil: true
+
+    # Aliases to match Spree::CreditCard's interface
     alias_method :last_digits, :last_4
+    alias_method :month, :expiration_month
+    alias_method :year, :expiration_year
+    alias_method :cc_type, :card_type
 
     # we are not currenctly supporting an "imported" flag
     def imported
@@ -35,6 +52,7 @@ module SolidusPaypalBraintree
 
     def can_void?(payment)
       return false unless payment.response_code
+
       transaction = protected_request do
         braintree_client.transaction.find(payment.response_code)
       end
@@ -59,8 +77,12 @@ module SolidusPaypalBraintree
       payment_type == PAYPAL
     end
 
+    def venmo?
+      payment_type == VENMO
+    end
+
     def reusable?
-      true
+      token.present?
     end
 
     def credit_card?
@@ -68,13 +90,30 @@ module SolidusPaypalBraintree
     end
 
     def display_number
-      "XXXX-XXXX-XXXX-#{last_digits.to_s.rjust(4, 'X')}"
+      if paypal?
+        email
+      elsif venmo?
+        username
+      else
+        "XXXX-XXXX-XXXX-#{last_digits.to_s.rjust(4, 'X')}"
+      end
+    end
+
+    def display_paypal_funding_source
+      I18n.t(paypal_funding_source,
+        scope: 'solidus_paypal_braintree.paypal_funding_sources',
+        default: paypal_funding_source)
+    end
+
+    def display_payment_type
+      "#{I18n.t('solidus_paypal_braintree.payment_type.label')}: #{friendly_payment_type}"
     end
 
     private
 
     def braintree_payment_method
-      return unless braintree_client && credit_card?
+      return unless braintree_client
+
       @braintree_payment_method ||= protected_request do
         braintree_client.payment_method.find(token)
       end
@@ -86,5 +125,9 @@ module SolidusPaypalBraintree
     def braintree_client
       @braintree_client ||= payment_method.try(:braintree)
     end
+
+    def clear_paypal_funding_source
+      self.paypal_funding_source = nil
+    end
   end
 end

data/app/models/solidus_paypal_braintree/transaction.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'active_model'
 
 module SolidusPaypalBraintree
   class Transaction
     include ActiveModel::Model
 
-    attr_accessor :nonce, :payment_method, :payment_type, :address, :email, :phone
+    attr_accessor :nonce, :payment_method, :payment_type, :paypal_funding_source, :address, :email, :phone
 
     validates :nonce, presence: true
     validates :payment_method, presence: true
@@ -16,8 +18,8 @@ module SolidusPaypalBraintree
         errors.add(:payment_method, 'Must be braintree')
       end
       if address && !address.valid?
-        address.errors.each do |field, error|
-          errors.add(:address, "#{field} #{error}")
+        address.errors.each do |error|
+          errors.add(:address, error.full_message)
         end
       end
     end

data/app/models/solidus_paypal_braintree/transaction_address.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_model'
 
 module SolidusPaypalBraintree
@@ -6,11 +8,11 @@ module SolidusPaypalBraintree
     include ActiveModel::Validations::Callbacks
     include SolidusPaypalBraintree::CountryMapper
 
-    attr_accessor :country_code, :last_name, :first_name,
-      :city, :zip, :state_code, :address_line_1, :address_line_2
+    attr_accessor :country_code, :name, :city, :zip, :state_code,
+      :address_line_1, :address_line_2, :first_name, :last_name
 
-    validates :first_name, :last_name, :address_line_1, :city, :zip,
-      :country_code, presence: true
+    validates :address_line_1, :city, :zip, :country_code, presence: true
+    validates :name, presence: true, unless: ->(address){ address.first_name.present? }
 
     before_validation do
       self.country_code = country_code.presence || "us"
@@ -29,25 +31,45 @@ module SolidusPaypalBraintree
     end
 
     def spree_country
-      country_code && (@country ||= Spree::Country.find_by(iso: country_code.upcase))
+      country_code && (@country ||= ::Spree::Country.find_by(iso: country_code.upcase))
     end
 
     def spree_state
-      spree_country && state_code && ( @state ||= spree_country.states.where(
-        Spree::State.arel_table[:name].matches(state_code).or(
-          Spree::State.arel_table[:abbr].matches(state_code)
+      spree_country && state_code && ( @state ||= spree_country.states.find_by(
+        ::Spree::State.arel_table[:name].matches(state_code).or(
+          ::Spree::State.arel_table[:abbr].matches(state_code)
         )
-      ).first )
+      ))
     end
 
     def to_spree_address
-      address = Spree::Address.new first_name: first_name,
-        last_name: last_name,
+      address = ::Spree::Address.new(
         city: city,
         country: spree_country,
         address1: address_line_1,
         address2: address_line_2,
         zipcode: zip
+      )
+
+      if SolidusSupport.combined_first_and_last_name_in_address?
+        address.name = begin
+          if first_name.nil?
+            name
+          else
+            [first_name, last_name].join(" ")
+          end
+        end
+      else
+        ::Spree::Deprecation.warn("first_name and last_name are deprecated. Use name instead.", caller)
+        if first_name.nil?
+          first, last = SolidusPaypalBraintree::Address.split_name(name)
+          address.firstname = first
+          address.lastname = last || "(left blank)"
+        else
+          address.firstname = first_name
+          address.lastname = last_name || "(left blank)"
+        end
+      end
 
       if spree_state
         address.state = spree_state
@@ -59,7 +81,7 @@ module SolidusPaypalBraintree
 
     # Check to see if this address should match to a state model in the database
     def should_match_state_model?
-      spree_country.try!(:states_required?)
+      spree_country&.states_required?
     end
   end
 end

data/app/models/solidus_paypal_braintree/transaction_import.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_model'
 
 module SolidusPaypalBraintree
@@ -10,8 +12,8 @@ module SolidusPaypalBraintree
       errors.add("Address", "is invalid") if address && !address.valid?
 
       if !transaction.valid?
-        transaction.errors.each do |field, error|
-          errors.add(field, error)
+        transaction.errors.each do |error|
+          errors.add(error.attribute, error.message)
         end
       end
       errors.none?
@@ -25,30 +27,33 @@ module SolidusPaypalBraintree
     end
 
     def source
-      SolidusPaypalBraintree::Source.new nonce: transaction.nonce,
+      SolidusPaypalBraintree::Source.new(
+        nonce: transaction.nonce,
         payment_type: transaction.payment_type,
         payment_method: transaction.payment_method,
+        paypal_funding_source: transaction.paypal_funding_source,
         user: user
+      )
     end
 
-    def user
-      order.user
-    end
+    delegate :user, to: :order
 
     def import!(end_state, restart_checkout: false)
       if valid?
-        order.email = user.try!(:email) || transaction.email
+        order.email = user&.email || transaction.email
 
         if address
           order.shipping_address = order.billing_address = address
           # work around a bug in most solidus versions
           # about tax zone cachine between address changes
-          order.instance_variable_set("@tax_zone", nil)
+          order.instance_variable_set(:@tax_zone, nil)
         end
 
-        payment = order.payments.new source: source,
+        payment = order.payments.new(
+          source: source,
           payment_method: transaction.payment_method,
           amount: order.total
+        )
 
         order.save!
         order.restart_checkout_flow if restart_checkout
@@ -85,9 +90,9 @@ module SolidusPaypalBraintree
       payment_total = order.payments.where(state: %w[checkout pending]).sum(:amount)
       payment_difference = order.outstanding_balance - payment_total
 
-      if payment_difference != 0
-        payment.update!(amount: payment.amount + payment_difference)
-      end
+      return unless payment_difference != 0
+
+      payment.update!(amount: payment.amount + payment_difference)
     end
   end
 end

data/app/overrides/spree/payments/payment/add_paypal_funding_source_to_payment.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+Deface::Override.new(
+  name: "payments/payment/add_paypal_funding_source_to_payment",
+  virtual_path: "spree/payments/_payment",
+  original: "0b5b5ae53626059cb3a202ef95d10827dd399925",
+  insert_after: "erb[loud]:contains('content_tag(:span, payment.payment_method.name)')",
+  partial: "solidus_paypal_braintree/payments/payment"
+)

data/app/views/spree/api/payments/source_views/_paypal_braintree.json.jbuilder

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+json.call(payment_source, :id, :token, :created_at)

data/app/views/spree/checkout/existing_payment/_paypal_braintree.html.erb

@@ -0,0 +1,10 @@
+<tr id="<%= dom_id(wallet_payment_source, 'spree')%>" class="<%= cycle('even', 'odd') %>">
+  <td>
+    <%= radio_button_tag "order[wallet_payment_source_id]",
+                          wallet_payment_source.id,
+                          default,
+                          class: "existing-cc-radio" %>
+  </td>
+  <td><%= wallet_payment_source.payment_source.friendly_payment_type %></td>
+  <td><%= wallet_payment_source.payment_source.display_number %></td>
+</tr>

data/app/views/spree/shared/_apple_pay_button.html.erb

@@ -11,8 +11,8 @@
     amount: "<%= current_order.total %>",
     shippingContact: {
       emailAddress: '<%= current_order.email %>',
-      familyName: '<%= address.firstname %>',
-      givenName: '<%= address.lastname %>',
+      givenName: '<%= address.firstname %>',
+      familyName: '<%= address.lastname %>',
       phoneNumber: '<%= address.phone %>',
       addressLines: ['<%= address.address1 %>','<%= address.address2 %>'],
       locality: '<%= address.city %>',

data/app/views/spree/shared/_braintree_errors.html.erb

@@ -1,19 +1,16 @@
 <script type="text/javascript">
-  BraintreeError = {
-    HOSTED_FIELDS_FIELDS_EMPTY: "<%= I18n.t('solidus_paypal_braintree.errors.empty_fields')%>",
-    HOSTED_FIELDS_FIELDS_INVALID: "<%= I18n.t('solidus_paypal_braintree.errors.invalid_fields')%>",
-    HOSTED_FIELDS_FAILED_TOKENIZATION: "<%= I18n.t('solidus_paypal_braintree.errors.invalid_card')%>",
-    HOSTED_FIELDS_TOKENIZATION_NETWORK_ERROR: "<%= I18n.t('solidus_paypal_braintree.errors.network_error')%>",
-    HOSTED_FIELDS_FIELD_DUPLICATE_IFRAME: "<%= I18n.t('solidus_paypal_braintree.errors.duplicate_iframe')%>",
-    HOSTED_FIELDS_TOKENIZATION_FAIL_ON_DUPLICATE: "<%= I18n.t('solidus_paypal_braintree.errors.fail_on_duplicate')%>",
-    HOSTED_FIELDS_TOKENIZATION_CVV_VERIFICATION_FAILED: "<%= I18n.t('solidus_paypal_braintree.errors.cvv_verification_failed')%>",
-
-    getErrorFromSlug: function(slug) {
-      // Default error message
-      error = "<%= I18n.t('solidus_paypal_braintree.errors.default_error')%>"
-      if (slug in BraintreeError)
-        error = BraintreeError[slug]
-      return error
-    }
-  }
+  BraintreeError.DEFAULT = "<%= I18n.t('solidus_paypal_braintree.errors.default_error')%>"
+  BraintreeError.PAYPAL_POPUP_CLOSED = "<%= I18n.t('solidus_paypal_braintree.errors.paypal_popup_closed') %>"
+  BraintreeError.HOSTED_FIELDS_FIELDS_EMPTY = "<%= I18n.t('solidus_paypal_braintree.errors.empty_fields')%>"
+  BraintreeError.HOSTED_FIELDS_FIELDS_INVALID = "<%= I18n.t('solidus_paypal_braintree.errors.invalid_fields')%>"
+  BraintreeError.HOSTED_FIELDS_FAILED_TOKENIZATION = "<%= I18n.t('solidus_paypal_braintree.errors.invalid_card')%>"
+  BraintreeError.HOSTED_FIELDS_TOKENIZATION_NETWORK_ERROR = "<%= I18n.t('solidus_paypal_braintree.errors.network_error')%>"
+  BraintreeError.HOSTED_FIELDS_FIELD_DUPLICATE_IFRAME = "<%= I18n.t('solidus_paypal_braintree.errors.duplicate_iframe')%>"
+  BraintreeError.HOSTED_FIELDS_TOKENIZATION_FAIL_ON_DUPLICATE = "<%= I18n.t('solidus_paypal_braintree.errors.fail_on_duplicate')%>"
+  BraintreeError.HOSTED_FIELDS_TOKENIZATION_CVV_VERIFICATION_FAILED = "<%= I18n.t('solidus_paypal_braintree.errors.cvv_verification_failed')%>"
+  BraintreeError.THREEDS_AUTHENTICATION_FAILED = "<%= t('solidus_paypal_braintree.errors.threeds.authentication_failed') %>";
+  BraintreeError.THREEDS_CARDINAL_SDK_ERROR = "<%= t('solidus_paypal_braintree.errors.threeds.authentication_failed') %>";
+  BraintreeError.VENMO_CANCELED = "<%= t('solidus_paypal_braintree.errors.venmo.canceled') %>";
+  BraintreeError.VENMO_DESKTOP_CANCELED = "<%= t('solidus_paypal_braintree.errors.venmo.desktop_canceled') %>";
+  BraintreeError.VENMO_APP_CANCELED = "<%= t('solidus_paypal_braintree.errors.venmo.app_canceled') %>";
 </script>

data/app/views/spree/shared/_braintree_hosted_fields.html.erb

@@ -1,24 +1,30 @@
-<% prefix = "payment_source[#{id}]" %>
+<% if defined?(id) && !defined?(payment_method) %>
+  <% payment_method = Spree::PaymentMethod.find(id) %>
+  <% Spree::Deprecation.warn(
+    "passing id to _braintree_hosted_fields.html.erb is deprecated. Please pass the payment_method directly.",
+    caller
+  ) %>
+<% end %>
 
-<%= render partial: "spree/shared/braintree_errors" %>
+<% prefix = "payment_source[#{payment_method.id}]" %>
 
 <div class="hosted-fields">
   <div class="field" data-hook="card_number">
-    <%= label_tag "card_number#{id}", Spree::CreditCard.human_attribute_name(:number), class: "required" %>
-    <div class="input" id="card_number<%= id %>"></div>
+    <%= label_tag "card_number#{payment_method.id}", Spree::CreditCard.human_attribute_name(:number), class: "required" %>
+    <div class="input" id="card_number<%= payment_method.id %>"></div>
   </div>
 
   <div class="field" data-hook="card_expiration">
-    <%= label_tag "card_expiry#{id}", Spree::CreditCard.human_attribute_name(:expiration), class: "required" %>
-    <div class="input" id="card_expiry<%= id %>"></div>
+    <%= label_tag "card_expiry#{payment_method.id}", Spree::CreditCard.human_attribute_name(:expiration), class: "required" %>
+    <div class="input" id="card_expiry<%= payment_method.id %>"></div>
   </div>
 
   <div class="field" data-hook="card_code">
-    <%= label_tag "card_code#{id}", Spree::CreditCard.human_attribute_name(:card_code), class: "required" %>
-    <div class="input" id="card_code<%= id %>"></div>
+    <%= label_tag "card_code#{payment_method.id}", Spree::CreditCard.human_attribute_name(:card_code), class: "required" %>
+    <div class="input" id="card_code<%= payment_method.id %>"></div>
 
     <a href="/content/cvv" class="info cvvLink" target="_blank">
-      (<%= Spree.t(:what_is_this) %>)
+      (<%= I18n.t("spree.what_is_this") %>)
     </a>
   </div>
 
@@ -26,3 +32,12 @@
   <input type="hidden" name="<%= prefix %>[payment_type]" value="<%= SolidusPaypalBraintree::Source::CREDIT_CARD %>">
   <input type="hidden" id="payment_method_nonce" name="<%= prefix %>[nonce]">
 </div>
+
+
+<script>
+  <% if current_store.braintree_configuration.three_d_secure? %>
+    var threeDSecureOptions = <%= raw braintree_3ds_options_for(current_order).to_json %>;
+  <% end -%>
+  var credit_card_fields_style = <%= raw payment_method.preferred_credit_card_fields_style.to_json %>
+  var placeholder_text = <%= raw payment_method.preferred_placeholder_text.to_json %>
+</script>