spree_core 3.0.1 → 3.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1d168d119d3a44a1239b14adbbbbd73e6fe2d23e
-  data.tar.gz: a3fa4208dc96c9d0c279fcd46a579a309faed8de
+  metadata.gz: 7aeecb32436b2f2e63f695ae7f8e72e0fc5d3dff
+  data.tar.gz: d3d9c62816751345378389914b51d876ac8f2910
 SHA512:
-  metadata.gz: c968dcf2009be78df09de90f3760f77c945cc86c16d2ca356213defed6699f049fc8823303b737ab6518ce0cec7ff5243d317b8464147e19e90df97dc03d593c
-  data.tar.gz: 45a207f6c1c87d87f49d14f0f18798568cb0709ed35f0c8de036c23ef335bf1cb2bbf8046f31ed8b176d452252f7f910f3e1d9f3c7f6d71b4fb6ee2e875b8c07
+  metadata.gz: 36a03013620da8c4081e87c51c29722106df038560a5cc0da2a6c3d39e5441d073e7deb643c349aacf276d96fb0c53f6fa3bb880ba6082dcb5ef86add172c2ce
+  data.tar.gz: e7e6816d26ae750cc2c9b5faee24fe5814d280679758e77e271d9a35952dcb52eb85e4bd54fb9598a1ea0240426f4870a51eb29a3725457b4573381bbce1fcdb

data/app/models/friendly_id/slug_decorator.rb

@@ -0,0 +1,3 @@
+FriendlyId::Slug.class_eval do
+  acts_as_paranoid
+end

data/app/models/spree/adjustment.rb

@@ -24,7 +24,7 @@ module Spree
   class Adjustment < Spree::Base
     belongs_to :adjustable, polymorphic: true, touch: true
     belongs_to :source, polymorphic: true
-    belongs_to :order, class_name: "Spree::Order"
+    belongs_to :order, class_name: 'Spree::Order', inverse_of: :all_adjustments
 
     validates :adjustable, presence: true
     validates :order, presence: true

data/app/models/spree/calculator.rb

@@ -1,5 +1,10 @@
 module Spree
   class Calculator < Spree::Base
+    # Conditional check for backwards compatibilty since acts as paranoid was added late https://github.com/spree/spree/issues/5858
+    if connection.table_exists?(:spree_calculators) && connection.column_exists?(:spree_calculators, :deleted_at)
+      acts_as_paranoid
+    end
+
     belongs_to :calculable, polymorphic: true
 
     # This method calls a compute_<computable> method. must be overriden in concrete calculator.

data/app/models/spree/customer_return.rb

@@ -2,15 +2,17 @@ module Spree
   class CustomerReturn < Spree::Base
     belongs_to :stock_location
 
-    has_many :return_items, inverse_of: :customer_return
-    has_many :return_authorizations, through: :return_items
     has_many :reimbursements, inverse_of: :customer_return
+    has_many :return_authorizations, through: :return_items
+    has_many :return_items, inverse_of: :customer_return
 
     after_create :process_return!
     before_create :generate_number
 
     validates :return_items, presence: true
     validates :stock_location, presence: true
+
+    validate :must_have_return_authorization, on: :create
     validate :return_items_belong_to_same_order
 
     accepts_nested_attributes_for :return_items
@@ -18,8 +20,12 @@ module Spree
     extend DisplayMoney
     money_methods pre_tax_total: { currency: Spree::Config[:currency] }
 
-    def pre_tax_total
-      return_items.sum(:pre_tax_amount)
+    def completely_decided?
+      !return_items.undecided.exists?
+    end
+
+    def fully_reimbursed?
+      completely_decided? && return_items.accepted.includes(:reimbursement).all? { |return_item| return_item.reimbursement.try(:reimbursed?) }
     end
 
     # Temporarily tie a customer_return to one order
@@ -32,15 +38,21 @@ module Spree
       order.try(:id)
     end
 
-    def fully_reimbursed?
-      completely_decided? && return_items.accepted.includes(:reimbursement).all? { |return_item| return_item.reimbursement.try(:reimbursed?) }
+    def pre_tax_total
+      return_items.sum(:pre_tax_amount)
     end
 
-    def completely_decided?
-      !return_items.undecided.exists?
+    private
+
+    def inventory_units
+      return_items.flat_map(&:inventory_unit)
     end
 
