spree_core 5.6.1 → 6.0.0.beta1

data/app/services/spree/imports/row_processors/purchase_order.rb

@@ -0,0 +1,157 @@
+module Spree
+  module Imports
+    module RowProcessors
+      # One line of a purchase order. The first row carrying a reference opens
+      # a draft for it through the same workflow the screen uses; every later
+      # row with that reference adds its line. Suppliers, warehouses and SKUs
+      # are named, not created: a typo must fail the row, not spawn a record.
+      class PurchaseOrder < Base
+        QUANTITY_FORMAT = /\A\d+\z/
+        AMOUNT_FORMAT = /\A\d+(\.\d+)?\z/
+
+        def initialize(row, **)
+          super
+          @store = import.store
+        end
+
+        attr_reader :store
+
+        def process!
+          reference = attributes['reference'].to_s.strip
+          raise ArgumentError, Spree.t(:purchase_order_import_reference_required) if reference.blank?
+
+          line = {
+            variant: find_variant,
+            quantity_ordered: quantity_for(attributes['quantity']),
+            unit_cost: amount_for(attributes['unit_cost'])
+          }
+
+          cache = import.row_lookup_cache
+          key = [:purchase_order_import_order, reference]
+          if cache.key?(key)
+            add_line(cache[key], line)
+          else
+            cache[key] = open_draft(reference, line)
+          end
+        end
+
+        private
+
+        def open_draft(reference, line)
+          result = Spree::PurchaseOrders::Create.call(
+            store: store,
+            supplier: find_supplier,
+            destination_location: find_destination,
+            items: [line],
+            currency: currency_for(attributes['currency']),
+            expected_at: date_for(attributes['expected_at'], 'expected_at'),
+            cancel_by: date_for(attributes['cancel_by'], 'cancel_by'),
+            reference: reference,
+            notes: attributes['notes'].to_s.strip.presence,
+            created_by: import.user
+          )
+          raise ArgumentError, failure_message(result) unless result.success?
+
+          result.value
+        end
+
+        # The update replaces the lines wholesale, so the ones already on the
+        # draft go back with the new one. A SKU repeated under one reference
+        # is one line with the quantities added, the way a picker would total
+        # two cartons of the same thing.
+        def add_line(purchase_order, line)
+          lines = purchase_order.items.map do |item|
+            { variant: item.variant, quantity_ordered: item.quantity_ordered, unit_cost: item.unit_cost }
+          end
+          existing = lines.find { |entry| entry[:variant].id == line[:variant].id }
+          if existing
+            existing[:quantity_ordered] += line[:quantity_ordered]
+          else
+            lines << line
+          end
+
+          result = Spree::PurchaseOrders::Update.call(purchase_order: purchase_order, items: lines)
+          raise ArgumentError, failure_message(result) unless result.success?
+
+          result.value
+        end
+
+        def find_supplier
+          name = attributes['supplier'].to_s.strip
+          raise ArgumentError, Spree.t(:purchase_order_import_supplier_required) if name.blank?
+
+          cached_lookup(:purchase_order_import_supplier, name.downcase) do
+            store.suppliers.find_by(Spree::Supplier.arel_table[:name].lower.eq(name.downcase))
+          end || raise(ArgumentError, Spree.t(:purchase_order_import_unknown_supplier, name: name))
+        end
+
+        def find_destination
+          name = attributes['destination'].to_s.strip
+          raise ArgumentError, Spree.t(:purchase_order_import_destination_required) if name.blank?
+
+          cached_lookup(:purchase_order_import_destination, name.downcase) do
+            store.stock_locations.find_by(Spree::StockLocation.arel_table[:name].lower.eq(name.downcase))
+          end || raise(ArgumentError, Spree.t(:purchase_order_import_unknown_destination, name: name))
+        end
+
+        def find_variant
+          sku = attributes['sku'].to_s.strip
+          raise ArgumentError, Spree.t(:purchase_order_import_sku_required) if sku.blank?
+
+          variants = cached_lookup(:purchase_order_import_variant, sku.downcase) do
+            store.variants.where(Spree::Variant.arel_table[:sku].lower.eq(sku.downcase)).limit(2).to_a
+          end
+          raise ArgumentError, Spree.t(:purchase_order_import_unknown_sku, sku: sku) if variants.empty?
+          raise ArgumentError, Spree.t(:purchase_order_import_ambiguous_sku, sku: sku) if variants.many?
+
+          variants.first
+        end
+
+        def quantity_for(value)
+          text = value.to_s.strip
+          unless text.match?(QUANTITY_FORMAT) && text.to_i.positive?
+            raise ArgumentError, Spree.t(:purchase_order_import_invalid_quantity, value: text)
+          end
+
+          text.to_i
+        end
+
+        def amount_for(value)
+          text = value.to_s.strip
+          raise ArgumentError, Spree.t(:purchase_order_import_invalid_cost, value: text) unless text.match?(AMOUNT_FORMAT)
+
+          BigDecimal(text)
+        end
+
+        def currency_for(value)
+          currency = value.to_s.strip.upcase.presence || store.default_currency
+          return currency if supported_currencies.include?(currency)
+
+          raise ArgumentError, Spree.t(:purchase_order_import_unsupported_currency, currency: currency)
+        end
+
+        def supported_currencies
+          cached_lookup(:purchase_order_import_currencies) { store.supported_currencies_list.map(&:iso_code) }
+        end
+
+        # A complete date only: `Date.parse` would take "March" and guess the
+        # rest, and a guessed delivery date is worse than none.
+        def date_for(value, column)
+          text = value.to_s.strip
+          return nil if text.blank?
+
+          Date.iso8601(text)
+        rescue Date::Error
+          raise ArgumentError, Spree.t(:purchase_order_import_invalid_date, column: column, value: text)
+        end
+
+        def failure_message(result)
+          error = result.error
+          return error.full_messages.to_sentence if error.respond_to?(:full_messages)
+
+          error.to_s.presence || Spree.t(:purchase_order_import_failed)
+        end
+      end
+    end
+  end
+end

