spree_core 6.0.0.beta1 → 6.0.0.beta3

data/app/services/spree/seeds/digital_delivery.rb

@@ -2,16 +2,11 @@ module Spree
   module Seeds
     class DigitalDelivery
       prepend Spree::ServiceModule::Base
-
-      def call
-        Spree::Store.all.find_each do |store|
-          create_for(store)
-        end
-      end
+      include StoreScoped
 
       private
 
-      def create_for(store)
+      def seed(store)
         # Digital goods are a distinct product set, so they get their own
         # profile; assigning a product to it is what makes it digital.
         profile = Spree::DeliveryProfiles::Digital.find_by(store: store) ||
@@ -22,7 +17,11 @@ module Spree
         digital_delivery_method.delivery_profile = profile
         digital_delivery_method.storefront_visible = true
         digital_delivery_method.fulfillment_provider = 'Spree::FulfillmentProvider::Digital'
-        digital_delivery_method.calculator ||= Spree::Calculator::Shipping::DigitalDelivery.create!
+        # Explicit, because the calculator's own default is the default
+        # store's currency rather than this store's.
+        digital_delivery_method.calculator ||= Spree::Calculator::Shipping::DigitalDelivery.create!(
+          preferred_currency: store.default_currency
+        )
         digital_delivery_method.save!
       end
     end

data/app/services/spree/seeds/payment_methods.rb

@@ -2,19 +2,20 @@ module Spree
   module Seeds
     class PaymentMethods
       prepend Spree::ServiceModule::Base
+      include StoreScoped
 
-      def call
-        Spree::Store.all.find_each do |store|
-          payment_method = store.payment_methods.find_or_initialize_by(
-            type: 'Spree::PaymentMethod::StoreCredit'
-          )
-          next if payment_method.persisted?
+      private
 
-          payment_method.name = Spree.t(:store_credit_name)
-          payment_method.description = Spree.t(:store_credit_name)
-          payment_method.active = true
-          payment_method.save!
-        end
+      def seed(store)
+        payment_method = store.payment_methods.find_or_initialize_by(
+          type: 'Spree::PaymentMethod::StoreCredit'
+        )
+        return if payment_method.persisted?
+
+        payment_method.name = Spree.t(:store_credit_name)
+        payment_method.description = Spree.t(:store_credit_name)
+        payment_method.active = true
+        payment_method.save!
       end
     end
   end

data/app/services/spree/seeds/product_types.rb

@@ -2,18 +2,17 @@ module Spree
   module Seeds
     class ProductTypes
       prepend Spree::ServiceModule::Base
+      include StoreScoped
 
-      def call
-        Spree::Store.all.find_each do |store|
-          Spree::ProductType.where(store: store).find_or_create_by!(name: I18n.t('spree.seed.product_types.default'))
-          Spree::ProductType.where(store: store).find_or_create_by!(name: I18n.t('spree.seed.product_types.digital')) do |product_type|
-            product_type.delivery_profile = digital_profile_for(store)
-          end
+      private
+
+      def seed(store)
+        Spree::ProductType.where(store: store).find_or_create_by!(name: I18n.t('spree.seed.product_types.default'))
+        Spree::ProductType.where(store: store).find_or_create_by!(name: I18n.t('spree.seed.product_types.digital')) do |product_type|
+          product_type.delivery_profile = digital_profile_for(store)
         end
       end
 
-      private
-
       def digital_profile_for(store)
         Spree::DeliveryProfiles::Digital.find_by(store: store) ||
           Spree::DeliveryProfiles::Digital.create!(store: store, name: I18n.t('spree.seed.delivery_profiles.digital'))

data/app/services/spree/seeds/returns_environment.rb

@@ -2,6 +2,7 @@ module Spree
   module Seeds
     class ReturnsEnvironment
       prepend Spree::ServiceModule::Base
+      include StoreScoped
 
       RETURN_REASONS = [
         'Better price available',
@@ -37,18 +38,18 @@ module Spree
         'Item not as described'
       ].freeze
 
-      def call
-        # Every vocabulary is store-owned, so every store gets its own.
-        Spree::Store.all.find_each do |store|
-          # Through the model helper, not a literal — the workflows look this
-          # row up by the same constant, so a hard-coded string here would
-          # silently create a second, unfindable reason if the name ever moves.
-          Spree::RefundReason.return_processing_reason(store)
+      private
 
