spree_core 2.2.14 → 2.3.0

data/app/models/spree/stock/package.rb

@@ -54,28 +54,6 @@ module Spree
         quantity == 0
       end
 
-      def flattened
-        flat = []
-        contents.each do |item|
-          item.quantity.times do
-            flat << ContentItem.new(item.line_item, item.variant, 1, item.state)
-          end
-        end
-        flat
-      end
-
-      def flattened=(flattened)
-        contents.clear
-        flattened.each do |item|
-          current_item = find_item(item.variant, item.state)
-          if current_item
-            current_item.quantity += 1
-          else
-            add(item.line_item, item.quantity, item.state)
-          end
-        end
-      end
-
       def currency
         #TODO calculate from first variant?
       end
@@ -98,7 +76,6 @@ module Spree
 
       def to_shipment
         shipment = Spree::Shipment.new
-        shipment.address = order.ship_address
         shipment.order = order
         shipment.stock_location = stock_location
         shipment.shipping_rates = shipping_rates

data/app/models/spree/stock/splitter/backordered.rb

@@ -1,7 +1,7 @@
 module Spree
   module Stock
     module Splitter
-      class Backordered < Base
+      class Backordered < Spree::Stock::Splitter::Base
 
         def split(packages)
           split_packages = []

data/app/models/spree/stock/splitter/shipping_category.rb

@@ -1,7 +1,7 @@
 module Spree
   module Stock
     module Splitter
-      class ShippingCategory < Base
+      class ShippingCategory < Spree::Stock::Splitter::Base
         def split(packages)
           split_packages = []
           packages.each do |package|

data/app/models/spree/stock/splitter/weight.rb

@@ -1,7 +1,7 @@
 module Spree
   module Stock
     module Splitter
-      class Weight < Base
+      class Weight < Spree::Stock::Splitter::Base
         attr_reader :packer, :next_splitter
 
         cattr_accessor :threshold do

data/app/models/spree/stock_item.rb

@@ -1,22 +1,19 @@
 module Spree
-  class StockItem < ActiveRecord::Base
+  class StockItem < Spree::Base
     acts_as_paranoid
 
-    belongs_to :stock_location, class_name: 'Spree::StockLocation', inverse_of: :stock_items
+    belongs_to :stock_location, class_name: 'Spree::StockLocation'
     belongs_to :variant, class_name: 'Spree::Variant', inverse_of: :stock_items
     has_many :stock_movements, inverse_of: :stock_item
 
     validates_presence_of :stock_location, :variant
     validates_uniqueness_of :variant_id, scope: [:stock_location_id, :deleted_at]
-    validates :count_on_hand, numericality: { greater_than_or_equal_to: 0 }, if: :verify_count_on_hand?
 
     delegate :weight, :should_track_inventory?, to: :variant
 
-    after_save :conditional_variant_touch, if: :changed?
+    after_save :conditional_variant_touch
     after_touch { variant.touch }
 
-    self.whitelisted_ransackable_attributes = ['count_on_hand', 'stock_location_id']
-
     def backordered_inventory_units
       Spree::InventoryUnit.backordered_for_stock_item(self)
     end
@@ -54,11 +51,11 @@ module Spree
       Spree::Variant.unscoped { super }
     end
 
-    private
-      def verify_count_on_hand?
-        count_on_hand_changed? && !backorderable? && (count_on_hand < count_on_hand_was) && (count_on_hand < 0)
-      end
+    def reduce_count_on_hand_to_zero
+      self.set_count_on_hand(0) if count_on_hand > 0
+    end
 
+    private
       def count_on_hand=(value)
         write_attribute(:count_on_hand, value)
       end

data/app/models/spree/stock_location.rb

@@ -1,7 +1,7 @@
 module Spree
-  class StockLocation < ActiveRecord::Base
+  class StockLocation < Spree::Base
     has_many :shipments
-    has_many :stock_items, dependent: :delete_all, inverse_of: :stock_location
+    has_many :stock_items, dependent: :delete_all
     has_many :stock_movements, through: :stock_items
 
     belongs_to :state, class_name: 'Spree::State'
@@ -13,10 +13,6 @@ module Spree
 
     after_create :create_stock_items, :if => "self.propagate_all_variants?"
 
-    def state_text
-      state.try(:abbr) || state.try(:name) || state_name
-    end
-    
     # Wrapper for creating a new stock item respecting the backorderable config
     def propagate_variant(variant)
       self.stock_items.create!(variant: variant, backorderable: self.backorderable_default)