data/app/services/spree/media/destroy.rb

@@ -0,0 +1,88 @@
+module Spree
+  class Media
+    # Deletes a library file everywhere at once: every placement sharing its
+    # blob, every plain attachment (a category image slot, a store logo)
+    # holding it, then the row itself — whose purge takes the blob with it once
+    # nothing references it. The alternative was refusing until the merchant
+    # cleared each use by hand, which is busywork the usage list already knows
+    # how to do.
+    #
+    # Scoped to the file's own store: a blob another tenant happens to share
+    # keeps their attachments, and the foreign key keeps the file in storage
+    # for them. Rich text embeds are plain URLs with nothing to detach — those
+    # descriptions lose the image, which is what the caller's confirmation
+    # acknowledged.
+    class Destroy
+      prepend Spree::ServiceModule::Base
+
+      # @param media [Spree::Media] the library row being deleted
+      # @return [Spree::ServiceModule::Result]
+      def call(media:)
+        # Only the file this row *is*, never its poster: a poster is a still
+        # another row may legitimately use as its own picture, and deleting a
+        # video must not take that image with it. The row's own poster goes
+        # when the row does.
+        blob_ids = [media.attachment_blob&.id].compact
+
+        # Detaching is collected inside the transaction and enqueued after it
+        # commits: purge_later hands the file to a worker that may run before
+        # the transaction ends, so a rollback would leave the rows intact with
+        # their file already gone.
+        detachable = nil
+
+        ApplicationRecord.transaction do
+          destroy_placements(media, blob_ids)
+          detachable = plain_attachments(media, blob_ids)
+          media.destroy!
+        end
+
+        # ActiveRecord::Rollback is swallowed by the transaction block, so a
+        # surviving row is how a rolled-back delete reports itself. Detaching
+        # then would strip the file from records the delete did not remove.
+        return failure(media) if media.persisted?
+
+        detachable.each(&:purge_later)
+
+        success(media)
+      end
+
+      private
+
+      # Other rows sharing the file — placements on products, categories,
+      # collections. destroy, not delete: the callbacks are what refresh the
+      # owners' thumbnails and counters.
+      def destroy_placements(media, blob_ids)
+        return if blob_ids.empty?
+
+        Spree::Media
+          .where(store_id: media.store_id)
+          .where.not(id: media.id)
+          .joins(:attachment_attachment)
+          .where(ActiveStorage::Attachment.table_name => { blob_id: blob_ids })
+          .find_each(&:destroy!)
+      end
+
+      # The plain attachments this store holds on the file — a category image
+      # slot, a store logo. Media rows are handled by destroy_placements.
+      #
+      # @return [Array<ActiveStorage::Attachment>]
+      def plain_attachments(media, blob_ids)
+        ActiveStorage::Attachment.where(blob_id: blob_ids).select do |attachment|
+          owner = attachment.record
+          next false if owner.blank? || owner.is_a?(Spree::Media)
+
+          owned_by_store?(owner, media.store_id)
+        end
+      end
+
+      # Ownership must be proven, never assumed. A Spree::Store has no
+      # store_id of its own, so treating a blank one as "mine" made every
+      # other store's logo look local — and deleting a file would strip it.
+      def owned_by_store?(owner, store_id)
+        return owner.id == store_id if owner.is_a?(Spree::Store)
+
+        owner.try(:store_id) == store_id
+      end
+    end
+  end
+end