-          RETURN_REASONS.each { |name| Spree::ReturnReason.where(store: store).find_or_create_by!(name: name) }
-          CLAIM_REASONS.each { |name| Spree::ClaimReason.where(store: store).find_or_create_by!(name: name) }
-          ORDER_CANCELLATION_REASONS.each { |name| Spree::OrderCancellationReason.where(store: store).find_or_create_by!(name: name) }
-        end
+      # Every vocabulary is store-owned, so every store gets its own.
+      def seed(store)
+        # Through the model helper, not a literal — the workflows look this
+        # row up by the same constant, so a hard-coded string here would
+        # silently create a second, unfindable reason if the name ever moves.
+        Spree::RefundReason.return_processing_reason(store)
+
+        RETURN_REASONS.each { |name| Spree::ReturnReason.where(store: store).find_or_create_by!(name: name) }
+        CLAIM_REASONS.each { |name| Spree::ClaimReason.where(store: store).find_or_create_by!(name: name) }
+        ORDER_CANCELLATION_REASONS.each { |name| Spree::OrderCancellationReason.where(store: store).find_or_create_by!(name: name) }
       end
     end
   end

data/app/services/spree/seeds/roles.rb

@@ -1,15 +1,16 @@
 module Spree
   module Seeds
+    # A role belongs to what it governs, so every store gets its own
+    # immutable admin.
     class Roles
       prepend Spree::ServiceModule::Base
+      include StoreScoped
 
-      # A role belongs to what it governs, so every store gets its own
-      # immutable admin.
-      def call
-        Spree::Store.find_each do |store|
-          admin = Spree::Role.default_admin_role(store)
-          admin.update_column(:mutable, false) if admin.read_attribute(:mutable)
-        end
+      private
+
+      def seed(store)
+        admin = Spree::Role.default_admin_role(store)
+        admin.update_column(:mutable, false) if admin.read_attribute(:mutable)
       end
     end
   end

data/app/services/spree/seeds/saved_reports.rb

@@ -6,6 +6,7 @@ module Spree
     # only never-created ones are added.
     class SavedReports
       prepend Spree::ServiceModule::Base
+      include StoreScoped
 
       REPORTS = [
         { key: 'sales_over_time',
@@ -70,31 +71,29 @@ module Spree
                    'time_range' => { 'preset' => 'last_4_weeks' } } }
       ].freeze
 
-      def call
-        Spree::Store.find_each do |store|
-          # Compared case-insensitively like the model's uniqueness rule, so a
-          # merchant's own "top products" never makes a re-seed raise.
-          existing = store.saved_reports.pluck(:name).map(&:downcase).to_set
+      private
+
+      def seed(store)
+        # Compared case-insensitively like the model's uniqueness rule, so a
+        # merchant's own "top products" never makes a re-seed raise.
+        existing = store.saved_reports.pluck(:name).map(&:downcase).to_set
 
-          REPORTS.each do |report|
-            # Every locale's name for this report, not just the current one:
-            # the name is translated, so a store seeded in one language and
-            # re-seeded in another would otherwise recognise none of its own
-            # built-ins and create a second full set.
-            next if known_names(report[:key]).intersect?(existing)
+        REPORTS.each do |report|
+          # Every locale's name for this report, not just the current one:
+          # the name is translated, so a store seeded in one language and
+          # re-seeded in another would otherwise recognise none of its own
+          # built-ins and create a second full set.
+          next if known_names(report[:key]).intersect?(existing)
 
-            store.saved_reports.create!(
-              name: Spree.t("reporting.seeds.#{report[:key]}.name"),
-              description: Spree.t("reporting.seeds.#{report[:key]}.description"),
-              query: report[:query],
-              seeded: true
-            )
-          end
+          store.saved_reports.create!(
+            name: Spree.t("reporting.seeds.#{report[:key]}.name"),
+            description: Spree.t("reporting.seeds.#{report[:key]}.description"),
+            query: report[:query],
+            seeded: true
+          )
         end
       end
 
-      private
-
       # The downcased name this report carries in every locale core ships.
       def known_names(key)
         @known_names ||= {}

data/app/services/spree/seeds/seller_requirements.rb

@@ -8,11 +8,12 @@ module Spree
     # a licence) is theirs to add, and there is no sensible default for it.
     class SellerRequirements
       prepend Spree::ServiceModule::Base