-    private
+    def must_have_return_authorization
+      if item = return_items.find { |ri| ri.return_authorization.blank? }
+        errors.add(:base, Spree.t(:missing_return_authorization, item_name: item.inventory_unit.variant.name))
+      end
+    end
 
     def generate_number
       self.number ||= loop do
@@ -55,15 +67,9 @@ module Spree
     end
 
     def return_items_belong_to_same_order
-      if return_items.select{ |return_item| return_item.inventory_unit.order_id != order_id }.any?
+      if return_items.select { |return_item| return_item.inventory_unit.order_id != order_id }.any?
         errors.add(:base, Spree.t(:return_items_cannot_be_associated_with_multiple_orders))
       end
     end
-
-    def inventory_units
-      return_items.flat_map(&:inventory_unit)
-    end
-
   end
 end
-

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

@@ -60,6 +60,10 @@ module Spree
       ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345')
     end
 
+    def cancel(_response_code)
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345')
+    end
+
     def test?
       # Test mode is not really relevant with bogus gateway (no such thing as live server)
       true

data/app/models/spree/line_item.rb

@@ -132,8 +132,8 @@ module Spree
 
       def update_adjustments
         if quantity_changed?
-          update_tax_charge # Called to ensure pre_tax_amount is updated.
           recalculate_adjustments
+          update_tax_charge # Called to ensure pre_tax_amount is updated.
         end
       end
 

data/app/models/spree/order.rb

@@ -58,7 +58,7 @@ module Spree
     alias_attribute :shipping_address, :ship_address
 
     belongs_to :store, class_name: 'Spree::Store'
-    has_many :state_changes, as: :stateful
+    has_many :state_changes, as: :stateful, dependent: :destroy
     has_many :line_items, -> { order("#{LineItem.table_name}.created_at ASC") }, dependent: :destroy, inverse_of: :order
     has_many :payments, dependent: :destroy
     has_many :return_authorizations, dependent: :destroy, inverse_of: :order
@@ -70,6 +70,11 @@ module Spree
     has_many :products, through: :variants
     has_many :variants, through: :line_items
     has_many :refunds, through: :payments
+    has_many :all_adjustments,
+             class_name: 'Spree::Adjustment',
+             foreign_key: :order_id,
+             dependent: :destroy,
+             inverse_of: :order
 
     has_and_belongs_to_many :promotions, join_table: 'spree_orders_promotions'
 
@@ -99,6 +104,7 @@ module Spree
     validate :has_available_shipment
 
     delegate :update_totals, :persist_totals, :to => :updater
+    delegate :merge!, to: :merger
 
     class_attribute :update_hooks
     self.update_hooks = Set.new
@@ -132,11 +138,6 @@ module Spree
       self.line_item_comparison_hooks.add(hook)
     end
 
-    def all_adjustments
-      Adjustment.where("order_id = :order_id OR (adjustable_id = :order_id AND adjustable_type = 'Spree::Order')",
-                       order_id: self.id)
-    end
-
     # For compatiblity with Calculator::PriceSack
     def amount
       line_items.inject(0.0) { |sum, li| sum + li.amount }
@@ -205,6 +206,10 @@ module Spree
       updater.update
     end
 
+    def merger
+      @merger ||= Spree::OrderMerger.new(self)
+    end
+
     def clone_billing_address
       if bill_address and self.ship_address.nil?
         self.ship_address = bill_address.clone
@@ -229,16 +234,17 @@ module Spree
 
     # Associates the specified user with the order.
     def associate_user!(user, override_email = true)
-      self.user = user
-      attrs_to_set = { user_id: user.id }
-      attrs_to_set[:email] = user.email if override_email
-      attrs_to_set[:created_by_id] = user.id if self.created_by.blank?
-      assign_attributes(attrs_to_set)
+      self.user           = user
+      self.email          = user.email if override_email
+      self.created_by   ||= user
+      self.bill_address ||= user.bill_address
+      self.ship_address ||= user.ship_address
 
-      if persisted?
-        # immediately persist the changes we just made, but don't use save since we might have an invalid address associated
-        self.class.unscoped.where(id: id).update_all(attrs_to_set)
-      end
+      changes = slice(:user_id, :email, :created_by_id, :bill_address_id, :ship_address_id)
+
+      # immediately persist the changes we just made, but don't use save
+      # since we might have an invalid address associated
+      self.class.unscoped.where(id: self).update_all(changes)
     end
 
     def quantity_of(variant, options = {})
