spree_core 0.60.6 → 0.70.0

data/app/models/creditcard.rb

@@ -23,7 +23,7 @@ class Creditcard < ActiveRecord::Base
     verification_value.to_s.gsub!(/\s/,'') unless number.nil?
     self.last_digits ||= number.to_s.length <= 4 ? number : number.to_s.slice(-4..-1)
   end
-  
+
   # cheap hack to get to the type? method from deep within ActiveMerchant without stomping on
   # potentially existing methods in CreditCard
   class CardDetector
@@ -31,12 +31,12 @@ class Creditcard < ActiveRecord::Base
       include ActiveMerchant::Billing::CreditCardMethods::ClassMethods
     end
   end
-  
+
   # sets self.cc_type while we still have the card number
   def set_card_type
     self.cc_type ||= CardDetector.type?(self.number)
   end
-  
+
   def name?
     first_name? && last_name?
   end
@@ -86,11 +86,11 @@ class Creditcard < ActiveRecord::Base
       payment.avs_response = response.avs_result['code']
       payment.pend
     else
-      payment.fail
+      payment.failure
       gateway_error(response)
     end
-  rescue ActiveMerchant::ConnectionError
-    gateway_error I18n.t(:unable_to_connect_to_gateway)
+  rescue ActiveMerchant::ConnectionError => e
+    gateway_error e
   end
 
   def purchase(amount, payment)
@@ -106,11 +106,11 @@ class Creditcard < ActiveRecord::Base
       payment.avs_response = response.avs_result['code']
       payment.complete
     else
-      payment.fail
+      payment.failure
       gateway_error(response) unless response.success?
     end
-  rescue ActiveMerchant::ConnectionError
-    gateway_error I18n.t(:unable_to_connect_to_gateway)
+  rescue ActiveMerchant::ConnectionError => e
+    gateway_error e
   end
 
   def capture(payment)
@@ -121,10 +121,10 @@ class Creditcard < ActiveRecord::Base
     if payment_gateway.payment_profiles_supported?
       # Gateways supporting payment profiles will need access to creditcard object because this stores the payment profile information
       # so supply the authorization itself as well as the creditcard, rather than just the authorization code
-      response = payment_gateway.capture(payment, self, minimal_gateway_options(payment))
+      response = payment_gateway.capture(payment, self, minimal_gateway_options(payment, false))
     else
       # Standard ActiveMerchant capture usage
-      response = payment_gateway.capture((payment.amount * 100).round, payment.response_code, minimal_gateway_options(payment))
+      response = payment_gateway.capture((payment.amount * 100).round, payment.response_code, minimal_gateway_options(payment, false))
     end
 
     record_log payment, response
@@ -133,18 +133,18 @@ class Creditcard < ActiveRecord::Base
       payment.response_code = response.authorization
       payment.complete
     else
-      payment.fail
+      payment.failure
       gateway_error(response)
     end
-  rescue ActiveMerchant::ConnectionError
-    gateway_error I18n.t(:unable_to_connect_to_gateway)
+  rescue ActiveMerchant::ConnectionError => e
+    gateway_error e
   end
 
   def void(payment)
     payment_gateway = payment.payment_method
     check_environment(payment_gateway)
 
-    response = payment_gateway.void(payment.response_code, minimal_gateway_options(payment))
+    response = payment_gateway.void(payment.response_code, minimal_gateway_options(payment, false))
     record_log payment, response
 
     if response.success?
@@ -153,8 +153,8 @@ class Creditcard < ActiveRecord::Base
     else
       gateway_error(response)
     end
-  rescue ActiveMerchant::ConnectionError
-    gateway_error I18n.t(:unable_to_connect_to_gateway)
+  rescue ActiveMerchant::ConnectionError => e
+    gateway_error e
   end
 
   def credit(payment)
@@ -162,11 +162,10 @@ class Creditcard < ActiveRecord::Base
     check_environment(payment_gateway)
 
     amount = payment.credit_allowed >= payment.order.outstanding_balance.abs ? payment.order.outstanding_balance.abs : payment.credit_allowed.abs
-
     if payment_gateway.payment_profiles_supported?
