spree_core 3.0.9 → 3.2.0

data/app/models/spree/store_credit_event.rb

@@ -0,0 +1,38 @@
+module Spree
+  class StoreCreditEvent < Spree::Base
+    acts_as_paranoid
+
+    belongs_to :store_credit
+    belongs_to :originator, polymorphic: true
+
+    scope :exposed_events, -> { where.not(action: [Spree::StoreCredit::ELIGIBLE_ACTION, Spree::StoreCredit::AUTHORIZE_ACTION]) }
+    scope :reverse_chronological, -> { order(created_at: :desc) }
+
+    delegate :currency, to: :store_credit
+
+    def display_amount
+      Spree::Money.new(amount, currency: currency)
+    end
+
+    def display_user_total_amount
+      Spree::Money.new(user_total_amount, currency: currency)
+    end
+
+    def display_action
+      case action
+      when Spree::StoreCredit::CAPTURE_ACTION
+        Spree.t('store_credit.captured')
+      when Spree::StoreCredit::AUTHORIZE_ACTION
+        Spree.t('store_credit.authorized')
+      when Spree::StoreCredit::ALLOCATION_ACTION
+        Spree.t('store_credit.allocated')
+      when Spree::StoreCredit::VOID_ACTION, Spree::StoreCredit::CREDIT_ACTION
+        Spree.t('store_credit.credit')
+      end
+    end
+
+    def order
+      Spree::Payment.find_by_response_code(authorization_code).try(:order)
+    end
+  end
+end

data/app/models/spree/store_credit_type.rb

@@ -0,0 +1,6 @@
+module Spree
+  class StoreCreditType < Spree::Base
+    DEFAULT_TYPE_NAME = 'Expiring'.freeze
+    has_many :store_credits, class_name: 'Spree::StoreCredit', foreign_key: 'type_id'
+  end
+end

data/app/models/spree/tag.rb

@@ -0,0 +1,4 @@
+module Spree
+  class Tag < ActsAsTaggableOn::Tag
+  end
+end

data/app/models/spree/tax_category.rb

@@ -1,7 +1,7 @@
 module Spree
   class TaxCategory < Spree::Base
     acts_as_paranoid
-    validates :name, presence: true, uniqueness: { scope: :deleted_at, allow_blank: true }
+    validates :name, presence: true, uniqueness: { case_sensitive: false, scope: :deleted_at, allow_blank: true }
 
     has_many :tax_rates, dependent: :destroy, inverse_of: :tax_category
 
@@ -10,13 +10,8 @@ module Spree
     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
-        unless tax_category == self
-          tax_category.update_columns(
-            is_default: false,
-            updated_at: Time.now,
-          )
-        end
+      if is_default && tax_category = self.class.where(is_default: true).where.not(id: id).first
+        tax_category.update_columns(is_default: false, updated_at: Time.current)
       end
     end
   end

data/app/models/spree/tax_rate.rb

@@ -1,13 +1,3 @@
-module Spree
-  class DefaultTaxZoneValidator < ActiveModel::Validator
-    def validate(record)
-      if record.included_in_price
-        record.errors.add(:included_in_price, Spree.t(:included_price_validation)) unless Zone.default_tax
-      end
-    end
-  end
-end
-
 module Spree
   class TaxRate < Spree::Base
     acts_as_paranoid
@@ -15,50 +5,32 @@ module Spree
     include Spree::CalculatedAdjustments
     include Spree::AdjustmentSource
 
-    belongs_to :zone, class_name: "Spree::Zone", inverse_of: :tax_rates
-    belongs_to :tax_category, class_name: "Spree::TaxCategory", inverse_of: :tax_rates
-
-    validates :amount, presence: true, numericality: true
-    validates :tax_category_id, presence: true
-    validates_with DefaultTaxZoneValidator
-
-    scope :by_zone, ->(zone) { where(zone_id: zone) }
+    with_options inverse_of: :tax_rates do
+      belongs_to :zone, class_name: "Spree::Zone"
+      belongs_to :tax_category,
+                 class_name: "Spree::TaxCategory"
+    end
 
