solidus_core 3.0.0 → 4.5.1

data/app/models/spree/order.rb

@@ -26,6 +26,7 @@ module Spree
     include ::Spree::Config.state_machines.order
 
     include Spree::Order::Payments
+    include Metadata
 
     class InsufficientStock < StandardError
       attr_reader :items
@@ -38,9 +39,21 @@ module Spree
     class CannotRebuildShipments < StandardError; end
 
     extend Spree::DisplayMoney
-    money_methods :outstanding_balance, :item_total, :adjustment_total,
-      :included_tax_total, :additional_tax_total, :tax_total,
-      :shipment_total, :total, :order_total_after_store_credit, :total_available_store_credit
+    money_methods(
+      :outstanding_balance,
+      :item_total,
+      :adjustment_total,
+      :included_tax_total,
+      :additional_tax_total,
+      :tax_total,
+      :shipment_total,
+      :total,
+      :order_total_after_store_credit,
+      :total_available_store_credit,
+      :item_total_before_tax,
+      :shipment_total_before_tax,
+      :item_total_excluding_vat
+    )
     alias :display_ship_total :display_shipment_total
 
     checkout_flow do
@@ -50,8 +63,8 @@ module Spree
       go_to_state :confirm
     end
 
-    self.whitelisted_ransackable_associations = %w[shipments user order_promotions promotions bill_address ship_address line_items]
-    self.whitelisted_ransackable_attributes = %w[bill_address_name completed_at created_at email number state payment_state shipment_state total store_id]
+    self.allowed_ransackable_associations = %w[shipments user bill_address ship_address line_items]
+    self.allowed_ransackable_attributes = %w[completed_at created_at email number state payment_state shipment_state total store_id]
 
     attr_reader :coupon_code
     attr_accessor :temporary_address
@@ -60,11 +73,15 @@ module Spree
 
     # Customer info
     belongs_to :user, class_name: Spree::UserClassHandle.new, optional: true
+
     belongs_to :bill_address, foreign_key: :bill_address_id, class_name: 'Spree::Address', optional: true
-    alias_attribute :billing_address, :bill_address
+    alias_method :billing_address, :bill_address
+    alias_method :billing_address=, :bill_address=
 
     belongs_to :ship_address, foreign_key: :ship_address_id, class_name: 'Spree::Address', optional: true
-    alias_attribute :shipping_address, :ship_address
+    alias_method :shipping_address, :ship_address
+    alias_method :shipping_address=, :ship_address=
+
     alias_attribute :ship_total, :shipment_total
 
     belongs_to :store, class_name: 'Spree::Store', optional: true
@@ -92,8 +109,6 @@ module Spree
              foreign_key: :order_id,
              dependent: :destroy,
              inverse_of: :order
-    has_many :order_promotions, class_name: 'Spree::OrderPromotion'
-    has_many :promotions, through: :order_promotions
 
     # Payments
     has_many :payments, dependent: :destroy, inverse_of: :order
@@ -102,7 +117,7 @@ module Spree
     # Returns
     has_many :return_authorizations, dependent: :destroy, inverse_of: :order
     has_many :return_items, through: :inventory_units
-    has_many :customer_returns, through: :return_items
+    has_many :customer_returns, -> { distinct }, through: :return_items
     has_many :reimbursements, inverse_of: :order
     has_many :refunds, through: :payments
 
@@ -123,12 +138,14 @@ module Spree
     before_validation :set_currency
     before_validation :generate_order_number, on: :create
     before_validation :assign_billing_to_shipping_address, if: :use_billing?
+    before_validation :assign_shipping_to_billing_address, if: :use_shipping?
     attr_accessor :use_billing
+    attr_accessor :use_shipping
 
     before_create :create_token
     before_create :link_by_email
 
-    validates :email, presence: true, if: :require_email
+    validates :email, presence: true, if: :email_required?
     validates :email, 'spree/email' => true, allow_blank: true
     validates :guest_token, presence: { allow_nil: true }
     validates :number, presence: true, uniqueness: { allow_blank: true, case_sensitive: true }
