spree_core 5.6.0 → 6.0.0.beta1

data/app/models/spree/delivery_method_rules/company_rule.rb

@@ -0,0 +1,24 @@
+module Spree
+  module DeliveryMethodRules
+    # Splits freight from parcel by who is buying.
+    #
+    # On, the method is offered only to orders placed for a company — a
+    # carton or container tier disappears from retail carts. Off, it is
+    # offered only to orders that are not, which is how a merchant keeps
+    # parcel methods away from wholesale buyers. A method with no company
+    # rule at all is offered to both, so the rule is only ever added to
+    # state a split.
+    #
+    # Presence only. Which company gets which freight terms is Enterprise
+    # territory, and open-source Spree has no company roles to gate on.
+    class CompanyRule < Spree::DeliveryMethodRule
+      preference :company_orders_only, :boolean, default: true
+
+      def eligible?(package)
+        buying_for_a_company = package.owner&.b2b? || false
+
+        preferred_company_orders_only ? buying_for_a_company : !buying_for_a_company
+      end
+    end
+  end
+end

data/app/models/spree/delivery_method_rules/excluded_products_rule.rb

@@ -0,0 +1,48 @@
+module Spree
+  module DeliveryMethodRules
+    # Blocks the method for packages containing any of the attached products
+    # ("fragile item can't ship express"). Products hang off the concrete
+    # spree_delivery_method_rule_products join table — catalog-scale
+    # references never live in preferences. A rule with no products passes,
+    # matching the empty-preference fail-open convention.
+    class ExcludedProductsRule < Spree::DeliveryMethodRule
+      has_many :delivery_method_rule_products, class_name: 'Spree::DeliveryMethodRuleProduct',
+               foreign_key: :delivery_method_rule_id, dependent: :destroy,
+               inverse_of: :delivery_method_rule
+      has_many :products, class_name: 'Spree::Product', through: :delivery_method_rule_products
+
+      self.additional_permitted_attributes = [product_ids: []]
+
+      # Excluded product ids in prefixed form. Plucked rather than hydrating N
+      # Product rows just to re-encode their ids, but read through the products
+      # association so soft-deleted products drop out — a client resubmitting
+      # this list must not be told a product it never chose is unreachable.
+      # Sorted so clients can compare a response against what they sent.
+      #
+      # @return [Array<String>]
+      def product_prefixed_ids
+        products.pluck(:id).sort.map { |id| Spree::Product.prefixed_id_for(id) }
+      end
+
+      # Asks whether any of the package's products is excluded, rather than
+      # loading the whole exclusion list — the join table's composite index
+      # answers it without transferring rows.
+      def eligible?(package)
+        product_ids = package.contents.map { |item| item.variant.product_id }.uniq
+        return true if product_ids.empty?
+
+        # `target` is whatever is already in memory, so reading it never
+        # triggers a load. It covers links assigned but not yet saved — the
+        # admin controller assigns products before saving the rule.
+        return false if delivery_method_rule_products.target.any? { |link|
+          link.new_record? && product_ids.include?(link.product_id)
+        }
+        # An unsaved rule has no rows to query, and asking would still cost a
+        # round trip.
+        return true if new_record?
+
+        !delivery_method_rule_products.exists?(product_id: product_ids)
+      end
+    end
+  end
+end

data/app/models/spree/delivery_method_rules/item_total_rule.rb

@@ -0,0 +1,19 @@
+module Spree
+  module DeliveryMethodRules
+    # Bounds the method by the package's item total (inclusive min/max in the
+    # owner's currency). Empty preferences pass — half-configured rules fail
+    # open per-rule, matching the PromotionRule/PriceRule convention.
+    class ItemTotalRule < Spree::DeliveryMethodRule
+      preference :minimum_amount, :decimal, default: nil, nullable: true
+      preference :maximum_amount, :decimal, default: nil, nullable: true
+
+      def eligible?(package)
+        total = package.item_total
+        return false if preferred_minimum_amount.present? && total < preferred_minimum_amount
+        return false if preferred_maximum_amount.present? && total > preferred_maximum_amount
+
+        true
+      end
+    end
+  end
+end

