spree_core 6.0.0.rc1 → 6.0.0.rc2

data/app/models/spree/calculator/shipping/flat_rate.rb

@@ -3,14 +3,14 @@ module Spree
     class FlatRate < ShippingCalculator
       include Spree::Calculator::CurrencyAmounts
 
-      preference :amount, :decimal, default: 0
+      preference :amount, :money, default: 0
       # @deprecated Together with the single `amount`, superseded by the
       #   per-currency `amounts` hash; kept as the fallback for its own
       #   currency so upgraded stores quote unchanged.
-      preference :currency, :string, default: -> { Spree::Store.default.default_currency }
+      preference :currency, :string, format: :currency, default: -> { Spree::Store.default.default_currency }
 
-      preference :minimum_item_total, :decimal, default: nil, nullable: true, deprecated: 'Use a Spree::DeliveryMethodRules rule on the delivery method instead; removed in Spree 6.1.'
-      preference :maximum_item_total, :decimal, default: nil, nullable: true, deprecated: 'Use a Spree::DeliveryMethodRules rule on the delivery method instead; removed in Spree 6.1.'
+      preference :minimum_item_total, :money, default: nil, nullable: true, deprecated: 'Use a Spree::DeliveryMethodRules rule on the delivery method instead; removed in Spree 6.1.'
+      preference :maximum_item_total, :money, default: nil, nullable: true, deprecated: 'Use a Spree::DeliveryMethodRules rule on the delivery method instead; removed in Spree 6.1.'
 
       preference :minimum_weight, :decimal, default: nil, nullable: true, deprecated: 'Use a Spree::DeliveryMethodRules rule on the delivery method instead; removed in Spree 6.1.'
       preference :maximum_weight, :decimal, default: nil, nullable: true, deprecated: 'Use a Spree::DeliveryMethodRules rule on the delivery method instead; removed in Spree 6.1.'

data/app/models/spree/calculator/shipping/flexi_rate.rb

@@ -1,10 +1,10 @@
 module Spree
   module Calculator::Shipping
     class FlexiRate < ShippingCalculator
-      preference :first_item,      :decimal, default: 0.0
-      preference :additional_item, :decimal, default: 0.0
+      preference :first_item,      :money, default: 0.0
+      preference :additional_item, :money, default: 0.0
       preference :max_items,       :integer, default: 0
-      preference :currency,        :string,  default: -> { Spree::Store.default.default_currency }
+      preference :currency,        :string,  format: :currency, default: -> { Spree::Store.default.default_currency }
 
       # Single-currency amounts: quoting another currency would mislabel
       # the configured numbers, so the method stays hidden there.

data/app/models/spree/calculator/shipping/per_item.rb

@@ -3,8 +3,8 @@ module Spree
     class PerItem < ShippingCalculator
       include Spree::Calculator::CurrencyAmounts
 
-      preference :amount, :decimal, default: 0
-      preference :currency, :string, default: -> { Spree::Store.default.default_currency }
+      preference :amount, :money, default: 0
+      preference :currency, :string, format: :currency, default: -> { Spree::Store.default.default_currency }
 
       def self.description
         I18n.t('spree.shipping_flat_rate_per_item')

data/app/models/spree/calculator/shipping/price_sack.rb

@@ -1,10 +1,10 @@
 module Spree
   module Calculator::Shipping
     class PriceSack < ShippingCalculator
-      preference :minimal_amount, :decimal, default: 0
-      preference :normal_amount, :decimal, default: 0
-      preference :discount_amount, :decimal, default: 0
-      preference :currency, :string, default: -> { Spree::Store.default.default_currency }
+      preference :minimal_amount, :money, default: 0
+      preference :normal_amount, :money, default: 0
+      preference :discount_amount, :money, default: 0
+      preference :currency, :string, format: :currency, default: -> { Spree::Store.default.default_currency }
 
       # Single-currency amounts: quoting another currency would mislabel
       # the configured numbers, so the method stays hidden there.

data/app/models/spree/calculator/tiered_flat_rate.rb

@@ -2,8 +2,8 @@ module Spree
   class Calculator::TieredFlatRate < Calculator
     include Spree::Calculator::Tiers
 
-    preference :base_amount, :decimal, default: 0
-    preference :currency, :string, default: -> { Spree::Store.default.default_currency }
+    preference :base_amount, :money, default: 0
+    preference :currency, :string, format: :currency, default: -> { Spree::Store.default.default_currency }
 
     def self.description
       I18n.t('spree.tiered_flat_rate')