-    def self.potential_rates_for_zone(zone)
-      select("spree_tax_rates.*, spree_zones.default_tax").
-        joins(:zone).
-        merge(Spree::Zone.potential_matching_zones(zone)).
-        order("spree_zones.default_tax DESC")
+    with_options presence: true do
+      validates :amount, numericality: { allow_nil: true }
+      validates :tax_category
     end
 
-    # Gets the array of TaxRates appropriate for the specified order
+    scope :by_zone, -> (zone) { where(zone_id: zone.id) }
+    scope :potential_rates_for_zone,
+          -> (zone) do
+            where(zone_id: Spree::Zone.potential_matching_zones(zone).pluck(:id))
+          end
+    scope :for_default_zone,
+          -> { potential_rates_for_zone(Spree::Zone.default_tax) }
+    scope :for_tax_category,
+          -> (category) { where(tax_category_id: category.try(:id)) }
+    scope :included_in_price, -> { where(included_in_price: true) }
+
+    # Gets the array of TaxRates appropriate for the specified tax zone
     def self.match(order_tax_zone)
       return [] unless order_tax_zone
-
-      potential_rates = potential_rates_for_zone(order_tax_zone)
-      rates = potential_rates.includes(zone: { zone_members: :zoneable }).load.select do |rate|
-        # Why "potentially"?
-        # Go see the documentation for that method.
-        rate.potentially_applicable?(order_tax_zone)
-      end
-
-      # Imagine with me this scenario:
-      # You are living in Spain and you have a store which ships to France.
-      # Spain is therefore your default tax rate.
-      # When you ship to Spain, you want the Spanish rate to apply.
-      # When you ship to France, you want the French rate to apply.
-      #
-      # Normally, Spree would notice that you have two potentially applicable
-      # tax rates for one particular item.
-      # When you ship to Spain, only the Spanish one will apply.
-      # When you ship to France, you'll see a Spanish refund AND a French tax.
-      # This little bit of code at the end stops the Spanish refund from appearing.
-      #
-      # For further discussion, see #4397 and #4327.
-      rates.delete_if do |rate|
-        rate.included_in_price? &&
-        (rates - [rate]).map(&:tax_category).include?(rate.tax_category)
-      end
+      potential_rates_for_zone(order_tax_zone)
     end
 
     # Pre-tax amounts must be stored so that we can calculate
@@ -66,9 +38,9 @@ module Spree
     # https://github.com/spree/spree/issues/4318#issuecomment-34723428
     def self.store_pre_tax_amount(item, rates)
       pre_tax_amount = case item
-        when Spree::LineItem then item.discounted_amount
-        when Spree::Shipment then item.discounted_cost
-        end
+                       when Spree::LineItem then item.discounted_amount
+                       when Spree::Shipment then item.discounted_cost
+                       end
 
       included_rates = rates.select(&:included_in_price)
       if included_rates.any?
@@ -78,99 +50,67 @@ module Spree
       item.update_column(:pre_tax_amount, pre_tax_amount)
     end
 
-    # This method is best described by the documentation on #potentially_applicable?
+    # Deletes all tax adjustments, then applies all applicable rates
+    # to relevant items.
     def self.adjust(order, items)
       rates = match(order.tax_zone)
       tax_categories = rates.map(&:tax_category)
-      relevant_items, non_relevant_items = items.partition { |item| tax_categories.include?(item.tax_category) }
-      Spree::Adjustment.where(adjustable: relevant_items).tax.destroy_all # using destroy_all to ensure adjustment destroy callback fires.
+
+      # using destroy_all to ensure adjustment destroy callback fires.
+      Spree::Adjustment.where(adjustable: items).tax.destroy_all
+
+      relevant_items = items.select do |item|
+        tax_categories.include?(item.tax_category)
+      end
+
       relevant_items.each do |item|
-        relevant_rates = rates.select { |rate| rate.tax_category == item.tax_category }
+        relevant_rates = rates.select do |rate|
+          rate.tax_category == item.tax_category
+        end
         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.destroy_all # using destroy_all to ensure adjustment destroy callback fires.
-          item.update_columns pre_tax_amount: 0
-        end
+
+      # updates pre_tax for items without any tax rates
+      remaining_items = items - relevant_items
+      remaining_items.each do |item|
+        store_pre_tax_amount(item, [])
       end
     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.
