spree_core 6.0.0.beta4 → 6.0.0.rc1

data/app/models/spree/digital_asset.rb

@@ -5,6 +5,9 @@ module Spree
     has_prefix_id :dig
 
     publishes_lifecycle_events
+    publishes_event 'digital.created', deprecated_alias_of: 'digital_asset.created'
+    publishes_event 'digital.updated', deprecated_alias_of: 'digital_asset.updated'
+    publishes_event 'digital.deleted', deprecated_alias_of: 'digital_asset.deleted'
 
     # Provider config lives under one key in `metadata` so a provider owns its
     # own namespace without colliding with other developer metadata. The values
@@ -22,6 +25,10 @@ module Spree
     # and provider-backed assets (which carry no file) are exempt.
     DEFAULT_PROVIDER = 'Spree::DigitalAssetProvider::File'.freeze
 
+    # The API names a provider by its shorthand (`file`); the column keeps the
+    # class name.
+    normalizes :provider_type, with: ->(value) { Spree::ApiTyped.class_name_for(Spree.digital_asset_providers, value) }
+
     validate :provider_type_is_registered, if: -> { provider_type.present? }
     # Only ask a valid provider whether it needs a file — an unregistered
     # provider_type is already rejected above, and calling requires_attachment?

data/app/models/spree/digital_asset_provider/base.rb

@@ -12,6 +12,8 @@ module Spree
     # into internal software and owns its own configuration. The base gives it
     # only the asset.
     class Base
+      extend Spree::ApiTyped
+
       attr_reader :digital_asset
 
       SETTING_TYPES = %i[string number boolean select].freeze

data/app/models/spree/digital_link.rb

@@ -3,12 +3,9 @@ module Spree
     has_prefix_id :dl  # Spree-specific: digital link
 
     publishes_lifecycle_events
+    publishes_event :downloaded
 
-    if Rails::VERSION::STRING >= '7.1.0'
-      has_secure_token on: :save
-    else
-      has_secure_token
-    end
+    has_secure_token on: :save
 
     if defined?(Spree::Security::DigitalLinks)
       include Spree::Security::DigitalLinks

data/app/models/spree/discount.rb

@@ -45,7 +45,7 @@ module Spree
     private
 
     def exactly_one_adjustable
-      errors.add(:base, :exactly_one_adjustable, message: Spree.t('errors.messages.exactly_one_adjustable')) unless [line_item, fulfillment].compact.one?
+      errors.add(:base, :exactly_one_adjustable, message: I18n.t('spree.errors.messages.exactly_one_adjustable')) unless [line_item, fulfillment].compact.one?
     end
   end
 end

data/app/models/spree/email_template.rb

@@ -0,0 +1,25 @@
+module Spree
+  # A store's published version of an editable email template (an email, the
+  # layout or a shared partial). Found before the template file whenever a
+  # customer email renders, so it is what customers receive. Reverting marks it
+  # reverted rather than deleting it, so its revisions stay reachable.
+  class EmailTemplate < Spree.base_class
+    has_prefix_id :etpl
+
+    include Spree::EmailTemplateIdentity
+    include Spree::HasStatus
+    include Spree::ActedBy
+
+    has_status :published, :reverted, default: :published
+
+    publishes_events :published, :reverted
+
+    acted_by :published_by
+    acted_by :reverted_by
+
+    has_many :revisions, -> { order(created_at: :desc) }, class_name: 'Spree::EmailTemplateRevision',
+                                                           dependent: :destroy, inverse_of: :email_template
+
+    validates :published_at, presence: true
+  end
+end

data/app/models/spree/email_template_draft.rb

@@ -0,0 +1,13 @@
+module Spree
+  # Work in progress on an editable email template, one per store, template
+  # and language. Shared by every admin of the store: `lock_version` refuses a
+  # save made from a stale copy, and `updated_by` says who saved it last.
+  class EmailTemplateDraft < Spree.base_class
+    has_prefix_id :etdr
+
+    include Spree::EmailTemplateIdentity
+    include Spree::ActedBy
+
+    acted_by :updated_by
+  end
+end

data/app/models/spree/email_template_revision.rb

@@ -0,0 +1,17 @@
+module Spree
+  # One published version of a store's email template, kept so it can be
+  # restored. Append-only.
+  class EmailTemplateRevision < Spree.base_class
+    has_prefix_id :etrv
+
+    include Spree::ActedBy
+
+    belongs_to :email_template, class_name: 'Spree::EmailTemplate', inverse_of: :revisions
+
+    acted_by :published_by
+
+    validates :body, presence: true
+
+    delegate :store, :key, :locale, to: :email_template
+  end
+end

