spree_core 4.0.0 → 4.5.1

data/app/models/spree/product.rb

@@ -21,21 +21,37 @@
 module Spree
   class Product < Spree::Base
     extend FriendlyId
-    include Spree::ProductScopes
+    include ProductScopes
+    include MultiStoreResource
+    include MemoizedData
+    include Metadata
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+    if defined?(Spree::VendorConcern)
+      include Spree::VendorConcern
+    end
+
+    MEMOIZED_METHODS = %w(total_on_hand taxonomy_ids taxon_and_ancestors category
+                          default_variant_id tax_category default_variant
+                          purchasable? in_stock? backorderable?)
 
     friendly_id :slug_candidates, use: :history
 
     acts_as_paranoid
+    auto_strip_attributes :name
 
     # 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
 
     has_many :product_option_types, dependent: :destroy, inverse_of: :product
     has_many :option_types, through: :product_option_types
     has_many :product_properties, dependent: :destroy, inverse_of: :product
     has_many :properties, through: :product_properties
 
+    has_many :menu_items, as: :linked_resource
+
     has_many :classifications, dependent: :delete_all, inverse_of: :product
     has_many :taxons, through: :classifications, before_remove: :remove_taxon
 
@@ -75,6 +91,11 @@ module Spree
     has_many :orders, through: :line_items
 
     has_many :variant_images, -> { order(:position) }, source: :images, through: :variants_including_master
+    has_many :variant_images_without_master, -> { order(:position) }, source: :images, through: :variants
+
+    has_many :store_products, class_name: 'Spree::StoreProduct'
+    has_many :stores, through: :store_products, class_name: 'Spree::Store'
+    has_many :digitals, through: :variants_including_master
 
     after_create :add_associations_from_prototype
     after_create :build_variants_from_option_values_hash, if: :option_values_hash
@@ -89,6 +110,7 @@ module Spree
     after_save :reset_nested_changes
     after_touch :touch_taxons
 
+    before_validation :downcase_slug
     before_validation :normalize_slug, on: :update
     before_validation :validate_master
 
@@ -97,12 +119,15 @@ module Spree
       validates :meta_title
     end
     with_options presence: true do
-      validates :name, :shipping_category
-      validates :price, if: proc { Spree::Config[:require_master_price] }
+      validates :name
+      validates :shipping_category, if: :requires_shipping_category?
+      validates :price, if: :requires_price?
     end
 
-    validates :slug, presence: true, uniqueness: { allow_blank: true, case_sensitive: false }
-    validate :discontinue_on_must_be_later_than_available_on, if: -> { available_on && discontinue_on }
+    validates :slug, presence: true, uniqueness: { allow_blank: true, case_sensitive: true, scope: spree_base_uniqueness_scope }
+    validate :discontinue_on_must_be_later_than_make_active_at, if: -> { make_active_at && discontinue_on }
+
+    scope :for_store, ->(store) { joins(:store_products).where(StoreProduct.table_name => { store_id: store.id }) }
 
     attr_accessor :option_values_hash
 
@@ -110,35 +135,52 @@ module Spree
 
     alias options product_option_types
 
-    self.whitelisted_ransackable_associations = %w[stores variants_including_master master variants]
-    self.whitelisted_ransackable_attributes = %w[description name slug discontinue_on]
-    self.whitelisted_ransackable_scopes = %w[not_discontinued]
+    self.whitelisted_ransackable_associations = %w[taxons stores variants_including_master master variants]
+    self.whitelisted_ransackable_attributes = %w[description name slug discontinue_on status]
+    self.whitelisted_ransackable_scopes = %w[not_discontinued search_by_name in_taxon price_between]
 
     [
-      :sku, :price, :currency, :weight, :height, :width, :depth, :is_master,
-      :cost_currency, :price_in, :amount_in, :cost_price
+      :sku, :barcode, :price, :currency, :weight, :height, :width, :depth, :is_master,
+      :cost_currency, :price_in, :amount_in, :cost_price, :compare_at_price, :compare_at_amount_in
     ].each do |method_name|
       delegate method_name, :"#{method_name}=", to: :find_or_build_master
     end
 
     delegate :display_amount, :display_price, :has_default_price?,
