spree_core 4.1.1 → 4.5.0

data/app/models/spree/taxonomy.rb

@@ -1,17 +1,26 @@
 module Spree
   class Taxonomy < Spree::Base
+    include Metadata
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+
     acts_as_list
 
-    validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
+    validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true, scope: :store_id }
+    validates :store, presence: true
 
     has_many :taxons, inverse_of: :taxonomy
     has_one :root, -> { where parent_id: nil }, class_name: 'Spree::Taxon', dependent: :destroy
+    belongs_to :store, class_name: 'Spree::Store'
 
     after_create :set_root
-    after_save :set_root_taxon_name
+    after_update :set_root_taxon_name
 
     default_scope { order("#{table_name}.position, #{table_name}.created_at") }
 
+    self.whitelisted_ransackable_associations = %w[root]
+
     private
 
     def set_root
@@ -19,6 +28,9 @@ module Spree
     end
 
     def set_root_taxon_name
+      return unless saved_change_to_name?
+      return if name.to_s == root.name.to_s
+
       root.update(name: name)
     end
   end

data/app/models/spree/variant.rb

@@ -3,17 +3,28 @@ module Spree
     acts_as_paranoid
     acts_as_list scope: :product
 
-    belongs_to :product, touch: true, class_name: 'Spree::Product', inverse_of: :variants
+    include MemoizedData
+    include Metadata
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+
+    MEMOIZED_METHODS = %w(purchasable in_stock backorderable tax_category options_text compare_at_price)
+
+    belongs_to :product, -> { with_deleted }, touch: true, class_name: 'Spree::Product', inverse_of: :variants
     belongs_to :tax_category, class_name: 'Spree::TaxCategory', optional: true
 
-    delegate :name, :name=, :description, :slug, :available_on, :shipping_category_id,
+    delegate :name, :name=, :description, :slug, :available_on, :make_active_at, :shipping_category_id,
              :meta_description, :meta_keywords, :shipping_category, to: :product
 
+    auto_strip_attributes :sku, nullify: false
+
     # we need to have this callback before any dependent: :destroy associations
     # https://github.com/rails/rails/issues/3458
-    before_destroy :ensure_no_line_items
+    before_destroy :ensure_not_in_complete_orders
+    after_destroy :remove_line_items_from_incomplete_orders
 
-    # must include this after ensure_no_line_items to make sure price won't be deleted before validation
+    # must include this after ensure_not_in_complete_orders to make sure price won't be deleted before validation
     include Spree::DefaultPrice
 
     with_options inverse_of: :variant do
@@ -29,7 +40,7 @@ module Spree
     end
 
     has_many :option_value_variants, class_name: 'Spree::OptionValueVariant'
-    has_many :option_values, through: :option_value_variants, class_name: 'Spree::OptionValue'
+    has_many :option_values, through: :option_value_variants, dependent: :destroy, class_name: 'Spree::OptionValue'
 
     has_many :images, -> { order(:position) }, as: :viewable, dependent: :destroy, class_name: 'Spree::Image'
 
@@ -38,6 +49,10 @@ module Spree
              dependent: :destroy,
              inverse_of: :variant
 
+    has_many :wished_items, dependent: :destroy
+
+    has_many :digitals
+
     before_validation :set_cost_currency
 
     validate :check_price
@@ -48,14 +63,15 @@ module Spree
       validates :cost_price
       validates :price
     end
-    validates :sku, uniqueness: { conditions: -> { where(deleted_at: nil) }, case_sensitive: false }, allow_blank: true
+    validates :sku, uniqueness: { conditions: -> { where(deleted_at: nil) }, case_sensitive: false, scope: spree_base_uniqueness_scope },
+                    allow_blank: true, unless: :disable_sku_validation?
 
     after_create :create_stock_items
     after_create :set_master_out_of_stock, unless: :is_master?
 
     after_touch :clear_in_stock_cache
 
-    scope :in_stock, -> { joins(:stock_items).where('count_on_hand > ? OR track_inventory = ?', 0, false) }
+    scope :in_stock, -> { joins(:stock_items).where("#{Spree::StockItem.table_name}.count_on_hand > ? OR #{Spree::Variant.table_name}.track_inventory = ?", 0, false) }
     scope :backorderable, -> { joins(:stock_items).where(spree_stock_items: { backorderable: true }) }
     scope :in_stock_or_backorderable, -> { in_stock.or(backorderable) }
 