-    # For instance, if a rate passes the criteria outlined in this method,
-    # but then has a tax category that doesn't match against any of the line items
-    # inside of the order, then that tax rate will not be applicable to anything.
-    # For instance:
-    #
-    # Zones:
-    #   - Spain (default tax zone)
-    #   - France
-    #
-    # Tax rates: (note: amounts below do not actually reflect real VAT rates)
-    #   21% inclusive - "Clothing" - Spain
-    #   18% inclusive - "Clothing" - France
-    #   10% inclusive - "Food" - Spain
-    #   8% inclusive - "Food" - France
-    #   5% inclusive - "Hotels" - Spain
-    #   2% inclusive - "Hotels" - France
-    #
-    # Order has:
-    #   Line Item #1 - Tax Category: Clothing
-    #   Line Item #2 - Tax Category: Food
-    #
-    # Tax rates that should be selected:
-    #
-    #  21% inclusive - "Clothing" - Spain
-    #  10% inclusive - "Food" - Spain
-    #
-    # If the order's address changes to one in France, then the tax will be recalculated:
-    #
-    #  18% inclusive - "Clothing" - France
-    #  8% inclusive - "Food" - France
-    #
-    # Note here that the "Hotels" tax rates will not be used at all.
-    # This is because there are no items which have the tax category of "Hotels".
-    #
-    # 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_tax_zone)
-      # If the rate's zone matches the order's tax zone, then it's applicable.
-      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) ||
-      # 1) The rate's zone is the default zone, then it's always applicable.
-      (self.included_in_price? && self.zone.default_tax)
+    def self.included_tax_amount_for(options)
+      return 0 unless options[:tax_zone] && options[:tax_category]
+      potential_rates_for_zone(options[:tax_zone]).
+        included_in_price.
+        for_tax_category(options[:tax_category]).
+        pluck(:amount).sum
     end
 
     def adjust(order, item)
-      included = included_in_price && default_zone_or_zone_match?(order)
-      create_adjustment(order, item, included)
+      create_adjustment(order, item, included_in_price)
     end
 
     def compute_amount(item)
-      refund = included_in_price && !default_zone_or_zone_match?(item.order)
-      compute(item) * (refund ? -1 : 1)
+      compute(item)
     end
 
     private
 
-    def default_zone_or_zone_match?(order)
-      Zone.default_tax.try(:contains?, order.tax_zone) || order.tax_zone == zone
+    def label
+      Spree.t included_in_price? ? :including_tax : :excluding_tax,
+              scope: "adjustment_labels.tax_rates",
+              name: name.presence || tax_category.name,
+              amount: amount_for_label
     end
 
-    def label(adjustment_amount)
-      label = ""
-      label << Spree.t(:refund) << ' ' if adjustment_amount < 0
-      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
+    def amount_for_label
+      return "" unless show_rate_in_label?
+      " " + ActiveSupport::NumberHelper::NumberToPercentageConverter.convert(
+        amount * 100,
+        locale: I18n.locale
+      )
     end
   end
 end

data/app/models/spree/taxon.rb

@@ -4,7 +4,7 @@ require 'stringex'
 module Spree
   class Taxon < Spree::Base
     extend FriendlyId
-    friendly_id :permalink, slug_column: :permalink, use: :slugged
+    friendly_id :permalink, slug_column: :permalink, use: :history
     before_create :set_permalink
 
     acts_as_nested_set dependent: :destroy
@@ -13,12 +13,18 @@ module Spree
     has_many :classifications, -> { order(:position) }, dependent: :delete_all, inverse_of: :taxon
     has_many :products, through: :classifications
 
-    has_and_belongs_to_many :prototypes, join_table: :spree_taxons_prototypes
+    has_many :prototype_taxons, class_name: 'Spree::PrototypeTaxon', dependent: :destroy
+    has_many :prototypes, through: :prototype_taxons, class_name: 'Spree::Prototype'
+
+    has_many :promotion_rule_taxons, class_name: 'Spree::PromotionRuleTaxon', dependent: :destroy
+    has_many :promotion_rules, through: :promotion_rule_taxons, class_name: 'Spree::PromotionRule'
 
     validates :name, presence: true
