spree_core 6.0.0.beta3 → 6.0.0.rc1

data/app/models/spree/return_line_item.rb

@@ -3,7 +3,11 @@ module Spree
   #
   # Named for {Spree::LineItem}, which it mirrors: `quantity` is what the
   # customer said was coming, `received_quantity` what the warehouse counted.
+  # Like a line item it carries its worth before tax in `pre_tax_amount` and
+  # the tax on it beside that, both for the announced quantity.
   class ReturnLineItem < Spree.base_class
+    include Spree::PostSale::TaxedLine
+
     has_prefix_id :rli
 
     belongs_to :return, class_name: 'Spree::Return', inverse_of: :return_line_items
@@ -19,31 +23,80 @@ module Spree
 
     delegate :order, :currency, to: :return
 
-    # What this line refunds. Once the warehouse has counted, only the units
-    # that arrived are paid for — a customer who announced three and sent two
-    # is owed two — and before the count there is nothing to go on but the
-    # announced quantity.
+    extend Spree::DisplayMoney
+    money_methods :pre_tax_amount, :included_tax_total, :additional_tax_total, :tax_total,
+                  :refund_amount, :refund_tax_amount
+
+    # What this line refunds, tax included. Once the warehouse has counted,
+    # only the units that arrived are paid for — a customer who announced
+    # three and sent two is owed two — and before the count there is nothing
+    # to go on but the announced quantity.
     #
     # Rounded to the currency, because this is the ceiling a refund is checked
     # against as well as the figure the dialog offers: a third of $29.99 taken
     # three times is not $29.99 until it is.
     #
+    # A line opened before returns carried tax holds the price it was opened
+    # with in `pre_tax_amount` and no tax, so it refunds exactly what it did.
+    #
     # @return [BigDecimal]
     def refund_amount
-      return pre_tax_amount unless self.return.counted?
-      return 0.to_d if quantity.to_i.zero?
+      counted_share(total)
+    end
 
-      Spree::Money::Rounding.to_currency(
-        (pre_tax_amount / quantity) * received_quantity.to_i, currency
-      )
+    # @return [BigDecimal] the tax inside {#refund_amount}
+    def refund_tax_amount
+      counted_share(tax_total)
+    end
+
+    # @return [BigDecimal] the announced units, tax included
+    def total
+      pre_tax_amount + tax_total
+    end
+
+    def tax_total
+      included_tax_total + additional_tax_total
+    end
+
+    # The units this line gives back: none once the return is canceled, what
+    # arrived once the warehouse has counted, what was announced before.
+    #
+    # @return [Integer]
+    def credited_quantity
+      return 0 if self.return.canceled?
+
+      self.return.counted? ? received_quantity.to_i : quantity.to_i
+    end
+
+    # @return [BigDecimal] what the credited units are worth, tax included
+    def credited_worth
+      refund_amount
     end
 
-    def display_pre_tax_amount
-      Spree::Money.new(pre_tax_amount, currency: currency)
+    # Copies the credit rows written at opening onto the line. The before-tax
+    # figure is what was paid after discounts less the tax inside it, so the
+    # three columns add up to the cent.
+    #
+    # @return [void]
+    def fold_tax_lines!
+      included, additional = tax_totals_from(tax_lines.credits.reload)
+
+      update_columns(
+        pre_tax_amount: default_pre_tax_amount - included,
+        included_tax_total: included,
+        additional_tax_total: additional
+      )
     end
 
     private
 
+    def counted_share(value)
+      return value unless self.return.counted?
+      return 0.to_d if quantity.to_i.zero?
+
+      Spree::Money::Rounding.to_currency((value / quantity) * received_quantity.to_i, currency)
+    end
+
     # The refundable amount defaults to this item's share of what the
     # customer actually paid for the line, after discounts — refunding the
     # list price would give back more than was taken.
@@ -53,9 +106,7 @@ module Spree
     end
 
     def default_pre_tax_amount
-      return 0 if line_item.nil? || line_item.quantity.to_i.zero?
-
-      (line_item.amount / line_item.quantity) * quantity.to_i
+      line_item&.discounted_amount_for(quantity) || 0
     end
   end
 end

data/app/models/spree/role.rb

