spree 0.9.4 → 0.10.0.beta

data/app/models/order_mailer.rb

@@ -22,6 +22,10 @@ class OrderMailer < ActionMailer::QueueMailer
   
   private
   def order_bcc
-    [Spree::Config[:order_bcc], Spree::Config[:mail_bcc]].delete_if { |email| email.blank? }.uniq
+      bcc = [Spree::Config[:order_bcc] || "", Spree::Config[:mail_bcc] || ""]
+      bcc = bcc.inject([]){|array, config_string| array + config_string.split(",")}
+      bcc = bcc.collect{|email| email.strip}
+      bcc = bcc.uniq
+      bcc
   end
 end

data/app/models/payment.rb

@@ -1,11 +1,102 @@
 class Payment < ActiveRecord::Base
-  belongs_to :order 
-  after_save :check_payments
-  after_destroy :check_payments
+  belongs_to :payable, :polymorphic => true
+  belongs_to :source, :polymorphic => true
+  belongs_to :payment_method
+
+  has_many :transactions
+  alias :txns :transactions
   
-  private
-  def check_payments                            
-    return unless order.checkout_complete       
-    order.pay! if order.payment_total >= order.total
+  after_save :create_payment_profile, :if => :payment_profiles_supported?
+  after_save :check_payments, :if => :order_payment?
+  after_destroy :check_payments, :if => :order_payment?
+
+  accepts_nested_attributes_for :source
+  
+  validate :amount_is_valid_for_outstanding_balance_or_credit, :if => :order_payment? 
+  validates_presence_of :payment_method, :if => Proc.new { |payable| payable.is_a? Checkout }
+
+  named_scope :from_creditcard, :conditions => {:source_type => 'Creditcard'}
+
+  def order
+    payable.is_a?(Order) ? payable : payable.order
+  end
+
+  # With nested attributes, Rails calls build_[association_name] for the nested model which won't work for a polymorphic association
+  def build_source(params)
+    if payment_method and payment_method.payment_source_class
+      self.source = payment_method.payment_source_class.new(params)
+    end
+  end
+  
+  def process!
+    source.process!(self) if source and source.respond_to?(:process!)
+  end  
+  
+  def can_finalize?
+    !finalized?
+  end
+  
+  def finalize!
+    return unless can_finalize?
+    source.finalize!(self) if source and source.respond_to?(:finalize!)
+    self.payable = payable.order
+    save!
+    payable.save!
   end
-end
+  
+  def finalized?
+    payable.is_a?(Order)
+  end
+
+  def actions
+    return [] unless source and source.respond_to? :actions
+    source.actions.select { |action| !source.respond_to?("can_#{action}?") or source.send("can_#{action}?", self) }
+  end
+
+  private
+  
+    def check_payments
+      return unless order.checkout_complete
+      #sorting by created_at.to_f to ensure millisecond percsision, plus ID - just in case
+      events = order.state_events.sort_by { |e| [e.created_at.to_f, e.id] }.reverse
+
+      
+      if order.returnable_units.nil? && order.return_authorizations.size >0
+        order.return!
+      elsif events.present? and %w(over_paid under_paid).include?(events.first.name)
+        events.each do |event|
+          if %w(shipped paid new).include?(event.previous_state)
+            order.update_attribute("state", event.previous_state)
+            return
+          end
+        end
+      elsif order.payment_total >= order.total
+        order.pay!
+      end
+    end
+  
+    def amount_is_valid_for_outstanding_balance_or_credit
+      if amount < 0
+        if amount.abs > order.outstanding_credit
+          errors.add(:amount, "Is greater than the credit owed (#{order.outstanding_credit})")
+        end
+      else
+        if amount > order.outstanding_balance
+          errors.add(:amount, "Is greater than the outstanding balance (#{order.outstanding_balance})")
+        end
+      end    
+    end
+  
+    def order_payment?
+      payable_type == "Order"
+    end 
+
+    def payment_profiles_supported?
+      source && source.payment_gateway && source.payment_gateway.payment_profiles_supported?
+    end
+
+    def create_payment_profile
+      source.create_payment_profile
+    end
+  
+end

data/app/models/payment_method.rb