data/app/models/spree/calculator/tiered_percent.rb

@@ -15,7 +15,7 @@ module Spree
 
     def compute(object)
       percent = tier_value_for(object.amount) || preferred_base_percent
-      (object.amount * percent / 100).round(2)
+      Spree::Money::Rounding.to_currency(object.amount * percent / 100, object.try(:currency))
     end
 
     private

data/app/models/spree/catalog.rb

@@ -86,6 +86,7 @@ module Spree
     scope :by_position, -> { ordered }
 
     self.whitelisted_ransackable_attributes = %w[name active]
+    search_by :name
 
     # The catalogs that apply to a purchase node, nearest node first: the
     # node's own assignments before its parent's, catalog position breaking

data/app/models/spree/catalog_price.rb

@@ -80,13 +80,6 @@ module Spree
       break_count.to_i.positive?
     end
 
-    # The amount as the wire carries it — see CatalogPriceTier#display_value.
-    #
-    # @return [String]
-    def display_value
-      amount.to_s
-    end
-
     # @return [Spree::Money]
     def money
       Spree::Money.new(amount, currency: currency)

data/app/models/spree/catalog_price_tier.rb

@@ -15,14 +15,6 @@ module Spree
 
     validates :min_quantity, numericality: { greater_than: 1 }
 
-    # The amount as the wire carries it — a string, like every other
-    # money-shaped value, since a float would round the merchant's figure.
-    #
-    # @return [String]
-    def display_value
-      amount.to_s
-    end
-
     # @return [Spree::Money]
     def money
       Spree::Money.new(amount, currency: currency)

data/app/models/spree/category.rb

@@ -61,6 +61,7 @@ module Spree
     #
     has_one_attached :image, service: Spree.public_storage_service_name
     has_one_attached :square_image, service: Spree.public_storage_service_name
+    signed_id_attachments :image, :square_image
     # The slots double as media-library placements, so an upload here is
     # visible and reusable there (Spree::HasLibraryMedia).
     has_library_media :image, :square_image
@@ -133,8 +134,9 @@ module Spree
     #  Ransack
     #
     self.whitelisted_ransackable_associations = %w[parent]
