solidus_core 4.1.6 → 4.5.1

data/app/models/concerns/spree/display_money.rb

@@ -24,7 +24,7 @@ module Spree
         money_method = { money_method => {} } unless money_method.is_a? Hash
         money_method.each do |method_name, opts|
           define_method("display_#{method_name}") do
-            default_opts = respond_to?(:currency) ? { currency: currency } : {}
+            default_opts = respond_to?(:currency) ? { currency: } : {}
             Spree::Money.new(send(method_name), default_opts.merge(opts))
           end
         end

data/app/models/concerns/spree/metadata.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Spree
+  module Metadata
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :customer_metadata, :json, default: {}
+      attribute :admin_metadata, :json, default: {}
+
+      validate :validate_metadata_limits, if: :validate_metadata_enabled?
+    end
+
+    class_methods do
+      def meta_data_columns
+        %i[customer_metadata admin_metadata]
+      end
+    end
+
+    private
+
+    def validate_metadata_enabled?
+      Spree::Config.meta_data_validation_enabled
+    end
+
+    def validate_metadata_limits
+      self.class.meta_data_columns.each { |column| validate_metadata_column(column) }
+    end
+
+    def validate_metadata_column(column)
+      config = Spree::Config
+      metadata = send(column)
+
+      return if metadata.nil?
+
+      # Check for maximum number of keys
+      validate_metadata_keys_count(metadata, column, config.meta_data_max_keys)
+
+      # Check for maximum key and value size
+      metadata.each do |key, value|
+        validate_metadata_key(key, column, config.meta_data_max_key_length)
+        validate_metadata_value(key, value, column, config.meta_data_max_value_length)
+      end
+    end
+
+    def validate_metadata_keys_count(metadata, column, max_keys)
+      return unless metadata.keys.count > max_keys
+
+      errors.add(column, "must not have more than #{max_keys} keys")
+    end
+
+    def validate_metadata_key(key, column, max_key_length)
+      return unless key.to_s.length > max_key_length
+
+      errors.add(column, "key '#{key}' exceeds #{max_key_length} characters")
+    end
+
+    def validate_metadata_value(key, value, column, max_value_length)
+      return unless value.to_s.length > max_value_length
+
+      errors.add(column, "value for key '#{key}' exceeds #{max_value_length} characters")
+    end
+  end
+end

data/app/models/concerns/spree/named_type.rb

@@ -5,6 +5,8 @@ module Spree
     extend ActiveSupport::Concern
 
     included do
+      Spree.deprecator.warn "Spree::NamedType is deprecated. Please set scopes and validations locally instead.", caller
+
       scope :active, -> { where(active: true) }
       default_scope -> { order(arel_table[:name].lower) }
 

data/app/models/concerns/spree/ordered_property_value_list.rb

@@ -18,8 +18,8 @@ module Spree
 
     def property_name=(name)
       unless name.blank?
-        unless property = Spree::Property.find_by(name: name)
-          property = Spree::Property.create(name: name, presentation: name)
+        unless property = Spree::Property.find_by(name:)
+          property = Spree::Property.create(name:, presentation: name)
         end
         self.property = property
       end

data/app/models/concerns/spree/user_address_book.rb

@@ -5,7 +5,7 @@ module Spree
     extend ActiveSupport::Concern
 
     included do
-      has_many :user_addresses, -> { active }, foreign_key: "user_id", class_name: "Spree::UserAddress" do
+      has_many :user_addresses, foreign_key: "user_id", class_name: "Spree::UserAddress" do
         def find_first_by_address_values(address_attrs)
           detect { |ua| ua.address == Spree::Address.new(address_attrs) }
         end
@@ -22,7 +22,7 @@ module Spree
             end
 
             if user_address.persisted?
-              user_address.update!(column_for_default => true, archived: false)
+              user_address.update!(column_for_default => true)
             else
               user_address.write_attribute(column_for_default, true)
             end
@@ -120,7 +120,7 @@ module Spree
         remove_from_address_book(address_attributes[:id])
       end
 
-      user_addresses.mark_default(user_address, address_type: address_type) if default || first_one
+      user_addresses.mark_default(user_address, address_type:) if default || first_one
 
       if persisted?
         user_address.save!
@@ -140,18 +140,18 @@ module Spree
     end
 
     def mark_default_ship_address(address)