@@ -142,11 +159,29 @@ module Spree
       find_by! number: value
     end
 
+    delegate :recalculate, to: :recalculator
+
     delegate :name, to: :bill_address, prefix: true, allow_nil: true
     alias_method :billing_name, :bill_address_name
 
-    class_attribute :line_item_comparison_hooks
-    self.line_item_comparison_hooks = Set.new
+    delegate :line_item_comparison_hooks, to: :class
+    class << self
+      def line_item_comparison_hooks=(value)
+        Spree::Config.line_item_comparison_hooks = value.to_a
+      end
+      line_item_hooks_deprecation_msg = "Use Spree::Config.line_item_comparison_hooks instead."
+      deprecate :line_item_comparison_hooks= => line_item_hooks_deprecation_msg, :deprecator => Spree.deprecator
+
+      def line_item_comparison_hooks
+        Spree::Config.line_item_comparison_hooks
+      end
+      deprecate line_item_comparison_hooks: line_item_hooks_deprecation_msg, deprecator: Spree.deprecator
+
+      def register_line_item_comparison_hook(hook)
+        Spree::Config.line_item_comparison_hooks << hook
+      end
+      deprecate register_line_item_comparison_hook: line_item_hooks_deprecation_msg, deprecator: Spree.deprecator
+    end
 
     scope :created_between, ->(start_date, end_date) { where(created_at: start_date..end_date) }
     scope :completed_between, ->(start_date, end_date) { where(completed_at: start_date..end_date) }
@@ -161,7 +196,7 @@ module Spree
     end
 
     def self.by_state(state)
-      where(state: state)
+      where(state:)
     end
 
     def self.complete
@@ -180,12 +215,6 @@ module Spree
       where.not(state: 'canceled')
     end
 
-    # Use this method in other gems that wish to register their own custom logic
-    # that should be called when determining if two line items are equal.
-    def self.register_line_item_comparison_hook(hook)
-      line_item_comparison_hooks.add(hook)
-    end
-
     # For compatiblity with Calculator::PriceSack
     def amount
       line_items.sum(&:amount)
@@ -195,6 +224,10 @@ module Spree
       line_items.to_a.sum(&:total_before_tax)
     end
 
+    def shipment_total_before_tax
+      shipments.to_a.sum(&:total_before_tax)
+    end
+
     # Sum of all line item amounts pre-tax
     def item_total_excluding_vat
       line_items.to_a.sum(&:total_excluding_vat)
@@ -205,7 +238,7 @@ module Spree
     end
 
     def shipping_discount
-      shipment_adjustments.credit.eligible.sum(:amount) * - 1
+      shipment_adjustments.credit.sum(:amount) * - 1
     end
 
     def to_param
@@ -239,22 +272,25 @@ module Spree
         ship_address
       else
         bill_address
-      end || store.default_cart_tax_location
+      end || store&.default_cart_tax_location
     end
 
-    def updater
-      @updater ||= Spree::OrderUpdater.new(self)
-    end
-
-    def recalculate
-      updater.update
+    def recalculator
+      @recalculator ||= Spree::Config.order_recalculator_class.new(self)
     end
+    alias_method :updater, :recalculator
+    deprecate updater: :recalculator, deprecator: Spree.deprecator
 
     def assign_billing_to_shipping_address
       self.ship_address = bill_address if bill_address
       true
     end
 
+    def assign_shipping_to_billing_address
+      self.bill_address = ship_address if ship_address
+      true
+    end
+
     def allow_cancel?
       return false unless completed? && state != 'canceled'
       shipment_state.nil? || %w{ready backorder pending}.include?(shipment_state)
@@ -269,15 +305,15 @@ module Spree
     end
 
     def contents
-      @contents ||= Spree::OrderContents.new(self)
+      @contents ||= Spree::Config.order_contents_class.new(self)
     end
 
     def shipping
-      @shipping ||= Spree::OrderShipping.new(self)
+      @shipping ||= Spree::Config.order_shipping_class.new(self)
     end
 
     def cancellations