@@ -84,7 +100,7 @@ module Spree
     scope :not_deleted, -> { where("#{Spree::Variant.quoted_table_name}.deleted_at IS NULL") }
 
     scope :for_currency_and_available_price_amount, ->(currency = nil) do
-      currency ||= Spree::Config[:currency]
+      currency ||= Spree::Store.default.default_currency
       joins(:prices).where('spree_prices.currency = ?', currency).where('spree_prices.amount IS NOT NULL').distinct
     end
 
@@ -92,6 +108,7 @@ module Spree
       not_discontinued.not_deleted.
         for_currency_and_available_price_amount(currency)
     end
+    # FIXME: cost price should be represented with DisplayMoney class
     LOCALIZED_NUMBERS = %w(cost_price weight depth width height)
 
     LOCALIZED_NUMBERS.each do |m|
@@ -100,23 +117,41 @@ module Spree
       end
     end
 
-    self.whitelisted_ransackable_associations = %w[option_values product prices default_price]
-    self.whitelisted_ransackable_attributes = %w[weight sku]
+    self.whitelisted_ransackable_associations = %w[option_values product tax_category prices default_price]
+    self.whitelisted_ransackable_attributes = %w[weight depth width height sku discontinue_on is_master cost_price cost_currency track_inventory deleted_at]
+    self.whitelisted_ransackable_scopes = %i(product_name_or_sku_cont search_by_product_name_or_sku)
+
+    def self.product_name_or_sku_cont(query)
+      joins(:product).where("LOWER(#{Product.table_name}.name) LIKE LOWER(:query) OR LOWER(sku) LIKE LOWER(:query)", query: "%#{query}%")
+    end
+
+    def self.search_by_product_name_or_sku(query)
+      if defined?(SpreeGlobalize)
+        joins(product: :translations).where("LOWER(#{Product::Translation.table_name}.name) LIKE LOWER(:query) OR LOWER(sku) LIKE LOWER(:query)",
+                                            query: "%#{query}%")
+      else
+        product_name_or_sku_cont(query)
+      end
+    end
 
     def available?
       !discontinued? && product.available?
     end
 
+    def in_stock_or_backorderable?
+      self.class.in_stock_or_backorderable.exists?(id: id)
+    end
+
     def tax_category
-      if self[:tax_category_id].nil?
-        product.tax_category
-      else
-        Spree::TaxCategory.find(self[:tax_category_id])
-      end
+      @tax_category ||= if self[:tax_category_id].nil?
+                          product.tax_category
+                        else
+                          Spree::TaxCategory.find_by(id: self[:tax_category_id]) || product.tax_category
+                        end
     end
 
     def options_text
-      Spree::Variants::OptionsPresenter.new(self).to_sentence
+      @options_text ||= Spree::Variants::OptionsPresenter.new(self).to_sentence
     end
 
     # Default to master name
@@ -135,15 +170,10 @@ module Spree
       !!deleted_at
     end
 
-    # Product may be created with deleted_at already set,
-    # which would make AR's default finder return nil.
-    # This is a stopgap for that little problem.
-    def product
-      Spree::Product.unscoped { super }
-    end
-
     def options=(options = {})
       options.each do |option|
+        next if option[:name].blank? || option[:value].blank?
+
         set_option_value(option[:name], option[:value])
       end
     end
@@ -152,12 +182,12 @@ module Spree
       # no option values on master
       return if is_master
 
-      option_type = Spree::OptionType.where(name: opt_name).first_or_initialize do |o|
-        o.presentation = opt_name
+      option_type = Spree::OptionType.where(['LOWER(name) = ?', opt_name.downcase.strip]).first_or_initialize do |o|
+        o.name = o.presentation = opt_name
         o.save!
       end
 
-      current_value = option_values.detect { |o| o.option_type.name == opt_name }
+      current_value = find_option_value(opt_name)
 
       if current_value.nil?
         # then we have to check to make sure that the product has the option type
@@ -165,13 +195,13 @@ module Spree
           product.option_types << option_type
         end
       else