data/app/services/spree/media/usage.rb

@@ -0,0 +1,175 @@
+module Spree
+  class Media
+    # Answers "what breaks if I delete this file" for the media library.
+    #
+    # Reuse in Spree shares the underlying blob rather than copying the file, so
+    # the question is about the blob, not about this row: the same file may be
+    # placed on several products and picked for a category or store image, and
+    # deleting one placement leaves the others working. This walks the blob's
+    # attachments to list every one of them.
+    #
+    # Rich text embeds are found separately and only approximately — an embedded
+    # image is a plain URL in stored markup, with no row tying it to the file —
+    # so a description referencing this blob's key is reported as a use, and
+    # markup that reaches the file some other way (a CDN alias, a copied URL from
+    # another environment) is not found at all. Treat the rich text half as a
+    # warning worth showing, never as proof a file is unused.
+    class Usage
+      prepend Spree::ServiceModule::Base
+
+      # @param media [Spree::Media] the library row being inspected
+      # @return [Array<Spree::MediaUsageReference>] every known use of its file
+      def call(media:)
+        blob_ids = [media.attachment_blob&.id, media.poster_blob&.id].compact
+        return success([]) if blob_ids.empty?
+
+        success(attachment_references(media, blob_ids) + rich_text_references(media, blob_ids))
+      end
+
+      private
+
+      # Every record whose attachment points at one of these blobs, minus
+      # anything belonging to another store — none of this store's business even
+      # when the two happen to share a file.
+      #
+      # The inspected row's own placement counts: the library shows a file, not a
+      # placement, so "where is this used" plainly includes the product it sits
+      # on. Leaving it out reported "not used anywhere else" about a file that is
+      # on a product, which is worst in the case the panel exists for — deciding
+      # whether deleting it is safe.
+      # One place can be reachable more than once — a video's file and poster
+      # are two blobs on one row, and a category holds a file both as its image
+      # slot and as the slot's library placement — hence the collapse to one
+      # reference per owner, preferring the placement, which is the library's
+      # own representation of the use and what the dashboard links.
+      def attachment_references(media, blob_ids)
+        # `record` is polymorphic, so preload it per type — reading it row by row
+        # is a query each, and a widely-reused file has many rows. Media owners
+        # additionally need their viewable, which build_reference reads.
+        attachments = ActiveStorage::Attachment.where(blob_id: blob_ids).to_a
+        owners = preloaded_owners(attachments)
+
+        references = attachments.filter_map do |attachment|
+          owner = owners[[attachment.record_type, attachment.record_id]]
+          next if owner.blank?
+          next unless owned_by_store?(owner, media.store_id)
+
+          build_reference(owner, attachment.name)
+        end
+
+        references
+          .group_by { |reference| [reference.owner_type, reference.owner_id] }
+          .map { |_owner, group| group.find { |reference| reference.kind == 'media' } || group.first }
+      end
+
+      # @return [Hash{Array(String, Integer) => ActiveRecord::Base}] owners by [type, id]
+      def preloaded_owners(attachments)
+        attachments.group_by(&:record_type).each_with_object({}) do |(type, rows), owners|
+          model = type.safe_constantize
+          next if model.blank?
+
+          scope = model.all
+          # A media owner's own viewable is what build_reference reports.
+          scope = scope.includes(:viewable) if model <= Spree::Media
+
+          scope.where(id: rows.map(&:record_id)).each do |record|
+            owners[[type, record.id]] = record
+          end
+        end
+      end
+
+      # Ownership must be proven, never assumed. A Spree::Store carries no
+      # store_id of its own, so a blank one is not evidence the record is
+      # local — treating it as such reported another tenant's logo as a use.
+      def owned_by_store?(owner, store_id)
+        return owner.id == store_id if owner.is_a?(Spree::Store)
+
+        owner.try(:store_id) == store_id
+      end
+
+      def build_reference(owner, field)
+        if owner.is_a?(Spree::Media)
+          placement = owner.viewable
+          return if placement.blank?
+
+          Spree::MediaUsageReference.new(
+            kind: 'media',
+            name: display_name(placement),
+            owner_type: placement.class.name,
+            owner_id: placement.try(:prefixed_id),
+            field: field
+          )
+        else
+          Spree::MediaUsageReference.new(
+            kind: 'attachment',
+            name: display_name(owner),
+            owner_type: owner.class.name,
+            owner_id: owner.try(:prefixed_id),
+            field: field
+          )
+        end
+      end
+
+      # Blob keys are opaque and unique, so a description containing one is
+      # almost certainly embedding that file. Searched with LIKE, which no index
+      # can serve — a deliberate cost paid on one admin screen, never in a
+      # listing, and only over the store's own rows.
+      #
+      # Every model declaring rich text is searched. Which editors can embed a
+      # file is the dashboard's decision — only the product, category and
+      # collection descriptions use the picker-backed editor — so a second
+      # list here would only restate that, and go stale when it changes.
+      def rich_text_references(media, blob_ids)
+        keys = ActiveStorage::Blob.where(id: blob_ids).pluck(:key)
+        return [] if keys.empty?
+
+        Spree::SanitizableRichText.declaring_models.flat_map do |model, attributes|
+          attributes.flat_map { |attribute| rich_text_matches(media, model, attribute, keys) }
+        end
+      end
+
+      def rich_text_matches(media, model, attribute, keys)
+        return [] unless model.column_names.include?(attribute)
+
+        column = model.arel_table[attribute]
+        condition = keys.map { |key| column.matches("%#{key}%") }.reduce(:or)
+
+        scope_to_store(media, model).where(condition).limit(MATCH_LIMIT).map do |record|
+          Spree::MediaUsageReference.new(
+            kind: 'rich_text',
+            name: display_name(record),
+            owner_type: record.class.name,
+            owner_id: record.try(:prefixed_id),
+            field: attribute
+          )
+        end
+      rescue ActiveRecord::StatementInvalid
+        # A declared rich text attribute that isn't a plain searchable column
+        # (a Mobility-backed field on some adapters) should not take the whole
+        # usage panel down with it.
+        []
+      end
+
+      # A file belongs to one store, so its uses are that store's rows. Without
+      # this the panel would report — and name — records from every other tenant.
+      def scope_to_store(media, model)
+        return model.all unless model.column_names.include?('store_id')
+
+        model.where(store_id: media.store_id)
+      end
+
+      # Enough to tell a merchant "this is in use, here's where"; listing every
+      # match on a catalog-wide embed would be a scan with no added meaning.
+      MATCH_LIMIT = 25
+
+      def display_name(record)
+        %i[name title number email].each do |attribute|
+          value = record.try(attribute)
+          return value if value.present?
+        end
+
+        "#{record.class.name.demodulize} ##{record.id}"
+      end
+    end
+  end
+end

