spree 0.10.2 → 0.11.0

data/app/models/calculator/flexi_rate.rb

@@ -21,7 +21,8 @@ class Calculator::FlexiRate < Calculator
   def compute(object)
     sum = 0
     max = self.preferred_max_items
-    object.length.times do |i|
+    items_count = object.inject(0) {|count, line_item| count + line_item.quantity }
+    items_count.times do |i|
       if (i % max == 0) && (max > 0)
         sum += self.preferred_first_item
       else

data/app/models/calculator/vat.rb

@@ -47,7 +47,7 @@ class Calculator::Vat < Calculator
 
     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 }
+    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

data/app/models/checkout.rb

@@ -118,7 +118,7 @@ class Checkout < ActiveRecord::Base
   end
 
   def process_coupon_code
-    return unless @coupon_code and coupon = Coupon.find_by_code(@coupon_code.upcase)
+    return unless @coupon_code and coupon = Coupon.find(:first, :conditions => ["UPPER(code) = ?",@coupon_code.upcase])
     coupon.create_discount(order)
     # recalculate order totals
     order.save

data/app/models/creditcard.rb

@@ -1,14 +1,14 @@
-class Creditcard < ActiveRecord::Base         
+class Creditcard < ActiveRecord::Base
   has_many :payments, :as => :source
 
   before_save :set_last_digits
-  
+
   validates_numericality_of :month, :integer => true
-  validates_numericality_of :year, :integer => true   
+  validates_numericality_of :year, :integer => true
   validates_presence_of :number, :unless => :has_payment_profile?, :on => :create
   validates_presence_of :verification_value, :unless => :has_payment_profile?, :on => :create
-  
-  
+
+
   def process!(payment)
     begin
       if Spree::Config[:auto_capture]
@@ -19,27 +19,29 @@ class Creditcard < ActiveRecord::Base
       end
     end
   end
-  
+
   def set_last_digits
-    self.last_digits ||= number.to_s.length <= 4 ? number : number.to_s.slice(-4..-1) 
+    number.to_s.gsub!(/\s/,'') unless number.nil?
+    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
-    
+
   def name?
     first_name? && last_name?
   end
-  
+
   def first_name?
     !self.first_name.blank?
   end
-  
+
   def last_name?
     !self.last_name.blank?
   end
-        
+
   def name
     "#{self.first_name} #{self.last_name}"
   end
-        
+
   def verification_value?
     !verification_value.blank?
   end
@@ -48,15 +50,19 @@ class Creditcard < ActiveRecord::Base
   def display_number
    "XXXX-XXXX-XXXX-#{last_digits}"
   end
-  
+
   alias :attributes_with_quotes_default :attributes_with_quotes
-  
 
-  
-  
+
+  # needed for some of the ActiveMerchant gateways (eg. SagePay)
+  def brand
+    cc_type
+  end
+
+
   private
-  
-  
+
+
   # Override default behavior of Rails attr_readonly so that its never written to the database (not even on create)
   def attributes_with_quotes(include_primary_key = true, include_readonly_attributes = true, attribute_names = @attributes.keys)
     attributes_with_quotes_default(include_primary_key, false, attribute_names)