-    self.whitelisted_ransackable_attributes = %w[name permalink automatic depth is_root children_count
+    self.whitelisted_ransackable_attributes = %w[name permalink automatic depth children_count
                                                  products_count pretty_name parent_id]
+    search_by :name, :pretty_name
 
     #
     # Translations

data/app/models/spree/channel/gating.rb

@@ -17,8 +17,9 @@ module Spree
         # Empty -> falls back to the Store-level preference. Both are `nullable`
         # so a blank write stays nil (inherit) rather than coercing to "" or
         # false, while an explicit value remains a channel override.
-        preference :storefront_access, :string, default: nil, nullable: true
+        preference :storefront_access, :string, default: nil, nullable: true, choices: STOREFRONT_ACCESS
         preference :guest_checkout, :boolean, default: nil, nullable: true
+        exposes_preferences :storefront_access, :guest_checkout
 
         validate :storefront_access_must_be_valid
       end

data/app/models/spree/channel.rb

@@ -16,6 +16,7 @@ module Spree
     # Empty -> falls back to the Store-level preference.
     preference :order_routing_strategy, :string, default: nil,
                                                  parse_on_set: ->(value) { Spree::ApiTyped.class_name_for(Spree.order_routing.strategies, value) }
+    exposes_preferences :order_routing_strategy
 
 
     has_many :orders, class_name: 'Spree::Order', inverse_of: :channel, dependent: :nullify
@@ -59,6 +60,7 @@ module Spree
     scope :default, -> { where(default: true) }
 
     self.whitelisted_ransackable_attributes = %w[name code active default store_id]
+    search_by :name
 
     # Publishes the given products on this channel by creating/upserting ProductPublications.
     # Optionally sets the publication window; if not given, the products will be published immediately

data/app/models/spree/claim.rb

@@ -44,6 +44,7 @@ module Spree
     delegate :currency, to: :order
 
     self.whitelisted_ransackable_attributes = %w[number status created_at]
+    search_by :number
     self.whitelisted_ransackable_associations = %w[order reason]
 
     def refund_total

data/app/models/spree/collection.rb

@@ -72,6 +72,7 @@ module Spree
     #
     has_one_attached :image, service: Spree.public_storage_service_name
     has_one_attached :square_image, service: Spree.public_storage_service_name
+    signed_id_attachments :image, :square_image
     # The slots double as media-library placements, so an upload here is
     # visible and reusable there (Spree::HasLibraryMedia).
     has_library_media :image, :square_image
@@ -101,6 +102,7 @@ module Spree
     # Ransack
     #
     self.whitelisted_ransackable_attributes = %w[permalink automatic sort_order products_count]
+    search_by :name
 
     #
     # Automatic (rule-based) membership

data/app/models/spree/commission_rate.rb

@@ -36,6 +36,9 @@ module Spree
     include Spree::SingleStoreResource
     include Spree::HasListPosition
     include Spree::Metadata
+    include Spree::CanonicalDecimals
+
+    canonical_decimals :value, places: 5
     include Spree::TypedAssociations
 
     KINDS = %w[percentage fixed].freeze
@@ -103,6 +106,7 @@ module Spree
 
     self.whitelisted_ransackable_attributes = %w[name code kind enabled position value
                                                  tax_inclusive include_shipping]
+    search_by :name
     self.whitelisted_ransackable_associations = %w[commission_rules]
 
     # @return [Boolean]
@@ -244,7 +248,7 @@ module Spree
     # shape a price list's rules use.
     #
     # Ids inside a rule's preferences are scope-checked against this rate's own
-    # store as they are written (see normalize_id_preference), so a rule can
+    # store as they are written (see `of: :id, scope:`), so a rule can
     # never be pointed at another marketplace's records.
     #
     # @param rows [Array<Hash>, nil]

data/app/models/spree/commission_rules/category_rule.rb

@@ -9,11 +9,8 @@ module Spree
     # restate the rule on every new leaf. The walk is done once per order by
     # Spree::Commissions::Context, not per rule.
     class CategoryRule < Spree::CommissionRule
-      preference :category_ids, :array, default: [],
-                 parse_on_set: normalize_id_preference(
-                   klass: Spree::Category,
-                   scope: ->(rule) { rule.store.categories }
-                 )
+      preference :category_ids, :array, of: :id, model: 'Spree::Category', default: [],
+                 scope: ->(rule) { rule.store.categories }
 
       # @return [Array<Spree::Category>]
       def categories

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

@@ -14,8 +14,8 @@ module Spree
     # This rule is the reason commission rules became classes. It could not
     # exist while a rule was only able to name a record.
     class ItemTotalRule < Spree::CommissionRule
-      preference :min_amount, :decimal, nullable: true
-      preference :max_amount, :decimal, nullable: true
+      preference :min_amount, :money, nullable: true
+      preference :max_amount, :money, nullable: true
 
       def applicable?(context)
         # Weighed exactly as the fee will weigh it, per this rate's own base.

data/app/models/spree/commission_rules/seller_rule.rb

@@ -7,11 +7,8 @@ module Spree
       # Ids are checked against the rate's own store on write, so a rule can
       # never be pointed at another marketplace's seller — and the client is
       # told, rather than having the id quietly dropped.
-      preference :seller_ids, :array, default: [],
-                 parse_on_set: normalize_id_preference(
-                   klass: Spree::Seller,
-                   scope: ->(rule) { rule.store.sellers }
-                 )
+      preference :seller_ids, :array, of: :id, model: 'Spree::Seller', default: [],
+                 scope: ->(rule) { rule.store.sellers }
 
       # @return [Array<Spree::Seller>]
       def sellers

data/app/models/spree/company.rb

@@ -101,6 +101,7 @@ module Spree
     }
 
     self.whitelisted_ransackable_attributes = %w[name kind parent_id po_number_required]
+    search_by :name
     self.whitelisted_ransackable_associations = %w[parent children memberships external_references]
 
     # The node a buyer browses and buys as when they name none: the single

data/app/models/spree/custom_field_definition.rb

@@ -25,16 +25,6 @@ module Spree
     scope :for_resource_type, ->(resource_type) { where(resource_type: resource_type) }
     scope :storefront_visible, -> { where(storefront_visible: true) }
     scope :admin_only, -> { where(storefront_visible: false) }
-    scope :search, ->(query) do
-      return all if query.blank?
-
-      search_term = "%#{query.downcase}%"
-      namespace_condition = arel_table[:namespace].lower.matches(search_term)
-      key_condition = arel_table[:key].lower.matches(search_term)
-      label_condition = arel_table[:label].lower.matches(search_term)
-
-      where(namespace_condition.or(key_condition).or(label_condition))
-    end
 
     #
     # Callbacks
