spree_braintree_vzero 3.5.1

data/app/assets/stylesheets/spree/backend/spree_braintree_vzero.css

@@ -0,0 +1,5 @@
+/*
+Placeholder manifest file.
+the installer will append this file to the app vendored assets here: 'vendor/assets/stylesheets/spree/backend/all.css'
+*/
+

data/app/controllers/spree/admin/payments_controller_decorator.rb

@@ -0,0 +1,43 @@
+module Spree
+  module Admin
+    module PaymentsControllerDecorator
+      def create
+        invoke_callbacks(:create, :before)
+        @payment ||= @order.payments.build(object_params)
+        # not only credit card may require source
+        if @payment.payment_method.source_required?
+          if params[:card].present? && params[:card] != 'new'
+            @payment.source = @payment.payment_method.payment_source_class.find_by_id(params[:card])
+          elsif @payment.payment_source.is_a?(Spree::Gateway::BraintreeVzeroBase)
+            @payment.braintree_token = params[:payment_method_token]
+            @payment.braintree_nonce = params[:payment_method_nonce]
+            @payment.source = Spree::BraintreeCheckout.create!(admin_payment: true)
+          end
+        end
+
+        begin
+          if @payment.save
+            invoke_callbacks(:create, :after)
+            # Transition order as far as it will go.
+            while @order.next; end
+            # If "@order.next" didn't trigger payment processing already (e.g. if the order was
+            # already complete) then trigger it manually now
+            @payment.process! if @order.completed? && @payment.checkout?
+            flash[:success] = flash_message_for(@payment, :successfully_created)
+            redirect_to admin_order_payments_path(@order)
+          else
+            invoke_callbacks(:create, :fails)
+            flash[:error] = Spree.t(:payment_could_not_be_created)
+            render :new
+          end
+        rescue Spree::Core::GatewayError => e
+          invoke_callbacks(:create, :fails)
+          flash[:error] = e.message.to_s
+          redirect_to new_admin_order_payment_path(@order)
+        end
+      end
+    end
+  end
+end
+
+::Spree::Admin::PaymentsController.prepend(Spree::Admin::PaymentsControllerDecorator)

data/app/controllers/spree/api/v1/braintree_client_token_controller.rb

@@ -0,0 +1,31 @@
+module Spree
+  module Api
+    module V1
+      class BraintreeClientTokenController < Spree::Api::BaseController
+        skip_before_action :authenticate_user
+
+        before_action :find_order, only: :create
+
+        def create
+          gateway = if params[:payment_method_id]
+            Spree::Gateway::BraintreeVzeroBase.find(params[:payment_method_id])
+          else
+            Spree::Gateway::BraintreeVzeroBase.active.first
+          end
+
+          render json: {
+            client_token: gateway.client_token(@order, @current_api_user),
+            payment_method_id: gateway.id
+          }
+        end
+
+        private
+
+        # We're skipping permission check for order, because it is needed only to get a currency
+        def find_order
+          @order = Spree::Order.find_by(number: params[:order_number])
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/checkout_controller_decorator.rb

@@ -0,0 +1,38 @@
+module Spree
+  module CheckoutControllerDecorator
+    def self.prepended(base)
+      base.include Spree::BraintreeHelper
+      base.helper_method [:asset_available?, :options_from_braintree_payments]
+      base.after_action :allow_braintree_iframe
+      base.after_action :update_source_data, only: :update, if: proc { params[:state].eql?('payment') }
+    end
+
+    private
+
+    def allow_braintree_iframe
+      response.headers['X-Frame-Options'] = 'ALLOW-FROM https://assets.braintreegateway.com'
+    end
+
+    def check_registration
+      return unless Spree::Auth::Config[:registration_step]
+      return if spree_current_user || current_order.email
+      store_location
+      redirect_to spree.checkout_registration_path
+    end
+
+    def update_source_data
+      return true unless current_order
+      payment = current_order.payments.last
+      return true unless payment
+      source = payment.source
+      return true unless source.is_a?(Spree::BraintreeCheckout)
+      update_advanced_fraud_data(source)
+    end
+
+    def update_advanced_fraud_data(source)
+      source.update(advanced_fraud_data: params[:device_data])
+    end
+  end
+end
+
+::Spree::CheckoutController.prepend(Spree::CheckoutControllerDecorator)

