solidus_core 2.11.10 → 3.3.1

data/app/models/spree/product.rb

@@ -5,10 +5,6 @@ module Spree
   # variations, called variants. Product properties include description,
   # permalink, availability, shipping category, etc. that do not change by
   # variant.
-  #
-  # @note this model uses {https://github.com/radar/paranoia paranoia}.
-  #   +#destroy+ will only soft-destroy records and the default scope hides
-  #   soft-destroyed records using +WHERE deleted_at IS NULL+.
   class Product < Spree::Base
     extend FriendlyId
     friendly_id :slug_candidates, use: :history
@@ -65,6 +61,17 @@ module Spree
     has_many :line_items, through: :variants_including_master
     has_many :orders, through: :line_items
 
+    scope :sort_by_master_default_price_amount_asc, -> {
+      with_default_price.order('spree_prices.amount ASC')
+    }
+    scope :sort_by_master_default_price_amount_desc, -> {
+      with_default_price.order('spree_prices.amount DESC')
+    }
+    scope :with_default_price, -> {
+      left_joins(master: :prices)
+        .where(master: { spree_prices: Spree::Config.default_pricing_options.desired_attributes })
+    }
+
     def find_or_build_master
       master || build_master
     end
@@ -89,7 +96,7 @@ module Spree
              :has_default_price?,
              :images,
              :price_for,
-             :price_in,
+             :price_for_options,
              :rebuild_vat_prices=,
              to: :find_or_build_master
 
@@ -124,11 +131,11 @@ module Spree
 
     alias :options :product_option_types
 
-    self.whitelisted_ransackable_associations = %w[stores variants_including_master master variants]
-    self.whitelisted_ransackable_attributes = %w[name slug]
+    self.allowed_ransackable_associations = %w[stores variants_including_master master variants]
+    self.allowed_ransackable_attributes = %w[name slug]
 
     def self.ransackable_scopes(_auth_object = nil)
-      %i(with_discarded with_variant_sku_cont)
+      %i(available with_discarded with_variant_sku_cont with_all_variant_sku_cont with_kept_variant_sku_cont)
     end
 
     # @return [Boolean] true if there are any variants
@@ -186,19 +193,6 @@ module Spree
       !!discontinue_on&.past?
     end
 
-    # Groups variants by the specified option type.
-    #
-    # @deprecated This method is not called in the Solidus codebase
-    # @param opt_type [String] the name of the option type to group by
-    # @param pricing_options [Spree::Config.pricing_options_class] the pricing options to search
-    #   for, default: the default pricing options
-    # @return [Hash] option_type as keys, array of variants as values.
-    def categorise_variants_from_option(opt_type, pricing_options = Spree::Config.default_pricing_options)
-      return {} unless option_types.include?(opt_type)
-      variants.with_prices(pricing_options).group_by { |variant| variant.option_values.detect { |option| option.option_type == opt_type } }
-    end
-    deprecate :categorise_variants_from_option, deprecator: Spree::Deprecation
-
     # Poor man's full text search.
     #
     # Filters products to those which have any of the strings in +values+ in
@@ -214,17 +208,6 @@ module Spree
       where conditions.inject(:or)
     end
 
-    # @param current_currency [String] currency to filter variants by; defaults to Spree's default
-    # @deprecated This method can only handle prices for currencies
-    # @return [Array<Spree::Variant>] all variants with at least one option value
-    def variants_and_option_values(current_currency = nil)
-      variants.includes(:option_values).active(current_currency).select do |variant|
-        variant.option_values.any?
-      end
-    end
-    deprecate variants_and_option_values: :variants_and_option_values_for,
-              deprecator: Spree::Deprecation
-
     # @param pricing_options [Spree::Variant::PricingOptions] the pricing options to search
     #   for, default: the default pricing options
     # @return [Array<Spree::Variant>] all variants with at least one option value
@@ -296,16 +279,6 @@ module Spree
       end
     end
 