-      @cancellations ||= Spree::OrderCancellations.new(self)
+      @cancellations ||= Spree::Config.order_cancellations_class.new(self)
     end
 
     # Associates the specified user with the order.
@@ -289,7 +325,7 @@ module Spree
 
       if persisted?
         # immediately persist the changes we just made, but don't use save since we might have an invalid address associated
-        self.class.unscoped.where(id: id).update_all(attrs_to_set)
+        self.class.unscoped.where(id:).update_all(attrs_to_set)
       end
 
       assign_attributes(attrs_to_set)
@@ -331,7 +367,7 @@ module Spree
     def line_item_options_match(line_item, options)
       return true unless options
 
-      line_item_comparison_hooks.all? { |hook|
+      Spree::Config.line_item_comparison_hooks.all? { |hook|
         send(hook, line_item, options)
       }
     end
@@ -379,30 +415,9 @@ module Spree
       Spree::CreditCard.where(id: credit_card_ids)
     end
 
-    # Finalizes an in progress order after checkout is complete.
-    # Called after transition to complete state when payments will have been processed
-    def finalize!
-      # lock all adjustments (coupon promotions, etc.)
-      all_adjustments.each(&:finalize!)
-
-      # update payment and shipment(s) states, and save
-      updater.update_payment_state
-      shipments.each do |shipment|
-        shipment.update_state
-        shipment.finalize!
-      end
-
-      updater.update_shipment_state
-      save!
-
-      touch :completed_at
-
-      Spree::Event.fire 'order_finalized', order: self
-    end
-
     def fulfill!
       shipments.each { |shipment| shipment.update_state if shipment.persisted? }
-      updater.update_shipment_state
+      recalculator.update_shipment_state
       save!
     end
 
@@ -444,7 +459,7 @@ module Spree
       line_items.destroy_all
       adjustments.destroy_all
       shipments.destroy_all
-      order_promotions.destroy_all
+      Spree::Bus.publish :order_emptied, order: self
 
       recalculate
     end
@@ -458,7 +473,7 @@ module Spree
     end
 
     def can_add_coupon?
-      Spree::Promotion.order_activatable?(self)
+      Spree::Config.promotions.coupon_code_handler_class.new(self).can_apply?
     end
 
     def shipped?
@@ -490,28 +505,21 @@ module Spree
         raise CannotRebuildShipments.new(I18n.t('spree.cannot_rebuild_shipments_shipments_not_pending'))
       else
         shipments.destroy_all
-        self.shipments = Spree::Config.stock.coordinator_class.new(self).shipments
+        shipments.push(*Spree::Config.stock.coordinator_class.new(self).shipments)
       end
     end
 
     def create_shipments_for_line_item(line_item)
-      units = Spree::Stock::InventoryUnitBuilder.new(self).missing_units_for_line_item(line_item)
+      units = Spree::Config.stock.inventory_unit_builder_class.new(self).missing_units_for_line_item(line_item)
+
       Spree::Config.stock.coordinator_class.new(self, units).shipments.each do |shipment|
         shipments << shipment
       end
     end
 
-    def apply_shipping_promotions
-      Spree::PromotionHandler::Shipping.new(self).activate
-      recalculate
-    end
-
-    # Clean shipments and make order back to address state
-    #
-    # At some point the might need to force the order to transition from address
-    # to delivery again so that proper updated shipments are created.
-    # e.g. customer goes back from payment step and changes order items
-    def ensure_updated_shipments
+    # Clean shipments and make order back to address state (or to whatever state
+    # is set by restart_checkout_flow in case of state machine modifications)
+    def check_shipments_and_restart_checkout
       if !completed? && shipments.all?(&:pending?)
         shipments.destroy_all
         update_column(:shipment_total, 0)
@@ -519,6 +527,9 @@ module Spree
       end
     end
 
+    alias_method :ensure_updated_shipments, :check_shipments_and_restart_checkout
+    deprecate ensure_updated_shipments: :check_shipments_and_restart_checkout, deprecator: Spree.deprecator
+
     def restart_checkout_flow
       return if state == 'cart'
 
@@ -526,7 +537,7 @@ module Spree
         state: 'cart',
         updated_at: Time.current
       )