data/app/models/spree/delivery_method_rules/volume_rule.rb

@@ -0,0 +1,35 @@
+module Spree
+  module DeliveryMethodRules
+    # Bounds the method by the packed volume of the shipment, in cubic
+    # meters. This is what turns a wholesale tier table into configuration: a
+    # "Pallet" method takes 1–15 CBM, a "20ft container" 15–33, and the
+    # estimator offers whichever one the order actually fills.
+    #
+    # Unlike {WeightRule}, the compared value is always converted to CBM
+    # first. Dimensions are stored in whatever unit the merchant typed, and
+    # inches read as centimeters overstate a carton roughly sixteenfold — too
+    # large an error to leave to convention.
+    class VolumeRule < Spree::DeliveryMethodRule
+      preference :minimum_volume, :decimal, default: nil, nullable: true
+      preference :maximum_volume, :decimal, default: nil, nullable: true
+
+      def eligible?(package)
+        summary = package.freight_summary
+        volume = summary.total_volume
+
+        # A partly measured catalog understates the load — wholly unmeasured
+        # goods roll up to zero, and one measured SKU among five reports a
+        # fraction of the truth. Either way the figure is a floor, not a
+        # measurement, so it may raise a shipment into a tier but never
+        # exclude it from one: failing a minimum on an understated volume
+        # hides the method from exactly the order it was built for, with
+        # nothing for the merchant to see. A maximum still applies, since
+        # passing one on too small a number errs toward offering the method.
+        return false if preferred_minimum_volume.present? && summary.complete? && volume < preferred_minimum_volume
+        return false if preferred_maximum_volume.present? && volume > preferred_maximum_volume
+
+        true
+      end
+    end
+  end
+end

data/app/models/spree/delivery_method_rules/weight_rule.rb

@@ -0,0 +1,19 @@
+module Spree
+  module DeliveryMethodRules
+    # Bounds the method by the package weight (inclusive min/max). Compares
+    # raw numbers in the store's implicit weight unit — the same semantics as
+    # variant weights themselves.
+    class WeightRule < Spree::DeliveryMethodRule
+      preference :minimum_weight, :decimal, default: nil, nullable: true
+      preference :maximum_weight, :decimal, default: nil, nullable: true
+
+      def eligible?(package)
+        weight = package.weight
+        return false if preferred_minimum_weight.present? && weight < preferred_minimum_weight
+        return false if preferred_maximum_weight.present? && weight > preferred_maximum_weight
+
+        true
+      end
+    end
+  end
+end

data/app/models/spree/delivery_method_service.rb

@@ -0,0 +1,24 @@
+module Spree
+  # One carrier service a delivery method offers ("UPS" / "Ground"), with an
+  # optional display label and markup overriding the method's defaults. A
+  # method with no service rows offers every service its rate provider
+  # returns — rows exist to narrow or customize, never to enable.
+  class DeliveryMethodService < Spree.base_class
+    has_prefix_id :dms
+
+    acts_as_list scope: :delivery_method
+
+    belongs_to :delivery_method, class_name: 'Spree::DeliveryMethod', inverse_of: :services
+
+    validates :carrier, :service, presence: true
+    validates :service, uniqueness: { scope: [:delivery_method_id, :carrier] }
+    validates :markup_flat, :markup_percent, numericality: true, allow_nil: true
+
+    # The identity DeliveryRateProvider::Estimate#service_key matches against.
+    #
+    # @return [String]
+    def service_key
+      "#{carrier}/#{service}"
+    end
+  end
+end

data/app/models/spree/delivery_method_stock_location.rb

@@ -0,0 +1,11 @@
+module Spree
+  # Restricts a delivery method to specific stock locations. For pickup
+  # methods this is the configured pickup-location set; an empty set means
+  # every pickup-enabled location qualifies.
+  class DeliveryMethodStockLocation < Spree.base_class
+    belongs_to :delivery_method, class_name: 'Spree::DeliveryMethod', inverse_of: :delivery_method_stock_locations
+    belongs_to :stock_location, class_name: 'Spree::StockLocation'
+
+    validates :stock_location_id, uniqueness: { scope: :delivery_method_id }
+  end
+end

