spree_core 1.3.5 → 2.0.0.rc1

data/app/models/spree/order.rb

@@ -15,53 +15,54 @@ module Spree
     checkout_flow do
       go_to_state :address
       go_to_state :delivery
-      go_to_state :payment, :if => lambda { |order|
+      go_to_state :payment, if: ->(order) {
         # Fix for #2191
-        # See #3708 also
-        if order.total.to_f <= 0 && order.shipping_method
-          order.create_shipment!
+        if order.shipments
           order.update_totals
         end
         order.payment_required?
       }
-      go_to_state :confirm, :if => lambda { |order| order.confirmation_required? }
-      go_to_state :complete, :if => lambda { |order| (order.payment_required? && order.has_unprocessed_payments?) || !order.payment_required? }
-      remove_transition :from => :delivery, :to => :confirm
+      go_to_state :confirm, if: ->(order) { order.confirmation_required? }
+      go_to_state :complete, if: ->(order) {
+        (order.payment_required? && order.has_unprocessed_payments?) || !order.payment_required?
+      }
+      remove_transition from: :delivery, to: :confirm
     end
 
     token_resource
 
-    attr_accessible :line_items, :bill_address_attributes, :ship_address_attributes, :payments_attributes,
-                    :ship_address, :bill_address, :payments_attributes, :line_items_attributes, :number,
-                    :shipping_method_id, :email, :use_billing, :special_instructions, :currency
+    attr_accessible :line_items, :bill_address_attributes, :ship_address_attributes,
+                    :payments_attributes, :ship_address, :bill_address, :currency,
+                    :payments_attributes, :line_items_attributes, :number, :email,
+                    :use_billing, :special_instructions, :shipments_attributes,
+                    :coupon_code
+
+    attr_reader :coupon_code
 
     if Spree.user_class
-      belongs_to :user, :class_name => Spree.user_class.to_s
+      belongs_to :user, class_name: Spree.user_class.to_s
     else
       belongs_to :user
     end
 
-    belongs_to :bill_address, :foreign_key => :bill_address_id, :class_name => "Spree::Address"
+    belongs_to :bill_address, foreign_key: :bill_address_id, class_name: 'Spree::Address'
     alias_attribute :billing_address, :bill_address
 
-    belongs_to :ship_address, :foreign_key => :ship_address_id, :class_name => "Spree::Address"
+    belongs_to :ship_address, foreign_key: :ship_address_id, class_name: 'Spree::Address'
     alias_attribute :shipping_address, :ship_address
 
-    belongs_to :shipping_method
+    has_many :state_changes, as: :stateful
+    has_many :line_items, dependent: :destroy, order: 'created_at ASC'
+    has_many :payments, dependent: :destroy
 
-    has_many :state_changes, :as => :stateful
-    has_many :line_items, :dependent => :destroy, :order => "created_at ASC"
-    has_many :inventory_units
-    has_many :payments, :dependent => :destroy
-
-    has_many :shipments, :dependent => :destroy do
+    has_many :shipments, dependent: :destroy do
       def states
         pluck(:state).uniq
       end
     end
 
-    has_many :return_authorizations, :dependent => :destroy
-    has_many :adjustments, :as => :adjustable, :dependent => :destroy, :order => "created_at ASC"
+    has_many :return_authorizations, dependent: :destroy
+    has_many :adjustments, as: :adjustable, dependent: :destroy, order: 'created_at ASC'
 
     accepts_nested_attributes_for :line_items
     accepts_nested_attributes_for :bill_address
@@ -71,29 +72,29 @@ module Spree
 
     # Needs to happen before save_permalink is called
     before_validation :set_currency
-    before_validation :generate_order_number, :on => :create
-    before_validation :clone_billing_address, :if => :use_billing?
+    before_validation :generate_order_number, on: :create
+    before_validation :clone_billing_address, if: :use_billing?
     attr_accessor :use_billing
 
     before_create :link_by_email
     after_create :create_tax_charge!
 
-    validates :email, :presence => true, :if => :require_email
-    validates :email, :email => true, :if => :require_email, :allow_blank => true
+    validates :email, presence: true, if: :require_email
+    validates :email, email: true, if: :require_email, allow_blank: true
     validate :has_available_shipment
     validate :has_available_payment
 
-    make_permalink :field => :number
+    make_permalink field: :number
 
     class_attribute :update_hooks
     self.update_hooks = Set.new
 
     def self.by_number(number)
-      where(:number => number)
+      where(number: number)
     end
 
     def self.between(start_date, end_date)
-      where(:created_at => start_date..end_date)
+      where(created_at: start_date..end_date)
     end
 
     def self.by_customer(customer)
@@ -101,7 +102,7 @@ module Spree
     end
 
     def self.by_state(state)
-      where(:state => state)
+      where(state: state)
     end
 
     def self.complete
@@ -109,17 +110,18 @@ module Spree
     end
 
     def self.incomplete
-      where(:completed_at => nil)
+      where(completed_at: nil)
     end
 
-    # Use this method in other gems that wish to register their own custom logic that should be called after Order#updat
+    # Use this method in other gems that wish to register their own custom logic
+    # that should be called after Order#update
     def self.register_update_hook(hook)
       self.update_hooks.add(hook)
     end
 
     # For compatiblity with Calculator::PriceSack
     def amount
-      line_items.sum(&:amount)
+      line_items.inject(0.0) { |sum, li| sum + li.amount }
     end
 
     def currency
@@ -127,19 +129,27 @@ module Spree
     end
 
     def display_outstanding_balance
-      Spree::Money.new(outstanding_balance, { :currency => currency })
+      Spree::Money.new(outstanding_balance, { currency: currency })
     end
 
     def display_item_total
-      Spree::Money.new(item_total, { :currency => currency })
+      Spree::Money.new(item_total, { currency: currency })
     end
 
     def display_adjustment_total
-      Spree::Money.new(adjustment_total, { :currency => currency })
+      Spree::Money.new(adjustment_total, { currency: currency })
+    end
+
+    def display_tax_total
+      Spree::Money.new(tax_total, { currency: currency })
+    end
+
+    def display_ship_total
+      Spree::Money.new(ship_total, { currency: currency })
     end
 
     def display_total
-      Spree::Money.new(total, { :currency => currency })
+      Spree::Money.new(total, { currency: currency })
     end
 
     def to_param
@@ -150,9 +160,10 @@ module Spree
       !! completed_at
     end
 
-    # Indicates whether or not the user is allowed to proceed to checkout.  Currently this is implemented as a
-    # check for whether or not there is at least one LineItem in the Order.  Feel free to override this logic
-    # in your own application if you require additional steps before allowing a checkout.
+    # Indicates whether or not the user is allowed to proceed to checkout.
+    # Currently this is implemented as a check for whether or not there is at
+    # least one LineItem in the Order.  Feel free to override this logic in your
+    # own application if you require additional steps before allowing a checkout.
     def checkout_allowed?
       line_items.count > 0
     end
@@ -165,64 +176,57 @@ module Spree
 
     # If true, causes the confirmation step to happen during the checkout process
     def confirmation_required?
-      payments.valid.map(&:payment_method).any?(&:payment_profiles_supported?)
+      payments.map(&:payment_method).compact.any?(&:payment_profiles_supported?)
     end
 
     # Used by the checkout state machine to check for unprocessed payments
-    # The Order should be only be able to proceed to complete if there are unprocessed
+    # The Order should be unable to proceed to complete if there are unprocessed
     # payments and there is payment required.
-    #
-    # The reason for this is directly before an order transitions to complete, all
-    # of the order's payments have `process!` called on it (look in order/checkout.rb).
-    # If payment *is* required and there's no payments which haven't already been tried,
-    # then the order cannot be paid for and therefore should not be able to become complete.
     def has_unprocessed_payments?
       payments.with_state('checkout').reload.exists?
     end
 
     # Indicates the number of items in the order
     def item_count
-      line_items.sum(:quantity)
+      line_items.inject(0) { |sum, li| sum + li.quantity }
     end
 
-    # Indicates whether there are any backordered InventoryUnits associated with the Order.
     def backordered?
-      return false unless Spree::Config[:track_inventory_levels]
-      inventory_units.backordered.present?
+      shipments.any?(&:backordered?)
     end
 
-    # Returns the relevant zone (if any) to be used for taxation purposes.  Uses default tax zone
-    # unless there is a specific match
+    # Returns the relevant zone (if any) to be used for taxation purposes.
+    # Uses default tax zone unless there is a specific match
     def tax_zone
       zone_address = Spree::Config[:tax_using_ship_address] ? ship_address : bill_address
       Zone.match(zone_address) || Zone.default_tax
     end
 
-    # Indicates whether tax should be backed out of the price calcualtions in cases where prices
-    # include tax but the customer is not required to pay taxes in that case.
+    # Indicates whether tax should be backed out of the price calcualtions in
+    # cases where prices include tax but the customer is not required to pay
+    # taxes in that case.
     def exclude_tax?
       return false unless Spree::Config[:prices_inc_tax]
       return tax_zone != Zone.default_tax
     end
 
-    # Array of adjustments that are inclusive in the variant price.  Useful for when prices
-    # include tax (ex. VAT) and you need to record the tax amount separately.
+    # Array of adjustments that are inclusive in the variant price. Useful for when
+    # prices include tax (ex. VAT) and you need to record the tax amount separately.
     def price_adjustments
       adjustments = []
 
-      line_items.each do |line_item|
-        adjustments.concat line_item.adjustments
-      end
+      line_items.each { |line_item| adjustments.concat line_item.adjustments }
 
       adjustments
     end
 
-    # Array of totals grouped by Adjustment#label.  Useful for displaying price adjustments on an
-    # invoice.  For example, you can display tax breakout for cases where tax is included in price.
+    # Array of totals grouped by Adjustment#label. Useful for displaying price
+    # adjustments on an invoice. For example, you can display tax breakout for
+    # cases where tax is included in price.
     def price_adjustment_totals
       Hash[price_adjustments.group_by(&:label).map do |label, adjustments|
         total = adjustments.sum(&:amount)
-        [label, Spree::Money.new(total, { :currency => currency })]
+        [label, Spree::Money.new(total, { currency: currency })]
       end]
     end
 
@@ -253,7 +257,8 @@ module Spree
     end
 
     def allow_resume?
-      # we shouldn't allow resume for legacy orders b/c we lack the information necessary to restore to a previous state
+      # we shouldn't allow resume for legacy orders b/c we lack the information
+      # necessary to restore to a previous state
       return false if state_changes.empty? || state_changes.last.previous_state.nil?
       true
     end
@@ -262,22 +267,29 @@ module Spree
       return_authorizations.any? { |return_authorization| return_authorization.authorized? }
     end
 
+    def contents
+      @contents ||= Spree::OrderContents.new(self)
+    end
+
     def add_variant(variant, quantity = 1, currency = nil)
+      ActiveSupport::Deprecation.warn("[SPREE] Spree::Order#add_variant will be deprecated in Spree 2.1, please use order.contents.add instead.")
+      contents.currency = currency unless currency.nil?
+      contents.add(variant, quantity)
+    end
+
+    def remove_variant(variant, quantity = 1)
+      ActiveSupport::Deprecation.warn("[SPREE] Spree::Order#remove_variant will be deprecated in Spree 2.1, please use order.contents.remove instead.")
+      contents.remove(variant, quantity)
+    end
+
+    def remove_variant(variant, quantity = 1)
       current_item = find_line_item_by_variant(variant)
-      if current_item
-        current_item.quantity += quantity
-        current_item.currency = currency unless currency.nil?
-        current_item.save
+      current_item.quantity += -quantity
+
+      if current_item.quantity == 0
+        current_item.destroy
       else
-        current_item = LineItem.new(:quantity => quantity)
-        current_item.variant = variant
-        if currency
-          current_item.currency = currency unless currency.nil?
-          current_item.price    = variant.price_in(currency).amount
-        else
-          current_item.price    = variant.price
-        end
-        self.line_items << current_item
+        current_item.save!
       end
 
       self.reload
@@ -290,7 +302,7 @@ module Spree
       self.email = user.email
       # disable validations since they can cause issues when associating
       # an incomplete address during the address step
-      save(:validate => false)
+      save(validate: false)
     end
 
     # FIXME refactor this method and implement validation using validates_* utilities
@@ -298,17 +310,22 @@ module Spree
       record = true
       while record
         random = "R#{Array.new(9){rand(9)}.join}"
-        record = self.class.where(:number => random).first
+        record = self.class.where(number: random).first
       end
       self.number = random if self.number.blank?
       self.number
     end
 
+    # TODO should be deprecated by split shipments
     # convenience method since many stores will not allow user to create multiple shipments
     def shipment
       @shipment ||= shipments.last
     end
 
+    def shipped_shipments
+      shipments.shipped
+    end
+
     def contains?(variant)
       find_line_item_by_variant(variant).present?
     end
@@ -342,19 +359,6 @@ module Spree
       Spree::TaxRate.adjust(self)
     end
 
-    # Creates a new shipment (adjustment is created by shipment model)
-    def create_shipment!
-      shipping_method(true)
-      if shipment.present?
-        shipment.update_attributes!({:shipping_method => shipping_method, :inventory_units => self.inventory_units}, :without_protection => true)
-      else
-        self.shipments << Shipment.create!({ :order => self,
-                                          :shipping_method => shipping_method,
-                                          :address => self.ship_address,
-                                          :inventory_units => self.inventory_units}, :without_protection => true)
-      end
-    end
-
     def outstanding_balance
       total - payment_total
     end
@@ -375,21 +379,24 @@ module Spree
 
     def credit_cards
       credit_card_ids = payments.from_credit_card.pluck(:source_id).uniq
-      CreditCard.scoped(:conditions => { :id => credit_card_ids })
+      CreditCard.scoped(conditions: { id: credit_card_ids })
     end
 
     # Finalizes an in progress order after checkout is complete.
     # Called after transition to complete state when payments will have been processed
     def finalize!
       touch :completed_at
-      InventoryUnit.assign_opening_inventory(self)
 
       # lock all adjustments (coupon promotions, etc.)
-      adjustments.each { |adjustment| adjustment.update_column('locked', true) }
+      adjustments.each { |adjustment| adjustment.update_column('state', "closed") }
 
       # update payment and shipment(s) states, and save
       updater.update_payment_state
-      shipments.reload.each { |shipment| shipment.update!(self) }
+      shipments.each do |shipment|
+        shipment.update!(self)
+        shipment.finalize!
+      end
+
       updater.update_shipment_state
       save
       updater.run_hooks
@@ -397,11 +404,11 @@ module Spree
       deliver_order_confirmation_email
 
       self.state_changes.create({
-        :previous_state => 'cart',
-        :next_state     => 'complete',
-        :name           => 'order' ,
-        :user_id        => self.user_id
-      }, :without_protection => true)
+        previous_state: 'cart',
+        next_state:     'complete',
+        name:           'order' ,
+        user_id:        self.user_id
+      }, without_protection: true)
     end
 
     def deliver_order_confirmation_email