data/app/models/spree/email_templates/entry.rb

@@ -0,0 +1,118 @@
+module Spree
+  module EmailTemplates
+    # One editable email template for one store and language, as the editor
+    # shows it: what customers receive now, the draft in progress and
+    # Spree's default. For one language, Spree's translation keys are written
+    # out as text in it, so the merchant reads and edits plain words.
+    class Entry
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+
+      attribute :definition
+      attribute :locale, :string, default: Spree::EmailTemplate::ANY_LOCALE
+      attribute :published
+      attribute :draft
+      attribute :customized_locales, default: -> { [] }
+
+      delegate :key, :kind, to: :definition
+
+      # @param store [Spree::Store]
+      # @param locale [String] a language code, or "any"
+      # @return [Array<Spree::EmailTemplates::Entry>] every editable template
+      def self.all(store, locale: Spree::EmailTemplate::ANY_LOCALE)
+        published = store.email_templates.published.where(locale: [locale, Spree::EmailTemplate::ANY_LOCALE]).
+                    sort_by { |template| template.locale == locale ? 0 : 1 }.uniq(&:key).index_by(&:key)
+        drafts = store.email_template_drafts.where(locale: locale).includes(:updated_by).index_by(&:key)
+        customized = store.email_templates.published.pluck(:key, :locale).group_by(&:first)
+
+        Spree.editable_email_templates.map do |definition|
+          new(definition: definition, locale: locale, published: published[definition.key], draft: drafts[definition.key],
+              customized_locales: customized.fetch(definition.key, []).map(&:last).sort)
+        end
+      end
+
+      # @param store [Spree::Store]
+      # @param id [String] the template's key with dots, e.g. "spree.order_mailer.confirm_email"
+      # @param locale [String]
+      # @return [Spree::EmailTemplates::Entry]
+      # @raise [ActiveRecord::RecordNotFound] when no editable template has that id
+      def self.for_id(store, id, locale: Spree::EmailTemplate::ANY_LOCALE)
+        definition = Spree.editable_email_templates[id.to_s.tr('.', '/')]
+        raise ActiveRecord::RecordNotFound, "Couldn't find email template #{id}" unless definition
+
+        locale = locale.presence || Spree::EmailTemplate::ANY_LOCALE
+        new(
+          definition: definition, locale: locale,
+          published: store.email_templates.published.where(key: definition.key, locale: [locale, Spree::EmailTemplate::ANY_LOCALE]).
+                     min_by { |template| template.locale == locale ? 0 : 1 },
+          draft: store.email_template_drafts.for_key(definition.key, locale).first,
+          customized_locales: store.email_templates.published.where(key: definition.key).order(:locale).pluck(:locale)
+        )
+      end
+
+      # The key with dots, so it fits in a URL segment.
+      def id
+        key.tr('/', '.')
+      end
+      alias prefixed_id id
+
+      def customized?
+        published.present?
+      end
+
+      # @return [Spree::Emails::Template, nil] the template file Spree or the app ships
+      def default
+        @default ||= Spree::Emails::TemplateResolver.for_mailers.find_default(key)
+      end
+
+      # @return [String, nil] the language of the published version customers
+      #   receive: this one, or "any" when the version for every language applies
+      def published_locale
+        published&.locale
+      end
+
+      # What customers receive now.
+      def subject
+        readable(customized? ? published.subject : default&.subject, escape: false)
+      end
+
+      def body
+        readable(customized? ? published.body : default&.body)
+      end
+
+      def default_subject
+        readable(default&.subject, escape: false)
+      end
+
+      def default_body
+        readable(default&.body)
+      end
+
+      def base_subject
+        readable(outdated_version&.base_subject, escape: false)
+      end
+
+      def base_body
+        readable(outdated_version&.base_body)
+      end
+
+      # The default the store's version started from, when Spree's default has
+      # changed since, so the editor can show what changed.
+      #
+      # @return [Spree::EmailTemplate, Spree::EmailTemplateDraft, nil]
+      def outdated_version
+        # An open draft is what gets published next, so it alone decides.
+        version = draft || published
+        version if version&.default_changed?(default)
+      end
+
+      private
+
+      def readable(text, escape: true)
+        return text if locale == Spree::EmailTemplate::ANY_LOCALE
+
+        Spree::Emails::TranslationInliner.call(text, locale: locale, escape: escape)
+      end
+    end
+  end
+end

