spree_core 6.0.0.rc1 → 6.0.0.rc3

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

@@ -20,7 +20,8 @@ module Spree
                             .group("#{Variant.table_name}.product_id")
                             .to_sql
 
-        price_expr = Arel.sql('COALESCE(price_agg.agg_price, 999999999)')
+        # Above any price decimal(19,4) holds, so an unpriced product sorts last.
+        price_expr = Arel.sql('COALESCE(price_agg.agg_price, 1000000000000000)')
 
         joins("LEFT JOIN (#{price_agg_sql}) AS price_agg ON price_agg.product_id = #{Product.table_name}.id").
           select("#{Product.table_name}.*").
@@ -109,6 +110,9 @@ module Spree
       #
       #   Spree::Product.in_taxon(taxon).count(distinct: true)
       scope :in_taxon, ->(taxon) {
+        taxon = Spree::Category.find_by_prefix_id(taxon) if taxon.is_a?(String)
+        next none if taxon.nil?
+
         joins(:product_categories).
           where("#{Spree::ProductCategory.table_name}.category_id" => taxon.cached_self_and_descendants_ids).distinct
       }

data/app/models/concerns/spree/purchase/payment_processing.rb

@@ -46,7 +46,7 @@ module Spree
       #
       # @return [Boolean]
       def payment_required?
-        total.to_f > 0.0
+        total.to_d.positive?
       end
 
       # Whether a confirm/review pass is expected before completion —

data/app/models/concerns/spree/purchase/purchase_order.rb

@@ -17,8 +17,8 @@ module Spree
       MAX_PO_DOCUMENT_SIZE = 10.megabytes
 
       # What a purchase order plausibly arrives as: an export from the buyer's
-      # procurement system, a scan, or a photo of one. Matches the list the
-      # seller document requirement accepts — the same kinds of paperwork.
+      # procurement system (often a spreadsheet or CSV), a scan, or a photo of
+      # one.
       PO_DOCUMENT_CONTENT_TYPES = %w[
         application/pdf
         image/jpeg
@@ -27,6 +27,10 @@ module Spree
         image/webp
         application/msword
         application/vnd.openxmlformats-officedocument.wordprocessingml.document
+        application/vnd.ms-excel
+        application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
+        application/vnd.oasis.opendocument.spreadsheet
+        text/csv
       ].freeze
 
       included do
@@ -36,6 +40,7 @@ module Spree
         # internal cost codes, and is served only through an authenticated
         # download action.
         has_one_attached :po_document, service: Spree.private_storage_service_name
+        signed_id_attachments :po_document
 
         validates :po_document,
                   size: { less_than_or_equal_to: MAX_PO_DOCUMENT_SIZE },

data/app/models/concerns/spree/purchase/store_credits.rb

@@ -58,7 +58,7 @@ module Spree
 
       # @return [BigDecimal]
       def total_applied_store_credit
-        if payments.loaded?
+        if read_association_in_memory?(:payments)
           payments.
             find_all(&:store_credit?).
             reject(&:has_invalid_status?).
@@ -68,10 +68,32 @@ module Spree
         end
       end
 
+      # Balance still to collect, never negative. Store credit already applied
+      # but not yet captured is taken off; captured credit is a completed
+      # payment, so the balance has counted it already.
+      #
+      # @return [BigDecimal]
+      def amount_due
+        [outstanding_balance - uncaptured_store_credit, 0].max
+      end
+
+      # What store credit paid, apart from gift cards. A gift card is redeemed
+      # as store credit, but it is reported on its own as +gift_card_total+, so
+      # a summary showing both rows deducts each amount once.
+      #
+      # @return [BigDecimal]
+      def store_credit_total
+        total_applied_store_credit - gift_card_total
+      end
+
       def using_store_credit?
         total_applied_store_credit > 0
       end
 
+      def display_store_credit_total
+        Spree::Money.new(-store_credit_total, currency: currency)
+      end
+
       def display_total_applicable_store_credit
         Spree::Money.new(-total_applicable_store_credit, currency: currency)
       end
@@ -95,6 +117,19 @@ module Spree
       def display_total_minus_store_credits
         Spree::Money.new(total_minus_store_credits, currency: currency)
       end