@@ -414,23 +421,6 @@ module Spree
     end
 
     # Helper methods for checkout steps
-
-    def available_shipping_methods(display_on = nil)
-      return [] unless ship_address
-      ShippingMethod.all_available(self, display_on)
-    end
-
-    def rate_hash
-      @rate_hash ||= available_shipping_methods.collect do |ship_method|
-        next unless cost = ship_method.calculator.compute(self)
-        ShippingRate.new( :id => ship_method.id,
-                          :shipping_method => ship_method,
-                          :name => ship_method.name,
-                          :cost => cost,
-                          :currency => currency)
-      end.compact.sort_by { |r| r.cost }
-    end
-
     def paid?
       payment_state == 'paid'
     end
@@ -440,7 +430,7 @@ module Spree
     end
 
     def pending_payments
-      payments.select {|p| p.state == "checkout"}
+      payments.select(&:checkout?)
     end
 
     def process_payments!
@@ -468,7 +458,7 @@ module Spree
     end
 
     def products
-      line_items.map { |li| li.variant.product }
+      line_items.map(&:product)
     end
 
     def variants
@@ -497,8 +487,8 @@ module Spree
     end
 
     def empty!
-      adjustments.destroy_all
       line_items.destroy_all
+      adjustments.destroy_all
     end
 
     # destroy any previous adjustments.
