spree_core 6.0.0.beta2 → 6.0.0.beta3

data/app/models/spree/exports/customers.rb

@@ -3,8 +3,8 @@ module Spree
     class Customers < Spree::Export
       def scope_includes
         [
-          { bill_address: :state },
-          { ship_address: :state },
+          :bill_address,
+          :ship_address,
           { custom_fields: :custom_field_definition }
         ]
       end

data/app/models/spree/fulfillment_group.rb

@@ -0,0 +1,127 @@
+module Spree
+  # One real parcel of a purchase, across however many orders it belongs to.
+  #
+  # A checkout that spans several sellers divides into one order per seller,
+  # and a parcel holding more than one seller's goods divides with them: the
+  # split clones the fulfillment onto each sibling and apportions the one
+  # delivery charge the customer was quoted between the halves
+  # (+Spree::Carts::SplitBySeller+). So "how many orders" and "how many
+  # parcels" are different numbers, and anything telling a customer what to
+  # expect has to answer the second — three orders shipping out of one
+  # warehouse are still one box, and saying otherwise promises deliveries that
+  # will never arrive.
+  #
+  # Ephemeral, never persisted: it is a reading of the fulfillments, and they
+  # remain the record.
+  class FulfillmentGroup
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+
+    attr_accessor :fulfillments
+
+    # Collapses divided halves back into the parcels that actually ship.
+    #
+    # Halves of a divided parcel share their origin and their delivery method,
+    # because the clone copies both. Genuinely separate parcels differ in at
+    # least one: a seller shipping from their own warehouse differs in origin
+    # even when quoted on a marketplace method the operator shares with them
+    # (+DeliveryMethod#available_to_sellers+), and two parcels leaving one
+    # warehouse differ in method. The pair is safe as an identity because the
+    # packer builds one package per stock location per order, so it cannot
+    # produce two same-origin same-method fulfillments on its own — only the
+    # split can.
+    #
+    # @param fulfillments [Enumerable<Spree::Fulfillment>]
+    # @return [Array<Spree::FulfillmentGroup>] in the order the fulfillments
+    #   were given, so a caller that ordered them decides how the parcels read
+    def self.build_from(fulfillments)
+      fulfillments.group_by { |fulfillment| identity(fulfillment) }.
+        map { |_identity, members| new(fulfillments: members) }
+    end
+
+    # @return [Array] origin and delivery method — see {.build_from}
+    def self.identity(fulfillment)
+      [fulfillment.stock_location_id, fulfillment.selected_delivery_rate&.delivery_method_id]
+    end
+
+    # @return [Spree::DeliveryMethod, nil]
+    def delivery_method
+      primary.delivery_method
+    end
+
+    # What the customer chose to be delivered by, named as they were shown it —
+    # a provider rate carries its own label ("UPS Ground"), a calculated one
+    # reads through to the method.
+    #
+    # @return [String, nil]
+    def name
+      primary.selected_delivery_rate&.name || delivery_method&.name
+    end
+
+    # @return [Spree::StockLocation, nil]
+    def stock_location
+      primary.stock_location
+    end
+
+    # What this parcel costs to deliver: the halves' apportioned shares added
+    # back up, which is what the customer was quoted for it before the split
+    # divided anything.
+    #
+    # @return [BigDecimal]
+    def cost
+      fulfillments.sum { |fulfillment| fulfillment.discounted_cost.to_d }
+    end
+
+    # @return [String, Spree::Money] the forwarder's placeholder while a
+    #   freight rate is unpriced, money otherwise
+    def display_cost(**options)
+      return primary.display_cost(**options) if unpriced?
+
+      Spree::Money.new(cost, { currency: primary.currency }.merge(options))
+    end
+
+    # @return [Boolean]
+    def unpriced?
+      fulfillments.any?(&:unpriced?)
+    end
+
+    # @return [Array<Spree::LineItem>] every line this parcel carries part of
+    def line_items
+      fulfillments.flat_map(&:line_items).uniq
+    end
+
+    # What the parcel carries, each line with the quantity *this* parcel holds.
+    #
+    # A line item can be packed from two warehouses, which puts it in two
+    # parcels — printing the line's own quantity in both would show the
+    # customer more goods than they bought, and charge for them twice.
+    #
+    # @return [Array<Spree::Fulfillment::ManifestItem>]
+    def manifest
+      fulfillments.flat_map(&:manifest).group_by(&:line_item).map do |line_item, items|
+        Spree::Fulfillment::ManifestItem.new(line_item, line_item.variant, items.sum(&:quantity), nil)
+      end
+    end
+
+    # Who is shipping it. More than one only where a marketplace's own
+    # warehouse ships several sellers' goods in one box.
+    #
+    # @return [Array<Spree::Seller>]
+    def sellers
+      fulfillments.filter_map { |fulfillment| fulfillment.order&.seller }.uniq
+    end
+
+    # @return [Array<Spree::Order>]
+    def orders
+      fulfillments.filter_map(&:order).uniq
+    end
+
+    private
+
+    # The half that answers for the parcel. Every half carries the same origin,
+    # method and rate name — only the money was divided.
+    def primary
+      fulfillments.first
+    end
+  end
+end