data/app/models/spree/email_templates/sample_record.rb

@@ -0,0 +1,16 @@
+module Spree
+  module EmailTemplates
+    # A record of the store an email can be previewed with, as the editor's
+    # record picker lists it.
+    class SampleRecord
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+
+      attribute :id, :string
+      attribute :label, :string
+      attribute :created_at, :datetime
+
+      alias prefixed_id id
+    end
+  end
+end

data/app/models/spree/emails/branding.rb

@@ -0,0 +1,80 @@
+module Spree
+  module Emails
+    # How a store's customer emails look: its colors and font over the
+    # defaults the shipped layout was designed with. Templates read it as
+    # `store.branding`, so it outlives any edit or revert of a template.
+    class Branding
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+
+      COLOR_FORMAT = /\A#\h{6}\z/
+
+      # Email-safe fonts, with fallback stacks for clients that do not load
+      # web fonts. Family names stay unquoted: templates escape what they print.
+      FONTS = {
+        'inter' => { family: 'Inter, Helvetica, Arial, sans-serif', heading_family: 'Geist, Inter, Helvetica, Arial, sans-serif' },
+        'system' => { family: '-apple-system, BlinkMacSystemFont, Segoe UI, Roboto, Helvetica, Arial, sans-serif' },
+        'helvetica' => { family: 'Helvetica, Arial, sans-serif' },
+        'georgia' => { family: 'Georgia, Times New Roman, Times, serif' },
+        'roboto' => { family: 'Roboto, Helvetica, Arial, sans-serif', url: 'https://fonts.googleapis.com/css2?family=Roboto:wght@400;500;700' },
+        'lato' => { family: 'Lato, Helvetica, Arial, sans-serif', url: 'https://fonts.googleapis.com/css2?family=Lato:wght@400;700' },
+        'merriweather' => { family: 'Merriweather, Georgia, serif', url: 'https://fonts.googleapis.com/css2?family=Merriweather:wght@400;700' }
+      }.freeze
+
+      DEFAULT_FONT = 'inter'.freeze
+      DEFAULT_COLORS = {
+        background_color: '#FFFFFF', card_color: '#F6F6F6', text_color: '#726A6A', heading_color: '#332C2C'
+      }.freeze
+      COLORS = %i[accent_color background_color card_color text_color heading_color].freeze
+
+      COLORS.each { |color| attribute color, :string }
+      attribute :font, :string
+
+      validates(*COLORS, format: { with: COLOR_FORMAT }, allow_blank: true)
+      validates :font, inclusion: { in: FONTS.keys }, allow_blank: true
+
+      # What templates read as `store.branding`. A value that is not a color
+      # or a known font falls back to the default, so nothing else ever reaches
+      # an email's CSS, unsaved preview values included.
+      #
+      # @return [Hash{String => String, nil}]
+      def to_h
+        accent = color(:accent_color)
+        typeface_key = FONTS.key?(font) ? font : DEFAULT_FONT
+        typeface = FONTS[typeface_key]
+        colors = DEFAULT_COLORS.to_h { |name, default| [name, color(name) || default] }
+
+        {
+          **colors,
+          accent_color: accent,
+          link_color: accent || colors[:heading_color],
+          # Without an accent, buttons keep the outlined look the layout ships with.
+          button_color: accent || '#FFFFFF',
+          button_text_color: accent ? readable_text_on(accent) : '#1F2222',
+          button_border: accent ? 'none' : '1px solid #E8E9E9',
+          font: typeface_key,
+          font_family: typeface[:family],
+          heading_font_family: typeface[:heading_family] || typeface[:family],
+          font_url: typeface[:url]
+        }.stringify_keys
+      end
+
+      private
+
+      def color(name)
+        value = public_send(name).to_s
+        value.upcase if value.match?(COLOR_FORMAT)
+      end
+
+      # Black or white, whichever reads better on the color (WCAG relative luminance).
+      def readable_text_on(hex)
+        red, green, blue = hex.delete('#').scan(/../).map do |channel|
+          value = channel.to_i(16) / 255.0
+          value <= 0.03928 ? value / 12.92 : ((value + 0.055) / 1.055)**2.4
+        end
+        luminance = (0.2126 * red) + (0.7152 * green) + (0.0722 * blue)
+        luminance > 0.179 ? '#000000' : '#FFFFFF'
+      end
+    end
+  end
+end