-             :images, to: :find_or_build_master
+             :display_compare_at_price, :images, to: :find_or_build_master
 
     alias master_images images
 
-    # Cant use short form block syntax due to https://github.com/Netflix/fast_jsonapi/issues/259
+    state_machine :status, initial: :draft do
+      event :activate do
+        transition to: :active
+      end
+      after_transition to: :active, do: :after_activate
+
+      event :archive do
+        transition to: :archived
+      end
+      after_transition to: :archived, do: :after_archive
+
+      event :draft do
+        transition to: :draft
+      end
+      after_transition to: :draft, do: :after_draft
+    end
+
+    # Can't use short form block syntax due to https://github.com/Netflix/fast_jsonapi/issues/259
     def purchasable?
-      variants_including_master.any?(&:purchasable?)
+      default_variant.purchasable? || variants.any?(&:purchasable?)
     end
 
-    # Cant use short form block syntax due to https://github.com/Netflix/fast_jsonapi/issues/259
+    # Can't use short form block syntax due to https://github.com/Netflix/fast_jsonapi/issues/259
     def in_stock?
-      variants_including_master.any?(&:in_stock?)
+      default_variant.in_stock? || variants.any?(&:in_stock?)
     end
 
-    # Cant use short form block syntax due to https://github.com/Netflix/fast_jsonapi/issues/259
+    # Can't use short form block syntax due to https://github.com/Netflix/fast_jsonapi/issues/259
     def backorderable?
-      variants_including_master.any?(&:backorderable?)
+      default_variant.backorderable? || variants.any?(&:backorderable?)
     end
 
     def find_or_build_master
@@ -150,23 +192,36 @@ module Spree
       variants.any?
     end
 
+    # Returns default Variant for Product
+    # If `track_inventory_levels` is enabled it will try to find the first Variant
+    # in stock or backorderable, if there's none it will return first Variant sorted
+    # by `position` attribute
+    # If `track_inventory_levels` is disabled it will return first Variant sorted
+    # by `position` attribute
+    #
+    # @return [Spree::Variant]
     def default_variant
-      has_variants? ? variants.first : master
+      @default_variant ||= Rails.cache.fetch(default_variant_cache_key) do
+        if Spree::Config[:track_inventory_levels] && available_variant = variants.detect(&:purchasable?)
+          available_variant
+        else
+          has_variants? ? variants.first : master
+        end
+      end
     end
 
+    # Returns default Variant ID for Product
+    # @return [Integer]
     def default_variant_id
-      default_variant.id
+      @default_variant_id ||= default_variant.id
     end
 
     def tax_category
-      super || TaxCategory.find_by(is_default: true)
+      @tax_category ||= super || TaxCategory.find_by(is_default: true)
     end
 
     # Adding properties and option types on creation based on a chosen prototype
-    attr_reader :prototype_id
-    def prototype_id=(value)
-      @prototype_id = value.to_i
-    end
+    attr_accessor :prototype_id
 
     # Ensures option_types and product_option_types exist for keys in option_values_hash
     def ensure_option_types_exist_for_values_hash
@@ -194,14 +249,16 @@ module Spree
     end
 
     # determine if product is available.
-    # deleted products and products with nil or future available_on date
+    # deleted products and products with status different than active
     # are not available
     def available?
-      !(available_on.nil? || available_on.future?) && !deleted? && !discontinued?
+      active? && !deleted?
     end
 
     def discontinue!
-      update_attribute(:discontinue_on, Time.current)
+      self.discontinue_on = Time.current
+      self.status = 'archived'
+      save(validate: false)
     end
 
     def discontinued?