data/app/controllers/spree/orders_controller_decorator.rb

@@ -0,0 +1,62 @@
+module Spree
+  module OrdersControllerDecorator
+    def self.prepended(base)
+      base.include Spree::BraintreeHelper
+      base.helper_method [:asset_available?, :options_from_braintree_payments]
+      base.before_action :process_paypal_express, only: :update
+    end
+
+    def process_paypal_express
+      if params[:paypal].blank? || params[:paypal][:payment_method_nonce].blank?
+        # when user goes back from checkout, paypal express payments should be invalidated  to ensure standard checkout flow
+        current_order.invalidate_paypal_express_payments
+        return true
+      end
+      payment_method = Spree::PaymentMethod.find_by_id(params[:paypal][:payment_method_id])
+      return true unless payment_method
+
+      email = params[:order][:email]
+      # when user goes back from checkout, order's state should be resetted to ensure paypal checkout flow
+      current_order.state = 'cart'
+      payment_method.push_order_to_state(current_order, 'address', email)
+      current_order.save_paypal_payment(payment_params)
+
+      manage_paypal_addresses
+      current_order.remove_phone_number_placeholder
+
+      redirect_to checkout_state_path(current_order.state, paypal_email: email)
+    end
+
+    private
+
+    def address_params(key)
+      params[:order].require(key).permit(:firstname, :lastname, :zipcode, :city, :address1, :address2, :phone, :full_name, :country, :state)
+    end
+
+    def payment_params
+      {
+        braintree_nonce: params[:paypal][:payment_method_nonce],
+        payment_method_id: params[:paypal][:payment_method_id],
+        paypal_email: params[:order][:email],
+        advanced_fraud_data: params[:device_data]
+      }
+    end
+
+    def manage_paypal_addresses
+      # addresses need to be cleared for restarted checkout orders
+      current_order.ship_address_id = nil
+      current_order.bill_address_id = nil
+
+      %w(ship_address bill_address).each do |address_type|
+        next if params[:order][address_type].blank?
+        current_order.save_paypal_address(address_type, address_params(address_type))
+      end
+      current_order.set_billing_address
+      return false if current_order.no_phone_number?
+
+      current_order.ship_address && current_order.bill_address
+    end
+  end
+end
+
+::Spree::OrdersController.prepend(Spree::OrdersControllerDecorator)

data/app/controllers/spree/user_sessions_controller_decorator.rb

@@ -0,0 +1,15 @@
+module Spree
+  module UserSessionsControllerDecorator
+    def self.prepended(base)
+      base.before_action :associate_user, only: :create
+    end
+
+    def current_order_params
+      { currency: current_currency, guest_token: cookies.signed[:guest_token], store_id: current_store.id }
+    end
+  end
+end
+
+if defined?(::Spree::UserSessionsController)
+  ::Spree::UserSessionsController.prepend(Spree::UserSessionsControllerDecorator)
+end

data/app/helpers/spree/admin/decorated_navigation_helper.rb

@@ -0,0 +1,10 @@
+module Spree
+  module Admin
+    module DecoratedNavigationHelper
+      def link_to_with_icon(icon_name, text, url, options = {})
+        icon_name = 'capture' if icon_name.eql?('settle')
+        super
+      end
+    end
+  end
+end

data/app/helpers/spree/admin/payment_methods_helper.rb