data/app/models/spree/exchange.rb

@@ -17,13 +17,14 @@ module Spree
     include Spree::HasStatus
     include Spree::HasCustomFields
     include Spree::Metadata
+    include Spree::PostSale::Taxation
 
     publishes_lifecycle_events
+    publishes_events :approved, :canceled, :fulfilled, :received, :requested
 
     has_status :requested, :approved, :received, :fulfilled, :canceled,
                default: :requested
 
-    belongs_to :store, class_name: 'Spree::Store'
     belongs_to :order, class_name: 'Spree::Order', inverse_of: :exchanges
     belongs_to :stock_location, class_name: 'Spree::StockLocation'
     belongs_to :reason, class_name: 'Spree::ReturnReason', optional: true, inverse_of: :exchanges
@@ -53,5 +54,18 @@ module Spree
     def display_price_difference
       Spree::Money.new(price_difference, currency: currency)
     end
+
+    def taxed_lines
+      exchange_line_items
+    end
+
+    private
+
+    # The replacement is a sale of its own, taxed as the order would be today
+    # rather than read off the original line, whose category it may not share.
+    def estimate_tax(lines, amounts: nil)
+      super
+      order.tax_provider.estimate_replacement(order, lines, **order.tax_estimate_inputs)
+    end
   end
 end

data/app/models/spree/exchange_line_item.rb

@@ -1,7 +1,13 @@
 module Spree
   # One swap on a {Spree::Exchange}: a quantity of one variant going back,
   # the same quantity of another coming out.
+  #
+  # Both halves are taxed: the units coming back are credited the tax the
+  # customer paid on them (`original_*`), and the replacement is taxed as a new
+  # sale (`new_*`), each for the announced quantity.
   class ExchangeLineItem < Spree.base_class
+    include Spree::PostSale::TaxedLine
+
     has_prefix_id :eli
 
     belongs_to :exchange, class_name: 'Spree::Exchange', inverse_of: :exchange_line_items
@@ -19,24 +25,134 @@ module Spree
 
     delegate :order, :currency, to: :exchange
 
-    # What the customer paid for the units coming back, after discounts —
-    # not the list price, which would over-credit a discounted line.
+    extend Spree::DisplayMoney
+    money_methods :original_price, :new_variant_price, :price_difference, :original_tax_total, :new_tax_total
+
+    # What the customer paid for the units coming back, after discounts and
+    # with the tax charged on top — not the list price, which would
+    # over-credit a discounted line.
     def original_price
-      return 0 if line_item.nil? || line_item.quantity.to_i.zero?
+      original_amount_for(quantity) + original_additional_tax_total
+    end
+
+    def original_pre_tax_amount
+      original_amount_for(quantity) - original_included_tax_total
+    end
 
-      (line_item.amount / line_item.quantity) * quantity.to_i
+    def original_tax_total
+      original_included_tax_total + original_additional_tax_total
     end
 
+    # What the replacement costs, tax on top included.
     def new_variant_price
-      new_variant.price_in(currency)&.amount.to_d * quantity.to_i
+      replacement_amount_for(quantity) + new_additional_tax_total
+    end
+
+    def new_pre_tax_amount
+      replacement_amount_for(quantity) - new_included_tax_total
+    end
+
+    def new_tax_total
+      new_included_tax_total + new_additional_tax_total
     end
 
     def price_difference
       new_variant_price - original_price
     end
 
