Skip to content

armgit / spree

Public Imported from GitHub
0

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.

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.rb
index 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 Spree
delivery.shipping_label = shipping_label if shipping_label
delivery.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)
end
end
end
diff --git a/spree/core/app/services/spree/deliveries/destroy.rb b/spree/core/app/services/spree/deliveries/destroy.rb
index 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 Spree
return 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)
end
end
end
diff --git a/spree/core/app/services/spree/fulfillments/recalculate_delivery.rb b/spree/core/app/services/spree/fulfillments/recalculate_delivery.rb
new file mode 100644
index 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
+end
diff --git a/spree/core/app/workflows/spree/deliveries/update_tracking.rb b/spree/core/app/workflows/spree/deliveries/update_tracking.rb
index 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 Spree
delivery.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.owner
return 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.rb
index 8c43cade20..2809ef9dd5 100644
--- a/spree/core/lib/spree/core/dependencies.rb
+++ b/spree/core/lib/spree/core/dependencies.rb
@@ -92,6 +92,7 @@ module Spree
delivery_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.rb
new file mode 100644
index 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