-      user_addresses.mark_default(user_addresses.find_by(address: address))
+      user_addresses.mark_default(user_addresses.find_by(address:))
     end
 
     def mark_default_bill_address(address)
-      user_addresses.mark_default(user_addresses.find_by(address: address), address_type: :billing)
+      user_addresses.mark_default(user_addresses.find_by(address:), address_type: :billing)
     end
 
     def remove_from_address_book(address_id)
-      user_address = user_addresses.find_by(address_id: address_id)
+      user_address = user_addresses.find_by(address_id:)
       if user_address
         remove_user_address_reference(address_id)
-        user_address.update(archived: true, default: false)
+        user_address.destroy!
       else
         false
       end
@@ -160,10 +160,9 @@ module Spree
     private
 
     def prepare_user_address(new_address)
-      user_address = user_addresses.all_historical.find_first_by_address_values(new_address.attributes)
+      user_address = user_addresses.find_first_by_address_values(new_address.attributes)
       user_address ||= user_addresses.build
       user_address.address = new_address
-      user_address.archived = false
       user_address
     end
 

data/app/models/concerns/spree/user_methods.rb

@@ -58,7 +58,7 @@ module Spree
     def last_incomplete_spree_order(store: nil, only_frontend_viewable: true)
       self_orders = orders
       self_orders = self_orders.where(frontend_viewable: true) if only_frontend_viewable
-      self_orders = self_orders.where(store: store) if store
+      self_orders = self_orders.where(store:) if store
       self_orders = self_orders.where('updated_at > ?', Spree::Config.completable_order_updated_cutoff_days.days.ago) if Spree::Config.completable_order_updated_cutoff_days
       self_orders = self_orders.where('created_at > ?', Spree::Config.completable_order_created_cutoff_days.days.ago) if Spree::Config.completable_order_created_cutoff_days
       last_order = self_orders.order(:created_at).last
@@ -73,8 +73,8 @@ module Spree
 
     def display_available_store_credit_total(currency:)
       Spree::Money.new(
-        available_store_credit_total(currency: currency),
-        currency: currency,
+        available_store_credit_total(currency:),
+        currency:,
       )
     end
 

data/app/models/spree/address.rb

@@ -28,8 +28,10 @@ module Spree
 
     self.allowed_ransackable_attributes = %w[name]
 
-    scope :with_values, ->(attributes) do
-      where(value_attributes(attributes))
+    unless ActiveRecord::Relation.method_defined? :with_values # Rails 7.1+
+      scope :with_values, ->(attributes) do
+        where(value_attributes(attributes))
+      end
     end
 
     # @return [Address] an address with default attributes
@@ -95,14 +97,14 @@ module Spree
     # @return [Hash] an ActiveMerchant compatible address hash
     def active_merchant_hash
       {
-        name: name,
-        address1: address1,
-        address2: address2,
-        city: city,
+        name:,
+        address1:,
+        address2:,
+        city:,
         state: state_text,
         zip: zipcode,
         country: country.try(:iso),
-        phone: phone
+        phone:
       }
     end
 
@@ -130,7 +132,7 @@ module Spree
     # @return [Country] setter that sets self.country to the Country with a matching 2 letter iso
     # @raise [ActiveRecord::RecordNotFound] if country with the iso doesn't exist
     def country_iso=(iso)
-      self.country = Spree::Country.find_by!(iso: iso)
+      self.country = Spree::Country.find_by!(iso:)
     end
 
     def country_iso

data/app/models/spree/adjustment.rb

@@ -4,29 +4,18 @@ module Spree
   # Adjustments represent a change to the +item_total+ of an Order. Each
   # adjustment has an +amount+ that can be either positive or negative.
   #
-  # Adjustments can be "opened" or "closed". Once an adjustment is closed, it
+  # Adjustments can be "unfinalized" or "finalized". Once an adjustment is finalized, it
   # will not be automatically updated.
-  #
-  # == Boolean attributes
-  #
-  # 1. *eligible?*
-  #
-  #    This boolean attributes stores whether this adjustment is currently
-  #    eligible for its order. Only eligible adjustments count towards the
-  #    order's adjustment total. This allows an adjustment to be preserved if
-  #    it becomes ineligible so it might be reinstated.
   class Adjustment < Spree::Base
     belongs_to :adjustable, polymorphic: true, touch: true, optional: true
     belongs_to :source, polymorphic: true, optional: true
     belongs_to :order, class_name: 'Spree::Order', inverse_of: :all_adjustments, optional: true
