spree_core 1.3.5 → 2.0.0.rc1

data/app/models/spree/order_inventory.rb

@@ -0,0 +1,109 @@
+module Spree
+  class OrderInventory
+    attr_accessor :order
+
+    def initialize(order)
+      @order = order
+    end
+
+    def verify(line_item, shipment=nil)
+      # should only verify inventory for completed orders
+      # as carts have inventory assigned via create_proposed_shipment methh
+      #
+      # or when shipment is explicitly passed
+      if order.completed? || shipment.present?
+
+        variant_units = inventory_units_for(line_item.variant)
+
+        if variant_units.size < line_item.quantity
+          #add
+          quantity = line_item.quantity - variant_units.size
+
+          shipment = determine_target_shipment(line_item.variant) unless shipment
+
+          add_to_shipment(shipment, line_item.variant, quantity)
+
+        elsif variant_units.size > line_item.quantity
+          #remove
+          quantity = variant_units.size - line_item.quantity
+
+          order.shipments.each do |shipment|
+            break if quantity == 0
+
+            quantity -= remove_from_shipment(shipment, line_item.variant, quantity)
+          end
+
+        end
+      else
+        true
+      end
+    end
+
+    def inventory_units_for(variant)
+      units = order.shipments.collect{|s| s.inventory_units.all}.flatten
+      units.group_by(&:variant_id)[variant.id] || []
+    end
+
+    private
+
+    def determine_target_shipment(variant)
+      # get first unshipped shipment that already includes this variant
+      shipment = order.shipments.detect { |shipment| (shipment.ready? || shipment.pending?) && shipment.include?(variant) }
+
+      # get first unshipped shipment that's leaving from the a stock_location that stocks this variant
+      shipment ||= order.shipments.detect { |shipment| (shipment.ready? || shipment.pending?) && variant.stock_location_ids.include?(shipment.stock_location_id) }
+
+      # ship it!
+      shipment
+    end
+
+    def add_to_shipment(shipment, variant, quantity)
+      #create inventory_units
+      on_hand, back_order = shipment.stock_location.fill_status(variant, quantity)
+
+      on_hand.times do
+        shipment.inventory_units.create({variant_id: variant.id,
+                                          state: 'on_hand'}, without_protection: true)
+      end
+
+      back_order.times do
+        shipment.inventory_units.create({variant_id: variant.id,
+                                         state: 'backordered'}, without_protection: true)
+      end
+
+
+      # adding to this shipment, and removing from stock_location
+      shipment.stock_location.unstock variant, quantity, shipment
+
+      # return quantity added
+      quantity
+    end
+
+    def remove_from_shipment(shipment, variant, quantity)
+      return 0 if quantity == 0 || shipment.shipped?
+
+      shipment_units = shipment.inventory_units_for(variant).reject do |variant_unit|
+        variant_unit.state == 'shipped'
+      end.sort_by(&:state)
+
+      removed_quantity = 0
+
+      shipment_units.each do |inventory_unit|
+        break if removed_quantity == quantity
+        inventory_unit.destroy
+        removed_quantity += 1
+      end
+
+      if shipment.inventory_units.count == 0
+        shipment.destroy
+      end
+
+      # removing this from shipment, and adding to stock_location
+      shipment.stock_location.restock variant, removed_quantity, shipment
+
+      # return quantity removed
+      removed_quantity
+    end
+
+  end
+end

data/app/models/spree/order_populator.rb

@@ -17,7 +17,6 @@ module Spree
     #
     # * Multiple products at once
     # +:products => { product_id => variant_id, product_id => variant_id }, :quantity => quantity+
-    # +:products => { product_id => variant_id, product_id => variant_id }, :quantity => { variant_id => quantity, variant_id => quantity }+
     def populate(from_hash)
       from_hash[:products].each do |product_id,variant_id|
         attempt_cart_add(variant_id, from_hash[:quantity])
@@ -38,16 +37,17 @@ module Spree
 
     def attempt_cart_add(variant_id, quantity)
       quantity = quantity.to_i
-      if quantity > Spree::Config[:max_quantity]
-        errors.add(:base, I18n.t(:please_enter_reasonable_quantity, :scope => :order_populator))
+      # 2,147,483,647 is crazy.
+      # See issue #2695.
+      if quantity > 2_147_483_647
+        errors.add(:base, Spree.t(:please_enter_reasonable_quantity, :scope => :order_populator))
         return false
       end
 
       variant = Spree::Variant.find(variant_id)
       if quantity > 0
         if check_stock_levels(variant, quantity)
-          @order.add_variant(variant, quantity, currency)
-          @order.restart_checkout_flow
+          @order.contents.add(variant, quantity, currency)
         end
       end
     end