@@ -0,0 +1,45 @@
+class PaymentMethod < ActiveRecord::Base
+  default_scope :conditions => {:deleted_at => nil}
+
+  @provider = nil
+  @@providers = Set.new
+  def self.register
+    @@providers.add(self)
+  end
+
+  def self.providers
+    @@providers.to_a
+  end
+  
+  def provider_class
+    raise "You must implement provider_class method for this gateway."
+  end
+  
+  # The class that will process payments for this payment type, used for @payment.source
+  # e.g. Creditcard in the case of a the Gateway payment type
+  # nil means the payment method doesn't require a source e.g. check
+  def payment_source_class
+    raise "You must implement payment_source_class method for this gateway."
+  end
+
+  def self.available    
+    PaymentMethod.all.select { |p| p.active and (p.environment == ENV['RAILS_ENV'] or p.environment.blank?) }
+  end
+  
+  def self.active?
+    self.count(:conditions => {:type => self.to_s, :environment => RAILS_ENV, :active => true}) > 0
+  end
+
+  def method_type
+    type.demodulize.downcase
+  end
+
+  def destroy
+    self.update_attribute(:deleted_at, Time.now.utc)
+  end
+
+  def self.find_with_destroyed *args
+    self.with_exclusive_scope { find(*args) }
+  end
+
+end

data/app/models/payment_method/check.rb

@@ -0,0 +1,2 @@
+class PaymentMethod::Check < PaymentMethod
+end

data/app/models/product.rb

@@ -1,10 +1,10 @@
 # PRODUCTS
-# Products represent an entity for sale in a store.  
-# Products can have variations, called variants 
-# Products properties include description, permalink, availability, 
+# 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 
+# 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.
@@ -16,73 +16,89 @@
 # 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
   has_many :product_option_types, :dependent => :destroy
   has_many :option_types, :through => :product_option_types
   has_many :variants, :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
-	
+  has_many :images, :as => :viewable, :order => :position, :dependent => :destroy
+  has_and_belongs_to_many :product_groups
   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
+
+  has_one :master,
+    :class_name => 'Variant',
+    :conditions => ["variants.is_master = ? AND variants.deleted_at IS NULL", true]
+
+  delegate_belongs_to :master, :sku, :price, :weight, :height, :width, :depth, :is_master, :cost_price
+
   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    
+  before_save :recalculate_count_on_hand
+  after_save :update_memberships if ProductGroup.table_exists?
+  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],
+
+  has_many :variants,
+    :conditions => ["variants.is_master = ? AND variants.deleted_at IS NULL", false]
+
+
+  has_many :variants_including_master,
+    :class_name => 'Variant',
+    :conditions => ["variants.deleted_at IS NULL"],
     :dependent => :destroy
 
-    validates_presence_of :name
-    validates_presence_of :price
+  validates_presence_of :name
+  validates_presence_of :price
 
   accepts_nested_attributes_for :product_properties
-  
+
   make_permalink
 
   alias :options :product_option_types
 
+  include ::Scopes::Product
+
   # default product scope only lists available and non-deleted products
   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 :on_hand,     { :conditions => "products.count_on_hand > 0" }
+  named_scope :not_deleted, { :conditions => "products.deleted_at is null" }
   named_scope :available,   lambda { |*args| { :conditions => ["products.available_on <= ?", args.first || Time.zone.now] } }
+  
+  if (ActiveRecord::Base.connection.adapter_name == 'PostgreSQL')
+    named_scope :group_by_products_id, { :group => "products." + Product.column_names.join(", products.") } if ActiveRecord::Base.connection.tables.include?("products")
+  else
+    named_scope :group_by_products_id, { :group => "products.id" }
+  end
 
-  # other useful product scopes
-  include ProductScopes
 
+  # truncate a list of results (TODO: move this into a superclass)
+  named_scope :limit, lambda {|n| {:limit => n}}
 
   # ----------------------------------------------------------------------------------------------------------
   #
   # 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]}"
+    warn "[DEPRECATION] `Product.master_price` is deprecated.  Please use `Product.price` instead. (called from #{caller[0]})"
     self.price
   end
-  
+
   def master_price=(value)
-    warn "[DEPRECATION] `Product.master_price=` is deprecated.  Please use `Product.price=` instead. (called from #{caller[0]}"
+    warn "[DEPRECATION] `Product.master_price=` is deprecated.  Please use `Product.price=` instead. (called from #{caller[0]})"
     self.price = value
   end
-  
+
   def variants?
     warn "[DEPRECATION] `Product.variants?` is deprecated.  Please use `Product.has_variants?` instead. (called from #{caller[0]})"
     self.has_variants?
   end
-  
+
   def variant
     warn "[DEPRECATION] `Product.variant` is deprecated.  Please use `Product.master` instead. (called from #{caller[0]})"
     self.master
@@ -92,11 +108,11 @@ class Product < ActiveRecord::Base
   # end deprecation region
   # ----------------------------------------------------------------------------------------------------------
 
-  def to_param       
+  def to_param
     return permalink unless permalink.blank?
     name.to_url
   end
-  
+
   # returns true if the product has any variants (the master variant is not a member of the variants array)
   def has_variants?
     !variants.empty?