@@ -150,7 +150,7 @@ module Spree
 
     def permissions_must_be_known
       unknown = permissions - Spree.permissions.catalog_keys
-      errors.add(:permissions, :role_permissions_unknown, message: Spree.t(:role_permissions_unknown, keys: unknown.join(', '))) if unknown.any?
+      errors.add(:permissions, :role_permissions_unknown, message: I18n.t('spree.role_permissions_unknown', keys: unknown.join(', '))) if unknown.any?
     end
 
     # Every role is bounded by the catalog: only resources registered as
@@ -164,26 +164,26 @@ module Spree
       return if ungrantable.none?
 
       errors.add(
-        :permissions, :role_permissions_not_grantable_for_audience, message: Spree.t(:role_permissions_not_grantable_for_audience, audience: audience, keys: ungrantable.join(', '))
+        :permissions, :role_permissions_not_grantable_for_audience, message: I18n.t('spree.role_permissions_not_grantable_for_audience', audience: audience, keys: ungrantable.join(', '))
       )
     end
 
     # Re-pointing the resource would move every existing assignment to another
     # panel — and, for a store, to another tenant.
     def resource_immutable
-      errors.add(:resource, :role_resource_immutable, message: Spree.t(:role_resource_immutable))
+      errors.add(:resource, :role_resource_immutable, message: I18n.t('spree.role_resource_immutable'))
     end
 
     def name_immutable
-      errors.add(:name, :role_immutable, message: Spree.t(:role_immutable)) unless mutable_was_and_not_admin?
+      errors.add(:name, :role_immutable, message: I18n.t('spree.role_immutable')) unless mutable_was_and_not_admin?
     end
 
     def permissions_immutable
-      errors.add(:permissions, :role_immutable, message: Spree.t(:role_immutable)) unless mutable_was_and_not_admin?
+      errors.add(:permissions, :role_immutable, message: I18n.t('spree.role_immutable')) unless mutable_was_and_not_admin?
     end
 
     def description_immutable
-      errors.add(:description, :role_immutable, message: Spree.t(:role_immutable)) unless mutable_was_and_not_admin?
+      errors.add(:description, :role_immutable, message: I18n.t('spree.role_immutable')) unless mutable_was_and_not_admin?
     end
 
     # Guards compare against the persisted `mutable` so flipping it in the same
@@ -197,7 +197,7 @@ module Spree
     def ensure_can_be_deleted
       return true if can_be_deleted?
 
-      errors.add(:base, :role_cannot_be_deleted, message: Spree.t(:role_cannot_be_deleted))
+      errors.add(:base, :role_cannot_be_deleted, message: I18n.t('spree.role_cannot_be_deleted'))
       throw :abort
     end
   end

data/app/models/spree/saved_report.rb

@@ -25,7 +25,7 @@ module Spree
     self.whitelisted_ransackable_attributes = %w[name seeded created_at updated_at]
 
     def event_serializer_class
-      'Spree::Api::V3::Admin::SavedReportSerializer'.safe_constantize
+      'Spree::Api::V3::SavedReportEventSerializer'.safe_constantize
     end
 
     # The stored query, normalized against the registry.

data/app/models/spree/seller.rb

@@ -25,6 +25,8 @@ module Spree
     MEMOIZED_METHODS = %w[onboarding_requirements onboarding_progress products_count returns_location].freeze
 
     publishes_lifecycle_events
+    publishes_events :approved, :invited, :onboarding_reopened, :onboarding_started, :rejected,
+                     :submitted_for_review, :suspended
 
     # Where a seller is in its life on the marketplace. Transitions belong to
     # workflows (Spree::Sellers::Approve and friends) rather than a state
@@ -62,7 +64,6 @@ module Spree
     #
     # Associations
     #
-    belongs_to :store, class_name: 'Spree::Store'
     # The address knows it is a seller's from its owner, so it is read back
     # with the business rules — no personal name insisted on, the company line
     # required. Not `dependent: :destroy`: a seller is paranoid, so destroy is

data/app/models/spree/seller_payout.rb

@@ -16,6 +16,8 @@ module Spree
   # and leaves the operator to pay by bank, while a provider like Stripe
   # Connect performs the transfer itself.
   class SellerPayout < Spree.base_class