@@ -239,9 +296,7 @@ module Spree
     # values should not be displayed to frontend users. Otherwise it breaks the
     # idea of having variants
     def variants_and_option_values(current_currency = nil)
-      variants.includes(:option_values).active(current_currency).select do |variant|
-        variant.option_values.any?
-      end
+      variants.active(current_currency).joins(:option_value_variants)
     end
 
     def empty_option_values?
@@ -265,10 +320,12 @@ module Spree
     end
 
     def total_on_hand
-      if any_variants_not_track_inventory?
-        Float::INFINITY
-      else
-        stock_items.sum(:count_on_hand)
+      @total_on_hand ||= Rails.cache.fetch(['product-total-on-hand', cache_key_with_version]) do
+        if any_variants_not_track_inventory?
+          BigDecimal::INFINITY
+        else
+          stock_items.sum(:count_on_hand)
+        end
       end
     end
 
@@ -280,11 +337,29 @@ module Spree
     end
 
     def brand
-      taxons.joins(:taxonomy).find_by(spree_taxonomies: { name: Spree.t(:taxonomy_brands_name) })
+      @brand ||= taxons.joins(:taxonomy).find_by(spree_taxonomies: { name: Spree.t(:taxonomy_brands_name) })
     end
 
     def category
-      taxons.joins(:taxonomy).find_by(spree_taxonomies: { name: Spree.t(:taxonomy_categories_name) })
+      @category ||= taxons.joins(:taxonomy).order(depth: :desc).find_by(spree_taxonomies: { name: Spree.t(:taxonomy_categories_name) })
+    end
+
+    def taxons_for_store(store)
+      Rails.cache.fetch("#{cache_key_with_version}/taxons-per-store/#{store.id}") do
+        taxons.for_store(store)
+      end
+    end
+
+    def any_variant_in_stock_or_backorderable?
+      if variants.any?
+        variants_including_master.in_stock_or_backorderable.exists?
+      else
+        master.in_stock_or_backorderable?
+      end
+    end
+
+    def digital?
+      shipping_category&.name == I18n.t('spree.seed.shipping.categories.digital')
     end
 
     private
@@ -292,7 +367,7 @@ module Spree
     def add_associations_from_prototype
       if prototype_id && prototype = Spree::Prototype.find_by(id: prototype_id)
         prototype.properties.each do |property|
-          product_properties.create(property: property)
+          product_properties.create(property: property, value: 'Placeholder')
         end
         self.option_types = prototype.option_types
         self.taxons = prototype.taxons
@@ -321,7 +396,11 @@ module Spree
           price: master.price
         )
       end
-      throw(:abort) unless save
+      save
+    end
+
+    def default_variant_cache_key
+      "spree/default-variant/#{cache_key_with_version}/#{Spree::Config[:track_inventory_levels]}"
     end
 
     def ensure_master
@@ -381,8 +460,18 @@ module Spree
       # We call master.default_price here to ensure price is initialized.
       # Required to avoid Variant#check_price validation failing on create.
       unless master.default_price && master.valid?
-        master.errors.each do |att, error|
-          errors.add(att, error)
+        if Rails::VERSION::STRING >= '6.1'
+          master.errors.map { |error| { field: error.attribute, message: error&.message } }.each do |err|
+            next if err[:field].blank? || err[:message].blank?
+
+            errors.add(err[:field], err[:message])
+          end
+        else
+          master.errors.messages.each do |field, error|
+            next if field.blank? || error.empty?
+
+            errors.add(field, error.first)
+          end
         end
       end
     end
@@ -400,12 +489,12 @@ module Spree
     end
 
     def taxon_and_ancestors
-      taxons.map(&:self_and_ancestors).flatten.uniq
+      @taxon_and_ancestors ||= taxons.map(&:self_and_ancestors).flatten.uniq
     end
 
     # Get the taxonomy ids of all taxons assigned to this product and their ancestors.
     def taxonomy_ids