@@ -52,8 +42,17 @@ module Spree
     #
     # Ransack
     #
-    self.whitelisted_ransackable_attributes = %w[key namespace label resource_type storefront_visible searchable sortable]
-    self.whitelisted_ransackable_scopes = %w[search]
+    self.whitelisted_ransackable_attributes = %w[key namespace label resource_type field_type storefront_visible searchable sortable]
+
+    # Both columns store class names; filters take the short names clients see.
+    def self.api_type_resolver(attribute)
+      case attribute
+      when 'resource_type' then ->(api_type) { normalize_value_for(:resource_type, api_type) }
+      when 'field_type' then ->(api_type) { Spree::CustomField::TYPE_TOKENS[api_type] }
+      else super
+      end
+    end
+    search_by :namespace, :key, :label
 
     # API-facing token for the STI subclass name stored in the `field_type`
     # column. Reader returns the registered token (`short_text`); writer

data/app/models/spree/customer_group.rb

@@ -5,6 +5,7 @@ module Spree
     acts_as_paranoid
 
     include Spree::SingleStoreResource
+    search_by :name
 
     #
     # Associations

data/app/models/spree/data_request.rb

@@ -56,6 +56,7 @@ module Spree
 
     self.whitelisted_ransackable_attributes = %w[number kind status email requested_at completed_at]
     self.whitelisted_ransackable_scopes = %w[access erasure in_progress]
+    self.ransackable_scope_types = %w[access erasure in_progress].index_with('boolean')
 
     before_validation :set_defaults, on: :create
 

data/app/models/spree/delivery_method.rb

@@ -122,6 +122,7 @@ module Spree
     # needed. `seller_id` is what the operator's list filters by to see one
     # seller's methods, or (blank) the marketplace's own.
     self.whitelisted_ransackable_attributes = %w[storefront_visible available_to_sellers seller_id]
+    search_by :name
     self.whitelisted_ransackable_associations = %w[seller]
 
     validates :name, presence: true
@@ -227,7 +228,11 @@ module Spree
     end
 
     def ensure_calculator
-      self.calculator ||= Spree::Calculator::Shipping::FlatRate.new(preferred_amount: 0)
+      self.calculator ||= default_calculator
+    end
+
+    def default_calculator
+      Spree::Calculator::Shipping::FlatRate.new(preferred_amount: 0)
     end
 
     def assign_default_delivery_profile

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

@@ -13,11 +13,8 @@ module Spree
       # decodes them on write, so eligibility compares against raw
       # `channel_id` rows. The scope confines the existence check to the
       # method's store, so cross-store channel IDs can't sneak in.
-      preference :channel_ids, :array, default: [],
-                 parse_on_set: normalize_id_preference(
-                   klass: Spree::Channel,
-                   scope: ->(rule) { rule.store.channels }
-                 )
+      preference :channel_ids, :array, of: :id, model: 'Spree::Channel', default: [],
+                 scope: ->(rule) { rule.store.channels }
 
       def channels
         return [] if preferred_channel_ids.blank?

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

@@ -4,8 +4,8 @@ module Spree
     # 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
+      preference :minimum_amount, :money, default: nil, nullable: true
+      preference :maximum_amount, :money, default: nil, nullable: true
 
       def eligible?(package)
         total = package.item_total

data/app/models/spree/delivery_profile.rb

@@ -13,6 +13,7 @@ module Spree
     include Spree::HasListPosition
 
     has_prefix_id :fp
+    search_by :name
 
     acts_as_list scope: :store
 

data/app/models/spree/delivery_rate.rb

@@ -80,9 +80,9 @@ module Spree
       @tax_amount ||= if tax_rate.nil?
                         BigDecimal(0)
                       elsif tax_rate.included_in_price?
-                        (cost / (1 + tax_rate.amount) * tax_rate.amount).round(2)
+                        Spree::Money::Rounding.to_currency(cost / (1 + tax_rate.amount) * tax_rate.amount, currency)
                       else
-                        (cost * tax_rate.amount).round(2)
+                        Spree::Money::Rounding.to_currency(cost * tax_rate.amount, currency)
                       end
     end
 
@@ -157,7 +157,7 @@ module Spree
     end
 
     def discount_amount
