dscf-marketplace 0.15.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96c72fe29f50fca0d789f14bdf6fe195678ec9dc1f65d7284de72a6aa24dff20
-  data.tar.gz: fa9fb4e1e7dab26a304efb5a528db3a0bcdab579d36c51a2505588b31fe40a9e
+  metadata.gz: 3cc1c9aaf986ce406e613ac0b3dc31e9a230a8a4e996ef61df353ef51003cdd6
+  data.tar.gz: ca71e2b9a1310eb873818fdeede519b86af08ca7db17764d0a123ab287c23376
 SHA512:
-  metadata.gz: 1adf7c893ca340a6f77021fdc354c35cefbdb8aee7bacb0e412a7a42082b4ea33c37fc8c4a8b26c7048057929b249b241d733182fc9be669a53b44ef83df0e4d
-  data.tar.gz: 07a3f375e446fbc537ec377c61de0800d18c8e42a94cc57369274d3b3dbacd96e66a071cb84f747ca14fb4c89fb37198f22faa2e61357faabb0889106139645d
+  metadata.gz: 59c39334fa8624f99730ef5bf36c9bb18f17e3ecb2c653af7be70cea8068c45fe0dad28b3a7cd632398ef14eed830f1f57111d36bae5ce9d1c63bc6961685ad2
+  data.tar.gz: 688c0ab34c504eaf3e393ef5e82a4ec0c2047d8ed0114126776fd6af88a27156fadf87b532bbb91458b6a63d8d43d2ec568477f15f2c8eb6cae9fb4bf58e2437

data/app/controllers/dscf/marketplace/orders_controller.rb

@@ -22,6 +22,61 @@ module Dscf
         render_error(error: e.message)
       end
 
+      # One-tap reorder: rebuild a past order's basket and place it again.
+      #
+      # An order line records the PRODUCT, not the aggregator listing it came
+      # from (a supplier-sourced feed line stores the fulfilling business as its
+      # source), so lines are re-resolved against what the same seller offers
+      # today rather than replayed. That also means the new order is priced at
+      # today's price — a stale price can't be honoured.
+      #
+      # Lines that can no longer be sourced are skipped and lines short on stock
+      # are clamped, both reported in meta, so one sold-out item doesn't block
+      # the whole reorder.
+      def reorder
+        source_order = find_record
+        authorize source_order, :reorder?
+
+        unless source_order.direct_listing?
+          return render_error(errors: "Only direct listing orders can be reordered", status: :unprocessable_entity)
+        end
+
+        resolved_items, skipped, adjusted = resolve_reorder_items(source_order)
+
+        if resolved_items.empty?
+          return render_error(
+            errors: "None of the items on order ##{source_order.id} are available to reorder",
+            status: :unprocessable_entity,
+            skipped_items: skipped
+          )
+        end
+
+        parent, orders = place_direct_listing_cart(resolved_items, base_attrs: reorder_base_attributes(source_order))
+
+        new_order = parent || orders.first
+        new_order = @clazz.includes(eager_loaded_associations).find(new_order.id) if eager_loaded_associations.present?
+        includes = default_serializer_includes[:create] || []
+        options = {include: includes} if includes.present?
+
+        meta = {
+          reordered_from: source_order.id,
+          reordered_items: resolved_items.size,
+          skipped_items: skipped,
+          adjusted_items: adjusted
+        }
+        if parent
+          meta[:split_by_business] = true
+          meta[:order_count] = orders.size
+        end
+
+        render_success(data: new_order, serializer_options: options, status: :created, meta: meta)
+      rescue ActiveRecord::RecordInvalid => e
+        errors = e.record&.errors&.full_messages&.presence || [ e.message ]
+        render_error(errors: errors.join(", "), status: :unprocessable_entity)
+      rescue => e
+        render_error(error: e.message)
+      end
+
       def filter
         authorize @clazz.new, :filter?
         orders = @clazz.all
@@ -451,19 +506,8 @@ module Dscf
         resolved_items = resolve_direct_listing_items
         return if performed? # resolve_direct_listing_items already rendered an error
 