+
+      private
+
+      # @return [BigDecimal]
+      def uncaptured_store_credit
+        if read_association_in_memory?(:payments)
+          payments.
+            select { |payment| payment.store_credit? && !payment.has_invalid_status? && !payment.completed? }.
+            sum(BigDecimal('0'), &:amount)
+        else
+          payments.store_credits.valid.where.not(status: 'completed').sum(:amount)
+        end
+      end
     end
   end
 end

data/app/models/concerns/spree/purchase/totals.rb

@@ -39,7 +39,7 @@ module Spree
 
         line_items.sum(BigDecimal('0')) do |line_item|
           gifted_quantity = excluded_gift_promo_actions.sum { |action| action.gifted_quantity_of(line_item) }
-          line_item.price * [gifted_quantity, line_item.quantity].min
+          Spree::Money::Rounding.to_currency(line_item.price * [gifted_quantity, line_item.quantity].min, line_item.currency)
         end
       end
 
@@ -75,13 +75,6 @@ module Spree
         outstanding_balance != 0
       end
 
-      # Balance still to collect after applied store credit, never negative.
-      #
-      # @return [BigDecimal]
-      def amount_due
-        [outstanding_balance - total_applied_store_credit, 0].max
-      end
-
       # @return [Boolean]
       def paid?
         total.positive? && payment_total >= total

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

@@ -11,6 +11,12 @@ module Spree::RansackableAttributes
     class_attribute :whitelisted_ransackable_attributes
     class_attribute :whitelisted_ransackable_scopes
 
+    # `{ 'price_between' => %w[decimal decimal], 'in_categories' => { list: 'id' } }`
+    # — the arguments a ransackable scope takes, which Ruby cannot report for
+    # a `scope` lambda. A scope taking none is `'boolean'`; an undeclared one
+    # is published as taking one text value.
+    class_attribute :ransackable_scope_types, default: {}
+
     # Associations the Store API may filter through. Empty by default: every
     # hop is a join into data the storefront was never meant to query, and a
     # join back to the model it came from lets one filter chain them forever.
@@ -21,6 +27,9 @@ module Spree::RansackableAttributes
     class_attribute :private_ransackable_attributes, default: {}
     class_attribute :private_ransackable_scopes, default: {}
 
+    # Attributes the `search` filter matches, set with {.search_by}.
+    class_attribute :search_attributes, default: [], instance_accessor: false
+
     class_attribute :default_ransackable_attributes
     # `position` is included so any `acts_as_list` model is sortable by it
     # without each subclass having to opt in. Ransack ignores attributes
@@ -48,10 +57,47 @@ module Spree::RansackableAttributes
     def self.ransackable_scopes(auth_object = nil)
       base = (whitelisted_ransackable_scopes || []).map(&:to_s)
       base |= Spree.ransack.custom_scopes_for(self).map(&:to_s)
+      base |= %w[search] if search_attributes.any? && search_attributes.all? { |path| ransackable_path?(path, auth_object) }
       return base unless Spree::RansackableAttributes.restricted_audience?(auth_object)
 
       base - Array(private_ransackable_scopes[auth_object.to_sym])
     end
+
+    # Declares the `search` filter (`q[search]=term`): a case-insensitive
+    # partial match on any of the given attributes, which may reach through
+    # associations (`variant_sku`). It runs as Ransack's `_cont` on those
+    # attributes, so translated names match in the current locale. An
+    # audience that may not filter on every one of them does not get it.
+    #
+    #   search_by :name, :code
+    #
+    # @param attributes [Array<Symbol, String>]
+    def self.search_by(*attributes)
+      self.search_attributes = attributes.map(&:to_s).freeze
+      scope :search, ->(query) {
+        query.blank? ? all : ransack("#{search_attributes.join('_or_')}_cont" => query.to_s.strip).result
+      }
+    end
+
+    # Whether an attribute, or one reached through associations
+    # (`variant_product_name`), is filterable by this audience.
+    #
+    # @param path [String]
+    # @param auth_object [Symbol, nil]
+    # @return [Boolean]
+    def self.ransackable_path?(path, auth_object = nil, depth = 0)
+      return true if ransackable_attributes(auth_object).include?(path)
+      return false if depth >= 2
+
+      ransackable_associations(auth_object).any? do |name|
+        next false unless path.start_with?("#{name}_")
+
+        reflection = reflect_on_association(name.to_sym)
+        next false if reflection.nil? || reflection.polymorphic? || !reflection.klass.respond_to?(:ransackable_path?)
+
+        reflection.klass.ransackable_path?(path.delete_prefix("#{name}_"), auth_object, depth + 1)
+      end
+    end
   end
 
   # @param auth_object [Symbol, nil] the Ransack auth object a search ran with

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