-      taxon_and_ancestors.map(&:taxonomy_id).flatten.uniq
+      @taxonomy_ids ||= taxon_and_ancestors.map(&:taxonomy_id).flatten.uniq
     end
 
     # Iterate through this products taxons and taxonomies and touch their timestamps in a batch
@@ -414,8 +503,8 @@ module Spree
       Spree::Taxonomy.where(id: taxonomy_ids).update_all(updated_at: Time.current)
     end
 
-    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
@@ -426,10 +515,34 @@ module Spree
       removed_classifications.each &:remove_from_list
     end
 
-    def discontinue_on_must_be_later_than_available_on
-      if discontinue_on < available_on
+    def discontinue_on_must_be_later_than_make_active_at
+      if discontinue_on < make_active_at
         errors.add(:discontinue_on, :invalid_date_range)
       end
     end
+
+    def requires_price?
+      Spree::Config[:require_master_price]
+    end
+
+    def requires_shipping_category?
+      true
+    end
+
+    def downcase_slug
+      slug&.downcase!
+    end
+
+    def after_activate
+      # this method is prepended in api/ to queue Webhooks requests
+    end
+
+    def after_archive
+      # this method is prepended in api/ to queue Webhooks requests
+    end
+
+    def after_draft
+      # this method is prepended in api/ to queue Webhooks requests
+    end
   end
 end

data/app/models/spree/product_property.rb

@@ -1,29 +1,45 @@
 module Spree
   class ProductProperty < Spree::Base
+    include Spree::FilterParam
+
+    auto_strip_attributes :value
+
     acts_as_list scope: :product
 
     with_options inverse_of: :product_properties do
       belongs_to :product, touch: true, class_name: 'Spree::Product'
-      belongs_to :property, class_name: 'Spree::Property'
+      belongs_to :property, touch: true, class_name: 'Spree::Property'
     end
 
     validates :property, presence: true
-
-    validates :value, db_maximum_length: true
+    validates :property_id, uniqueness: { scope: :product_id }
+    validates :value, presence: true
 
     default_scope { order(:position) }
 
-    self.whitelisted_ransackable_attributes = ['value']
+    scope :filterable, -> { joins(:property).where(Property.table_name => { filterable: true }) }
+    scope :for_products, ->(products) { joins(:product).merge(products) }
+
+    self.whitelisted_ransackable_attributes = ['value', 'filter_param']
     self.whitelisted_ransackable_associations = ['property']
 
     # virtual attributes for use with AJAX completion stuff
     delegate :name, :presentation, to: :property, prefix: true, allow_nil: true
 
     def property_name=(name)
+      ActiveSupport::Deprecation.warn(<<-DEPRECATION, caller)
+        `ProductProperty#property_name=` is deprecated and will be removed in Spree 5.0.
+      DEPRECATION
       if name.present?
         # don't use `find_by :name` to workaround globalize/globalize#423 bug
         self.property = Property.where(name: name).first_or_create(presentation: name)
       end
     end
+
+    protected
+
+    def param_candidate
+      value
+    end
   end
 end

data/app/models/spree/promotion/actions/create_item_adjustments.rb

@@ -23,7 +23,7 @@ module Spree
           order   = line_item.order
 
           # Prevent negative order totals
-          amounts << order.amount - order.adjustments.sum(:amount).abs if order.adjustments.any?
+          amounts << order.amount - order.adjustments.eligible.sum(:amount).abs if order.adjustments.eligible.any?
 
           amounts.min * -1
         end

data/app/models/spree/promotion/rules/country.rb

@@ -11,7 +11,7 @@ module Spree
 
         def eligible?(order, options = {})
           country_id = options[:country_id] || order.ship_address.try(:country_id)
-          unless country_id.eql?(preferred_country_id || Spree::Country.default)
+          unless country_id.eql?(preferred_country_id || order.store.default_country_id)
             eligibility_errors.add(:base, eligibility_error_message(:wrong_country))
           end
 

