spree 0.8.5 → 0.9.0

data/app/models/calculator/sales_tax.rb

@@ -0,0 +1,48 @@
+class Calculator::SalesTax < Calculator
+
+  def self.description
+    I18n.t("sales_tax")
+  end
+    
+  def self.register
+    super
+    TaxRate.register_calculator(self)
+  end
+  
+  def self.calculate_tax(order, rates)
+    ActiveSupport::Deprecation.warn("please use Calculator::SalesTax#compute instead", caller)
+
+    return 0 if rates.empty?
+    # note: there is a bug with associations in rails 2.1 model caching so we're using this hack
+    # (see http://rails.lighthouseapp.com/projects/8994/tickets/785-caching-models-fails-in-development)
+    cache_hack = rates.first.respond_to?(:tax_category_id)
+            
+    taxable_totals = {}
+    order.line_items.each do |line_item|
+      next unless tax_category = line_item.variant.product.tax_category
+      next unless rate = rates.find { | sales_rate | sales_rate.tax_category_id == tax_category.id } if cache_hack
+      next unless rate = rates.find { | sales_rate | sales_rate.tax_category == tax_category } unless cache_hack
+
+      taxable_totals[tax_category] ||= 0
+      taxable_totals[tax_category] += line_item.total
+    end
+
+    return 0 if taxable_totals.empty?
+    tax = 0
+    rates.each do |rate|
+      tax_category = rate.tax_category unless cache_hack
+      tax_category = TaxCategory.find(rate.tax_category_id) if cache_hack
+      next unless taxable_total = taxable_totals[tax_category]
+      tax += taxable_total * rate.amount
+    end
+    tax
+  end
+
+  def compute(order)
+    rate = self.calculable
+    line_items = order.line_items.select { |i| i.product.tax_category == rate.tax_category }
+    line_items.inject(0) {|sum, line_item|
+      sum += line_item.total * rate.amount
+    }
+  end
+end

data/app/models/calculator/vat.rb

@@ -0,0 +1,63 @@
+class Calculator::Vat < Calculator
+
+  def self.description
+    I18n.t("vat")
+  end
+
+  def self.register
+    super
+    TaxRate.register_calculator(self)
+  end
+
+  # list the vat rates for the default country
+  def self.default_rates
+    origin = Country.find(Spree::Config[:default_country_id])
+    calcs = Calculator::Vat.find(:all, :include => {:calculable => :zone}).select {
+      |vat| vat.calculable.zone.country_list.include?(origin)
+    }
+    calcs.collect { |calc| calc.calculable }
+  end
+
+  def self.calculate_tax(order, rates=default_rates)
+    return 0 if rates.empty?
+    # note: there is a bug with associations in rails 2.1 model caching so we're using this hack
+    # (see http://rails.lighthouseapp.com/projects/8994/tickets/785-caching-models-fails-in-development)
+    cache_hack = rates.first.respond_to?(:tax_category_id)
+
+    taxable_totals = {}
+    order.line_items.each do |line_item|
+      next unless tax_category = line_item.variant.product.tax_category
+      next unless rate = rates.find { | vat_rate | vat_rate.tax_category_id == tax_category.id } if cache_hack
+      next unless rate = rates.find { | vat_rate | vat_rate.tax_category == tax_category } unless cache_hack
+      taxable_totals[tax_category] ||= 0
+      taxable_totals[tax_category] += line_item.price * rate.amount * line_item.quantity
+    end
+
+    return 0 if taxable_totals.empty?
+    tax = 0
+    taxable_totals.values.each do |total|
+      tax += total
+    end
+    tax
+  end
+
+  # TODO: Refactor this method after integrating #54 to use default address
+  def self.calculate_tax_on(product_or_variant)
+    vat_rates = default_rates
+
+    return 0 if vat_rates.nil?
+    return 0 unless tax_category = product_or_variant.is_a?(Product) ? product_or_variant.tax_category : product_or_variant.product.tax_category
+    return 0 unless rate = vat_rates.find { | vat_rate | vat_rate.tax_category_id = tax_category.id }
+
+    (product_or_variant.is_a?(Product) ? product_or_variant.price : product_or_variant.price) * rate.amount
+  end
+
+  # computes vat for line_items associated with order, and tax rate
+  def compute(order)
+    rate = self.calculable
+    line_items = order.line_items.select { |i| i.product.tax_category == rate.tax_category }
+    line_items.inject(0) {|sum, line_item|
+      sum += (line_item.price * rate.amount * line_item.quantity)
+    }
+  end
+end