-    validates :meta_keywords, length: { maximum: 255 }
-    validates :meta_description, length: { maximum: 255 }
-    validates :meta_title, length: { maximum: 255 }
+    with_options length: { maximum: 255 }, allow_blank: true do
+      validates :meta_keywords
+      validates :meta_description
+      validates :meta_title
+    end
 
     after_save :touch_ancestors_and_taxonomy
     after_touch :touch_ancestors_and_taxonomy
@@ -88,7 +94,7 @@ module Spree
 
     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)
+      ancestors.update_all(updated_at: Time.current)
       # Have taxonomy touch happen in #touch_ancestors_and_taxonomy rather than association option in order for imports to override.
       taxonomy.try!(:touch)
     end

data/app/models/spree/tracker.rb

@@ -1,8 +1,19 @@
 module Spree
   class Tracker < Spree::Base
+    after_commit :clear_cache
+
+    validates :analytics_id, presence: true, uniqueness: { allow_blank: true }
+
     def self.current
-      tracker = where(active: true).first
+      tracker = Rails.cache.fetch("current_tracker") do
+        where(active: true).first
+      end
       tracker.analytics_id.present? ? tracker : nil if tracker
     end
+
+
+    def clear_cache
+      Rails.cache.delete("current_tracker")
+    end
   end
 end

data/app/models/spree/validations/db_maximum_length_validator.rb

@@ -11,9 +11,10 @@ module Spree
       end
 
       def validate(record)
+        warn "`Spree::Validations::DbMaximumLengthValidator` is deprecated. Use `DbMaximumLengthValidator` instead."
         limit = record.class.columns_hash[@field].limit
         value = record[@field.to_sym]
-        if value && limit && value.to_s.length > limit 
+        if value && limit && value.to_s.length > limit
           record.errors.add(@field.to_sym, :too_long, count: limit)
         end
       end

data/app/models/spree/variant.rb

@@ -12,15 +12,25 @@ module Spree
                         :shipping_category_id, :meta_description, :meta_keywords,
                         :shipping_category
 
-    has_many :inventory_units, inverse_of: :variant
-    has_many :line_items, inverse_of: :variant
+    # we need to have this callback before any dependent: :destroy associations
+    # https://github.com/rails/rails/issues/3458
+    before_destroy :ensure_no_line_items
+
+    with_options inverse_of: :variant do
+      has_many :inventory_units
+      has_many :line_items
+      has_many :stock_items, dependent: :destroy
+    end
+
     has_many :orders, through: :line_items
+    with_options through: :stock_items do
+      has_many :stock_locations
+      has_many :stock_movements
+    end
 
-    has_many :stock_items, dependent: :destroy, inverse_of: :variant
-    has_many :stock_locations, through: :stock_items
-    has_many :stock_movements, through: :stock_items
+    has_many :option_value_variants, class_name: 'Spree::OptionValueVariant'
+    has_many :option_values, through: :option_value_variants, class_name: 'Spree::OptionValue'
 
-    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"
 
     has_many :prices,
@@ -32,9 +42,13 @@ module Spree
 
     validate :check_price
 
-    validates :cost_price, numericality: { greater_than_or_equal_to: 0, allow_nil: true }
-    validates :price,      numericality: { greater_than_or_equal_to: 0, allow_nil: true }
-    validates_uniqueness_of :sku, allow_blank: true, conditions: -> { where(deleted_at: nil) }
+    validates :option_values, presence: true, unless: :is_master?
+
+    with_options numericality: { greater_than_or_equal_to: 0, allow_nil: true } do
+      validates :cost_price
+      validates :price
+    end
+    validates :sku, uniqueness: { conditions: -> { where(deleted_at: nil) } }, allow_blank: true
 
     after_create :create_stock_items
     after_create :set_master_out_of_stock, unless: :is_master?
@@ -43,6 +57,26 @@ module Spree
 
     scope :in_stock, -> { joins(:stock_items).where('count_on_hand > ? OR track_inventory = ?', 0, false) }
 
