spree_braintree_vzero 3.5.1

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

@@ -0,0 +1,28 @@
+module Spree
+  class Gateway::BraintreeVzeroHostedFields < Spree::Gateway::BraintreeVzeroBase
+    preference :checkout_form_id, :string, default: 'checkout_form_payment'
+    preference :error_messages_container_id, :string, default: 'content'
+    preference :number_selector, :string, default: '#hosted-fields-number'
+    preference :number_placeholder, :string, default: 'Card Number'
+    preference :cvv_selector, :string, default: '#hosted-fields-cvv'
+    preference :cvv_placeholder, :string, default: 'Cvv code'
+    preference :expiration_date_selector, :string, default: '#hosted-fields-expiration-date'
+    preference :expiration_date_placeholder, :string, default: 'Card Expiration Date'
+    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_dropin_gateways, if: proc {
+      active? && (saved_changes.keys & %w[active id]).any?
+    }
+
+    def method_type
+      'braintree_vzero_hosted_fields'
+    end
+
+    private
+
+    def disable_dropin_gateways
+      Spree::Gateway::BraintreeVzeroDropInUi.update_all(active: false)
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Spree
+  class Gateway::BraintreeVzeroPaypalExpress < Spree::Gateway::BraintreeVzeroBase
+    preference :paypal_display_on_cart, :boolean_select, default: true
+    preference :store_payments_in_vault, :select, default: -> { { values: [:do_not_store, :store_all] } }
+    preference :paypal_display_name, :string
+    preference :checkout_form_id, :string, default: 'checkout_form_payment'
+    preference :error_messages_container_id, :string, default: 'content'
+
+    def method_type
+      'braintree_vzero_paypal_express'
+    end
+
+    def push_order_to_state(order, state, email)
+      order.update_column(:email, email)
+      order.next! until order.state.eql?(state)
+      order.update_column(:email, nil)
+    end
+
+    def find_identifier_hash(payment, utils)
+      token = payment[:braintree_token] || vaulted_token_by_email(payment, utils)
+      if token.present?
+        { payment_method_token: token }
+      else
+        { payment_method_nonce: payment[:braintree_nonce] }
+      end
+    end
+
+    private
+
+    def vaulted_token_by_email(payment, utils)
+      utils.customer_payment_methods('paypal').find do |customer_payment|
+        customer_payment.try(:email).eql?(payment.source.paypal_email)
+      end.try(:token)
+    end
+  end
+end

data/app/models/spree/order_decorator.rb