@@ -0,0 +1,101 @@
+module Spree
+  module Admin
+    module PaymentMethodsHelper
+      def preference_field_for(form, field, options)
+        case options[:type]
+        when :integer
+          form.text_field(field, preference_field_options(options))
+        when :boolean
+          form.check_box(field, preference_field_options(options))
+        when :string
+          if field.eql?('preferred_descriptor_name')
+             content_tag(:div,
+                         Spree.t('descriptor_name_information_box_text').html_safe,
+                         class: 'alert alert-warning'
+             )
+          end.to_s.html_safe +
+            form.text_field(field, preference_field_options(options))
+        when :password
+          form.password_field(field, preference_field_options(options))
+        when :text
+          form.text_area(field, preference_field_options(options))
+        when :boolean_select
+          label_tag(field, Spree.t(field))
+          form.select(field, {
+            Spree.t(:enabled) => true,
+            Spree.t(:disabled) => false
+          },
+          {},
+          class: 'select2')
+        when :select
+          label_tag(field, Spree.t(field))
+          form.select(field, options_for_select(options[:values].map { |key| [I18n.t(key, scope: 'braintree.preferences'), key] }, options[:selected]), {}, class: 'select2')
+        else
+          form.text_field(field, preference_field_options(options))
+        end
+      end
+
+      def preference_field_tag(name, value, options)
+        case options[:type]
+        when :integer
+          text_field_tag(name, value, preference_field_options(options))
+        when :boolean
+          hidden_field_tag(name, 0, id: "#{name}_hidden") +
+            check_box_tag(name, 1, value, preference_field_options(options))
+        when :string
+          text_field_tag(name, value, preference_field_options(options))
+        when :password
+          password_field_tag(name, value, preference_field_options(options))
+        when :text
+          text_area_tag(name, value, preference_field_options(options))
+        when :boolean_select
+          select_tag(name, value, preference_field_options(options))
+        when :select
+          select_tag(name, value, preference_field_options(options))
+        else
+          text_field_tag(name, value, preference_field_options(options))
+        end
+      end
+
+      def preference_fields(object, form)
+        return unless object.respond_to?(:preferences)
+
+        get_preference_fields(object, object.preferences.keys, form)
+      end
+
+      def braintree_basic_preference_fields(object, form)
+        return unless object.respond_to?(:preferences)
+
+        keys = object.preferences.slice(*basic_braintree_preference_keys).keys
+        get_preference_fields(object, keys, form)
+      end
+
+      def braintree_advanced_preference_fields(object, form)
+        return unless object.respond_to?(:preferences)
+
+        keys = object.preferences.keys.reverse - basic_braintree_preference_keys
+        keys_left, keys_right = keys.each_slice((keys.size / 2.0).ceil).to_a
+
+        content_tag(:div, get_preference_fields(object, keys_left, form), class: 'col-md-6') +
+          content_tag(:div, get_preference_fields(object, keys_right, form), class: 'col-md-6')
+      end
+
+      def get_preference_fields(object, keys, form)
+        keys.reject { |k| k == :currency_merchant_accounts }.map do |key|
+          next unless object.has_preference?(key)
+
+          content_tag(:div, class: 'form-group', 'data-hook' => "preferred_#{key}") do
+            form.label("preferred_#{key}", Spree.t(key) + ': ') +
+              preference_field_for(form, "preferred_#{key}", type: object.preference_type(key),
+                                 values: object.send("preferred_#{key}_default").is_a?(Hash) ? object.send("preferred_#{key}_default")[:values] : nil,
+                                 selected: object.preferences[key])
+          end
+        end.join(' ').html_safe
+      end
+
+      def basic_braintree_preference_keys
+        %i[merchant_id public_key private_key server test_mode]
+      end
+    end
+  end
+end

data/app/helpers/spree/braintree_helper.rb

@@ -0,0 +1,27 @@
+module Spree
+  module BraintreeHelper
+    def options_from_braintree_payments(payment_methods, include_empty = false)
+      additional_options = if include_empty
+                             ["<option value=''>#{t('braintree.checkout.blank_saved_payment_method')}</option>"]
+                           else
+                             []
+                           end
+      additional_options + payment_methods.map do |method|
+        text = if method.is_a?(Braintree::CreditCard)
+                 Spree.t('admin.vaulted_payments.credit_card', card_type: method.card_type, last_4: method.last_4)
+               elsif method.is_a?(Braintree::PayPalAccount)
+                 Spree.t('admin.vaulted_payments.paypal', email: method.email)
+               end
+        "<option value='#{method.token}'>#{text}</option>"
+      end.join.html_safe
+    end
+
+    def asset_available?(logical_path)
+      if Rails.configuration.assets.compile
+        Rails.application.precompiled_assets.include? logical_path
+      else
+        Rails.application.assets_manifest.assets[logical_path].present?
+      end
+    end
+  end
+end

data/app/models/braintree/successful_result_decorator.rb