-        return if current_value.name == opt_value
+        return if current_value.name.downcase.strip == opt_value.downcase.strip
 
         option_values.delete(current_value)
       end
 
-      option_value = Spree::OptionValue.where(option_type_id: option_type.id, name: opt_value).first_or_initialize do |o|
-        o.presentation = opt_value
+      option_value = option_type.option_values.where(['LOWER(name) = ?', opt_value.downcase.strip]).first_or_initialize do |o|
+        o.name = o.presentation = opt_value
         o.save!
       end
 
@@ -179,18 +209,39 @@ module Spree
       save
     end
 
+    def find_option_value(opt_name)
+      option_values.detect { |o| o.option_type.name.downcase.strip == opt_name.downcase.strip }
+    end
+
     def option_value(opt_name)
-      option_values.detect { |o| o.option_type.name == opt_name }.try(:presentation)
+      find_option_value(opt_name).try(:presentation)
     end
 
     def price_in(currency)
-      prices.detect { |price| price.currency == currency } || prices.build(currency: currency)
+      currency = currency&.upcase
+      find_or_build_price = lambda do
+        if prices.loaded?
+          prices.detect { |price| price.currency == currency } || prices.build(currency: currency)
+        else
+          prices.find_or_initialize_by(currency: currency)
+        end
+      end
+
+      Rails.cache.fetch("spree/prices/#{cache_key_with_version}/price_in/#{currency}") do
+        find_or_build_price.call
+      end
+    rescue TypeError
+      find_or_build_price.call
     end
 
     def amount_in(currency)
       price_in(currency).try(:amount)
     end
 
+    def compare_at_amount_in(currency)
+      price_in(currency).try(:compare_at_amount)
+    end
+
     def price_modifier_amount_in(currency, options = {})
       return 0 unless options.present?
 
@@ -217,6 +268,10 @@ module Spree
       end.sum
     end
 
+    def compare_at_price
+      @compare_at_price ||= price_in(cost_currency).try(:compare_at_amount)
+    end
+
     def name_and_sku
       "#{name} - #{sku}"
     end
@@ -226,17 +281,27 @@ module Spree
     end
 
     def in_stock?
-      Rails.cache.fetch(in_stock_cache_key) do
+      # Issue 10280
+      # Check if model responds to cache version and fall back to updated_at for older rails versions
+      # This makes sure a version is supplied when recyclable cache keys are disabled.
+      version = respond_to?(:cache_version) ? cache_version : updated_at.to_i
+      @in_stock ||= Rails.cache.fetch(in_stock_cache_key, version: version) do
         total_on_hand > 0
       end
     end
 
-    delegate :total_on_hand, :can_supply?, :backorderable?, to: :quantifier
+    def backorderable?
+      @backorderable ||= Rails.cache.fetch(['variant-backorderable', cache_key_with_version]) do
+        quantifier.backorderable?
+      end
+    end
+
+    delegate :total_on_hand, :can_supply?, to: :quantifier
 
     alias is_backorderable? backorderable?
 
     def purchasable?
-      in_stock? || backorderable?
+      @purchasable ||= in_stock? || backorderable?
     end
 
     # Shortcut method to determine if inventory tracking is enabled for this variant
@@ -245,10 +310,6 @@ module Spree
       track_inventory? && Spree::Config.track_inventory_levels
     end
 
-    def track_inventory
-      should_track_inventory?
-    end
-
     def volume
       (width || 0) * (height || 0) * (depth || 0)
     end
@@ -266,18 +327,27 @@ module Spree
     end
 
     def backordered?
-      total_on_hand <= 0 && stock_items.exists?(backorderable: true)
+      @backordered ||= !in_stock? && stock_items.exists?(backorderable: true)
+    end
+
+    # Is this variant to be downloaded by the customer?
+    def digital?
+      digitals.present?
     end
 
     private
 
-    def ensure_no_line_items
-      if line_items.any?
+    def ensure_not_in_complete_orders
+      if orders.complete.any?
         errors.add(:base, :cannot_destroy_if_attached_to_line_items)
         throw(:abort)
       end
     end
 
+    def remove_line_items_from_incomplete_orders
+      Spree::Variants::RemoveFromIncompleteOrdersJob.perform_later(self)
+    end
+
     def quantifier
       Spree::Stock::Quantifier.new(self)
     end
