spree 0.8.5 → 0.9.0

data/app/models/order_mailer.rb

@@ -1,4 +1,4 @@
-class OrderMailer < ActionMailer::Base
+class OrderMailer < ActionMailer::QueueMailer
   helper "spree/base"
   
   def confirm(order, resend = false)

data/app/models/order_observer.rb

@@ -0,0 +1,15 @@
+class OrderObserver < ActiveRecord::Observer
+  observe :order
+
+  # Generic transition callback *after* the transition is performed
+  def after_transition(record, attribute_name, event_name, from_state, to_state)
+    current_user_session = UserSession.activated? ? UserSession.find : nil
+    author = current_user_session ? current_user_session.user : record.user
+    record.state_events.create({
+        :previous_state => from_state,
+        :name           => event_name,
+        :user_id        => author && author.id 
+      })
+    ActiveRecord::Base.logger.info("Order##{record.id}: #{from_state} => #{to_state}")
+  end
+end

data/app/models/product.rb

@@ -1,20 +1,50 @@
+# PRODUCTS
+# Products represent an entity for sale in a store.  
+# Products can have variations, called variants 
+# Products properties include description, permalink, availability, 
+#   shipping category, etc. that do not change by variant.
+#
+# MASTER VARIANT 
+# Every product has one master variant, which stores master price and sku, size and weight, etc.
+# The master variant does not have option values associated with it.
+# Price, SKU, size, weight, etc. are all delegated to the master variant.
+# Contains on_hand inventory levels only when there are no variants for the product.
+#
+# VARIANTS
+# All variants can access the product properties directly (via reverse delegation).
+# Inventory units are tied to Variant.
+# The master variant can have inventory units, but not option values.
+# All other variants have option values and may have inventory units.
+# Sum of on_hand each variant's inventory level determine "on_hand" level for the product.
+# 
 class Product < ActiveRecord::Base
-  after_update :adjust_inventory, :adjust_variant_price
-  after_create :set_initial_inventory
-  
   has_many :product_option_types, :dependent => :destroy
   has_many :option_types, :through => :product_option_types
   has_many :variants, :dependent => :destroy
-  has_many :images, :as => :viewable, :order => :position, :dependent => :destroy
   has_many :product_properties, :dependent => :destroy, :attributes => true
   has_many :properties, :through => :product_properties
+	has_many :images, :as => :viewable, :order => :position, :dependent => :destroy
+	
   belongs_to :tax_category
   has_and_belongs_to_many :taxons
   belongs_to :shipping_category
   
+  has_one :master, 
+    :class_name => 'Variant', 
+    :conditions => ["variants.is_master = ? AND variants.deleted_at IS NULL", true],
+    :dependent => :destroy
+  delegate_belongs_to :master, :sku, :price, :weight, :height, :width, :depth, :is_master
+  after_create :set_master_variant_defaults
+  after_create :add_properties_and_option_types_from_prototype
+  after_save :set_master_on_hand_to_zero_when_product_has_variants    
+  after_save :save_master
+  
+  has_many :variants, 
+    :conditions => ["variants.is_master = ? AND variants.deleted_at IS NULL", false],
+    :dependent => :destroy
 
-  validates_presence_of :name
-  validates_presence_of :master_price
+    validates_presence_of :name
+    validates_presence_of :price
 
   accepts_nested_attributes_for :product_properties
   
@@ -23,66 +53,76 @@ class Product < ActiveRecord::Base
   alias :options :product_option_types
 
   # default product scope only lists available and non-deleted products
-  named_scope :active, lambda { |*args| { :conditions => ["products.available_on <= ? and products.deleted_at is null", (args.first || Time.zone.now)] } }
-  named_scope :not_deleted, lambda { |*args| { :conditions => ["products.deleted_at is null", (args.first || Time.zone.now)] } }
-  
-  named_scope :available, lambda { |*args| { :conditions => ["products.available_on <= ?", (args.first || Time.zone.now)] } }
+  named_scope :active,      lambda { |*args| Product.not_deleted.available(args.first).scope(:find) }
 