+    # The replacement keeps the deal the customer had on what it replaces:
+    # its price carries the original line's discount in the same proportion,
+    # so swapping a size of a discounted item costs nothing.
+    #
+    # @param units [Integer]
+    # @return [BigDecimal]
+    def replacement_amount_for(units)
+      price = new_variant&.price_in(currency)&.amount.to_d
+
+      Spree::Money::Rounding.to_currency(price * units.to_i * discount_ratio, currency)
+    end
+
+    # The units this swap covers: none once canceled, what arrived once the
+    # warehouse has counted, what was announced before.
+    #
+    # @return [Integer]
+    def credited_quantity
+      return 0 if exchange.canceled?
+
+      exchange.received? || exchange.fulfilled? ? received_quantity.to_i : quantity.to_i
+    end
+
+    # @return [BigDecimal] what the units coming back are worth, tax included
+    def credited_worth
+      units = credited_quantity
+      return 0.to_d if quantity.to_i.zero?
+
+      original_amount_for(units) +
+        Spree::Money::Rounding.to_currency((original_additional_tax_total / quantity) * units, currency)
+    end
+
+    # What the provider taxes the replacement on (see
+    # Spree::TaxProvider::Base#estimate_replacement).
+    def taxable_basis
+      replacement_amount_for(credited_quantity)
+    end
+
+    def tax_category_id
+      new_variant&.tax_category_id
+    end
+
+    # What the units that arrived are credited, from the rows as they stand.
+    #
+    # @return [BigDecimal]
+    def settled_credit
+      original_amount_for(received_quantity) + tax_lines.credits.additional.sum(:amount)
+    end
+
+    # What their replacements cost, from the rows as they stand.
+    #
+    # @return [BigDecimal]
+    def settled_charge
+      replacement_amount_for(received_quantity) + tax_lines.charges.additional.sum(:amount)
+    end
+
+    # The tax inside {#settled_credit} less the tax inside {#settled_charge}.
+    #
+    # @return [BigDecimal]
+    def settled_tax
+      credited_tax_total - tax_lines.charges.sum(:amount)
+    end
+
+    # @return [void]
+    def fold_tax_lines!
+      rows = tax_lines.reload.to_a
+      original_included, original_additional = tax_totals_from(rows.select(&:credit?))
+      new_included, new_additional = tax_totals_from(rows.reject(&:credit?))
+
+      update_columns(
+        original_included_tax_total: original_included,
+        original_additional_tax_total: original_additional,
+        new_included_tax_total: new_included,
+        new_additional_tax_total: new_additional
+      )
+    end
+
     private
 
+    def original_amount_for(units)
+      line_item&.discounted_amount_for(units) || 0.to_d
+    end
+
+    def discount_ratio
+      amount = line_item&.amount.to_d
+      return 1 unless amount.positive?
+
+      [line_item.discounted_amount, 0].max / amount
+    end
+
+    def recorded_tax_total
+      original_tax_total + new_tax_total
+    end
+
     def set_original_variant_from_line_item
       self.original_variant ||= line_item&.variant
     end

data/app/models/spree/export.rb

@@ -30,7 +30,6 @@ module Spree
     #
     # Associations
     #
-    belongs_to :store, class_name: 'Spree::Store'
     # Optional so secret-API-key callers (apps / server-to-server) can create
     # exports without a human user attached. The email notification is
     # skipped for these — apps poll instead.

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

@@ -9,13 +9,22 @@ module Spree
       end
 
       def variant_includes
-        [:images, :prices, :stock_levels, :stock_locations, { option_values: [:option_type] }]
+        [:images, :prices, { stock_levels: :stock_location, option_values: [:option_type] }]
       end
 
       def multi_line_csv?
         true
       end
 
+      # The seller scopes which locations the inventory columns cover; their
+      # default, worked out once per export, carries the full row's stock.
+      def to_csv_options
+        @to_csv_options ||= {
+          seller: seller,
+          default_stock_location: Spree::StockLocation.owned_by(store_id: store.id, seller_id: seller&.id).active.order_default.first || store.default_stock_location
+        }
+      end
+
       # when doing full product export, we want to exclude archived products
       def scope
         if search_params.nil?

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

@@ -52,7 +52,7 @@ module Spree
           totals = query.metrics.map { |m| result.totals[m.name][:value] }
           # 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? ? [] : [Spree.t('reporting.export.total')] + Array.new(query.dimensions.size - 1, '')
+          label = query.dimensions.empty? ? [] : [I18n.t('spree.reporting.export.total')] + Array.new(query.dimensions.size - 1, '')
           csv << Spree::CSV::FormulaSanitizer.row(label + totals)
         end
       end

data/app/models/spree/fee.rb

@@ -10,8 +10,10 @@ module Spree
     # Extensions may append their own kinds — the list is validated, not frozen.
     # `duty` rows are written by a duties provider's adjuster and snapshot the
     # classification they were calculated from in `metadata` — never re-derive
-    # a duty from the live catalog.
-    KINDS = %w[surcharge handling gift_wrap cod payment duty]
+    # a duty from the live catalog. `exchange` is what a customer owes when an
+    # exchange's replacement costs more, put on the order for the merchant to
+    # collect.
+    KINDS = %w[surcharge handling gift_wrap cod payment duty exchange]
 
     has_prefix_id :fee