@@ -56,20 +56,10 @@ module Spree
       display_name = %Q{#{variant.name}}
       display_name += %Q{ (#{variant.options_text})} unless variant.options_text.blank?
 
-      if variant.available?
-        on_hand = variant.on_hand
-        if on_hand >= quantity || Spree::Config[:allow_backorders]
-          return true
-        else
-          remainder_message = I18n.t(:remainder_message,
-                                     :item => display_name.inspect,
-                                     :on_hand => on_hand,
-                                     :scope => :order_populator)
-          errors.add(:base, remainder_message)
-          return false
-        end
+      if Stock::Quantifier.new(variant).can_supply? quantity
+        true
       else
-        errors.add(:base, I18n.t(:out_of_stock, :item => display_name.inspect, :scope => :order_populator))
+        errors.add(:base, Spree.t(:out_of_stock, :scope => :order_populator, :item => display_name.inspect))
         return false
       end
     end

data/app/models/spree/order_updater.rb

@@ -1,7 +1,7 @@
 module Spree
   class OrderUpdater
     attr_reader :order
-    delegate :payments, :line_items, :adjustments, :shipments, :update_hooks, :to => :order
+    delegate :payments, :line_items, :adjustments, :shipments, :update_hooks, to: :order
 
     def initialize(order)
       @order = order
@@ -26,12 +26,12 @@ module Spree
       update_totals
 
       order.update_attributes_without_callbacks({
-        :payment_state => order.payment_state,
-        :shipment_state => order.shipment_state,
-        :item_total => order.item_total,
-        :adjustment_total => order.adjustment_total,
-        :payment_total => order.payment_total,
-        :total => order.total
+        payment_state: order.payment_state,
+        shipment_state: order.shipment_state,
+        item_total: order.item_total,
+        adjustment_total: order.adjustment_total,
+        payment_total: order.payment_total,
+        total: order.total
       })
 
       run_hooks
@@ -76,10 +76,11 @@ module Spree
         else
           # will return nil if no shipments are found
           order.shipment_state = shipment_states.first
-          if order.shipment_state && order.inventory_units.where(:shipment_id => nil).exists?
-            # shipments exist but there are unassigned inventory units
-            order.shipment_state = 'partial'
-          end
+          # TODO inventory unit states?
+          # if order.shipment_state && order.inventory_units.where(:shipment_id => nil).exists?
+          #   shipments exist but there are unassigned inventory units
+          #   order.shipment_state = 'partial'
+          # end
         end
       end
 
@@ -120,12 +121,22 @@ module Spree
     # Adjustments will check if they are still eligible. Ineligible adjustments
     # are preserved but not counted towards adjustment_total.
     def update_adjustments
-      order.adjustments.reload.each { |adjustment| adjustment.update!(order) }
+      order.adjustments.reload.each { |adjustment| adjustment.update! }
+      choose_best_promotion_adjustment
     end
-    
 
     private
 
+      # Picks one (and only one) promotion to be eligible for this order
+      # This promotion provides the most discount, and if two promotions
+      # have the same amount, then it will pick the latest one.
+      def choose_best_promotion_adjustment
+        if best_promotion_adjustment = order.adjustments.promotion.reorder("amount ASC, created_at DESC").first
+          other_promotions = order.adjustments.promotion.where("id NOT IN (?)", best_promotion_adjustment.id)
+          other_promotions.update_all(eligible: false)
+        end
+      end
+
       def round_money(n)
         (n * 100).round / 100.0
       end

data/app/models/spree/payment/processing.rb

@@ -17,7 +17,7 @@ module Spree
               end
             end
           else
-            raise Core::GatewayError.new(I18n.t(:payment_processing_failed))
+            raise Core::GatewayError.new(Spree.t(:payment_processing_failed))
           end
         end
       end
@@ -124,14 +124,13 @@ module Spree
 
       options.merge!({ :shipping => order.ship_total * 100,
                        :tax      => order.tax_total * 100,
-                       :subtotal => order.item_total * 100 })
-
-      options.merge!({ :currency => currency })
+                       :subtotal => order.item_total * 100,
+                       :discount => order.promo_total * 100,
+                       :currency => currency })
 
       options.merge!({ :billing_address  => order.bill_address.try(:active_merchant_hash),
                       :shipping_address => order.ship_address.try(:active_merchant_hash) })
 
-      options.merge!(:discount => promo_total) if respond_to?(:promo_total)
       options
     end
 
@@ -155,11 +154,6 @@ module Spree
         unless response.authorization.nil?
           self.response_code = response.authorization
           self.avs_response = response.avs_result['code']
-
-          if response.cvv_result
-            self.cvv_response_code = response.cvv_result['code']
-            self.cvv_response_message = response.cvv_result['message']
-          end
         end
         self.send("#{success_state}!")
       else
@@ -184,11 +178,11 @@ module Spree
       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)