@@ -298,12 +368,12 @@ module Spree
         self.price = product.master.price
       end
       if price.present? && currency.nil?
-        self.currency = Spree::Config[:currency]
+        self.currency = Spree::Store.default.default_currency
       end
     end
 
     def set_cost_currency
-      self.cost_currency = Spree::Config[:currency] if cost_currency.blank?
+      self.cost_currency = Spree::Store.default.default_currency if cost_currency.blank?
     end
 
     def create_stock_items
@@ -319,5 +389,9 @@ module Spree
     def clear_in_stock_cache
       Rails.cache.delete(in_stock_cache_key)
     end
+
+    def disable_sku_validation?
+      Spree::Config[:disable_sku_validation]
+    end
   end
 end

data/app/models/spree/wished_item.rb

@@ -0,0 +1,33 @@
+module Spree
+  class WishedItem < Spree::Base
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+
+    extend DisplayMoney
+    money_methods :total, :price
+
+    belongs_to :variant, class_name: 'Spree::Variant'
+    belongs_to :wishlist, class_name: 'Spree::Wishlist'
+
+    has_one :product, class_name: 'Spree::Product', through: :variant
+
+    validates :variant, :wishlist, presence: true
+    validates :variant, uniqueness: { scope: [:wishlist] }
+    validates :quantity, numericality: { only_integer: true, greater_than: 0 }
+
+    def price(currency)
+      variant.amount_in(currency[:currency])
+    end
+
+    def total(currency)
+      variant_price = variant.amount_in(currency[:currency])
+
+      if variant_price.nil?
+        variant_price
+      else
+        quantity * variant_price
+      end
+    end
+  end
+end

data/app/models/spree/wishlist.rb

@@ -0,0 +1,38 @@
+module Spree
+  class Wishlist < Spree::Base
+    include SingleStoreResource
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+
+    has_secure_token
+
+    belongs_to :user, class_name: "::#{Spree.user_class}", touch: true
+    belongs_to :store, class_name: 'Spree::Store'
+
+    has_many :wished_items, class_name: 'Spree::WishedItem', dependent: :destroy
+
+    after_commit :ensure_default_exists_and_is_unique
+    validates :name, :store, :user, presence: true
+
+    def include?(variant_id)
+      wished_items.exists?(variant_id: variant_id)
+    end
+
+    def to_param
+      token
+    end
+
+    def self.get_by_param(param)
+      find_by(token: param)
+    end
+
+    private
+
+    def ensure_default_exists_and_is_unique
+      if is_default?
+        Wishlist.where(is_default: true, user_id: user_id, store_id: store_id).where.not(id: id).update_all(is_default: false)
+      end
+    end
+  end
+end

data/app/models/spree/zone.rb

@@ -1,5 +1,10 @@
 module Spree
   class Zone < Spree::Base
+    include UniqueName
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+
     with_options dependent: :destroy, inverse_of: :zone do
       has_many :zone_members, class_name: 'Spree::ZoneMember'
       has_many :tax_rates
@@ -12,8 +17,6 @@ module Spree
     has_many :shipping_method_zones, class_name: 'Spree::ShippingMethodZone'
     has_many :shipping_methods, through: :shipping_method_zones, class_name: 'Spree::ShippingMethod'
 
-    validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
-
     scope :with_default_tax, -> { where(default_tax: true) }
 
     after_save :remove_defunct_members
@@ -70,9 +73,15 @@ module Spree
       matches.first
     end
 
+    def self.default_checkout_zone
+      ActiveSupport::Deprecation.warn('Spree::Zone.default_checkout_zone is deprecated and will be removed in Spree 5')
+
+      first
+    end
+
     def kind
-      if kind?
-        super
+      if self[:kind].present?
+        self[:kind]
       else
         not_nil_scope = members.where.not(zoneable_type: nil)
         zone_type = not_nil_scope.order('created_at ASC').pluck(:zoneable_type).last
@@ -97,8 +106,6 @@ module Spree
           zone_member.zoneable_id == address.country_id
         when 'Spree::State'
           zone_member.zoneable_id == address.state_id
-        else
-          false
         end
       end
     end
@@ -107,12 +114,10 @@ module Spree
     def country_list
       @countries ||= case kind
                      when 'country' then