+      include StoreScoped
 
-      def call
-        Spree::Store.find_each do |store|
-          Spree::SellerRequirement.provision_defaults(store)
-        end
+      private
+
+      def seed(store)
+        Spree::SellerRequirement.provision_defaults(store)
       end
     end
   end

data/app/services/spree/seeds/store_resources.rb

@@ -0,0 +1,41 @@
+module Spree
+  module Seeds
+    # Seeds what a single store needs to trade, without touching any other
+    # store.
+    #
+    # Country-shaped defaults (market, warehouse, delivery zones, pickup) are
+    # not part of it: the caller runs Spree::Stores::ProvisionDefaults
+    # afterwards with the merchant's answers.
+    class StoreResources
+      prepend Spree::ServiceModule::Base
+
+      # @param store [Spree::Store] the store to seed, already persisted
+      # @return [Spree::ServiceModule::Result]
+      def call(store:)
+        # A nil store would fall through to every seed's all-stores mode.
+        raise ArgumentError, 'store is required' if store.nil?
+
+        Spree::Events.disable do
+          ActiveRecord::Base.no_touching do
+            TaxCategories.call(store: store)
+            Channels.call(store: store)
+            Roles.call(store: store)
+            DigitalDelivery.call(store: store)
+            PaymentMethods.call(store: store)
+            ProductTypes.call(store: store)
+            CustomerGroups.call(store: store)
+            ReturnsEnvironment.call(store: store)
+            # The marketplace's catch-all rate, at the bottom of the list so
+            # narrower rates added later resolve ahead of it.
+            CommissionRates.call(store: store)
+            SellerRequirements.call(store: store)
+            # Binds to the wholesale channel that Channels creates above.
+            ApiKeys.call(store: store)
+            SavedReports.call(store: store)
+            AllowedOrigins.call(store: store)
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/spree/seeds/store_scoped.rb

@@ -0,0 +1,15 @@
+module Spree
+  module Seeds
+    # Shared entry point for seeds whose rows belong to a store. Including
+    # classes implement a private `seed(store)` that seeds exactly one store
+    # and is safe to re-run.
+    module StoreScoped
+      # @param store [Spree::Store, nil] the store to seed; every store when nil
+      def call(store: nil)
+        return seed(store) if store
+
+        Spree::Store.find_each { |each_store| seed(each_store) }
+      end
+    end
+  end
+end

data/app/services/spree/seeds/tax_categories.rb

@@ -2,17 +2,18 @@ module Spree
   module Seeds
     class TaxCategories
       prepend Spree::ServiceModule::Base
+      include StoreScoped
 
-      def call
-        Spree::Store.find_each do |store|
-          # The block form only runs on create, so a store that already had a
-          # "Default" category with the flag unset kept no default at all — and
-          # the default is what taxes an item carrying no category of its own.
-          default = store.tax_categories.find_or_create_by!(name: 'Default')
-          default.update!(is_default: true) unless default.is_default?
+      private
 
-          store.tax_categories.find_or_create_by!(name: 'Non-taxable')
-        end
+      def seed(store)
+        # The block form only runs on create, so a store that already had a
+        # "Default" category with the flag unset kept no default at all — and
+        # the default is what taxes an item carrying no category of its own.
+        default = store.tax_categories.find_or_create_by!(name: 'Default')
+        default.update!(is_default: true) unless default.is_default?
+
+        store.tax_categories.find_or_create_by!(name: 'Non-taxable')
       end
     end
   end

data/app/services/spree/stock_locations/stock_items/create.rb

@@ -10,7 +10,7 @@ module Spree
         # @param stock_location [Spree::StockLocation]
         # @param variants_scope [ActiveRecord::Relation]
         # @return [Spree::ServiceModule::Base::Result]
-        def call(stock_location:, variants_scope: Spree::Variant)
+        def call(stock_location:, variants_scope: nil)
           Spree::Deprecation.warn('Spree::StockLocations::StockItems::Create is deprecated and will be removed in Spree 6.1. Use Spree::StockLocations::StockLevels::Create instead.')
           Spree::StockLocations::StockLevels::Create.call(stock_location: stock_location, variants_scope: variants_scope)
         end

data/app/services/spree/stock_locations/stock_levels/create.rb

@@ -4,8 +4,13 @@ module Spree
       class Create
         prepend Spree::ServiceModule::Base
 