data/app/models/spree/delivery_origin_group.rb

@@ -0,0 +1,73 @@
+module Spree
+  # Partitions a delivery profile's fulfillment origins: every zone and
+  # method belongs to a group, so the same products can quote different
+  # rates depending on which warehouse fulfills them. A profile always has
+  # at least one group; the auto-created default is nameless with no
+  # location members, which means every store location — simple stores
+  # never see the layer.
+  class DeliveryOriginGroup < Spree.base_class
+    has_prefix_id :og
+
+    acts_as_list scope: :delivery_profile
+
+    include Spree::HasListPosition
+
+    belongs_to :delivery_profile, class_name: 'Spree::DeliveryProfile', inverse_of: :delivery_origin_groups
+
+    has_many :delivery_origin_group_locations, class_name: 'Spree::DeliveryOriginGroupLocation',
+             dependent: :destroy, inverse_of: :delivery_origin_group
+    has_many :stock_locations, through: :delivery_origin_group_locations, class_name: 'Spree::StockLocation'
+    # The group contains its zones and methods — that is how the dashboard
+    # nests them and how a merchant reads it — so deleting the group takes
+    # them with it rather than asking for them to be emptied by hand first.
+    # (Destroying a zone cascades to its own methods in turn.)
+    has_many :delivery_zones, class_name: 'Spree::DeliveryZone', dependent: :destroy,
+             inverse_of: :delivery_origin_group
+    has_many :delivery_methods, class_name: 'Spree::DeliveryMethod', dependent: :destroy,
+             inverse_of: :delivery_origin_group
+
+    delegate :store, to: :delivery_profile
+
+    # Only one rule survives: a profile needs somewhere for delivery to live,
+    # so its last group stays. Anything hanging off a group goes with it.
+    def can_be_deleted?
+      delivery_profile.delivery_origin_groups.where.not(id: id).exists?
+    end
+
+    # Whether packages originating from this stock location are served by
+    # the group's zones and methods. No linked locations means every store
+    # location.
+    #
+    # Allocation asks this once per location per unit, so the membership is
+    # read through the loaded association rather than re-queried each call.
+    #
+    # @param stock_location [Spree::StockLocation, nil]
+    # @return [Boolean]
+    def covers_location?(stock_location)
+      return false if stock_location.nil?
+      return true if member_stock_location_ids.empty?
+      # A narrowed group names which of the *operator's* warehouses ship this
+      # kind of goods ("pallets go out of Warehouse B"), and says nothing
+      # about where a seller keeps stock. Reading it as a store-wide allowlist
+      # would make every seller's inventory unallocatable
+      # (docs/plans/6.0-multi-vendor-marketplace.md, Decision 13).
+      return true if stock_location.seller_id.present?
+
+      member_stock_location_ids.include?(stock_location.id)
+    end
+
+    # @return [Array<Integer>] ids of the locations this group is limited to
+    def member_stock_location_ids
+      @member_stock_location_ids ||= delivery_origin_group_locations.map(&:stock_location_id)
+    end
+
+    # The locations this group fulfills from.
+    #
+    # @return [ActiveRecord::Relation<Spree::StockLocation>]
+    def fulfillable_stock_locations
+      return store.stock_locations if member_stock_location_ids.empty?
+
+      store.stock_locations.where(id: stock_locations.select(:id))
+    end
+  end
+end

data/app/models/spree/delivery_origin_group_location.rb

@@ -0,0 +1,9 @@
+module Spree
+  class DeliveryOriginGroupLocation < Spree.base_class
+    belongs_to :delivery_origin_group, class_name: 'Spree::DeliveryOriginGroup',
+               inverse_of: :delivery_origin_group_locations
+    belongs_to :stock_location, class_name: 'Spree::StockLocation'
+
+    validates :stock_location_id, uniqueness: { scope: :delivery_origin_group_id }
+  end
+end

data/app/models/spree/delivery_profile.rb