@@ -516,23 +506,47 @@ module Spree
       state = "#{name}_state"
       if persisted?
         old_state = self.send("#{state}_was")
-        new_state = self.send(state)
-        if old_state != new_state
-          self.state_changes.create({
-            :previous_state => old_state,
-            :next_state     => self.send(state),
-            :name           => name,
-            :user_id        => self.user_id
-          }, :without_protection => true)
-        end
+        self.state_changes.create({
+          previous_state: old_state,
+          next_state:     self.send(state),
+          name:           name,
+          user_id:        self.user_id
+        }, without_protection: true)
       end
     end
 
-    def restart_checkout_flow
-      self.update_column(:state, checkout_steps.first) unless cart?
+    def coupon_code=(code)
+      @coupon_code = code.strip.downcase rescue nil
+    end
+
+    # Tells us if there if the specified promotion is already associated with the order
+    # regardless of whether or not its currently eligible.  Useful because generally
+    # you would only want a promotion to apply to order no more than once.
+    def promotion_credit_exists?(promotion)
+      !! adjustments.promotion.reload.detect { |credit| credit.originator.promotion.id == promotion.id }
+    end
+
+    def promo_total
+      adjustments.eligible.promotion.map(&:amount).sum
+    end
+
+    def shipped?
+      %w(partial shipped).include?(shipment_state)
+    end
+
+    def create_proposed_shipments
+      shipments.destroy_all
+
+      packages = Spree::Stock::Coordinator.new(self).packages
+      packages.each do |package|
+        shipments << package.to_shipment
+      end
+
+      shipments
     end
 
     private
