Open Source Platform for DTC, B2B Commerce, Marketplaces & Omnichannel. REST APIs, TypeScript SDKs, and production-ready Next.js storefront. Self-host it. Own your data. No vendor lock-in. Zero platform fees.
Ruby b2b-commercee-commerceecommerceecommerce-apiecommerce-frameworkecommerce-platformheadlessheadless-commerceheadless-ecommercemarketplacemulti-tenantmulti-vendormulti-vendor-ecommerceopen-sourcespree-commerce
Recompute delivered whenever a fulfillment's parcels change
Damian Legawiec04589404cc95
diff --git a/spree/core/app/services/spree/deliveries/create.rb b/spree/core/app/services/spree/deliveries/create.rbindex fc46e526cf..b8afafd43f 100644--- a/spree/core/app/services/spree/deliveries/create.rb+++ b/spree/core/app/services/spree/deliveries/create.rb@@ -36,7 +36,20 @@ module Spreedelivery.shipping_label = shipping_label if shipping_labeldelivery.tracking_url ||= delivery.tracking_number if delivery.pasted_link?- delivery.save ? success(delivery) : failure(delivery)+ return failure(delivery) unless delivery.save++ # A parcel that has not arrived makes a delivered fulfillment untrue.+ recalculate(owner)++ success(delivery)+ end++ private++ def recalculate(owner)+ return unless owner.is_a?(Spree::Fulfillment)++ Spree.fulfillment_recalculate_delivery_service.call(fulfillment: owner)endendenddiff --git a/spree/core/app/services/spree/deliveries/destroy.rb b/spree/core/app/services/spree/deliveries/destroy.rbindex 90eb124c52..6d68813343 100644--- a/spree/core/app/services/spree/deliveries/destroy.rb+++ b/spree/core/app/services/spree/deliveries/destroy.rb@@ -24,7 +24,15 @@ module Spreereturn failure(delivery)end- delivery.destroy ? success(delivery) : failure(delivery)+ owner = delivery.owner+ return failure(delivery) unless delivery.destroy++ # Removing the last parcel still travelling completes the fulfillment.+ if owner.is_a?(Spree::Fulfillment)+ Spree.fulfillment_recalculate_delivery_service.call(fulfillment: owner)+ end++ success(delivery)endendenddiff --git a/spree/core/app/services/spree/fulfillments/recalculate_delivery.rb b/spree/core/app/services/spree/fulfillments/recalculate_delivery.rbnew file mode 100644index 0000000000..92cce39899--- /dev/null+++ b/spree/core/app/services/spree/fulfillments/recalculate_delivery.rb@@ -0,0 +1,62 @@+module Spree+ module Fulfillments+ # Keeps a fulfillment's `delivered` honest about its consignments.+ #+ # A fulfillment travels as one parcel most of the time, but not always: a+ # single gym rack is one line item in three boxes, each with its own+ # tracking number and its own carrier journey. So `delivered` is not a+ # flag anyone sets — it is the answer to "has every parcel arrived?",+ # recomputed whenever that answer could have changed: a carrier reports an+ # arrival, a merchant adds a fourth box, or removes one.+ #+ # It moves in both directions. Adding a parcel to a fulfillment already+ # marked delivered steps it back to `fulfilled`, because the goods are out+ # and not all of them have landed — saying otherwise would misdate the+ # returns window, which counts from arrival.+ #+ # A fulfillment with no consignments at all is left alone. Pickup, hand+ # delivery and freight with no carrier feed are delivered by staff saying+ # so, and there is nothing here to compute from.+ class RecalculateDelivery+ prepend Spree::ServiceModule::Base++ # @param fulfillment [Spree::Fulfillment]+ # @param notify_customer [Boolean] whether completing the delivery+ # emails the customer+ # @return [Spree::ServiceModule::Result] the fulfillment+ def call(fulfillment:, notify_customer: true)+ # The caller has usually just written a delivery through another+ # object, so the loaded collection may still hold the old picture.+ fulfillment.deliveries.reset+ deliveries = fulfillment.deliveries++ return success(fulfillment) if deliveries.empty?++ if deliveries.undelivered.exists?+ return success(fulfillment) unless fulfillment.delivered?++ return reopen(fulfillment)+ end++ return success(fulfillment) unless fulfillment.can_mark_delivered?++ result = Spree.fulfillment_mark_delivered_workflow.call(+ fulfillment: fulfillment,+ delivered_at: deliveries.maximum(:delivered_at),+ notify_customer: notify_customer+ )+ result.success? ? success(fulfillment.reload) : failure(fulfillment, result.error.to_s)+ end++ private++ # Back to handed-over. `delivered_at` is cleared with it: it stamps when+ # the whole fulfillment arrived, and that is no longer true.+ def reopen(fulfillment)+ fulfillment.update!(status: 'fulfilled', delivered_at: nil)+ fulfillment.order&.update_statuses!+ success(fulfillment)+ end+ end+ end+enddiff --git a/spree/core/app/workflows/spree/deliveries/update_tracking.rb b/spree/core/app/workflows/spree/deliveries/update_tracking.rbindex e6b7eae79a..8d8133c73e 100644--- a/spree/core/app/workflows/spree/deliveries/update_tracking.rb+++ b/spree/core/app/workflows/spree/deliveries/update_tracking.rb@@ -73,26 +73,16 @@ module Spreedelivery.update_columns(attributes.merge(updated_at: Time.current))end- # Delivery is the one carrier report that is also a merchant fact, so it+ # Arrival is the one carrier report that is also a merchant fact, so it# crosses over to the fulfillment's status — once every consignment has- # arrived, and only from `fulfilled`, which MarkDelivered enforces. A- # carrier reporting delivery on a canceled parcel is noise on this axis.+ # arrived. A Return owner never transitions: goods coming back is not+ # goods inspected.def roll_up_owner_delivery- return unless reported_delivered?-owner = delivery.ownerreturn unless owner.is_a?(Spree::Fulfillment)- return unless owner.can_mark_delivered?-- # update_columns above left any loaded association holding the old- # status, and this decides whether the parcel is done.- owner.deliveries.reset- return if owner.deliveries.undelivered.exists?- result = Spree.fulfillment_mark_delivered_workflow.call(- fulfillment: owner,- delivered_at: owner.deliveries.maximum(:delivered_at),- notify_customer: notify_customer+ result = Spree.fulfillment_recalculate_delivery_service.call(+ fulfillment: owner, notify_customer: notify_customer)failure(delivery, result.error.to_s) if result.failure?diff --git a/spree/core/lib/spree/core/dependencies.rb b/spree/core/lib/spree/core/dependencies.rbindex 8c43cade20..2809ef9dd5 100644--- a/spree/core/lib/spree/core/dependencies.rb+++ b/spree/core/lib/spree/core/dependencies.rb@@ -92,6 +92,7 @@ module Spreedelivery_create_service: 'Spree::Deliveries::Create',delivery_upsert_primary_service: 'Spree::Deliveries::UpsertPrimary',fulfillment_stand_down_service: 'Spree::Fulfillments::StandDownProvider',+ fulfillment_recalculate_delivery_service: 'Spree::Fulfillments::RecalculateDelivery',delivery_destroy_service: 'Spree::Deliveries::Destroy',return_purchase_label_workflow: 'Spree::Returns::PurchaseLabel',diff --git a/spree/core/spec/services/spree/fulfillments/recalculate_delivery_spec.rb b/spree/core/spec/services/spree/fulfillments/recalculate_delivery_spec.rbnew file mode 100644index 0000000000..a68c221404--- /dev/null+++ b/spree/core/spec/services/spree/fulfillments/recalculate_delivery_spec.rb@@ -0,0 +1,79 @@+require 'spec_helper'++RSpec.describe Spree::Fulfillments::RecalculateDelivery do+ subject(:service) { described_class.new }++ let(:store) { @default_store }+ let(:fulfillment) { create(:order_ready_to_ship, store: store).fulfillments.first }++ def deliver(delivery)+ Spree.delivery_update_tracking_workflow.call(delivery: delivery, tracking_status: 'delivered')+ end++ before { Spree.fulfillment_fulfill_workflow.call(fulfillment: fulfillment) }++ # One line item can travel as several parcels — a gym rack in three boxes —+ # so arrival is the answer to "have they all landed", not a flag.+ it 'waits for every parcel before the fulfillment is delivered' do+ second = Spree.delivery_create_service.call(owner: fulfillment, tracking_number: 'BOX-2').value++ deliver(fulfillment.deliveries.first)+ expect(fulfillment.reload).to be_fulfilled++ deliver(second)+ expect(fulfillment.reload).to be_delivered+ end++ it 'stamps the fulfillment with the last parcel to arrive' do+ second = Spree.delivery_create_service.call(owner: fulfillment, tracking_number: 'BOX-2').value+ fulfillment.deliveries.first.update_columns(status: 'delivered', delivered_at: 3.days.ago)+ second.update_columns(status: 'delivered', delivered_at: 1.hour.ago)++ service.call(fulfillment: fulfillment)++ expect(fulfillment.reload.delivered_at).to be_within(1.second).of(1.hour.ago)+ end++ # The bug this service exists for: a parcel added after the fulfillment was+ # marked delivered used to leave it claiming an arrival that had not happened.+ it 'steps back when a parcel joins a delivered fulfillment' do+ deliver(fulfillment.deliveries.first)+ expect(fulfillment.reload).to be_delivered++ Spree.delivery_create_service.call(owner: fulfillment, tracking_number: 'LATE-BOX')++ expect(fulfillment.reload).to be_fulfilled+ # The stamp goes with it: the returns window counts from arrival, and the+ # fulfillment has not arrived.+ expect(fulfillment.delivered_at).to be_nil+ end++ it 'completes when the last parcel still travelling is removed' do+ late = Spree.delivery_create_service.call(owner: fulfillment, tracking_number: 'LATE-BOX').value+ deliver(fulfillment.deliveries.first)+ expect(fulfillment.reload).to be_fulfilled++ Spree.delivery_destroy_service.call(delivery: late)++ expect(fulfillment.reload).to be_delivered+ end++ # Pickup, hand delivery and freight with no carrier feed are delivered by+ # staff saying so; there is nothing here to compute from.+ it 'leaves a fulfillment with no parcels alone' do+ fulfillment.deliveries.destroy_all+ Spree.fulfillment_mark_delivered_workflow.call(fulfillment: fulfillment)++ expect(service.call(fulfillment: fulfillment.reload)).to be_success+ expect(fulfillment.reload).to be_delivered+ end++ it 'does nothing to a parcel that never shipped' do+ unfulfilled = create(:order_ready_to_ship, store: store).fulfillments.first+ unfulfilled.deliveries.first.update_columns(status: 'delivered', delivered_at: Time.current)++ service.call(fulfillment: unfulfilled)++ expect(unfulfilled.reload).to be_unfulfilled+ end+end