solidus_core 3.1.6 → 3.2.0

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]
@@ -83,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/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

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
@@ -67,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
@@ -151,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?
@@ -163,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
@@ -190,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, exclude_canceled: true).
-        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)
@@ -215,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
@@ -251,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

data/app/models/spree/promotion_code.rb

@@ -28,10 +28,14 @@ class Spree::PromotionCode < Spree::Base
   # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage count
   # @return [Integer] usage count
   def usage_count(excluded_orders: [])
-    adjustments.
-    eligible.
-    in_completed_orders(excluded_orders: excluded_orders, exclude_canceled: true).
-    count(:order_id)
+    promotion.
+      discounted_orders.
+      complete.
+      where.not(spree_orders: { state: :canceled }).
+      joins(:order_promotions).
+      where(spree_orders_promotions: { promotion_code_id: self.id }).
+      where.not(id: excluded_orders.map(&:id)).
+      count
   end
 
   def usage_limit

data/app/models/spree/promotion_handler/cart.rb

@@ -33,23 +33,43 @@ module Spree
       private
 
       def promotions
-        connected_order_promotions | sale_promotions
+        promos = connected_order_promotions | sale_promotions
+        promos.flat_map(&:promotion_actions).group_by(&:preload_relations).each do |preload_relations, actions|
+          preload(records: actions, associations: preload_relations)
+        end
+        promos.flat_map(&:promotion_rules).group_by(&:preload_relations).each do |preload_relations, rules|
+          preload(records: rules, associations: preload_relations)
+        end
+        promos
+      end
+
+      def preload(records:, associations:)
+        if Rails::VERSION::MAJOR >= 7
+          ActiveRecord::Associations::Preloader.new(records: records, associations: associations).call
+        else
+          ActiveRecord::Associations::Preloader.new.preload(records, associations)
+        end
       end
 
       def connected_order_promotions
-        Spree::Promotion.active.includes(:promotion_rules).
-          joins(:order_promotions).
-          where(spree_orders_promotions: { order_id: order.id }).readonly(false).to_a
+        order.promotions.active.includes(promotion_includes)
       end
 
       def sale_promotions
-        Spree::Promotion.where(apply_automatically: true).active.includes(:promotion_rules)
+        Spree::Promotion.where(apply_automatically: true).active.includes(promotion_includes)
       end
 
       def promotion_code(promotion)
-        order_promotion = Spree::OrderPromotion.where(order: order, promotion: promotion).first
+        order_promotion = order.order_promotions.detect { |op| op.promotion_id == promotion.id }
         order_promotion.present? ? order_promotion.promotion_code : nil
       end
+
+      def promotion_includes
+        [
+          :promotion_rules,
+          :promotion_actions,
+        ]
+      end
     end
   end
 end

data/app/models/spree/promotion_rule.rb

@@ -14,9 +14,14 @@ module Spree
     validates :promotion, presence: true
     validate :unique_per_promotion, on: :create
 
+    def preload_relations
+      []
+    end
+
     def self.for(promotable)
       all.select { |rule| rule.applicable?(promotable) }
     end
+    deprecate :for, "Please select promotion rules by their applicable status on the promotable instead."
 
     def applicable?(_promotable)
       raise NotImplementedError, "applicable? should be implemented in a sub-class of Spree::PromotionRule"

data/app/models/spree/reimbursement.rb

@@ -92,10 +92,10 @@ module Spree
 
       if unpaid_amount_within_tolerance?
         reimbursed!
-        Spree::Event.fire 'reimbursement_reimbursed', reimbursement: self
+        Spree::Bus.publish :reimbursement_reimbursed, reimbursement: self
       else
         errored!
-        Spree::Event.fire 'reimbursement_errored', reimbursement: self
+        Spree::Bus.publish :reimbursement_errored, reimbursement: self
       end
 
       if errored?

data/app/models/spree/return_item.rb

@@ -30,7 +30,7 @@ module Spree
     self.refund_amount_calculator = Calculator::Returns::DefaultRefundAmount
 
     belongs_to :return_authorization, inverse_of: :return_items, optional: true