-      next! if !line_items.empty?
+      self.next if line_items.any?
     end
 
     def refresh_shipment_rates
@@ -544,9 +555,7 @@ module Spree
     def canceled_by(user)
       transaction do
         cancel!
-        # rubocop:disable Rails/SkipsModelValidations
         update_column(:canceler_id, user.id)
-        # rubocop:enable Rails/SkipsModelValidations
       end
     end
 
@@ -563,8 +572,7 @@ module Spree
     end
 
     def has_non_reimbursement_related_refunds?
-      refunds.non_reimbursement.exists? ||
-        payments.offset_payment.exists? # how old versions of spree stored refunds
+      refunds.non_reimbursement.exists?
     end
 
     def tax_total
@@ -573,7 +581,7 @@ module Spree
 
     def add_store_credit_payments
       return if user.nil?
-      return if payments.store_credits.checkout.empty? && user.available_store_credit_total(currency: currency).zero?
+      return if payments.store_credits.checkout.empty? && user.available_store_credit_total(currency:).zero?
 
       payments.store_credits.checkout.each(&:invalidate!)
 
@@ -584,18 +592,19 @@ module Spree
 
       remaining_total = outstanding_balance - authorized_total
 
-      matching_store_credits = user.store_credits.where(currency: currency)
+      matching_store_credits = user.store_credits.where(currency:)
 
       if matching_store_credits.any?
         payment_method = Spree::PaymentMethod::StoreCredit.first
+        sorter = Spree::Config.store_credit_prioritizer_class.new(matching_store_credits, self)
 
-        matching_store_credits.order_by_priority.each do |credit|
+        sorter.call.each do |credit|
           break if remaining_total.zero?
           next if credit.amount_remaining.zero?
 
           amount_to_take = [credit.amount_remaining, remaining_total].min
           payments.create!(source: credit,
-                           payment_method: payment_method,
+                           payment_method:,
                            amount: amount_to_take,
                            state: 'checkout',
                            response_code: credit.generate_authorization_code)
@@ -619,13 +628,13 @@ module Spree
 
     def covered_by_store_credit?
       return false unless user
-      user.available_store_credit_total(currency: currency) >= total
+      user.available_store_credit_total(currency:) >= total
     end
     alias_method :covered_by_store_credit, :covered_by_store_credit?
 
     def total_available_store_credit
       return 0.0 unless user
-      user.available_store_credit_total(currency: currency)
+      user.available_store_credit_total(currency:)
     end
 
     def order_total_after_store_credit
@@ -636,16 +645,16 @@ module Spree
       if can_complete? || complete?
         valid_store_credit_payments.to_a.sum(&:amount)
       else
-        [total, (user.try(:available_store_credit_total, currency: currency) || 0.0)].min
+        [total, user.try(:available_store_credit_total, currency:) || 0.0].min
       end
     end
 
     def display_total_applicable_store_credit
-      Spree::Money.new(-total_applicable_store_credit, { currency: currency })
+      Spree::Money.new(-total_applicable_store_credit, { currency: })
     end
 
     def display_store_credit_remaining_after_capture
-      Spree::Money.new(total_available_store_credit - total_applicable_store_credit, { currency: currency })
+      Spree::Money.new(total_available_store_credit - total_applicable_store_credit, { currency: })
     end
 
     def bill_address_attributes=(attributes)
@@ -741,6 +750,27 @@ module Spree
       end
     end
 
+    # Finalizes an in progress order after checkout is complete.
+    # Called after transition to complete state when payments will have been processed
+    def finalize
+      # lock all adjustments (coupon promotions, etc.)
+      all_adjustments.each(&:finalize!)
+
+      # update payment and shipment(s) states, and save
+      recalculator.update_payment_state
+      shipments.each do |shipment|
+        shipment.update_state
+        shipment.finalize!
+      end
+
+      recalculator.update_shipment_state
+      save!
+
+      touch :completed_at
+
+      Spree::Bus.publish :order_finalized, order: self
+    end
+
     def associate_store
       self.store ||= Spree::Store.default
     end