-      response = payment_gateway.credit((amount * 100).round, self, payment.response_code, minimal_gateway_options(payment))
+      response = payment_gateway.credit((amount * 100).round, self, payment.response_code, minimal_gateway_options(payment, false))
     else
-      response = payment_gateway.credit((amount * 100).round, payment.response_code, minimal_gateway_options(payment))
+      response = payment_gateway.credit((amount * 100).round, payment.response_code, minimal_gateway_options(payment, false))
     end
 
     record_log payment, response
@@ -181,8 +180,8 @@ class Creditcard < ActiveRecord::Base
     else
       gateway_error(response)
     end
-  rescue ActiveMerchant::ConnectionError
-    gateway_error I18n.t(:unable_to_connect_to_gateway)
+  rescue ActiveMerchant::ConnectionError => e
+    gateway_error e
   end
 
   def actions
@@ -218,6 +217,8 @@ class Creditcard < ActiveRecord::Base
   def gateway_error(error)
     if error.is_a? ActiveMerchant::Billing::Response
       text = error.params['message'] || error.params['response_reason_text'] || error.message
+    elsif error.is_a? ActiveMerchant::ConnectionError
+      text = I18n.t(:unable_to_connect_to_gateway)  
     else
       text = error.to_s
     end
@@ -242,18 +243,22 @@ class Creditcard < ActiveRecord::Base
   # Generates a minimal set of gateway options.  There appears to be some issues with passing in
   # a billing address when authorizing/voiding a previously captured transaction.  So omits these
   # options in this case since they aren't necessary.
-  def minimal_gateway_options(payment)
-    {:email    => payment.order.email,
-     :customer => payment.order.email,
-     :ip       => payment.order.ip_address,
-     :order_id => payment.order.number,
-     :shipping => payment.order.ship_total * 100,
-     :tax      => payment.order.tax_total * 100,
-     :subtotal => payment.order.item_total * 100}
+  def minimal_gateway_options(payment, totals=true)
+
+    options = {:email    => payment.order.email,
+               :customer => payment.order.email,
+               :ip       => payment.order.ip_address,
+               :order_id => payment.order.number}
+    if totals
+      options.merge!({ :shipping => payment.order.ship_total * 100,
+                       :tax      => payment.order.tax_total * 100,
+                       :subtotal => payment.order.item_total * 100 })
+    end
+    options
   end
 
   def spree_cc_type
-    return "visa" if ::Rails.env == "development"
+    return "visa" if ENV['RAILS_ENV'] == "development"
     self.cc_type
   end
 

data/app/models/gateway.rb

@@ -17,6 +17,7 @@ class Gateway < PaymentMethod
 
   def provider
     gateway_options = options
+    gateway_options.delete :login if gateway_options.has_key?(:login) and gateway_options[:login].nil?
     ActiveMerchant::Billing::Base.gateway_mode = gateway_options[:server].to_sym
     @provider ||= provider_class.new(gateway_options)
   end

data/app/models/image.rb

@@ -3,13 +3,18 @@ class Image < Asset
   has_attached_file :attachment,
                     :styles => { :mini => '48x48>', :small => '100x100>', :product => '240x240>', :large => '600x600>' },
                     :default_style => :product,
-                    :url => "/assets/products/:id/:style/:basename.:extension",
-                    :path => ":rails_root/public/assets/products/:id/:style/:basename.:extension"
+                    :url => "/spree/products/:id/:style/:basename.:extension",
+                    :path => ":rails_root/public/spree/products/:id/:style/:basename.:extension"
 
   # save the w,h of the original image (from which others can be calculated)
   # we need to look at the write-queue for images which have not been saved yet
   after_post_process :find_dimensions
 
+  #used by admin products autocomplete
+  def mini_url
+    attachment.url(:mini, false)
+  end
+
   def find_dimensions
     temporary = attachment.queued_for_write[:original]
     filename = temporary.path unless temporary.nil?

data/app/models/inventory_unit.rb

@@ -22,12 +22,6 @@ class InventoryUnit < ActiveRecord::Base
     after_transition :to => 'returned', :do => :restock_variant
   end
 