-    # Image that can be used for the product.
-    #
-    # Will first search for images on the product, then those belonging to the
-    # variants. If all else fails, will return a new image object.
-    # @return [Spree::Image] the image to display
-    def display_image
-      Spree::Deprecation.warn('Spree::Product#display_image is DEPRECATED. Choose an image from Spree::Product#gallery instead.')
-      images.first || variant_images.first || Spree::Image.new
-    end
-
     # Finds the variant property rule that matches the provided option value ids.
     #
     # @param option_value_ids [Array<Integer>] list of option value ids

data/app/models/spree/product_property.rb

@@ -9,6 +9,6 @@ module Spree
     belongs_to :product, touch: true, class_name: 'Spree::Product', inverse_of: :product_properties, optional: true
     belongs_to :property, class_name: 'Spree::Property', inverse_of: :product_properties, optional: true
 
-    self.whitelisted_ransackable_attributes = ['value']
+    self.allowed_ransackable_attributes = ['value']
   end
 end

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

@@ -15,6 +15,10 @@ module Spree
         before_destroy :remove_adjustments_from_incomplete_orders
         before_discard :remove_adjustments_from_incomplete_orders
 
+        def preload_relations
+          [:calculator]
+        end
+
         # Creates the adjustment related to a promotion for the order passed
         # through options hash
         #
@@ -39,9 +43,6 @@ module Spree
         # item_total and ship_total
         def compute_amount(calculable)
           amount = calculator.compute(calculable)
-          if !amount.is_a?(BigDecimal)
-            Spree::Deprecation.warn "#{calculator.class.name}#compute returned #{amount.inspect}, it should return a BigDecimal"
-          end
           amount ||= BigDecimal(0)
           amount = amount.abs
           [(calculable.item_total + calculable.ship_total), amount].min * -1

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

@@ -15,6 +15,10 @@ module Spree
         before_destroy :remove_adjustments_from_incomplete_orders
         before_discard :remove_adjustments_from_incomplete_orders
 
+        def preload_relations
+          [:calculator]
+        end
+
         def perform(payload = {})
           order = payload[:order]
           promotion = payload[:promotion]
@@ -33,9 +37,6 @@ module Spree
           order = adjustable.is_a?(Order) ? adjustable : adjustable.order
           return 0 unless promotion.line_item_actionable?(order, adjustable)
           promotion_amount = calculator.compute(adjustable)
-          if !promotion_amount.is_a?(BigDecimal)
-            Spree::Deprecation.warn "#{calculator.class.name}#compute returned #{promotion_amount.inspect}, it should return a BigDecimal"
-          end
           promotion_amount ||= BigDecimal(0)
           promotion_amount = promotion_amount.abs
           [adjustable.amount, promotion_amount].min * -1
@@ -86,13 +87,8 @@ module Spree
         end
 
         def line_items_to_adjust(promotion, order)
-          excluded_ids = adjustments.
-            where(adjustable_id: order.line_items.pluck(:id), adjustable_type: 'Spree::LineItem').
-            pluck(:adjustable_id).
-            to_set
-
           order.line_items.select do |line_item|
-            !excluded_ids.include?(line_item.id) &&
+            line_item.adjustments.none? { |adjustment| adjustment.source == self } &&
               promotion.line_item_actionable?(order, line_item)
           end
         end

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

@@ -57,9 +57,6 @@ module Spree
         #
         def compute_amount(line_item)
           adjustment_amount = calculator.compute(PartialLineItem.new(line_item))
-          if !adjustment_amount.is_a?(BigDecimal)
-            Spree::Deprecation.warn "#{calculator.class.name}#compute returned #{adjustment_amount.inspect}, it should return a BigDecimal"
-          end
           adjustment_amount ||= BigDecimal(0)
           adjustment_amount = adjustment_amount.abs
 

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

@@ -7,6 +7,7 @@ module Spree
         def perform(payload = {})
           order = payload[:order]
           promotion_code = payload[:promotion_code]
+          return false unless promotion.eligible? order
 
           created_adjustments = order.shipments.map do |shipment|
             next if promotion_credit_exists?(shipment)