@@ -395,44 +401,12 @@ module Spree
       end
     end
 
-    def merge!(order, user = nil)
-      order.line_items.each do |other_order_line_item|
-        next unless other_order_line_item.currency == currency
-
-        # Compare the line items of the other order with mine.
-        # Make sure you allow any extensions to chime in on whether or
-        # not the extension-specific parts of the line item match
-        current_line_item = self.line_items.detect { |my_li|
-                      my_li.variant == other_order_line_item.variant &&
-                      self.line_item_comparison_hooks.all? { |hook|
-                        self.send(hook, my_li, other_order_line_item.serializable_hash)
-                      }
-                    }
-        if current_line_item
-          current_line_item.quantity += other_order_line_item.quantity
-          current_line_item.save!
-        else
-          other_order_line_item.order_id = self.id
-          other_order_line_item.save!
-        end
-      end
-
-      self.associate_user!(user) if !self.user && !user.blank?
-
-      updater.update_item_count
-      updater.update_item_total
-      updater.persist_totals
-
-      # So that the destroy doesn't take out line items which may have been re-assigned
-      order.line_items.reload
-      order.destroy
-    end
-
     def empty!
       line_items.destroy_all
       updater.update_item_count
       adjustments.destroy_all
       shipments.destroy_all
+      state_changes.destroy_all
 
       update_totals
       persist_totals

data/app/models/spree/order/checkout.rb

@@ -1,323 +1,338 @@
 module Spree
   class Order < Spree::Base
     module Checkout
-      def self.included(klass)
-        klass.class_eval do
-          class_attribute :next_event_transitions
-          class_attribute :previous_states
-          class_attribute :checkout_flow
-          class_attribute :checkout_steps
-          class_attribute :removed_transitions
-
-          def self.checkout_flow(&block)
-            if block_given?
-              @checkout_flow = block
-              define_state_machine!
-            else
-              @checkout_flow
-            end
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :next_event_transitions
+        class_attribute :previous_states
+        class_attribute :checkout_flow
+        class_attribute :checkout_steps
+        class_attribute :removed_transitions
+
+        self.checkout_steps ||= {}
+        self.next_event_transitions ||= []
+        self.previous_states ||= [:cart]
+        self.removed_transitions ||= []
+
+        def self.checkout_flow(&block)
+          if block_given?
+            @checkout_flow = block
+            define_state_machine!
+          else
+            @checkout_flow
           end
+        end
 
-          def self.define_state_machine!
-            self.checkout_steps = {}
-            self.next_event_transitions = []
-            self.previous_states = [:cart]
-            self.removed_transitions = []
-
-            # Build the checkout flow using the checkout_flow defined either
-            # within the Order class, or a decorator for that class.
-            #
-            # This method may be called multiple times depending on if the
-            # checkout_flow is re-defined in a decorator or not.
-            instance_eval(&checkout_flow)
-
-            klass = self
-
-            # To avoid a ton of warnings when the state machine is re-defined
-            StateMachines::Machine.ignore_method_conflicts = true
-            # To avoid multiple occurrences of the same transition being defined
-            # On first definition, state_machines will not be defined
-            state_machines.clear if respond_to?(:state_machines)
-            state_machine :state, initial: :cart, use_transactions: false, action: :save_state do
-              klass.next_event_transitions.each { |t| transition(t.merge(on: :next)) }
-
-              # Persist the state on the order
-              after_transition do |order, transition|
-                order.state = order.state
-                order.state_changes.create(
-                  previous_state: transition.from,
-                  next_state:     transition.to,
-                  name:           'order',
-                  user_id:        order.user_id
-                )
-                order.save
-              end
+        def self.define_state_machine!
+          self.checkout_steps = {}
+          self.next_event_transitions = []
+          self.previous_states = [:cart]
+          self.removed_transitions = []
 