@@ -749,25 +779,33 @@ module Spree
       self.email = user.email if user
     end
 
-    # Determine if email is required (we don't want validation errors before we hit the checkout)
-    def require_email
+    # Determine if the email is required for this order
+    #
+    # We don't require email for orders in the cart state or address state because those states
+    # precede the entry of an email address.
+    #
+    # @return [Boolean] true if the email is required
+    # @note This method was called require_email before.
+    def email_required?
       true unless new_record? || ['cart', 'address'].include?(state)
     end
 
     def ensure_inventory_units
       if has_checkout_step?("delivery")
-        inventory_validator = Spree::Stock::InventoryValidator.new
+        inventory_validator = Spree::Config.stock.inventory_validator_class.new
+
+        errors = line_items.map { |line_item|
+          inventory_validator.validate(line_item)
+        }.compact
 
-        errors = line_items.map { |line_item| inventory_validator.validate(line_item) }.compact
         raise InsufficientStock if errors.any?
       end
     end
 
     def ensure_promotions_eligible
-      adjustment_changed = all_adjustments.eligible.promotion.any? do |adjustment|
-        !adjustment.calculate_eligibility
-      end
-      if adjustment_changed
+      Spree::Config.promotions.order_adjuster_class.new(self).call
+
+      if promo_total_changed?
         restart_checkout_flow
         recalculate
         errors.add(:base, I18n.t('spree.promotion_total_changed_before_complete'))
@@ -776,8 +814,15 @@ module Spree
     end
 
     def validate_line_item_availability
-      availability_validator = Spree::Stock::AvailabilityValidator.new
-      raise InsufficientStock unless line_items.all? { |line_item| availability_validator.validate(line_item) }
+      availability_validator = Spree::Config.stock.availability_validator_class.new
+
+      # NOTE: This code assumes that the availability validator will return
+      # true for success and false for failure. This is not normally the
+      # behaviour of validators, as the framework only cares about the
+      # population of the errors, not the return value of the validate method.
+      raise InsufficientStock unless line_items.all? { |line_item|
+        availability_validator.validate(line_item)
+      }
     end
 
     def ensure_line_items_present
@@ -800,9 +845,7 @@ module Spree
       cancel_payments!
 
       send_cancel_email
-      # rubocop:disable Rails/SkipsModelValidations
       update_column(:canceled_at, Time.current)
-      # rubocop:enable Rails/SkipsModelValidations
       recalculate
     end
 
@@ -831,6 +874,10 @@ module Spree
       use_billing.in?([true, 'true', '1'])
     end
 
+    def use_shipping?
+      use_shipping.in?([true, 'true', '1'])
+    end
+
     def set_currency
       self.currency = Spree::Config[:currency] if self[:currency].nil?
     end

data/app/models/spree/order_cancellations.rb

@@ -36,7 +36,7 @@ class Spree::OrderCancellations
     Spree::OrderMutex.with_lock!(@order) do
       Spree::InventoryUnit.transaction do
         inventory_units.each do |iu|
-          unit_cancels << short_ship_unit(iu, created_by: created_by)
+          unit_cancels << short_ship_unit(iu, created_by:)
         end
 
         update_shipped_shipments(inventory_units)
@@ -67,9 +67,9 @@ class Spree::OrderCancellations
 
     Spree::OrderMutex.with_lock!(@order) do
       unit_cancel = Spree::UnitCancel.create!(
-        inventory_unit: inventory_unit,
-        reason: reason,
-        created_by: created_by
+        inventory_unit:,
+        reason:,
+        created_by:
       )
 
       inventory_unit.cancel!
@@ -89,8 +89,8 @@ class Spree::OrderCancellations
 
     Spree::OrderMutex.with_lock!(@order) do
       return_items = inventory_units.map(&:current_or_new_return_item)