-    belongs_to :inventory_unit, inverse_of: :return_items, optional: true
+    belongs_to :inventory_unit, inverse_of: :return_items
     belongs_to :exchange_variant, class_name: 'Spree::Variant', optional: true
     belongs_to :exchange_inventory_unit, class_name: 'Spree::InventoryUnit', inverse_of: :original_return_item, optional: true
     belongs_to :customer_return, inverse_of: :return_items, optional: true
@@ -42,7 +42,6 @@ module Spree
     validate :eligible_exchange_variant
     validate :belongs_to_same_customer_order
     validate :validate_acceptance_status_for_reimbursement
-    validates :inventory_unit, presence: true
     validate :validate_no_other_completed_return_items
 
     after_create :cancel_others, unless: :cancelled?

data/app/models/spree/stock/allocator/on_hand_first.rb

@@ -7,11 +7,11 @@ module Spree
         def allocate_inventory(desired)
           # Allocate any available on hand inventory
           on_hand = allocate_on_hand(desired)
-          desired -= on_hand.values.sum if on_hand.present?
+          desired -= on_hand.values.reduce(&:+) if on_hand.present?
 
           # Allocate remaining desired inventory from backorders
           backordered = allocate_backordered(desired)
-          desired -= backordered.values.sum if backordered.present?
+          desired -= backordered.values.reduce(&:+) if backordered.present?
 
           # If all works at this point desired must be empty
           [on_hand, backordered, desired]

data/app/models/spree/stock/quantifier.rb

@@ -6,14 +6,18 @@ module Spree
       attr_reader :stock_items
 
       # @param [Variant] variant The variant to check inventory for.
-      # @param [StockLocation, Integer] stock_location The stock_location to check inventory in. If unspecified it will check inventory in all available StockLocations
-      def initialize(variant, stock_location = nil)
+      # @param [StockLocation, Integer] stock_location_or_id
+      #        The stock_location or stock location ID to check inventory in.
+      #        If unspecified it will check inventory in all available StockLocations
+      def initialize(variant, stock_location_or_id = nil)
         @variant = variant
-        @stock_items = Spree::StockItem.where(variant_id: variant)
-        if stock_location
-          @stock_items.where!(stock_location: stock_location)
-        else
-          @stock_items.joins!(:stock_location).merge!(Spree::StockLocation.active)
+        @stock_items = variant.stock_items.select do |stock_item|
+          if stock_location_or_id
+            stock_item.stock_location == stock_location_or_id ||
+              stock_item.stock_location_id == stock_location_or_id
+          else
+            stock_item.stock_location.active?
+          end
         end
       end
 
@@ -23,7 +27,7 @@ module Spree
       #   inventory is not tracked on the variant.
       def total_on_hand
         if @variant.should_track_inventory?
-          stock_items.sum(:count_on_hand)
+          stock_items.sum(&:count_on_hand)
         else
           Float::INFINITY
         end

data/app/models/spree/stock/simple_coordinator.rb

@@ -24,7 +24,8 @@ module Spree
 
       def initialize(order, inventory_units = nil)
         @order = order
-        @inventory_units = inventory_units || InventoryUnitBuilder.new(order).units
+        @inventory_units =
+          inventory_units || Spree::Config.stock.inventory_unit_builder_class.new(order).units
         @splitters = Spree::Config.environment.stock_splitters
 
         filtered_stock_locations = Spree::Config.stock.location_filter_class.new(Spree::StockLocation.all, @order).filter

data/app/models/spree/tax/item_tax.rb

@@ -5,9 +5,10 @@ module Spree
     # Simple object used to hold tax data for an item.
     #
     # This generic object will hold the amount of tax that should be applied to
-    # an item. (Either a {Spree::LineItem} or a {Spree::Shipment}.)
+    # an item. (Either a {Spree::Order}, a {Spree::LineItem} or a {Spree::Shipment}.)
     #
-    # @attr_reader [Integer] item_id the {Spree::LineItem} or {Spree::Shipment} ID
+    # @attr_reader [Integer] item_id the {Spree::LineItem} or {Spree::Shipment} ID.
+    #   Or blank if an order-level tax.
     # @attr_reader [String] label information about the taxes
     # @attr_reader [Spree::TaxRate] tax_rate will be used as the source for tax
     #   adjustments

data/app/models/spree/tax/order_tax.rb

@@ -8,13 +8,15 @@ module Spree
     # adjustments on an order.
     #
     # @attr_reader [Integer] order_id the {Spree::Order} these taxes apply to
