spree_braintree_vzero 3.5.1

data/app/models/spree/gateway/braintree_vzero_base.rb

@@ -0,0 +1,168 @@
+require 'braintree'
+
+module Spree
+  class Gateway::BraintreeVzeroBase < Gateway
+    include BraintreeVzeroBase::PurchaseData
+
+    preference :merchant_id, :string
+    preference :public_key, :string
+    preference :private_key, :string
+    preference :server, :select, default: -> { { values: [:sandbox, :production] } }
+    preference :pass_billing_and_shipping_address, :boolean_select, default: false
+    preference :kount_merchant_id, :string
+    preference :advanced_fraud_tools, :boolean_select, default: false
+    preference :descriptor_name, :string
+    preference :currency_merchant_accounts, :hash, default: {}
+
+    attr_reader :utils
+
+    def self.current
+      super
+    end
+
+    def provider_class
+      Braintree
+    end
+
+    def provider
+      Braintree::Configuration.environment = preferred_server.to_sym
+      Braintree::Configuration.merchant_id = preferred_merchant_id
+      Braintree::Configuration.public_key = preferred_public_key
+      Braintree::Configuration.private_key = preferred_private_key
+      Braintree
+    end
+
+    def client_token(order = nil, user = nil)
+      braintree_provider = provider
+      braintree_provider::ClientToken.generate token_params(braintree_provider, user, order)
+    end
+
+    def purchase(money_in_cents, source, gateway_options)
+      order, payment = order_data_from_options(gateway_options)
+
+      @utils = Utils.new(self, order)
+      identifier_hash = find_identifier_hash(payment, @utils)
+
+      data = set_purchase_data(identifier_hash, order, money_in_cents, source)
+
+      return invalid_payment_error(data) if identifier_hash.values.all?(&:blank?)
+      sale(data, order, payment.source)
+    end
+
+    def authorize(money_in_cents, source, gateway_options)
+      purchase money_in_cents, source, gateway_options
+    end
+
+    def settle(amount, checkout, _gateway_options)
+      result = Transaction.new(provider, checkout.transaction_id).submit_for_settlement(amount / 100.0)
+      checkout.update(state: result.transaction.status)
+      result
+    end
+
+    def capture(amount, transaction_id, _gateway_options)
+      checkout = Spree::BraintreeCheckout.find_by(transaction_id: transaction_id)
+      settle(amount, checkout, _gateway_options)
+    end
+
+    def void(transaction_id, _data)
+      result = Transaction.new(provider, transaction_id).void
+
+      if result.success?
+        Spree::BraintreeCheckout.find_by(transaction_id: transaction_id).update(state: 'voided')
+      end
+
+      result
+    end
+
+    def credit(credit_cents, transaction_id, _options)
+      Transaction.new(provider, transaction_id).refund(credit_cents.to_f / 100)
+    end
+
+    def customer_payment_methods(order, payment_method_type)
+      @utils = Utils.new(self, order)
+      @utils.customer_payment_methods(payment_method_type)
+    end
+
+    def vaulted_payment_method(token)
+      provider::PaymentMethod.find(token)
+    end
+
+    private
+
+    def sale(data, order, source = nil)
+      Rails.logger.info "Sale data: #{data.inspect}"
+      result = Transaction.new(provider).sale(data)
+      Rails.logger.info "Risk Data: #{result.transaction.risk_data.inspect}" if result.success?
+
+      if result.success?
+        update_addresses(result, order)
+        update_source(result, source)
+      else
+        add_order_errors(result, order)
+      end
+
+      result
+    end
+
+    def update_addresses(response, order)
+      shipping_address = order.shipping_address
+      billing_address = order.billing_address
+      transaction = response.transaction
+
+      shipping_details_id = transaction.shipping_details.id
+      details_id = if shipping_address.same_as?(billing_address)
+                     shipping_details_id ||= transaction.billing_details.id
+                   else
+                     transaction.billing_details.id
+                   end
+
+      shipping_address.update_attribute(:braintree_id, shipping_details_id)
+      billing_address.update_attribute(:braintree_id, details_id)
+    end
+
+    def update_source(response, source)
+      return unless source.present?
+      transaction = response.transaction
+      if (risk_data = transaction.risk_data).present?
+        source.update(transaction_id: transaction.id, state: transaction.status,
+                      risk_id: risk_data.id, risk_decision: risk_data.decision)
+      else
+        source.update(transaction_id: transaction.id, state: transaction.status)
+      end
+    end
+
+    def add_order_errors(response, order)
+      response.errors.each { |e| order.errors.add(:base, I18n.t(e.message), scope: 'braintree.error') }
+      return unless response.errors.size.zero? && response.transaction.try(:gateway_rejection_reason)
+      order.errors.add(:base, I18n.t(response.transaction.gateway_rejection_reason, scope: 'braintree.error'))
+    end
+
+    def find_identifier_hash(payment, _utils)
+      if (token = payment[:braintree_token]).present?
+        { payment_method_token: token }
+      else
+        { payment_method_nonce: payment[:braintree_nonce] }
+      end
+    end
+
+    def invalid_payment_error(data)
+      # We want only direct choice of payment method (token or nonce), not by customer_id
+      message = 'Payment method identification was not specified'
+      errors = { errors: [{ code: '0', attribute: '', message: message }] }
+      Braintree::ErrorResult.new(:transaction, params: data, errors: { transaction: errors }, message: message)
+    end
+
+    def braintree_user(provider, user, order)
+      Gateway::BraintreeVzeroBase::BraintreeUser.new(provider, user, order).user
+    end
+
+    def token_params(provider, user, order)
+      token_params = {}
+      token_params[:customer_id] = user.id if braintree_user(provider, user, order)
+      currency = order.try(:currency)
+      merchant_account_id = currency ? get_merchant_account(currency) : nil
+      token_params[:merchant_account_id] = merchant_account_id if merchant_account_id
+      token_params
+    end
+  end
+end