-      reimbursement = Spree::Reimbursement.new(order: @order, return_items: return_items)
-      reimbursement.return_all(created_by: created_by)
+      reimbursement = Spree::Reimbursement.new(order: @order, return_items:)
+      reimbursement.return_all(created_by:)
     end
 
     reimbursement
@@ -100,9 +100,9 @@ class Spree::OrderCancellations
 
   def short_ship_unit(inventory_unit, created_by: nil)
     unit_cancel = Spree::UnitCancel.create!(
-      inventory_unit: inventory_unit,
+      inventory_unit:,
       reason: Spree::UnitCancel::SHORT_SHIP,
-      created_by: created_by
+      created_by:
     )
     unit_cancel.adjust!
     inventory_unit.cancel!

data/app/models/spree/order_inventory.rb

@@ -57,14 +57,16 @@ module Spree
     # first unshipped that's leaving from a stock_location that stocks this variant, with availability check
     # first unshipped that's leaving from a stock_location that stocks this variant, without availability check
     def determine_target_shipment(quantity)
-      potential_shipments = order.shipments.select(&:ready_or_pending?)
+      potential_shipments = order.shipments.order(:created_at, :id).select(&:ready_or_pending?)
 
       potential_shipments.detect do |shipment|
         shipment.include?(variant)
-      end || potential_shipments.detect do |shipment|
-        stock_item = shipment.stock_location.stock_item(variant.id)
-        if stock_item
-          stock_item.backorderable? || stock_item.count_on_hand >= quantity
+      end || begin
+        stock_items = variant.stock_items.sort_by(&:id) # cache stock items to avoid N+1
+
+        potential_shipments.detect do |shipment|
+          stock_item = stock_items.detect { |stock_item| stock_item.stock_location == shipment.stock_location }
+          stock_item.backorderable? || stock_item.count_on_hand >= quantity if stock_item
         end
       end || potential_shipments.detect do |shipment|
         variant.stock_location_ids.include?(shipment.stock_location_id)

data/app/models/spree/order_merger.rb

@@ -13,8 +13,6 @@ module Spree
     #   @return [Spree::Order] The order which items wll be merged into.
     attr_accessor :order
 
-    delegate :updater, to: :order
-
     # Create the OrderMerger
     #
     # @api public
@@ -80,7 +78,7 @@ module Spree
     def find_matching_line_item(other_order_line_item)
       order.line_items.detect do |my_li|
         my_li.variant == other_order_line_item.variant &&
-          order.line_item_comparison_hooks.all? do |hook|
+          Spree::Config.line_item_comparison_hooks.all? do |hook|
             order.send(hook, my_li, other_order_line_item.serializable_hash)
           end
       end
@@ -115,8 +113,8 @@ module Spree
         current_line_item.quantity += other_order_line_item.quantity
         handle_error(current_line_item) unless current_line_item.save
       else
-        order.line_items << other_order_line_item
-        handle_error(other_order_line_item) unless other_order_line_item.save
+        new_line_item = order.line_items.build(other_order_line_item.attributes.except("id"))
+        handle_error(new_line_item) unless new_line_item.save
       end
     end
 
@@ -133,13 +131,13 @@ module Spree
 
     # Save the order totals after merge
     #
-    # It triggers the order updater to ensure that item counts and totals are
+    # It triggers the order recalculator to ensure that item counts and totals are
     # up to date.
     #
     # @api private
     # @return [void]
     def persist_merge
-      updater.update
+      order.recalculate
     end
   end
 end

data/app/models/spree/order_mutex.rb

@@ -16,10 +16,10 @@ module Spree
         raise ArgumentError, "order must be supplied" if order.nil?
 
         # limit the maximum lock time just in case a lock is somehow left in place accidentally
-        expired.where(order: order).delete_all
+        expired.where(order:).delete_all
 
         begin
-          order_mutex = create!(order: order)
+          order_mutex = create!(order:)
         rescue ActiveRecord::RecordNotUnique
           error = LockFailed.new("Could not obtain lock on order #{order.id}")
           logger.error error.inspect