-  # method deprecated in favour of adjust_units (which creates & destroys units as needed).
-  def self.sell_units(order)
-    warn "[DEPRECATION] `InventoryUnits#sell_units` is deprecated.  Please use `InventoryUnits#assign_opening_inventory` instead. (called from #{caller[0]})"
-    self.adjust_units(order)
-  end
-
   # Assigns inventory to a newly completed order.
   # Should only be called once during the life-cycle of an order, on transition to completed.
   #
@@ -88,7 +82,10 @@ class InventoryUnit < ActiveRecord::Base
   end
 
   def self.destroy_units(order, variant, quantity)
-    variant_units = order.inventory_units.group_by(&:variant_id)[variant.id].sort_by(&:state)
+    variant_units = order.inventory_units.group_by(&:variant_id)
+    return unless variant_units.include? variant.id
+
+    variant_units = variant_units[variant.id].sort_by(&:state)
 
     quantity.times do
       inventory_unit = variant_units.shift
@@ -97,9 +94,8 @@ class InventoryUnit < ActiveRecord::Base
   end
 
   def self.create_units(order, variant, sold, back_order)
-    if back_order > 0 && !Spree::Config[:allow_backorders]
-      raise "Cannot request back orders when backordering is disabled"
-    end
+    return if back_order > 0 && !Spree::Config[:allow_backorders]
+
 
     shipment = order.shipments.detect {|shipment| !shipment.shipped? }
 

data/app/models/line_item.rb

@@ -10,6 +10,8 @@ class LineItem < ActiveRecord::Base
   validates :variant, :presence => true
   validates :quantity, :numericality => { :only_integer => true, :message => I18n.t("validation.must_be_int") }
   validates :price, :numericality => true
+  validate :stock_availability
+  
   # validate :meta_validation_of_quantities
 
   attr_accessible :quantity
@@ -58,6 +60,14 @@ class LineItem < ActiveRecord::Base
     self.quantity = 0 if self.quantity.nil? || self.quantity < 0
   end
 
+  def sufficient_stock?
+    Spree::Config[:allow_backorders] ? true : (self.variant.on_hand >= self.quantity)
+  end
+
+  def insufficient_stock?
+    !sufficient_stock?
+  end
+
   private
     def update_inventory
       return true unless self.order.completed?
@@ -89,7 +99,12 @@ class LineItem < ActiveRecord::Base
       if order.try(:inventory_units).to_a.any?{|unit| unit.variant_id == variant_id && unit.shipped?}
         errors.add :base, I18n.t("cannot_destory_line_item_as_inventory_units_have_shipped")
         return false
-     end
-  end
+      end
+    end
+
+    def stock_availability
+      return if sufficient_stock?
+      errors.add(:quantiy, "can't be greater than avaiable stock.")
+    end
 end
 

data/app/models/order.rb

@@ -25,6 +25,7 @@ class Order < ActiveRecord::Base
 
   before_create :create_user
   before_create :generate_order_number
+  after_create :create_tax_charge!
 
   # TODO: validate the format of the email as well (but we can't rely on authlogic anymore to help with validation)
   validates :email, :presence => true, :format => /^([\w\.%\+\-]+)@([\w\-]+\.)+([\w]{2,})$/i, :if => :require_email
@@ -44,8 +45,6 @@ class Order < ActiveRecord::Base
 
   make_permalink :field => :number
 
-  attr_accessor :out_of_stock_items
-
   class_attribute :update_hooks
   self.update_hooks = Set.new
 
@@ -69,18 +68,24 @@ class Order < ActiveRecord::Base
     line_items.count > 0
   end
 
+  # Is this a free order in which case the payment step should be skipped
+  def payment_required?
+    total.to_f > 0.0
+  end
+
   # Indicates the number of items in the order
   def item_count
     line_items.map(&:quantity).sum
   end
 
   # order state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
-  state_machine :initial => 'cart', :use_transactions => false do
+  state_machine :initial => :cart, :use_transactions => false do
 
     event :next do
       transition :from => 'cart',     :to => 'address'
       transition :from => 'address',  :to => 'delivery'
-      transition :from => 'delivery', :to => 'payment'
+      transition :from => 'delivery', :to => 'payment', :if => :payment_required?
+      transition :from => 'delivery', :to => 'complete'
       transition :from => 'confirm',  :to => 'complete'
 
       # note: some payment methods will not support a confirm step