data/app/models/charge.rb

@@ -0,0 +1,37 @@
+class Charge < Adjustment
+  validates_presence_of :secondary_type
+
+  def calculate_adjustment
+    if adjustment_source
+      case secondary_type
+      when "TaxCharge"
+        calculate_tax_charge
+      when "ShippingCharge"
+        calculate_shipping_charge
+      else
+        super
+      end
+    end
+  end
+
+  def calculate_tax_charge
+    return Calculator::Vat.calculate_tax(order) if order.shipment.address.blank? and Spree::Config[:show_price_inc_vat]
+    return unless order.shipment.address
+    zones = Zone.match(order.shipment.address)
+    tax_rates = zones.map{|zone| zone.tax_rates}.flatten.uniq
+    calculated_taxes = tax_rates.map{|tax_rate| tax_rate.calculate_tax(order)}
+    return(calculated_taxes.sum)
+  end
+
+  # Calculates shipping cost using calculators from shipping_rates and shipping_method
+  # shipping_method calculator is used when there's no corresponding shipping_rate calculator
+  #
+  # shipping costs are calculated for each shipping_category - so if order have items
+  # from 3 shipping categories, shipping cost will triple.
+  # You can alter this behaviour by overwriting this method in your site extension
+  def calculate_shipping_charge
+    return unless shipping_method = adjustment_source.shipping_method
+    shipping_method.calculate_cost(adjustment_source)
+  end
+
+end

data/app/models/checkout.rb

@@ -0,0 +1,48 @@
+class Checkout < ActiveRecord::Base  
+  before_save :authorize_creditcard, :unless => "Spree::Config[:auto_capture]"
+  before_save :capture_creditcard, :if => "Spree::Config[:auto_capture]"
+  after_save :process_coupon_code
+  
+  belongs_to :order
+  belongs_to :bill_address, :foreign_key => "bill_address_id", :class_name => "Address"
+  has_one :shipment, :through => :order, :source => :shipments, :order => "shipments.created_at ASC"                       
+  
+  accepts_nested_attributes_for :bill_address
+  accepts_nested_attributes_for :shipment
+
+  # for memory-only storage of creditcard details
+  attr_accessor :creditcard    
+  attr_accessor :coupon_code
+
+  validates_presence_of :order_id
+
+  private
+  def authorize_creditcard
+    return unless process_creditcard?
+    cc = Creditcard.new(creditcard.merge(:address => self.bill_address, :checkout => self))
+    return false unless cc.valid? 
+    return false unless cc.authorize(order.total)
+    return false unless order.complete
+  end
+
+  def capture_creditcard
+    return unless process_creditcard? 
+    cc = Creditcard.new(creditcard.merge(:address => self.bill_address, :checkout => self))
+    return false unless cc.valid?
+    return false unless cc.purchase(order.total)
+    return false unless order.complete
+    order.pay
+  end
+
+  def process_creditcard?
+    order and creditcard and not creditcard[:number].blank?
+  end
+
+  def process_coupon_code
+    return unless @coupon_code and coupon = Coupon.find_by_code(@coupon_code.upcase)
+    coupon.create_discount(order)       
+    # recalculate order totals
+    order.save
+  end
+
+end

data/app/models/country.rb

@@ -1,8 +1,18 @@
 class Country < ActiveRecord::Base
   has_many :states
-  named_scope :order_by_name, :order => :name  
+  
+  has_one     :zone_member, :as => :zoneable
+  has_one     :zone,        :through => :zone_member
 
+  named_scope :order_by_name, :order => :name  
+  validates_presence_of :name  
+  validates_presence_of :iso_name
+  
   def <=>(other)
     name <=> other.name
   end
+
+  def to_s
+    name
+  end
 end

data/app/models/coupon.rb

