solidus_core 3.0.0 → 4.5.1

data/app/models/spree/core/state_machines/return_item/reception_status.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    class StateMachines
+      module ReturnItem
+        # Return Items' reception status state machine
+        #
+        # for each event the following instance methods are dynamically implemented:
+        #   #<event_name>
+        #   #<event_name>!
+        #   #can_<event_name>?
+        #
+        # for each state the following instance methods are implemented:
+        #   #<state_name>?
+        #
+        module ReceptionStatus
+          extend ActiveSupport::Concern
+
+          included do
+            state_machine :reception_status, initial: :awaiting do
+              after_transition to: ::Spree::ReturnItem::COMPLETED_RECEPTION_STATUSES, do: :attempt_accept, if: :can_attempt_accept?
+              after_transition to: ::Spree::ReturnItem::COMPLETED_RECEPTION_STATUSES, do: :check_unexchange
+              after_transition to: :received, do: :process_inventory_unit!
+
+              event(:cancel) { transition to: :cancelled, from: :awaiting }
+
+              event(:receive) { transition to: :received, from: ::Spree::ReturnItem::INTERMEDIATE_RECEPTION_STATUSES + [:awaiting] }
+              event(:unexchange) { transition to: :unexchanged, from: [:awaiting] }
+              event(:give) { transition to: :given_to_customer, from: :awaiting }
+              event(:lost) { transition to: :lost_in_transit, from: :awaiting }
+              event(:wrong_item_shipped) { transition to: :shipped_wrong_item, from: :awaiting }
+              event(:short_shipped) { transition to: :short_shipped, from: :awaiting }
+              event(:in_transit) { transition to: :in_transit, from: :awaiting }
+              event(:expired) { transition to: :expired, from: :awaiting }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/spree/core/state_machines/shipment.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    class StateMachines
+      # Shipments' state machine
+      #
+      # for each event the following instance methods are dynamically implemented:
+      #   #<event_name>
+      #   #<event_name>!
+      #   #can_<event_name>?
+      #
+      # for each state the following instance methods are implemented:
+      #   #<state_name>?
+      #
+      module Shipment
+        extend ActiveSupport::Concern
+
+        included do
+          state_machine initial: :pending, use_transactions: false do
+            event :ready do
+              transition from: :pending, to: :shipped, if: :can_transition_from_pending_to_shipped?
+              transition from: :pending, to: :ready, if: :can_transition_from_pending_to_ready?
+            end
+
+            event :pend do
+              transition from: :ready, to: :pending
+            end
+
+            event :ship do
+              transition from: [:ready, :canceled], to: :shipped
+            end
+            after_transition to: :shipped, do: :after_ship
+
+            event :cancel do
+              transition to: :canceled, from: [:pending, :ready]
+            end
+            after_transition to: :canceled, do: :after_cancel
+
+            event :resume do
+              transition from: :canceled, to: :ready, if: :can_transition_from_canceled_to_ready?
+              transition from: :canceled, to: :pending
+            end
+            after_transition from: :canceled, to: [:pending, :ready, :shipped], do: :after_resume
+
+            after_transition do |shipment, transition|
+              shipment.state_changes.create!(
+                previous_state: transition.from,
+                next_state:     transition.to,
+                name:           'shipment'
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/spree/country.rb

@@ -8,7 +8,7 @@ module Spree
 
     validates :name, :iso_name, presence: true
 
-    self.whitelisted_ransackable_attributes = %w[name]
+    self.allowed_ransackable_attributes = %w[name]
 
     def self.default
       find_by!(iso: Spree::Config.default_country_iso)

data/app/models/spree/credit_card.rb

@@ -21,9 +21,6 @@ module Spree
 
     scope :with_payment_profile, -> { where('gateway_customer_profile_id IS NOT NULL') }
 
-    # needed for some of the ActiveMerchant gateways (eg. SagePay)
-    alias_attribute :brand, :cc_type
-
     # Taken from ActiveMerchant
     # https://github.com/activemerchant/active_merchant/blob/2f2acd4696e8de76057b5ed670b9aa022abc1187/lib/active_merchant/billing/credit_card_methods.rb#L5
     CARD_TYPES = {
@@ -95,9 +92,15 @@ module Spree
       end
     end
 
+    # needed for some of the ActiveMerchant gateways (eg. SagePay)
+    alias_attribute :brand, :cc_type
+
+    # Rails 7.1+ won't use the custom setter with alias_attribute
+    alias_method :brand=, :cc_type=
+
     # Sets the last digits field based on the assigned credit card number.
     def set_last_digits
-      self.last_digits ||= number.to_s.length <= 4 ? number : number.to_s.slice(-4..-1)
+      self.last_digits ||= number.to_s.length <= 4 ? number : number.to_s.slice(-4..)
     end
 
     # @return [String] the credit card type if it can be determined from the
@@ -152,12 +155,12 @@ module Spree
     #   card that represents this credit card
     def to_active_merchant
       ActiveMerchant::Billing::CreditCard.new(
-        number: number,
-        month: month,
-        year: year,
-        verification_value: verification_value,
-        first_name: first_name,
-        last_name: last_name
+        number:,
+        month:,
+        year:,
+        verification_value:,
+        first_name:,
+        last_name:
       )
     end
 

data/app/models/spree/customer_return.rb

@@ -2,6 +2,8 @@
 
 module Spree
   class CustomerReturn < Spree::Base
+    include Metadata
+
     belongs_to :stock_location, optional: true
 
     has_many :return_items, inverse_of: :customer_return
@@ -17,7 +19,7 @@ module Spree
 
     accepts_nested_attributes_for :return_items
 
-    self.whitelisted_ransackable_attributes = ['number']
+    self.allowed_ransackable_attributes = ['number']
 
     extend DisplayMoney
     money_methods :total, :total_excluding_vat, :amount
@@ -40,7 +42,8 @@ module Spree
     # Temporarily tie a customer_return to one order
     def order
       return nil if return_items.blank?
-      return_items.first.inventory_unit.order
+
+      return_items.first.inventory_unit&.order
     end
 
     def fully_reimbursed?
@@ -65,7 +68,7 @@ module Spree
     end
 
     def return_items_belong_to_same_order
-      if return_items.reject{ |return_item| return_item.inventory_unit.order_id == order_id }.any?
+      if return_items.reject{ |return_item| return_item.inventory_unit&.order_id == order_id }.any?
         errors.add(:base, I18n.t('spree.return_items_cannot_be_associated_with_multiple_orders'))
       end
     end

data/app/models/spree/deprecated_configurable_class.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Spree
+  class DeprecatedConfigurableClass
+    def self.new(*_args, &_block)
+      @deprecation_proxy ||= DeprecationProxy.new
+    end
+
+    def self.method_missing(method_name, *args, &block)
+      @deprecation_proxy ||= DeprecationProxy.new
+      @deprecation_proxy.send(method_name, args, block)
+    end
+
+    def self.respond_to_missing?(_method_name, _include_private = false)
+      true
+    end
+
+    class DeprecationProxy
+      def method_missing(_method_name, *_args, &_block)
+        issue_deprecation_warning
+        self
+      end
+
+      def respond_to_missing?(_method_name, _include_private = false)
+        true
+      end
+
+      private
+
+      def issue_deprecation_warning
+        Spree.deprecator.warn(
+          <<-WARNING
+            It appears you are using Solidus' Legacy promotion system. This system has been extracted into the
+            `solidus_legacy_promotions` gem. Please add the gem to your Gemfile and follow in the instructions in the README.
+          WARNING
+        )
+      end
+    end
+  end
+end

data/app/models/spree/fulfilment_changer.rb

@@ -20,15 +20,16 @@ module Spree
     include ActiveModel::Validations
 
     attr_accessor :current_shipment, :desired_shipment
-    attr_reader :variant, :quantity, :current_stock_location, :desired_stock_location
+    attr_reader :variant, :quantity, :current_stock_location, :desired_stock_location, :track_inventory
 
-    def initialize(current_shipment:, desired_shipment:, variant:, quantity:)
+    def initialize(current_shipment:, desired_shipment:, variant:, quantity:, track_inventory:)
       @current_shipment = current_shipment
       @desired_shipment = desired_shipment
       @current_stock_location = current_shipment.stock_location
       @desired_stock_location = desired_shipment.stock_location
       @variant = variant
       @quantity = quantity
+      @track_inventory = track_inventory
     end
 
     validates :quantity, numericality: { greater_than: 0 }
@@ -45,6 +46,45 @@ module Spree
       return false if invalid?
       desired_shipment.save! if desired_shipment.new_record?
 
+      if track_inventory
+        run_tracking_inventory
+      else
+        run_without_tracking_inventory
+      end
+
+      # We modified the inventory units at the database level for speed reasons.
+      # The downside of that is that we need to reload the associations.
+      current_shipment.inventory_units.reload
+      desired_shipment.inventory_units.reload
+
+      # If the current shipment now has no inventory units left, we won't need it any longer.
+      if current_shipment.inventory_units.length.zero?
+        current_shipment.destroy!
+      else
+        # The current shipment has changed, so we need to make sure that shipping rates
+        # have the correct amount.
+        current_shipment.refresh_rates
+      end
+
+      # The desired shipment has also change, so we need to make sure shipping rates
+      # are up-to-date, too.
+      desired_shipment.refresh_rates
+
+      # In order to reflect the changes in the order totals
+      desired_shipment.order.reload
+      desired_shipment.order.recalculate
+
+      true
+    end
+
+    private
+
+    # When moving things from one stock location to another, we need to restock items
+    # from the current location and unstock them at the desired location.
+    # Also, when we want to track inventory changes, we need to make sure that we have
+    # enough stock at the desired location to fulfil the order. Based on how many items
+    # we can take from the desired location, we could end up with some items being backordered.
+    def run_tracking_inventory
       # Retrieve how many on hand items we can take from desired stock location
       available_quantity = [desired_shipment.stock_location.count_on_hand(variant), default_on_hand_quantity].max
 
@@ -67,46 +107,33 @@ module Spree
         # We order by state, because `'backordered' < 'on_hand'`.
         current_shipment.
           inventory_units.
-          where(variant: variant).
+          where(variant:).
           order(state: :asc).
           limit(new_on_hand_quantity).
           update_all(shipment_id: desired_shipment.id, state: :on_hand)
 
         current_shipment.
           inventory_units.
-          where(variant: variant).
+          where(variant:).
           order(state: :asc).
           limit(quantity - new_on_hand_quantity).
           update_all(shipment_id: desired_shipment.id, state: :backordered)
       end
+    end
 
-      # We modified the inventory units at the database level for speed reasons.
-      # The downside of that is that we need to reload the associations.
-      current_shipment.inventory_units.reload
-      desired_shipment.inventory_units.reload
-
-      # If the current shipment now has no inventory units left, we won't need it any longer.
-      if current_shipment.inventory_units.length.zero?
-        current_shipment.destroy!
-      else
-        # The current shipment has changed, so we need to make sure that shipping rates
-        # have the correct amount.
-        current_shipment.refresh_rates
+    # When we don't track inventory, we can just move the inventory units from one shipment
+    # to the other.
+    def run_without_tracking_inventory
+      ActiveRecord::Base.transaction do
+        current_shipment.
+          inventory_units.
+          where(variant:).
+          order(state: :asc).
+          limit(quantity).
+          update_all(shipment_id: desired_shipment.id)
       end
-
-      # The desired shipment has also change, so we need to make sure shipping rates
-      # are up-to-date, too.
-      desired_shipment.refresh_rates
-
-      # In order to reflect the changes in the order totals
-      desired_shipment.order.reload
-      desired_shipment.order.recalculate
-
-      true
     end
 
-    private
-
     # We don't need to handle stock counts for incomplete orders. Also, if
     # the new shipment and the desired shipment will ship from the same stock location,
     # unstocking and restocking will not be necessary.
@@ -118,7 +145,7 @@ module Spree
       if current_stock_location != desired_stock_location
         0
       else
-        current_shipment.inventory_units.where(variant: variant).on_hand.count
+        current_shipment.inventory_units.where(variant:).on_hand.count
       end
     end
 

data/app/models/spree/image/active_storage_attachment.rb

@@ -12,13 +12,8 @@ module Spree::Image::ActiveStorageAttachment
     validate :supported_content_type
 
     has_attachment :attachment,
-                   styles: {
-                   mini: '48x48>',
-                   small: '400x400>',
-                   product: '680x680>',
-                   large: '1200x1200>'
-                 },
-                 default_style: :product
+                   styles: Spree::Config.product_image_styles,
+                   default_style: Spree::Config.product_image_style_default
 
     def supported_content_type
       unless attachment.content_type.in?(Spree::Config.allowed_image_mime_types)

data/app/models/spree/image/paperclip_attachment.rb

@@ -7,8 +7,8 @@ module Spree::Image::PaperclipAttachment
     validate :no_attachment_errors
 
     has_attached_file :attachment,
-                      styles: { mini: '48x48>', small: '400x400>', product: '680x680>', large: '1200x1200>' },
-                      default_style: :product,
+                      styles: Spree::Config.product_image_styles,
+                      default_style: Spree::Config.product_image_style_default,
                       default_url: 'noimage/:style.png',
                       url: '/spree/products/:id/:style/:basename.:extension',
                       path: ':rails_root/public/spree/products/:id/:style/:basename.:extension',

data/app/models/spree/inventory_unit.rb

@@ -64,7 +64,7 @@ module Spree
     #   stock location that is associated with this inventory unit's variant
     def find_stock_item
       Spree::StockItem.where(stock_location_id: shipment.stock_location_id,
-        variant_id: variant_id).first
+        variant_id:).first
     end
 
     # @return [Spree::ReturnItem] a valid return item for this inventory unit
@@ -114,7 +114,7 @@ module Spree
 
     def ensure_can_destroy
       if !backordered? && !on_hand?
-        errors.add(:state, :cannot_destroy, state: state)
+        errors.add(:state, :cannot_destroy, state:)
         throw :abort
       end
 

data/app/models/spree/item_total.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Spree::ItemTotal
+  def initialize(item)
+    @item = item
+  end
+
+  def recalculate!
+    tax_adjustments = item.adjustments.select do |adjustment|
+      adjustment.tax? && !adjustment.marked_for_destruction?
+    end
+
+    # Included tax adjustments are those which are included in the price.
+    # These ones should not affect the eventual total price.
+    #
+    # Additional tax adjustments are the opposite, affecting the final total.
+    item.included_tax_total   = tax_adjustments.select(&:included?).sum(&:amount)
+    item.additional_tax_total = tax_adjustments.reject(&:included?).sum(&:amount)
+
+    item.adjustment_total = item.adjustments.reject { |adjustment|
+      adjustment.marked_for_destruction? || adjustment.included?
+    }.sum(&:amount)
+  end
+
+  private
+
+  attr_reader :item
+end

data/app/models/spree/legacy_user.rb

@@ -7,6 +7,7 @@ module Spree
   #   spree_auth_devise)
   class LegacyUser < Spree::Base
     include UserMethods
+    include Metadata
 
     self.table_name = 'spree_users'
 

data/app/models/spree/line_item.rb

@@ -10,6 +10,8 @@ module Spree
   # promotion system.
   #
   class LineItem < Spree::Base
+    include Metadata
+
     belongs_to :order, class_name: "Spree::Order", inverse_of: :line_items, touch: true, optional: true
     belongs_to :variant, -> { with_discarded }, class_name: "Spree::Variant", inverse_of: :line_items, optional: true
     belongs_to :tax_category, class_name: "Spree::TaxCategory", optional: true
@@ -19,9 +21,6 @@ module Spree
     has_many :adjustments, as: :adjustable, inverse_of: :adjustable, dependent: :destroy
     has_many :inventory_units, inverse_of: :line_item
 
-    has_many :line_item_actions, dependent: :destroy
-    has_many :actions, through: :line_item_actions
-
     before_validation :normalize_quantity
     before_validation :set_required_attributes
 
@@ -39,12 +38,13 @@ module Spree
     before_destroy :destroy_inventory_units
 
     delegate :name, :description, :sku, :should_track_inventory?, to: :variant
+    delegate :tax_category, :tax_category_id, to: :variant, prefix: true
     delegate :currency, to: :order, allow_nil: true
 
     attr_accessor :target_shipment, :price_currency
 
-    self.whitelisted_ransackable_associations = ['variant']
-    self.whitelisted_ransackable_attributes = ['variant_id']
+    self.allowed_ransackable_associations = ['variant']
+    self.allowed_ransackable_attributes = ['variant_id']
 
     # @return [BigDecimal] the amount of this line item, which is the line
     #   item's price multiplied by its quantity.
@@ -62,7 +62,7 @@ module Spree
     # @return [BigDecimal] the amount of this item, taking into consideration
     #   all non-tax adjustments.
     def total_before_tax
-      amount + adjustments.select { |value| !value.tax? && value.eligible? }.sum(&:amount)
+      amount + adjustments.reject(&:tax?).sum(&:amount)
     end
 
     # @return [BigDecimal] the amount of this line item before VAT tax
@@ -123,7 +123,7 @@ module Spree
       # a price for this line item, even if there is no existing price
       # for the associated line item in the order currency.
       unless options.key?(:price) || options.key?('price')
-        self.money_price = variant.price_for(pricing_options)
+        self.money_price = variant.price_for_options(pricing_options)&.money
       end
     end
 
@@ -131,6 +131,24 @@ module Spree
       Spree::Config.pricing_options_class.from_line_item(self)
     end
 
+    # @return [Spree::TaxCategory] the variant's tax category
+    #
+    # This returns the variant's tax category if the tax category ID on the line_item is nil. It looks
+    # like an association, but really is an override.
+    #
+    def tax_category
+      super || variant_tax_category
+    end
+
+    # @return [Integer] the variant's tax category ID
+    #
+    # This returns the variant's tax category ID if the tax category ID on the line_id is nil. It looks
+    # like an association, but really is an override.
+    #
+    def tax_category_id
+      super || variant_tax_category_id
+    end
+
     private
 
     # Sets the quantity to zero if it is nil or less than zero.
@@ -149,7 +167,7 @@ module Spree
     # Set price, cost_price and currency.
     def set_pricing_attributes
       self.cost_price ||= variant.cost_price
-      self.money_price = variant.price_for(pricing_options) if price.nil?
+      self.money_price = variant.price_for_options(pricing_options)&.money if price.nil?
       true
     end
 

data/app/models/spree/log_entry.rb

@@ -2,10 +2,107 @@
 
 module Spree
   class LogEntry < Spree::Base
+    # Classes used in core that can be present in serialized details
+    #
+    # Users can add their own classes in
+    # `Spree::Config#log_entry_permitted_classes`.
+    #
+    # @see Spree::AppConfiguration#log_entry_permitted_classes
+    CORE_PERMITTED_CLASSES = [
+      ActiveMerchant::Billing::Response,
+      ActiveSupport::TimeWithZone,
+      Time,
+      ActiveSupport::TimeZone
+    ].freeze
+
+    class SerializationError < RuntimeError
+      attr_reader :psych_exception
+
+      def initialize(psych_exception:)
+        @psych_exception = psych_exception
+        super(default_message)
+      end
+    end
+
+    # Raised when a disallowed class is tried to be loaded
+    class DisallowedClass < SerializationError
+      private
+
+      def default_message
+        <<~MSG
+          #{psych_exception.message}
+
+          You can specify custom classes to be loaded in config/initializers/spree.rb. E.g:
+
+          Spree.config do |config|
+            config.log_entry_permitted_classes = ['MyClass']
+          end
+        MSG
+      end
+    end
+
+    # Raised when YAML contains aliases and they're not enabled
+    class BadAlias < SerializationError
+      private
+
+      def default_message
+        <<~MSG
+          #{psych_exception.message}
+
+          You can explicitly enable aliases in config/initializers/spree.rb. E.g:
+
+          Spree.config do |config|
+            config.log_entry_allow_aliases = true
+          end
+        MSG
+      end
+    end
+
+    def self.permitted_classes
+      CORE_PERMITTED_CLASSES + Spree::Config.log_entry_permitted_classes.map(&:constantize)
+    end
+
     belongs_to :source, polymorphic: true, optional: true
 
     def parsed_details
-      @details ||= YAML.load(details)
+      handle_psych_serialization_errors do
+        @details ||= YAML.safe_load(
+          details,
+          permitted_classes: self.class.permitted_classes,
+          aliases: Spree::Config.log_entry_allow_aliases,
+        )
+      end
+    end
+
+    def parsed_details=(value)
+      handle_psych_serialization_errors do
+        self.details = YAML.safe_dump(
+          value,
+          permitted_classes: self.class.permitted_classes,
+          aliases: Spree::Config.log_entry_allow_aliases,
+        )
+      end
+    end
+
+    def parsed_payment_response_details_with_fallback=(response)
+      self.parsed_details = response
+    rescue SerializationError, YAML::Exception => e
+      # Fall back on wrapping the response and signaling the error to the end user.
+      self.parsed_details = ActiveMerchant::Billing::Response.new(
+        response.success?,
+        "[WARNING: An error occurred while trying to serialize the payment response] #{response.message}",
+        { 'data' => response.inspect, 'error' => e.message.to_s },
+      )
+    end
+
+    private
+
+    def handle_psych_serialization_errors
+      yield
+    rescue Psych::DisallowedClass => e
+      raise DisallowedClass.new(psych_exception: e)
+    rescue Psych::BadAlias => e
+      raise BadAlias.new(psych_exception: e)
     end
   end
 end