+
       def link_by_email
         self.email = user.email if self.user
       end
@@ -546,42 +560,27 @@ module Spree
         return unless has_step?("delivery")
         return unless address?
         return unless ship_address && ship_address.valid?
-        errors.add(:base, :no_shipping_methods_available) if available_shipping_methods.empty?
+        # errors.add(:base, :no_shipping_methods_available) if available_shipping_methods.empty?
       end
 
       def has_available_payment
         return unless delivery?
-        errors.add(:base, :no_payment_methods_available) if available_payment_methods.empty?
+        # errors.add(:base, :no_payment_methods_available) if available_payment_methods.empty?
       end
 
       def after_cancel
-        restock_items!
+        shipments.each { |shipment| shipment.cancel! }
 
-        #TODO: make_shipments_pending
         OrderMailer.cancel_email(self.id).deliver
-        unless %w(partial shipped).include?(shipment_state)
-          self.payment_state = 'credit_owed'
-        end
-      end
-
-      def restock_items!
-        line_items.each do |line_item|
-          InventoryUnit.decrease(self, line_item.variant, line_item.quantity)
-        end
+        self.payment_state = 'credit_owed' unless shipped?
       end
 
       def after_resume
-        unstock_items!
-      end
-
-      def unstock_items!
-        line_items.each do |line_item|
-          InventoryUnit.increase(self, line_item.variant, line_item.quantity)
-        end
+        shipments.each { |shipment| shipment.resume! }
       end
 
       def use_billing?