@@ -0,0 +1,27 @@
+class Coupon < ActiveRecord::Base
+  has_many  :credits,    :as => :adjustment_source
+  has_calculator
+
+  validates_presence_of :code
+  
+  def eligible?(order)
+    return false if expires_at and Time.now > expires_at
+    return false if usage_limit and credits.count >= usage_limit
+    return false if starts_at and Time.now < starts_at
+    # TODO - also check items in the order (once we support product groups for coupons)
+    true
+  end
+    
+  def create_discount(order)
+    if eligible?(order) and amount = calculator.compute(order)
+      amount = order.item_total if amount > order.item_total
+      order.coupon_credits.reload.clear unless combine? and order.coupon_credits.all? { |credit| credit.adjustment_source.combine? }
+      order.save
+      credits.create({
+          :order => order, 
+          :amount => amount,
+          :description => "#{I18n.t(:coupon)} (#{code})"
+        })
+    end
+  end
+end

data/app/models/credit.rb

@@ -0,0 +1,27 @@
+class Credit < Adjustment
+   before_save :inverse_amount
+
+  def calculate_adjustment
+    if adjustment_source
+      case adjustment_source_type
+      when "Coupon"
+       calculate_coupon_credit
+      else
+        super
+      end
+    end
+  end
+   
+  def inverse_amount
+    x = self.amount > 0 ? -1 : 1
+    self.amount = self.amount * x
+  end
+  
+  private 
+  def calculate_coupon_credit
+    return 0 if order.line_items.empty?
+    amount = adjustment_source.calculator.compute(order)
+    amount = order.item_total if amount > order.item_total
+    amount
+  end
+end

data/app/models/creditcard.rb

@@ -1,6 +1,6 @@
 class Creditcard < ActiveRecord::Base 
-  before_create :filter_sensitive
-  belongs_to :order
+  before_save :filter_sensitive
+  belongs_to :checkout
   belongs_to :address
   has_many :creditcard_payments
   before_validation :prepare
@@ -91,6 +91,7 @@ class Creditcard < ActiveRecord::Base
   # Validation logic ripped from ActiveMerchant's Creditcard model
   # http://github.com/Shopify/active_merchant/tree/master/lib/active_merchant/billing/credit_card.rb
   def filter_sensitive
+    self.display_number = ActiveMerchant::Billing::CreditCard.mask(number) if self.display_number.blank?
     self.number = nil unless Spree::Config[:store_cc]
     self.verification_value = nil unless Spree::Config[:store_cvv]
   end
@@ -99,9 +100,8 @@ class Creditcard < ActiveRecord::Base
     self.month = month.to_i
     self.year = year.to_i
     self.number = number.to_s.gsub(/[^\d]/, "")
-    self.display_number = ActiveMerchant::Billing::CreditCard.mask(number)
     self.cc_type.downcase! if cc_type.respond_to?(:downcase)
-    self.cc_type = self.class.type?(number) if cc_type.blank?    
+    self.cc_type = spree_cc_type if cc_type.blank?    
     self.first_name = address.firstname if address
     self.last_name = address.lastname if address
   end
@@ -127,7 +127,7 @@ class Creditcard < ActiveRecord::Base
   end
   
   def validate_switch_or_solo_attributes #:nodoc:
-    if %w[switch solo].include?(type)
+    if %w[switch solo].include?(cc_type)
       unless valid_month?(@start_month) && valid_start_year?(@start_year) || valid_issue_number?(@issue_number)
         errors.add :start_month, "is invalid" unless valid_month?(@start_month)
         errors.add :start_year, "is invalid" unless valid_start_year?(@start_year)

data/app/models/creditcard_payment.rb

@@ -5,14 +5,22 @@ class CreditcardPayment < Payment
   
   alias :txns :creditcard_txns
   
-  def find_authorization
+  def can_capture?
+    txns.present? and txns.last == authorization
+  end
+  
+  def capture
+    return unless can_capture?
+    original_auth = authorization
+    creditcard.capture(original_auth)
+    update_attribute("amount", original_auth.amount)
+  end
+  
+  def authorization
     #find the transaction associated with the original authorization/capture 
     txns.find(:first, 
-              :conditions => ["txn_type = ? AND response_code IS NOT NULL", CreditcardTxn::TxnType::AUTHORIZE],
+              :conditions => ["txn_type = ? AND response_code IS NOT NULL", CreditcardTxn::TxnType::AUTHORIZE.to_s],
               :order => 'created_at DESC')
   end 
   
