spree_core 1.2.5 → 1.3.0.rc1

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

@@ -126,14 +126,7 @@ module Spree
               end
               checkout_steps << step
             end
-            steps = checkout_steps.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) : false
+            checkout_steps.map(&:to_s)
           end
         end
       end

data/app/models/spree/order_updater.rb

@@ -0,0 +1,134 @@
+module Spree
+  class OrderUpdater
+    attr_reader :order
+    delegate :payments, :line_items, :adjustments, :shipments, :update_hooks, :to => :order
+
+    def initialize(order)
+      @order = order
+    end
+
+    # This is a multi-purpose method for processing logic related to changes in the Order.
+    # It is meant to be called from various observers so that the Order is aware of changes
+    # that affect totals and other values stored in the Order.
+    #
+    # This method should never do anything to the Order that results in a save call on the
+    # object with callbacks (otherwise you will end up in an infinite recursion as the
+    # associations try to save and then in turn try to call +update!+ again.)
+    def update
+      update_totals
+      update_payment_state
+
+      # give each of the shipments a chance to update themselves
+      shipments.each { |shipment| shipment.update!(order) }#(&:update!)
+      update_shipment_state
+      update_adjustments
+      # update totals a second time in case updated adjustments have an effect on the total
+      update_totals
+
+      order.update_attributes_without_callbacks({
+        :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
+      })
+
+      #ensure checkout payment always matches order total
+      if order.payment and order.payment.checkout? and order.payment.amount != order.total
+        order.payment.update_attributes_without_callbacks(:amount => order.total)
+      end
+
+      update_hooks.each { |hook| order.send hook }
+    end
+
+    # Updates the following Order total values:
+    #
+    # +payment_total+      The total value of all finalized Payments (NOTE: non-finalized Payments are excluded)
+    # +item_total+         The total value of all LineItems
+    # +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.item_total = line_items.map(&:amount).sum
+      order.adjustment_total = adjustments.eligible.map(&:amount).sum
+      order.total = order.item_total + order.adjustment_total
+    end
+
+    # Updates the +shipment_state+ attribute according to the following logic:
+    #
+    # shipped   when all Shipments are in the "shipped" state
+    # partial   when at least one Shipment has a state of "shipped" and there is another Shipment with a state other than "shipped"
+    #           or there are InventoryUnits associated with the order that have a state of "sold" but are not associated with a Shipment.
+    # ready     when all Shipments are in the "ready" state
+    # backorder when there is backordered inventory associated with an order
+    # pending   when all Shipments are in the "pending" state
+    #
+    # The +shipment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
+    def update_shipment_state
+      if order.backordered?
+        order.shipment_state = 'backorder'
+      else
+        order.shipment_state =
+        case shipments.count
+        when 0
+          nil
+        when shipments.shipped.count
+          'shipped'
+        when shipments.ready.count
+          'ready'
+        when shipments.pending.count
+          'pending'
+        else
+          'partial'
+        end
+      end
+
+      order.state_changed('shipment')
+    end
+
+    # Updates the +payment_state+ attribute according to the following logic:
+    #
+    # paid          when +payment_total+ is equal to +total+
+    # balance_due   when +payment_total+ is less than +total+
+    # credit_owed   when +payment_total+ is greater than +total+
+    # failed        when most recent payment is in the failed state
+    #
+    # The +payment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
+    def update_payment_state
+
+      #line_item are empty when user empties cart
+      if line_items.empty? || round_money(order.payment_total) < round_money(order.total)
+        if payments.present? && payments.last.state == 'failed'
+          order.payment_state = 'failed'
+        else
+          order.payment_state = 'balance_due'
+        end
+      elsif round_money(order.payment_total) > round_money(order.total)
+        order.payment_state = 'credit_owed'
+      else
+        order.payment_state = 'paid'
+      end
+
+      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) }
+    end
+    
+
+    private
+
+      def round_money(n)
+        (n * 100).round / 100.0
+      end
+  end
+end

data/app/models/spree/payment.rb