-      fulfillment.discounts.promotion.sum(:amount)
+      fulfillment.promotion_discount_total
     end
   end
 end

data/app/models/spree/delivery_zone.rb

@@ -33,7 +33,7 @@ module Spree
     validate :origin_group_must_belong_to_profile,
              if: -> { delivery_origin_group_id_changed? || delivery_profile_id_changed? }
 
-    self.whitelisted_ransackable_attributes = %w[name]
+    self.whitelisted_ransackable_attributes = %w[name delivery_profile_id]
 
     # @param address [Spree::Address, nil]
     # @return [Boolean] whether any member of this zone matches the address

data/app/models/spree/exchange.rb

@@ -42,6 +42,7 @@ module Spree
     delegate :currency, to: :order
 
     self.whitelisted_ransackable_attributes = %w[number status created_at]
+    search_by :number
     self.whitelisted_ransackable_associations = %w[order reason]
 
     # Positive when the replacements cost more than what came back (the

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

@@ -46,10 +46,10 @@ module Spree
           result.rows.each do |row|
             csv << Spree::CSV::FormulaSanitizer.row(
               row[:dimensions].map { |name, raw| hydration.label(name, raw) } +
-                query.metrics.map { |m| row[:metrics][m.name][:value] }
+                query.metrics.map { |m| m.format_value(row[:metrics][m.name][:value], result.meta[:currency]) }
             )
           end
-          totals = query.metrics.map { |m| result.totals[m.name][:value] }
+          totals = query.metrics.map { |m| m.format_value(result.totals[m.name][:value], result.meta[:currency]) }
           # With a breakdown the totals close the file under a "Total" label in
           # the first dimension column; without one the totals are the only row.
           label = query.dimensions.empty? ? [] : [I18n.t('spree.reporting.export.total')] + Array.new(query.dimensions.size - 1, '')

data/app/models/spree/file_upload.rb

