spree_core 2.3.13 → 2.4.0.rc1

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

@@ -58,7 +58,7 @@ module Spree
               end
 
               event :return do
-                transition to: :returned, from: :awaiting_return, unless: :awaiting_returns?
+                transition to: :returned, from: [:complete, :awaiting_return, :canceled], if: :all_inventory_units_returned?
               end
 
               event :resume do
@@ -78,6 +78,10 @@ module Spree
                     order.process_payments!
                   end
                 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
@@ -88,11 +92,6 @@ module Spree
                 before_transition from: :address, do: :persist_user_address!
               end
 
-              if states[:payment]
-                before_transition to: :payment, do: :set_shipments_cost
-                before_transition to: :payment, do: :create_tax_charge!
-              end
-
               if states[:delivery]
                 before_transition to: :delivery, do: :create_proposed_shipments
                 before_transition to: :delivery, do: :ensure_available_shipping_rates
@@ -102,8 +101,6 @@ module Spree
 
               before_transition to: :resumed, do: :ensure_line_items_are_in_stock
 
-              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
@@ -203,8 +200,12 @@ module Spree
             step.present? && self.checkout_steps.include?(step)
           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)
+            self.checkout_steps.index(step).to_i
           end
 
           def self.removed_transitions
@@ -228,10 +229,7 @@ module Spree
 
               # Set existing card after setting permitted parameters because
               # rails would slice parameters containg ruby objects, apparently
-              #
-              # Need to check both outside and inside :order beacuse frontend
-              # sends existing_card out of :order
-              existing_card_id = @updating_params[:existing_card] || (@updating_params[:order] ? @updating_params[:order][:existing_card] : nil)
+              existing_card_id = @updating_params[:order] ? @updating_params[:order][:existing_card] : nil
 
               if existing_card_id.present?
                 credit_card = CreditCard.find existing_card_id
@@ -273,6 +271,22 @@ module Spree
             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
+          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
+          end
+
           private
           # For payment step, filter order parameters to produce the expected nested
           # attributes for a single payment and its source, discarding attributes
@@ -288,19 +302,17 @@ module Spree
           #   }
           #
           def update_params_payment_source
-            if has_checkout_step?("payment") && self.payment?
-              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 @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
+              if source_params
+                @updating_params[:order][:payments_attributes].first[:source_attributes] = source_params
               end
+            end
 
-              if @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] = self.total
             end
           end
         end

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

@@ -0,0 +1,66 @@
+module Spree
+  class Order < Spree::Base
+    module Payments
+      extend ActiveSupport::Concern
+      included do
+        # processes any pending payments and must return a boolean as it's
+        # return value is used by the checkout state_machine to determine
+        # success or failure of the 'complete' event for the order
+        #
+        # Returns:
+        #
+        # - true if all pending_payments processed successfully
+        #
+        # - true if a payment failed, ie. raised a GatewayError
+        #   which gets rescued and converted to TRUE when
+        #   :allow_checkout_gateway_error is set to true
+        #
+        # - false if a payment failed, ie. raised a GatewayError
+        #   which gets rescued and converted to FALSE when
+        #   :allow_checkout_on_gateway_error is set to false
+        #
+        def process_payments!
+          process_payments_with(:process!)
+        end
+
+        def authorize_payments!
+          process_payments_with(:authorize!)
+        end
+
+        def capture_payments!
+          process_payments_with(:purchase!)
+        end
+
+        def pending_payments
+          payments.select { |payment| payment.pending? }
+        end
+
+        def unprocessed_payments
+          payments.select { |payment| payment.checkout? }
+        end
+
+        private
+
+        def process_payments_with(method)
+          # Don't run if there is nothing to pay.
+          return if payment_total >= total
+          # Prevent orders from transitioning to complete without a successfully processed payment.
+          raise Core::GatewayError.new(Spree.t(:no_payment_found)) if unprocessed_payments.empty?
+
+          unprocessed_payments.each do |payment|
+            break if payment_total >= total
+
+            payment.public_send(method)
+
+            if payment.completed?
+              self.payment_total += payment.amount
+            end
+          end
+        rescue Core::GatewayError => e
+          result = !!Spree::Config[:allow_checkout_on_gateway_error]
+          errors.add(:base, e.message) and return result
+        end
+      end
+    end
+  end
+end

data/app/models/spree/order_contents.rb

@@ -6,9 +6,10 @@ module Spree
       @order = order
     end
 
-    def add(variant, quantity = 1, currency = nil, shipment = nil)
-      line_item = add_to_line_item(variant, quantity, currency, shipment)
+    def add(variant, quantity = 1, options = {})
+      line_item = add_to_line_item(variant, quantity, options)
       reload_totals
+      shipment = options[:shipment]
       shipment.present? ? shipment.update_amounts : order.ensure_updated_shipments
       PromotionHandler::Cart.new(order, line_item).activate
       ItemAdjustments.new(line_item).update