-              event :cancel do
-                transition to: :canceled, if: :allow_cancel?
-              end
+          # Build the checkout flow using the checkout_flow defined either
+          # within the Order class, or a decorator for that class.
+          #
+          # This method may be called multiple times depending on if the
+          # checkout_flow is re-defined in a decorator or not.
+          instance_eval(&checkout_flow)
+
+          klass = self
+
+          # To avoid a ton of warnings when the state machine is re-defined
+          StateMachines::Machine.ignore_method_conflicts = true
+          # To avoid multiple occurrences of the same transition being defined
+          # On first definition, state_machines will not be defined
+          state_machines.clear if respond_to?(:state_machines)
+          state_machine :state, initial: :cart, use_transactions: false, action: :save_state do
+            klass.next_event_transitions.each { |t| transition(t.merge(on: :next)) }
+
+            # Persist the state on the order
+            after_transition do |order, transition|
+              order.state = order.state
+              order.state_changes.create(
+                previous_state: transition.from,
+                next_state:     transition.to,
+                name:           'order',
+                user_id:        order.user_id
+              )
+              order.save
+            end
 
-              event :return do
-                transition to: :returned, from: [:complete, :awaiting_return, :canceled], if: :all_inventory_units_returned?
-              end
+            event :cancel do
+              transition to: :canceled, if: :allow_cancel?
+            end
 
-              event :resume do
-                transition to: :resumed, from: :canceled, if: :canceled?
-              end
+            event :return do
+              transition to: :returned,
+                         from: [:complete, :awaiting_return, :canceled],
+                         if: :all_inventory_units_returned?
+            end
 
-              event :authorize_return do
-                transition to: :awaiting_return
-              end
+            event :resume do
+              transition to: :resumed, from: :canceled, if: :canceled?
+            end
+
+            event :authorize_return do
+              transition to: :awaiting_return
+            end
 
-              if states[:payment]
-                before_transition to: :complete do |order|
-                  if order.payment_required? && order.payments.valid.empty?
-                    order.errors.add(:base, Spree.t(:no_payment_found))
-                    false
-                  elsif order.payment_required?
-                    order.process_payments!
-                  end
+            if states[:payment]
+              before_transition to: :complete do |order|
+                if order.payment_required? && order.payments.valid.empty?
+                  order.errors.add(:base, Spree.t(:no_payment_found))
+                  false
+                elsif order.payment_required?
+                  order.process_payments!
                 end
-                after_transition to: :complete, do: :persist_user_credit_card
-                before_transition to: :payment, do: :set_shipments_cost
-                before_transition to: :payment, do: :create_tax_charge!
-                before_transition to: :payment, do: :assign_default_credit_card
               end
+              after_transition to: :complete, do: :persist_user_credit_card
+              before_transition to: :payment, do: :set_shipments_cost
+              before_transition to: :payment, do: :create_tax_charge!
+              before_transition to: :payment, do: :assign_default_credit_card
+            end
 
-              before_transition from: :cart, do: :ensure_line_items_present
+            before_transition from: :cart, do: :ensure_line_items_present
 
-              if states[:address]
-                before_transition from: :address, do: :create_tax_charge!
-                before_transition to: :address, do: :assign_default_addresses!
-                before_transition from: :address, do: :persist_user_address!
-              end
+            if states[:address]
+              before_transition from: :address, do: :create_tax_charge!
+              before_transition to: :address, do: :assign_default_addresses!
+              before_transition from: :address, do: :persist_user_address!
+            end
 
-              if states[:delivery]
-                before_transition to: :delivery, do: :create_proposed_shipments
-                before_transition to: :delivery, do: :ensure_available_shipping_rates
-                before_transition to: :delivery, do: :set_shipments_cost
-                before_transition from: :delivery, do: :apply_free_shipping_promotions
-              end
+            if states[:delivery]
+              before_transition to: :delivery, do: :create_proposed_shipments
+              before_transition to: :delivery, do: :ensure_available_shipping_rates
+              before_transition to: :delivery, do: :set_shipments_cost
+              before_transition from: :delivery, do: :apply_free_shipping_promotions
+            end
 
-              before_transition to: :resumed, do: :ensure_line_item_variants_are_not_deleted
-              before_transition to: :resumed, do: :ensure_line_items_are_in_stock
+            before_transition to: :resumed, do: :ensure_line_item_variants_are_not_deleted
+            before_transition to: :resumed, do: :ensure_line_items_are_in_stock
 
-              before_transition to: :complete, do: :ensure_line_item_variants_are_not_deleted
-              before_transition to: :complete, do: :ensure_line_items_are_in_stock
+            before_transition to: :complete, do: :ensure_line_item_variants_are_not_deleted
+            before_transition to: :complete, do: :ensure_line_items_are_in_stock
 
