spree_core 2.1.12 → 2.2.0

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

@@ -84,11 +84,22 @@ module Spree
               if states[:delivery]
                 before_transition :to => :delivery, :do => :create_proposed_shipments
                 before_transition :to => :delivery, :do => :ensure_available_shipping_rates
+                before_transition :from => :delivery, :do => :apply_free_shipping_promotions
+              end
+
+              if states[:payment]
+                before_transition :to => :payment, :do => :set_shipments_cost
+                before_transition :to => :payment, :do => :create_tax_charge!
               end
 
               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
             end
           end
 
@@ -190,6 +201,43 @@ module Spree
             return false unless has_checkout_step?(self.state) && has_checkout_step?(state)
             checkout_step_index(state) > checkout_step_index(self.state)
           end
+
+          define_callbacks :updating_from_params, terminator: 'result == false'
+
+          set_callback :updating_from_params, :before, :update_params_payment_source
+
+          def update_from_params(params, permitted_params)
+            success = false
+            @updating_params = params
+            run_callbacks :updating_from_params do
+              attributes = @updating_params[:order] ? @updating_params[:order].permit(permitted_params) : {}
+              success = self.update_attributes(attributes)
+            end
+            @updating_params = nil
+            success
+          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
+          def update_params_payment_source
+            # respond_to check is necessary due to issue described in #2910
+            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].underscore]
+
+                if source_params
+                  @updating_params[:order][:payments_attributes].first[:source_attributes] = source_params
+                end
+              end
+
+              if (@updating_params[:order][:payments_attributes])
+                @updating_params[:order][:payments_attributes].first[:amount] = self.total
+              end
+            end
+          end
+
         end
       end
     end

data/app/models/spree/order_contents.rb

@@ -6,62 +6,97 @@ module Spree
       @order = order
     end
 
-    # Get current line item for variant if exists
-    # Add variant qty to line_item
     def add(variant, quantity = 1, currency = nil, shipment = nil)
-      line_item = order.find_line_item_by_variant(variant)
-      add_to_line_item(line_item, variant, quantity, currency, shipment)
+      line_item = add_to_line_item(variant, quantity, currency, shipment)
+      reload_totals
+      PromotionHandler::Cart.new(order, line_item).activate
+      ItemAdjustments.new(line_item).update
+      reload_totals
+      line_item
     end
 
-    # Get current line item for variant
-    # Remove variant qty from line_item
     def remove(variant, quantity = 1, shipment = nil)
-      line_item = order.find_line_item_by_variant(variant)
+      line_item = remove_from_line_item(variant, quantity, shipment)
+      reload_totals
+      PromotionHandler::Cart.new(order, line_item).activate
+      ItemAdjustments.new(line_item).update
+      reload_totals
+      line_item
+    end
 