@@ -0,0 +1,54 @@
+module Spree
+  # Gives attachment slots their API write name, `<slot>_signed_id`
+  # (docs/plans/6.0-uploads-and-file-ownership.md).
+  #
+  #   signed_id_attachments :logo, :mailer_logo
+  #   store.update(logo_signed_id: upload.signed_id) # attaches
+  #   store.update(logo_signed_id: nil)              # removes
+  #
+  # A declared slot also refuses a file stored with the other visibility:
+  # attaching never moves a file between storage services, so a public upload
+  # attached to a private slot would stay readable at a public URL.
+  module SignedIdAttachments
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :signed_id_attachment_slots, instance_writer: false, default: []
+    end
+
+    class_methods do
+      # @param slots [Array<Symbol>] `has_one_attached` slot names
+      # @return [void]
+      def signed_id_attachments(*slots)
+        validate :signed_id_attachments_on_their_storage if signed_id_attachment_slots.empty?
+        self.signed_id_attachment_slots += slots
+
+        slots.each do |slot|
+          define_method(:"#{slot}_signed_id=") { |signed_id| public_send(:"#{slot}=", signed_id) }
+        end
+      end
+
+      # The name the API reports +attribute+'s errors under: `logo_signed_id`
+      # for the `logo` slot, so a client reads them back under the field it sent.
+      #
+      # @param attribute [Symbol, String]
+      # @return [String, nil] nil when +attribute+ is not a declared slot
+      def signed_id_attribute_for(attribute)
+        "#{attribute}_signed_id" if signed_id_attachment_slots.include?(attribute.to_sym)
+      end
+    end
+
+    private
+
+    def signed_id_attachments_on_their_storage
+      signed_id_attachment_slots.each do |slot|
+        blob = attachment_changes[slot.to_s].try(:blob)
+        expected_service = self.class.reflect_on_attachment(slot)&.options&.dig(:service_name)
+        next if blob.nil? || expected_service.nil? || blob.service_name.to_s == expected_service.to_s
+
+        visibility = expected_service.to_s == Spree.private_storage_service_name.to_s ? 'private' : 'public'
+        errors.add(slot, :wrong_visibility, message: I18n.t('spree.upload_wrong_visibility', visibility: visibility))
+      end
+    end
+  end
+end

data/app/models/concerns/spree/stores/email_branding.rb

@@ -6,7 +6,8 @@ module Spree
       extend ActiveSupport::Concern
 
       included do
-        Spree::Emails::Branding.attribute_names.each { |name| preference :"email_#{name}", :string }
+        Spree::Emails::Branding::COLORS.each { |name| preference :"email_#{name}", :string, format: :color }
+        preference :email_font, :string, choices: -> { Spree::Emails::Branding::FONTS.keys }
 
         validate :email_branding_valid
       end

data/app/models/concerns/spree/stores/markets.rb

@@ -7,6 +7,9 @@ module Spree
         has_many :markets, class_name: 'Spree::Market', dependent: :destroy
         has_one :default_market, -> { default }, class_name: 'Spree::Market'
 
+        normalizes :default_locale, with: ->(value) { value.to_s.strip.presence }
+        validates_with Spree::LocaleCodesValidator, attributes: %i[default_locale supported_locales]
+
         after_create :ensure_default_market
         after_update :sync_default_market_settings
       end