@@ -0,0 +1,153 @@
+module Spree
+  module OrderDecorator
+    def self.prepended(base)
+      base.state_machine.before_transition to: :complete, do: :process_paypal_express_payments
+    end
+
+    def save_paypal_address(type, address_hash)
+      return if address_hash.blank?
+      address = Spree::Address.new(prepare_address_hash(address_hash))
+      return unless address.save
+
+      update_column("#{type}_id", address.id)
+    end
+
+    def save_paypal_payment(options)
+      options[:source] = Spree::BraintreeCheckout.create!(options.slice(:paypal_email, :advanced_fraud_data))
+      payments.create(options.slice(:braintree_nonce, :payment_method_id, :source))
+    end
+
+    def set_billing_address
+      return if bill_address_id
+      return unless ship_address_id
+
+      address = Spree::Address.create(shipping_address.attributes.except('id', 'updated_at', 'created_at', 'braintree_id'))
+      update_column(:bill_address_id, address.try(:id))
+    end
+
+    # override needed to add braintree source attribute
+    def update_from_params(params, permitted_params, request_env = {})
+      success = false
+      @updating_params = params
+      run_callbacks :updating_from_params do
+        # Set existing card after setting permitted parameters because
+        # rails would slice parameters containg ruby objects, apparently
+        existing_card_id = @updating_params[:order] ? @updating_params[:order].delete(:existing_card) : nil
+
+        attributes = @updating_params[:order] ? @updating_params[:order].permit(permitted_params).delete_if { |_k, v| v.nil? } : {}
+        payment_attributes = attributes[:payments_attributes].first if attributes[:payments_attributes].present?
+
+        if existing_card_id.present?
+          credit_card = Spree::CreditCard.find existing_card_id
+          if credit_card.user_id != user_id || credit_card.user_id.blank?
+            raise Spree::Core::GatewayError, Spree.t(:invalid_credit_card)
+          end
+
+          credit_card.verification_value = params[:cvc_confirm] if params[:cvc_confirm].present?
+
+          attributes[:payments_attributes].first[:source] = credit_card
+          attributes[:payments_attributes].first[:payment_method_id] = credit_card.payment_method_id
+          attributes[:payments_attributes].first.delete :source_attributes
+        end
+
+        if payment_attributes.present?
+          payment_attributes[:request_env] = request_env
+
+          if (token = payment_attributes[:braintree_token]).present?
+            payment_attributes[:source] = Spree::BraintreeCheckout.create_from_token(token, payment_attributes[:payment_method_id])
+          elsif payment_attributes[:braintree_nonce].present?
+            payment_attributes[:source] = Spree::BraintreeCheckout.create_from_params(params)
+          end
+        end
+
+        success = update(attributes)
+        set_shipments_cost if shipments.any?
+      end
+
+      @updating_params = nil
+      success
+    end
+
+    def payment_required?
+      # default payment processing requires order to have state == payment
+      # so there is no need to divide this method for checkout steps and actual payment processing
+      return false if paid_with_paypal_express?
+      total.to_f > 0.0
+    end
+
+    def confirmation_required?
+      Spree::Config[:always_include_confirm_step] ||
+        payments.valid.map(&:payment_method).compact.any?(&:payment_profiles_supported?) ||
+        # setting payment_profiles_supported? for braintree gateways would require few additional changes in payments profiles system
+        braintree_confirmation_required? || state == 'confirm'
+    end
+
+    def paid_with_braintree?
+      payments.valid.map(&:payment_method).compact.any? { |p| p.is_a?(Spree::Gateway::BraintreeVzeroBase) }
+    end
+
+    def paid_with_paypal_express?
+      payments.valid.map(&:payment_method).compact.any? { |p| p.is_a?(Spree::Gateway::BraintreeVzeroPaypalExpress) }
+    end
+
+    def invalidate_paypal_express_payments
+      return unless paid_with_paypal_express?
+
+      payments.valid.each do |payment|
+        payment.invalidate! if payment.payment_method.is_a?(Spree::Gateway::BraintreeVzeroPaypalExpress)
+      end
+    end
+
+    def no_phone_number?
+      [ship_address, bill_address].each do |address|
+        return true if address.try(:phone).eql?(I18n.t('braintree.phone_number_placeholder'))
+      end
+      false
+    end
+
+    def remove_phone_number_placeholder
+      [ship_address, bill_address].each do |address|
+        address.update_column(:phone, nil) if address.try(:phone).eql?(I18n.t('braintree.phone_number_placeholder'))
+      end
+    end
+
+    private
+
+    def braintree_confirmation_required?
+      paid_with_braintree? && state.eql?('payment')
+    end
+
+    def prepare_address_hash(hash)
+      hash.delete_if { |e| hash[e].eql?('undefined') }
+      country_id = Spree::Country.find_by(iso: hash.delete(:country)).try(:id)
+
+      hash[:country_id] = country_id
+      state_param = hash.delete(:state)
+      state = Spree::State.where('spree_states.abbr = :abbr OR upper(spree_states.name) = :name',
+                                 abbr: state_param, name: state_param.upcase).find_by(country_id: country_id)
+      hash[:state_id] = state.try(:id)
+      hash[:phone] ||= I18n.t('braintree.phone_number_placeholder')
+
+      return hash if hash[:full_name].blank?
+
+      full_name = hash.delete(:full_name).split(' ')
+      hash[:lastname] = full_name.slice!(-1)
+      hash[:firstname] = full_name.join(' ')
+      hash
+    end
+
+    def process_paypal_express_payments
+      return unless paid_with_paypal_express?
+
+      if payments.valid.empty?
+        order.errors.add(:base, Spree.t(:no_payment_found))
+        false
+      else
+        payments.valid.last.update(amount: order_total_after_store_credit)
+        process_payments!
+      end
+    end
+  end
+end
+
+::Spree::Order.prepend(Spree::OrderDecorator)

data/app/models/spree/payment_decorator.rb