@@ -257,9 +262,18 @@ class Order < ActiveRecord::Base
 
   # Creates a new tax charge if applicable.  Uses the highest possible matching rate and destroys any previous
   # tax charges if they were created by rates that no longer apply.
+  # for the vat case adjutments according to default country are created
   def create_tax_charge!
     adjustments.tax.each {|e| e.destroy }
-    TaxRate.match(ship_address).each {|r| r.create_adjustment(I18n.t(:tax), self, self, true) }
+    matching_rates = TaxRate.match(ship_address)
+    if matching_rates.empty? and Spree::Config[:show_price_inc_vat]
+    # somebody may be able to make the search shorter here , some unremember bug caused this
+      matching_rates = TaxRate.all.select{|rate| # get all rates that apply to default country
+          rate.zone.country_list.collect{|c| c.id}.include?(Spree::Config[:default_country_id]) }
+    end
+    matching_rates.each do |rate|
+      rate.create_adjustment( "#{rate.calculator.description} #{rate.amount*100}%" , self, self, true)
+    end
   end
 
   # Creates a new shipment (adjustment is created by shipment model)
@@ -283,11 +297,6 @@ class Order < ActiveRecord::Base
    self.outstanding_balance != 0
   end
 
-  def destroy_inapplicable_adjustments
-    destroyed = adjustments.reject(&:applicable?).map(&:destroy)
-    adjustments.reload if destroyed.any?
-  end
-
   def name
     if (address = bill_address || ship_address)
       "#{address.firstname} #{address.lastname}"
@@ -307,7 +316,7 @@ class Order < ActiveRecord::Base
   # Called after transition to complete state when payments will have been processed
   def finalize!
     update_attribute(:completed_at, Time.now)
-    self.out_of_stock_items = InventoryUnit.assign_opening_inventory(self)
+    InventoryUnit.assign_opening_inventory(self)
     # lock any optional adjustments (coupon promotions, etc.)
     adjustments.optional.each { |adjustment| adjustment.update_attribute("locked", true) }
     OrderMailer.confirm_email(self).deliver
@@ -367,6 +376,10 @@ class Order < ActiveRecord::Base
     line_items.map{|li| li.variant.product}
   end
 
+  def insufficient_stock_lines
+    line_items.select &:insufficient_stock?
+  end
+
   private
   def create_user
     self.email = user.email if self.user and not user.anonymous?
@@ -419,10 +432,10 @@ class Order < ActiveRecord::Base
   #
   # 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
-    if payment_total < total
+    if round_money(payment_total) < round_money(total)
       self.payment_state = "balance_due"
       self.payment_state = "failed" if payments.present? and payments.last.state == "failed"
-    elsif payment_total > total
+    elsif round_money(payment_total) > round_money(total)
       self.payment_state = "credit_owed"
     else
       self.payment_state = "paid"
@@ -432,12 +445,16 @@ class Order < ActiveRecord::Base
       self.state_events.create({
         :previous_state => old_payment_state,
         :next_state     => self.payment_state,
-        :name           => "payment" ,
+        :name           => "payment",
         :user_id        =>  (User.respond_to?(:current) && User.current && User.current.id) || self.user_id
       })
     end
   end
 
+  def round_money(n)
+    (n*100).round / 100.0
+  end
+  
   # Updates the following Order total values:
   #
   # +payment_total+      The total value of all finalized Payments (NOTE: non-finalized Payments are excluded)
@@ -448,17 +465,15 @@ class Order < ActiveRecord::Base
     # update_adjustments
     self.payment_total = payments.completed.map(&:amount).sum
     self.item_total = line_items.map(&:amount).sum
-    self.adjustment_total = adjustments.map(&:amount).sum
+    self.adjustment_total = adjustments.eligible.map(&:amount).sum
     self.total = item_total + adjustment_total
   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 that are no longer
-  # applicable will be removed from the association and destroyed.
+  # 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
-    # separate into adjustments to keep and adjustements to toss
-    obsolete_adjustments = adjustments.select{|adjustment| !adjustment.applicable?}
-    obsolete_adjustments.each(&:destroy)
     self.adjustments.reload.each(&:update!)
   end
 

data/app/models/payment.rb