data/app/models/spree/promotion/rules/first_order.rb

@@ -2,7 +2,7 @@ module Spree
   class Promotion
     module Rules
       class FirstOrder < PromotionRule
-        attr_reader :user, :email
+        attr_reader :user, :email, :store
 
         def applicable?(promotable)
           promotable.is_a?(Spree::Order)
@@ -11,6 +11,7 @@ module Spree
         def eligible?(order, options = {})
           @user = order.try(:user) || options[:user]
           @email = order.email
+          @store = order.store
 
           if user || email
             if !completed_orders.blank? && completed_orders.first != order
@@ -26,11 +27,11 @@ module Spree
         private
 
         def completed_orders
-          user ? user.orders.complete : orders_by_email
+          user ? user.orders.for_store(store).complete : orders_by_email
         end
 
         def orders_by_email
-          Spree::Order.where(email: email).complete
+          store.orders.where(email: email).complete
         end
       end
     end

data/app/models/spree/promotion/rules/option_value.rb

@@ -4,9 +4,9 @@ module Spree
       module OptionValueWithNumerificationSupport
         def preferred_eligible_values
           values = super || {}
-          Hash[values.keys.map(&:to_i).zip(
+          Hash[values.keys.zip(
             values.values.map do |v|
-              (v.is_a?(Array) ? v : v.split(',')).map(&:to_i)
+              (v.is_a?(Array) ? v : v.split(','))
             end
           )]
         end
@@ -31,7 +31,7 @@ module Spree
         end
 
         def actionable?(line_item)
-          product_id = line_item.product.id
+          product_id = line_item.product_id
           option_values_ids = line_item.variant.option_value_ids
           eligible_product_ids = preferred_eligible_values.keys
           eligible_value_ids = preferred_eligible_values[product_id]

data/app/models/spree/promotion/rules/product.rb

@@ -1,6 +1,6 @@
 # A rule to limit a promotion based on products in the order.
 # Can require all or any of the products to be present.
-# Valid products either come from assigned product group or are assingned directly to the rule.
+# Valid products either come from assigned product group or are assigned directly to the rule.
 module Spree
   class Promotion
     module Rules
@@ -58,7 +58,8 @@ module Spree
         end
 
         def product_ids_string=(s)
-          self.product_ids = s.to_s.split(',').map(&:strip)
+          # check this
+          self.product_ids = s
         end
       end
     end

data/app/models/spree/promotion/rules/taxon.rb

@@ -30,7 +30,12 @@ module Spree
         end
 
         def actionable?(line_item)
-          taxon_product_ids.include? line_item.variant.product_id
+          store = line_item.order.store
+
+          store.products.
+            joins(:classifications).
+            where(Spree::Classification.table_name => { taxon_id: taxon_ids, product_id: line_item.product_id }).
+            exists?
         end
 
         def taxon_ids_string
@@ -39,14 +44,16 @@ module Spree
 
         def taxon_ids_string=(s)
           ids = s.to_s.split(',').map(&:strip)
-          self.taxons = Spree::Taxon.find(ids)
+          self.taxons = Spree::Taxon.for_stores(stores).find(ids)
         end
 
         private
 
         # All taxons in an order
         def order_taxons(order)
-          Spree::Taxon.joins(products: { variants_including_master: :line_items }).where(spree_line_items: { order_id: order.id }).distinct
+          taxon_ids = Spree::Classification.where(product_id: order.product_ids).pluck(:taxon_id).uniq
+
+          order.store.taxons.where(id: taxon_ids)
         end
 
         # ids of taxons rules and taxons rules children
@@ -62,10 +69,6 @@ module Spree
         def taxons_in_order_including_parents(order)
           order_taxons_in_taxons_and_children(order).inject([]) { |taxons, taxon| taxons << taxon.self_and_ancestors }.flatten.uniq
         end
-
-        def taxon_product_ids
-          Spree::Product.joins(:taxons).where(spree_taxons: { id: taxons.pluck(:id) }).pluck(:id).uniq
-        end
       end
     end
   end

data/app/models/spree/promotion/rules/user.rb

@@ -22,7 +22,8 @@ module Spree
         end
 
         def user_ids_string=(s)
-          self.user_ids = s.to_s.split(',').map(&:strip)
+          # check this
+          self.user_ids = s
         end
       end
     end

data/app/models/spree/promotion.rb

@@ -1,5 +1,14 @@
 module Spree
   class Promotion < Spree::Base
+    include MultiStoreResource
+    include Metadata
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+    if defined?(Spree::Security::Promotions)
+      include Spree::Security::Promotions
+    end
+
     MATCH_POLICIES = %w(all any)
     UNACTIVATABLE_ORDER_STATES = ['complete', 'awaiting_return', 'returned']
 
@@ -16,17 +25,19 @@ module Spree
     has_many :order_promotions, class_name: 'Spree::OrderPromotion'
     has_many :orders, through: :order_promotions, class_name: 'Spree::Order'
 
+    has_many :store_promotions, class_name: 'Spree::StorePromotion'
+    has_many :stores, class_name: 'Spree::Store', through: :store_promotions
+
     accepts_nested_attributes_for :promotion_actions, :promotion_rules
 
     validates_associated :rules
 
     validates :name, presence: true
-    validates :path, :code, uniqueness: { case_sensitive: false, allow_blank: true }
     validates :usage_limit, numericality: { greater_than: 0, allow_nil: true }
     validates :description, length: { maximum: 255 }, allow_blank: true
     validate :expires_at_must_be_later_than_starts_at, if: -> { starts_at && expires_at }
 
-    before_save :normalize_blank_values
+    auto_strip_attributes :code, :path, :name
 
     scope :coupons, -> { where.not(code: nil) }
     scope :advertised, -> { where(advertise: true) }
@@ -42,7 +53,7 @@ module Spree
     def self.with_coupon_code(coupon_code)
       where("lower(#{table_name}.code) = ?", coupon_code.strip.downcase).
         includes(:promotion_actions).where.not(spree_promotion_actions: { id: nil }).
-        first
+        last
     end
 
     def self.active
@@ -192,21 +203,10 @@ module Spree
     end
 
     def used_by?(user, excluded_orders = [])
-      [
-        :adjustments,
-        :line_item_adjustments,
-        :shipment_adjustments
-      ].any? do |adjustment_type|
-        user.orders.complete.joins(adjustment_type).where(
-          spree_adjustments: {
-            source_type: 'Spree::PromotionAction',
-            source_id: actions.map(&:id),
-            eligible: true
-          }
-        ).where.not(
-          id: excluded_orders.map(&:id)
-        ).any?
-      end
+      user.orders.complete.joins(:promotions).joins(:all_adjustments).
+        where.not(spree_orders: { id: excluded_orders.map(&:id) }).
+        where(spree_promotions: { id: id }).
+        where(spree_adjustments: { source_type: 'Spree::PromotionAction', eligible: true }).any?
     end
 
     private
@@ -221,12 +221,6 @@ module Spree
       end
     end
 
-    def normalize_blank_values
-      [:code, :path].each do |column|
-        self[column] = nil if self[column].blank?
-      end
-    end
-
     def match_all?
       match_policy == 'all'
     end

data/app/models/spree/promotion_action.rb

@@ -8,7 +8,7 @@ module Spree
 
     scope :of_type, ->(t) { where(type: t) }
 
-    # This method should be overriden in subclass
+    # This method should be overridden in subclass
     # Updates the state of the order or performs some other action depending on the subclass
     # options will contain the payload from the event that activated the promotion. This will include
     # the key :user which allows user based actions to be performed in addition to actions on the order