@@ -8,8 +8,6 @@ module Spree
     has_many :offsets, :class_name => "Spree::Payment", :foreign_key => :source_id, :conditions => "source_type = 'Spree::Payment' AND amount < 0 AND state = 'completed'"
     has_many :log_entries, :as => :source
 
-    before_save :set_unique_identifier
-
     after_save :create_payment_profile, :if => :profiles_supported?
 
     # update the order totals, etc.
@@ -49,6 +47,14 @@ module Spree
       end
     end
 
+    def currency
+      order.currency
+    end
+
+    def display_amount
+      Spree::Money.new(amount, { :currency => currency })
+    end
+
     def offsets_total
       offsets.map(&:amount).sum
     end
@@ -102,22 +108,5 @@ module Spree
         order.payments.reload
         order.update!
       end
-
-      # Necessary because some payment gateways will refuse payments with
-      # duplicate IDs. We *were* using the Order number, but that's set once and
-      # is unchanging. What we need is a unique identifier on a per-payment basis,
-      # and this is it. Related to #1998.
-      # See https://github.com/spree/spree/issues/1998#issuecomment-12869105
-      def set_unique_identifier
-        chars = [('A'..'Z').to_a, ('0'..'9').to_a].flatten - %w(0 1 I O)
-        identifier = ''
-        8.times { identifier << chars[rand(chars.length)] }
-        if Spree::Payment.exists?(:identifier => identifier)
-          # Call it again, we've got a duplicate ID.
-          set_unique_identifier
-        else
-          self.identifier = identifier
-        end
-      end
   end
 end

data/app/models/spree/payment/processing.rb

@@ -111,13 +111,13 @@ module Spree
       options = { :email    => order.email,
                   :customer => order.email,
                   :ip       => '192.168.1.100', # TODO: Use an actual IP
-                  :order_id => "#{order.number}-#{self.identifier}" }
+                  :order_id => order.number }
 
       options.merge!({ :shipping => order.ship_total * 100,
                        :tax      => order.tax_total * 100,
                        :subtotal => order.item_total * 100 })
-      
-      options.merge!({ :currency => payment_method.preferences[:currency_code] }) if payment_method && payment_method.preferences[:currency_code]
+
+      options.merge!({ :currency => currency })
 
       options.merge!({ :billing_address  => order.bill_address.try(:active_merchant_hash),
                       :shipping_address => order.ship_address.try(:active_merchant_hash) })

data/app/models/spree/payment_method.rb

@@ -1,11 +1,11 @@
 module Spree
   class PaymentMethod < ActiveRecord::Base
-    DISPLAY = [:both, :front_end, :back_end]
     default_scope where(:deleted_at => nil)
 
     scope :production, lambda { where(:environment => 'production') }
 
-    attr_accessible :name, :description, :environment, :display_on, :active
+    attr_accessible :name, :description, :environment, :active
+    validates :name, :presence => true
 
     def self.providers
       Rails.application.config.spree.payment_methods
@@ -22,8 +22,10 @@ module Spree
       raise 'You must implement payment_source_class method for this gateway.'
     end
 
-    def self.available(display_on = 'both')
-      all.select { |p| p.active && (p.display_on == display_on.to_s || p.display_on.blank?) && (p.environment == Rails.env || p.environment.blank?) }
+    def self.available
+      all.select do |p|
+        p.active && (p.environment == Rails.env || p.environment.blank?)
+      end
     end
 
     def self.active?

data/app/models/spree/preference.rb

@@ -1,5 +1,5 @@
 class Spree::Preference < ActiveRecord::Base
-  attr_accessible :name, :key, :value_type, :value
+  attr_accessible :key, :value_type, :value
 
   validates :key, :presence => true
   validates :value_type, :presence => true

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

@@ -10,13 +10,16 @@ module Spree::Preferences
       # cache_key will be nil for new objects, then if we check if there
       # is a pending preference before going to default
       define_method preference_getter_method(name) do
-
-        # perference_cache_key will only be nil/false for new records
-        #
-        if preference_cache_key(name)
-          preference_store.get(preference_cache_key(name), default)
+        if preference_cache_key(name) && preference_store.exist?(preference_cache_key(name))
+          preference_store.get preference_cache_key(name)
         else