@@ -26,7 +26,7 @@ class Payment < ActiveRecord::Base
       transition :from => ['checkout', 'pending', 'completed'], :to => 'processing'
     end
     # When processing during checkout fails
-    event :fail do
+    event :failure do
       transition :from => 'processing', :to => 'failed'
     end
     # With card payments this represents authorizing the payment
@@ -62,22 +62,16 @@ class Payment < ActiveRecord::Base
   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)
+  def build_source(params, opts)
     if payment_method and payment_method.payment_source_class
       self.source = payment_method.payment_source_class.new(params)
     end
   end
 
   def process!
-    if payment_method && payment_method.source_required?
-      if source
-        if !processing? && source.respond_to?(:process!)
-          started_processing!
-          source.process!(self) # source is responsible for updating the payment state when it's done processing
-        end
-      else
-        raise Spree::GatewayError.new(I18n.t(:payment_processing_failed))
-      end
+    if !processing? and source and source.respond_to?(:process!)
+      started_processing!
+      source.process!(self) # source is responsible for updating the payment state when it's done processing
     end
   end
 
@@ -108,7 +102,7 @@ class Payment < ActiveRecord::Base
       return unless source.is_a?(Creditcard) && source.number && !source.has_payment_profile?
       payment_method.create_profile(self)
     rescue ActiveMerchant::ConnectionError => e
-      gateway_error I18n.t(:unable_to_connect_to_gateway)
+      gateway_error e
     end
 
     def update_order

data/app/models/payment_method/check.rb

@@ -24,8 +24,4 @@ class PaymentMethod::Check < PaymentMethod
     payment.void
     true
   end
-  
-  def source_required?
-    false
-  end
 end

data/app/models/payment_method.rb

@@ -2,14 +2,8 @@ class PaymentMethod < ActiveRecord::Base
   DISPLAY =  [:both, :front_end, :back_end]
   default_scope where(:deleted_at => nil)
 
-  @provider = nil
-  @@providers = Set.new
-  def self.register
-    @@providers.add(self)
-  end
-
   def self.providers
-    @@providers.to_a
+    Rails.application.config.spree.payment_methods
   end
 
   def provider_class
@@ -51,8 +45,4 @@ class PaymentMethod < ActiveRecord::Base
     false
   end
 
-  def source_required?
-    true
-  end
-
 end

data/app/models/product.rb

@@ -44,21 +44,25 @@ class Product < ActiveRecord::Base
   after_save :save_master
 
   has_many :variants,
-    :conditions => ["variants.is_master = ? AND variants.deleted_at IS NULL", false],
-    :order => 'variants.position ASC'
-
+    :conditions => ["#{Variant.table_name}.is_master = ? AND #{Variant.table_name}.deleted_at IS NULL", false],
+    :order => "#{Variant.table_name}.position ASC"
 
   has_many :variants_including_master,
     :class_name => 'Variant',
-    :conditions => ["variants.deleted_at IS NULL"],
+    :conditions => ["#{Variant.table_name}.deleted_at IS NULL"],
     :dependent => :destroy
 
   has_many :variants_with_only_master,
     :class_name => 'Variant',
-    :conditions => ["variants.deleted_at IS NULL AND variants.is_master = ?", true],
+    :conditions => ["#{Variant.table_name}.deleted_at IS NULL AND #{Variant.table_name}.is_master = ?", true],
     :dependent => :destroy
 
 
+  def variant_images
+    Image.find_by_sql("SELECT assets.* FROM assets LEFT JOIN variants ON (variants.id = assets.viewable_id) WHERE (variants.product_id = #{self.id})")
+  end
+
+
   validates :name, :price, :permalink, :presence => true
 
   accepts_nested_attributes_for :product_properties, :allow_destroy => true, :reject_if => lambda { |pp| pp[:property_name].blank? }
@@ -69,30 +73,43 @@ class Product < ActiveRecord::Base
 
   include ::Scopes::Product
 
-  #RAILS3 TODO -  scopes are duplicated here and in scopres/product.rb - can we DRY it up?
+  #RAILS3 TODO -  scopes are duplicated here and in scopes/product.rb - can we DRY it up?
   # default product scope only lists available and non-deleted products
-  scope :not_deleted,     where("products.deleted_at is NULL")
+  class << self
+    def not_deleted
+      where(Product.arel_table[:deleted_at].eq(nil))
+    end
 
