spree_core 6.0.0.beta3 → 6.0.0.rc1

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

@@ -7,6 +7,8 @@ module Spree
     # decide at resolution time rather than at claim creation.
     class Resolve < Spree::Workflow
       include Spree::Refunds::OrderPayments
+      include Spree::Refunds::TaxCredit
+      include Spree::Fulfillments::Replacements
 
       hooks :validate, :before_settle, :after_resolve
 
@@ -32,6 +34,8 @@ module Spree
         step :resolve_amount if refunding?
         run_hooks :validate
 
+        step :settle_tax
+
         ApplicationRecord.transaction do
           run_hooks :before_settle
           step :build_replacement_fulfillments if replacing?
@@ -40,6 +44,7 @@ module Spree
         end
 
         external_step :refund_at_gateway if refunding? && !internal_refund?
+        external_step :refund_tax if refunding?
 
         step :recalculate_order
         run_hooks :after_resolve
@@ -68,14 +73,35 @@ module Spree
           # attribute, and ActiveModel raises when an error names one that
           # does not exist on the record.
           claim.errors.add(:base, :invalid_refund_method,
-                           message: Spree.t('errors.messages.invalid_refund_method'))
+                           message: I18n.t('spree.errors.messages.invalid_refund_method'))
           failure(claim)
         end
         failure(claim, :not_approved) unless claim.approved?
       end
 
+      # Rewrites the credit rows for the money actually going back — each line's
+      # share of it follows the refund agreed for that line — or clears them
+      # when the claim is put right with a replacement alone.
+      def settle_tax
+        lines = claim.claim_line_items.to_a
+        amounts = if refunding?
+                    weights = lines.index_with(&:refund_amount)
+                    weights = lines.index_with(&:paid_amount) if weights.values.sum.zero?
+                    allocate_refund(@amount_to_refund, weights, claim.currency)
+                  else
+                    lines.index_with { 0.to_d }
+                  end
+
+        with_tax_provider(claim) { claim.settle_tax!(amounts: amounts) }
+        @tax_amount = claim.credited_tax_total
+      end
+
+      def refund_tax
+        file_tax_credit(claim, claim.claim_line_items.to_a, @amount_to_refund)
+      end
+
       # A claim can never refund more than the customer paid for the affected
-      # items.
+      # items, tax included.
       def resolve_amount
         @amount_to_refund = (amount || claim.refund_total).to_d
         ceiling = claim.claim_line_items.sum(&:paid_amount).to_d
@@ -96,37 +122,13 @@ module Spree
       end
 
       def build_replacement_fulfillments
-        units = claim.replacement_line_items.map do |line|
-          claim.order.fulfillment_items.new(
-            variant: line.variant_to_send,
-            quantity: line.quantity,
-            line_item: line.line_item,
-            order: claim.order,
-            status: 'on_hand'
-          )
-        end
-
-        failure(claim, :nothing_to_replace) if units.empty?
-
-        @fulfillments = Spree::Stock::Coordinator.new(claim.order, units).fulfillments
-        if @fulfillments.flat_map(&:fulfillment_items).sum(&:quantity) != units.sum(&:quantity)
-          failure(claim, :replacement_out_of_stock)
+        items = claim.replacement_line_items.map do |line|
+          { variant: line.variant_to_send, quantity: line.quantity, line_item: line.line_item }
         end
 
-        claim.order.fulfillments += @fulfillments
-        claim.order.save!
-        @fulfillments.each { |fulfillment| allocate_replacement_stock(fulfillment) }
-      end
-
-      # See Spree::Exchanges::Fulfill — a replacement that holds no promise
-      # ships without writing a movement, so the shelf never follows the goods.
-      def allocate_replacement_stock(fulfillment)
-        fulfillment.manifest.each do |item|
-          next unless item.variant.track_inventory?
-          next unless item.quantity.positive?
+        failure(claim, :nothing_to_replace) if items.empty?
 
-          fulfillment.stock_location.allocate(item.variant, item.quantity, fulfillment)
-        end
+        @fulfillments = build_replacements(claim, items)
       end
 
       def issue_store_credit
@@ -144,7 +146,8 @@ module Spree
           order: claim.order,
           amount: @amount_to_refund,
           record: claim,
-          refunder: resolver
+          refunder: resolver,
+          tax_amount: @tax_amount
         )
 
         failure(claim, :no_refundable_payments) if @refunds.empty?

data/app/workflows/spree/customers/anonymize.rb

@@ -91,7 +91,7 @@ module Spree
         # release gateway data, and hand back success, for a row that is still
         # fully identified.
         unless committed
-          return failure(customer, Spree.t('customer_errors.anonymize_failed'))
+          return failure(customer, I18n.t('spree.customer_errors.anonymize_failed'))
         end
 
         purge_collected_attachments