@@ -123,7 +139,7 @@ class Product < ActiveRecord::Base
   def prototype_id=(value)
     @prototype_id = value.to_i
   end
-  
+
   def add_properties_and_option_types_from_prototype
     if prototype_id and prototype = Prototype.find_by_id(prototype_id)
       prototype.properties.each do |property|
@@ -132,9 +148,54 @@ class Product < ActiveRecord::Base
       self.option_types = prototype.option_types
     end
   end
-  
+
+  # for adding products which are closely related to existing ones
+  # define "duplicate_extra" for site-specific actions, eg for additional fields
+  def duplicate
+    p = self.clone
+    p.name = 'COPY OF ' + self.name
+    p.deleted_at = nil
+    p.created_at = p.updated_at = nil
+    p.taxons = self.taxons
+
+    p.product_properties = self.product_properties.map {|q| r = q.clone; r.created_at = r.updated_at = nil; r}
+
+    image_clone = lambda {|i| j = i.clone; j.attachment = i.attachment.clone; j}
+    p.images = self.images.map {|i| image_clone.call i}
+
+    variant = self.master.clone
+    variant.sku = 'COPY OF ' + self.master.sku
+    variant.deleted_at = nil
+    variant.images = self.master.images.map {|i| image_clone.call i}
+    p.master = variant
+
+    if self.has_variants?
+      # don't clone the actual variants, just the characterising types
+      p.option_types = self.option_types
+    else
+    end
+    # allow site to do some customization
+    p.send(:duplicate_extra) if p.respond_to?(:duplicate_extra)
+    p.save!
+    p
+  end
+
+  # use deleted? rather than checking the attribute directly. this
+  # allows extensions to override deleted? if they want to provide
+  # their own definition.
+  def deleted?
+    deleted_at
+  end
+
   private
 
+  def recalculate_count_on_hand
+    product_count_on_hand = has_variants? ?
+        variants.inject(0) {|acc, v| acc + v.count_on_hand} :
+        (master ? master.count_on_hand : 0)
+    self.count_on_hand = product_count_on_hand
+  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
@@ -144,11 +205,15 @@ class Product < ActiveRecord::Base
   # ensures the master variant is flagged as such
   def set_master_variant_defaults
     master.is_master = true
-  end      
-  
+  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
+    master.save if master && (master.changed? || master.new_record?)
   end
+
+  def update_memberships
+    self.product_groups = ProductGroup.all.select{|pg| pg.include?(self)}
+  end  
 end

data/app/models/product_group.rb