-  scope :available,       lambda { |*on| where("products.available_on <= ?", on.first || Time.zone.now ) }
+    def available(available_on = nil)
+      where(Product.arel_table[:available_on].lteq(available_on || Time.zone.now ))
+    end
 
-  #RAILS 3 TODO - this scope doesn't match the original 2.3.x version, needs attention (but it works)
-  scope :active,          lambda{ not_deleted.available }
+    #RAILS 3 TODO - this scope doesn't match the original 2.3.x version, needs attention (but it works)
+    def active
+      not_deleted.available
+    end
 
-  scope :on_hand,         where("products.count_on_hand > 0")
+    def on_hand
+      where(Product.arel_table[:count_on_hand].gteq(0))
+    end
+
+    def id_equals(input_id)
+      where(Product.arel_table[:id].eq(input_id))
+    end
 
+    def taxons_name_eq(name)
+      joins(:taxons).where(Taxon.arel_table[:name].eq(name))
+    end
+  end
   if (ActiveRecord::Base.connection.adapter_name == 'PostgreSQL')
-    if ActiveRecord::Base.connection.tables.include?("products")
-      scope :group_by_products_id, { :group => "products." + Product.column_names.join(", products.") }
+    if Product.table_exists?
+      scope :group_by_products_id, { :group => Product.column_names.map{|col_name| "#{Product.table_name}.#{col_name}"} }
     end
   else
-    scope :group_by_products_id, { :group => "products.id" }
+    scope :group_by_products_id, { :group => "#{Product.table_name}.id" }
   end
   search_methods :group_by_products_id
 
-  scope :id_equals, lambda { |input_id| where("products.id = ?", input_id) }
-
-  scope :taxons_name_eq, lambda { |name| joins(:taxons).where("taxons.name = ?", name) }
-
   # ----------------------------------------------------------------------------------------------------------
   #
   # The following methods are deprecated and will be removed in a future version of Spree
@@ -130,7 +147,7 @@ class Product < ActiveRecord::Base
 
   # returns true if the product has any variants (the master variant is not a member of the variants array)
   def has_variants?
-    !variants.empty?
+    variants.any?
   end
 
   # returns the number of inventory units "on_hand" for this product
@@ -146,7 +163,7 @@ class Product < ActiveRecord::Base
 
   # Returns true if there are inventory units (any variant) with "on_hand" state for this product
   def has_stock?
-    master.in_stock? || !!variants.detect{|v| v.in_stock?}
+    master.in_stock? || variants.any?(&:in_stock?)
   end
 
   def tax_category
@@ -175,30 +192,30 @@ class Product < ActiveRecord::Base
   # 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 = self.dup
     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}
+    p.product_properties = self.product_properties.map {|q| r = q.dup; 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}
+    image_dup = lambda {|i| j = i.dup; j.attachment = i.attachment.clone; j}
+    p.images = self.images.map {|i| image_dup.call i}
 
-    variant = self.master.clone
+    variant = self.master.dup
     variant.sku = 'COPY OF ' + self.master.sku
     variant.deleted_at = nil
-    variant.images = self.master.images.map {|i| image_clone.call i}
+    variant.images = self.master.images.map {|i| image_dup.call i}
     p.master = variant
 
     if self.has_variants?
-      # don't clone the actual variants, just the characterising types
+      # don't dup 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.send(:duplicate_extra, self) if p.respond_to?(:duplicate_extra)
     p.save!
     p
   end
@@ -217,13 +234,21 @@ class Product < ActiveRecord::Base
     variants.active.group_by {|v| v.option_values.detect {|o| o.option_type == opt_type} }
   end
 
+  def effective_tax_rate
+    if self.tax_category
+      tax_category.effective_amount
+    else
+      TaxRate.default
+    end
+  end
+
   def self.like_any(fields, values)
     where_str = fields.map{|field| Array.new(values.size, "products.#{field} #{LIKE} ?").join(' OR ') }.join(' OR ')
     self.where([where_str, values.map{|value| "%#{value}%"} * fields.size].flatten)
   end
 
   private
-  
+
   def sanitize_permalink
     self.permalink = self.permalink.to_url
   end