@@ -67,8 +73,8 @@ class Creditcard < ActiveRecord::Base
       attributes.delete_if { |key, value| self.class.readonly_attributes.include?(key.gsub(/\(.+/,"")) }
     end
     # extra logic for sanitizing the number and verification value based on preferences
-    attributes.delete_if { |key, value| key == "number" and !Spree::Config[:store_cc] } 
-    attributes.delete_if { |key, value| key == "verification_value" and !Spree::Config[:store_cvv] } 
+    attributes.delete_if { |key, value| key == "number" and !Spree::Config[:store_cc] }
+    attributes.delete_if { |key, value| key == "verification_value" and !Spree::Config[:store_cvv] }
   end
 end
 

data/app/models/inventory_unit.rb

@@ -34,42 +34,57 @@ class InventoryUnit < ActiveRecord::Base
 
   # grab the appropriate units from inventory, mark as sold and associate with the order
   def self.sell_units(order)
+
+    # we should not already have inventory associated with the order at this point but we should clear to be safe (#1394)
+    order.inventory_units.destroy_all
+
     out_of_stock_items = []
     order.line_items.each do |line_item|
       variant = line_item.variant
       quantity = line_item.quantity
 
-      # mark all of these units as sold and associate them with this order
-      remaining_quantity = variant.count_on_hand - quantity
-      if (remaining_quantity >= 0)
-        quantity.times do
-          order.inventory_units.create(:variant => variant, :state => "sold")
-        end
-        variant.update_attribute(:count_on_hand, remaining_quantity)
-      else
-        (quantity + remaining_quantity).times do
-          order.inventory_units.create(:variant => variant, :state => "sold")
-        end
-        if Spree::Config[:allow_backorders]
-          (-remaining_quantity).times do
-            order.inventory_units.create(:variant => variant, :state => "backordered")
-          end
-        else
-          line_item.update_attribute(:quantity, quantity + remaining_quantity)
-          out_of_stock_items << {:line_item => line_item, :count => -remaining_quantity}
+      out_of_stock_items.concat create_units(order, variant, quantity)
+    end
+    out_of_stock_items
+  end
+
+  def self.adjust_units(order)
+    units_by_variant = order.inventory_units.group_by(&:variant_id)
+    out_of_stock_items = []
+
+    #check line items quantities match
+    order.line_items.each do |line_item|
+      variant = line_item.variant
+      quantity = line_item.quantity
+      unit_count = units_by_variant.key?(variant.id) ? units_by_variant[variant.id].size : 0
+
+      if unit_count < quantity
+        out_of_stock_items.concat create_units(order, variant, (quantity - unit_count))
+      elsif  unit_count > quantity
+        (unit_count - quantity).times do
+          inventory_unit = units_by_variant[variant.id].pop
+          inventory_unit.restock!
         end
-        variant.update_attribute(:count_on_hand, 0)
       end
+
+      #remove it from hash as it's up-to-date
+      units_by_variant.delete(variant.id)
     end
+
+    #check for deleted line items (if theres anything left in units_by_variant its' extra)
+    units_by_variant.each do |variant_id, units|
+      units.each {|unit| unit.restock!}
+    end
+
     out_of_stock_items
   end
 
   def can_restock?
-    %w(sold shipped).include?(state)
+    %w(sold shipped backordered).include?(state)
   end
 
   def restock!
-    variant.update_attribute(:count_on_hand, variant.count_on_hand + 1)
+    variant.update_attribute(:count_on_hand, variant.count_on_hand + 1) if Spree::Config[:track_inventory_levels] && !backordered?
     delete
   end
 
@@ -85,4 +100,38 @@ class InventoryUnit < ActiveRecord::Base
     Spree::Config[:allow_backorder_shipping] || (state == 'ready_to_ship')
   end
 
+  def self.create_units(order, variant, quantity)
+    out_of_stock_items = []
+
+    if Spree::Config[:track_inventory_levels]
+      # mark all of these units as sold and associate them with this order
+      remaining_quantity = variant.count_on_hand - quantity
+      if (remaining_quantity >= 0)
+        quantity.times do
+          order.inventory_units.create(:variant => variant, :state => "sold")
+        end
+        variant.update_attribute(:count_on_hand, remaining_quantity)
+      else
+        (quantity + remaining_quantity).times do
+          order.inventory_units.create(:variant => variant, :state => "sold")
+        end
+        if Spree::Config[:allow_backorders]
+          (-remaining_quantity).times do
+            order.inventory_units.create(:variant => variant, :state => "backordered")
+          end
+        else
+          line_item.update_attribute(:quantity, quantity + remaining_quantity)
+          out_of_stock_items << {:line_item => line_item, :count => -remaining_quantity}
+        end
+        variant.update_attribute(:count_on_hand, 0)
+      end
+    else
+      # not tracking stock levels, so just create all inventory_units as sold (for shipping purposes)
+      quantity.times do
+        order.inventory_units.create(:variant => variant, :state => "sold")
+      end
+    end
+    out_of_stock_items
+  end
+
 end

data/app/models/line_item.rb

@@ -2,10 +2,11 @@ class LineItem < ActiveRecord::Base
   before_validation :adjust_quantity
   belongs_to :order
   belongs_to :variant
-  
+
   has_one :product, :through => :variant
 
   before_validation :copy_price
+  before_destroy :ensure_not_shipped
 
   validates_presence_of :variant, :order
   validates_numericality_of :quantity, :only_integer => true, :message => I18n.t("validation.must_be_int")
@@ -16,19 +17,24 @@ class LineItem < ActiveRecord::Base
   def copy_price
     self.price = variant.price if variant && self.price.nil?
   end
-  
+
   def validate
     unless quantity && quantity >= 0
       errors.add(:quantity, I18n.t("validation.must_be_non_negative"))
     end
     # 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, I18n.t("validation.is_too_large"))
+    unless !Spree::Config[:track_inventory_levels]                        ||
+           Spree::Config[:allow_backorders]                               ||
+           order   && InventoryUnit.order_id_equals(order).first.present? ||
+           variant && quantity <= variant.on_hand
+      errors.add(:quantity, I18n.t("validation.is_too_large") + " (#{self.variant.name})")
+    end
+
+    if shipped_count = order.shipped_units.nil? ? nil : order.shipped_units[variant]
+      errors.add(:quantity, I18n.t("validation.cannot_be_less_than_shipped_units") ) if quantity < shipped_count
     end
   end
-  
+
   def increment_quantity
     self.quantity += 1
   end
@@ -36,14 +42,22 @@ class LineItem < ActiveRecord::Base
   def decrement_quantity
     self.quantity -= 1
   end
-  
+
   def total
-    self.price * self.quantity  
+    self.price * self.quantity
   end
   alias amount total
-  
-  def adjust_quantity    
+
+  def adjust_quantity
     self.quantity = 0 if self.quantity.nil? || self.quantity < 0
   end
+
+  private
+  def ensure_not_shipped
+    if shipped_count = order.shipped_units.nil? ? nil : order.shipped_units[variant]
+      errors.add_to_base I18n.t("cannot_destory_line_item_as_inventory_units_have_shipped")
+      return false
+    end
+  end
 end
 

data/app/models/order.rb

@@ -52,7 +52,7 @@ class Order < ActiveRecord::Base
   make_permalink :field => :number
 
   # attr_accessible is a nightmare with attachment_fu, so use attr_protected instead.
-  attr_protected :charge_total, :item_total, :total, :user, :number, :state, :token
+  attr_protected :charge_total, :item_total, :total, :user, :user_id, :number, :state, :token
 
   def checkout_complete; !!completed_at; end
 
@@ -98,7 +98,7 @@ class Order < ActiveRecord::Base
       transition :to => 'shipped', :from  => 'paid'
     end
     event :return_authorized do
-      transition :to => 'awaiting_return', :from => 'shipped'
+      transition :to => 'awaiting_return'
     end
   end
 
@@ -106,6 +106,13 @@ class Order < ActiveRecord::Base
     # pop the resume event so we can see what the event before that was
     state_events.pop if state_events.last.name == "resume"
     update_attribute("state", state_events.last.previous_state)
+
+    if paid?
+      InventoryUnit.sell_units(self) if inventory_units.empty?
+      shipment.inventory_units = inventory_units
+      shipment.ready!
+    end
+
   end
 
   def make_shipments_shipped
@@ -123,13 +130,8 @@ class Order < ActiveRecord::Base
   end
 
   def shipped_units
-    shipped_units = shipments.inject([]) { |units, shipment| units << shipment.inventory_units if shipment.shipped? }
-
-    if shipped_units.nil?
-      return nil
-    else
-      shipped_units.flatten!
-    end
+    shipped_units = shipments.inject([]) { |units, shipment| units.concat(shipment.shipped? ? shipment.inventory_units : []) }
+    return nil if shipped_units.empty?
 
     shipped = {}
     shipped_units.group_by(&:variant_id).each do |variant_id, ship_units|
@@ -286,8 +288,9 @@ class Order < ActiveRecord::Base
     end
 
     self.adjustment_total = self.charge_total - self.credit_total
-
     self.total            = self.item_total   + self.adjustment_total
+    
+    self.checkout.enable_validation_group(:register) unless self.checkout.nil?
   end
 
   def update_totals!
@@ -365,6 +368,7 @@ class Order < ActiveRecord::Base
   end
 
   def cancel_order
+    make_shipments_pending
     restock_inventory
     OrderMailer.deliver_cancel(self)
   end
@@ -373,6 +377,8 @@ class Order < ActiveRecord::Base
     inventory_units.each do |inventory_unit|
       inventory_unit.restock! if inventory_unit.can_restock?
     end
+
+    inventory_units.reload
   end
 
   def update_line_items

data/app/models/payment.rb

@@ -96,7 +96,10 @@ class Payment < ActiveRecord::Base
     end
 
     def create_payment_profile
-      source.create_payment_profile
+      return unless payment_profiles_supported? and source.number and !source.has_payment_profile?
+      source.payment_gateway.create_profile(self)
+    rescue ActiveMerchant::ConnectionError => e
+      gateway_error I18n.t(:unable_to_connect_to_gateway)
     end
   
 end

data/app/models/payment_method.rb

@@ -1,4 +1,5 @@
 class PaymentMethod < ActiveRecord::Base
+  DISPLAY =  [:both, :front_end, :back_end]
   default_scope :conditions => {:deleted_at => nil}
 
   @provider = nil
@@ -10,11 +11,11 @@ class PaymentMethod < ActiveRecord::Base
   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
@@ -22,14 +23,18 @@ class PaymentMethod < ActiveRecord::Base
     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?) }