-  def can_capture?
-    txns.last == find_authorization
-  end
 end

data/app/models/image.rb

@@ -4,4 +4,26 @@ class Image < Asset
                     :default_style => :product,
                     :url => "/assets/products/:id/:style/:basename.:extension",
                     :path => ":rails_root/public/assets/products/:id/:style/:basename.:extension"
-end
+
+  # 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
+  def find_dimensions
+    temporary = attachment.queued_for_write[:original] 
+    filename = temporary.path unless temporary.nil?
+    filename = attachment.path if filename.blank?
+    geometry = Paperclip::Geometry.from_file(filename)
+    self.attachment_width  = geometry.width
+    self.attachment_height = geometry.height
+  end
+
+  # if there are errors from the plugin, then add a more meaningful message
+  def validate
+    unless attachment.errors.empty?
+      # uncomment this to get rid of the less-than-useful interrim messages
+      # errors.clear 
+      errors.add :attachment, "Paperclip returned errors for file '#{attachment_file_name}' - check ImageMagick installation or image source file."
+      false
+    end
+  end
+end

data/app/models/inventory_unit.rb

@@ -21,7 +21,7 @@ class InventoryUnit < ActiveRecord::Base
     # TODO: add backorder state and relevant transitions
   end
   
-  # destory the specified number of on hand inventory units 
+  # destroy the specified number of on hand inventory units 
   def self.destroy_on_hand(variant, quantity)
     inventory = self.retrieve_on_hand(variant, quantity)
     inventory.each do |unit|
@@ -29,7 +29,7 @@ class InventoryUnit < ActiveRecord::Base
     end                                          
   end
   
-  # destory the specified number of on hand inventory units
+  # create the specified number of on hand inventory units
   def self.create_on_hand(variant, quantity)
     quantity.times do
       self.create(:variant => variant, :state => 'on_hand')
@@ -44,7 +44,8 @@ class InventoryUnit < ActiveRecord::Base
       # retrieve the requested number of on hand units (or as many as possible) - note: optimistic locking used here
       on_hand = self.retrieve_on_hand(variant, quantity)
       # mark all of these units as sold and associate them with this order 
-      on_hand.each do |unit|
+      on_hand.each do |unit|          
+        unit.order = order
         unit.sell!
       end
       # right now we always allow back ordering

data/app/models/line_item.rb

@@ -8,13 +8,18 @@ class LineItem < ActiveRecord::Base
   validates_presence_of :variant
   validates_numericality_of :quantity, :only_integer => true, :message => "must be an integer"
   validates_numericality_of :price
+
+  attr_accessible :quantity
   
   def validate
     unless quantity && quantity >= 0
-      errors.add(:quantity, "must be a positive value")
+      errors.add(:quantity, "must be a non-negative value")
     end
-    unless quantity <= variant.on_hand || Spree::Config[:allow_backorders]
-      errors.add(:quantity, " for #{variant.product.name} is too large-- stock on hand cannot cover requested quantity!")
+    # avoid reload of order.inventory_units by using direct lookup
+    unless Spree::Config[:allow_backorders]                               ||
+           order   && InventoryUnit.order_id_equals(order).first.present? || 
+           variant && quantity <= variant.on_hand                         
+      errors.add(:quantity, " is too large-- stock on hand cannot cover requested quantity!")
     end
   end
   
@@ -29,9 +34,10 @@ class LineItem < ActiveRecord::Base
   def total
     self.price * self.quantity  
   end
+  alias amount total
   
   def adjust_quantity    
-    self.quantity = 0 if self.quantity < 0
+    self.quantity = 0 if self.quantity.nil? || self.quantity < 0
   end
 end
 

data/app/models/order.rb

@@ -1,24 +1,47 @@
-class Order < ActiveRecord::Base  
-#  before_create :generate_order_number
-  before_save :update_line_items 
+class Order < ActiveRecord::Base
+  module Totaling
+    def total
+      map(&:amount).sum
+    end
+  end
+
   before_create :generate_token