-          get_pending_preference(name) || default
+          if get_pending_preference(name)
+            get_pending_preference(name)
+          elsif Spree::Preference.table_exists? && preference = Spree::Preference.find_by_key(name.to_s)
+            preference.value
+          else
+            send self.class.preference_default_getter_method(name)
+          end
         end
       end
       alias_method prefers_getter_method(name), preference_getter_method(name)

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

@@ -27,36 +27,25 @@ module Spree::Preferences
       should_persist? && Spree::Preference.where(:key => key).exists?
     end
 
-    def get(key,fallback=nil)
+    def get(key)
       # return the retrieved value, if it's in the cache
-      # use unless nil? incase the value is actually boolean false
-      #
-      unless (val = @cache.read(key)).nil?
+      if (val = @cache.read(key)).present?
         return val
       end
 
-      if should_persist?
-        # If it's not in the cache, maybe it's in the database, but
-        # has been cleared from the cache
+      return nil unless should_persist?
 
-        # does it exist in the database?
-        if Spree::Preference.table_exists? && preference = Spree::Preference.find_by_key(key)
-          # it does exist, so let's put it back into the cache
-          @cache.write(preference.key, preference.value)
+      # If it's not in the cache, maybe it's in the database, but
+      # has been cleared from the cache
 
-          # and return the value
-          return preference.value
-        end
-      end
+      # does it exist in the database?
+      if preference = Spree::Preference.find_by_key(key)
+        # it does exist, so let's put it back into the cache
+        @cache.write(preference.key, preference.value)
 
-      unless fallback.nil?
-        # cache fallback so we won't hit the db above on
-        # subsequent queries for the same key
-        #
-        @cache.write(key, fallback)
+        # and return the value
+        preference.value
       end
-
-      return fallback
     end
 
     def delete(key)
@@ -64,10 +53,6 @@ module Spree::Preferences
       destroy(key)
     end
 
-    def clear_cache
-      @cache.clear
-    end
-
     private
 
     def persist(cache_key, value, type)

data/app/models/spree/price.rb