+    publishes_event :completed
+
     has_prefix_id :vpo
 
     include Spree::Metadata
@@ -58,6 +60,11 @@ module Spree
     scope :owed, -> { where(status: %w[pending processing]) }
 
     self.whitelisted_ransackable_attributes = %w[amount currency status provider reference period_start period_end created_at seller_id]
+    # Filtered by the provider's API shorthand (`system`); the column holds
+    # its class name.
+    ransacker :provider, formatter: ->(value) { Spree::ApiTyped.class_name_for(Spree.payout_providers, value) } do |parent|
+      parent.table[:provider]
+    end
     # No `transfers`: they lead on to the order and its buyer, which a
     # payouts-only caller may not read.
     self.whitelisted_ransackable_associations = %w[seller]

data/app/models/spree/seller_requirement.rb

@@ -16,6 +16,9 @@ module Spree
     include Spree::HasListPosition
     include Spree::PreferenceSchema
     include Spree::Metadata
+    include Spree::TypeLabels
+
+    self.type_labels_scope = 'spree.seller_requirement_types'
 
     has_prefix_id :selreq
 
@@ -87,16 +90,6 @@ module Spree
       end
     end
 
-    # @return [String] the localized name of the kind, used by operator pickers
-    def self.human_name
-      Spree.t("seller_requirement_types.#{api_type}.name", default: api_type.titleize)
-    end
-
-    # @return [String] the localized description of the kind
-    def self.human_description
-      Spree.t("seller_requirement_types.#{api_type}.description", default: '')
-    end
-
     # Whether the operator may configure this kind more than once per store.
     # True for the kinds whose meaning comes from the operator's own copy.
     #
@@ -266,8 +259,7 @@ module Spree
       return if Spree.seller_requirements.any? { |kind| kind.to_s == type }
 
       errors.add(
-        :type, :invalid_seller_requirement, message: Spree.t(:invalid_seller_requirement, scope: [:errors, :messages],
-                                             default: 'is not a registered seller requirement')
+        :type, :invalid_seller_requirement, message: I18n.t('spree.errors.messages.invalid_seller_requirement')
       )
     end
   end

data/app/models/spree/seller_requirement_custom_field.rb

@@ -22,8 +22,7 @@ module Spree
       return if custom_field_definition.resource_type == Spree::Seller.to_s
 
       errors.add(:custom_field_definition, :invalid,
-                 message: Spree.t('seller_requirements.custom_field_not_for_sellers',
-                                  default: 'must be a custom field defined for sellers'))
+                 message: I18n.t('spree.seller_requirements.custom_field_not_for_sellers'))
     end
 
     # Both sides are store-owned, so a marketplace can only ask its sellers

data/app/models/spree/seller_requirement_submission.rb

@@ -16,6 +16,7 @@ module Spree
     has_prefix_id :selsub
 
     publishes_lifecycle_events
+    publishes_events :accepted, :created, :rejected, :waived
 
     # `waived` is the operator excusing one seller from something the store
     # asks of everyone — a requirement they have already satisfied off the
@@ -84,8 +85,7 @@ module Spree
       return if seller.nil? || requirement.nil?
       return if seller.store_id == requirement.store_id
 
-      errors.add(:requirement, :seller_requirement_store_mismatch, message: Spree.t('errors.messages.seller_requirement_store_mismatch',
-                                       default: 'must belong to the same store as the seller'))
+      errors.add(:requirement, :seller_requirement_store_mismatch, message: I18n.t('spree.errors.messages.seller_requirement_store_mismatch'))
     end
   end
 end

data/app/models/spree/seller_requirements/accept_terms.rb

@@ -90,14 +90,13 @@ module Spree
         # On the preference rather than :base, so the operator's form marks the
         # field they got wrong instead of only showing a summary line.
         errors.add(:preferred_terms_effective_from, :invalid_terms_effective_from,
-                   message: Spree.t('seller_requirements.invalid_terms_effective_from',
-                                    default: 'Terms effective from is not a date'))
+                   message: I18n.t('spree.seller_requirements.invalid_terms_effective_from'))
       end
 
       def store_terms_body
         return if store.nil?
 
-        store.policies.with_matching_name(Spree.t(:terms_of_service)).detect(&:with_body?)&.body
+        store.policies.with_matching_name(I18n.t('spree.terms_of_service')).detect(&:with_body?)&.body
       end
     end
   end