-        groups = resolved_items.group_by { |ri| ri[:ordered_to] }.values
-        parent = nil
-        orders = []
-        ActiveRecord::Base.transaction do
-          # A cart spanning several fulfilling businesses still checks out as
-          # ONE retailer-facing order: a parent with one sub-order per business.
-          # Single-business carts stay a plain standalone order (no parent).
-          parent = build_and_save_parent_order if groups.size > 1
-          groups.each do |items|
-            orders << build_and_save_direct_listing_order(items, parent: parent)
-          end
-          parent&.sync_aggregates!
-        end
+        base_attrs = model_params.except(:order_items_attributes, :listing_id, :listing_type, :retailer_id)
+        parent, orders = place_direct_listing_cart(resolved_items, base_attrs: base_attrs)
 
         if agent_order_retailer
           # One OTP for the whole cart — on the parent when split, so the
@@ -576,13 +620,122 @@ module Dscf
       # Order with one line per item, saves it, then decrements each source's
       # quantity. Raises ActiveRecord::RecordInvalid on insufficient stock so
       # the whole checkout (all groups) rolls back together.
+      # The shared order fields the reorder inherits. Deliberately NOT copied:
+      # status (the new order starts fresh), agent_id (a reorder is the
+      # retailer acting for themselves, so it skips the agent OTP gate), and
+      # any payment reference from the original transaction.
+      def reorder_base_attributes(source_order)
+        {
+          user_id: source_order.user_id,
+          ordered_by_id: source_order.ordered_by_id,
+          fulfillment_type: source_order.fulfillment_type,
+          payment_method: source_order.payment_method,
+          dropoff_address_id: source_order.dropoff_address_id
+        }
+      end
+
+      # Re-resolves a past order's lines against what is offerable now.
+      # Returns [resolved_items, skipped, adjusted] where the latter two are
+      # client-facing reports of what could not be honoured as-is.
+      def resolve_reorder_items(source_order)
+        resolved = []
+        skipped = []
+        adjusted = []
+
+        reorder_source_lines(source_order).each do |item, seller|
+          product_name = item.product&.name
+          wanted = item.quantity.to_i
+          next if wanted <= 0
+
+          listing, aggregator_listing = find_reorder_listing(item, seller)
+
+          if listing.nil? && aggregator_listing.nil?
+            skipped << {product_id: item.product_id, product_name: product_name, reason: "no_longer_available"}
+            next
+          end
+
+          available = (listing || aggregator_listing).quantity.to_i
+          if available <= 0
+            skipped << {product_id: item.product_id, product_name: product_name, reason: "out_of_stock"}
+            next
+          end
+
+          quantity = [ wanted, available ].min
+          if quantity < wanted
+            adjusted << {
+              product_id: item.product_id, product_name: product_name,
+              requested_quantity: wanted, quantity: quantity, reason: "insufficient_stock"
+            }
+          end
+
+          resolved << if listing
+            {listing: listing, quantity: quantity, ordered_to: listing.business}
+          else
+            {aggregator_listing: aggregator_listing, quantity: quantity, ordered_to: aggregator_listing.aggregator}
+          end
+        end
+
+        [ resolved, skipped, adjusted ]
+      end
+
+      # The lines worth reordering, each paired with the business it was bought
+      # from. A parent holds no lines of its own, so a reorder of a whole cart
+      # collects them from its sub-orders (and may split again). Cancelled lines
+      # were never fulfilled, so they don't come along.
+      def reorder_source_lines(source_order)
+        orders = source_order.parent? ? source_order.sub_orders.to_a : [ source_order ]
+        orders.flat_map do |order|
+          order.order_items.reject(&:cancelled?).map { |item| [ item, order.ordered_to ] }
+        end
+      end
+
+      # A supplier listing is re-found by id — silently moving the retailer to a
+      # different supplier would not be the same purchase. A feed line only
+      # knows its product, so it re-resolves to whatever the SAME aggregator
+      # currently offers for that product.
+      def find_reorder_listing(item, seller)
+        if item.listing_id.present?
+          listing = Dscf::Marketplace::Listing.active.find_by(id: item.listing_id)
+          return [ listing, nil ] if listing
+        end
+
+        aggregator_listing = Dscf::Marketplace::AggregatorListing
+          .offerable
+          .for_product(item.product_id)
+          .find_by(aggregator_id: seller&.id)
+
+        [ nil, aggregator_listing ]
+      end
+
+      # Groups a resolved cart by fulfilling business and writes it out. A cart
+      # spanning several businesses becomes ONE retailer-facing parent order
+      # with a sub-order each; a single-business cart stays a plain standalone
+      # order (no parent). Shared by checkout and reorder — they differ only in
+      # where the cart and the shared order fields come from.
+      # Returns [parent_or_nil, orders].
+      def place_direct_listing_cart(resolved_items, base_attrs:)
+        groups = resolved_items.group_by { |ri| ri[:ordered_to] }.values
+        parent = nil
+        orders = []
+
+        ActiveRecord::Base.transaction do
+          parent = build_and_save_parent_order(base_attrs) if groups.size > 1
+          groups.each do |items|
+            orders << build_and_save_direct_listing_order(items, base_attrs, parent: parent)
+          end
+          parent&.sync_aggregates!
+        end
+
+        [ parent, orders ]
+      end
+
       # The retailer-facing umbrella for a multi-business cart. Carries the
       # shared checkout fields (who ordered, payment, fulfillment, agent) but
       # no ordered_to (it spans businesses), no listing and no items — those
       # live on the per-business sub-orders. Status/total are synced from the
       # sub-orders (Order#sync_aggregates!).