data/app/models/spree/promotion/order_adjustments_recalculator.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Spree
+  class Promotion < Spree::Base
+
+    # This class encapsulates all the things the promotion system does to
+    # an order. It is called from the `Spree::OrderUpdater` before taxes are
+    # calculated, such that taxes always respect promotions.
+
+    # This class iterates over all existing promotion adjustments and recalculates
+    # their amount and eligibility using their adjustment source.
+    class OrderAdjustmentsRecalculator
+      def initialize(order)
+        @order = order
+      end
+
+      def call
+        all_items = line_items + shipments
+        all_items.each do |item|
+          promotion_adjustments = item.adjustments.select(&:promotion?)
+
+          promotion_adjustments.each { |adjustment| recalculate(adjustment) }
+          Spree::Config.promotion_chooser_class.new(promotion_adjustments).update
+
+          item.promo_total = promotion_adjustments.select(&:eligible?).sum(&:amount)
+        end
+        # Update and select the best promotion adjustment for the order.
+        # We don't update the order.promo_total yet. Order totals are updated later
+        # in #update_adjustment_total since they include the totals from the order's
+        # line items and/or shipments.
+        order_promotion_adjustments = order.adjustments.select(&:promotion?)
+        order_promotion_adjustments.each { |adjustment| recalculate(adjustment) }
+        Spree::Config.promotion_chooser_class.new(order_promotion_adjustments).update
+
+        order.promo_total = all_items.sum(&:promo_total) +
+                            order_promotion_adjustments.
+                              select(&:eligible?).
+                              select(&:promotion?).
+                              sum(&:amount)
+        order
+      end
+
+      private
+
+      attr_reader :order
+      delegate :line_items, :shipments, to: :order
+
+      # Recalculate and persist the amount from this adjustment's source based on
+      # the adjustable ({Order}, {Shipment}, or {LineItem})
+      #
+      # If the adjustment has no source (such as when created manually from the
+      # admin) or is closed, this is a noop.
+      #
+      # @return [BigDecimal] New amount of this adjustment
+      def recalculate(adjustment)
+        if adjustment.finalized?
+          return adjustment.amount
+        end
+
+        # If the adjustment has no source, do not attempt to re-calculate the
+        # amount.
+        # Some scenarios where this happens:
+        #   - Adjustments that are manually created via the admin backend
+        #   - PromotionAction adjustments where the PromotionAction was deleted
+        #     after the order was completed.
+        if adjustment.source.present?
+          adjustment.amount = adjustment.source.compute_amount(adjustment.adjustable)
+
+          adjustment.eligible = calculate_eligibility(adjustment)
+
+          # Persist only if changed
+          # This is only not a save! to avoid the extra queries to load the order
+          # (for validations) and to touch the adjustment.
+          adjustment.update_columns(eligible: adjustment.eligible, amount: adjustment.amount, updated_at: Time.current) if adjustment.changed?
+        end
+        adjustment.amount
+      end
+
+      # Calculates based on attached promotion (if this is a promotion
+      # adjustment) whether this promotion is still eligible.
+      # @api private
+      # @return [true,false] Whether this adjustment is eligible
+      def calculate_eligibility(adjustment)
+        if !adjustment.finalized? && adjustment.source
+          adjustment.source.promotion.eligible?(adjustment.adjustable, promotion_code: adjustment.promotion_code)
+        else
+          adjustment.eligible?
+        end
+      end
+    end
+  end
+end

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

@@ -5,12 +5,38 @@ module Spree
     module Rules
       # A rule to apply to an order greater than (or greater than or equal to)
       # a specific amount
+      #
+      # To add extra operators please override `self.operators_map` or any other helper method.
+      # To customize the error message you can also override `ineligible_message`.
       class ItemTotal < PromotionRule
+        include ActiveSupport::Deprecation::DeprecatedConstantAccessor
+
         preference :amount, :decimal, default: 100.00
         preference :currency, :string, default: ->{ Spree::Config[:currency] }