data/app/models/spree/seller_transfer.rb

@@ -112,6 +112,11 @@ module Spree
     end
 
     self.whitelisted_ransackable_attributes = %w[amount currency kind status provider reference created_at seller_id order_id payout_id]
+    # Filtered by the provider's API shorthand (`system`); the column holds
+    # its class name.
+    ransacker :provider, formatter: ->(value) { Spree::ApiTyped.class_name_for(Spree.payout_providers, value) } do |parent|
+      parent.table[:provider]
+    end
     # No `order`: filtering through it reaches the buyer's email and address,
     # which a payouts-only caller may not read. `order_id` covers the lookup.
     self.whitelisted_ransackable_associations = %w[seller payout refund]

data/app/models/spree/shipping_label.rb

@@ -20,6 +20,7 @@ module Spree
     include Spree::Metadata
 
     publishes_lifecycle_events
+    publishes_events :purchased, :refunded
 
     has_status :purchased, :refund_requested, :refunded, default: :purchased
 

data/app/models/spree/stock/availability_validator.rb

@@ -17,11 +17,11 @@ module Spree
         if variant.available? || variant.preorder?
           line_item.errors.add(:quantity,
                                :selected_quantity_not_available,
-                               message: Spree.t(:selected_quantity_not_available, item: display_name.inspect))
+                               message: I18n.t('spree.selected_quantity_not_available', item: display_name.inspect))
         else
           line_item.errors.add(:base,
                                :only_active_products_can_be_added_to_cart,
-                               message: Spree.t(:only_active_products_can_be_added_to_cart))
+                               message: I18n.t('spree.only_active_products_can_be_added_to_cart'))
         end
       end
 

data/app/models/spree/stock/inventory_unit_builder.rb

@@ -14,7 +14,7 @@ module Spree
         @order.line_items.map do |line_item|
           # They go through multiple splits, avoid loading the
           # association to order until needed.