data/app/models/spree/gateway/braintree_vzero_base/address.rb

@@ -0,0 +1,33 @@
+module Spree
+  class Gateway
+    class BraintreeVzeroBase
+      class Address
+        attr_reader :user, :utils, :request
+
+        def initialize(provider, order)
+          @utils = Utils.new(provider, order)
+          @user = order.user
+          @request = provider::Address
+        end
+
+        def create
+          @request.create(@utils.address_data('billing', utils.order).merge!(customer_id: user.id.to_s))
+        end
+
+        def find(braintree_address)
+          address_id = braintree_address.try(:id) || braintree_address
+          @request.find(user.id.to_s, address_id.to_s)
+        rescue Braintree::NotFoundError
+        end
+
+        def update(braintree_address, params)
+          @request.update(user.id.to_s, braintree_address.id.to_s, params)
+        end
+
+        def delete(braintree_address)
+          @request.delete(user.id.to_s, braintree_address.id.to_s)
+        end
+      end
+    end
+  end
+end

data/app/models/spree/gateway/braintree_vzero_base/braintree_user.rb

@@ -0,0 +1,25 @@
+module Spree
+  class Gateway
+    class BraintreeVzeroBase
+      class BraintreeUser
+        attr_reader :user, :spree_user, :request, :utils
+
+        delegate :shipping_address, :billing_address, to: :spree_user
+
+        def initialize(provider, spree_user, order)
+          @utils = Utils.new(provider, order)
+          @spree_user = spree_user
+          @request = provider::Customer
+          begin
+            @user = @request.find(spree_user.try(:id))
+          rescue
+          end
+        end
+
+        def register_user
+          @request.create(@utils.customer_data(spree_user))
+        end
+      end
+    end
+  end
+end

data/app/models/spree/gateway/braintree_vzero_base/purchase_data.rb

@@ -0,0 +1,48 @@
+module Spree
+  class Gateway
+    class BraintreeVzeroBase
+      module PurchaseData
+        extend ActiveSupport::Concern
+
+        private
+
+        def set_purchase_data(identifier_hash, order, money_in_cents, source)
+          data = set_basic_purchase_data(identifier_hash, order, @utils, money_in_cents)
+          merchant_account_id = get_merchant_account(order.currency)
+          data[:merchant_account_id] = merchant_account_id if merchant_account_id
+          data[:descriptor] = { name: preferred_descriptor_name.to_s.tr('/', '*') }
+          data[:options] = {
+            submit_for_settlement: auto_capture?,
+            add_billing_address_to_payment_method: preferred_pass_billing_and_shipping_address ? true : false,
+            three_d_secure: {
+              required: (try(:preferred_3dsecure) unless source.admin_payment?)
+            }
+          }.merge!(@utils.payment_in_vault(data))
+          return data if source.admin_payment? || !preferred_advanced_fraud_tools
+          data.merge!(device_data: source.advanced_fraud_data)
+        end
+
+        def set_basic_purchase_data(identifier_hash, order, utils, money_in_cents)
+          data = { channel: I18n.t('braintree.channel_parameter') }
+          data.merge!(utils.get_customer)
+          data.merge!(utils.order_data(identifier_hash, money_in_cents.to_f / 100))
+          return data unless preferred_pass_billing_and_shipping_address
+
+          data.merge!(utils.get_address('billing'))
+          data.merge!(utils.get_address('shipping'))
+        end
+
+        def get_merchant_account(currency)
+          preferred_currency_merchant_accounts[currency]
+        end
+
+        def order_data_from_options(options)
+          order_number, payment_number = options[:order_id].split('-')
+          order = Spree::Order.find_by(number: order_number)
+          payment = order.payments.find_by(number: payment_number)
+          [order, payment]
+        end
+      end
+    end
+  end
+end

data/app/models/spree/gateway/braintree_vzero_base/transaction.rb