-        @use_billing == true || @use_billing == "true" || @use_billing == "1"
+        @use_billing == true || @use_billing == 'true' || @use_billing == '1'
       end
 
       def set_currency

data/app/models/spree/order_contents.rb

@@ -0,0 +1,69 @@
+module Spree
+  class OrderContents
+    attr_accessor :order, :currency
+
+    def initialize(order)
+      @order = order
+    end
+
+    def add(variant, quantity, currency=nil, shipment=nil)
+      #get current line item for variant if exists
+      line_item = order.find_line_item_by_variant(variant)
+
+      #add variant qty to line_item
+      add_to_line_item(line_item, variant, quantity, currency, shipment)
+    end
+
+    def remove(variant, quantity, shipment=nil)
+      #get current line item for variant
+      line_item = order.find_line_item_by_variant(variant)
+
+      #TODO raise exception if line_item is nil
+
+      #remove variant qty from line_item
+      remove_from_line_item(line_item, variant, quantity, shipment)
+    end
+
+    private
+
+    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
+        line_item.currency = currency unless currency.nil?
+        line_item.save
+      else
+        line_item = LineItem.new(quantity: quantity)
+        line_item.target_shipment = shipment
+        line_item.variant = variant
+        if currency
+          line_item.currency = currency unless currency.nil?
+          line_item.price    = variant.price_in(currency).amount
+        else
+          line_item.price    = variant.price
+        end
+        order.line_items << line_item
+        line_item
+      end
+
+      order.reload
+      line_item
+    end
+
+    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
+        Spree::OrderInventory.new(order).verify(line_item, shipment)
+        line_item.destroy
+      else
+        line_item.save!
+      end
+
+      order.reload
+      line_item
+    end
+
+  end
+end