@@ -0,0 +1,10 @@
+module Spree
+  module PaymentDecorator
+    def update_order
+      # without reload order was updated with inaccurate data
+      order.reload && super
+    end
+  end
+end
+
+::Spree::Payment.prepend(Spree::PaymentDecorator)

data/app/models/spree/payment_processing_decorator.rb

@@ -0,0 +1,61 @@
+module Spree
+  module PaymentProcessingDecorator
+    def self.prepended(base)
+      base.delegate :settle, to: :provider
+    end
+
+    def settle!
+      handle_payment_preconditions { process_settle }
+    end
+
+    def gateway_action(source, action, success_state)
+      protect_from_connection_error do
+        response = payment_method.send(action, money.money.cents,
+                                       source,
+                                       gateway_options)
+        success_state = set_proper_state(success_state, response, action)
+        handle_response(response, success_state, :failure)
+      end
+    end
+
+    private
+
+    def process_settle
+      started_processing!
+      gateway_action(source, :settle, :started_processing)
+    end
+
+    def gateway_error(error)
+      if error.is_a? ActiveMerchant::Billing::Response
+        text = error.params['message'] || error.params['response_reason_text'] || error.message
+      elsif error.is_a? ActiveMerchant::ConnectionError
+        text = Spree.t(:unable_to_connect_to_gateway)
+      elsif error.is_a? Braintree::ErrorResult
+        text = error.message
+      else
+        text = error.to_s
+      end
+      logger.error(Spree.t(:gateway_error))
+      logger.error("  #{error.to_yaml}")
+      raise Spree::Core::GatewayError, text
+    end
+
+    def set_proper_state(current_state, response, action)
+      return current_state unless action.eql?(:purchase)
+      return current_state unless source.is_a?(Spree::BraintreeCheckout)
+      utils = Spree::Gateway::BraintreeVzeroBase::Utils.new(payment_method, order)
+      state = utils.map_payment_status(response.try(:transaction).try(:status))
+
+      case state
+      when 'completed'
+        'complete'
+      when 'pending'
+        'pend'
+      else
+        current_state
+      end
+    end
+  end
+end
+
+::Spree::Payment.prepend(Spree::PaymentProcessingDecorator)

data/app/models/spree/preferences/preferable_decorator.rb

@@ -0,0 +1,54 @@
+module Spree
+  module Preferences
+    module PreferableDecorator
+      private
+
+      def convert_preference_value(value, type)
+        case type
+        when :string, :text, :select
+          value.to_s
+        when :password
+          value.to_s
+        when :decimal
+          BigDecimal.new(value.to_s)
+        when :integer
+          value.to_i
+        when :boolean, :boolean_select
+          if value.is_a?(FalseClass) ||
+            value.nil? ||
+            value == 0 ||
+            value =~ /^(f|false|0)$/i ||
+            (value.respond_to?(:empty?) && value.empty?)
+            false
+          else
+            true
+          end
+        when :array
+          value.is_a?(Array) ? value : Array.wrap(value)
+        when :hash
+          case value.class.to_s
+          when 'Hash'
+            value
+          when 'String'
+            # only works with hashes whose keys are strings
+            JSON.parse value.gsub('=>', ':')
+          when 'Array'
+            begin
+              value.try(:to_h)
+            rescue TypeError
+              Hash[*value]
+            rescue ArgumentError
+              raise 'An even count is required when passing an array to be converted to a hash'
+            end
+          else
+            value.class.ancestors.include?(Hash) ? value : {}
+          end
+        else
+          value
+        end
+      end
+    end
+  end
+end
+
+::Spree::Preferences::Preferable.prepend(Spree::Preferences::PreferableDecorator)

data/app/overrides/spree/admin/orders/customer_details/_form.rb

@@ -0,0 +1,8 @@
+Deface::Override.new(
+  virtual_path: 'spree/admin/orders/customer_details/_form',
+  name: 'Add warning for braintree admins',
+  insert_after: '[data-hook="customer_fields"]',
+  text: '<div class="alert alert-warning">
+           <%= I18n.t("braintree.admin.guest_checkout_warning") %>
+         </div>'
+)

data/app/overrides/spree/admin/payment_methods/_form.rb

