spree_core 0.60.6 → 0.70.RC1

data/app/models/app_configuration.rb

@@ -2,6 +2,8 @@ class AppConfiguration < Configuration
 
   preference :site_name, :string, :default => 'Spree Demo Site'
   preference :default_seo_title, :string, :default => ''
+  preference :default_meta_description, :string, :default => 'Spree demo site'
+  preference :default_meta_keywords, :string, :default => 'spree, demo'
   preference :site_url, :string, :default => 'demo.spreecommerce.com'
   preference :default_locale, :string, :default => 'en'
   preference :allow_locale_switching, :boolean, :default => true
@@ -13,12 +15,12 @@ class AppConfiguration < Configuration
   preference :show_descendents, :boolean, :default => true
   preference :show_zero_stock_products, :boolean, :default => true
   preference :orders_per_page, :integer, :default => 15
-  preference :show_only_complete_orders_by_default, :boolean, :default => false
+  preference :show_only_complete_orders_by_default, :boolean, :default => true
   preference :admin_products_per_page, :integer, :default => 10
   preference :admin_pgroup_preview_size, :integer, :default => 10
   preference :products_per_page, :integer, :default => 10
-  preference :logo, :string, :default => '/images/admin/bg/spree_50.png'
-  preference :stylesheets, :string, :default => 'screen' # Comma separate multiple stylesheets, e.g. 'screen,mystyle'
+  preference :logo, :string, :default => 'admin/bg/spree_50.png'
+  preference :stylesheets, :string, :default => 'reset,screen' # Comma separate multiple stylesheets, e.g. 'screen,mystyle'
   preference :admin_interface_logo, :string, :default => "admin/bg/spree_50.png"
   preference :allow_ssl_in_production, :boolean, :default => true
   preference :allow_ssl_in_development_and_test, :boolean, :default => false
@@ -27,6 +29,7 @@ class AppConfiguration < Configuration
   preference :alternative_shipping_phone, :boolean, :default => false # Request extra phone for ship addr
   preference :shipping_instructions,      :boolean, :default => false # Request instructions/info for shipping
   preference :show_price_inc_vat, :boolean, :default => false
+  preference :shipment_inc_vat, :boolean, :default => false
   preference :auto_capture, :boolean, :default => false # automatically capture the creditcard (as opposed to just authorize and capture later)
   preference :address_requires_state, :boolean, :default => true # should state/state_name be required
   preference :checkout_zone, :string, :default => nil # replace with the name of a zone if you would like to limit the countries
@@ -35,9 +38,7 @@ class AppConfiguration < Configuration
   preference :use_content_controller, :boolean, :default => true
   preference :allow_checkout_on_gateway_error, :boolean, :default => false
   preference :select_taxons_from_tree, :boolean, :default => false # provide opportunity to select taxons from tree instead of search with autocomplete
-  preference :check_for_spree_alerts, :boolean, :default => true
-  preference :dismissed_spree_alerts, :string, :default => ''
-  preference :last_check_for_spree_alerts, :string, :default => nil
+  preference :max_level_in_taxons_menu, :integer, :default => 1 # maximum nesting level in taxons menu
 
   validates :name, :presence => true, :uniqueness => true
 

data/app/models/calculator/vat.rb

@@ -9,55 +9,39 @@ class Calculator::Vat < Calculator
     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.includes(:calculable => :zone).select {
-      |vat| vat.calculable.zone.country_list.include?(origin)
-    }
-    calcs.collect { |calc| calc.calculable }
-  end
+  def self.calculate_tax_on(product_or_variant)
+    product = product_or_variant.try(:product) || product_or_variant
 
-  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
+    (product_or_variant.price * product.effective_tax_rate).round(2, BigDecimal::ROUND_HALF_UP)
+  end
 
-    return 0 if taxable_totals.empty?
+  # computes vat for line_items associated with order, and tax rate and 
+  # now coupon discounts are taken into account in tax calcs
+  # and tax is added to shipment if :shipment_inc_vat is set
+  # coupons and shipment are applied if this object is the rate for the default category
+  #           (also items with no category get this rate applied)
+  def compute(order)
+    rate = self.calculable
     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
+    if rate.tax_category.is_default 
+      order.adjustments.each do | adjust |
+        next if adjust.originator_type == "TaxRate"
+        next if adjust.originator_type == "ShippingMethod" and not Spree::Config[:shipment_inc_vat]
 
-    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 }
+        tax += (adjust.amount * rate.amount).round(2, BigDecimal::ROUND_HALF_UP)
+      end
+    end
 
-    (product_or_variant.is_a?(Product) ? product_or_variant.price : product_or_variant.price) * rate.amount
-  end
+    order.line_items.each do  | line_item|
+      if line_item.product.tax_category  #only apply this calculator to products assigned this rates category
+        next unless line_item.product.tax_category == rate.tax_category
+      else
+        next unless rate.tax_category.is_default # and apply to products with no category, if this is the default rate
+      end
+      tax += (line_item.price * rate.amount).round(2, BigDecimal::ROUND_HALF_UP) * line_item.quantity
+    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)
-    }
+    tax
   end
 end

data/app/models/creditcard.rb

@@ -2,7 +2,6 @@ class Creditcard < ActiveRecord::Base
   has_many :payments, :as => :source
 
   before_save :set_last_digits
-  after_validation :set_card_type
 
   attr_accessor :number, :verification_value
 
@@ -23,20 +22,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
-    class << self
-      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,7 +72,7 @@ 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
@@ -106,7 +92,7 @@ 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
@@ -121,10 +107,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,7 +119,7 @@ class Creditcard < ActiveRecord::Base
       payment.response_code = response.authorization
       payment.complete
     else
-      payment.fail
+      payment.failure
       gateway_error(response)
     end
   rescue ActiveMerchant::ConnectionError
@@ -144,7 +130,7 @@ class Creditcard < ActiveRecord::Base
     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?
@@ -162,11 +148,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
@@ -242,19 +227,23 @@ 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"
-    self.cc_type
+    return "visa" if ENV['RAILS_ENV'] == "development"
+    self.class.type?(number)
   end
 
   # Saftey check to make sure we're not accidentally performing operations on a live gateway.

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/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
@@ -69,18 +70,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 +264,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( "#{I18n.t(:vat)} #{rate.amount*100}%" , self, self, true)
+    end
   end
 
   # Creates a new shipment (adjustment is created by shipment model)
@@ -283,11 +299,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}"
@@ -419,10 +430,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 +443,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 +463,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
 

data/app/models/payment_method.rb

@@ -51,8 +51,4 @@ class PaymentMethod < ActiveRecord::Base
     false
   end
 
-  def source_required?
-    true
-  end
-
 end

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