-    belongs_to :promotion_code, class_name: 'Spree::PromotionCode', optional: true
     belongs_to :adjustment_reason, class_name: 'Spree::AdjustmentReason', inverse_of: :adjustments, optional: true
 
     validates :adjustable, presence: true
     validates :order, presence: true
     validates :label, presence: true
     validates :amount, numericality: true
-    validates :promotion_code, presence: true, if: :require_promotion_code?
 
     scope :not_finalized, -> { where(finalized: false) }
     scope :finalized, -> { where(finalized: true) }
@@ -38,16 +27,23 @@ module Spree
     end
     scope :price, -> { where(adjustable_type: 'Spree::LineItem') }
     scope :shipping, -> { where(adjustable_type: 'Spree::Shipment') }
-    scope :eligible, -> { where(eligible: true) }
+    scope :eligible, -> { all }
+    class << self
+      deprecate :eligible, deprecator: Spree.deprecator
+    end
     scope :charge, -> { where("#{quoted_table_name}.amount >= 0") }
     scope :credit, -> { where("#{quoted_table_name}.amount < 0") }
     scope :nonzero, -> { where("#{quoted_table_name}.amount != 0") }
-    scope :promotion, -> { where(source_type: 'Spree::PromotionAction') }
-    scope :non_promotion, -> { where.not(source_type: 'Spree::PromotionAction') }
+    scope :promotion, -> { where(source_type: Spree::Config.adjustment_promotion_source_types.map(&:to_s)) }
+    scope :non_promotion, -> { where.not(source_type: Spree::Config.adjustment_promotion_source_types.map(&:to_s)) }
     scope :return_authorization, -> { where(source_type: "Spree::ReturnAuthorization") }
     scope :is_included, -> { where(included: true) }
     scope :additional, -> { where(included: false) }
 
+    singleton_class.deprecate :return_authorization, deprecator: Spree.deprecator
+
+    allowed_ransackable_attributes << 'label'
+
     extend DisplayMoney
     money_methods :amount
 
@@ -73,7 +69,7 @@ module Spree
 
     # @return [Boolean] true when this is a promotion adjustment (Promotion adjustments have a {PromotionAction} source)
     def promotion?
-      source_type == 'Spree::PromotionAction'
+      source_type.to_s.in?(Spree::Config.adjustment_promotion_source_types.map(&:to_s))
     end
 
     # @return [Boolean] true when this is a tax adjustment (Tax adjustments have a {TaxRate} source)
@@ -86,55 +82,9 @@ module Spree
       source_type == 'Spree::UnitCancel'
     end
 
-    # 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
-      if finalized? && !tax?
-        return 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 source.present?
-        self.amount = source.compute_amount(adjustable)
-
-        if promotion?
-          self.eligible = calculate_eligibility
-        end
-
-        # 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.
-        update_columns(eligible: eligible, amount: amount, updated_at: Time.current) if changed?
-      end
-      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
-      if !finalized? && source && promotion?
-        source.promotion.eligible?(adjustable, promotion_code: promotion_code)
-      else
-        eligible?
-      end
-    end
-
-    private
-
-    def require_promotion_code?
-      promotion? && !source.promotion.apply_automatically && source.promotion.codes.any?
+    def eligible?
+      true
     end
+    alias_method :eligible, :eligible?
   end
 end

data/app/models/spree/adjustment_reason.rb

@@ -8,5 +8,7 @@ module Spree
     validates :code, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
 
     scope :active, -> { where(active: true) }
+
+    self.allowed_ransackable_attributes = %w[name code]
   end
 end

data/app/models/spree/calculator/returns/default_refund_amount.rb

@@ -14,7 +14,7 @@ module Spree
       private
 
       def weighted_order_adjustment_amount(inventory_unit)
-        inventory_unit.order.adjustments.eligible.non_tax.sum(:amount) * percentage_of_order_total(inventory_unit)
+        inventory_unit.order.adjustments.non_tax.sum(:amount) * percentage_of_order_total(inventory_unit)
       end
 
       def weighted_line_item_amount(inventory_unit)

data/app/models/spree/carton.rb

@@ -46,11 +46,11 @@ class Spree::Carton < Spree::Base
   end
 
   def manifest