+  named_scope :not_deleted,                  { :conditions => "products.deleted_at is null" }
+  named_scope :available,   lambda { |*args| { :conditions => ["products.available_on <= ?", args.first || Time.zone.now] } }
 
-  named_scope :with_property_value, lambda { |property_id, value| { :include => :product_properties, :conditions => ["product_properties.property_id = ? AND product_properties.value = ?", property_id, value] } }
+  # other useful product scopes
+  include ProductScopes
 
-                 
-  def to_param       
-    return permalink unless permalink.blank?
-    name.parameterize.to_s
+
+  # ----------------------------------------------------------------------------------------------------------
+  #
+  # The following methods are deprecated and will be removed in a future version of Spree
+  # 
+  # ----------------------------------------------------------------------------------------------------------
+  
+  def master_price
+    warn "[DEPRECATION] `Product.master_price` is deprecated.  Please use `Product.price` instead. (called from #{caller[0]}"
+    self.price
   end
   
-  # checks is there are any meaningful variants (ie. variants with at least one option value)
-  def variants?
-    self.variants.each do |v|
-      return true unless v.option_values.empty?
-    end
-    false
+  def master_price=(value)
+    warn "[DEPRECATION] `Product.master_price=` is deprecated.  Please use `Product.price=` instead. (called from #{caller[0]}"
+    self.price = value
   end
-
-  # special method that returns the single empty variant (but only if there are no meaningful variants)
-  def variant
-    return nil if variants?
-    variants.first
+  
+  def variants?
+    warn "[DEPRECATION] `Product.variants?` is deprecated.  Please use `Product.has_variants?` instead. (called from #{caller[0]})"
+    self.has_variants?
   end
   
-  # Pseduo Attribute.  Products don't really have inventory - variants do.  We want to make the variant stuff transparent
-  # in the simple cases, however, so we pretend like we're setting the inventory of the product when in fact, we're really 
-  # changing the inventory of the so-called "empty variant."
-  def on_hand
-    variant.on_hand
+  def variant
+    warn "[DEPRECATION] `Product.variant` is deprecated.  Please use `Product.master` instead. (called from #{caller[0]})"
+    self.master
   end
 
-  def on_hand=(quantity)
-    @quantity = quantity
+  # ----------------------------------------------------------------------------------------------------------
+  # end deprecation region
+  # ----------------------------------------------------------------------------------------------------------
+
+  def to_param       
+    return permalink unless permalink.blank?
+    name.to_url
   end
   
-  # Pseduo attribute for SKU, similiar as on_hand above.
-  def sku
-    variant.sku if variant
+  # returns true if the product has any variants (the master variant is not a member of the variants array)
+  def has_variants?
+    !variants.empty?
   end
-  
-  def sku=(sku)
-    variant.sku = sku if variant
+
+  # returns the number of inventory units "on_hand" for this product
+  def on_hand
+    has_variants? ? variants.inject(0){|sum, v| sum + v.on_hand} : master.on_hand
   end
-  
+
+  # 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?
+    master.on_hand = new_level
+  end
+
+  # Returns true if there are inventory units (any variant) with "on_hand" state for this product
   def has_stock?
-    variants.inject(false){ |tf, v| tf ||= v.in_stock }
+    master.in_stock? || !!variants.detect{|v| v.in_stock?}
   end
-  
-  
+
   # Adding properties and option types on creation based on a chosen prototype
-  
   attr_reader :prototype_id
   def prototype_id=(value)
     @prototype_id = value.to_i
   end
-  after_create :add_properties_and_option_types_from_prototype
   
   def add_properties_and_option_types_from_prototype
     if prototype_id and prototype = Prototype.find_by_id(prototype_id)
@@ -93,48 +133,22 @@ class Product < ActiveRecord::Base
     end
   end
   
-  
-  
   private
 