-              after_transition to: :complete, do: :finalize!
-              after_transition to: :resumed,  do: :after_resume
-              after_transition to: :canceled, do: :after_cancel
+            after_transition to: :complete, do: :finalize!
+            after_transition to: :resumed,  do: :after_resume
+            after_transition to: :canceled, do: :after_cancel
 
-              after_transition from: any - :cart, to: any - [:confirm, :complete] do |order|
-                order.update_totals
-                order.persist_totals
-              end
+            after_transition from: any - :cart, to: any - [:confirm, :complete] do |order|
+              order.update_totals
+              order.persist_totals
             end
+          end
 
-            alias_method :save_state, :save
+          alias_method :save_state, :save
+        end
+
+        def self.go_to_state(name, options = {})
+          self.checkout_steps[name] = options
+          previous_states.each do |state|
+            add_transition({ from: state, to: name }.merge(options))
+          end
+          if options[:if]
+            previous_states << name
+          else
+            self.previous_states = [name]
           end
+        end
 
-          def self.go_to_state(name, options={})
-            self.checkout_steps[name] = options
-            previous_states.each do |state|
-              add_transition({from: state, to: name}.merge(options))
+        def self.insert_checkout_step(name, options = {})
+          before = options.delete(:before)
+          after = options.delete(:after) unless before
+          after = self.checkout_steps.keys.last unless before || after
+
+          cloned_steps = self.checkout_steps.clone
+          cloned_removed_transitions = self.removed_transitions.clone
+          checkout_flow do
+            cloned_steps.each_pair do |key, value|
+              go_to_state(name, options) if key == before
+              go_to_state(key, value)
+              go_to_state(name, options) if key == after
             end
-            if options[:if]
-              self.previous_states << name
-            else
-              self.previous_states = [name]
+            cloned_removed_transitions.each do |transition|
+              remove_transition(transition)
             end
           end
+        end
 
-          def self.insert_checkout_step(name, options = {})
-            before = options.delete(:before)
-            after = options.delete(:after) unless before
-            after = self.checkout_steps.keys.last unless before || after
-
-            cloned_steps = self.checkout_steps.clone
-            cloned_removed_transitions = self.removed_transitions.clone
-            self.checkout_flow do
-              cloned_steps.each_pair do |key, value|
-                self.go_to_state(name, options) if key == before
-                self.go_to_state(key, value)
-                self.go_to_state(name, options) if key == after
-              end
-              cloned_removed_transitions.each do |transition|
-                self.remove_transition(transition)
-              end
+        def self.remove_checkout_step(name)
+          cloned_steps = self.checkout_steps.clone
+          cloned_removed_transitions = self.removed_transitions.clone
+          checkout_flow do
+            cloned_steps.each_pair do |key, value|
+              go_to_state(key, value) unless key == name
             end
-          end
-
-          def self.remove_checkout_step(name)
-            cloned_steps = self.checkout_steps.clone
-            cloned_removed_transitions = self.removed_transitions.clone
-            self.checkout_flow do
-              cloned_steps.each_pair do |key, value|
-                self.go_to_state(key, value) unless key == name
-              end
-              cloned_removed_transitions.each do |transition|
-                self.remove_transition(transition)
-              end
+            cloned_removed_transitions.each do |transition|
+              remove_transition(transition)
             end
           end
+        end
 
-          def self.remove_transition(options={})
-            self.removed_transitions << options
-            self.next_event_transitions.delete(find_transition(options))
-          end
-
-          def self.find_transition(options={})
-            return nil if options.nil? || !options.include?(:from) || !options.include?(:to)
-            self.next_event_transitions.detect do |transition|
-              transition[options[:from].to_sym] == options[:to].to_sym
-            end
-          end
+        def self.remove_transition(options = {})
+          self.removed_transitions << options
+          self.next_event_transitions.delete(find_transition(options))
+        end
 
-          def self.next_event_transitions
-            @next_event_transitions ||= []
+        def self.find_transition(options = {})
+          return nil if options.nil? || !options.include?(:from) || !options.include?(:to)
+          self.next_event_transitions.detect do |transition|
+            transition[options[:from].to_sym] == options[:to].to_sym
           end
+        end
 
-          def self.checkout_steps
-            @checkout_steps ||= {}
-          end
+        def self.checkout_step_names
+          self.checkout_steps.keys
+        end
 