-        preference :operator, :string, default: '>'
+        preference :operator, :string, default: 'gt'
+
+        # The list of allowed operators names mapped to their symbols.
+        def self.operators_map
+          {
+            gte: :>=,
+            gt: :>,
+          }
+        end
+
+        def self.operator_options
+          operators_map.map do |name, _method|
+            [I18n.t(name, scope: 'spree.item_total_rule.operators'), name]
+          end
+        end
 
-        OPERATORS = ['gt', 'gte']
+        # @deprecated
+        OPERATORS = operators_map.keys.map(&:to_s)
+        deprecate_constant(
+          :OPERATORS,
+          :operators_map,
+          message: "OPERATORS is deprecated! Use `operators_map.keys.map(&:to_s)` instead.",
+          deprecator: Spree::Deprecation,
+        )
 
         def applicable?(promotable)
           promotable.is_a?(Spree::Order)
@@ -18,8 +44,8 @@ module Spree
 
         def eligible?(order, _options = {})
           return false unless order.currency == preferred_currency
-          item_total = order.item_total
-          unless item_total.send(preferred_operator == 'gte' ? :>= : :>, BigDecimal(preferred_amount.to_s))
+
+          unless total_for_order(order).send(operator, threshold)
             eligibility_errors.add(:base, ineligible_message, error_code: ineligible_error_code)
           end
 
@@ -28,15 +54,33 @@ module Spree
 
         private
 
+        def operator
+          self.class.operators_map.fetch(
+            preferred_operator.to_sym,
+            preferred_operator_default,
+          )
+        end
+
+        def total_for_order(order)
+          order.item_total
+        end
+
+        def threshold
+          BigDecimal(preferred_amount.to_s)
+        end
+
         def formatted_amount
           Spree::Money.new(preferred_amount, currency: preferred_currency).to_s
         end
 
         def ineligible_message
-          if preferred_operator == 'gte'
+          case preferred_operator.to_s
+          when 'gte'
             eligibility_error_message(:item_total_less_than, amount: formatted_amount)
-          else
+          when 'gt'
             eligibility_error_message(:item_total_less_than_or_equal, amount: formatted_amount)
+          else
+            eligibility_error_message(:item_total_doesnt_match_with_operator, amount: formatted_amount, operator: preferred_operator)
           end
         end
 

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

@@ -12,6 +12,10 @@ module Spree
                                            class_name: 'Spree::ProductPromotionRule'
         has_many :products, class_name: 'Spree::Product', through: :product_promotion_rules
 
+        def preload_relations
+          [:products]
+        end
+
         MATCH_POLICIES = %w(any all none)
 
         validates_inclusion_of :preferred_match_policy, in: MATCH_POLICIES
@@ -31,17 +35,19 @@ module Spree
           return true if eligible_products.empty?
 
           case preferred_match_policy
-          when 'all'
-            unless eligible_products.all? { |product| order.products.include?(product) }
+          when "all"
+            unless eligible_products.all? { |product| order_products(order).include?(product) }
               eligibility_errors.add(:base, eligibility_error_message(:missing_product), error_code: :missing_product)
             end
-          when 'any'
-            unless order.products.any? { |product| eligible_products.include?(product) }
-              eligibility_errors.add(:base, eligibility_error_message(:no_applicable_products), error_code: :no_applicable_products)
+          when "any"
+            unless order_products(order).any? { |product| eligible_products.include?(product) }
+              eligibility_errors.add(:base, eligibility_error_message(:no_applicable_products),
+                                     error_code: :no_applicable_products)
             end
-          when 'none'
-            unless order.products.none? { |product| eligible_products.include?(product) }
-              eligibility_errors.add(:base, eligibility_error_message(:has_excluded_product), error_code: :has_excluded_product)
+          when "none"
+            unless order_products(order).none? { |product| eligible_products.include?(product) }
+              eligibility_errors.add(:base, eligibility_error_message(:has_excluded_product),
+                                     error_code: :has_excluded_product)
             end
           else
             raise "unexpected match policy: #{preferred_match_policy.inspect}"