-    def adjust_inventory
-      return if self.new_record?
-      return unless @quantity && @quantity.is_integer?    
-      new_level = @quantity.to_i
-      # don't allow negative on_hand inventory
-      return if new_level < 0
-      variant.save
-      variant.inventory_units.with_state("backordered").each{|iu|
-        if new_level > 0
-          iu.fill_backorder
-          new_level = new_level - 1
-        end
-        break if new_level < 1
-        }
-      
-      adjustment = new_level - on_hand
-      if adjustment > 0
-        InventoryUnit.create_on_hand(variant, adjustment)
-        reload
-      elsif adjustment < 0
-        InventoryUnit.destroy_on_hand(variant, adjustment.abs)
-        reload
-      end      
-    end
-  
-    def adjust_variant_price
-      # If there's a master price change, make sure the empty variant has its price changed as well (Bug #61)
-      if master_price_changed?
-        variants.first.price = master_price
-        variants.first.save
-      end
-    end
-      
-    def set_initial_inventory
-      return unless @quantity && @quantity.is_integer?    
-      variant.save
-      level = @quantity.to_i
-      InventoryUnit.create_on_hand(variant, level)
-      reload
-    end
+  # 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?
+  end
+
+  # ensures the master variant is flagged as such
+  def set_master_variant_defaults
+    master.is_master = true
+  end      
+  
+  # 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
+  end
 end

data/app/models/shipment.rb

@@ -2,12 +2,14 @@ class Shipment < ActiveRecord::Base
   belongs_to :order
   belongs_to :shipping_method
   belongs_to :address
+  has_one    :charge,   :as => :adjustment_source
 
   before_create :generate_shipment_number
-  after_save :recalculate_tax
   after_save :transition_order
-
-  accepts_nested_attributes_for :address 
+  after_save :create_shipping_charge
+  
+  attr_accessor :special_instructions 
+  accepts_nested_attributes_for :address
      
   def shipped?
     self.shipped_at
@@ -18,7 +20,19 @@ class Shipment < ActiveRecord::Base
     self.shipped_at = Time.now
   end
 
-  private  
+  def create_shipping_charge
+    if shipping_method
+      self.charge ||= Charge.create({
+          :order => order,
+          :secondary_type => "ShippingCharge",
+          :description => "#{I18n.t(:shipping)} (#{shipping_method.name})",
+          :adjustment_source => self,
+        })
+    end
+  end
+
+  private
+
   def generate_shipment_number
     record = true
     while record
@@ -34,14 +48,6 @@ class Shipment < ActiveRecord::Base
     order.shipments.each do |shipment|
       return unless shipment.shipped?
     end
-    current_user_session = UserSession.find   
-    current_user = current_user_session.user if current_user_session    
-    order.ship!                                        
-    order.state_events.create(:name => I18n.t('ship'), :user => current_user, :previous_state => order.state_was)
-  end
-  
-  def recalculate_tax
-    return unless order && order.respond_to?(:calculate_tax)      
-    order.update_attribute("tax_amount", order.calculate_tax)
+    order.ship!
   end
-end
+end

data/app/models/shipping_category.rb

@@ -1,3 +1,5 @@
 class ShippingCategory < ActiveRecord::Base
+  has_many :shipping_rates
+
   validates_presence_of :name
 end

data/app/models/shipping_method.rb

@@ -1,14 +1,27 @@
 class ShippingMethod < ActiveRecord::Base
   belongs_to :zone
+  has_many :shipping_rates
 
-  def calculate_shipping(shipment)
-    return 0 unless zone.include?(shipment.address)
-    return shipping_calculator.constantize.new.send(:calculate_shipping, shipment)
+  has_calculator
+   
+  def calculate_cost(shipment)
+    rate_calculators = {}
+    shipping_rates.each do |sr|
+      rate_calculators[sr.shipping_category_id] = sr.calculator
+    end
+ 
+    calculated_costs = shipment.order.line_items.group_by{|li|
+      li.product.shipping_category_id
+    }.map{ |shipping_category_id, line_items|
+      calc = rate_calculators[shipping_category_id] || self.calculator
+      calc.compute(line_items)
+    }.sum
+ 
+    return(calculated_costs)
   end   
   
   def available?(order)
-    calculator = shipping_calculator.constantize.new                               
-    return true unless calculator.respond_to?(:available?)
-    calculator.available?(order)    
+    zone.include?(order.shipment.address) &&
+      calculator
   end
 end