data/app/models/spree/stock_movement.rb

@@ -1,5 +1,5 @@
 module Spree
-  class StockMovement < ActiveRecord::Base
+  class StockMovement < Spree::Base
     belongs_to :stock_item, class_name: 'Spree::StockItem', inverse_of: :stock_movements
     belongs_to :originator, polymorphic: true
 
@@ -10,8 +10,6 @@ module Spree
 
     scope :recent, -> { order('created_at DESC') }
 
-    self.whitelisted_ransackable_attributes = ['quantity']
-
     def readonly?
       !new_record?
     end

data/app/models/spree/stock_transfer.rb

@@ -1,5 +1,5 @@
 module Spree
-  class StockTransfer < ActiveRecord::Base
+  class StockTransfer < Spree::Base
     has_many :stock_movements, :as => :originator
 
     belongs_to :source_location, :class_name => 'StockLocation'
@@ -7,8 +7,6 @@ module Spree
 
     make_permalink field: :number, prefix: 'T'
 
-    self.whitelisted_ransackable_attributes = %w[reference source_location_id destination_location_id closed_at created_at number]
-
     def to_param
       number
     end

data/app/models/spree/store.rb

@@ -0,0 +1,33 @@
+module Spree
+  class Store < Spree::Base
+
+    validates :code, presence: true, uniqueness: true
+    validates :name, presence: true
+    validates :url, presence: true
+    validates :mail_from_address, presence: true
+
+    before_create :ensure_default_exists_and_is_unique
+
+    scope :by_url, lambda { |url| where("url like ?", "%#{url}%") }
+
+    def self.current(domain = nil)
+      current_store = domain ? Store.by_url(domain).first : nil
+      current_store || Store.default
+    end
+
+    def self.default
+      where(default: true).first || new
+    end
+
+    private
+
+    def ensure_default_exists_and_is_unique
+      if default
+        Store.update_all(default: false)
+      else
+        self.default = true
+      end
+    end
+
+  end
+end

data/app/models/spree/tax_category.rb

@@ -1,9 +1,9 @@
 module Spree
-  class TaxCategory < ActiveRecord::Base
+  class TaxCategory < Spree::Base
     acts_as_paranoid
     validates :name, presence: true, uniqueness: { scope: :deleted_at }
 
-    has_many :tax_rates, dependent: :destroy, inverse_of: :tax_category
+    has_many :tax_rates, dependent: :destroy
 
     before_save :set_default_category
 

data/app/models/spree/tax_rate.rb

@@ -9,19 +9,13 @@ module Spree
 end
 
 module Spree
-  class TaxRate < ActiveRecord::Base
+  class TaxRate < Spree::Base
     acts_as_paranoid
-
-    # Need to deal with adjustments before calculator is destroyed.
-    before_destroy :deals_with_adjustments_for_deleted_source
-
     include Spree::Core::CalculatedAdjustments
-    include Spree::Core::AdjustmentSource
-
-    belongs_to :zone, class_name: "Spree::Zone", inverse_of: :tax_rates
-    belongs_to :tax_category, class_name: "Spree::TaxCategory", inverse_of: :tax_rates
+    belongs_to :zone, class_name: "Spree::Zone"
+    belongs_to :tax_category, class_name: "Spree::TaxCategory"
 
-    has_many :adjustments, as: :source
+    has_many :adjustments, as: :source, dependent: :destroy
 
     validates :amount, presence: true, numericality: true
     validates :tax_category_id, presence: true
@@ -30,13 +24,12 @@ module Spree
     scope :by_zone, ->(zone) { where(zone_id: zone) }
 
     # Gets the array of TaxRates appropriate for the specified order
-    def self.match(order)
-      order_zone = order.tax_zone
-      return [] unless order_zone
+    def self.match(order_tax_zone)
+      return [] unless order_tax_zone
       rates = includes(zone: { zone_members: :zoneable }).load.select do |rate|
         # Why "potentially"?
         # Go see the documentation for that method.
-        rate.potentially_applicable?(order)
+        rate.potentially_applicable?(order_tax_zone)
       end
 
       # Imagine with me this scenario:
@@ -75,41 +68,20 @@ module Spree
     end
 
     # This method is best described by the documentation on #potentially_applicable?
