spree_core 4.0.0 → 4.6.0

data/app/models/spree/price.rb

@@ -1,12 +1,15 @@
 module Spree
   class Price < Spree::Base
     include VatPriceCalculation
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
 
     acts_as_paranoid
 
     MAXIMUM_AMOUNT = BigDecimal('99_999_999.99')
 
-    belongs_to :variant, class_name: 'Spree::Variant', inverse_of: :prices, touch: true
+    belongs_to :variant, -> { with_deleted }, class_name: 'Spree::Variant', inverse_of: :prices, touch: true
 
     before_validation :ensure_currency
 
@@ -15,39 +18,58 @@ module Spree
       less_than_or_equal_to: MAXIMUM_AMOUNT
     }
 
+    validates :compare_at_amount, allow_nil: true, numericality: {
+      greater_than_or_equal_to: 0,
+      less_than_or_equal_to: MAXIMUM_AMOUNT
+    }
+
     extend DisplayMoney
-    money_methods :amount, :price
+    money_methods :amount, :price, :compare_at_amount
+    alias display_compare_at_price display_compare_at_amount
 
-    self.whitelisted_ransackable_attributes = ['amount']
+    self.whitelisted_ransackable_attributes = ['amount', 'compare_at_amount']
 
     def money
-      Spree::Money.new(amount || 0, currency: currency)
+      Spree::Money.new(amount || 0, currency: currency.upcase)
     end
 
     def amount=(amount)
       self[:amount] = Spree::LocalizedNumber.parse(amount)
     end
 
+    def compare_at_money
+      Spree::Money.new(compare_at_amount || 0, currency: currency)
+    end
+
+    def compare_at_amount=(compare_at_amount)
+      self[:compare_at_amount] = Spree::LocalizedNumber.parse(compare_at_amount)
+    end
+
     alias_attribute :price, :amount
+    alias_attribute :compare_at_price, :compare_at_amount
 
     def price_including_vat_for(price_options)
       options = price_options.merge(tax_category: variant.tax_category)
       gross_amount(price, options)
     end
 
+    def compare_at_price_including_vat_for(price_options)
+      options = price_options.merge(tax_category: variant.tax_category)
+      gross_amount(compare_at_price, options)
+    end
+
     def display_price_including_vat_for(price_options)
       Spree::Money.new(price_including_vat_for(price_options), currency: currency)
     end
 
-    # Remove variant default_scope `deleted_at: nil`
-    def variant
-      Spree::Variant.unscoped { super }
+    def display_compare_at_price_including_vat_for(price_options)
+      Spree::Money.new(compare_at_price_including_vat_for(price_options), currency: currency)
     end
 
     private
 
     def ensure_currency
-      self.currency ||= Spree::Config[:currency]
+      self.currency ||= Spree::Store.default.default_currency
     end
   end
 end

data/app/models/spree/product.rb

@@ -21,21 +21,47 @@
 module Spree
   class Product < Spree::Base
     extend FriendlyId
-    include Spree::ProductScopes
+    include ProductScopes
+    include MultiStoreResource
+    include TranslatableResource
+    include TranslatableResourceSlug
+    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
+    TRANSLATABLE_FIELDS = %i[name description slug meta_description meta_keywords meta_title].freeze
+    translates(*TRANSLATABLE_FIELDS)
 
+    self::Translation.class_eval do
+      acts_as_paranoid
+      # deleted translation values also need to be accessible for index views listing deleted resources
+      default_scope { unscope(where: :deleted_at) }
+    end
+
+    friendly_id :slug_candidates, use: [:history, :mobility]
     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 +101,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 +120,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 +129,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 +145,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 +202,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 +259,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 +306,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?
@@ -251,24 +316,38 @@ module Spree
     end
 
     def property(property_name)
-      product_properties.joins(:property).find_by(spree_properties: { name: property_name }).try(:value)
+      product_properties.joins(:property).
+        join_translation_table(Property).
+        find_by(Property.translation_table_alias => { name: property_name }).try(:value)
     end
 
     def set_property(property_name, property_value, property_presentation = property_name)
       ApplicationRecord.transaction do
-        # Works around spree_i18n #301
-        property = Property.create_with(presentation: property_presentation).find_or_create_by(name: property_name)
-        product_property = ProductProperty.where(product: self, property: property).first_or_initialize
+        # Manual first_or_create to work around Mobility bug
+        property = if Property.where(name: property_name).exists?
+                     Property.where(name: property_name).first
+                   else
+                     Property.create(name: property_name, presentation: property_presentation)
+                   end
+
+        product_property = if ProductProperty.where(product: self, property: property).exists?
+                             ProductProperty.where(product: self, property: property).first
+                           else
+                             ProductProperty.create(product: self, property: property)
+                           end
+
         product_property.value = property_value
         product_property.save!
       end
     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 +359,34 @@ module Spree
     end
 
     def brand
-      taxons.joins(:taxonomy).find_by(spree_taxonomies: { name: Spree.t(:taxonomy_brands_name) })
+      @brand ||= taxons.joins(:taxonomy).
+                 join_translation_table(Taxonomy).
+                 find_by(Taxonomy.translation_table_alias => { 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).
+                    join_translation_table(Taxonomy).
+                    order(depth: :desc).
+                    find_by(Taxonomy.translation_table_alias => { 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 +394,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 +423,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
@@ -336,7 +442,11 @@ module Spree
 
     def punch_slug
       # punch slug with date prefix to allow reuse of original
-      update_column :slug, "#{Time.current.to_i}_#{slug}"[0..254] unless frozen?
+      return if frozen?
+
+      translations.with_deleted.each do |t|
+        t.update_column :slug, "#{Time.current.to_i}_#{t.slug}"[0..254]
+      end
     end
 
     def update_slug_history
@@ -381,8 +491,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 +520,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 +534,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 +546,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,54 @@
 module Spree
   class ProductProperty < Spree::Base
+    include Spree::FilterParam
+    include TranslatableResource
+
+    TRANSLATABLE_FIELDS = %i[value filter_param].freeze
+    translates(*TRANSLATABLE_FIELDS)
+
+    self::Translation.class_eval do
+      auto_strip_attributes :value
+    end
+
     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)
+        self.property = if Property.where(name: name).exists?
+                          Property.where(name: name).first
+                        else
+                          Property.create(name: name, presentation: name)
+                        end
       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