-      unless line_item
-        raise ActiveRecord::RecordNotFound, "Line item not found for variant #{variant.sku}"
+    def update_cart(params)
+      if order.update_attributes(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.
+        reload_totals
+        PromotionHandler::Cart.new(order).activate
+        order.ensure_updated_shipments
+        reload_totals
+        true
+      else
+        false
       end
-
-      remove_from_line_item(line_item, variant, quantity, shipment)
     end
 
     private
+      def order_updater
+        @updater ||= OrderUpdater.new(order)
+      end
 
-    def add_to_line_item(line_item, variant, quantity, currency=nil, shipment=nil)
-      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
+      def reload_totals
+        order_updater.update_item_count
+        order_updater.update_item_total
+        order_updater.update_adjustment_total
+        order_updater.persist_totals
+        order.reload
+      end
+
+      def add_to_line_item(variant, quantity, currency=nil, shipment=nil)
+        line_item = grab_line_item_by_variant(variant)
+
+        if line_item
+          line_item.target_shipment = shipment
+          line_item.quantity += quantity.to_i
           line_item.currency = currency unless currency.nil?
-          line_item.price    = variant.price_in(currency).amount
         else
-          line_item.price    = variant.price
+          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
         end
+
+        line_item.save
+        line_item
       end
 
-      line_item.save
-      order.reload
-      line_item
-    end
+      def remove_from_line_item(variant, quantity, shipment=nil)
+        line_item = grab_line_item_by_variant(variant, true)
+        line_item.quantity += -quantity
+        line_item.target_shipment= shipment
 
-    def remove_from_line_item(line_item, variant, quantity, shipment=nil)
-      line_item.quantity += -quantity
-      line_item.target_shipment= shipment
+        if line_item.quantity == 0
+          line_item.destroy
+        else
+          line_item.save!
+        end
 
-      if line_item.quantity == 0
-        Spree::OrderInventory.new(order).verify(line_item, shipment)
-        line_item.destroy
-      else
-        line_item.save!
+        line_item
       end
 
-      order.reload
-      line_item
-    end
+      def grab_line_item_by_variant(variant, raise_error = false)
+        line_item = order.find_line_item_by_variant(variant)
 
+        if !line_item.present? && raise_error
+          raise ActiveRecord::RecordNotFound, "Line item not found for variant #{variant.sku}"
+        end
+
+        line_item
+      end
   end
 end

data/app/models/spree/order_inventory.rb

@@ -1,9 +1,11 @@
 module Spree
   class OrderInventory
-    attr_accessor :order
+    attr_accessor :order, :line_item, :variant
 
-    def initialize(order)
+    def initialize(order, line_item)
       @order = order
+      @line_item = line_item
+      @variant = line_item.variant
     end
 
     # Only verify inventory for completed orders (as orders in frontend checkout
@@ -13,98 +15,93 @@ module Spree
     # In case shipment is passed the stock location should only unstock or
     # restock items if the order is completed. That is so because stock items
     # are always unstocked when the order is completed through +shipment.finalize+
-    def verify(line_item, shipment = nil)
+    def verify(shipment = nil)
       if order.completed? || shipment.present?
 
-        variant_units = inventory_units_for(line_item.variant)
+        if inventory_units.size < line_item.quantity
+          quantity = line_item.quantity - inventory_units.size
 
-        if variant_units.size < line_item.quantity
-          quantity = line_item.quantity - variant_units.size
-
-          shipment = determine_target_shipment(line_item.variant) unless shipment
-          add_to_shipment(shipment, line_item.variant, quantity)
-        elsif variant_units.size > line_item.quantity
-          remove(line_item, variant_units, shipment)
+          shipment = determine_target_shipment unless shipment
+          add_to_shipment(shipment, quantity)
+        elsif inventory_units.size > line_item.quantity
+          remove(inventory_units, shipment)
         end
-      else
-        true
       end
     end
 
-    def inventory_units_for(variant)
-      units = order.shipments.collect{|s| s.inventory_units.to_a}.flatten
-      units.group_by(&:variant_id)[variant.id] || []
+    def inventory_units
+      line_item.inventory_units
     end
 
     private
-    def remove(line_item, variant_units, shipment = nil)
-      quantity = variant_units.size - line_item.quantity
-
-      if shipment.present?
-        remove_from_shipment(shipment, line_item.variant, quantity)
-      else
-        order.shipments.each do |shipment|
-          break if quantity == 0
-          quantity -= remove_from_shipment(shipment, line_item.variant, quantity)
+      def remove(item_units, shipment = nil)
+        quantity = item_units.size - line_item.quantity
+
+        if shipment.present?
+          remove_from_shipment(shipment, quantity)
+        else
+          order.shipments.each do |shipment|
+            break if quantity == 0
+            quantity -= remove_from_shipment(shipment, quantity)
+          end
         end
       end
-    end
 
-    # Returns either one of the shipment:
-    #
-    # first unshipped that already includes this variant
-    # first unshipped that's leaving from a stock_location that stocks this variant
-    def determine_target_shipment(variant)
-      shipment = order.shipments.detect do |shipment|
-        (shipment.ready? || shipment.pending?) && shipment.include?(variant)
-      end
+      # Returns either one of the shipment:
+      #
+      # first unshipped that already includes this variant
+      # first unshipped that's leaving from a stock_location that stocks this variant
+      def determine_target_shipment
+        shipment = order.shipments.detect do |shipment|
+          shipment.ready_or_pending? && shipment.include?(variant)
+        end
 
-      shipment ||= order.shipments.detect do |shipment|
-        (shipment.ready? || shipment.pending?) && variant.stock_location_ids.include?(shipment.stock_location_id)
+        shipment ||= order.shipments.detect do |shipment|
+          shipment.ready_or_pending? && variant.stock_location_ids.include?(shipment.stock_location_id)
+        end
       end
-    end
 
-    def add_to_shipment(shipment, variant, quantity)
-      if variant.should_track_inventory?
-        on_hand, back_order = shipment.stock_location.fill_status(variant, quantity)
+      def add_to_shipment(shipment, quantity)
+        if variant.should_track_inventory?
+          on_hand, back_order = shipment.stock_location.fill_status(variant, quantity)
 
-        on_hand.times { shipment.set_up_inventory('on_hand', variant, order) }
-        back_order.times { shipment.set_up_inventory('backordered', variant, order) }
-      else
-        quantity.times { shipment.set_up_inventory('on_hand', variant, order) }
-      end
+          on_hand.times { shipment.set_up_inventory('on_hand', variant, order, line_item) }
+          back_order.times { shipment.set_up_inventory('backordered', variant, order, line_item) }
+        else
+          quantity.times { shipment.set_up_inventory('on_hand', variant, order, line_item) }
+        end
 
-      # adding to this shipment, and removing from stock_location
-      if order.completed?
-        shipment.stock_location.unstock(variant, quantity, shipment)
+        # adding to this shipment, and removing from stock_location
+        if order.completed?
+          shipment.stock_location.unstock(variant, quantity, shipment)
+        end
+
+        quantity
       end
 
-      quantity
-    end
+      def remove_from_shipment(shipment, quantity)
+        return 0 if quantity == 0 || shipment.shipped?
 
-    def remove_from_shipment(shipment, variant, quantity)
-      return 0 if quantity == 0 || shipment.shipped?
+        shipment_units = shipment.inventory_units_for_item(line_item, variant).reject do |variant_unit|
+          variant_unit.state == 'shipped'
+        end.sort_by(&:state)
 
-      shipment_units = shipment.inventory_units_for(variant).reject do |variant_unit|
-        variant_unit.state == 'shipped'
-      end.sort_by(&:state)
+        removed_quantity = 0
 
-      removed_quantity = 0
+        shipment_units.each do |inventory_unit|
+          break if removed_quantity == quantity
+          inventory_unit.destroy
+          removed_quantity += 1
+        end
 
-      shipment_units.each do |inventory_unit|
-        break if removed_quantity == quantity
-        inventory_unit.destroy
-        removed_quantity += 1
-      end
+        shipment.destroy if shipment.inventory_units.count == 0
 
-      shipment.destroy if shipment.inventory_units.count == 0
+        # removing this from shipment, and adding to stock_location
+        if order.completed?
+          shipment.stock_location.restock variant, removed_quantity, shipment
+        end
 
-      # removing this from shipment, and adding to stock_location
-      if order.completed?
-        shipment.stock_location.restock variant, removed_quantity, shipment
+        removed_quantity
       end
-
-      removed_quantity
-    end
   end
 end

data/app/models/spree/order_populator.rb

@@ -9,23 +9,9 @@ module Spree
       @errors = ActiveModel::Errors.new(self)
     end
 
-    #
-    # Parameters can be passed using the following possible parameter configurations:
-    #
-    # * Single variant/quantity pairing
-    # +:variants => { variant_id => quantity }+
-    #
-    # * Multiple products at once
-    # +:products => { product_id => variant_id, product_id => variant_id }, :quantity => quantity+
-    def populate(from_hash)
-      from_hash[:products].each do |product_id,variant_id|
-        attempt_cart_add(variant_id, from_hash[:quantity])
-      end if from_hash[:products]
-
-      from_hash[:variants].each do |variant_id, quantity|
-        attempt_cart_add(variant_id, quantity)
-      end if from_hash[:variants]
-
+    
+    def populate(variant_id, quantity)
+      attempt_cart_add(variant_id, quantity)
       valid?
     end
 

data/app/models/spree/order_updater.rb

@@ -16,35 +16,23 @@ module Spree
     # associations try to save and then in turn try to call +update!+ again.)
     def update
       update_totals
-
       if order.completed?
         update_payment_state
-
-        # give each of the shipments a chance to update themselves
-        shipments.each { |shipment| shipment.update!(order) }
+        update_shipments
         update_shipment_state
       end
-      
-      update_adjustments
-      # update totals a second time in case updated adjustments have an effect on the total
-      update_totals
-
-      order.update_columns({
-        payment_state: order.payment_state,
-        shipment_state: order.shipment_state,
-        item_total: order.item_total,
-        adjustment_total: order.adjustment_total,
-        payment_total: order.payment_total,
-        total: order.total
-      })
-
       run_hooks
+      persist_totals
     end
 
     def run_hooks
       update_hooks.each { |hook| order.send hook }
     end
 
+    def recalculate_adjustments
+      adjustments.includes(:source).each { |adjustment| adjustment.update! order }
+    end
+
     # Updates the following Order total values:
     #
     # +payment_total+      The total value of all finalized Payments (NOTE: non-finalized Payments are excluded)
@@ -52,11 +40,61 @@ module Spree
     # +adjustment_total+   The total value of all adjustments (promotions, credits, etc.)
     # +total+              The so-called "order total."  This is equivalent to +item_total+ plus +adjustment_total+.
     def update_totals
-      order.payment_total = payments.completed.map(&:amount).sum
+      order.payment_total = payments.completed.sum(:amount)
+      update_item_total
+      update_shipment_total
+      update_adjustment_total
+    end
+
+
+    # give each of the shipments a chance to update themselves
+    def update_shipments
+      shipments.each { |shipment| shipment.update!(order) }
+    end
+
+    def update_shipment_total
+      order.shipment_total = shipments.sum("cost + promo_total")
+      update_order_total
+    end
+
+    def update_order_total
+      order.total = order.item_total + order.shipment_total + order.adjustment_total
+    end
+
+    def update_adjustment_total
+      recalculate_adjustments
+      order.adjustment_total = line_items.sum(:adjustment_total) +
+                               shipments.sum(:adjustment_total)  +
+                               adjustments.eligible.sum(:amount)
+      order.included_tax_total = line_items.sum(:included_tax_total) + shipments.sum(:included_tax_total)
+      order.additional_tax_total = line_items.sum(:additional_tax_total) + shipments.sum(:additional_tax_total)
+
+      update_order_total
+    end
+
+    def update_item_count
+      order.item_count = line_items.sum(:quantity)
+    end
+
+    def update_item_total
       order.item_total = line_items.map(&:amount).sum
-      order.adjustment_total = adjustments.eligible.map(&:amount).sum
-      order.tax_total = order.all_adjustments.tax.map(&:amount).sum
-      order.total = order.item_total + order.adjustment_total
+      update_order_total
+    end
+
+    def persist_totals
+      order.update_columns(
+        payment_state: order.payment_state,
+        shipment_state: order.shipment_state,
+        item_total: order.item_total,
+        item_count: order.item_count,
+        adjustment_total: order.adjustment_total,
+        included_tax_total: order.included_tax_total,
+        additional_tax_total: order.additional_tax_total,
+        payment_total: order.payment_total,
+        shipment_total: order.shipment_total,
+        total: order.total,
+        updated_at: Time.now,
+      )
     end
 
     # Updates the +shipment_state+ attribute according to the following logic:
@@ -90,6 +128,7 @@ module Spree
       end
 
       order.state_changed('shipment')
+      order.shipment_state
     end
 
     # Updates the +payment_state+ attribute according to the following logic:
@@ -107,6 +146,8 @@ module Spree
         if payments.present?
           if payments.last.state == 'failed'
             order.payment_state = 'failed'
+          elsif payments.last.state == 'checkout'
+            order.payment_state = 'pending'
           elsif payments.last.state == 'completed'
             order.payment_state = 'credit_owed'
           else
@@ -124,30 +165,8 @@ module Spree
       order.state_changed('payment')
     end
 
-    # Updates each of the Order adjustments.
-    #
-    # This is intended to be called from an Observer so that the Order can
-    # respond to external changes to LineItem, Shipment, other Adjustments, etc.
-    #
-    # Adjustments will check if they are still eligible. Ineligible adjustments
-    # are preserved but not counted towards adjustment_total.
-    def update_adjustments
-      order.adjustments.reload.each { |adjustment| adjustment.update!(order) }
-      choose_best_promotion_adjustment
-    end
-
     private
 
-      # Picks one (and only one) promotion to be eligible for this order
-      # This promotion provides the most discount, and if two promotions
-      # have the same amount, then it will pick the latest one.
-      def choose_best_promotion_adjustment
-        if best_promotion_adjustment = order.adjustments.promotion.eligible.reorder("amount ASC, created_at DESC").first
-          other_promotions = order.adjustments.promotion.where("id NOT IN (?)", best_promotion_adjustment.id)
-          other_promotions.update_all(eligible: false)
-        end
-      end
-
       def round_money(n)
         (n * 100).round / 100.0
       end