-          def self.checkout_step_names
-            self.checkout_steps.keys
-          end
+        def self.add_transition(options)
+          self.next_event_transitions << { options.delete(:from) => options.delete(:to) }.merge(options)
+        end
 
-          def self.add_transition(options)
-            self.next_event_transitions << { options.delete(:from) => options.delete(:to) }.merge(options)
-          end
+        def checkout_steps
+          steps = (self.class.checkout_steps.each_with_object([]) do |(step, options), checkout_steps|
+            next if options.include?(:if) && !options[:if].call(self)
+            checkout_steps << step
+          end).map(&:to_s)
+          # Ensure there is always a complete step
+          steps << "complete" unless steps.include?("complete")
+          steps
+        end
 
-          def checkout_steps
-            steps = self.class.checkout_steps.each_with_object([]) { |(step, options), checkout_steps|
-              next if options.include?(:if) && !options[:if].call(self)
-              checkout_steps << step
-            }.map(&:to_s)
-            # Ensure there is always a complete step
-            steps << "complete" unless steps.include?("complete")
-            steps
-          end
+        def has_checkout_step?(step)
+          step.present? && self.checkout_steps.include?(step)
+        end
 
-          def has_checkout_step?(step)
-            step.present? && self.checkout_steps.include?(step)
-          end
+        def passed_checkout_step?(step)
+          has_checkout_step?(step) && checkout_step_index(step) < checkout_step_index(state)
+        end
 
-          def passed_checkout_step?(step)
-            has_checkout_step?(step) && checkout_step_index(step) < checkout_step_index(self.state)
-          end
+        def checkout_step_index(step)
+          self.checkout_steps.index(step).to_i
+        end
 
-          def checkout_step_index(step)
-            self.checkout_steps.index(step).to_i
-          end
+        def can_go_to_state?(state)
+          return false unless has_checkout_step?(self.state) && has_checkout_step?(state)
+          checkout_step_index(state) > checkout_step_index(self.state)
+        end
 
-          def self.removed_transitions
-            @removed_transitions ||= []
-          end
+        define_callbacks :updating_from_params, terminator: ->(_target, result) { result == false }
 
-          def can_go_to_state?(state)
-            return false unless has_checkout_step?(self.state) && has_checkout_step?(state)
-            checkout_step_index(state) > checkout_step_index(self.state)
-          end
+        set_callback :updating_from_params, :before, :update_params_payment_source
 
-          define_callbacks :updating_from_params, terminator: ->(target, result) { result == false }
+        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
 
-          set_callback :updating_from_params, :before, :update_params_payment_source
+            attributes = @updating_params[:order] ? @updating_params[:order].permit(permitted_params).delete_if { |_k, v| v.nil? } : {}
 
-          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
+            if existing_card_id.present?
+              credit_card = CreditCard.find existing_card_id
+              if credit_card.user_id != user_id || credit_card.user_id.blank?
+                raise Core::GatewayError.new Spree.t(:invalid_credit_card)
+              end
 
-              attributes = @updating_params[:order] ? @updating_params[:order].permit(permitted_params).delete_if { |k,v| v.nil? } : {}
+              credit_card.verification_value = params[:cvc_confirm] if params[:cvc_confirm].present?
 
-              if existing_card_id.present?
-                credit_card = CreditCard.find existing_card_id
-                if credit_card.user_id != self.user_id || credit_card.user_id.blank?
-                  raise Core::GatewayError.new Spree.t(:invalid_credit_card)
-                end
+              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
 
-                credit_card.verification_value = params[:cvc_confirm] if params[:cvc_confirm].present?
+            if attributes[:payments_attributes]
+              attributes[:payments_attributes].first[:request_env] = request_env
+            end
 
-                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
+            success = update_attributes(attributes)
+            set_shipments_cost if shipments.any?
+          end
 
-              if attributes[:payments_attributes]
-                attributes[:payments_attributes].first[:request_env] = request_env
-              end
+          @updating_params = nil
+          success
+        end
 
-              success = self.update_attributes(attributes)
-              set_shipments_cost if self.shipments.any?
-            end
+        def assign_default_addresses!
+          if user
+            clone_billing
+            # Skip setting ship address if order doesn't have a delivery checkout step
+            # to avoid triggering validations on shipping address
+            clone_shipping if checkout_steps.include?("delivery")
+          end
+        end
 
-            @updating_params = nil
-            success
+        def clone_billing
+          if !bill_address_id && user.bill_address.try(:valid?)
+            self.bill_address = user.bill_address.try(:clone)
           end