@@ -103,9 +103,8 @@ module Spree
         customer.reload
 
         customer.publish_event(
-          'customer.anonymized',
-          store_id: store&.prefixed_id,
-          requested_by_id: requested_by&.prefixed_id
+          'customer.anonymized', nil,
+          store_id: store&.prefixed_id, requested_by_id: requested_by&.prefixed_id
         )
 
         run_hooks :after_anonymize

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

@@ -195,7 +195,7 @@ module Spree
       # vocabulary: a store may not have one called "Terms of Service", and
       # then there is nothing to snapshot rather than something to guess at.
       def consent_policies
-        store.policies.with_matching_name(Spree.t(:terms_of_service)).to_a
+        store.policies.with_matching_name(I18n.t('spree.terms_of_service')).to_a
       end
 
       def link_order

data/app/workflows/spree/data_requests/fulfill.rb

@@ -53,7 +53,7 @@ module Spree
       def ensure_pending
         return if data_request.pending?
 
-        failure(data_request, Spree.t('data_request_errors.not_pending'))
+        failure(data_request, I18n.t('spree.data_request_errors.not_pending'))
       end
 
       def mark_processing
@@ -92,7 +92,7 @@ module Spree
 
         return unless refused
 
-        failure(data_request, Spree.t('data_request_errors.already_anonymized'))
+        failure(data_request, I18n.t('spree.data_request_errors.already_anonymized'))
       end
 
       def attach_export

data/app/workflows/spree/deliveries/update_tracking.rb

@@ -49,7 +49,7 @@ module Spree
         return if tracking_status.blank?
         return if Spree::Delivery::STATUSES.include?(tracking_status.to_s)
 
-        failure(delivery, Spree.t('fulfillments.errors.unknown_tracking_status', status: tracking_status))
+        failure(delivery, I18n.t('spree.fulfillments.errors.unknown_tracking_status', status: tracking_status))
       end
 
       # Overwrite rather than accumulate: this axis answers "where is it now",

data/app/workflows/spree/email_templates/discard_draft.rb

@@ -0,0 +1,20 @@
+module Spree
+  module EmailTemplates
+    # Throws away the draft of one template and language. Given the
+    # `lock_version` the draft was seen at, a draft saved or published since
+    # is reported as a conflict.
+    class DiscardDraft < Spree::Workflow
+      def perform(store:, key:, locale: Spree::EmailTemplate::ANY_LOCALE, lock_version: nil)
+        super
+        draft = store.email_template_drafts.find_by(key: key, locale: locale)
+        return failure(nil, :stale) if !lock_version.nil? && lock_version.to_i != draft&.lock_version
+        return success(nil) unless draft
+
+        draft.destroy!
+        success(nil)
+      rescue ActiveRecord::StaleObjectError
+        failure(nil, :stale)
+      end
+    end
+  end
+end

data/app/workflows/spree/email_templates/publish.rb

@@ -0,0 +1,70 @@
+module Spree
+  module EmailTemplates
+    # Makes a draft live. The draft is first rendered the way customers would
+    # receive it (see Spree::EmailTemplates::Check); a draft that does not
+    # render is refused with what is wrong and where, so an email already
+    # being sent can never break. Publishing records a revision and clears
+    # the draft. Given the `lock_version` the draft was reviewed at, a draft
+    # saved since is refused rather than published unseen.
+    class Publish < Spree::Workflow
+      def perform(store:, key:, locale: Spree::EmailTemplate::ANY_LOCALE, actor: nil, lock_version: nil)
+        super
+        step :ensure_draft
+        step :ensure_current
+        step :check
+
+        begin
+          ApplicationRecord.transaction do
+            step :publish
+            step :record_revision
+            step :clear_draft
+          end
+        rescue ActiveRecord::StaleObjectError, ActiveRecord::RecordNotUnique
+          failure(nil, :stale)
+        end
+
+        template.publish_event('email_template.published')
+        success(template)
+      end
+
+      private
+
+      def draft
+        @draft ||= store.email_template_drafts.find_by(key: key, locale: locale)
+      end
+
+      def template
+        @template ||= store.email_templates.find_or_initialize_by(key: draft.key, locale: draft.locale)
+      end
+
+      def ensure_draft
+        failure(nil, :no_draft) unless draft
+      end
+
+      def ensure_current
+        failure(nil, :stale) if !lock_version.nil? && lock_version.to_i != draft.lock_version
+      end
+
+      def check
+        problems = Spree::EmailTemplates::Check.new(store: store, draft: draft).call
+        failure(problems, :invalid_template) if problems.any?
+      end
+
+      def publish
+        template.assign_attributes(
+          subject: draft.subject, body: draft.body, base_subject: draft.base_subject, base_body: draft.base_body,
+          status: :published, published_at: Time.current, published_by: actor, reverted_at: nil, reverted_by: nil
+        )
+        template.save!
+      end
+
+      def record_revision
+        template.revisions.create!(subject: template.subject, body: template.body, published_by: actor)
+      end
+
+      def clear_draft
+        draft.destroy!
+      end
+    end
+  end
+end