data/app/models/spree/gift_card.rb

@@ -146,6 +146,15 @@ module Spree
       code.upcase
     end
 
+    # The code with all but its last four characters hidden — for a reader who
+    # may see which card paid for an order but must not be able to spend it.
+    #
+    # @return [String]
+    def masked_code
+      visible = display_code.last(4)
+      ('*' * [display_code.length - visible.length, 0].max) + visible
+    end
+
     # Checks if the gift card is expired
     # @return [Boolean]
     def expired?

data/app/models/spree/invitation.rb

@@ -51,7 +51,7 @@ module Spree
     # Callbacks
     #
     after_initialize :set_defaults, if: :new_record?
-    before_validation :set_role_and_resource, if: :new_record?
+    before_validation :set_resource, if: :new_record?
     before_validation :set_invitee_from_email, on: :create
     after_commit :publish_invitation_created_event, on: :create, unless: :skip_email
 
@@ -97,10 +97,22 @@ module Spree
       true
     end
 
-    # Resends the invitation email if the invitation is pending and not expired
+    # The link that accepts this invitation. It carries the token, which is the
+    # only credential acceptance asks for, so hand it only to a caller who could
+    # have sent the invitation themselves.
+    #
+    # @return [String] an absolute URL when the app's origin is configured, otherwise a path
+    def acceptance_url
+      Rails.application.routes.url_helpers.admin_invitation_acceptance_url(self)
+    end
+
+    # Resends the invitation email if the invitation is pending and not expired.
+    # The token is rotated first, so a link that leaked with the earlier email
+    # stops working.
     def resend!
       return if expired? || deleted? || accepted?
 
+      regenerate_token
       publish_event('invitation.resent')
     end
 
@@ -123,10 +135,11 @@ module Spree
     # A role names what it governs, so the invitation follows it — one carrying
     # another resource's role would grant access somewhere the inviter never
     # named. Resolved at validation rather than on initialize, since a caller's
-    # own `resource` is not assigned yet when the record is instantiated.
-    def set_role_and_resource
+    # own `resource` is not assigned yet when the record is instantiated. The
+    # role is never defaulted: the inviter names it, and the controller checks
+    # they may grant it.
+    def set_resource
       self.resource ||= role&.resource || Spree::Store.current
-      self.role ||= Spree::Role.default_admin_role(resource)
     end
 
     def invitee_is_not_inviter

data/app/models/spree/number_generators/sequential.rb

@@ -50,7 +50,7 @@ module Spree
       end
 
       def taken?(record, candidate)
-        record.class.unscoped.exists?(number: candidate)
+        record.class.base_class.unscoped.exists?(number: candidate)
       end
 
       def next_free_value(record, from)
@@ -58,7 +58,7 @@ module Spree
 
         loop do
           candidates = (value + 1..value + SCAN_BATCH_SIZE).index_by { |v| compose(record, v) }
-          taken = record.class.unscoped.where(number: candidates.keys).pluck(:number)
+          taken = record.class.base_class.unscoped.where(number: candidates.keys).pluck(:number)
           free = (candidates.keys - taken).first
 
           return candidates.fetch(free) if free

data/app/models/spree/option_value.rb

@@ -48,6 +48,13 @@ module Spree
         distinct
     }
 