@@ -68,6 +74,12 @@ module Spree
         def product_ids_string=(product_ids)
           self.product_ids = product_ids.to_s.split(',').map(&:strip)
         end
+
+        private
+
+        def order_products(order)
+          order.line_items.map(&:variant).map(&:product)
+        end
       end
     end
   end

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

@@ -9,6 +9,10 @@ module Spree
                                          dependent: :destroy
         has_many :stores, through: :promotion_rule_stores, class_name: "Spree::Store"
 
+        def preload_relations
+          [:stores]
+        end
+
         def applicable?(promotable)
           promotable.is_a?(Spree::Order)
         end

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

@@ -8,6 +8,10 @@ module Spree
           dependent: :destroy
         has_many :taxons, through: :promotion_rule_taxons, class_name: 'Spree::Taxon'
 
+        def preload_relations
+          [:taxons]
+        end
+
         MATCH_POLICIES = %w(any all none)
 
         validates_inclusion_of :preferred_match_policy, in: MATCH_POLICIES
@@ -38,11 +42,7 @@ module Spree
               eligibility_errors.add(:base, eligibility_error_message(:has_excluded_taxon), error_code: :has_excluded_taxon)
             end
           else
-            # Change this to an exception in a future version of Solidus
-            warn_invalid_match_policy(assume: 'any')
-            unless order_taxons.where(id: rule_taxon_ids_with_children).exists?
-              eligibility_errors.add(:base, eligibility_error_message(:no_matching_taxons), error_code: :no_matching_taxons)
-            end
+            raise "unexpected match policy: #{preferred_match_policy.inspect}"
           end
 
           eligibility_errors.empty?
@@ -60,9 +60,7 @@ module Spree
           when 'none'
             !found
           else
-            # Change this to an exception in a future version of Solidus
-            warn_invalid_match_policy(assume: 'any')
-            found
+            raise "unexpected match policy: #{preferred_match_policy.inspect}"
           end
         end
 
@@ -77,13 +75,6 @@ module Spree
 
         private
 
-        def warn_invalid_match_policy(assume:)
-          Spree::Deprecation.warn(
-            "#{self.class.name} id=#{id} has unexpected match policy #{preferred_match_policy.inspect}. "\
-            "Interpreting it as '#{assume}'."
-          )
-        end
-
         # All taxons in an order
         def taxons_in_order(order)
           Spree::Taxon.joins(products: { variants_including_master: :line_items })

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

@@ -9,6 +9,10 @@ module Spree
                                         dependent: :destroy
         has_many :users, through: :promotion_rule_users, class_name: Spree::UserClassHandle.new
 
+        def preload_relations
+          [:users]
+        end
+
         def applicable?(promotable)
           promotable.is_a?(Spree::Order)
         end

data/app/models/spree/promotion.rb

@@ -3,6 +3,7 @@
 module Spree
   class Promotion < Spree::Base
     MATCH_POLICIES = %w(all any)
+
     UNACTIVATABLE_ORDER_STATES = ["complete", "awaiting_return", "returned"]
 
     attr_reader :eligibility_errors
@@ -38,11 +39,7 @@ module Spree
 
     scope :coupons, -> { joins(:codes).distinct }
     scope :advertised, -> { where(advertise: true) }
-    scope :active, -> do
-      return started_and_unexpired if Spree::Config.consider_actionless_promotion_active == true
-
-      has_actions.started_and_unexpired
-    end
+    scope :active, -> { has_actions.started_and_unexpired }
     scope :started_and_unexpired, -> do
       table = arel_table
       time = Time.current
@@ -51,12 +48,12 @@ module Spree
         where(table[:expires_at].eq(nil).or(table[:expires_at].gt(time)))
     end
     scope :has_actions, -> do
-      joins(:promotion_actions)
+      joins(:promotion_actions).distinct
     end
     scope :applied, -> { joins(:order_promotions).distinct }
 
-    self.whitelisted_ransackable_associations = ['codes']
-    self.whitelisted_ransackable_attributes = %w[name path promotion_category_id]
+    self.allowed_ransackable_associations = ['codes']
+    self.allowed_ransackable_attributes = %w[name path promotion_category_id]
     def self.ransackable_scopes(*)
       %i(active)
     end