+        text = Spree.t(:unable_to_connect_to_gateway)
       else
         text = error.to_s
       end
-      logger.error(I18n.t(:gateway_error))
+      logger.error(Spree.t(:gateway_error))
       logger.error("  #{error.to_yaml}")
       raise Core::GatewayError.new(text)
     end
@@ -197,7 +191,7 @@ module Spree
     # Ex. When testing in staging environment with a copy of production data.
     def check_environment
       return if payment_method.environment == Rails.env
-      message = I18n.t(:gateway_config_unavailable) + " - #{Rails.env}"
+      message = Spree.t(:gateway_config_unavailable) + " - #{Rails.env}"
       raise Core::GatewayError.new(message)
     end
 

data/app/models/spree/payment.rb

@@ -1,16 +1,16 @@
 module Spree
   class Payment < ActiveRecord::Base
     include Spree::Payment::Processing
-    belongs_to :order
-    belongs_to :source, :polymorphic => true, :validate => true
-    belongs_to :payment_method
+    belongs_to :order, class_name: 'Spree::Order'
+    belongs_to :source, polymorphic: true, validate: true
+    belongs_to :payment_method, class_name: 'Spree::PaymentMethod'
 
-    has_many :offsets, :class_name => "Spree::Payment", :foreign_key => :source_id, :conditions => "source_type = 'Spree::Payment' AND amount < 0 AND state = 'completed'"
-    has_many :log_entries, :as => :source
+    has_many :offsets, class_name: "Spree::Payment", foreign_key: :source_id, conditions: "source_type = 'Spree::Payment' AND amount < 0 AND state = 'completed'"
+    has_many :log_entries, as: :source
 
-    before_create :set_unique_identifier
+    before_save :set_unique_identifier
 
-    after_save :create_payment_profile, :if => :profiles_supported?
+    after_save :create_payment_profile, if: :profiles_supported?
 
     # update the order totals, etc.
     after_save :update_order
@@ -22,12 +22,12 @@ module Spree
 
     attr_accessible :amount, :payment_method_id, :source_attributes
 
-    scope :from_credit_card, lambda { where(:source_type => 'Spree::CreditCard') }
-    scope :with_state, lambda { |s| where(:state => s) }
+    scope :from_credit_card, -> { where(source_type: 'Spree::CreditCard') }
+    scope :with_state, ->(s) { where(state: s.to_s) }
     scope :completed, with_state('completed')
     scope :pending, with_state('pending')
     scope :failed, with_state('failed')
-    scope :valid, where("state NOT IN (?)", %w(failed invalid))
+    scope :valid, where('state NOT IN (?)', %w(failed invalid))
 
     after_rollback :persist_invalid
 
@@ -38,29 +38,29 @@ module Spree
     end
 
     # order state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
-    state_machine :initial => 'checkout' do
+    state_machine initial: 'checkout' do
       # With card payments, happens before purchase or authorization happens
       event :started_processing do
-        transition :from => ['checkout', 'pending', 'completed', 'processing'], :to => 'processing'
+        transition from: ['checkout', 'pending', 'completed', 'processing'], to: 'processing'
       end
       # When processing during checkout fails
       event :failure do
-        transition :from => ['pending', 'processing'], :to => 'failed'
+        transition from: ['pending', 'processing'], to: 'failed'
       end
       # With card payments this represents authorizing the payment
       event :pend do
-        transition :from => ['checkout', 'processing'], :to => 'pending'
+        transition from: ['checkout', 'processing'], to: 'pending'
       end
       # With card payments this represents completing a purchase or capture transaction
       event :complete do
-        transition :from => ['processing', 'pending', 'checkout'], :to => 'completed'
+        transition from: ['processing', 'pending', 'checkout'], to: 'completed'
       end
       event :void do
-        transition :from => ['pending', 'completed', 'checkout'], :to => 'void'
+        transition from: ['pending', 'completed', 'checkout'], to: 'void'
       end
       # when the card brand isnt supported
       event :invalidate do
-        transition :from => ['checkout'], :to => 'invalid'
+        transition from: ['checkout'], to: 'invalid'
       end
     end
 
@@ -69,7 +69,7 @@ module Spree
     end
 
     def money
-      Spree::Money.new(amount, { :currency => currency })
+      Spree::Money.new(amount, { currency: currency })
     end
     alias display_amount money
 
@@ -104,12 +104,6 @@ module Spree
     end
 
     private
-      def amount_is_valid_for_outstanding_balance_or_credit
-        return unless order
-        if amount != order.outstanding_balance
-          errors.add(:amount, "does not match outstanding balance (#{order.outstanding_balance})")
-        end
-      end
 
       def profiles_supported?
         payment_method.respond_to?(:payment_profiles_supported?) && payment_method.payment_profiles_supported?