@@ -0,0 +1,141 @@
+module Spree
+  # The grouping that decides how a set of products ships: which origins can
+  # fulfill them, which destination zones apply, and which delivery methods
+  # are offered. Products reference a profile directly (nil = the store's
+  # default profile); carts split per profile, and a package's candidate
+  # methods are exactly its profile's methods.
+  #
+  # Formerly Spree::ShippingCategory — the table is renamed in place, so 5.x
+  # category assignments become profile assignments (see
+  # docs/plans/6.0-delivery-profiles.md).
+  class DeliveryProfile < Spree.base_class
+    include Spree::SingleStoreResource
+    include Spree::HasListPosition
+
+    has_prefix_id :fp
+
+    acts_as_list scope: :store
+
+    belongs_to :store, class_name: 'Spree::Store', optional: true
+
+    has_many :products, class_name: 'Spree::Product', dependent: :restrict_with_error, inverse_of: :delivery_profile
+    # Origin groups partition the profile's fulfillment origins; zones and
+    # methods hang off a group, so per-origin rate tables need no second
+    # profile. Every profile has at least one (the nameless default, whose
+    # empty membership means every store location).
+    has_many :delivery_origin_groups, -> { order(:position) }, class_name: 'Spree::DeliveryOriginGroup',
+             dependent: :destroy, inverse_of: :delivery_profile
+    has_many :delivery_zones, class_name: 'Spree::DeliveryZone', dependent: :destroy,
+             inverse_of: :delivery_profile
+    has_many :delivery_methods, class_name: 'Spree::DeliveryMethod', dependent: :destroy,
+             inverse_of: :delivery_profile
+
+    after_create :create_default_origin_group
+
+    validates :name, presence: true, uniqueness: { case_sensitive: false, scope: :store_id }
+
+    registers_subclasses_via { Spree.delivery_profile_types }
+
+    # Whether a delivery method using the given fulfillment provider may
+    # join this profile — the guard that keeps a Digital profile from
+    # quietly gaining a shipping method and reinterpreting its products.
+    #
+    # @param _provider_class [Class] a Spree::FulfillmentProvider subclass
+    # @return [Boolean]
+    def accepts_provider?(_provider_class)
+      true
+    end
+
+    # Whether this profile's products are delivered digitally. Declared by
+    # the kind, not derived from the method set — a freshly created profile
+    # with no methods yet must already know what it is.
+    def digital?
+      false
+    end
+
+    # Whether checkout must collect a shipping address for this profile's
+    # products. Kinds override; the physical default derives from methods'
+    # providers (a pickup-only profile needs none).
+    def requires_shipping_address?
+      delivery_methods.any?(&:requires_address?)
+    end
+
+    # Whether this profile's products can be collected at a merchant counter
+    # — true when any of its methods hands goods over via a pickup provider.
+    def offers_pickup?
+      delivery_methods.any?(&:pickup?)
+    end
+
+    # Whether this profile's products ship to a customer address.
+    def offers_shipping?
+      delivery_methods.any?(&:requires_address?)
+    end
+
+    before_save :ensure_one_default
+
+    scope :order_default, -> { order(default: :desc, position: :asc) }
+
+    # The profile products fall back to when they reference none. Every
+    # store has exactly one.
+    #
+    # @param store [Spree::Store]
+    # @return [Spree::DeliveryProfile, nil]
+    def self.default_for(store)
+      where(store: store, default: true).first
+    end
+
+    # The default profile is load-bearing (products fall back to it); other
+    # profiles must be empty of products first.
+    def can_be_deleted?
+      !default? && products.none?
+    end
+
+    # Whether packages originating from this stock location can carry the
+    # profile's products — true when any origin group covers it.
+    #
+    # @param stock_location [Spree::StockLocation, nil]
+    # @return [Boolean]
+    def covers_location?(stock_location)
+      return false if stock_location.nil?
+
+      delivery_origin_groups.any? { |group| group.covers_location?(stock_location) }
+    end
+
+    # The locations this profile's products may be allocated from — the
+    # union of its origin groups' locations. Any group with no members
+    # widens the union to every store location.
+    #
+    # @return [ActiveRecord::Relation<Spree::StockLocation>]
+    def fulfillable_stock_locations
+      groups = delivery_origin_groups.includes(:delivery_origin_group_locations)
+      # Any group without members widens the union to every store location.
+      return store.stock_locations if groups.empty? || groups.any? { |group| group.member_stock_location_ids.empty? }
+
+      store.stock_locations.where(id: groups.flat_map(&:member_stock_location_ids).uniq)
+    end
+
+    # The group zones and methods join when none is named — the first by
+    # position, which for untouched profiles is the auto-created default.
+    #
+    # @return [Spree::DeliveryOriginGroup, nil]
+    def default_origin_group
+      delivery_origin_groups.first
+    end
+
+    private
+
+    def create_default_origin_group
+      delivery_origin_groups.create!
+    end
+
+    # Mirrors StockLocation#ensure_one_default: promoting a profile demotes
+    # the previous default; the default flag can never be simply removed.
+    def ensure_one_default
+      if default?
+        Spree::DeliveryProfile.where(store_id: store_id, default: true).where.not(id: id).update_all(default: false)
+      elsif default_was && will_save_change_to_default?
+        self.default = true
+      end
+    end
+  end
+end