@@ -0,0 +1,21 @@
+module Braintree
+  module SuccessfulResultDecorator
+    def self.prepended(base)
+      base.mattr_reader :authorization, :message
+    end
+
+    def authorization
+      transaction.id
+    end
+
+    def avs_result
+      { code: transaction.avs_street_address_response_code }.with_indifferent_access
+    end
+
+    def cvv_result
+      { code: transaction.cvv_response_code, message: nil }.with_indifferent_access
+    end
+  end
+end
+
+::Braintree::SuccessfulResult.prepend(Braintree::SuccessfulResultDecorator)

data/app/models/spree/address_decorator.rb

@@ -0,0 +1,18 @@
+module Spree
+  module AddressDecorator
+    def self.prepended(base)
+      base.scope :vaulted_duplicates, ->(address) do
+        where.not(id: address.id).
+          where.not(braintree_id: nil).
+          where(address.attributes.except('id', 'updated_at', 'created_at', 'braintree_id'))
+      end
+    end
+
+    def same_as?(other)
+      return false if other.nil?
+      attributes.except('id', 'updated_at', 'created_at', 'braintree_id') == other.attributes.except('id', 'updated_at', 'created_at', 'braintree_id')
+    end
+  end
+end
+
+::Spree::Address.prepend(Spree::AddressDecorator)

data/app/models/spree/braintree_checkout.rb

@@ -0,0 +1,105 @@
+module Spree
+  class BraintreeCheckout < ActiveRecord::Base
+    scope :in_state, ->(state) { where(state: state) }
+    scope :not_in_state, ->(state) { where.not(state: state) }
+
+    after_commit :update_payment_and_order
+
+    FINAL_STATES = %w(authorization_expired processor_declined gateway_rejected failed voided settled settlement_declined refunded released).freeze
+
+    has_one :payment, foreign_key: :source_id, as: :source, class_name: 'Spree::Payment'
+    has_one :order, through: :payment
+
+    def self.create_from_params(params)
+      type = braintree_card_type_to_spree(params[:braintree_card_type])
+      create!(paypal_email: params[:paypal_email],
+              braintree_last_digits: params[:braintree_last_two],
+              braintree_card_type: type)
+    end
+
+    def self.create_from_token(token, payment_method_id)
+      gateway = Spree::PaymentMethod.find(payment_method_id)
+      vaulted_payment_method = gateway.vaulted_payment_method(token)
+      type = braintree_card_type_to_spree(vaulted_payment_method.try(:card_type))
+      create!(paypal_email: vaulted_payment_method.try(:email),
+              braintree_last_digits: vaulted_payment_method.try(:last_4),
+              braintree_card_type: type)
+    end
+
+    def self.update_states
+      braintree = Gateway::BraintreeVzeroBase.first.provider
+      result = { changed: 0, unchanged: 0 }
+      not_in_state(FINAL_STATES).find_each do |checkout|
+        checkout.state = braintree::Transaction.find(checkout.transaction_id).status
+        if checkout.state_changed?
+          result[:changed] += 1
+          checkout.save
+        else
+          result[:unchanged] += 1
+        end
+      end
+      result
+    end
+
+    def update_state
+      status = Transaction.new(Gateway::BraintreeVzeroBase.first.provider, transaction_id).status
+      payment.send(payment_action(status))
+      status
+    end
+
+    def actions
+      %w(void settle credit)
+    end
+
+    def can_void?(_payment)
+      %w(authorized submitted_for_settlement).include? state
+    end
+
+    def can_settle?(_)
+      %w(authorized).include? state
+    end
+
+    def can_credit?(_payment)
+      %w(settled settling).include? state
+    end
+
+    private
+
+    def update_payment_and_order
+      return unless (changes = previous_changes[:state])
+      return unless changes[0] != changes[1]
+      return unless payment
+
+      utils = Gateway::BraintreeVzeroBase::Utils.new(Gateway::BraintreeVzeroBase.first, order)
+      payment_state = utils.map_payment_status(state)
+      payment.send(payment_action(payment_state))
+    end
+
+    def self.braintree_card_type_to_spree(type)
+      return '' unless type
+      case type
+      when 'AmericanExpress'
+        'american_express'
+      when 'Diners Club'
+        'diners_club'
+      when 'MasterCard'
+        'master'
+      else
+        type.downcase
+      end
+    end
+
+    def payment_action(state)
+      case state
+      when 'pending'
+        'pend'
+      when 'void'
+        'void'
+      when 'completed'
+        'complete'
+      else
+        'failure'
+      end
+    end
+  end
+end