-          Spree::InventoryUnit.new(
+          Spree::FulfillmentItem.new(
             pending: true,
             line_item_id: line_item.id,
             variant_id: line_item.variant_id,

data/app/models/spree/stock/packer.rb

@@ -35,8 +35,8 @@ module Spree
             next unless stock_location.stocks? variant
 
             on_hand, backordered = stock_location.fill_status(variant, unit.quantity)
-            package.add(InventoryUnit.split(unit, backordered), :backordered) if backordered.positive?
-            package.add(InventoryUnit.split(unit, on_hand), :on_hand) if on_hand.positive?
+            package.add(FulfillmentItem.split(unit, backordered), :backordered) if backordered.positive?
+            package.add(FulfillmentItem.split(unit, on_hand), :on_hand) if on_hand.positive?
           else
             package.add unit
           end

data/app/models/spree/stock/splitter/weight.rb

@@ -73,7 +73,7 @@ module Spree
           per_content_max_quantity = 1 if per_content_max_quantity.zero?
           content_items = [content_item]
           while content_item.quantity > per_content_max_quantity
-            split_inventory = InventoryUnit.split(content_item.inventory_unit, per_content_max_quantity)
+            split_inventory = FulfillmentItem.split(content_item.inventory_unit, per_content_max_quantity)
             content_items << ContentItem.new(split_inventory, content_item.state)
           end
           content_items

data/app/models/spree/stock_level/custom_events.rb

@@ -17,6 +17,12 @@ module Spree
       LEGACY_EVENT_PREFIX = 'stock_item'
       LEGACY_EVENT_SUFFIXES = %w[created updated deleted].freeze
 
+      def self.included(base)
+        LEGACY_EVENT_SUFFIXES.each do |suffix|
+          base.publishes_event("#{LEGACY_EVENT_PREFIX}.#{suffix}", deprecated_alias_of: "#{base.event_prefix}.#{suffix}")
+        end
+      end
+
       # Wraps publishing rather than the three callbacks that call it, so the
       # decisions Publishable makes — whether events are enabled at all,
       # whether a touch-only update is worth announcing — are made once and the

data/app/models/spree/stock_level.rb

@@ -100,7 +100,7 @@ module Spree
     }
 
     def backordered_inventory_units
-      Spree::InventoryUnit.backordered_for_stock_level(self)
+      Spree::FulfillmentItem.backordered_for_stock_level(self)
     end
 
     # @api private

data/app/models/spree/stock_movement.rb

@@ -114,7 +114,7 @@ module Spree
       return default_adjustment_reason if reason.blank?
       return reason.to_s unless ADJUSTMENT_REASONS.include?(reason.to_s)
 
-      Spree.t("stock_movement.reasons.#{reason}", locale: :en)
+      I18n.t("spree.stock_movement.reasons.#{reason}", locale: :en)
     end
 
     # A movement is an immutable audit row: once written, nothing may rewrite

data/app/models/spree/stock_receipt_item.rb

@@ -29,7 +29,7 @@ module Spree
     def counts_something
       return if quantity_counted.positive?
 
-      errors.add(:base, :nothing_counted, message: Spree.t('stock_receipt.errors.nothing_counted'))
+      errors.add(:base, :nothing_counted, message: I18n.t('spree.stock_receipt.errors.nothing_counted'))
     end
   end
 end

data/app/models/spree/stock_reservation.rb

@@ -127,7 +127,7 @@ module Spree
     end
 
     def exactly_one_owner
-      errors.add(:base, :exactly_one_of_cart_or_order, message: Spree.t('errors.messages.exactly_one_of_cart_or_order')) unless [order, cart].compact.one?
+      errors.add(:base, :exactly_one_of_cart_or_order, message: I18n.t('spree.errors.messages.exactly_one_of_cart_or_order')) unless [order, cart].compact.one?
     end
 
     # Only a quantity change moves units between counters, so re-pointing a
@@ -135,7 +135,7 @@ module Spree
     # missing from the new. A hold that belongs elsewhere is released and
     # taken again, never moved.
     def stock_level_unchanged
-      errors.add(:stock_level_id, :immutable, message: Spree.t('errors.messages.stock_level_immutable')) if stock_level_id_changed?
+      errors.add(:stock_level_id, :immutable, message: I18n.t('spree.errors.messages.stock_level_immutable')) if stock_level_id_changed?
     end
   end
 end

data/app/models/spree/stock_transfer.rb

@@ -36,6 +36,8 @@ module Spree
     acts_as_paranoid
 
     publishes_lifecycle_events
+    publishes_events :canceled, :draft, :partially_received, :over_received, :ready_to_ship,
+                     :received, :shipped
 
     has_status :draft, :ready_to_ship, :in_transit, :partially_received, :received, :over_received, :canceled,
                default: :draft
@@ -97,7 +99,7 @@ module Spree
       return if source_location_id.blank? || destination_location_id.blank?
       return if source_location_id != destination_location_id
 
-      errors.add(:source_location, :same_location, message: Spree.t('stock_transfer.errors.same_location'))
+      errors.add(:source_location, :same_location, message: I18n.t('spree.stock_transfer.errors.same_location'))
     end
 
     # A transfer moves a merchant's own stock between their own warehouses. Two
@@ -108,7 +110,7 @@ module Spree
       return if source_location.store_id == destination_location.store_id
 
       errors.add(:destination_location, :must_belong_to_same_store,
-                 message: Spree.t('stock_transfer.errors.locations_in_different_stores'))
+                 message: I18n.t('spree.stock_transfer.errors.locations_in_different_stores'))
     end
   end
 end

data/app/models/spree/store.rb

@@ -13,6 +13,7 @@ module Spree
     include Spree::Stores::Setup
     include Spree::Stores::Markets
     include Spree::Stores::Channels
+    include Spree::Stores::EmailBranding
     include Spree::StoreDataSources
     include Spree::Security::Stores if defined?(Spree::Security::Stores)
     include Spree::UserManagement
@@ -45,6 +46,9 @@ module Spree
     preference :timezone, :string, default: Time.zone.name
     preference :weight_unit, :string, default: 'lb'
     preference :unit_system, :string, default: 'imperial'
+    # Anonymous identifier of this installation, kept on the default store
+    # (see Spree.install_id). Written by Spree, never by the operator.
+    preference :install_id, :string, internal: true, nullable: true
     # email preferences
     preference :send_consumer_transactional_emails, :boolean, default: true
     # Sellers are a different audience from shoppers, with their own reasons to