@@ -16,9 +17,10 @@ module Spree
       line_item
     end
 
-    def remove(variant, quantity = 1, shipment = nil)
-      line_item = remove_from_line_item(variant, quantity, shipment)
+    def remove(variant, quantity = 1, options = {})
+      line_item = remove_from_line_item(variant, quantity, options)
       reload_totals
+      shipment = options[:shipment]
       shipment.present? ? shipment.update_amounts : order.ensure_updated_shipments
       PromotionHandler::Cart.new(order, line_item).activate
       ItemAdjustments.new(line_item).update
@@ -27,8 +29,8 @@ module Spree
     end
 
     def update_cart(params)
-      if order.update_attributes(params)
-        order.line_items = order.line_items.select {|li| li.quantity > 0 }
+      if order.update_attributes(filter_order_items(params))
+        order.line_items = order.line_items.select { |li| li.quantity > 0 }
         # Update totals, then check if the order is eligible for any cart promotions.
         # If we do not update first, then the item total will be wrong and ItemTotal
         # promotion rules would not be triggered.
@@ -43,6 +45,18 @@ module Spree
     end
 
     private
+
+      def filter_order_items(params)
+        filtered_params = params.symbolize_keys
+        return filtered_params if filtered_params[:line_items_attributes].nil? || filtered_params[:line_items_attributes][:id]
+
+        params[:line_items_attributes].each_pair do |id, value|
+          line_item_id = value[:id]
+          filtered_params[:line_items_attributes].delete(id) unless Spree::LineItem.find_by_id(line_item_id.to_i)
+        end
+        filtered_params
+      end
+
       def order_updater
         @updater ||= OrderUpdater.new(order)
       end
@@ -53,32 +67,28 @@ module Spree
         order.reload
       end
 
-      def add_to_line_item(variant, quantity, currency=nil, shipment=nil)
-        line_item = grab_line_item_by_variant(variant)
+      def add_to_line_item(variant, quantity, options = {})
+        line_item = grab_line_item_by_variant(variant, false, options)
 
         if line_item
-          line_item.target_shipment = shipment
           line_item.quantity += quantity.to_i
           line_item.currency = currency unless currency.nil?
         else
-          line_item = order.line_items.new(quantity: quantity, variant: variant)
-          line_item.target_shipment = shipment
-          if currency
-            line_item.currency = currency
-            line_item.price    = variant.price_in(currency).amount
-          else
-            line_item.price    = variant.price
-          end
+          opts = { currency: order.currency }.merge ActionController::Parameters.new(options).
+                                              permit(PermittedAttributes.line_item_attributes)
+          line_item = order.line_items.new(quantity: quantity,
+                                            variant: variant,
+                                            options: opts)
         end
-
-        line_item.save
+        line_item.target_shipment = options[:shipment] if options.has_key? :shipment
+        line_item.save!
         line_item
       end
 
-      def remove_from_line_item(variant, quantity, shipment=nil)
-        line_item = grab_line_item_by_variant(variant, true)
+      def remove_from_line_item(variant, quantity, options = {})
+        line_item = grab_line_item_by_variant(variant, true, options)
         line_item.quantity -= quantity
-        line_item.target_shipment= shipment
+        line_item.target_shipment= options[:shipment]
 
         if line_item.quantity == 0
           line_item.destroy
@@ -89,8 +99,8 @@ module Spree
         line_item
       end
 
-      def grab_line_item_by_variant(variant, raise_error = false)
-        line_item = order.find_line_item_by_variant(variant)
+      def grab_line_item_by_variant(variant, raise_error = false, options = {})
+        line_item = order.find_line_item_by_variant(variant, options)
 
         if !line_item.present? && raise_error
           raise ActiveRecord::RecordNotFound, "Line item not found for variant #{variant.sku}"

data/app/models/spree/order_populator.rb

@@ -9,8 +9,10 @@ module Spree
       @errors = ActiveModel::Errors.new(self)
     end
 
-    def populate(variant_id, quantity)
-      attempt_cart_add(variant_id, quantity)
+    def populate(variant_id, quantity, options = {})
+      # protect against passing a nil hash being passed in
+      # due to an empty params[:options]
+      attempt_cart_add(variant_id, quantity, options || {})
       valid?
     end
 
@@ -20,7 +22,7 @@ module Spree
 
     private
 
-    def attempt_cart_add(variant_id, quantity)
+    def attempt_cart_add(variant_id, quantity, options = {})
       quantity = quantity.to_i
       # 2,147,483,647 is crazy.
       # See issue #2695.
@@ -31,7 +33,7 @@ module Spree
 
       variant = Spree::Variant.find(variant_id)
       if quantity > 0