+    # Option values are owned through their option type, and the store has no
+    # `option_values` association for `Spree::Base.for_store` to follow, which
+    # would otherwise fall back to every store's values.
+    scope :for_store, lambda { |store|
+      joins(:option_type).where(Spree::OptionType.table_name => { store_id: store.id })
+    }
+
     scope :for_products, lambda { |products|
       # we need to use map(&:id) to avoid SQL errors when merging with other scopes
       joins(:variants).where(Spree::Variant.table_name => { product_id: products.map(&:id) })

data/app/models/spree/order.rb

@@ -170,6 +170,17 @@ module Spree
       order_group_id po_number
     ]
     self.whitelisted_ransackable_scopes = %w[complete incomplete refunded partially_refunded search multi_search]
+    # A seller never sees the buyer's email, and a company member filtering the
+    # company's orders must not learn a colleague's; the risk flag and coupon
+    # are back-office data. `search` matches on the email too.
+    self.private_ransackable_attributes = {
+      store: %w[email considered_risky coupon_code],
+      seller: %w[email considered_risky coupon_code]
+    }
+    self.private_ransackable_scopes = {
+      store: %w[search multi_search],
+      seller: %w[search multi_search]
+    }
 
     # Set to false on admin-initiated flows to suppress customer-facing emails.
     attr_accessor :notify_customer
@@ -242,6 +253,11 @@ module Spree
     # checkout names the one child being refunded. Keyed on that column rather
     # than walked through payments, which a grouped order does not own.
     has_many :refunds, class_name: 'Spree::Refund', inverse_of: :order, dependent: :nullify
+    # The other half of what this order gave back. A refund paid as store
+    # credit writes no Spree::Refund row, so anything measuring what the
+    # customer got back has to add the two ledgers.
+    has_many :store_credit_refunds, class_name: 'Spree::StoreCredit', inverse_of: :refunded_order,
+                                    foreign_key: :refunded_order_id, dependent: :nullify
 
     # Typed adjustment rows owned by this order (line-, fulfillment- and
     # order-level). See docs/plans/6.0-6.1-split-adjustments.md.
@@ -333,12 +349,8 @@ module Spree
     scope :partially_shipped, -> { where(fulfillment_status: %w[partial]) }
     scope :not_shipped, -> { where(fulfillment_status: %w[unfulfilled partial]) }
     scope :shipped, -> { where(fulfillment_status: %w[fulfilled delivered shipped]) }
-    scope :refunded, lambda {
-      joins(:refunds).group(:id).having("sum(#{Spree::Refund.table_name}.amount) = #{Spree::Order.table_name}.total")
-    }
-    scope :partially_refunded, lambda {
-      joins(:refunds).group(:id).having("sum(#{Spree::Refund.table_name}.amount) < #{Spree::Order.table_name}.total")
-    }
+    scope :refunded, -> { where(payment_status: 'refunded') }
+    scope :partially_refunded, -> { where(payment_status: 'partially_refunded') }
     scope :with_deleted_bill_address, -> { joins(:bill_address).where.not(Address.table_name => { deleted_at: nil }) }
     scope :with_deleted_ship_address, -> { joins(:ship_address).where.not(Address.table_name => { deleted_at: nil }) }
 
@@ -746,12 +758,8 @@ module Spree
 
     # What has been captured against this order, net of refunds.
     #
-    # An order placed in a split checkout owns no payments, so its own
-    # +payment_total+ stays at zero however much the customer paid — the
-    # figure comes from its share of the group's payments instead, the same
-    # way {Spree::Orders::UpdateStatuses} derives +payment_status+. The
-    # group's own total will not do: once one seller has been captured and
-    # another has not, no proportion of it describes either.
+    # Read from the share rows rather than the +payment_total+ they are summed
+    # into, since a caller about to move money needs what they say now.
     #
     # @return [BigDecimal]
     def net_captured_total
@@ -1248,6 +1256,21 @@ module Spree
 
     private
 