-  
-  has_many :line_items, :dependent => :destroy, :attributes => true
-  has_many :inventory_units
-  has_many :state_events
-  has_many :payments
-  has_many :creditcard_payments
-  has_many :creditcards
+  before_save :update_line_items, :update_totals
+  after_create :create_checkout_and_shippment, :create_tax_charge
+
   belongs_to :user
+  has_many :state_events
+
+  has_many :line_items, :extend => Totaling, :dependent => :destroy
+  has_many :inventory_units
+
+  has_many :payments,            :extend => Totaling
+  has_many :creditcard_payments, :extend => Totaling
+
+  has_one :checkout
+  has_one :bill_address, :through => :checkout
   has_many :shipments, :dependent => :destroy
-  belongs_to :bill_address, :foreign_key => "bill_address_id", :class_name => "Address"
-  belongs_to :ship_address, :foreign_key => "ship_address_id", :class_name => "Address"
-  accepts_nested_attributes_for :creditcards, :reject_if => proc { |attributes| attributes['number'].blank? }  
-  accepts_nested_attributes_for :ship_address, :bill_address
+
+  has_many :adjustments,      :extend => Totaling, :order => :position
+  has_many :charges,          :extend => Totaling, :order => :position
+  has_many :shipping_charges, :extend => Totaling, :order => :position,
+    :class_name => "Charge", :conditions => {:secondary_type => "ShippingCharge"}
+  has_many :tax_charges,      :extend => Totaling, :order => :position,
+    :class_name => "Charge", :conditions => {:secondary_type => "TaxCharge"}
+  has_many :credits,          :extend => Totaling, :order => :position
+  has_many :coupon_credits, :class_name => "Credit", :extend => Totaling, :conditions => {:adjustment_source_type => "Coupon"}, :order => :position
+  has_many :non_zero_charges, :class_name => "Charge", :conditions => ["amount > 0"]
+
+  accepts_nested_attributes_for :checkout  
+  accepts_nested_attributes_for :line_items
+  
+  def ship_address; shipment.address; end
+  delegate :shipping_method, :to =>:shipment
+  delegate :email, :to => :checkout
+  delegate :ip_address, :to => :checkout
+  delegate :special_instructions, :to => :checkout 
   
   validates_associated :line_items, :message => "are not valid"
-  validates_numericality_of :tax_amount
-  validates_numericality_of :ship_amount
   validates_numericality_of :item_total
   validates_numericality_of :total
 
@@ -26,19 +49,21 @@ class Order < ActiveRecord::Base
   named_scope :between, lambda {|*dates| {:conditions => ["orders.created_at between :start and :stop", {:start => dates.first.to_date, :stop => dates.last.to_date}]}}
   named_scope :by_customer, lambda {|customer| {:include => :user, :conditions => ["users.email = ?", customer]}}
   named_scope :by_state, lambda {|state| {:conditions => ["state = ?", state]}}
-  named_scope :checkout_completed, lambda {|state| {:conditions => ["checkout_complete = ?", state]}}
-  
+  named_scope :checkout_complete, {:include => :checkout, :conditions => ["checkouts.completed_at IS NOT NULL"]}
+  make_permalink :field => :number
   
   # attr_accessible is a nightmare with attachment_fu, so use attr_protected instead.
-  attr_protected :ship_amount, :tax_amount, :item_total, :total, :user, :number, :ip_address, :checkout_complete, :state, :token
-  
+  attr_protected :charge_total, :item_total, :total, :user, :number, :state, :token
+
   def to_param  
     self.number if self.number
     generate_order_number unless self.number
     self.number.parameterize.to_s.upcase
   end
-  make_permalink :field => :number
-  
+
+  def checkout_complete
+    checkout.completed_at
+  end
   # order state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
   state_machine :initial => 'in_progress' do    
     after_transition :to => 'in_progress', :do => lambda {|order| order.update_attribute(:checkout_complete, false)}
@@ -46,7 +71,7 @@ class Order < ActiveRecord::Base
     after_transition :to => 'canceled', :do => :cancel_order
     after_transition :to => 'returned', :do => :restock_inventory
     after_transition :to => 'resumed', :do => :restore_state 
-     
+
     event :complete do
       transition :to => 'new', :from => 'in_progress'
     end