-                       zoneables
+                       Country.where(id: country_ids)
                      when 'state' then
-                       zoneables.collect(&:country)
-                     else
-                       []
-                     end.flatten.compact.uniq
+                       Country.where(id: zoneables.collect(&:country_id))
+                     end
     end
 
     def <=>(other)
@@ -167,6 +172,19 @@ module Spree
       true
     end
 
+    def state_list
+      case kind
+      when 'country'
+        zoneables.map(&:states)
+      when 'state'
+        zoneables
+      end.flatten.compact.uniq
+    end
+
+    def state_list_for(country)
+      state_list.select { |state| state.country == country }
+    end
+
     private
 
     def remove_defunct_members

data/app/paginators/spree/shared/paginate.rb

@@ -4,7 +4,14 @@ module Spree
       def initialize(collection, params)
         @collection = collection
         @page       = params[:page]
-        @per_page   = params[:per_page]
+
+        per_page_limit = Spree::Api::Config[:api_v2_per_page_limit]
+
+        @per_page = if params[:per_page].to_i.between?(1, per_page_limit)
+                      params[:per_page]
+                    else
+                      Kaminari.config.default_per_page
+                    end
       end
 
       def call

data/app/presenters/spree/filters/options_presenter.rb

@@ -0,0 +1,47 @@
+module Spree
+  module Filters
+    class OptionsPresenter
+      FilterableOptionType = Struct.new(:option_type, :option_values, keyword_init: true) do
+        delegate_missing_to :option_type
+
+        def to_h
+          {
+            id: option_type.id,
+            name: option_type.name,
+            presentation: option_type.presentation,
+            option_values: option_values.map { |e| option_value_hash(e) }
+          }
+        end
+
+        private
+
+        def option_value_hash(option_value)
+          {
+            id: option_value.id,
+            name: option_value.name,
+            presentation: option_value.presentation,
+            position: option_value.position
+          }
+        end
+      end
+
+      def initialize(option_values_scope:)
+        @option_values = option_values_scope.includes(:option_type)
+      end
+
+      def to_a
+        grouped_options.map do |option_type, option_values|
+          FilterableOptionType.new(option_type: option_type, option_values: option_values)
+        end
+      end
+
+      private
+
+      attr_reader :option_values
+
+      def grouped_options
+        option_values.group_by(&:option_type)
+      end
+    end
+  end
+end

data/app/presenters/spree/filters/price_presenter.rb

@@ -0,0 +1,22 @@
+module Spree
+  module Filters
+    class PricePresenter
+      def initialize(amount:, currency:)
+        @amount = amount.to_i
+        @currency = currency
+      end
+
+      def to_i
+        amount
+      end
+
+      def to_s
+        Spree::Money.new(amount, currency: currency, no_cents_if_whole: true).to_s
+      end
+
+      private
+
+      attr_reader :amount, :currency
+    end
+  end
+end

data/app/presenters/spree/filters/price_range_presenter.rb

@@ -0,0 +1,29 @@
+module Spree
+  module Filters
+    class PriceRangePresenter
+      def self.from_param(param, currency:)
+        prices = param.split('-')
+
+        new(
+          min_price: PricePresenter.new(amount: prices.first, currency: currency),
+          max_price: PricePresenter.new(amount: prices.last, currency: currency)
+        )
+      end
+
+      def initialize(min_price:, max_price:)
+        @min_price = min_price
+        @max_price = max_price
+      end
+
+      attr_reader :min_price, :max_price
+
+      def to_param
+        "#{min_price.to_i}-#{max_price.to_i}"
+      end
+
+      def to_s
+        "#{min_price} - #{max_price}"
+      end
+    end
+  end
+end

data/app/presenters/spree/filters/properties_presenter.rb

@@ -0,0 +1,23 @@
+module Spree
+  module Filters
+    class PropertiesPresenter
+      def initialize(product_properties_scope:)
+        @product_properties = product_properties_scope.includes(:property)
+      end
+
+      def to_a
+        grouped_options.map do |property, product_properties|
+          PropertyPresenter.new(property: property, product_properties: product_properties)
+        end
+      end
+
+      private
+
+      attr_reader :product_properties
+
+      def grouped_options
+        product_properties.group_by(&:property)
+      end
+    end
+  end
+end