@@ -0,0 +1,201 @@
+# *ProductGroups* are used for creating and managing sets of products.
+# Product group can be either anonymous(adhoc) or named.
+#
+# Anonymous Product groups are created by combining product scopes generated from url
+# in 2 formats:
+#
+#   /t/*taxons/s/name_of_scope/comma_separated_arguments/name_of_scope_that_doesn_take_any//order
+#   */s/name_of_scope/comma_separated_arguments/name_of_scope_that_doesn_take_any//order
+#
+# Named product groups can be created from anonymous ones, lub from another named scope
+# (using ProductGroup.from_url method).
+# Named product groups have pernament urls, that don't change even after changes
+# to scopes are made, and come in two types.
+#
+#   /t/*taxons/pg/named_product_group
+#   */pg/named_product_group
+#
+# first one is used for combining named scope with taxons, named product group can
+# have #in_taxon or #taxons_name_eq scope defined, result should combine both
+# and return products that exist in both taxons.
+#
+# ProductGroup#dynamic_products returns chain of named scopes generated from order and
+# product scopes. So you can do counting, calculations etc, on resulted set of products,
+# without retriving all records.
+#
+# ProductGroup operates on named scopes defined for product in Scopes::Product,
+# or generated automatically by Searchlogic
+#
+class ProductGroup < ActiveRecord::Base
+  validates_presence_of :name
+  validates_associated :product_scopes
+
+  before_save :set_permalink
+  after_save :update_memberships
+
+  has_and_belongs_to_many :cached_products, :class_name => "Product"
+  # name
+  has_many :product_scopes
+  accepts_nested_attributes_for :product_scopes 
+
+  # Testing utility: creates new *ProductGroup* from search permalink url.
+  # Follows conventions for accessing PGs from URLs, as decoded in routes
+  def self.from_url(url)
+    pg = nil;
+    case url
+    when /\/t\/(.+?)\/s\/(.+)/  then taxons = $1; attrs = $2;
+    when /\/t\/(.+?)\/pg\/(.+)/ then taxons = $1; pg_name = $2;
+    when /(.*?)\/s\/(.+)/       then attrs = $2;
+    when /(.*?)\/pg\/(.+)/      then pg_name = $2;
+    else                        return(nil)
+    end
+
+    if pg_name && opg = ProductGroup.find_by_permalink(pg_name)
+      pg = new.from_product_group(opg)
+    elsif attrs
+      attrs = url.split("/")
+      pg = new.from_route(attrs)
+    end
+    taxon = taxons && taxons.split("/").last
+    pg.add_scope("in_taxon", taxon) if taxon
+    
+    pg
+  end
+
+  def from_product_group(opg)
+    self.product_scopes = opg.product_scopes.map{|ps|
+      ps = ps.clone;
+      ps.product_group_id = nil;
+      ps.product_group = self;
+      ps
+    }
+    self
+  end
+
+  def from_route(attrs)
+    self.order_scope = attrs.pop if attrs.length % 2 == 1
+    attrs.each_slice(2) do |scope|
+      next unless Product.condition?(scope.first)
+      add_scope(scope.first, scope.last.split(","))
+    end
+    self
+  end
+
+  def from_search(search_hash)
+    search_hash.each_pair do |scope_name, scope_attribute|
+      add_scope(scope_name, scope_attribute)
+    end
+    
+    self
+  end
+
+  def add_scope(scope_name, arguments=[])
+    self.product_scopes << ProductScope.new({
+        :name => scope_name.to_s,
+        :arguments => [*arguments]
+      })
+    self
+  end
+
+  def apply_on(scopish, use_order = true)
+    # There's bug in AR, it doesn't merge :order, instead it takes order
+    # from first nested_scope so we have to apply ordering FIRST.
+    # see #2253 on rails LH
+    base_product_scope = scopish
+    if use_order && !self.order_scope.blank? && Product.condition?(self.order_scope)
+      base_product_scope = base_product_scope.send(self.order_scope)
+    end
+
+    return self.product_scopes.reject {|s|
+             s.is_ordering?
+           }.inject(base_product_scope){|result, scope|
+             scope.apply_on(result)
+           }
+  end
+
+  # returns chain of named scopes generated from order scope and product scopes.
+  def dynamic_products(use_order = true)
+    apply_on(Product.scoped(nil), use_order)
+  end
+
+  # Does the final ordering if requested
+  # TODO: move the order stuff out of the above - is superfluous now
+  def products(use_order = true)
+    cached_group = Product.in_cached_group(self)	
+    if cached_group.limit(1).blank?
+      dynamic_products(use_order)
+    elsif !use_order
+      cached_group
+    else
+      product_scopes.select {|s| 
+        s.is_ordering?
+      }.inject(cached_group) {|res,order| 
+        order.apply_on(res)
+      }
+    end
+  end
+
+  def include?(product)
+    res = apply_on(Product.id_equals(product.id), false)
+    res.count > 0
+  end
+
+  def scopes_to_hash
+    result = {}
+    self.product_scopes.each do |scope|
+      result[scope.name] = scope.arguments
+    end
+    result
+  end
+
+  # generates ProductGroup url
+  def to_url
+    if (new_record? || name.blank?)
+      result = ""
+      result+= self.product_scopes.map{|ps|
+        [ps.name, ps.arguments.join(",")]
+      }.flatten.join('/')
+      result+= self.order_scope if self.order_scope
+    
+      result
+    else
+      name.to_url
+    end
+  end
+
+  def set_permalink
+    self.permalink = self.name.to_url
+  end
+  
+  def update_memberships
+    # wipe everything directly to avoid expensive in-rails sorting
+    ActiveRecord::Base.connection.execute "DELETE FROM product_groups_products WHERE product_group_id = #{self.id}"
+
+    # and generate the new group entirely in SQL
+    ActiveRecord::Base.connection.execute "INSERT INTO product_groups_products #{dynamic_products(false).scoped(:select => "products.id, #{self.id}").to_sql}"
+  end
+
+  def generate_preview(size = Spree::Config[:admin_pgroup_preview_size])
+    count = self.class.count_by_sql ["SELECT COUNT(*) FROM product_groups_products WHERE product_groups_products.product_group_id = ?", self]
+
+    return count, products.limit(size)
+  end
+
+  def to_s
+    "<ProductGroup" + (id && "[#{id}]").to_s + ":'#{to_url}'>"
+  end
+  
+  def order_scope
+    if scope = product_scopes.detect {|s| s.is_ordering?}
+      scope.name
+    end
+  end
+  def order_scope=(scope_name)
+    if scope = product_scopes.detect {|s| s.is_ordering?}
+      scope.update_attribute(:name, scope_name)
+    else
+      self.product_scopes.build(:name => scope_name, :arguments => [])
+    end    
+  end
+  
+end