@@ -94,7 +119,9 @@ class Order < ActiveRecord::Base
       current_item.quantity = (current_item.quantity + quantity) if quantity > 1
       current_item.save
     else
-      current_item = LineItem.new(:quantity => quantity, :variant => variant, :price => variant.price)
+      current_item = LineItem.new(:quantity => quantity)
+      current_item.variant = variant
+      current_item.price   = variant.price
       self.line_items << current_item
     end
     
@@ -120,24 +147,7 @@ class Order < ActiveRecord::Base
     end          
     self.number = random
   end          
-  
-  def payment_total
-    payments.inject(0) {|sum, payment| sum + payment.amount}
-  end
-
-  # total of line items (no tax or shipping inc.)
-  def item_total
-    tot = 0
-    self.line_items.each do |li|
-      tot += li.total
-    end
-    self.item_total = tot
-  end
-  
-  def total
-    self.total = self.item_total + self.ship_amount + self.tax_amount
-  end 
- 
+    
   # convenience method since many stores will not allow user to create multiple shipments
   def shipment
     shipments.last
@@ -168,28 +178,70 @@ class Order < ActiveRecord::Base
     ShippingMethod.all.select { |method| method.zone.include?(ship_address) && method.available?(self) }
   end
    
-  def update_totals
-    # finalize order totals 
-    unless shipment.nil?
-      calculator = shipment.shipping_method.shipping_calculator.constantize.new
-      self.ship_amount = calculator.calculate_shipping(shipment) 
-    else
-      self.ship_amount = 0
+  def payment_total
+    payments.reload.total
+  end
+
+  def ship_total
+    shipping_charges.reload.total
+  end
+
+  def tax_total
+    tax_charges.reload.total
+  end
+
+  def credit_total
+    credits.reload.total.abs
+  end
+
+  def charge_total
+    charges.reload.total
+  end
+
+  def create_tax_charge
+    if tax_charges.empty?
+      tax_charges.create({
+          :order => self,
+          :description => I18n.t(:tax),
+          :adjustment_source => self,
+        })
     end
-    self.tax_amount = calculate_tax
-  end  
+  end
+
+  def update_totals
+    self.item_total       = self.line_items.total
+
+    # save the items which might be changed by an order update, so that
+    # charges can be recalculated accurately.
+    self.line_items.map(&:save)
+
+    adjustments.reload.each(&:update_amount)
+    self.adjustment_total = self.charge_total - self.credit_total
+
+    self.total            = self.item_total   + self.adjustment_total
+  end
+
+  def update_totals!
+    update_totals
+    save!
+  end
 
   private
+ 
   def complete_order
-    self.update_attribute(:checkout_complete, true)
-    InventoryUnit.sell_units(self)
-    if user && user.email
+    checkout.update_attribute(:completed_at, Time.now)
+    if email
       OrderMailer.deliver_confirm(self)
-    end   
-    update_totals
-    save
-  end   
-  
+    end
+    begin
+      InventoryUnit.sell_units(self)
+      save!
+    rescue Exception => e
+      logger.error "Problem saving authorized order: #{e.message}"
+      logger.error self.to_yaml
+    end
+  end
+
   def cancel_order
     restock_inventory
     OrderMailer.deliver_cancel(self)
@@ -200,14 +252,22 @@ class Order < ActiveRecord::Base
       inventory_unit.restock! if inventory_unit.can_restock?
     end
   end
-  
+ 
   def update_line_items
-    self.line_items.each do |line_item|
-      LineItem.destroy(line_item.id) if line_item.quantity == 0
-    end
+    to_wipe = self.line_items.select {|li| 0 == li.quantity || li.quantity.nil? }
+    LineItem.destroy(to_wipe)
+    self.line_items -= to_wipe      # important: remove defunct items, avoid a reload
   end
   
   def generate_token
-    self.token = Authlogic::Random.friendly_token    
-  end      
+    self.token = Authlogic::Random.friendly_token
+  end
+  
+  def create_checkout_and_shippment
+    self.shipments << Shipment.create(:order => self)
+    self.checkout ||= Checkout.create(:order => self)
+  end
 end
+
+# please don't remove it, it's needed to activite observer if user doesn't update environment.rb
+OrderObserver.instance