-    def self.adjust(order, items)
-      rates = self.match(order)
+    def self.adjust(order_tax_zone, items)
+      rates = self.match(order_tax_zone)
       tax_categories = rates.map(&:tax_category)
-      relevant_items, non_relevant_items = items.partition { |item| tax_categories.include?(item.tax_category) }
+      relevant_items = items.select { |item| tax_categories.include?(item.tax_category) }
       relevant_items.each do |item|
         item.adjustments.tax.delete_all
         relevant_rates = rates.select { |rate| rate.tax_category == item.tax_category }
         store_pre_tax_amount(item, relevant_rates)
         relevant_rates.each do |rate|
-          rate.adjust(order, item)
-        end
-      end
-      non_relevant_items.each do |item|
-        if item.adjustments.tax.present?
-          item.adjustments.tax.delete_all
-          item.update_column(:pre_tax_amount, nil)
-          Spree::ItemAdjustments.new(item).update
+          rate.adjust(order_tax_zone, item)
         end
       end
     end
 
-    # For Vat the default rate is the rate that is configured for the default category
-    # 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
-      return 0 unless category
-
-      address ||= Address.new(country_id: Spree::Config[:default_country_id])
-      rate = category.tax_rates.detect { |rate| rate.zone.include? address }.try(:amount)
-
-      rate || 0
-    end
-
-
     # Tax rates can *potentially* be applicable to an order.
     # We do not know if they are/aren't until we attempt to apply these rates to
     # the items contained within the Order itself.
@@ -150,21 +122,21 @@ module Spree
     # Under no circumstances should negative adjustments be applied for the Spanish tax rates.
     #
     # Those rates should never come into play at all and only the French rates should apply.
-    def potentially_applicable?(order)
+    def potentially_applicable?(order_tax_zone)
       # If the rate's zone matches the order's tax zone, then it's applicable.
-      self.zone == order.tax_zone ||
+      self.zone == order_tax_zone ||
       # If the rate's zone *contains* the order's tax zone, then it's applicable.
-      self.zone.contains?(order.tax_zone) ||
+      self.zone.contains?(order_tax_zone) ||
       # 1) The rate's zone is the default zone, then it's always applicable.
       (self.included_in_price? && self.zone.default_tax)
     end
 
     # Creates necessary tax adjustments for the order.
-    def adjust(order, item)
+    def adjust(order_tax_zone, item)
       amount = compute_amount(item)
       return if amount == 0
 
-      included = included_in_price && default_zone_or_zone_match?(item)
+      included = included_in_price && default_zone_or_zone_match?(order_tax_zone)
 
       if amount < 0
         label = Spree.t(:refund) + ' ' + create_label
@@ -173,7 +145,7 @@ module Spree
       self.adjustments.create!({
         :adjustable => item,
         :amount => amount,
-        :order => order,
+        :order_id => item.order_id,
         :label => label || create_label,
         :included => included
       })
@@ -182,7 +154,7 @@ module Spree
     # This method is used by Adjustment#update to recalculate the cost.
     def compute_amount(item)
       if included_in_price
-        if default_zone_or_zone_match?(item)
+        if default_zone_or_zone_match?(item.order.tax_zone)
           calculator.compute(item)
         else
           # In this case, it's a refund.
@@ -193,9 +165,9 @@ module Spree
       end
     end
 
-    def default_zone_or_zone_match?(item)
-      Zone.default_tax.contains?(item.order.tax_zone) ||
-      item.order.tax_zone == self.zone
+    def default_zone_or_zone_match?(order_tax_zone)
+      default_tax = Zone.default_tax
+      (default_tax && default_tax.contains?(order_tax_zone)) || order_tax_zone == self.zone
     end
 
     private
@@ -204,9 +176,6 @@ module Spree
         label = ""
         label << (name.present? ? name : tax_category.name) + " "
         label << (show_rate_in_label? ? "#{amount * 100}%" : "")
-        label << " (#{Spree.t(:included_in_price)})" if included_in_price?
-        label
       end
-
   end
 end

data/app/models/spree/taxon.rb

@@ -1,8 +1,8 @@
 module Spree
-  class Taxon < ActiveRecord::Base
+  class Taxon < Spree::Base
     acts_as_nested_set dependent: :destroy
 
-    belongs_to :taxonomy, class_name: 'Spree::Taxonomy', touch: true, inverse_of: :taxons
+    belongs_to :taxonomy, class_name: 'Spree::Taxonomy', inverse_of: :taxons
     has_many :classifications, -> { order(:position) }, dependent: :delete_all, inverse_of: :taxon
     has_many :products, through: :classifications
 