@@ -145,7 +148,7 @@ module Spree
           markets.create!(
             name: country.name,
             currency: read_attribute(:default_currency) || iso_country&.currency_code || 'USD',
-            default_locale: read_attribute(:default_locale) || iso_country&.languages_official&.first || 'en',
+            default_locale: read_attribute(:default_locale) || Spree::Locales.listed(iso_country&.languages_official&.first) || 'en',
             supported_locales: read_attribute(:supported_locales),
             default: true,
             bootstrap_default: true,
@@ -190,7 +193,7 @@ module Spree
       end
 
       def legacy_supported_locales_list
-        (read_attribute(:supported_locales).to_s.split(',') << default_locale).compact.uniq.sort
+        (read_attribute(:supported_locales).to_s.split(',').map(&:strip) << default_locale).compact_blank.uniq.sort
       end
     end
   end

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

@@ -1,11 +1,14 @@
 module Spree
   # Shared shape of the typed adjustment rows (TaxLine, Discount, Fee):
   # dual-FK cart/order owner (exactly one), consolidated +metadata+ JSON
-  # column, money display and localized amount parsing.
+  # column, money display and strict amount parsing.
   module TypedAdjustmentLine
     extend ActiveSupport::Concern
 
     included do
+      include Spree::CanonicalDecimals
+
+      canonical_decimals :amount
       attribute :metadata, default: -> { {} }
 
       belongs_to :order, class_name: 'Spree::Order', optional: true
@@ -38,10 +41,6 @@ module Spree
       end
     end
 
-    def amount=(amount)
-      self[:amount] = Spree::LocalizedNumber.parse(amount)
-    end
-
     def currency
       owner&.currency
     end

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

@@ -53,7 +53,7 @@ module Spree
 
     def reconcile_typed_association(association, rows)
       collection = public_send(association)
-      kept_ids = rows.filter_map { |row| save_typed_association_row(collection, row) }
+      kept_ids = rows.each_with_index.filter_map { |row, index| save_typed_association_row(collection, row, "/#{association.to_s.split('_').last}/#{index}") }
       if kept_ids.any? || rows.empty?
         collection.where.not(id: kept_ids).destroy_all
         # `where.not(...).destroy_all` deletes the dropped rows from the DB but
@@ -64,7 +64,8 @@ module Spree
       end
     end
 
-    def save_typed_association_row(collection, row)
+    # @param pointer [String] where the row sits in the request, e.g. `/rules/1`
+    def save_typed_association_row(collection, row, pointer)
       record = find_or_build_typed_association_row(collection, row)
       return nil unless record
 
@@ -78,12 +79,10 @@ module Spree
       deferred_ids, scalar_attrs = attrs.partition { |k, _| record.new_record? && k.to_s.end_with?('_ids') }
       record.assign_attributes(scalar_attrs.to_h) if scalar_attrs.any?
 
-      preferences&.each do |key, value|
-        next unless record.has_preference?(key.to_sym)
-
-        record.set_preference(key.to_sym, decode_preference_value(key, value))
+      record.assign_preferences(preferences, pointer: "#{pointer}/preferences") if preferences
+      if calculator.present? && record.respond_to?(:assign_calculator_attributes)
+        record.assign_calculator_attributes(calculator, pointer: "#{pointer}/calculator")
       end
-      record.assign_calculator_attributes(calculator) if calculator.present? && record.respond_to?(:assign_calculator_attributes)
 
       # Always save — `record.changed?` doesn't reflect preferences
       # (serialized hash) or calculator association changes.
@@ -101,17 +100,6 @@ module Spree
       raise
     end
 
-    # Decode `*_ids` array preferences (`customer_group_ids`, `user_ids`,
-    # …) from prefixed strings to raw PKs. Plain-scalar / non-id
-    # preferences pass through unchanged.
-    def decode_preference_value(key, value)
-      return value unless key.to_s.end_with?('_ids') && value.is_a?(Array)
-
-      value.map do |v|
-        Spree::PrefixedId.prefixed_id?(v) ? Spree::PrefixedId.decode_prefixed_id(v) : v
-      end
-    end
-
     def find_or_build_typed_association_row(collection, row)
       if row[:id].present?
         id = Spree::PrefixedId.prefixed_id?(row[:id]) ? Spree::PrefixedId.decode_prefixed_id(row[:id]) : row[:id]

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

@@ -1,6 +1,9 @@
 module Spree
   # Restates a VAT-inclusive price for a customer in another country: the
   # home-country VAT comes out, the destination's goes on.
+  #
+  # The including class answers +currency+, which the restated amount is
+  # rounded to.
   module VatPriceCalculation
     # Cheapest test first: a domestic sale needs no restatement whatever the
     # provider is, so the provider lookup (a constantize and an instantiation) is
@@ -11,7 +14,7 @@ module Spree
       return amount if amount.nil? || !outside_default_vat_zone?(price_options)
       return amount unless restatement_available?(price_options)
 
-      round_to_two_places(add_foreign_vat_for(amount, price_options))
+      Spree::Money::Rounding.to_currency(add_foreign_vat_for(amount, price_options), currency)
     end
 
     private
@@ -66,7 +69,7 @@ module Spree
         lookup[:country] = country_from(price_options)
       end
 
-      Spree::TaxRate.included_tax_amount_for(lookup).to_f
+      Spree::TaxRate.included_tax_amount_for(lookup).to_d
     end
 
     # +current_price_options+ is documented as an override point, so an app may
@@ -92,9 +95,5 @@ module Spree
 
       @default_tax_country = Spree::Current.store&.default_country
     end
-
-    def round_to_two_places(amount)
-      Spree::Money::Rounding.quantize(amount, 2)
-    end
   end
 end

data/app/models/spree/address.rb

@@ -206,7 +206,7 @@ module Spree
       scope.first
     end
 
-    self.whitelisted_ransackable_attributes = ADDRESS_FIELDS + %w[country_code state_code]
+    self.whitelisted_ransackable_attributes = ADDRESS_FIELDS - %w[country state] + %w[country_code state_code]
     self.whitelisted_ransackable_associations = %w[owner]
 
     def self.required_fields

data/app/models/spree/adjusters/largest_remainder.rb

@@ -1,6 +1,7 @@
 module Spree
   module Adjusters
-    # Largest-remainder apportionment of an integer cent total across weights.
+    # Largest-remainder apportionment of an integer total, in the currency's
+    # minor units, across weights.
     # Shared by promotion order-level distribution and manual admin discounts
     # so both split identically (sum of shares always equals the total).
     module LargestRemainder
@@ -19,6 +20,18 @@ module Spree
         end
         shares
       end
+
+      # Splits an amount across weights in the currency's minor units, so the
+      # shares are amounts that sum exactly to the one given.
+      #
+      # @param amount [BigDecimal]
+      # @param weights [Array<Numeric>] proportional bases (sum must be > 0)
+      # @param currency [String]
+      # @return [Array<BigDecimal>]
+      def apportion(amount, weights, currency)
+        units = Spree::Money::Rounding.to_minor_units(amount, currency)
+        largest_remainder_shares(units, weights).map { |share| Spree::Money::Rounding.from_minor_units(share, currency) }
+      end
     end
   end
 end

data/app/models/spree/adjusters/promotion.rb

@@ -140,7 +140,7 @@ module Spree
         end
       end
 
-      # Largest-remainder distribution (in cents) of the order-wide winner over
+      # Largest-remainder distribution (in minor units) of the order-wide winner over
       # each line's remaining discounted base, so shares always sum exactly to
       # the promotion amount and no line goes below zero.
       def distribute_over_line_items(chosen)
@@ -149,11 +149,10 @@ module Spree
         bases_sum = bases.sum
         return if bases_sum <= 0
 
-        total_cents = [chosen[:amount].abs, bases_sum].min * 100
-        shares = Spree::Adjusters::LargestRemainder.largest_remainder_shares(total_cents.round, bases)
+        shares = Spree::Adjusters::LargestRemainder.apportion([chosen[:amount].abs, bases_sum].min, bases, order.currency)
 
         line_items.each_with_index do |line_item, index|
-          amount = -BigDecimal(shares[index]) / 100
+          amount = -shares[index]
           next if amount.zero?
 
           persist_discount(line_item, chosen, amount)

data/app/models/spree/allowed_origin.rb

@@ -10,6 +10,9 @@ module Spree
 
     include Spree::SingleStoreResource
 
+    self.whitelisted_ransackable_attributes = %w[origin]
+    search_by :origin
+
 
     validates :origin, presence: true
     validates :origin, uniqueness: { scope: [:store_id, *spree_base_uniqueness_scope] }

data/app/models/spree/base.rb

@@ -9,6 +9,7 @@ class Spree::Base < ApplicationRecord
   include Spree::HasNumber
   include Spree::HasIsoGeography
   include Spree::TypedAssociations
+  include Spree::SignedIdAttachments
   include Spree::ValidatesStoreUniqueness
 
   # Extra writable attributes contributed by extensions, appended to the v3
@@ -68,6 +69,18 @@ class Spree::Base < ApplicationRecord
     true
   end
 
+  # Whether to answer from an association's rows rather than a query of its
+  # own (a SUM, an EXISTS). True when the rows are loaded already, or when
+  # this record came from a list loaded with +preload_associations_lazily+:
+  # loading them then fetches the rows for the whole list in one query, where
+  # an aggregate would run once per record.
+  #
+  # @param name [Symbol] the association
+  # @return [Boolean]
+  def read_association_in_memory?(name)
+    association(name).loaded? || lazy_preload_context.present?
+  end
+
   # @see Spree.mysql? — the single definition; this reads it so a model can
   #   branch without reaching for the connection itself.
   def mysql_adapter?
@@ -151,6 +164,22 @@ class Spree::Base < ApplicationRecord
     end
   end
 
+  # How a filter on one of this model's columns turns the short name a client
+  # sends (`purchase_order`) into the class name the column stores, or nil
+  # when the column does not store class names. Covers the STI column of a
+  # typed family and polymorphic `*_type` columns; a model with another such
+  # column overrides this.
+  #
+  # @param attribute [String]
+  # @return [Proc, nil] short name → stored class name
+  def self.api_type_resolver(attribute)
+    if attribute == inheritance_column && api_type_registry.any?
+      ->(api_type) { class_name_for_api_type(api_type) }
+    elsif reflect_on_all_associations(:belongs_to).any? { |reflection| reflection.polymorphic? && reflection.foreign_type == attribute }
+      ->(api_type) { Spree::Base.polymorphic_type_for(api_type) }
+    end
+  end
+
   # Shorthand for a *polymorphic* `*_type` column (`owner_type`,
   # `viewable_type`, …), where the value names an arbitrary model rather than a
   # subclass of the serialized one — so `api_type_for`'s registry lookup does

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

@@ -7,7 +7,7 @@ module Spree
     end
 
     def compute(object)
-      computed_amount = (object.amount * preferred_flat_percent / 100).round(2)
+      computed_amount = Spree::Money::Rounding.to_currency(object.amount * preferred_flat_percent / 100, object.try(:currency))
 
       # We don't want to cause the promotion adjustments to push the order into a negative total.
       if computed_amount > object.amount

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

@@ -1,7 +1,7 @@
 module Spree
   class Calculator::FlatRate < Calculator
-    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 }
     preference :apply_only_on_full_priced_items, :boolean, default: false
 
     def self.description

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