@@ -0,0 +1,155 @@
+module Spree
+  # A file sent to `POST /files` (docs/plans/6.0-uploads-and-file-ownership.md),
+  # before anything uses it.
+  #
+  # Two ways in, one result. A presigned upload carries only the file's
+  # metadata and gets back a storage target the client sends the bytes to; a
+  # multipart upload carries the bytes, which are stored here. Either way the
+  # result is a blob owned by +store+ and an expiring, opaque `signed_id` the
+  # client passes to whichever endpoint uses the file.
+  #
+  # Never persisted: the blob is the record.
+  class FileUpload
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+
+    VISIBILITIES = %w[public private].freeze
+
+    attribute :filename, :string
+    attribute :content_type, :string
+    attribute :byte_size, :integer
+    attribute :checksum, :string
+    attribute :visibility, :string, default: 'public'
+    # The bytes of a multipart upload (an uploaded file or any IO).
+    attribute :file
+    attribute :store
+    # Narrower limits for a caller with its own rules (a buyer's purchase
+    # order document); the installation-wide ones apply otherwise.
+    attribute :max_byte_size, :integer
+    attribute :allowed_content_types
+
+    attr_reader :blob, :signed_id, :expires_at
+
+    validates :store, presence: true
+    validates :visibility, inclusion: { in: VISIBILITIES }
+    validates :filename, :content_type, presence: true
+    validates :checksum, presence: true, unless: :multipart?
+    validates :byte_size, numericality: { only_integer: true, greater_than: 0 }
+    validate :byte_size_within_limit
+    validate :content_type_allowed
+
+    # The content types a public upload may have. Private uploads accept any
+    # type: digital products are ebooks, archives and audio, and each
+    # attachment validates its own file.
+    #
+    # @return [Array<String>]
+    def self.public_content_types
+      Rails.application.config.active_storage.web_image_content_types +
+        Spree::Config.video_content_types +
+        %w[text/csv]
+    end
+
+    # @return [Boolean] whether the bytes travel in the request
+    def multipart?
+      file.respond_to?(:read)
+    end
+
+    # @return [Boolean] whether the file lands on private storage
+    def private?
+      visibility == 'private'
+    end
+
+    # Validates and creates the blob. A multipart upload is stored here; a
+    # presigned one waits for the client to send its bytes to {#upload_target}.
+    #
+    # @return [Boolean]
+    def save
+      read_file_facts if multipart?
+      return false unless valid?
+
+      @blob = multipart? ? store_bytes : reserve_blob
+      @expires_at = Spree::Uploads::SIGNED_ID_EXPIRY.from_now
+      @signed_id = Spree::Uploads.signed_id_for(@blob)
+      true
+    end
+
+    # Where a presigned upload's bytes go, or nil once the file is stored.
+    #
+    # @return [Spree::FileUpload::Target, nil]
+    def upload_target
+      return if multipart? || blob.nil?
+
+      Target.new(
+        http_method: 'PUT',
+        url: blob.service_url_for_direct_upload,
+        headers: blob.service_headers_for_direct_upload
+      )
+    end
+
+    # The storage target a presigned upload sends its bytes to.
+    class Target
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+
+      # Not `method`, which every Ruby object already answers.
+      attribute :http_method, :string
+      attribute :url, :string
+      attribute :headers
+    end
+
+    private
+
+    # The size of a multipart upload comes from the bytes, and so does its type
+    # wherever the bytes carry a recognisable signature: Marcel reads the
+    # content first, so a renamed executable is not accepted as an image. Only
+    # bytes it cannot place fall back to the declared type and the file name.
+    def read_file_facts
+      self.filename = filename.presence || file.try(:original_filename)
+      self.byte_size = io.size
+      self.content_type = Marcel::MimeType.for(io, name: filename, declared_type: content_type.presence || file.try(:content_type))
+      io.rewind
+    end
+
+    def reserve_blob
+      ActiveStorage::Blob.create!(
+        filename: filename, byte_size: byte_size, checksum: checksum, content_type: content_type,
+        service_name: service_name, store_id: store.id
+      )
+    end
+
+    def store_bytes
+      ActiveStorage::Blob.build_after_unfurling(
+        io: io, filename: filename, content_type: content_type, service_name: service_name, identify: false
+      ).tap do |blob|
+        blob.store_id = store.id
+        blob.save!
+        blob.upload_without_unfurling(io)
+      end
+    end
+
+    def io
+      @io ||= file.respond_to?(:to_io) ? file.to_io : file
+    end
+
+    def service_name
+      private? ? Spree.private_storage_service_name : Spree.public_storage_service_name
+    end
+
+    def size_limit
+      max_byte_size || (multipart? ? Spree::Config.max_multipart_upload_size : Spree::Config.max_upload_size)
+    end
+
+    def byte_size_within_limit
+      return if byte_size.nil? || byte_size <= size_limit
+
+      errors.add(:byte_size, :less_than_or_equal_to, count: ActiveSupport::NumberHelper.number_to_human_size(size_limit))
+    end
+
+    def content_type_allowed
+      allowed = allowed_content_types || (self.class.public_content_types unless private?)
+      return if allowed.nil? || content_type.blank? || allowed.include?(content_type)
+
+      errors.add(:content_type, :inclusion, value: content_type)
+    end
+  end
+end

data/app/models/spree/fulfillment.rb

@@ -374,9 +374,20 @@ module Spree
     #
     # @return [Boolean]
     def with_free_shipping_promotion?
+      return discounts.any?(&:promotion?) if read_association_in_memory?(:discounts)
+
       discounts.promotion.exists?
     end
 
+    # What promotions took off this shipment's cost, as a negative amount.
+    #
+    # @return [BigDecimal]
+    def promotion_discount_total
+      return discounts.select(&:promotion?).sum(BigDecimal('0'), &:amount) if read_association_in_memory?(:discounts)
+
+      discounts.promotion.sum(:amount)
+    end
+
     # Placement no longer moves physical stock — the units are promised in
     # Spree::Orders::Complete and only leave the shelf when the parcel does.
     def finalize!
@@ -701,7 +712,7 @@ module Spree
     #
     # @return [Spree::Delivery, nil]
     def primary_delivery
-      deliveries.first
+      read_association_in_memory?(:deliveries) ? deliveries.to_a.first : deliveries.first
     end
 
     # The primary delivery's tracking number. Read-only since 6.0: tracking is
@@ -895,8 +906,7 @@ module Spree
     def capture_at_gateway(payment, amount)
       return 0 if amount <= 0
 
-      units = Spree::Money::Rounding.to_minor_units(amount, payment.currency)
-      result = Spree.payment_capture_workflow.call(payment: payment, amount: units)
+      result = Spree.payment_capture_workflow.call(payment: payment, amount: amount)
       raise Spree::Core::GatewayError, result.error.value.to_s if result.failure?
 
       amount