@@ -0,0 +1,51 @@
+module Spree
+  class Price < ActiveRecord::Base
+    belongs_to :variant, :class_name => 'Spree::Variant'
+
+    validate :check_price
+    validates :amount, :numericality => { :greater_than_or_equal_to => 0 }, :allow_nil => true
+
+    attr_accessible :variant_id, :currency, :amount
+
+    def display_amount
+      return nil if amount.nil?
+      money.to_s
+    end
+    alias :display_price :display_amount
+
+    def money
+      Spree::Money.new(amount, { :currency => currency })
+    end
+
+    def price
+      amount
+    end
+
+    def price=(price)
+      self[:amount] = parse_price(price)
+    end
+
+    private
+    def check_price
+      raise "Price must belong to a variant" if variant.nil?
+
+      if currency.nil?
+        self.currency = Spree::Config[:currency]
+      end
+    end
+
+    # strips all non-price-like characters from the price, taking into account locale settings
+    def parse_price(price)
+      return price unless price.is_a?(String)
+
+      separator, delimiter = I18n.t([:'number.currency.format.separator', :'number.currency.format.delimiter'])
+      non_price_characters = /[^0-9\-#{separator}]/
+      price.gsub!(non_price_characters, '') # strip everything else first
+      price.gsub!(separator, '.') unless separator == '.' # then replace the locale-specific decimal separator with the standard separator if necessary
+
+      price.to_d
+    end
+
+  end
+end
+

data/app/models/spree/product.rb

@@ -46,13 +46,16 @@ module Spree
 
     has_many :variants_including_master_and_deleted, :class_name => 'Spree::Variant'
 
-    delegate_belongs_to :master, :sku, :price, :weight, :height, :width, :depth, :is_master
+    has_many :prices, :through => :variants, :order => 'spree_variants.position, spree_variants.id, currency'
+
+    delegate_belongs_to :master, :sku, :price, :currency, :display_amount, :display_price, :weight, :height, :width, :depth, :is_master, :has_default_price?, :cost_currency, :price_in, :amount_in
     delegate_belongs_to :master, :cost_price if Variant.table_exists? && Variant.column_names.include?('cost_price')
 
     after_create :set_master_variant_defaults
     after_create :add_properties_and_option_types_from_prototype
     after_create :build_variants_from_option_values_hash, :if => :option_values_hash
     before_save :recalculate_count_on_hand
+
     after_save :save_master
     after_save :set_master_on_hand_to_zero_when_product_has_variants
 
@@ -63,19 +66,19 @@ module Spree
 
     accepts_nested_attributes_for :variants, :allow_destroy => true
 
-    validates :name, :price, :permalink, :presence => true
+    validates :name, :permalink, :presence => true
+    validates :price, :presence => true, :if => proc { Spree::Config[:require_master_price] }
 
     attr_accessor :option_values_hash
 
     attr_accessible :name, :description, :available_on, :permalink, :meta_description,
                     :meta_keywords, :price, :sku, :deleted_at, :prototype_id,
-                    :option_values_hash, :on_hand, :weight, :height, :width, :depth,
+                    :option_values_hash, :on_demand, :on_hand, :weight, :height, :width, :depth,
                     :shipping_category_id, :tax_category_id, :product_properties_attributes,
-                    :variants_attributes, :taxon_ids, :option_type_ids
+                    :variants_attributes, :taxon_ids, :option_type_ids, :cost_currency
 
     attr_accessible :cost_price if Variant.table_exists? && Variant.column_names.include?('cost_price')
 
-
     accepts_nested_attributes_for :product_properties, :allow_destroy => true, :reject_if => lambda { |pp| pp[:property_name].blank? }
 
     make_permalink :order => :name
@@ -89,7 +92,6 @@ module Spree
       master
     end
 
-
     def to_param
       permalink.present? ? permalink : (permalink_was || name.to_s.to_url)
     end
@@ -116,8 +118,16 @@ module Spree
 
     # adjusts the "on_hand" inventory level for the product up or down to match the given new_level
     def on_hand=(new_level)
-      raise 'cannot set on_hand of product with variants' if has_variants? && Spree::Config[:track_inventory_levels]
-      master.on_hand = new_level
+      unless self.on_demand
+        raise 'cannot set on_hand of product with variants' if has_variants? && Spree::Config[:track_inventory_levels] 
+        master.on_hand = new_level
+      end
+    end
+
+    def on_demand=(new_on_demand)
+      raise 'cannot set on_demand of product with variants' if has_variants? && Spree::Config[:track_inventory_levels]
+      master.on_demand = on_demand
+      self[:on_demand] = new_on_demand
     end
 
     # Returns true if there are inventory units (any variant) with "on_hand" state for this product
@@ -173,6 +183,8 @@ module Spree
       variant.sku = 'COPY OF ' + master.sku
       variant.deleted_at = nil
       variant.images = master.images.map { |i| image_dup.call i }
+      variant.price = master.price
+      variant.currency = master.currency
       p.master = variant
 
       # don't dup the actual variants, just the characterising types
@@ -230,10 +242,6 @@ module Spree
       end
     end
 
-    def display_price
-      Spree::Money.new(price)
-    end
-
     private
 
       # Builds variants from a hash of option types & values
@@ -266,7 +274,7 @@ module Spree
       # the master on_hand is meaningless once a product has variants as the inventory
       # units are now "contained" within the product variants
       def set_master_on_hand_to_zero_when_product_has_variants
-        master.on_hand = 0 if has_variants? && Spree::Config[:track_inventory_levels]
+        master.on_hand = 0 if has_variants? && Spree::Config[:track_inventory_levels] && !self.on_demand
       end
 
       # ensures the master variant is flagged as such
@@ -277,7 +285,7 @@ module Spree
       # there's a weird quirk with the delegate stuff that does not automatically save the delegate object
       # when saving so we force a save using a hook.
       def save_master
-        master.save if master && (master.changed? || master.new_record?)
+        master.save if master && (master.changed? || master.new_record? || (master.default_price && (master.default_price.changed || master.default_price.new_record)))
       end
 
       def ensure_master