@@ -69,7 +73,8 @@ module Spree
     # Who pays this store's sellers. Blank means core's record-only provider,
     # so a marketplace that has connected nothing still keeps a correct ledger
     # and settles by hand.
-    preference :payout_provider, :string, default: nil
+    preference :payout_provider, :string, default: nil,
+                                          parse_on_set: ->(value) { Spree::ApiTyped.class_name_for(Spree.payout_providers, value) }
     # Refused at write time rather than silently falling back at read time: an
     # operator who mistypes a provider would otherwise get a bookkeeping-only
     # ledger and no indication anywhere that their choice was ignored.
@@ -151,7 +156,8 @@ module Spree
     preference :digital_asset_link_expire_time, :integer, default: 300
     # Class name of the Spree::OrderRouting::Strategy::Base subclass that
     # decides which StockLocation fulfills which items.
-    preference :order_routing_strategy, :string, default: 'Spree::OrderRouting::Strategy::Rules'
+    preference :order_routing_strategy, :string, default: 'Spree::OrderRouting::Strategy::Rules',
+                                                 parse_on_set: ->(value) { Spree::ApiTyped.class_name_for(Spree.order_routing.strategies, value) }
 
     # Document numbering (docs/plans/6.0-document-numbers.md). The format
     # applies to every numbered document; prefix, suffix and starting value
@@ -300,6 +306,8 @@ module Spree
     has_many :policies, class_name: 'Spree::Policy', dependent: :destroy, as: :owner
 
     has_many :webhook_endpoints, class_name: 'Spree::WebhookEndpoint', dependent: :destroy, inverse_of: :store
+    has_many :email_templates, class_name: 'Spree::EmailTemplate', dependent: :destroy, inverse_of: :store
+    has_many :email_template_drafts, class_name: 'Spree::EmailTemplateDraft', dependent: :destroy, inverse_of: :store
     has_many :webhook_deliveries, through: :webhook_endpoints, class_name: 'Spree::WebhookDelivery'
 
     has_many :channels, class_name: 'Spree::Channel', dependent: :destroy
@@ -384,6 +392,7 @@ module Spree
     before_validation :set_default_code, on: :create
     before_validation :normalize_preferred_storefront_url
     before_save :ensure_default_exists_and_is_unique
+    before_save :set_install_id
     after_create :create_default_policies
     after_create :create_default_delivery_profile
 
@@ -475,14 +484,12 @@ module Spree
     #
     # @return [Class]
     def payout_provider_class
-      configured = preferred_payout_provider.presence
       # A name no longer in the registry — a typo, or a gem since removed —
       # would otherwise raise inside a subscriber on every fulfillment and stop
       # the ledger recording anything. The built-in provider keeps the books
       # until an operator fixes the setting.
-      configured = nil unless Spree.payout_providers.any? { |provider| provider.to_s == configured }
-
-      (configured || Spree.default_payout_provider.to_s).constantize
+      Spree::ApiTyped.registered_class(Spree.payout_providers, preferred_payout_provider) ||
+        Spree.default_payout_provider.to_s.constantize
     end
 
     def formatted_url
@@ -543,6 +550,21 @@ module Spree
       allowed_origins.any? { |allowed_origin| allowed_origin.matches?(url) }
     end
 
+    # The logo emails show: the dedicated mailer logo, else the store logo.
+    #
+    # @return [ActiveStorage::Attached::One, nil] nil when neither is an image
+    def email_logo
+      logo = mailer_logo.attached? ? mailer_logo : self.logo
+      logo if logo.attached? && logo.variable?
+    end
+
+    # The address customers are told to write to: the support address, else the sender address.
+    #
+    # @return [String, nil]
+    def support_email_address
+      customer_support_email.presence || mail_from_address
+    end
+
     # Returns the states available for checkout for the store
     # @param country [Spree::Country] the country to get the states for
     # @return [Array<Spree::State>]
@@ -613,7 +635,7 @@ module Spree
       @default_stock_location ||= begin
         stock_location_scope = stock_locations.first_party.where(default: true)
         stock_location_scope.first || ActiveRecord::Base.connected_to(role: :writing) do