@@ -142,7 +136,7 @@ module Spree
         chars = [('A'..'Z').to_a, ('0'..'9').to_a].flatten - %w(0 1 I O)
         identifier = ''
         8.times { identifier << chars[rand(chars.length)] }
-        if Spree::Payment.exists?(:identifier => identifier)
+        if Spree::Payment.exists?(identifier: identifier)
           # Call it again, we've got a duplicate ID.
           set_unique_identifier
         else

data/app/models/spree/payment_method.rb

@@ -1,12 +1,12 @@
 module Spree
   class PaymentMethod < ActiveRecord::Base
     DISPLAY = [:both, :front_end, :back_end]
-    default_scope where(:deleted_at => nil)
+    default_scope where(deleted_at: nil)
 
-    scope :production, lambda { where(:environment => 'production') }
+    scope :production, -> { where(environment: 'production') }
 
     attr_accessible :name, :description, :environment, :display_on, :active
-    validates :name, :presence => true
+    validates :name, presence: true
 
     def self.providers
       Rails.application.config.spree.payment_methods
@@ -32,7 +32,7 @@ module Spree
     end
 
     def self.active?
-      where(:type => self.to_s, :environment => Rails.env, :active => true).count > 0
+      where(type: self.to_s, environment: Rails.env, active: true).count > 0
     end
 
     def method_type

data/app/models/spree/preference.rb

@@ -1,10 +1,10 @@
 class Spree::Preference < ActiveRecord::Base
   attr_accessible :key, :value_type, :value
 
-  validates :key, :presence => true
-  validates :value_type, :presence => true
+  validates :key, presence: true
+  validates :value_type, presence: true
 
-  scope :valid, lambda { where(Spree::Preference.arel_table[:key].not_eq(nil)).where(Spree::Preference.arel_table[:value_type].not_eq(nil)) }
+  scope :valid, -> { where(Spree::Preference.arel_table[:key].not_eq(nil)).where(Spree::Preference.arel_table[:value_type].not_eq(nil)) }
 
   # The type conversions here should match
   # the ones in spree::preferences::preferrable#convert_preference_value
@@ -32,5 +32,4 @@ class Spree::Preference < ActiveRecord::Base
   def raw_value
     self[:value]
   end
-
 end

data/app/models/spree/price.rb

@@ -1,9 +1,9 @@
 module Spree
   class Price < ActiveRecord::Base
-    belongs_to :variant, :class_name => 'Spree::Variant'
+    belongs_to :variant, class_name: 'Spree::Variant'
 
     validate :check_price
-    validates :amount, :numericality => { :greater_than_or_equal_to => 0 }, :allow_nil => true
+    validates :amount, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true
 
     attr_accessible :variant_id, :currency, :amount
 
@@ -13,7 +13,7 @@ module Spree
     alias :display_price :display_amount
 
     def money
-      Spree::Money.new(amount || 0, { :currency => currency })
+      Spree::Money.new(amount || 0, { currency: currency })
     end
 
     def price

data/app/models/spree/product/scopes.rb

@@ -54,7 +54,7 @@ module Spree
     # If you need products only within one taxon use
     #
     #   Spree::Product.taxons_id_eq(x)
-    # 
+    #
     # If you're using count on the result of this scope, you must use the
     # `:distinct` option as well:
     #
@@ -68,11 +68,14 @@ module Spree
     #
     #   SELECT COUNT(*) ...
     add_search_scope :in_taxon do |taxon|
-      select("spree_products.id, spree_products.*").
-      where(id: Classification.select('spree_products_taxons.product_id').
-            joins(:taxon).
-            where(Taxon.table_name => { :id => taxon.self_and_descendants.pluck(:id) })
-           )
+      if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+        scope = select("DISTINCT ON (spree_products.id) spree_products.*")
+      else
+        scope = select("DISTINCT(spree_products.id), spree_products.*")
+      end
+
+      scope.joins(:taxons).
+      where(Taxon.table_name => { :id => taxon.self_and_descendants.map(&:id) })
     end
 
     # This scope selects products in all taxons AND all its descendants
@@ -208,11 +211,6 @@ module Spree
     end
     search_scopes << :active
 
-    add_search_scope :on_hand do
-      variants_table = Variant.table_name
-      where("#{table_name}.id in (select product_id from #{variants_table} where product_id = #{table_name}.id and #{variants_table}.deleted_at IS NULL group by product_id having sum(count_on_hand) > 0)")
-    end
-
     add_search_scope :taxons_name_eq do |name|
       group("spree_products.id").joins(:taxons).where(Taxon.arel_table[:name].eq(name))
     end