@@ -10,7 +10,7 @@ module Spree
 
     validates :name, presence: true
 
-    after_touch :touch_parent
+    after_touch :touch_ancestors_and_taxonomy
 
     has_attached_file :icon,
       styles: { mini: '32x32>', normal: '128x128>' },
@@ -20,9 +20,7 @@ module Spree
       default_url: '/assets/default_taxon.png'
 
     validates_attachment :icon,
-      content_type: { content_type: ["image/jpg", "image/jpeg", "image/png", "image/gif"] }
-
-    include Spree::Core::ProductFilters  # for detailed defs of filters
+      content_type: { content_type: ["image/jpg", "image/jpeg", "image/png"] }
 
     # indicate which filters should be used for a taxon
     # this method should be customized to your own site
@@ -83,8 +81,11 @@ module Spree
 
     private
 
-    def touch_parent
-      parent.touch if parent
+    def touch_ancestors_and_taxonomy
+      # Touches all ancestors at once to avoid recursive taxonomy touch, and reduce queries.
+      self.class.where(id: ancestors.pluck(:id)).update_all(updated_at: Time.now)
+      # Have taxonomy touch happen in #touch_ancestors_and_taxonomy rather than association option in order for imports to override.
+      taxonomy.touch
     end
   end
 end

data/app/models/spree/taxonomy.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Taxonomy < ActiveRecord::Base
+  class Taxonomy < Spree::Base
     validates :name, presence: true
 
     has_many :taxons, inverse_of: :taxonomy

data/app/models/spree/tracker.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Tracker < ActiveRecord::Base
+  class Tracker < Spree::Base
     def self.current
       tracker = where(active: true, environment: Rails.env).first
       tracker.analytics_id.present? ? tracker : nil if tracker

data/app/models/spree/variant.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Variant < ActiveRecord::Base
+  class Variant < Spree::Base
     acts_as_paranoid
 
     belongs_to :product, touch: true, class_name: 'Spree::Product', inverse_of: :variants
@@ -9,12 +9,12 @@ module Spree
                         :shipping_category_id, :meta_description, :meta_keywords,
                         :shipping_category
 
-    has_many :inventory_units, inverse_of: :variant
+    has_many :inventory_units
     has_many :line_items, inverse_of: :variant
 
     has_many :stock_items, dependent: :destroy, inverse_of: :variant
     has_many :stock_locations, through: :stock_items
-    has_many :stock_movements
+    has_many :stock_movements, through: :stock_items
 
     has_and_belongs_to_many :option_values, join_table: :spree_option_values_variants
     has_many :images, -> { order(:position) }, as: :viewable, dependent: :destroy, class_name: "Spree::Image"
@@ -40,15 +40,10 @@ module Spree
     after_save :save_default_price
     after_create :create_stock_items
     after_create :set_position
+    after_create :set_master_out_of_stock, :unless => :is_master?
 
     after_touch :clear_in_stock_cache
 
-    # default variant scope only lists non-deleted variants
-    scope :deleted, lambda { where.not(deleted_at: nil) }
-
-    self.whitelisted_ransackable_associations = %w[option_values product prices default_price]
-    self.whitelisted_ransackable_attributes = %w[weight sku]
-
     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
@@ -75,7 +70,7 @@ module Spree
         a.option_type.position <=> b.option_type.position
       end
 
-      values.map! do |ov|
+      values.to_a.map! do |ov|
         "#{ov.option_type.presentation}: #{ov.presentation}"
       end
 
@@ -193,6 +188,13 @@ module Spree
         price.to_d
       end
 
+      def set_master_out_of_stock
+        if product.master && product.master.in_stock?
+          product.master.stock_items.update_all(:backorderable => false)
+          product.master.stock_items.each { |item| item.reduce_count_on_hand_to_zero }
+        end
+      end
+
       # Ensures a new variant takes the product master price when price is not supplied
       def check_price
         if price.nil? && Spree::Config[:require_master_price]
@@ -205,12 +207,8 @@ module Spree
         end
       end
 
-      def default_price_changed?
-        default_price && (default_price.changed? || default_price.new_record?)
-      end
-
       def save_default_price
-        default_price.save if default_price_changed?
+        default_price.save if default_price && (default_price.changed? || default_price.new_record?)
       end
 
       def set_cost_currency