data/app/workflows/spree/email_templates/restore_revision.rb

@@ -0,0 +1,33 @@
+module Spree
+  module EmailTemplates
+    # Copies a published revision into the draft, to be checked and
+    # published like any other change. A revision of the version for every
+    # language can be restored into one language's draft (`locale`).
+    class RestoreRevision < Spree::Workflow
+      # @param draft_version [Hash] `{ lock_version: }` to check the draft as saving does; empty checks nothing
+      def perform(revision:, actor: nil, locale: nil, draft_version: {})
+        super
+        template = revision.email_template
+        target_locale = locale.presence || template.locale
+
+        Spree.email_template_save_draft_workflow.call(
+          store: template.store, key: template.key, locale: target_locale, actor: actor,
+          attributes: {
+            subject: readable(revision.subject, target_locale, escape: false),
+            body: readable(revision.body, target_locale),
+            **draft_version.slice(:lock_version)
+          }
+        )
+      end
+
+      private
+
+      # A shared revision restored into one language reads in that language's words.
+      def readable(text, target_locale, escape: true)
+        return text if target_locale == Spree::EmailTemplate::ANY_LOCALE
+
+        Spree::Emails::TranslationInliner.call(text, locale: target_locale, escape: escape)
+      end
+    end
+  end
+end

data/app/workflows/spree/email_templates/revert.rb

@@ -0,0 +1,29 @@
+module Spree
+  module EmailTemplates
+    # Goes back to Spree's default for one template and language: the
+    # published version is marked reverted, so the file answers again, and
+    # any draft is discarded. The row and its revisions stay, so the history
+    # can still be restored. Given the `lock_version` the draft was seen at,
+    # a draft saved or published since is not thrown away.
+    class Revert < Spree::Workflow
+      def perform(store:, key:, locale: Spree::EmailTemplate::ANY_LOCALE, actor: nil, lock_version: nil)
+        super
+        template = store.email_templates.find_by(key: key, locale: locale)
+        draft = store.email_template_drafts.find_by(key: key, locale: locale)
+        return failure(nil, :stale) if !lock_version.nil? && lock_version.to_i != draft&.lock_version
+
+        begin
+          ApplicationRecord.transaction do
+            draft&.destroy!
+            template&.update!(status: :reverted, reverted_at: Time.current, reverted_by: actor) if template&.published?
+          end
+        rescue ActiveRecord::StaleObjectError
+          return failure(nil, :stale)
+        end
+
+        template&.publish_event('email_template.reverted') if template&.reverted?
+        success(template)
+      end
+    end
+  end
+end

data/app/workflows/spree/email_templates/save_draft.rb