-        def call(stock_location:, variants_scope: Spree::Variant)
-          prepared_stock_levels = variants_scope.ids.map do |variant_id|
+        # @param stock_location [Spree::StockLocation]
+        # @param variants_scope [ActiveRecord::Relation, nil] defaults to what the
+        #   location may stock; always narrowed to it, so no caller can seed rows
+        #   for another store's or another seller's variants
+        def call(stock_location:, variants_scope: nil)
+          variant_ids = propagatable_variants(stock_location, variants_scope).ids
+          prepared_stock_levels = variant_ids.map do |variant_id|
             Hash[
               'stock_location_id', stock_location.id,
               'variant_id', variant_id,
@@ -16,9 +21,20 @@ module Spree
           end
           if prepared_stock_levels.any?
             stock_location.stock_levels.insert_all(prepared_stock_levels)
-            variants_scope.touch_all
+            # By id: MySQL refuses an UPDATE whose own table appears in a subquery.
+            Spree::Variant.where(id: variant_ids).touch_all
           end
         end
+
+        private
+
+        # A location stocks its own store's variants, and a seller's location
+        # only the variants that seller sells.
+        def propagatable_variants(stock_location, variants_scope)
+          scope = Spree::Variant.where(id: (variants_scope || Spree::Variant).select(:id))
+          scope = scope.for_seller(stock_location.seller_id) if stock_location.seller_id.present?
+          scope.joins(:product).where(Spree::Product.table_name => { store_id: stock_location.store_id })
+        end
       end
     end
   end

data/app/subscribers/spree/order_status_subscriber.rb

@@ -1,6 +1,6 @@
 module Spree
   # The trigger side of derive-then-persist statuses: any payment, refund,
-  # fulfillment or return change recomputes the owning order's
+  # store credit, fulfillment or return change recomputes the owning order's
   # payment_status / fulfillment_status through the single writer
   # (Spree::Orders::UpdateStatuses). Synchronous so API responses right
   # after a capture/void/fulfill already carry the fresh status. Cart-owned
@@ -15,12 +15,15 @@ module Spree
     subscribes_to 'payment.created', 'payment.updated', 'payment.deleted',
                   'payment.completed', 'payment.captured', 'payment.voided',
                   'refund.created', 'refund.updated',
+                  'store_credit.created', 'store_credit.updated', 'store_credit.deleted',
                   'fulfillment.created', 'fulfillment.updated', 'fulfillment.deleted',
                   'return.received', 'return.refunded', 'return.canceled',
                   async: false
 
     # Events whose payload changes what the customer has actually paid, so
     # payment_total has to be re-summed before statuses derive from it.
+    # Store credit is not one of them: the money stayed with the store, and
+    # payment_total is what came in through payments.
     MONEY_EVENTS = %w[
       payment.created payment.updated payment.deleted payment.completed
       payment.voided refund.created refund.updated
@@ -63,19 +66,24 @@ module Spree
       resource_class = {
         'payment' => Spree::Payment,
         'refund' => Spree::Refund,
+        'store_credit' => Spree::StoreCredit,
         'fulfillment' => Spree::Fulfillment,
         'return' => Spree::Return
       }[event.resource_type]
       return if resource_class.nil?
 
-      record = resource_class.find_by_prefix_id(event.payload['id'])
-      # None of these models are paranoid, so a .deleted event arrives with
-      # its row already gone and a payload carrying no owner — nothing can
-      # lead back to the order. The models whose deletion changes order
-      # money recalculate from their own after_destroy instead.
+      # A paranoid model's .deleted event leaves the row in place but out of
+      # default scope, and a credit that has been withdrawn is exactly the
+      # kind of change the order has to learn about.
+      record = (resource_class.try(:with_deleted) || resource_class).
+               find_by_prefix_id(event.payload['id'])
+      # Neither Payment nor Fulfillment is paranoid, so their .deleted events
+      # arrive with the row already gone and a payload carrying no owner —
+      # nothing can lead back to the order. The models whose deletion changes
+      # order money recalculate from their own after_destroy instead.
       return if record.nil?
 
-      record.try(:owner) || record.try(:order) ||
+      record.try(:owner) || record.try(:order) || record.try(:refunded_order) ||
         record.try(:payment)&.try(:owner)
     end
   end

data/app/workflows/spree/carts/add_item.rb

@@ -1,9 +1,6 @@
 module Spree
   module Carts
     class AddItem < Spree::Workflow
-      # Line item attributes a caller may set through `options`.
-      ITEM_OPTIONS = [:id, :variant_id, :quantity].freeze
-
       hooks :validate, :after_item_added
 
       # Hook handlers read these plus the argument readers. Both are nil
@@ -110,10 +107,11 @@ module Spree
 
         if @line_item.nil?
           # `LineItem#options=` mass-assigns, so the caller's hash is narrowed
-          # first — `options` must not be a way to set arbitrary attributes.
-          # Extensions widen this through the model's permitted attributes.
-          writable = ITEM_OPTIONS +
-                     ::Spree::LineItem.additional_permitted_attributes.flat_map { |a| a.is_a?(Hash) ? a.keys : a }
+          # to the attributes extensions declare. The variant and quantity are
+          # never among them: both were checked and priced above, and an
+          # `options` value replacing them would sell something else.
+          writable = ::Spree::LineItem.additional_permitted_attributes.flat_map { |a| a.is_a?(Hash) ? a.keys : a }.
+                     map(&:to_sym) - [:id, :variant_id, :quantity]
 
           opts = item_options.symbolize_keys.slice(*writable).
                  merge(currency: cart.currency).

data/app/workflows/spree/carts/complete.rb

@@ -207,6 +207,13 @@ module Spree
       # typed money lines re-pointed, fulfillments + selected rates, address
       # copies); money records (payments, sessions, reservations, coupon
       # codes) re-point — external transaction references must never fork.
+      #
+      # The cart's metadata is copied whole: storefronts and checkout
+      # requirements keep what they collected about the purchase there, and it
+      # has to outlive the cart. The order is new at this point, so there is
+      # nothing on it to merge with — the cart's hash simply becomes the
+      # order's. A deep copy, so a later edit to either record can never reach
+      # the other through a shared nested hash.
       def create_draft_order!(cart)
         order = nil
         ApplicationRecord.transaction do
@@ -228,6 +235,7 @@ module Spree
             po_number: cart.po_number,
             gift_card: cart.gift_card,
             last_ip_address: cart.last_ip_address,
+            metadata: cart.metadata.to_h.deep_dup,
             ship_address: cart.ship_address&.snapshot,
             bill_address: cart.bill_address&.snapshot
           )
@@ -407,82 +415,30 @@ module Spree
       # resumes like any other finalize failure.
       def finalize!(cart, order)
         @order = order
-        step :split_by_seller
-        step :allocate_payment_splits
         step :complete_orders
         step :complete_cart
         step :mark_coupon_codes_used
         external_step :commit_tax
       end
 
-      # Divides the paid draft order into one order per seller, under a group.
-      # A cart of one partition — all first-party, or all one seller — is left
-      # exactly as it is: no group, no splits, and the order it already built
-      # is the order the customer gets.
+      # Places what the checkout produced, through the order-side workflow
+      # that owns placement — including dividing the basket between sellers,
+      # which an order raised from the admin needs just as much and which only
+      # that workflow can give both of them.
       #
-      # The draft order built in PREPARE becomes the group's first child rather
-      # than being replaced. It is the record the payment was taken against and
-      # the row carrying the unique cart_id that makes completion replayable,
-      # so it is kept and narrowed to its own partition; the remaining
-      # partitions become new siblings beside it.
-      def split_by_seller
-        @order_group = cart.order_group
-        return if order_group.present?
-        return if order.placed?
-
-        partitions = Spree::Carts::PartitionBySeller.call(purchase: order).value
-
-        if partitions.one?
-          # Nothing to divide, but the sale still belongs to whoever made it:
-          # a basket entirely from one seller is that seller's order, and the
-          # column is what their own order list reads.
-          order.update_columns(seller_id: partitions.first.seller_id) if order.seller_id != partitions.first.seller_id
-          return
-        end
-
-        return if partitions.empty?
+      # It answers with the group when the basket divided, and the first of
+      # its children is the order this checkout carries on with. No child holds
+      # the confirmation: the customer is confirmed from the group.
+      def complete_orders
+        result = Spree.order_complete_workflow.call(order: order, payment_pending: payment_pending)
+        failure(cart, code: 'completion_failed', message: result.error) if result.failure?
 
-        result = Spree::Carts::SplitBySeller.call(cart: cart, order: order, partitions: partitions)
-        failure(cart, code: 'split_failed', message: result.error) if result.failure?
+        return unless result.value.is_a?(Spree::OrderGroup)
 
         @order_group = result.value
-        # Ordered, because which child comes first decides which one carries
-        # the confirmation email — that must not depend on how the rows come
-        # back.
         @order = order_group.orders.order(:id).first
       end
 
-      def allocate_payment_splits
-        return if order_group.nil?
-
-        result = Spree::OrderGroups::AllocatePayments.call(group: order_group)
-        failure(cart, code: 'split_failed', message: result.error) if result.failure?
-      end
-
-      # Places what the checkout produced — the children of a split, or the one
-      # order otherwise. Each child publishes its own order.placed, which is
-      # what gets every seller their own commission lines with no marketplace
-      # code in the commission engine.
-      #
-      # A split checkout's payments were already taken against the whole basket
-      # and moved onto the group, so the children place without processing them
-      # again. One purchase means one confirmation email: the first child
-      # carries the notification and its siblings place silently.
-      def complete_orders
-        split = order_group.present?
-
-        placed_orders.each_with_index do |child, index|
-          result = Spree.order_complete_workflow.call(
-            order: child,
-            payment_pending: split,
-            notify_customer: split && !index.zero? ? false : nil
-          )
-          failure(cart, code: 'completion_failed', message: result.error) if result.failure?
-        end
-
-        order_group&.publish_event('order_group.completed')
-      end
-
       # Tells the tax engine the sale is final. A no-op for the built-in
       # provider, whose rows are already the record; external engines file the
       # document that a tax return is later built from. Outside the
@@ -499,7 +455,7 @@ module Spree
       # otherwise. The single answer to "which orders came out of here", so
       # placement and tax filing can never disagree about the set.
       def placed_orders
-        order_group.present? ? order_group.orders.to_a : [order]
+        order_group.present? ? order_group.orders.to_a.sort_by(&:id) : [order]
       end
 
       def complete_cart

data/app/workflows/spree/carts/recalculate_totals.rb

@@ -137,7 +137,9 @@ module Spree
       # @return [BigDecimal]
       def paid_so_far
         if cart.is_a?(Spree::Order) && cart.grouped?
-          return cart.payment_splits.to_a.sum(&:net_captured_amount)
+          # Reloaded: a share moved since this instance loaded them would be
+          # re-summed at its old figure and persisted back over the correction.
+          return cart.payment_splits.reload.to_a.sum(&:net_captured_amount)
         end
 
         cart.payments.completed.includes(:refunds).inject(0) do |sum, payment|

data/app/workflows/spree/claims/create.rb

@@ -39,6 +39,9 @@ module Spree
         failure(order, :no_items_to_claim) if items.blank?
       end
 
+      # Bounded by what earlier claims left: each claim can pay out what was
+      # paid for its units, so claiming the same units again would pay twice.
+      # A denied or canceled claim settled nothing and frees its units.
       def normalize_items
         @normalized_items = items.map do |item|
           line_item = item[:line_item]
@@ -46,13 +49,40 @@ module Spree
 
           failure(order, :invalid_quantity) unless quantity.positive?
           failure(order, :item_not_on_order) unless line_item&.order_id == order.id
-          failure(order, :invalid_quantity) if quantity > line_item.quantity.to_i
 
           item.merge(line_item: line_item, quantity: quantity)
         end
+
+        ensure_claimable_quantities
+      end
+
+      def ensure_claimable_quantities
+        requested = Hash.new(0)
+
+        @normalized_items.each do |item|
+          line_item = item[:line_item]
+          failure(order, :invalid_quantity) if item[:quantity] > claimable_quantity_for(line_item) - requested[line_item.id]
+
+          requested[line_item.id] += item[:quantity]
+        end
+      end
+
+      def claimable_quantity_for(line_item)
+        claimed = Spree::ClaimLineItem.
+                  joins(:claim).
+                  where(line_item_id: line_item.id).
+                  where.not(Spree::Claim.table_name => { status: %w[denied canceled] }).
+                  sum(:quantity)
+
+        line_item.quantity.to_i - claimed
       end
 
       def build_claim
+        # Again under the order's row lock, so two requests racing for the same
+        # units cannot both pass the check above.
+        Spree::Order.lock.find(order.id)
+        ensure_claimable_quantities
+
         @claim = order.claims.new(
           store: order.store,
           reason: reason,