+    # An order placed in a split checkout owns no payments, so its money is
+    # the sum of its shares of the group's instead — the same source
+    # {Spree::Orders::UpdateStatuses} derives payment_status from.
+    #
+    # @return [Arel::Nodes::NamedFunction]
+    def settled_payments_arel
+      return super unless grouped?
+
+      splits = Spree::PaymentSplit.arel_table
+      net = splits.project(splits[:captured_amount].sum - splits[:refunded_amount].sum).
+            where(splits[:order_id].eq(id))
+
+      Arel::Nodes::NamedFunction.new('COALESCE', [Arel::Nodes::Grouping.new(net), Arel.sql('0')])
+    end
+
     def ensure_can_be_deleted
       return true if can_be_deleted?
 

data/app/models/spree/order_group.rb

@@ -55,15 +55,23 @@ module Spree
     has_many :payments, class_name: 'Spree::Payment', inverse_of: :order_group, dependent: :restrict_with_error
     has_many :payment_splits, through: :payments, class_name: 'Spree::PaymentSplit', source: :payment_splits
 
+    # What the customer bought and the money hanging off it, reached through
+    # the children that own it. A purchase-level reader is not a second source
+    # of truth — it is the same rows, asked for as one basket, which is how the
+    # customer's own confirmation has to describe them.
+    has_many :line_items, through: :orders, class_name: 'Spree::LineItem', source: :line_items
+    has_many :fulfillments, through: :orders, class_name: 'Spree::Fulfillment', source: :fulfillments
+    has_many :discounts, through: :orders, class_name: 'Spree::Discount', source: :discounts
+    has_many :fees, through: :orders, class_name: 'Spree::Fee', source: :fees
+
     # Brings the ship/bill pair with the shipping_address/billing_address
     # aliases every other purchase surface reads them by.
     #
     # Only the associations and aliases apply here. The concern's checkout
-    # helpers — shipping_address_required?, assign_default_addresses! — reach
-    # for line items, fulfillments and digital goods, none of which a group
-    # has: they belong to its children, which answer those questions for
-    # themselves. A group's addresses are copies made when the checkout
-    # divided, so nothing asks it to work them out.
+    # helpers — shipping_address_required?, assign_default_addresses! — are
+    # about working an address out, and a group's addresses are copies made
+    # when the checkout divided, so nothing asks it to. They also read digital
+    # goods, which only a child can answer for.
     include Spree::Purchase::Addresses
     # What a marketplace asks about a group. Kept out of the class itself so
     # this stays the neutral primitive its other consumers need.
@@ -81,7 +89,6 @@ module Spree
     self.whitelisted_ransackable_associations = %w[orders customer]
 
     extend Spree::DisplayMoney
-    money_methods :total, :item_total
 
     # What the customer was charged for the whole checkout, and what it was
     # charged for — the sums of what each child independently computed. Never
@@ -104,6 +111,9 @@ module Spree
       end
     end
 
+    money_methods(*ROLLED_UP_TOTALS)
+    money_methods :gift_card_total
+
     alias ship_total delivery_total
 
     # Where the checkout was made from, carried on the children because they
@@ -114,6 +124,68 @@ module Spree
       orders.first&.last_ip_address
     end
 