data/app/models/shipping_rate.rb

@@ -0,0 +1,6 @@
+class ShippingRate < ActiveRecord::Base
+  belongs_to :shipping_method
+  belongs_to :shipping_category
+  
+  has_calculator
+end

data/app/models/state.rb

@@ -1,11 +1,17 @@
 class State < ActiveRecord::Base
-  belongs_to :country
+  belongs_to  :country
   named_scope :order_by_name, :order => :name
+
+  has_one     :zone_member, :as => :zoneable
+  has_one     :zone,        :through => :zone_member
   
   validates_presence_of [:country, :name]
   
   def <=>(other)
     name <=> other.name
   end
-   
+
+  def to_s
+    name
+  end
 end

data/app/models/state_event.rb

@@ -5,4 +5,11 @@ class StateEvent < ActiveRecord::Base
   def <=>(other)
     created_at <=> other.created_at
   end
+
+  def before_create
+    if UserSession.activated? && current_user_session = UserSession.find
+      self.user_id ||= current_user_session.user.id
+    end
+    true   # don't stop the filters
+  end
 end

data/app/models/tax_category.rb

@@ -1,4 +1,6 @@
 class TaxCategory < ActiveRecord::Base
   validates_presence_of :name
   validates_uniqueness_of :name
+
+  has_many :tax_rates
 end

data/{vendor/extensions/tax_calculator/app → app}/models/tax_rate.rb

@@ -1,9 +1,15 @@
 class TaxRate < ActiveRecord::Base
   belongs_to :zone
   belongs_to :tax_category
-  validates_numericality_of :amount
+  
   validates_presence_of :amount
-  named_scope :by_zone, lambda { |zone| { :conditions => ["zone_id = ?", zone] } }
+  validates_numericality_of :amount
   
-  enumerable_constant :tax_type, :constants => [:sales_tax, :vat]
+  has_calculator
+  named_scope :by_zone, lambda { |zone| { :conditions => ["zone_id = ?", zone] } }
+
+  def calculate_tax(order)
+    calculator.compute(order)
+  end
+
 end

data/app/models/taxon.rb

@@ -4,25 +4,31 @@ class Taxon < ActiveRecord::Base
   has_and_belongs_to_many :products
   before_save :set_permalink  
     
+
+  # indicate which filters should be used for a taxon
+  # this method should be customized to your own site
+  include ProductFilters  # for detailed defs of filters
+  def applicable_filters
+    fs  = []
+    fs << ProductFilters.taxons_below(self)
+                          ## unless it's a root taxon? left open for demo purposes
+    fs += [ 
+            ProductFilters.price_filter,
+            ProductFilters.brand_filter,
+            ProductFilters.selective_brand_filter(self) ]
+  end
+
   private
+
+  # Creates permalink based on .to_url method provided by stringx gem
   def set_permalink
-    ancestors.reverse.collect { |ancestor| ancestor.name }.join( "/")
-    prefix = ancestors.reverse.collect { |ancestor| escape(ancestor.name) }.join( "/")
-    prefix += "/" unless prefix.blank?
-    self.permalink =  prefix + "#{escape(name)}/"
+    self.permalink = (ancestors.reverse + [self]).collect { |taxon| 
+      taxon.name.to_url 
+    }.join("/") + "/"
   end
   
-  # taken from the find_by_param plugin
+  # obsolete, kept for backwards compat 
   def escape(str)
-    return "" if str.blank? # hack if the str/attribute is nil/blank
-    s = Iconv.iconv('ascii//ignore//translit', 'utf-8', str.dup).to_s
-    returning str.dup.to_s do |s|
-      s.gsub!(/\ +/, '-') # spaces to dashes, preferred separator char everywhere
-      s.gsub!(/[^\w^-]+/, '') # kill non-word chars except -
-      s.strip!            # ohh la la
-      s.downcase!         # :D
-      s.gsub!(/([^ a-zA-Z0-9_-]+)/n,"") # and now kill every char not allowed.
-    end
+    str.blank? ? "" : str.to_url
   end
-  
 end