+    # @attr_reader [Array<Spree::Tax::ItemTax>] order_taxes an array of tax
+    #   data for the order
     # @attr_reader [Array<Spree::Tax::ItemTax>] line_item_taxes an array of
     #   tax data for order's line items
     # @attr_reader [Array<Spree::Tax::ItemTax>] shipment_taxes an array of
     #   tax data for the order's shipments
     class OrderTax
       include ActiveModel::Model
-      attr_accessor :order_id, :line_item_taxes, :shipment_taxes
+      attr_accessor :order_id, :order_taxes, :line_item_taxes, :shipment_taxes
     end
   end
 end

data/app/models/spree/tax/tax_location.rb

@@ -8,7 +8,7 @@ module Spree
     # @attr_reader [Integer] country_id the ID of a Spree::Country object
     # @attr_reader [Integer] state_id the ID of a Spree::State object
     class TaxLocation
-      attr_reader :country_id, :state_id
+      attr_reader :country, :state
 
       # Create a new TaxLocation object
       #
@@ -19,18 +19,15 @@ module Spree
       #
       # @return [Spree::Tax::TaxLocation] a Spree::Tax::TaxLocation object
       def initialize(country: nil, state: nil)
-        @country_id = country && country.id
-        @state_id = state && state.id
+        @country, @state = country, state
       end
+      delegate :id, to: :state, prefix: true, allow_nil: true
+      delegate :id, to: :country, prefix: true, allow_nil: true
 
       def ==(other)
         state_id == other.state_id && country_id == other.country_id
       end
 
-      def country
-        Spree::Country.find_by(id: country_id)
-      end
-
       def empty?
         country_id.nil? && state_id.nil?
       end

data/app/models/spree/tax_rate.rb

@@ -27,6 +27,8 @@ module Spree
 
     validates :amount, presence: true, numericality: true
 
+    self.whitelisted_ransackable_associations = %w[tax_categories zone]
+
     # Finds all tax rates whose zones match a given address
     scope :for_address, ->(address) { joins(:zone).merge(Spree::Zone.for_address(address)) }
     scope :for_country,

data/app/models/spree/variant.rb

@@ -66,7 +66,7 @@ module Spree
 
     validates :cost_price, numericality: { greater_than_or_equal_to: 0, allow_nil: true }
     validates :price,      numericality: { greater_than_or_equal_to: 0, allow_nil: true }
-    validates_uniqueness_of :sku, allow_blank: true, case_sensitive: true, if: :enforce_unique_sku?
+    validates_uniqueness_of :sku, allow_blank: true, case_sensitive: true, conditions: -> { where(deleted_at: nil) }, if: :enforce_unique_sku?
 
     after_create :create_stock_items
     after_create :set_position

data/app/subscribers/spree/mailer_subscriber.rb

@@ -3,6 +3,10 @@
 require 'spree/event/subscriber'
 
 module Spree
+  # Legacy subscriber
+  #
+  # This subscriber module is used by the legacy pub/sub system (see
+  # {Spree::Event}).
   module MailerSubscriber
     include Spree::Event::Subscriber
 

data/app/subscribers/spree/order_mailer_subscriber.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Spree
+  # Mailing after events on a {Spree::Order}
+  class OrderMailerSubscriber
+    include Omnes::Subscriber
+
+    handle :order_finalized,
+           with: :send_confirmation_email,
+           id: :spree_order_mailer_send_confirmation_email
+
+    handle :reimbursement_reimbursed,
+           with: :send_reimbursement_email,
+           id: :spree_order_mailer_send_reimbursement_email
+
+    # Sends confirmation email to the user
+    #
+    # @param event [Omnes::UnstructuredEvent]
+    def send_confirmation_email(event)
+      order = event[:order]
+      unless order.confirmation_delivered?
+        Spree::Config.order_mailer_class.confirm_email(order).deliver_later
+        order.update_column(:confirmation_delivered, true)
+      end
+    end
+
+    # Sends reimbursement email to the user
+    #
+    # @param event [Omnes::UnstructuredEvent]
+    def send_reimbursement_email(event)
+      reimbursement = event[:reimbursement]
+      Spree::Config.reimbursement_mailer_class.reimbursement_email(reimbursement.id).deliver_later
+    end
+  end
+end