+    # @return [String, nil]
+    def locale
+      orders.first&.locale
+    end
+
+    # @return [String, nil]
+    def po_number
+      orders.first&.po_number
+    end
+
+    # Who to address the purchase to, read off the addresses the checkout
+    # copied onto the group — the same answer +Spree::Order#name+ gives, so a
+    # customer-facing document greets them identically either way.
+    #
+    # @return [String, nil]
+    def name
+      (bill_address || ship_address)&.full_name
+    end
+
+    # The parcels this purchase actually ships in — not one per child order.
+    # A parcel divided between sellers is counted once, because one box leaves
+    # the warehouse however many orders its contents belong to. See
+    # +Spree::FulfillmentGroup+ for why the two numbers differ.
+    #
+    # Ordered by child, so first-party goods lead and sellers follow in the
+    # order the split filed them, and the same purchase reads the same way
+    # twice.
+    #
+    # @return [Array<Spree::FulfillmentGroup>]
+    def fulfillment_groups
+      Spree::FulfillmentGroup.build_from(
+        fulfillments.
+          includes(:stock_location, { order: :seller }, { selected_delivery_rate: :delivery_method }).
+          order(:order_id, :id)
+      )
+    end
+
+    # What was bought that no parcel carries — a downloaded album, a gift card
+    # sent by email. Without it a confirmation organised by parcel would list
+    # everything the customer is waiting for and silently omit what they
+    # already have.
+    #
+    # @param groups [Array<Spree::FulfillmentGroup>] the parcels, when the
+    #   caller has already built them — rebuilding re-reads the fulfillments
+    # @return [Array<Spree::LineItem>]
+    def unfulfilled_line_items(groups = fulfillment_groups)
+      line_items.to_a - groups.flat_map(&:line_items)
+    end
+
+    # What the customer paid with a gift card. Not rolled up from the children:
+    # the group claims the payments at completion, so a child's own
+    # +gift_card_total+ — which reads its payments — answers zero for every one
+    # of them, and the confirmation would omit a deduction its total makes.
+    #
+    # @return [BigDecimal]
+    def gift_card_total
+      return 0.to_d if gift_card.nil?
+
+      store_credit_ids = payments.store_credits.valid.pluck(:source_id)
+      Spree::StoreCredit.where(id: store_credit_ids, originator: gift_card).sum(:amount)
+    end
+
     # @return [String, nil] the group's fulfillment position, in the same
     #   vocabulary a single order uses, rolled up across children
     def fulfillment_status

data/app/models/spree/payment_source.rb

@@ -1,7 +1,7 @@
 # This model is used to store payment sources for non-credit card payments, eg wallet, account, etc.
 module Spree
   class PaymentSource < Spree.base_class
-    has_prefix_id :ps
+    has_prefix_id :psrc
 
     include Spree::HasCustomFields
     include Spree::Metadata

data/app/models/spree/payment_split.rb

@@ -33,6 +33,12 @@ module Spree
     validates :currency, presence: true
     validates :order_id, uniqueness: { scope: [:payment_id, *spree_base_uniqueness_scope] }
 
+    #
+    # Callbacks
+    #
+    after_save :refresh_order_payment_total, if: :settled_money_moved?
+    after_destroy :refresh_order_payment_total, if: :held_settled_money?
+
     #
     # Scopes
     #
@@ -86,5 +92,23 @@ module Spree
     def capture_in_flight?
       claimed_amount.positive?
     end
+
+    private
+
+    # Here rather than at each of the five writers that move a share, because a
+    # column refreshed at five call sites will eventually be refreshed at four.
+    def refresh_order_payment_total
+      order&.refresh_payment_total!
+    end
+
+    # Reserving money or moving an authorisation reports no differently, and
+    # locking the order for it would invert {Spree::Payment#carry_splits_to}.
+    def settled_money_moved?
+      saved_change_to_captured_amount? || saved_change_to_refunded_amount?
+    end
+
+    def held_settled_money?
+      captured_amount.positive? || refunded_amount.positive?
+    end
   end
 end

data/app/models/spree/price.rb

@@ -56,6 +56,7 @@ module Spree
               numericality: { only_integer: true, greater_than: 0 }
     validate :break_requires_price_list
     validate :breaks_within_cap
+    validate :ladder_does_not_rise
 
     scope :with_currency, ->(currency) { where(currency: currency) }
     scope :non_zero, -> { where.not(amount: [nil, 0]) }
@@ -229,6 +230,31 @@ module Spree
       variant&.product&.store
     end
 
+    # The first rung of `[[quantity, amount], ...]` costing more than the
+    # quantity below it buys — the rung beneath, or `floor` for a ladder
+    # starting above one unit. Returned as `[quantity, amount, floor]`.
+    #
+    # @param ladder [Array<Array>] rungs by quantity
+    # @param floor [BigDecimal, nil]
+    # @return [Array, nil]
+    def self.rising_rung(ladder, floor)
+      bottom_quantity, bottom_amount = ladder.first
+      return if bottom_quantity.nil?
+
+      # The bottom rung answers to the floor, and is checked first so the rung
+      # named is the first breach reading upward — a merchant who fixes what
+      # they are told to fix should not meet a second error beneath it.
+      if bottom_quantity != 1 && floor.present? && bottom_amount > floor
+        return [bottom_quantity, bottom_amount, floor]
+      end
+
+      ladder.each_cons(2) do |(_, below), (quantity, amount)|
+        return [quantity, amount, below] if amount > below
+      end
+
+      nil
+    end
+
     # Whether this row is a quantity break rather than the list's ordinary
     # price for the variant.
     # @return [Boolean]