@@ -0,0 +1,85 @@
+module Spree
+  module EmailTemplates
+    # Saves a draft of an editable email template, in any state: it is work
+    # in progress and customers keep receiving the published version. The
+    # first save starts from what is published, else Spree's default, and
+    # remembers that default so an upgrade changing it can be spotted.
+    #
+    # A save carrying an older `lock_version` than the draft has is refused,
+    # so two admins editing at once cannot overwrite each other. `rebase`
+    # marks the draft as based on Spree's current default, for a merchant who
+    # reviewed an upgraded default and keeps their own version.
+    class SaveDraft < Spree::Workflow
+      def perform(store:, key:, attributes:, locale: Spree::EmailTemplate::ANY_LOCALE, actor: nil)
+        super
+        step :ensure_editable
+        step :ensure_current
+        step :save
+
+        success(draft)
+      end
+
+      private
+
+      def draft
+        @draft ||= store.email_template_drafts.find_or_initialize_by(key: key, locale: locale)
+      end
+
+      def ensure_editable
+        failure(nil, :not_editable) unless Spree.editable_email_templates.include?(key)
+      end
+
+      # Without `lock_version` nothing is checked. `nil` says the caller saw no
+      # draft, so one saved since is refused rather than overwritten.
+      def ensure_current
+        return unless attributes.key?(:lock_version)
+
+        expected = attributes[:lock_version]
+        if expected.nil?
+          failure(nil, :stale) if draft.persisted?
+        elsif draft.new_record? || expected.to_i != draft.lock_version
+          # A draft that is gone was published or discarded since it was loaded.
+          failure(nil, :stale)
+        end
+      end
+
+      def save
+        start_from_current if draft.new_record?
+        rebase if ActiveModel::Type::Boolean.new.cast(attributes[:rebase])
+        draft.subject = attributes[:subject] if attributes.key?(:subject)
+        draft.body = attributes[:body] if attributes.key?(:body)
+        draft.updated_by = actor
+        failure(draft) unless draft.save
+      rescue ActiveRecord::StaleObjectError, ActiveRecord::RecordNotUnique
+        failure(nil, :stale)
+      end
+
+      # Starts from what customers in this language receive, with Spree's
+      # translation keys written out as text in it.
+      def start_from_current
+        published = store.email_templates.published.where(key: key, locale: [draft.locale, Spree::EmailTemplate::ANY_LOCALE]).
+                    min_by { |template| template.locale == draft.locale ? 0 : 1 }
+
+        draft.subject = readable(published&.subject || default&.subject, escape: false)
+        draft.body = readable(published&.body || default&.body)
+        draft.base_subject = published ? published.base_subject : default&.subject
+        draft.base_body = published ? published.base_body : default&.body
+      end
+
+      def rebase
+        draft.base_subject = default&.subject
+        draft.base_body = default&.body
+      end
+
+      def readable(text, escape: true)
+        return text if draft.locale == Spree::EmailTemplate::ANY_LOCALE
+
+        Spree::Emails::TranslationInliner.call(text, locale: draft.locale, escape: escape)
+      end
+
+      def default
+        @default ||= Spree::Emails::TemplateResolver.for_mailers.find_default(key)
+      end
+    end
+  end
+end

data/app/workflows/spree/exchanges/approve.rb

@@ -1,38 +1,21 @@
 module Spree
   module Exchanges
     class Approve < Spree::Workflow
+      include Spree::PostSale::Approval
+
       hooks :validate, :after_approve
 
       # @param exchange [Spree::Exchange]
       # @param approver [Object, nil]
       def perform(exchange:, approver: nil)
         super
-
-        step :ensure_approvable
-        run_hooks :validate
-
-        ApplicationRecord.transaction do
-          step :mark_approved
-        end
-
-        run_hooks :after_approve
-        exchange.publish_event('exchange.approved')
-        success(exchange.reload)
+        approve
       end
 
       private
 
-      def ensure_approvable
-        failure(exchange, :not_requested) unless exchange.requested?
-      end
-
-      def mark_approved
-        exchange.update!(
-          status: 'approved',
-          approved_at: Time.current,
-          created_by: exchange.created_by || approver
-        )
-      end
+      def post_sale_record = exchange
+      def approvable_status = 'requested'
     end
   end
 end

data/app/workflows/spree/exchanges/cancel.rb

@@ -4,37 +4,21 @@ module Spree
     # merchant holds the customer's items and must either fulfill the
     # replacement or refund.
     class Cancel < Spree::Workflow
+      include Spree::PostSale::Cancellation
+
       hooks :validate, :after_cancel
 
       # @param exchange [Spree::Exchange]
       # @param reason [String, nil]
       def perform(exchange:, reason: nil)
         super
-
-        step :ensure_cancellable
-        run_hooks :validate
-
-        ApplicationRecord.transaction do
-          step :mark_canceled
-        end
-
-        run_hooks :after_cancel
-        exchange.publish_event('exchange.canceled')
-        success(exchange.reload)
+        cancel
       end
 
       private
 
-      def ensure_cancellable
-        return if exchange.requested? || exchange.approved?
-
-        failure(exchange, :not_cancellable)
-      end
-
-      def mark_canceled
-        memo = [exchange.memo, reason].compact_blank.join("\n")
-        exchange.update!(status: 'canceled', canceled_at: Time.current, memo: memo.presence)
-      end
+      def post_sale_record = exchange
+      def cancellable_statuses = %w[requested approved]
     end
   end
 end

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

@@ -4,6 +4,7 @@ module Spree
     # in their place.
     class Create < Spree::Workflow
       include Spree::Returns::ReturnableQuantity
+      include Spree::Refunds::TaxCredit
 
       hooks :validate, :after_create
 
@@ -24,6 +25,7 @@ module Spree
 
         ApplicationRecord.transaction do
           step :build_exchange
+          step :calculate_tax
         end
 
         run_hooks :after_create
@@ -92,6 +94,10 @@ module Spree
         failure(@exchange) unless @exchange.save
       end
 
+      def calculate_tax
+        with_tax_provider(exchange) { exchange.calculate_tax! }
+      end
+
       def default_stock_location
         @normalized_items.first[:fulfillment_item].fulfillment&.stock_location ||
           order.store.stock_locations.first