-    @manifest ||= Spree::ShippingManifest.new(inventory_units: inventory_units).items
+    @manifest ||= Spree::ShippingManifest.new(inventory_units:).items
   end
 
   def manifest_for_order(order)
-    Spree::ShippingManifest.new(inventory_units: inventory_units).for_order(order).items
+    Spree::ShippingManifest.new(inventory_units:).for_order(order).items
   end
 
   def any_exchanges?

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    class StateMachines
+      # Inventory Units' 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 InventoryUnit
+        extend ActiveSupport::Concern
+
+        included do
+          state_machine initial: :on_hand do
+            event :fill_backorder do
+              transition to: :on_hand, from: :backordered
+            end
+            after_transition on: :fill_backorder, do: :fulfill_order
+
+            event :ship do
+              transition to: :shipped, if: :allow_ship?
+            end
+
+            event :return do
+              transition to: :returned, from: :shipped
+            end
+
+            event :cancel do
+              transition to: :canceled, from: ::Spree::InventoryUnit::CANCELABLE_STATES.map(&:to_sym)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/spree/core/state_machines/order/class_methods.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    class StateMachines
+      module Order
+        module ClassMethods
+          attr_accessor :previous_states
+          attr_writer :next_event_transitions, :checkout_steps, :removed_transitions
+
+          def checkout_flow(&block)
+            if block_given?
+              @checkout_flow = block
+              define_state_machine!
+            else
+              @checkout_flow
+            end
+          end
+
+          def define_state_machine!
+            self.checkout_steps = {}
+            self.next_event_transitions = []
+            self.previous_states = [:cart]
+            self.removed_transitions = []
+
+            # Build the checkout flow using the checkout_flow defined either
+            # within the Order class, or a decorator for that class.
+            #
+            # This method may be called multiple times depending on if the
+            # checkout_flow is re-defined in a decorator or not.
+            instance_eval(&checkout_flow)
+
+            klass = self
+
+            # To avoid multiple occurrences of the same transition being defined
+            # On first definition, state_machines will not be defined
+            state_machines.clear if respond_to?(:state_machines)
+            state_machine :state, initial: :cart, use_transactions: false do
+              klass.next_event_transitions.each { |state| transition(state.merge(on: :next)) }
+
+              # Persist the state on the order
+              after_transition do |order, transition|
+                # Hard to say if this is really necessary, it was introduced in this commit:
+                # https://github.com/mamhoff/solidus/commit/fa1d66c42e4c04ee7cd1c20d87e4cdb74a226d3d
+                # But it seems to be harmless, so we'll keep it for now.
+                order.state = order.state # rubocop:disable Lint/SelfAssignment
+
+                order.state_changes.create(
+                  previous_state: transition.from,
+                  next_state:     transition.to,
+                  name:           'order',
+                  user_id:        order.user_id
+                )
+                order.save
+              end
+
+              event :cancel do
+                transition to: :canceled, if: :allow_cancel?, from: :complete
+              end
+
+              event :return do
+                transition to: :returned, from: [:complete, :awaiting_return], if: :all_inventory_units_returned?
+              end
+
+              event :resume do
+                transition to: :resumed, from: :canceled, if: :canceled?
+              end
+
+              event :authorize_return do
+                transition to: :awaiting_return, from: :complete
+              end
+
+              event :complete do
+                transition to: :complete, from: klass.checkout_steps.keys.last
+              end
+
+              if states[:payment]
+                event :payment_failed do
+                  transition to: :payment, from: :confirm
+                end
+
+                after_transition to: :complete, do: :add_payment_sources_to_wallet
+                before_transition to: :payment, do: :add_default_payment_from_wallet
+                before_transition to: :payment, do: :ensure_billing_address
+
+                before_transition to: :confirm, do: :add_store_credit_payments
+
+                # see also process_payments_before_complete below which needs to
+                # be added in the correct sequence.
+              end
+
+              before_transition from: :cart, do: :ensure_line_items_present
+
+              if states[:address]
+                before_transition to: :address, do: :assign_default_user_addresses
+                before_transition from: :address, do: :persist_user_address!
+              end
+
+              if states[:delivery]
+                before_transition to: :delivery, do: :ensure_shipping_address
+                before_transition to: :delivery, do: :create_proposed_shipments
+                before_transition to: :delivery, do: :ensure_available_shipping_rates
+              end
+
+              before_transition to: :resumed, do: :ensure_line_item_variants_are_not_deleted
+              before_transition to: :resumed, do: :validate_line_item_availability
+
+              # Sequence of before_transition to: :complete
+              # calls matter so that we do not process payments
+              # until validations have passed
+              before_transition to: :complete, do: :validate_line_item_availability
+              before_transition to: :complete, do: :ensure_promotions_eligible
+              before_transition to: :complete, do: :ensure_line_item_variants_are_not_deleted
+              before_transition to: :complete, do: :ensure_inventory_units
+              if states[:payment]
+                before_transition to: :complete, do: :process_payments_before_complete
+              end
+
+              after_transition to: :complete, do: :finalize
+              after_transition to: :resumed,  do: :after_resume
+              after_transition to: :canceled, do: :after_cancel
+
+              after_transition from: any - :cart, to: any - [:confirm, :complete] do |order|
+                order.recalculate
+              end
+
+              after_transition do |order, transition|
+                order.logger.debug "Order #{order.number} transitioned from #{transition.from} to #{transition.to} via #{transition.event}"
+              end
+
+              after_failure do |order, transition|
+                order.logger.debug "Order #{order.number} halted transition on event #{transition.event} state #{transition.from}: #{order.errors.full_messages.join}"
+              end
+            end
+          end
+
+          def go_to_state(name, options = {})
+            checkout_steps[name] = options
+            previous_states.each do |state|
+              add_transition({ from: state, to: name }.merge(options))
+            end
+            if options[:if]
+              previous_states << name
+            else
+              self.previous_states = [name]
+            end
+          end
+
+          def insert_checkout_step(name, options = {})
+            before = options.delete(:before)
+            after = options.delete(:after) unless before
+            after = checkout_steps.keys.last unless before || after
+
+            cloned_steps = checkout_steps.clone
+            cloned_removed_transitions = removed_transitions.clone
+            checkout_flow do
+              cloned_steps.each_pair do |key, value|
+                go_to_state(name, options) if key == before
+                go_to_state(key, value)
+                go_to_state(name, options) if key == after
+              end
+              cloned_removed_transitions.each do |transition|
+                remove_transition(transition)
+              end
+            end
+          end
+
+          def remove_checkout_step(name)
+            cloned_steps = checkout_steps.clone
+            cloned_removed_transitions = removed_transitions.clone
+            checkout_flow do
+              cloned_steps.each_pair do |key, value|
+                go_to_state(key, value) unless key == name
+              end
+              cloned_removed_transitions.each do |transition|
+                remove_transition(transition)
+              end
+            end
+          end
+
+          def remove_transition(options = {})
+            removed_transitions << options
+            next_event_transitions.delete(find_transition(options))
+          end
+
+          def find_transition(options = {})
+            return nil if options.nil? || !options.include?(:from) || !options.include?(:to)
+
+            next_event_transitions.detect do |transition|
+              transition[options[:from].to_sym] == options[:to].to_sym
+            end
+          end
+
+          def next_event_transitions
+            @next_event_transitions ||= []
+          end
+
+          def checkout_steps
+            @checkout_steps ||= {}
+          end
+
+          def checkout_step_names
+            checkout_steps.keys
+          end
+
+          def add_transition(options)
+            next_event_transitions << { options.delete(:from) => options.delete(:to) }.merge(options)
+          end
+
+          def removed_transitions
+            @removed_transitions ||= []
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Spree
+  module Core
+    class StateMachines
+      module Order
+        def self.included(klass)
+          klass.extend ClassMethods
+        end
+
+        def checkout_steps
+          steps = self.class.checkout_steps.each_with_object([]) { |(step, options), checkout_steps|
+            next if options.include?(:if) && !options[:if].call(self)
+
+            checkout_steps << step
+          }.map(&:to_s)
+          # Ensure there is always a complete step
+          steps << "complete" unless steps.include?("complete")
+          steps
+        end
+
+        def has_checkout_step?(step)
+          step.present? && checkout_steps.include?(step)
+        end
+
+        def passed_checkout_step?(step)
+          has_checkout_step?(step) && checkout_step_index(step) < checkout_step_index(state)
+        end
+
+        def checkout_step_index(step)
+          checkout_steps.index(step).to_i
+        end
+
+        def can_go_to_state?(state)
+          return false unless has_checkout_step?(self.state) && has_checkout_step?(state)
+
+          checkout_step_index(state) > checkout_step_index(self.state)
+        end
+      end
+    end
+  end
+end