-          stock_location_scope.create(default: true, name: Spree.t(:default_stock_location_name),
+          stock_location_scope.create(default: true, name: I18n.t('spree.default_stock_location_name'),
                                       country_code: default_country&.iso)
         end
       end
@@ -699,6 +721,10 @@ module Spree
       I18n.t(key, locale: locale, default: I18n.t(key, locale: :en))
     end
 
+    def set_install_id
+      self.preferred_install_id = SecureRandom.uuid if preferred_install_id.blank?
+    end
+
     def ensure_default_exists_and_is_unique
       if default
         Spree::Store.where.not(id: id).update_all(default: false)

data/app/models/spree/store_credit.rb

@@ -18,7 +18,6 @@ module Spree
     AUTHORIZE_ACTION  = 'authorize'.freeze
     ALLOCATION_ACTION = 'allocation'.freeze
 
-    belongs_to :store, class_name: 'Spree::Store'
     # A gift card applied to a guest cart issues store credit with no customer
     # to attach it to.
     belongs_to :customer, class_name: "::#{Spree.customer_class}", optional: true
@@ -146,16 +145,16 @@ module Spree
         )
         authorization_code
       else
-        errors.add(:base, :insufficient_authorized_amount, message: Spree.t('store_credit_payment_method.insufficient_authorized_amount'))
+        errors.add(:base, :insufficient_authorized_amount, message: I18n.t('spree.store_credit_payment_method.insufficient_authorized_amount'))
         false
       end
     end
 
     def validate_authorization(amount, order_currency)
       if BigDecimal(amount_remaining, 3) < BigDecimal(amount, 3)
-        errors.add(:base, :insufficient_funds, message: Spree.t('store_credit_payment_method.insufficient_funds'))
+        errors.add(:base, :insufficient_funds, message: I18n.t('spree.store_credit_payment_method.insufficient_funds'))
       elsif currency != order_currency
-        errors.add(:base, :currency_mismatch, message: Spree.t('store_credit_payment_method.currency_mismatch'))
+        errors.add(:base, :currency_mismatch, message: I18n.t('spree.store_credit_payment_method.currency_mismatch'))
       end
       errors.blank?
     end
@@ -165,7 +164,7 @@ module Spree
 
       if amount <= amount_authorized
         if currency != order_currency
-          errors.add(:base, :currency_mismatch, message: Spree.t('store_credit_payment_method.currency_mismatch'))
+          errors.add(:base, :currency_mismatch, message: I18n.t('spree.store_credit_payment_method.currency_mismatch'))
           false
         else
           update!(
@@ -179,7 +178,7 @@ module Spree
           authorization_code
         end
       else
-        errors.add(:base, :insufficient_authorized_amount, message: Spree.t('store_credit_payment_method.insufficient_authorized_amount'))
+        errors.add(:base, :insufficient_authorized_amount, message: I18n.t('spree.store_credit_payment_method.insufficient_authorized_amount'))
         false
       end
     end
@@ -196,7 +195,7 @@ module Spree
         true
       else
         errors.add(:base, :unable_to_void, auth_code: authorization_code,
-                   message: Spree.t('store_credit_payment_method.unable_to_void', auth_code: authorization_code))
+                   message: I18n.t('spree.store_credit_payment_method.unable_to_void', auth_code: authorization_code))
         false
       end
     end
@@ -206,7 +205,7 @@ module Spree
       capture_event = store_credit_events.find_by(action: CAPTURE_ACTION, authorization_code: authorization_code)
 
       if currency != order_currency # sanity check to make sure the order currency hasn't changed since the auth
-        errors.add(:base, :currency_mismatch, message: Spree.t('store_credit_payment_method.currency_mismatch'))
+        errors.add(:base, :currency_mismatch, message: I18n.t('spree.store_credit_payment_method.currency_mismatch'))
         false
       elsif capture_event && amount <= capture_event.amount
         action_attributes = {
@@ -219,7 +218,7 @@ module Spree
         true
       else
         errors.add(:base, :unable_to_credit, auth_code: authorization_code,
-                   message: Spree.t('store_credit_payment_method.unable_to_credit', auth_code: authorization_code))
+                   message: I18n.t('spree.store_credit_payment_method.unable_to_credit', auth_code: authorization_code))
         false
       end
     end