@@ -0,0 +1,10 @@
+Deface::Override.new(
+  virtual_path: 'spree/admin/payment_methods/_form',
+  name: 'Use custom form partial for braintree vzero payment method',
+  surround: '[data-hook="admin_payment_method_form_fields"]',
+  text: '<% if @object.kind_of?(Spree::Gateway::BraintreeVzeroBase) %>
+           <%= render "braintree_vzero_form", f: f %>
+         <% else %>
+           <%= render_original %>
+         <% end %>'
+)

data/app/overrides/spree/admin/shared/_order_summary.rb

@@ -0,0 +1,23 @@
+Deface::Override.new(
+  virtual_path: 'spree/admin/shared/_order_summary',
+  name: 'Add Risk ID & Risk Decision to Order Summary',
+  insert_bottom: 'tbody.additional-info',
+  text: '<% if @order.paid_with_braintree? %>
+          <tr>
+            <td data-hook="admin_order_tab_risk_id">
+              <strong><%= Spree.t("admin.risk_id") %>:</strong>
+            </td>
+            <td id="risk_id">
+              <%= @order.payments.valid.take.try(:source).try(:risk_id) %>
+            </td>
+          </tr>
+          <tr>
+            <td data-hook="admin_order_tab_risk_decision">
+              <strong><%= Spree.t("admin.risk_decision") %>:</strong>
+            </td>
+            <td id="risk_id">
+              <%= @order.payments.valid.take.try(:source).try(:risk_decision) %>
+            </td>
+          </tr>
+        <% end %>'
+)

data/app/overrides/spree/admin/shared/_refunds.rb

@@ -0,0 +1,13 @@
+Deface::Override.new(
+  virtual_path: 'spree/admin/shared/_refunds',
+  name: 'Remove refund edit button',
+  surround: 'erb[loud]:contains("edit_admin_order_payment_refund_path")',
+  text: '<% unless refund.payment.source_type.eql?(Spree::BraintreeCheckout.to_s) %><%= render_original %><% end %>'
+)
+
+Deface::Override.new(
+  virtual_path: 'spree/admin/shared/_refunds',
+  name: 'Fix spree identifier search',
+  replace: 'erb[loud]:contains("refund.payment.identifier")',
+  text: '<%= refund.payment.number %>'
+)

data/app/overrides/spree/checkout/_new_user.rb

@@ -0,0 +1,6 @@
+Deface::Override.new(
+  virtual_path: 'spree/checkout/_new_user',
+  name: 'Set proper email',
+  insert_after: 'erb[loud]:contains("form_for")',
+  text: '<% @user.email ||= params[:paypal_email] %>'
+)

data/app/overrides/spree/checkout/_payment.rb

@@ -0,0 +1,20 @@
+Deface::Override.new(
+  virtual_path: 'spree/checkout/_payment',
+  name: 'Modifies Paypal Express payment method on checkout',
+  surround: 'erb[loud]:contains("Spree.t(method.name, :scope => :payment_methods, :default => method.name)")',
+  text: %{
+    <% if method.is_a?(Spree::Gateway::BraintreeVzeroPaypalExpress) %>
+      <img src="https://www.paypalobjects.com/webstatic/mktg/logo/pp_cc_mark_37x23.jpg" border="0" alt="PayPal Logo">
+      <a href="https://www.paypal.com/webapps/mpp/paypal-popup" title="<%= Spree.t(:how_paypal_works) %>" onclick="javascript:window.open('https://www.paypal.com/webapps/mpp/paypal-popup', 'WIPaypal','toolbar=no, location=no, directories=no, status=no, menubar=no, scrollbars=yes, resizable=yes, width=1060, height=700'); return false;"> <%= Spree.t(:what_is_paypal) %></a>
+    <% else %>
+      <%= render_original %>
+    <% end %>
+  }
+)
+
+Deface::Override.new(
+  virtual_path: 'spree/checkout/_payment',
+  name: 'Adds necessary buttons for Braintree payment methods',
+  insert_after: 'erb[loud]:contains("submit_tag")',
+  partial: 'spree/checkout/payment/braintree_vzero/buttons'
+)

data/app/overrides/spree/checkout/registration.rb

@@ -0,0 +1,6 @@
+Deface::Override.new(
+  virtual_path: 'spree/checkout/registration',
+  name: 'Set proper email',
+  insert_after: 'erb[loud]:contains("form_for")',
+  text: '<% @order.email ||= params[:paypal_email] %>'
+)