-        line_item = @order.contents.add(variant, quantity, currency)
+        line_item = @order.contents.add(variant, quantity, options.merge(currency: currency))
         unless line_item.valid?
           errors.add(:base, line_item.errors.messages.values.join(" "))
           return false

data/app/models/spree/order_updater.rb

@@ -24,6 +24,7 @@ module Spree
       run_hooks
       persist_totals
     end
+    Spree.instrument_method self, :update
 
     def run_hooks
       update_hooks.each { |hook| order.send hook }
@@ -111,6 +112,7 @@ module Spree
         updated_at: Time.now,
       )
     end
+    Spree.instrument_method self, :persist_totals
 
     # Updates the +shipment_state+ attribute according to the following logic:
     #
@@ -158,7 +160,9 @@ module Spree
       last_state = order.payment_state
       if payments.present? && payments.valid.size == 0
         order.payment_state = 'failed'
-      elsif order.state == 'canceled' && order.payment_total == 0
+      elsif !payments.present? && order.state == 'canceled'
+        order.payment_state = 'void'
+      elsif order.state == 'canceled' && order.payment_total == 0 && payments.completed.size > 0
         order.payment_state = 'void'
       else
         order.payment_state = 'balance_due' if order.outstanding_balance > 0
@@ -168,5 +172,10 @@ module Spree
       order.state_changed('payment') if last_state != order.payment_state
       order.payment_state
     end
+
+    private
+      def round_money(n)
+        (n * 100).round / 100.0
+      end
   end
 end

data/app/models/spree/payment.rb

@@ -8,15 +8,14 @@ module Spree
 
     belongs_to :order, class_name: 'Spree::Order', touch: true, inverse_of: :payments
     belongs_to :source, polymorphic: true
-    belongs_to :payment_method, class_name: 'Spree::PaymentMethod', inverse_of: :payments
+    belongs_to :payment_method, class_name: 'Spree::PaymentMethod'
 
-    has_many :offsets, -> { where("source_type = 'Spree::Payment' AND amount < 0 AND state = 'completed'") },
-      class_name: "Spree::Payment", foreign_key: :source_id
+    has_many :offsets, -> { offset_payment }, class_name: "Spree::Payment", foreign_key: :source_id
     has_many :log_entries, as: :source
     has_many :state_changes, as: :stateful
     has_many :capture_events, :class_name => 'Spree::PaymentCaptureEvent'
+    has_many :refunds, inverse_of: :payment
 
-    validates_presence_of :payment_method
     before_validation :validate_source
     before_create :set_unique_identifier
 
@@ -39,13 +38,23 @@ module Spree
 
     scope :from_credit_card, -> { where(source_type: 'Spree::CreditCard') }
     scope :with_state, ->(s) { where(state: s.to_s) }
+    # "offset" is reserved by activerecord
+    scope :offset_payment, -> { where("source_type = 'Spree::Payment' AND amount < 0 AND state = 'completed'") }
+
+    scope :checkout, -> { with_state('checkout') }
     scope :completed, -> { with_state('completed') }
     scope :pending, -> { with_state('pending') }
     scope :processing, -> { with_state('processing') }
     scope :failed, -> { with_state('failed') }
+
     scope :risky, -> { where("avs_response IN (?) OR (cvv_response_code IS NOT NULL and cvv_response_code != 'M') OR state = 'failed'", RISKY_AVS_CODES) }
     scope :valid, -> { where.not(state: %w(failed invalid)) }
 
+    # transaction_id is much easier to understand
+    def transaction_id
+      response_code
+    end
+
     def persist_invalid
       return unless ['failed', 'invalid'].include?(state)
       state_will_change!
@@ -115,7 +124,7 @@ module Spree
     end
 
     def credit_allowed
-      amount - offsets_total.abs
+      amount - (offsets_total.abs + refunds.sum(:amount))
     end
 
     def can_credit?
@@ -158,10 +167,6 @@ module Spree
       amount - capture_events.sum(:amount)
     end
 
-    def editable?
-      checkout? || pending?
-    end
-
     private
 
       def validate_source
@@ -179,8 +184,8 @@ module Spree
       end
 
       def create_payment_profile
-        return unless source.respond_to?(:has_payment_profile?) && !source.has_payment_profile?
-        return if %w(invalid failed).include?(state)
+        # Payment profile cannot be created without source
+        return unless source
         # Imported payments shouldn't create a payment profile.
         return if source.imported
 
@@ -190,15 +195,13 @@ module Spree
       end
 
       def invalidate_old_payments
-        if state != 'invalid' and state != 'failed'
-          order.payments.with_state('checkout').where("id != ?", self.id).each do |payment|
-            payment.invalidate!
-          end
+        order.payments.with_state('checkout').where("id != ?", self.id).each do |payment|
+          payment.invalidate!
         end
       end
 
       def update_order
-        if completed? || void?
+        if self.completed?
           order.updater.update_payment_total
         end