+  def self.available(display=nil)
+    PaymentMethod.all.select { |p| p.active && (p.display == display.to_s || p.display.blank?) &&  (p.environment == ENV['RAILS_ENV'] || p.environment.blank?) }
   end
-  
+
   def self.active?
     self.count(:conditions => {:type => self.to_s, :environment => RAILS_ENV, :active => true}) > 0
   end
 
+  def self.current
+    PaymentMethod.find(:first, :conditions => {:active => true, :environment => ENV['RAILS_ENV']})
+  end
+
   def method_type
     type.demodulize.downcase
   end
@@ -42,4 +47,8 @@ class PaymentMethod < ActiveRecord::Base
     self.with_exclusive_scope { find(*args) }
   end
 
+  def payment_profiles_supported?
+    false
+  end
+
 end

data/app/models/product.rb

@@ -68,7 +68,7 @@ class Product < ActiveRecord::Base
   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
@@ -126,7 +126,7 @@ class Product < ActiveRecord::Base
 
   # adjusts the "on_hand" inventory level for the product up or down to match the given new_level
   def on_hand=(new_level)
-    raise "cannot set on_hand of product with variants" if has_variants?
+    raise "cannot set on_hand of product with variants" if has_variants? && Spree::Config[:track_inventory_levels]
     master.on_hand = new_level
   end
 
@@ -135,6 +135,14 @@ class Product < ActiveRecord::Base
     master.in_stock? || !!variants.detect{|v| v.in_stock?}
   end
 
+  def tax_category
+    if self[:tax_category_id].nil?
+      TaxCategory.first(:conditions => {:is_default => true})
+    else
+      TaxCategory.find(self[:tax_category_id])
+    end
+  end
+
   # Adding properties and option types on creation based on a chosen prototype
   attr_reader :prototype_id
   def prototype_id=(value)
@@ -207,7 +215,7 @@ class Product < ActiveRecord::Base
   # the master on_hand is meaningless once a product has variants as the inventory
   # units are now "contained" within the product variants
   def set_master_on_hand_to_zero_when_product_has_variants
-    master.on_hand = 0 if has_variants?
+    master.on_hand = 0 if has_variants? && Spree::Config[:track_inventory_levels]
   end
 
   # ensures the master variant is flagged as such
@@ -223,5 +231,5 @@ class Product < ActiveRecord::Base
 
   def update_memberships
     self.product_groups = ProductGroup.all.select{|pg| pg.include?(self)}
-  end  
+  end
 end