+    scope :not_discontinued, -> do
+      where(
+        arel_table[:discontinue_on].eq(nil).or(
+          arel_table[:discontinue_on].gteq(Time.current)
+        )
+      )
+    end
+
+    scope :not_deleted, -> { where("#{Variant.quoted_table_name}.deleted_at IS NULL") }
+
+    scope :for_currency_and_available_price_amount, -> (currency) do
+      currency ||= Spree::Config[:currency]
+      joins(:prices).where("spree_prices.currency = ?", currency).where("spree_prices.amount IS NOT NULL").distinct
+    end
+
+    scope :active, -> (currency = nil) do
+      not_discontinued.not_deleted.
+        for_currency_and_available_price_amount(currency)
+    end
+
     LOCALIZED_NUMBERS = %w(cost_price weight depth width height)
 
     LOCALIZED_NUMBERS.each do |m|
@@ -54,8 +88,8 @@ module Spree
     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')
+    def available?
+      !discontinued? && product.available?
     end
 
     def self.having_orders
@@ -75,10 +109,6 @@ module Spree
       inventory_units.with_state('backordered').size
     end
 
-    def is_backorderable?
-      Spree::Stock::Quantifier.new(self).backorderable?
-    end
-
     def options_text
       values = self.option_values.sort do |a, b|
         a.option_type.position <=> b.option_type.position
@@ -155,7 +185,7 @@ module Spree
     end
 
     def price_in(currency)
-      prices.detect { |price| price.currency == currency } || Spree::Price.new(variant_id: id, currency: currency)
+      prices.detect { |price| price.currency == currency } || prices.build(currency: currency)
     end
 
     def amount_in(currency)
@@ -202,13 +232,9 @@ module Spree
       end
     end
 
-    def can_supply?(quantity=1)
-      Spree::Stock::Quantifier.new(self).can_supply?(quantity)
-    end
+    delegate :total_on_hand, :can_supply?, :backorderable?, to: :quantifier
 
-    def total_on_hand
-      Spree::Stock::Quantifier.new(self).total_on_hand
-    end
+    alias is_backorderable? backorderable?
 
     # Shortcut method to determine if inventory tracking is enabled for this variant
     # This considers both variant tracking flag and site-wide inventory tracking settings
@@ -228,43 +254,62 @@ module Spree
       (width || 0) + (height || 0) + (depth || 0)
     end
 
+    def discontinue!
+      update_attribute(:discontinue_on, Time.current)
+    end
+
+    def discontinued?
+      !!discontinue_on && discontinue_on <= Time.current
+    end
+
     private
 
-      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
+    def ensure_no_line_items
+      if line_items.any?
+        errors.add(:base, Spree.t(:cannot_destroy_if_attached_to_line_items))
+        throw(:abort)
       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]
-          raise 'No master variant found to infer price' unless (product && product.master)
-          raise 'Must supply price for variant or master.price for product.' if self == product.master
-          self.price = product.master.price
-        end
-        if currency.nil?
-          self.currency = Spree::Config[:currency]
-        end
-      end
+    def quantifier
+      Spree::Stock::Quantifier.new(self)
+    end
 
-      def set_cost_currency
-        self.cost_currency = Spree::Config[:currency] if cost_currency.nil? || cost_currency.empty?
+    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(&:reduce_count_on_hand_to_zero)
       end
+    end
 
-      def create_stock_items
-        StockLocation.where(propagate_all_variants: true).each do |stock_location|
-          stock_location.propagate_variant(self)
-        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]
+        raise 'No master variant found to infer price' unless product && product.master
+        raise 'Must supply price for variant or master.price for product.' if self == product.master
+        self.price = product.master.price
       end
-
-      def in_stock_cache_key
-        "variant-#{id}-in_stock"
+      if price.present? && currency.nil?
+        self.currency = Spree::Config[:currency]
       end
+    end
 
-      def clear_in_stock_cache
-        Rails.cache.delete(in_stock_cache_key)
+    def set_cost_currency
+      self.cost_currency = Spree::Config[:currency] if cost_currency.blank?
+    end
+
+    def create_stock_items
+      StockLocation.where(propagate_all_variants: true).each do |stock_location|
+        stock_location.propagate_variant(self)
       end
+    end
+
+    def in_stock_cache_key
+      "variant-#{id}-in_stock"
+    end
+
+    def clear_in_stock_cache
+      Rails.cache.delete(in_stock_cache_key)
+    end
   end
 end