@@ -71,6 +68,19 @@ module Spree
       ).first
     end
 
+    # All orders that have been discounted using this promotion
+    def discounted_orders
+      Spree::Order.
+        joins(:all_adjustments).
+        where(
+          spree_adjustments: {
+            source_type: "Spree::PromotionAction",
+            source_id: actions.map(&:id),
+            eligible: true
+          }
+        ).distinct
+    end
+
     def as_json(options = {})
       options[:except] ||= :code
       super
@@ -93,7 +103,7 @@ module Spree
     end
 
     def active?
-      started? && not_expired? && (Spree::Config.consider_actionless_promotion_active || actions.present?)
+      started? && not_expired? && actions.present?
     end
 
     def inactive?
@@ -155,7 +165,7 @@ module Spree
       return [] if rules.none?
 
       eligible = lambda { |rule| rule.eligible?(promotable, options) }
-      specific_rules = rules.for(promotable)
+      specific_rules = rules.select { |rule| rule.applicable?(promotable) }
       return [] if specific_rules.none?
 
       if match_all?
@@ -167,6 +177,12 @@ module Spree
         end
         specific_rules
       else
+        Spree::Deprecation.warn(
+        <<~WARN
+          Your promotion "#{name}" with ID #{id} has a match_policy of 'any'.
+          This is deprecated, please split the promotion into separate promotions for each rule.
+        WARN
+        )
         unless specific_rules.any?(&eligible)
           @eligibility_errors = specific_rules.map(&:eligibility_errors).detect(&:present?)
           return nil
@@ -194,11 +210,11 @@ module Spree
     # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage count
     # @return [Integer] usage count
     def usage_count(excluded_orders: [])
-      Spree::Adjustment.promotion.
-        eligible.
-        in_completed_orders(excluded_orders: excluded_orders).
-        where(source_id: actions).
-        count(:order_id)
+      discounted_orders.
+        complete.
+        where.not(id: [excluded_orders.map(&:id)]).
+        where.not(spree_orders: { state: :canceled }).
+        count
     end
 
     def line_item_actionable?(order, line_item, promotion_code: nil)
@@ -219,21 +235,12 @@ 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
+      discounted_orders.
+        complete.
+        where.not(id: excluded_orders.map(&:id)).
+        where(user: user).
+        where.not(spree_orders: { state: :canceled }).
+        exists?
     end
 
     # Removes a promotion and any adjustments or other side effects from an
@@ -255,9 +262,9 @@ module Spree
     def blacklisted?(promotable)
       case promotable
       when Spree::LineItem
-        !promotable.product.promotionable?
+        !promotable.variant.product.promotionable?
       when Spree::Order
-        promotable.line_items.joins(:product).where(spree_products: { promotionable: false }).exists?
+        promotable.line_items.any? { |line_item| !line_item.variant.product.promotionable? }
       end
     end
 

data/app/models/spree/promotion_action.rb

@@ -16,6 +16,10 @@ module Spree
     scope :of_type, ->(type) { where(type: Array.wrap(type).map(&:to_s)) }
     scope :shipping, -> { of_type(Spree::Config.environment.promotions.shipping_actions.to_a) }
 
+    def preload_relations
+      []
+    end
+
     # 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
@@ -32,15 +36,8 @@ module Spree
     #
     # @param order [Spree::Order] the order to remove the action from
     # @return [void]
-    def remove_from(order)
-      Spree::Deprecation.warn("#{self.class.name.inspect} does not define #remove_from. The default behavior may be incorrect and will be removed in a future version of Solidus.", caller)
-      [order, *order.line_items, *order.shipments].each do |item|
-        item.adjustments.each do |adjustment|
-          if adjustment.source == self
-            item.adjustments.destroy(adjustment)
-          end
-        end
-      end
+    def remove_from(_order)
+      raise 'remove_from should be implemented in a sub-class of PromotionAction'
     end
 
     def to_partial_path