-      def build_and_save_parent_order
-        parent = @clazz.new(model_params.except(:order_items_attributes, :listing_id, :listing_type, :retailer_id, :ordered_to_id))
+      def build_and_save_parent_order(base_attrs)
+        parent = @clazz.new(base_attrs.except(:ordered_to_id))
         parent.order_type = :direct_listing
         parent.status = :pending
         parent.ordered_to = nil
@@ -591,7 +744,7 @@ module Dscf
         parent
       end
 
-      def build_and_save_direct_listing_order(items, parent: nil)
+      def build_and_save_direct_listing_order(items, base_attrs, parent: nil)
         items.each { |ri| (ri[:listing] || ri[:aggregator_listing]).lock! }
 
         items.each do |ri|
@@ -602,7 +755,7 @@ module Dscf
           raise ActiveRecord::RecordInvalid.new(source)
         end
 
-        order = @clazz.new(model_params.except(:order_items_attributes, :listing_id, :listing_type, :retailer_id))
+        order = @clazz.new(base_attrs)
         order.order_type = :direct_listing
         order.status = :pending
         order.ordered_to = items.first[:ordered_to]

data/app/models/dscf/marketplace/aggregator_listing.rb

@@ -87,6 +87,11 @@ module Dscf::Marketplace
       SQL
     end
 
+    # Listings offering a given catalogue product, whichever way they source it.
+    # Used to re-find a listing for a product the retailer bought before — the
+    # order line records the product, not the listing it came from.
+    scope :for_product, ->(product_id) { where("(#{resolved_product_id_sql}) = ?", product_id) }
+
     # Pulls one column off the resolved product row.
     def self.resolved_product_column_sql(column)
       <<~SQL.squish

data/app/policies/dscf/marketplace/order_policy.rb

@@ -17,6 +17,12 @@ module Dscf
         user.has_permission?("orders.cancel")
       end
 
+      # Reorder places a new order, so it is gated on create rather than on
+      # read access to the order being copied.
+      def reorder?
+        user.has_permission?("orders.create")
+      end
+
       def complete?
         user.has_permission?("orders.complete")
       end

data/config/routes.rb

@@ -124,6 +124,7 @@ Dscf::Marketplace::Engine.routes.draw do
     resources :order_items, only: [ :index ]
     member do
       post "confirm"
+      post "reorder"
       post "cancel"
       post "complete"
       get "invoice"

data/lib/dscf/marketplace/version.rb

@@ -1,5 +1,5 @@
 module Dscf
   module Marketplace
-    VERSION = "0.15.0".freeze
+    VERSION = "0.16.0".freeze
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dscf-marketplace
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.16.0
 platform: ruby
 authors:
 - Asrat
 bindir: bin
 cert_chain: []
-date: 2026-07-25 00:00:00.000000000 Z
+date: 2026-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails