spree_core 1.3.5 → 2.0.0.rc1

data/app/models/spree/stock_item.rb

@@ -0,0 +1,52 @@
+module Spree
+  class StockItem < ActiveRecord::Base
+    belongs_to :stock_location, class_name: 'Spree::StockLocation'
+    belongs_to :variant, class_name: 'Spree::Variant'
+    has_many :stock_movements, dependent: :destroy
+
+    validates_presence_of :stock_location, :variant
+    validates_uniqueness_of :variant_id, scope: :stock_location_id
+
+    attr_accessible :count_on_hand, :variant, :stock_location, :backorderable, :variant_id
+
+    after_save :process_backorders
+
+    delegate :weight, to: :variant
+
+    def backordered_inventory_units
+      Spree::InventoryUnit.backordered_for_stock_item(self)
+    end
+
+    def variant_name
+      variant.name
+    end
+
+    def adjust_count_on_hand(value)
+      self.with_lock do
+        self.reload
+        self.update_attribute(:count_on_hand, self.count_on_hand + value)
+        self.save!
+      end
+    end
+
+    def in_stock?
+      self.count_on_hand > 0
+    end
+
+    private
+    def count_on_hand=(value)
+      write_attribute(:count_on_hand, value)
+    end
+
+    def process_backorders
+      return unless changes['count_on_hand'] && changes['count_on_hand'].last.to_i > 0
+
+      backordered_units = backordered_inventory_units
+      while in_stock? && !backordered_units.empty?
+        inventory_unit = backordered_units.shift
+        inventory_unit.fill_backorder
+        self.adjust_count_on_hand(-1)
+      end
+    end
+  end
+end

data/app/models/spree/stock_location.rb

@@ -0,0 +1,65 @@
+module Spree
+  class StockLocation < ActiveRecord::Base
+    has_many :stock_items, dependent: :destroy
+    has_many :stock_movements, through: :stock_items
+
+    belongs_to :state, class_name: 'Spree::State'
+    belongs_to :country, class_name: 'Spree::Country'
+
+    validates_presence_of :name
+
+    attr_accessible :name, :active, :address1, :address2, :city, :zipcode,
+                    :state_name, :state_id, :country_id, :phone, :country_id
+
+    scope :active, -> { where(active: true) }
+
+    after_create :create_stock_items
+
+    def stock_item(variant)
+      stock_items.where(variant_id: variant).order(:id).first
+    end
+
+    def count_on_hand(variant)
+      stock_item(variant).try(:count_on_hand)
+    end
+
+    def backorderable?(variant)
+      stock_item(variant).try(:backorderable?)
+    end
+
+    def restock(variant, quantity, originator = nil)
+      move(variant, quantity, originator)
+    end
+
+    def unstock(variant, quantity, originator = nil)
+      move(variant, -quantity, originator)
+    end
+
+    def move(variant, quantity, originator = nil)
+      stock_item(variant).stock_movements.create!(quantity: quantity, originator: originator)
+    end
+
+    def fill_status(variant, quantity)
+      item = stock_item(variant)
+
+      if item.count_on_hand >= quantity
+        on_hand = quantity
+        backordered = 0
+      else
+        on_hand = item.count_on_hand
+        on_hand = 0 if on_hand < 0
+        backordered = item.backorderable? ? (quantity - on_hand) : 0
+      end
+
+      [on_hand, backordered]
+    end
+
+    private
+
+      def create_stock_items
+        Spree::Variant.find_each do |v|
+          self.stock_items.create!(variant: v)
+        end
+      end
+  end
+end

data/app/models/spree/stock_movement.rb

@@ -0,0 +1,26 @@
+module Spree
+  class StockMovement < ActiveRecord::Base
+    belongs_to :stock_item, class_name: 'Spree::StockItem'
+    belongs_to :originator, polymorphic: true
+
+    attr_accessible :quantity, :stock_item, :stock_item_id, :originator
+
+    after_create :update_stock_item_quantity
+
+    validates :stock_item, presence: true
+    validates :quantity, presence: true
+
+    scope :recent, order('created_at DESC')
+
+    def readonly?
+      !new_record?
+    end
+
+    private
+    def update_stock_item_quantity
+      return unless Spree::Config[:track_inventory_levels]
+      stock_item.adjust_count_on_hand quantity
+    end
+  end
+end
+

data/app/models/spree/stock_transfer.rb

@@ -0,0 +1,43 @@
+module Spree
+  class StockTransfer < ActiveRecord::Base
+    has_many :stock_movements, :as => :originator
+
+    belongs_to :source_location, :class_name => 'StockLocation'
+    belongs_to :destination_location, :class_name => 'StockLocation'
+
+    make_permalink field: :number, prefix: 'T'
+
+    attr_accessible :reference
+
+    def to_param
+      number
+    end
+
+    def source_movements
+      stock_movements.joins(:stock_item)
+        .where('spree_stock_items.stock_location_id' => source_location_id)
+    end
+
+    def destination_movements
+      stock_movements.joins(:stock_item)
+        .where('spree_stock_items.stock_location_id' => destination_location_id)
+    end
+
+    def transfer(source_location, destination_location, variants)
+      transaction do
+        variants.each_pair do |variant, quantity|
+          source_location.unstock(variant, quantity, self) if source_location
+          destination_location.restock(variant, quantity, self)
+
+          self.source_location = source_location
+          self.destination_location = destination_location
+          self.save!
+        end
+      end
+    end
+
+    def receive(destination_location, variants)
+      transfer(nil, destination_location, variants)
+    end
+  end
+end

data/app/models/spree/tax_category.rb

@@ -1,19 +1,19 @@
 module Spree
   class TaxCategory < ActiveRecord::Base
-    validates :name, :presence => true, :uniqueness => { :scope => :deleted_at }
+    validates :name, presence: true, uniqueness: { scope: :deleted_at }
 
-    has_many :tax_rates, :dependent => :destroy
+    has_many :tax_rates, dependent: :destroy
 
     attr_accessible :name, :description, :is_default
 
     before_save :set_default_category
 
-    default_scope where(:deleted_at => nil)
+    default_scope where(deleted_at: nil)
 
     def set_default_category
       #set existing default tax category to false if this one has been marked as default
 
-      if is_default && tax_category = self.class.where(:is_default => true).first
+      if is_default && tax_category = self.class.where(is_default: true).first
         tax_category.update_column(:is_default, false) unless tax_category == self
       end
     end

data/app/models/spree/tax_rate.rb

@@ -2,7 +2,7 @@ module Spree
   class DefaultTaxZoneValidator < ActiveModel::Validator
     def validate(record)
       if record.included_in_price
-        record.errors.add(:included_in_price, I18n.t(:included_price_validation)) unless Zone.default_tax
+        record.errors.add(:included_in_price, Spree.t(:included_price_validation)) unless Zone.default_tax
       end
     end
   end
@@ -10,17 +10,18 @@ end
 
 module Spree
   class TaxRate < ActiveRecord::Base
-    belongs_to :zone, :class_name => "Spree::Zone"
-    belongs_to :tax_category, :class_name => "Spree::TaxCategory"
+    include Spree::Core::CalculatedAdjustments
+    belongs_to :zone, class_name: "Spree::Zone"
+    belongs_to :tax_category, class_name: "Spree::TaxCategory"
 
-    validates :amount, :presence => true, :numericality => true
-    validates :tax_category_id, :presence => true
+    validates :amount, presence: true, numericality: true
+    validates :tax_category_id, presence: true
     validates_with DefaultTaxZoneValidator
 
-    calculated_adjustments
-    scope :by_zone, lambda { |zone| where(:zone_id => zone) }
+    scope :by_zone, ->(zone) { where(zone_id: zone) }
 
-    attr_accessible :amount, :tax_category_id, :calculator, :zone_id, :included_in_price, :name, :show_rate_in_label
+    attr_accessible :amount, :tax_category_id, :calculator, :zone_id, :name,
+                    :included_in_price, :show_rate_in_label
 
     # Gets the array of TaxRates appropriate for the specified order
     def self.match(order)
@@ -41,10 +42,10 @@ module Spree
     # It is needed for every price calculation (as all customer facing prices include vat )
     # The function returns the actual amount, which may be 0 in case of wrong setup, but is never nil
     def self.default
-      category = TaxCategory.includes(:tax_rates).where(:is_default => true).first
+      category = TaxCategory.includes(:tax_rates).where(is_default: true).first
       return 0 unless category
 
-      address ||= Address.new(:country_id => Spree::Config[:default_country_id])
+      address ||= Address.new(country_id: Spree::Config[:default_country_id])
       rate = category.tax_rates.detect { |rate| rate.zone.include? address }.try(:amount)
 
       rate || 0
@@ -58,12 +59,12 @@ module Spree
           order.line_items.each { |line_item| create_adjustment(label, line_item, line_item) }
         else
           amount = -1 * calculator.compute(order)
-          label = I18n.t(:refund) + label
-          order.adjustments.create({ :amount => amount,
-                                     :source => order,
-                                     :originator => self,
-                                     :locked => true,
-                                     :label => label }, :without_protection => true)
+          label = Spree.t(:refund) + label
+          order.adjustments.create({ amount: amount,
+                                     source: order,
+                                     originator: self,
+                                     state: "closed",
+                                     label: label }, without_protection: true)
         end
       else
         create_adjustment(label, order, order)

data/app/models/spree/taxon.rb

@@ -1,29 +1,29 @@
 module Spree
   class Taxon < ActiveRecord::Base
-    acts_as_nested_set :dependent => :destroy
+    acts_as_nested_set dependent: :destroy
 
-    belongs_to :taxonomy
-    has_many :classifications, :dependent => :delete_all
-    has_many :products, :through => :classifications
+    belongs_to :taxonomy, class_name: 'Spree::Taxonomy'
+    has_many :classifications, dependent: :delete_all
+    has_many :products, through: :classifications
 
     before_create :set_permalink
 
     attr_accessible :name, :parent_id, :position, :icon, :description, :permalink, :taxonomy_id,
                     :meta_description, :meta_keywords, :meta_title
 
-    validates :name, :presence => true
+    validates :name, presence: true
 
     has_attached_file :icon,
-      :styles => { :mini => '32x32>', :normal => '128x128>' },
-      :default_style => :mini,
-      :url => '/spree/taxons/:id/:style/:basename.:extension',
-      :path => ':rails_root/public/spree/taxons/:id/:style/:basename.:extension',
-      :default_url => '/assets/default_taxon.png'
+      styles: { mini: '32x32>', normal: '128x128>' },
+      default_style: :mini,
+      url: '/spree/taxons/:id/:style/:basename.:extension',
+      path: ':rails_root/public/spree/taxons/:id/:style/:basename.:extension',
+      default_url: '/assets/default_taxon.png'
 
     include Spree::Core::S3Support
     supports_s3 :icon
 
-    include ::Spree::ProductFilters  # for detailed defs of filters
+    include Spree::Core::ProductFilters  # for detailed defs of filters
 
     # indicate which filters should be used for a taxon
     # this method should be customized to your own site
@@ -32,8 +32,8 @@ module Spree
       # fs << ProductFilters.taxons_below(self)
       ## unless it's a root taxon? left open for demo purposes
 
-      fs << ProductFilters.price_filter if ProductFilters.respond_to?(:price_filter)
-      fs << ProductFilters.brand_filter if ProductFilters.respond_to?(:brand_filter)
+      fs << Spree::Core::ProductFilters.price_filter if Spree::Core::ProductFilters.respond_to?(:price_filter)
+      fs << Spree::Core::ProductFilters.brand_filter if Spree::Core::ProductFilters.respond_to?(:brand_filter)
       fs
     end
 
@@ -62,7 +62,6 @@ module Spree
 
     def active_products
       scope = products.active
-      scope = scope.on_hand unless Spree::Config[:show_zero_stock_products]
       scope
     end
 

data/app/models/spree/taxonomy.rb

@@ -1,23 +1,23 @@
 module Spree
   class Taxonomy < ActiveRecord::Base
-    validates :name, :presence => true
+    validates :name, presence: true
 
     attr_accessible :name
 
     has_many :taxons
-    has_one :root, :conditions => { :parent_id => nil }, :class_name => "Spree::Taxon",
-                   :dependent => :destroy
+    has_one :root, conditions: { parent_id: nil }, class_name: "Spree::Taxon",
+                   dependent: :destroy
 
     after_save :set_name
 
-    default_scope :order => "#{self.table_name}.position"
+    default_scope order: "#{self.table_name}.position"
 
     private
       def set_name
         if root
           root.update_column(:name, name)
         else
-          self.root = Taxon.create!({ :taxonomy_id => id, :name => name }, :without_protection => true)
+          self.root = Taxon.create!({ taxonomy_id: id, name: name }, without_protection: true)
         end
       end
 

data/app/models/spree/tokenized_permission.rb

@@ -1,6 +1,6 @@
 module Spree
   class TokenizedPermission < ActiveRecord::Base
-    belongs_to :permissable, :polymorphic => true
+    belongs_to :permissable, polymorphic: true
   end
 end
 

data/app/models/spree/tracker.rb

@@ -3,7 +3,7 @@ module Spree
     attr_accessible :analytics_id, :environment, :active
 
     def self.current
-      tracker = where(:active => true, :environment => Rails.env).first
+      tracker = where(active: true, environment: Rails.env).first
       tracker.analytics_id.present? ? tracker : nil if tracker
     end
   end

data/app/models/spree/variant.rb

@@ -1,67 +1,51 @@
 module Spree
   class Variant < ActiveRecord::Base
-    belongs_to :product, :touch => true
+    belongs_to :product, touch: true, class_name: 'Spree::Product'
 
     delegate_belongs_to :product, :name, :description, :permalink, :available_on,
                         :tax_category_id, :shipping_category_id, :meta_description,
-                        :meta_keywords, :tax_category
+                        :meta_keywords, :tax_category, :shipping_category
 
     attr_accessible :name, :presentation, :cost_price, :lock_version,
-                    :position, :on_demand, :on_hand, :option_value_ids,
+                    :position, :option_value_ids,
                     :product_id, :option_values_attributes, :price,
-                    :weight, :height, :width, :depth, :sku, :cost_currency,
-                    :options
+                    :weight, :height, :width, :depth, :sku, :cost_currency
 
     has_many :inventory_units
     has_many :line_items
-    has_and_belongs_to_many :option_values, :join_table => :spree_option_values_variants
-    has_many :images, :as => :viewable, :order => :position, :dependent => :destroy, :class_name => "Spree::Image"
+
+    has_many :stock_items, dependent: :destroy
+    has_many :stock_locations, through: :stock_items
+    has_many :stock_movements
+
+    has_and_belongs_to_many :option_values, join_table: :spree_option_values_variants
+    has_many :images, as: :viewable, order: :position, dependent: :destroy, class_name: "Spree::Image"
 
     has_one :default_price,
-      :class_name => 'Spree::Price',
-      :conditions => proc { { :currency => Spree::Config[:currency] } },
-      :dependent => :destroy
+      class_name: 'Spree::Price',
+      conditions: proc { { currency: Spree::Config[:currency] } },
+      dependent: :destroy
 
     delegate_belongs_to :default_price, :display_price, :display_amount, :price, :price=, :currency if Spree::Price.table_exists?
 
     has_many :prices,
-      :class_name => 'Spree::Price',
-      :dependent => :destroy
+      class_name: 'Spree::Price',
+      dependent: :destroy
 
     validate :check_price
-    validates :price, :numericality => { :greater_than_or_equal_to => 0 }, :presence => true, :if => proc { Spree::Config[:require_master_price] }
-    validates :cost_price, :numericality => { :greater_than_or_equal_to => 0, :allow_nil => true } if self.table_exists? && self.column_names.include?('cost_price')
-    validates :count_on_hand, :numericality => true
+    validates :price, numericality: { greater_than_or_equal_to: 0 }, presence: true, if: proc { Spree::Config[:require_master_price] }
+    validates :cost_price, numericality: { greater_than_or_equal_to: 0, allow_nil: true } if self.table_exists? && self.column_names.include?('cost_price')
 
     before_validation :set_cost_currency
-    after_save :process_backorders
     after_save :save_default_price
-    after_save :recalculate_product_on_hand
+    after_create :create_stock_items
     after_create :set_position
 
     # default variant scope only lists non-deleted variants
     scope :deleted, lambda { where('deleted_at IS NOT NULL') }
 
     def self.active(currency = nil)
-      joins(:prices).where(:deleted_at => nil).where('spree_prices.currency' => currency || Spree::Config[:currency]).where('spree_prices.amount IS NOT NULL')
-    end
-
-    # Returns number of inventory units for this variant (new records haven't been saved to database, yet)
-    def on_hand
-      if Spree::Config[:track_inventory_levels] && !self.on_demand
-        count_on_hand 
-      else
-        (1.0 / 0) # Infinity
-      end
-    end
-
-    # set actual attribute
-    def on_hand=(new_level)
-      if !Spree::Config[:track_inventory_levels]
-        raise 'Cannot set on_hand value when Spree::Config[:track_inventory_levels] is false'
-      else
-        self.count_on_hand = new_level unless self.on_demand
-      end
+      joins(:prices).where(deleted_at: nil).where('spree_prices.currency' => currency || Spree::Config[:currency]).where('spree_prices.amount IS NOT NULL')
     end
 
     def cost_price=(price)