@@ -1,9 +1,9 @@
 module Spree
   class Calculator::FlexiRate < Calculator
-    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 }
     preference :apply_only_on_full_priced_items, :boolean, default: false
 
     def self.description

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

@@ -11,7 +11,7 @@ module Spree
       def compute(object)
         return 0 if preferred_apply_only_on_full_priced_items && object.variant.compare_at_amount_in(object.currency).present?
 
-        computed_amount = (object.amount * preferred_percent / 100).round(2)
+        computed_amount = Spree::Money::Rounding.to_currency(object.amount * preferred_percent / 100, object.currency)
 
         # We don't want to cause the promotion adjustments to push the order into a negative total.
         if computed_amount > object.amount

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

@@ -1,9 +1,9 @@
 module Spree
   class Calculator::PriceSack < Calculator
-    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 }
 
     def self.description
       I18n.t('spree.price_sack')

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

@@ -3,8 +3,8 @@ module Spree
     class DigitalDelivery < 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.digital.digital_delivery')

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

@@ -8,12 +8,14 @@ module Spree
       end
 
       def compute_package(package)
-        compute_from_price(total(package.contents))
+        compute_from_price(total(package.contents), package.currency)
       end
 
-      def compute_from_price(price)
-        value = price * BigDecimal(preferred_flat_percent.to_s) / 100.0
-        (value * 100).round.to_f / 100
+      # @param price [BigDecimal]
+      # @param currency [String, nil] the amount is rounded to its minor unit
+      # @return [BigDecimal]
+      def compute_from_price(price, currency = nil)
+        Spree::Money::Rounding.to_currency(price * BigDecimal(preferred_flat_percent.to_s) / 100, currency)
       end
     end
   end