@@ -0,0 +1,39 @@
+module Spree
+  class Gateway
+    class BraintreeVzeroBase
+      class Transaction
+        attr_reader :transaction_id, :request
+
+        def initialize(provider, transaction_id = nil)
+          @transaction_id = transaction_id
+          @request = provider::Transaction
+        end
+
+        def submit_for_settlement(amount)
+          @request.submit_for_settlement(transaction_id, amount)
+        end
+
+        def clone
+          t = @request.find(transaction_id)
+          sale(payment_method_token: t.credit_card_details.token, amount: t.amount, options: { submit_for_settlement: true })
+        end
+
+        def sale(data)
+          @request.sale(data)
+        end
+
+        def status
+          @request.find(transaction_id).status
+        end
+
+        def void
+          @request.void(transaction_id)
+        end
+
+        def refund(cents)
+          @request.refund(transaction_id, cents)
+        end
+      end
+    end
+  end
+end

data/app/models/spree/gateway/braintree_vzero_base/utils.rb

@@ -0,0 +1,108 @@
+module Spree
+  class Gateway
+    class BraintreeVzeroBase
+      class Utils
+        attr_reader :order, :customer, :gateway
+
+        def initialize(gateway, order)
+          @order = order
+          begin
+            @customer = gateway.provider::Customer.find(order.user.id) if order.user
+          rescue
+          end
+          @gateway = gateway
+        end
+
+        def get_address(address_type)
+          if order.user && (address = order.user.send("#{address_type}_address"))
+            braintree_address = BraintreeVzeroBase::Address.new(gateway.provider, order)
+            vaulted_duplicate = Spree::Address.vaulted_duplicates(address).first
+
+            if vaulted_duplicate && braintree_address.find(vaulted_duplicate.braintree_id)
+              { "#{address_type}_address_id" => vaulted_duplicate.braintree_id }
+            else
+              { address_type => address_data(address_type, order.user) }
+            end
+          else
+            { address_type => address_data(address_type, order) }
+          end
+        end
+
+        def get_customer
+          if @customer
+            { customer_id: @customer.id }
+          else
+            { customer: (payment_in_vault[:store_shipping_address_in_vault] && order.user) ? customer_data(order.user) : {} }
+          end
+        end
+
+        def order_data(identifier, amount)
+          identifier.merge(
+            amount: amount,
+            order_id: order.number
+          )
+        end
+
+        def address_data(address_type, target)
+          address = target.send("#{address_type}_address")
+          country = address.country
+
+          {
+            company: address.company,
+            country_code_alpha2: country.iso,
+            country_code_alpha3: country.iso3,
+            country_code_numeric: country.numcode,
+            country_name: country.name,
+            first_name: address.first_name,
+            last_name: address.last_name,
+            locality: address.city,
+            postal_code: address.zipcode,
+            region: address.state.try(:abbr),
+            street_address: address.address1,
+            extended_address: address.address2
+          }
+        end
+
+        def customer_data(user)
+          address_data('billing', user).slice(:first_name, :last_name, :company, :phone).merge!(id: user.id, email: user.email)
+        end
+
+        def customer_payment_methods(payment_method_type)
+          payment_methods = @customer.try(:payment_methods) || []
+
+          if payment_method_type.eql?('custom')
+            payment_methods.select { |pm| pm.is_a?(Braintree::CreditCard) }
+          elsif payment_method_type.eql?('paypal')
+            payment_methods.select { |pm| pm.is_a?(Braintree::PayPalAccount) }
+          else
+            payment_methods
+          end
+        end
+
+        def payment_in_vault(data = {})
+          store_ship_address = data['shipping_address_id'].blank?
+          if gateway.preferred_store_payments_in_vault == 'store_only_on_success'
+            { store_in_vault_on_success: true, store_shipping_address_in_vault: store_ship_address }
+          elsif gateway.preferred_store_payments_in_vault == 'store_all'
+            { store_in_vault: true, store_shipping_address_in_vault: store_ship_address }
+          else
+            { store_in_vault: false }
+          end
+        end
+
+        def map_payment_status(braintree_status)
+          case braintree_status
+          when 'authorized', 'settlement_pending'
+            'pending'
+          when 'voided'
+            'void'
+          when 'settled', 'submitted_for_settlement', 'settling'
+            'completed'
+          else
+            'failed'
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/spree/gateway/braintree_vzero_drop_in_ui.rb

@@ -0,0 +1,24 @@
+module Spree
+  class Gateway::BraintreeVzeroDropInUi < Spree::Gateway::BraintreeVzeroBase
+    preference :dropin_container, :string, default: 'payment-form'
+    preference :checkout_form_id, :string, default: 'checkout_form_payment'
+    preference :error_messages_container_id, :string, default: 'content'
+    preference :store_payments_in_vault, :select, default: -> { { values: [:do_not_store, :store_only_on_success, :store_all] } }
+    preference :'3dsecure', :boolean_select, default: false
+
+    after_save :disable_hosted_gateways, if: proc {
+      active? && (saved_changes.keys & %w[active id]).any?
+    }
+
+    def method_type
+      'braintree_vzero_dropin_ui'
+    end
+
+    private
+
+    # we cannot have Hosted and DropInUI both active at the same time
+    def disable_hosted_gateways
+      Spree::Gateway::BraintreeVzeroHostedFields.update_all(active: false)
+    end
+  end
+end