@@ -268,6 +294,54 @@ module Spree
       errors.add(:min_quantity, :too_many_breaks, count: MAXIMUM_BREAKS_PER_VARIANT)
     end
 
+    # A break promises a better price for a bigger order, so no rung may cost
+    # more than the quantity below it buys. Judged over the ladder this save
+    # would leave behind rather than this row alone: lowering one rung strands
+    # every rung above it, and a base price is the floor each ladder falls
+    # through to. The bulk path judges the same way; this covers the
+    # single-row writers, as the break cap is covered on both
+    # (docs/plans/6.0-volume-pricing.md).
+    def ladder_does_not_rise
+      return if amount.nil? || variant_id.blank? || currency.blank?
+      return unless new_record? || will_save_change_to_attribute?(:amount) || will_save_change_to_attribute?(:min_quantity)
+
+      breach = affected_ladders.lazy.filter_map { |list_id, floor| self.class.rising_rung(resulting_ladder(list_id), floor) }.first
+      return if breach.nil?
+
+      errors.add(:amount, :leaves_a_rising_ladder,
+                 quantity: breach[0],
+                 amount: Spree::Money.new(breach[1], currency: currency),
+                 floor: Spree::Money.new(breach[2], currency: currency))
+    end
+
+    # The ladders this row can disturb, each with the floor it falls through
+    # to: its own list for a break, and every ladder the variant carries for a
+    # base price, since that is the floor they all read.
+    #
+    # @return [Array<Array>] `[[price_list_id, floor], ...]`
+    def affected_ladders
+      if price_list_id.present?
+        base = self.class.base_prices.where(variant_id: variant_id, currency: currency).
+               where.not(amount: nil).pick(:amount)
+        return [[price_list_id, base]]
+      end
+
+      self.class.where(variant_id: variant_id, currency: currency).
+        where.not(price_list_id: nil).where.not(amount: nil).
+        distinct.pluck(:price_list_id).map { |list_id| [list_id, amount] }
+    end
+
+    # One list's rungs as this save would leave them, by quantity.
+    #
+    # @return [Array<Array>] `[[quantity, amount], ...]`
+    def resulting_ladder(list_id)
+      rows = self.class.where(variant_id: variant_id, currency: currency, price_list_id: list_id).where.not(amount: nil)
+      rows = rows.where.not(id: id) if persisted?
+      rungs = rows.pluck(:min_quantity, :amount).to_h
+      rungs[min_quantity] = amount if price_list_id == list_id
+      rungs.sort_by(&:first)
+    end
+
     def should_record_price_history?
       price_list_id.nil? &&
         amount.present? &&

data/app/models/spree/product.rb

@@ -369,6 +369,10 @@ module Spree
     self.whitelisted_ransackable_attributes = %w[description name slug discontinue_on status available_on created_at updated_at seller_id]
     self.whitelisted_ransackable_associations = %w[categories collections store channels variants default_variant tags labels
                                                    product_type product_categories option_types seller]
+    # The storefront filters by tag, category and collection; every other hop
+    # (variants, prices, channels) reaches back-office data, and variants lead
+    # back to the product, which lets one filter chain joins without end.
+    self.storefront_ransackable_associations = %w[tags categories collections]
     self.whitelisted_ransackable_scopes = %w[not_discontinued search_by_name in_taxon in_category in_categories in_collection price_between
                                              price_lte price_gte
                                              search multi_search in_stock out_of_stock with_option_value_ids

data/app/models/spree/product_option_type.rb

@@ -7,5 +7,16 @@ module Spree
     acts_as_list scope: :product
 
     validates :product_id, uniqueness: { scope: :option_type_id }, allow_nil: true
+    validate :option_type_belongs_to_product_store
+
+    private
+
+    # Option types are store-owned, so a product may only use its own store's.
+    def option_type_belongs_to_product_store
+      return if product.nil? || option_type.nil?
+      return if option_type.store_id == product.store_id
+
+      errors.add(:option_type, :invalid)
+    end
   end
 end