@@ -73,21 +57,6 @@ module Spree
       inventory_units.with_state('backordered').size
     end
 
-    # returns true if at least one inventory unit of this variant is "on_hand"
-    def in_stock?
-      if Spree::Config[:track_inventory_levels] && !self.on_demand
-        on_hand > 0 
-      else
-        true
-      end
-    end
-    alias in_stock in_stock?
-
-    # returns true if this variant is allowed to be placed on a new order
-    def available?
-      Spree::Config[:track_inventory_levels] ? (Spree::Config[:allow_backorders] || in_stock? || self.on_demand) : true
-    end
-
     def options_text
       values = self.option_values.joins(:option_type).order("#{Spree::OptionType.table_name}.position asc")
 
@@ -95,7 +64,7 @@ module Spree
         "#{ov.option_type.presentation}: #{ov.presentation}"
       end
 
-      values.to_sentence({ :words_connector => ", ", :two_words_connector => ", " })
+      values.to_sentence({ words_connector: ", ", two_words_connector: ", " })
     end
 
     def gross_profit
@@ -109,17 +78,11 @@ module Spree
       deleted_at
     end
 
-    def options=(options = {})
-      options.each do |option|
-        set_option_value(option[:name], option[:value])
-      end
-    end
-
     def set_option_value(opt_name, opt_value)
       # no option values on master
       return if self.is_master
 
-      option_type = Spree::OptionType.where(:name => opt_name).first_or_initialize do |o|
+      option_type = Spree::OptionType.where(name: opt_name).first_or_initialize do |o|
         o.presentation = opt_name
         o.save!
       end
@@ -137,7 +100,7 @@ module Spree
         end
       end
 
-      option_value = Spree::OptionValue.where(:option_type_id => option_type.id, :name => opt_value).first_or_initialize do |o|
+      option_value = Spree::OptionValue.where(option_type_id: option_type.id, name: opt_value).first_or_initialize do |o|
         o.presentation = opt_value
         o.save!
       end
@@ -150,46 +113,23 @@ module Spree
       self.option_values.detect { |o| o.option_type.name == opt_name }.try(:presentation)
     end
 
-    def on_demand=(on_demand)
-      self[:on_demand] = on_demand
-      if on_demand
-        inventory_units.with_state('backordered').each(&:fill_backorder)
-      end
-    end
-
     def has_default_price?
       !self.default_price.nil?
     end
 
     def price_in(currency)
-      prices.select{ |price| price.currency == currency }.first || Spree::Price.new(:variant_id => self.id, :currency => currency)
+      prices.select{ |price| price.currency == currency }.first || Spree::Price.new(variant_id: self.id, currency: currency)
     end
 
     def amount_in(currency)
       price_in(currency).try(:amount)
     end
 
-    private
-
-      def process_backorders
-        if count_changes = changes['count_on_hand']
-          new_level = count_changes.last
-
-          if Spree::Config[:track_inventory_levels] && !self.on_demand
-            new_level = new_level.to_i
-
-            # update backorders if level is positive
-            if new_level > 0
-              # fill backordered orders before creating new units
-              backordered_units = inventory_units.with_state('backordered')
-              backordered_units.slice(0, new_level).each(&:fill_backorder)
-              new_level -= backordered_units.length
-            end
+    def name_and_sku
+      "#{name} - #{sku}"
+    end
 
-            self.update_attribute_without_callbacks(:count_on_hand, new_level)
-          end
-        end
-      end
+    private
 
       # Ensures a new variant takes the product master price when price is not supplied
       def check_price
@@ -215,10 +155,11 @@ module Spree
         price.to_d
       end
 
-      def recalculate_product_on_hand
-        on_hand = product.on_hand
-        if Spree::Config[:track_inventory_levels] && on_hand != (1.0 / 0) # Infinity
-          product.update_column(:count_on_hand, on_hand)
+      # Ensures a new variant takes the product master price when price is not supplied
+      def check_price
+        if price.nil?
+          raise 'Must supply price for variant or master.price for product.' if self == product.master
+          self.price = product.master.price
         end
       end
 
@@ -230,6 +171,12 @@ module Spree
         self.cost_currency = Spree::Config[:currency] if cost_currency.nil? || cost_currency.empty?
       end
 
+      def create_stock_items
+        Spree::StockLocation.all.each do |stock_location|
+          stock_location.stock_items.create!(variant: self)
+        end
+      end
+
       def set_position
         self.update_column(:position, product.variants.maximum(:position).to_i + 1)
       end