data/app/services/spree/newsletter/link_user.rb

@@ -15,7 +15,7 @@ module Spree
 
       def call
         return if subscriber.blank? || user.blank?
-        return if subscriber.user_id == user.id && !needs_marketing_propagation?
+        return if subscriber.customer_id == user.id && !needs_marketing_propagation?
 
         link_subscriber_to_user
         propagate_marketing_consent if needs_marketing_propagation?
@@ -28,9 +28,9 @@ module Spree
       attr_reader :subscriber, :user
 
       def link_subscriber_to_user
-        return if subscriber.user_id == user.id
+        return if subscriber.customer_id == user.id
 
-        return if subscriber.update(user: user)
+        return if subscriber.update(customer: user)
 
         Rails.logger.warn(
           "NewsletterSubscriber #{subscriber.id} link to user #{user.id} failed: #{subscriber.errors.full_messages.to_sentence}"
@@ -42,6 +42,7 @@ module Spree
       end
 
       def propagate_marketing_consent
+        user.consent_source = Spree::ConsentRecord::NEWSLETTER
         return if user.update(accepts_email_marketing: true)
 
         Rails.logger.warn(

data/app/services/spree/newsletter/subscribe.rb

@@ -41,7 +41,7 @@ module Spree
           verification_token: subscriber.verification_token,
           unsubscribe_token: subscriber.generate_token_for(:unsubscribe),
           store_id: current_store.prefixed_id,
-          customer_id: subscriber.user&.prefixed_id
+          customer_id: subscriber.customer&.prefixed_id
         }
         payload[:redirect_url] = redirect_url if redirect_url.present?
         payload
@@ -49,7 +49,7 @@ module Spree
 
       def upsert_subscriber
         @upsert_subscriber ||= Spree::NewsletterSubscriber.find_or_create_by(email: email, store: current_store) do |new_record|
-          new_record.user = known_user
+          new_record.customer = known_user
         end
       end
       alias_method :subscriber, :upsert_subscriber
@@ -59,7 +59,7 @@ module Spree
       end
 
       def known_user
-        @known_user ||= current_user || Spree.user_class.find_by(email: email)
+        @known_user ||= current_user || Spree.customer_class.find_by(email: email)
       end
     end
   end

data/app/services/spree/newsletter/verify.rb

@@ -22,9 +22,13 @@ module Spree
       end
 
       def set_user_email_marketing_to_true
-        return if subscriber.user.blank?
+        return if subscriber.customer.blank?
 
-        subscriber.user.update!(accepts_email_marketing: true)
+        customer = subscriber.customer
+        # Confirming a newsletter sign-up, not editing a profile — left unset
+        # the stamp would say the person changed this from their account page.
+        customer.consent_source = Spree::ConsentRecord::NEWSLETTER
+        customer.update!(accepts_email_marketing: true)
       end
 
       def publish_event

data/app/services/spree/order_groups/allocate_payments.rb

@@ -0,0 +1,101 @@
+module Spree
+  module OrderGroups
+    # Re-points a split checkout's payments onto the group and records each
+    # child order's share of them.
+    #
+    # The customer authorised one amount for one basket, so the charge stays
+    # singular and the per-seller figures are bookkeeping. Every payment on the
+    # group gets its own set of shares — the card, the store credit, the gift
+    # card — apportioned by what each child is worth, with largest-remainder so
+    # a child's shares across all payments add back up to that child's total. A
+    # mixed store-credit checkout therefore never overstates what the gateway is
+    # exposed to on any one seller's order.
+    #
+    # Idempotent: the shares are found-or-created on the unique
+    # (payment, order) index, so a replayed completion writes nothing new.
+    class AllocatePayments
+      prepend Spree::ServiceModule::Base
+
+      # @param group [Spree::OrderGroup]
+      # @return [Spree::ServiceModule::Result] value is the group
+      def call(group:)
+        orders = group.orders.order(:id).to_a
+        return success(group) if orders.empty?
+
+        ApplicationRecord.transaction do
+          claim_payments(group)
+          # What each child still needs covering. Payments draw this down as
+          # they are allocated, so several payments cannot each round in the
+          # same direction and leave one child a penny over and another under —
+          # every child ends up with exactly its own total.
+          outstanding = orders.map { |order| Spree::Money::Rounding.to_minor_units(order.total, group.currency) }
+
+          group.payments.reload.each do |payment|
+            taken = allocate(payment, orders, outstanding)
+            outstanding = outstanding.each_with_index.map { |amount, index| amount - taken[index] }
+          end
+        end
+
+        success(group)
+      end
+
+      private
+
+      # The payments were made against the cart and re-pointed onto the child
+      # orders as they were built; a split checkout moves them up to the group,
+      # where the single charge actually belongs.
+      #
+      # Payment sessions deliberately stay where they are. A session is the
+      # external gateway's own record of one authorisation attempt, keyed to
+      # the reference the provider holds — moving it would fork a reference
+      # that has to keep resolving, and nothing about the split changes what
+      # the gateway authorised.
+      def claim_payments(group)
+        order_ids = group.orders.select(:id)
+        Spree::Payment.where(order_id: order_ids).update_all(order_id: nil, order_group_id: group.id)
+        group.payments.reset
+      end
+
+      # A share records what this order can draw on, and what it already has.
+      #
+      # The captured figure matters as much as the authorised one: a checkout
+      # paid by a method that charges up front arrives here with the payment
+      # already completed, and a share showing nothing captured would report
+      # every child of a fully paid checkout as merely authorised. So a
+      # completed payment's shares are born captured, and one still pending is
+      # captured later, as each seller dispatches.
+      #
+      # @param outstanding [Array<Integer>] what each child still needs, in
+      #   minor units, so this payment covers what is left rather than
+      #   re-dividing the whole basket
+      # @return [Array<Integer>] what each child took from this payment
+      def allocate(payment, orders, outstanding)
+        # A basket worth nothing — fully discounted, wholly gift-carded — has
+        # nothing to divide by. Every child still gets a share saying so,
+        # rather than none at all, so each reads as settled instead of waiting
+        # on money that was never owed.
+        weights = outstanding.sum.positive? ? outstanding : Array.new(orders.size, 1)
+
+        currency = payment.currency
+        shares = Spree::Adjusters::LargestRemainder.largest_remainder_shares(
+          Spree::Money::Rounding.to_minor_units(payment.amount, currency), weights
+        )
+        captured = payment.completed?
+
+        orders.each_with_index do |order, index|
+          split = Spree::PaymentSplit.find_or_initialize_by(payment_id: payment.id, order_id: order.id)
+          next if split.persisted?
+
+          share = Spree::Money::Rounding.from_minor_units(shares[index], currency)
+          split.currency = payment.currency
+          split.authorized_amount = share
+          split.captured_amount = captured ? share : 0
+          split.save!
+        end
+
+        shares
+      end
+
+    end
+  end
+end

data/app/services/spree/orders/approve.rb

@@ -3,38 +3,24 @@ module Spree
     class Approve
       prepend Spree::ServiceModule::Base
 
-      # Approves an order and records a Spree::OrderApproval history record.
-      #
-      # The legacy keyword `approver:` remains valid; new keywords (`level:`, `note:`)
-      # are additive and stored on the approval record.
+      # Approves an order: clears the risk flag and records who approved it and when.
       #
       # @param order [Spree::Order]
       # @param approver [Object, nil] the user/admin who approved
-      # @param level [String, nil] approval level (used by 6.0 multi-level B2B flow)
-      # @param note [String, nil] staff-facing note
+      # @param level [String, nil] deprecated and ignored — removed in Spree 6.1
+      # @param note [String, nil] deprecated and ignored — removed in Spree 6.1
       # @return [Spree::ServiceModule::Result]
       def call(order:, approver: nil, level: nil, note: nil)
-        decided_at = Time.current
-
-        order.transaction do
-          order.approvals.create!(
-            status: 'approved',
-            level: level,
-            note: note,
-            approver: approver,
-            decided_at: decided_at,
-            created_at: decided_at
-          )
-
-          changes = { considered_risky: false, approved_at: decided_at }
-          changes[:approver_id] = approver.id if approver.present?
-          order.update_columns(changes)
+        if level.present? || note.present?
+          Spree::Deprecation.warn('Spree::Orders::Approve no longer accepts level or note — they were never read and will be removed in Spree 6.1.')
         end
 
+        changes = { considered_risky: false, approved_at: Time.current }
+        changes[:approver_id] = approver.id if approver.present?
+        order.update_columns(changes)
+
         order.publish_event('order.approved')
         success(order.reload)
-      rescue ActiveRecord::RecordInvalid, StateMachines::InvalidTransition
-        failure(order)
       end
     end
   end

data/app/services/spree/orders/build_fulfillments.rb

@@ -0,0 +1,29 @@
+module Spree
+  module Orders
+    # Shared fulfillment-building step for admin order Create / Update.
+    #
+    # Rebuilds fulfillments from scratch (Stock::Coordinator), then layers in
+    # tax, costs, and free-shipping promotions so totals reflect delivery
+    # before payment is requested. Without this, draft orders would expose
+    # delivery_total: 0.0 until completion is attempted — which is too late.
+    #
+    # No-op when the order has no shipping address, no line items, or does
+    # not require delivery (digital orders, etc.).
+    class BuildFulfillments
+      prepend Spree::ServiceModule::Base
+
+      def call(order:)
+        return success(order) unless order.ship_address_id.present?
+        return success(order) unless order.line_items.any?
+        return success(order) unless order.delivery_step_required?
+
+        order.rebuild_fulfillments!
+        order.create_shipment_tax_charge!
+        order.set_fulfillments_cost
+        order.apply_free_shipping_promotions
+
+        success(order)
+      end
+    end
+  end
+end