data/app/models/spree/delivery_profiles/digital.rb

@@ -0,0 +1,20 @@
+module Spree
+  module DeliveryProfiles
+    # Digital goods: products in this profile are delivered digitally and
+    # checkout collects no shipping address. Only digital-provider methods
+    # may join, so the profile can never quietly reinterpret its products.
+    class Digital < Spree::DeliveryProfile
+      def accepts_provider?(provider_class)
+        provider_class.digital?
+      end
+
+      def digital?
+        true
+      end
+
+      def requires_shipping_address?
+        false
+      end
+    end
+  end
+end

data/app/models/spree/delivery_profiles/shipping.rb

@@ -0,0 +1,12 @@
+module Spree
+  module DeliveryProfiles
+    # Physical goods — the default profile kind. Accepts any non-digital
+    # provider (shipping, pickup, extension mechanics); the store's
+    # "General" default profile is one of these.
+    class Shipping < Spree::DeliveryProfile
+      def accepts_provider?(provider_class)
+        !provider_class.digital?
+      end
+    end
+  end
+end

data/app/models/spree/delivery_rate.rb

@@ -0,0 +1,164 @@
+module Spree
+  class DeliveryRate < Spree.base_class
+    has_prefix_id :dr
+
+    # Carrier payload from the rate provider (quote ids, service codes) —
+    # a plain single column per the house rule for new columns, not the
+    # legacy public/private Metadata pair.
+    serialize :metadata, coder: Spree::Metadata::HashSerializer
+
+    belongs_to :fulfillment, class_name: 'Spree::Fulfillment'
+    belongs_to :tax_rate, -> { with_deleted }, class_name: 'Spree::TaxRate', optional: true
+    belongs_to :delivery_method, -> { with_deleted }, class_name: 'Spree::DeliveryMethod', inverse_of: :delivery_rates
+    # Legacy names — removed in 6.1.
+    belongs_to :shipment, class_name: 'Spree::Fulfillment', foreign_key: :fulfillment_id, optional: true, deprecated: true
+    belongs_to :shipping_method, -> { with_deleted }, class_name: 'Spree::DeliveryMethod', foreign_key: :delivery_method_id, optional: true, deprecated: true
+    alias_attribute :shipment_id, :fulfillment_id
+    alias_attribute :shipping_method_id, :delivery_method_id
+
+    extend Spree::DisplayMoney
+
+    money_methods :base_price, :final_price, :tax_amount, :additional_tax_total, :included_tax_total, :tax_total
+
+    delegate :order, :currency, :with_free_shipping_promotion?, to: :fulfillment
+    delegate :code, to: :delivery_method, prefix: true
+
+    # Provider-priced rates carry their own display name ("UPS Ground", or a
+    # merchant label override) set by the Estimator; calculator rates store
+    # nil and read as the delivery method's name, preserving the historic
+    # delegate behavior.
+    #
+    # @return [String]
+    def name
+      self[:name].presence || delivery_method.name
+    end
+
+    def display_price
+      return quoted_after_review if unpriced?
+
+      price = display_base_price.to_s
+
+      return price if tax_rate.nil? || tax_amount.zero? || !tax_rate.show_rate_in_label
+
+      Spree.t(
+        tax_rate.included_in_price? ? :including_tax : :excluding_tax,
+        scope: 'shipping_rates.display_price',
+        price: price,
+        tax_amount: display_tax_amount,
+        tax_rate_name: tax_rate.name
+      )
+    end
+    alias display_cost display_price
+    alias_attribute :base_price, :cost
+
+    # Returns true if the shipping rate is free.
+    #
+    # An unpriced rate is never free — its cost is zero because nobody has
+    # quoted it yet, and saying "free shipping" over a container of goods
+    # would be a promise the merchant cannot keep.
+    #
+    # @return [Boolean]
+    def free?
+      !unpriced? && final_price.zero?
+    end
+
+    # The logistics the freight provider computed when it quoted this rate —
+    # cartons, pallets, cubic meters, gross weight. Frozen at estimate time
+    # and never re-derived, so an order keeps reporting what it actually
+    # shipped as.
+    #
+    # @return [Spree::FreightSummary, nil]
+    def freight_summary
+      @freight_summary ||= Spree::FreightSummary.from_metadata(metadata&.dig('freight_summary'))
+    end
+
+    # Returns the tax amount for the shipping rate, computed directly from
+    # the rate configuration (rates display estimated tax before a
+    # fulfillment exists, so this never reads TaxLine rows).
+    #
+    # @return [BigDecimal]
+    def tax_amount
+      @tax_amount ||= if tax_rate.nil?
+                        BigDecimal(0)
+                      elsif tax_rate.included_in_price?
+                        (cost / (1 + tax_rate.amount) * tax_rate.amount).round(2)
+                      else
+                        (cost * tax_rate.amount).round(2)
+                      end
+    end
+
+    # Returns the additional tax total for the shipping rate
+    #
+    # @return [BigDecimal]
+    def additional_tax_total
+      tax_rate&.included_in_price? ? BigDecimal(0) : tax_amount
+    end
+
+    # Returns the included tax total for the shipping rate
+    #
+    # @return [BigDecimal]
+    def included_tax_total
+      tax_rate&.included_in_price? ? tax_amount : BigDecimal(0)
+    end
+
+    alias tax_total tax_amount
+    alias display_tax_total display_tax_amount
+
+    # returns base price - any available discounts for this Shipment
+    # useful when you want to present a list of available shipping rates
+    def final_price
+      if with_free_shipping_promotion? || cost < -discount_amount
+        BigDecimal(0)
+      else
+        cost + discount_amount
+      end
+    end
+    alias total final_price
+
+    # Every money display on an unpriced rate says the same thing. A
+    # storefront that renders the total rather than the cost would otherwise
+    # put "$0.00" — free freight — in front of a buyer whose shipment has not
+    # been quoted yet.
+    #
+    # Keeps the generated method's shape: the same keyword options, and a
+    # Spree::Money on every priced path, so callers doing money arithmetic on
+    # the total are unaffected.
+    #
+    # @return [String, Spree::Money]
+    def display_final_price(**options)
+      return quoted_after_review if unpriced?
+
+      Spree::Money.new(final_price, { currency: currency }.merge(options))
+    end
+    alias display_total display_final_price
+
+    # Returns the delivery range for the shipping method
+    #
+    # @return [String]
+    def delivery_range
+      return unless delivery_method.delivery_range
+
+      delivery_method.delivery_range
+    end
+
+    # Returns the display delivery range for the shipping method
+    #
+    # @return [String]
+    def display_delivery_range
+      return unless delivery_range
+
+      Spree.t(:display_delivery_range, delivery_range: delivery_range)
+    end
+
+    private
+
+    # What every money display on this rate reads instead of an amount.
+    def quoted_after_review
+      Spree.t('delivery_rates.quoted_after_review')
+    end
+
+    def discount_amount
+      fulfillment.discounts.promotion.sum(:amount)
+    end
+  end
+end