+        end
 
-          def assign_default_addresses!
-            if self.user
-              self.bill_address = user.bill_address.try(:clone) if !self.bill_address_id && user.bill_address.try(:valid?)
-              # Skip setting ship address if order doesn't have a delivery checkout step
-              # to avoid triggering validations on shipping address
-              self.ship_address = user.ship_address.try(:clone) if !self.ship_address_id && user.ship_address.try(:valid?) && self.checkout_steps.include?("delivery")
-            end
+        def clone_shipping
+          if !ship_address_id && user.ship_address.try(:valid?)
+            self.ship_address = user.ship_address.try(:clone)
           end
+        end
 
-          def persist_user_address!
-            if !self.temporary_address && self.user && self.user.respond_to?(:persist_order_address) && self.bill_address_id
-              self.user.persist_order_address(self)
-            end
+        def persist_user_address!
+          if !temporary_address && user && user.respond_to?(:persist_order_address) && bill_address_id
+            user.persist_order_address(self)
           end
+        end
 
-          def persist_user_credit_card
-            if !self.temporary_credit_card && self.user_id && self.valid_credit_cards.present?
-              default_cc = self.valid_credit_cards.first
-              default_cc.user_id = self.user_id
-              default_cc.default = true
-              default_cc.save
-            end
+        def persist_user_credit_card
+          if !temporary_credit_card && user_id && valid_credit_cards.present?
+            default_cc = valid_credit_cards.first
+            default_cc.user_id = user_id
+            default_cc.default = true
+            default_cc.save
           end
+        end
 
-          def assign_default_credit_card
-            if self.payments.from_credit_card.count == 0 && self.user && self.user.default_credit_card.try(:valid?)
-              cc = self.user.default_credit_card
-              self.payments.create!(payment_method_id: cc.payment_method_id, source: cc)
-            end
+        def assign_default_credit_card
+          if payments.from_credit_card.count == 0 && user_has_valid_default_card? && payment_required?
+            cc = user.default_credit_card
+            payments.create!(payment_method_id: cc.payment_method_id, source: cc, amount: total)
           end
+        end
 
-          private
-          # For payment step, filter order parameters to produce the expected nested
-          # attributes for a single payment and its source, discarding attributes
-          # for payment methods other than the one selected
-          #
-          # In case a existing credit card is provided it needs to build the payment
-          # attributes from scratch so we can set the amount. example payload:
-          #
-          #   {
-          #     "order": {
-          #       "existing_card": "2"
-          #     }
-          #   }
-          #
-          def update_params_payment_source
-            if @updating_params[:payment_source].present?
-              source_params = @updating_params.delete(:payment_source)[@updating_params[:order][:payments_attributes].first[:payment_method_id].to_s]
+        def user_has_valid_default_card?
+          user && user.default_credit_card.try(:valid?)
+        end
 
-              if source_params
-                @updating_params[:order][:payments_attributes].first[:source_attributes] = source_params
-              end
+        private
+
+        # For payment step, filter order parameters to produce the expected nested
+        # attributes for a single payment and its source, discarding attributes
+        # for payment methods other than the one selected
+        #
+        # In case a existing credit card is provided it needs to build the payment
+        # attributes from scratch so we can set the amount. example payload:
+        #
+        #   {
+        #     "order": {
+        #       "existing_card": "2"
+        #     }
+        #   }
+        #
+        def update_params_payment_source
+          if @updating_params[:payment_source].present?
+            source_params = @updating_params.
+                            delete(:payment_source)[@updating_params[:order][:payments_attributes].
+                                                    first[:payment_method_id].to_s]
+
+            if source_params
+              @updating_params[:order][:payments_attributes].first[:source_attributes] = source_params
             end
+          end
 
-            if @updating_params[:order] && (@updating_params[:order][:payments_attributes] || @updating_params[:order][:existing_card])
-              @updating_params[:order][:payments_attributes] ||= [{}]
-              @updating_params[:order][:payments_attributes].first[:amount] = self.total
-            end
+          if @updating_params[:order] && (@updating_params[:order][:payments_attributes] ||
+                                          @updating_params[:order][:existing_card])
+            @updating_params[:order][:payments_attributes] ||= [{}]
+            @updating_params[:order][:payments_attributes].first[:amount] = total
           end
         end
       end