dscf-marketplace 0.13.13 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c4a2b0e347680bb877dbcce80829d80bddb751cd5248a674db3208ba169f4824
-  data.tar.gz: 450244b5f6bb3bfe6933dc5bcbe6ec1ce9a0e4cf12d2b6ba38fbba64451c3009
+  metadata.gz: 3cc1c9aaf986ce406e613ac0b3dc31e9a230a8a4e996ef61df353ef51003cdd6
+  data.tar.gz: ca71e2b9a1310eb873818fdeede519b86af08ca7db17764d0a123ab287c23376
 SHA512:
-  metadata.gz: 2c541d060329f90f173c4489da2991aa8e7ec95edd1eaf71cdea683ac6e676d2316990c24d05d8d6c85f59394b9d0a9e432164ff32449876703b61d95c0ad6c3
-  data.tar.gz: e482e00be97fae32c2b57501b9c036520ddbf385e0bc12b3290e8e687907e7da5ca8673e6778f76d132ef85d4a8f900e51abb28ac02a790a3a6eb3ef1d221496
+  metadata.gz: 59c39334fa8624f99730ef5bf36c9bb18f17e3ecb2c653af7be70cea8068c45fe0dad28b3a7cd632398ef14eed830f1f57111d36bae5ce9d1c63bc6961685ad2
+  data.tar.gz: 688c0ab34c504eaf3e393ef5e82a4ec0c2047d8ed0114126776fd6af88a27156fadf87b532bbb91458b6a63d8d43d2ec568477f15f2c8eb6cae9fb4bf58e2437

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

@@ -8,15 +8,19 @@ module Dscf
         # Retailer-facing feed: only listings that are truly offerable — own
         # status :active AND (for supplier-sourced) the supplier hasn't paused
         # or run out of stock. A listing whose supplier paused drops out here.
-        listings = @clazz.active
-          .includes(:product, {supplier_product: :product}, {sub_supplier_product: :product})
-          .select(&:available?)
+        # #offerable expresses that in SQL so the feed stays a relation and can
+        # be Ransack-filtered and paginated instead of loading every listing.
+        listings = filter_records(
+          @clazz.offerable.includes(feed_associations)
+        )
 
         options = {
           include: default_serializer_includes[:index] || [],
           meta: {resource_type: "aggregator_feed"}
         }
 
+        listings, options = apply_pagination(listings, options)
+
         render_success(data: listings, serializer_options: options)
       end
 
@@ -35,6 +39,41 @@ module Dscf
 
       private
 
+      # The serializer reads product name/description/category through whichever
+      # source the listing was created from, so all three paths get eager loaded.
+      def feed_associations
+        [
+          {product: :category},
+          {supplier_product: {product: :category}},
+          {sub_supplier_product: {product: :category}}
+        ]
+      end
+
+      # Same pagination contract as Common#index (opt-in via ?page), for the
+      # custom collection actions that don't route through it.
+      def apply_pagination(records, options)
+        return [records, options] unless params[:page]
+
+        total_count = records.count
+        records = records.then(&paginate)
+        total_pages = (total_count.to_f / per_page).ceil
+
+        options[:pagination] = {
+          current_page: page_no,
+          per_page: per_page,
+          count: records.length,
+          total_count: total_count,
+          total_pages: total_pages,
+          links: pagination_links(total_pages)
+        }
+
+        [records, options]
+      end
+
+      def allowed_order_columns
+        %w[id created_at updated_at price quantity]
+      end
+
       def model_params
         params.require(:aggregator_listing).permit(
           :aggregator_id, :source_kind, :supplier_product_id, :product_id,

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
@@ -45,6 +100,7 @@ module Dscf
       def confirm
         @obj = find_record
         authorize @obj, :confirm?
+        return if parent_order_guard(@obj)
         return render_error("orders.errors.otp_confirmation_required", status: :unprocessable_entity) if @obj.agent_assisted? && !@obj.otp_verified?
 
         if @obj.confirm!
@@ -97,6 +153,20 @@ module Dscf
       def cancel
         @obj = find_record
         authorize @obj, :cancel?
+
+        # Cancelling the retailer-facing parent cancels every sub-order that
+        # hasn't already completed; the parent's own status follows via
+        # aggregation (child after_save -> sync_aggregates!).
+        if @obj.parent?
+          ActiveRecord::Base.transaction do
+            @obj.sub_orders.where.not(status: :completed).find_each do |sub_order|
+              sub_order.update!(status: :cancelled)
+              sub_order.order_items.update_all(status: OrderItem.statuses[:cancelled])
+            end
+          end
+          return render_success("orders.success.cancelled", data: @obj.reload)
+        end
+
         if @obj.update(status: :cancelled)
           @obj.order_items.update_all(status: OrderItem.statuses[:cancelled])
           render_success("orders.success.cancelled", data: @obj)
@@ -108,6 +178,8 @@ module Dscf
       def complete
         @obj = find_record
         authorize @obj, :complete?
+        return if parent_order_guard(@obj)
+
         if @obj.can_be_completed? && @obj.update(status: :completed)
           @obj.order_items.update_all(status: OrderItem.statuses[:fulfilled])
           begin
@@ -125,6 +197,8 @@ module Dscf
       def invoice
         @obj = find_record
         authorize @obj, :show?
+        return if parent_order_guard(@obj)
+
         invoice = @obj.order_invoice
         if invoice&.pdf_file&.attached?
           redirect_to rails_storage_proxy_url(invoice.pdf_file, disposition: "attachment")
@@ -149,6 +223,7 @@ module Dscf
       def validate
         obj = find_record
         authorize obj, :validate?
+        return if parent_order_guard(obj)
         return render_error(errors: "Order awaits retailer OTP confirmation", status: :unprocessable_entity) if obj.agent_assisted? && !obj.otp_verified?
 
         Dscf::Marketplace::OrderValidationService.validate(obj)
@@ -161,6 +236,7 @@ module Dscf
       def resolve_item
         obj = find_record
         authorize obj, :resolve_item?
+        return if parent_order_guard(obj)
 
         item = obj.order_items.find(params[:order_item_id])
 
@@ -199,6 +275,7 @@ module Dscf
       def assign_source
         obj = find_record
         authorize obj, :split?
+        return if parent_order_guard(obj)
 
         item = obj.order_items.find(params[:order_item_id])
         Dscf::Marketplace::OrderSplittingService.assign_source(item, source_type: params[:source_type], source_id: params[:source_id])
@@ -210,6 +287,7 @@ module Dscf
       def split
         obj = find_record
         authorize obj, :split?
+        return if parent_order_guard(obj)
 
         return render_error(errors: "All items must be validated before splitting") unless obj.all_items_validated?
 
@@ -223,6 +301,7 @@ module Dscf
       def supplier_confirm
         obj = find_record
         authorize obj, :supplier_confirm?
+        return if parent_order_guard(obj)
 
         confirmed = params[:confirmed]
         reason = params[:reason]
@@ -237,6 +316,7 @@ module Dscf
       def confirm_item
         obj = find_record
         authorize obj, :supplier_confirm?
+        return if parent_order_guard(obj)
 
         item = obj.order_items.find(params[:order_item_id])
         confirmed = params[:confirmed] != false
@@ -252,6 +332,7 @@ module Dscf
       def adjust_item
         obj = find_record
         authorize obj, :supplier_confirm?
+        return if parent_order_guard(obj)
 
         item = obj.order_items.find(params[:order_item_id])
         Dscf::Marketplace::OrderSplittingService.adjust_item(
@@ -269,6 +350,7 @@ module Dscf
       def accept_adjustment
         obj = find_record
         authorize obj, :split?
+        return if parent_order_guard(obj)
 
         item = obj.order_items.find(params[:order_item_id])
         Dscf::Marketplace::OrderSplittingService.accept_item_adjustment(obj, item)
@@ -281,6 +363,7 @@ module Dscf
       def reject_adjustment
         obj = find_record
         authorize obj, :split?
+        return if parent_order_guard(obj)
 
         item = obj.order_items.find(params[:order_item_id])
         Dscf::Marketplace::OrderSplittingService.reject_item_adjustment(obj, item, reason: params[:reason])
@@ -295,6 +378,7 @@ module Dscf
       def reopen_item
         obj = find_record
         authorize obj, :split?
+        return if parent_order_guard(obj)
 
         item = obj.order_items.find(params[:order_item_id])
         Dscf::Marketplace::OrderSplittingService.reopen_item(obj, item)
@@ -307,24 +391,47 @@ module Dscf
         obj = find_record
         authorize obj, :confirm? # reuse existing or add specific
 
-        return render_error(errors: "Order not ready for retailer confirmation") unless obj.retailer_can_confirm?
+        # The retailer confirms the parent once; the decision fans out to every
+        # sub-order that's ready. Sub-orders still waiting on their supplier are
+        # left untouched — they come back for confirmation when ready.
+        notification = retailer_rejecting? ? :retailer_rejected : :retailer_confirmed
 
-        if params[:confirmed] == false
-          reason = params[:reason]
-          obj.update!(status: :cancelled)
-          obj.order_items.update_all(status: OrderItem.statuses[:cancelled])
-          create_notification_for_order(obj, :retailer_rejected, reason: reason)
-        else
-          obj.update!(status: :confirmed)
-          obj.order_items.update_all(status: OrderItem.statuses[:confirmed])
-          create_notification_for_order(obj, :retailer_confirmed)
+        if obj.parent?
+          ready = obj.sub_orders.to_a.select(&:retailer_can_confirm?)
+          return render_error(errors: "Order not ready for retailer confirmation") if ready.empty?
+
+          ActiveRecord::Base.transaction do
+            ready.each { |sub_order| apply_retailer_confirmation(sub_order) }
+          end
+          create_notification_for_order(obj.reload, notification, reason: params[:reason])
+          return render_success(data: obj, serializer_options: { include: default_serializer_includes[:show] || [] })
         end
 
+        return render_error(errors: "Order not ready for retailer confirmation") unless obj.retailer_can_confirm?
+
+        apply_retailer_confirmation(obj)
+        create_notification_for_order(obj, notification, reason: params[:reason])
+
         render_success(data: obj, serializer_options: { include: default_serializer_includes[:show] || [] })
       rescue => e
         render_error(errors: e.message, status: :unprocessable_entity)
       end
 
+      def retailer_rejecting?
+        params[:confirmed] == false
+      end
+
+      # The retailer's confirm-or-cancel decision applied to one order row.
+      def apply_retailer_confirmation(order)
+        if retailer_rejecting?
+          order.update!(status: :cancelled)
+          order.order_items.update_all(status: OrderItem.statuses[:cancelled])
+        else
+          order.update!(status: :confirmed)
+          order.order_items.update_all(status: OrderItem.statuses[:confirmed])
+        end
+      end
+
 
       def create_notification_for_order(order, action, reason: nil, otp_code: nil)
         recipient = order.ordered_by || order.user
@@ -368,7 +475,10 @@ module Dscf
       # agent and the aggregator (the business the order was placed with)
       # get notified, in addition to the retailer's own notification above.
       def notify_agent_order_confirmed(order)
-        [ order.agent&.user, order.ordered_to&.user ].compact.each do |recipient|
+        # A parent order has no ordered_to of its own — notify every
+        # sub-order's fulfilling business instead.
+        ordered_to_users = order.parent? ? order.sub_orders.map { |so| so.ordered_to&.user } : [ order.ordered_to&.user ]
+        [ order.agent&.user, *ordered_to_users ].compact.uniq.each do |recipient|
           notification = Dscf::Core::Notification.create!(
             notifiable: order,
             recipient: recipient,
@@ -396,24 +506,25 @@ module Dscf
         resolved_items = resolve_direct_listing_items
         return if performed? # resolve_direct_listing_items already rendered an error
 
-        orders = []
-        ActiveRecord::Base.transaction do
-          resolved_items.group_by { |ri| ri[:ordered_to] }.each_value do |items|
-            orders << build_and_save_direct_listing_order(items)
-          end
-        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)
 
-        orders.each { |order| send_agent_order_otp(order, agent_order_retailer) } if agent_order_retailer
+        if agent_order_retailer
+          # One OTP for the whole cart — on the parent when split, so the
+          # retailer confirms once; sub-orders inherit via Order#otp_verified?.
+          send_agent_order_otp(parent || orders.first, agent_order_retailer)
+        end
 
-        orders = orders.map { |o| @clazz.includes(eager_loaded_associations).find(o.id) } if eager_loaded_associations.present?
+        retailer_order = parent || orders.first
+        retailer_order = @clazz.includes(eager_loaded_associations).find(retailer_order.id) if eager_loaded_associations.present?
         includes = default_serializer_includes[:create] || []
         options = {include: includes} if includes.present?
 
-        if orders.size == 1
-          render_success(data: orders.first, serializer_options: options, status: :created)
-        else
-          render_success(data: orders, serializer_options: options, status: :created,
+        if parent
+          render_success(data: retailer_order, serializer_options: options, status: :created,
             meta: {split_by_business: true, order_count: orders.size})
+        else
+          render_success(data: retailer_order, serializer_options: options, status: :created)
         end
       rescue ActiveRecord::RecordInvalid => e
         errors = e.record&.errors&.full_messages&.presence || [ e.message ]
@@ -509,7 +620,131 @@ 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.
-      def build_and_save_direct_listing_order(items)
+      # 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(base_attrs)
+        parent = @clazz.new(base_attrs.except(:ordered_to_id))
+        parent.order_type = :direct_listing
+        parent.status = :pending
+        parent.ordered_to = nil
+        parent.acts_as_parent = true
+        parent.save!
+        parent
+      end
+
+      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|
@@ -520,10 +755,11 @@ 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]
+        order.parent_order = parent
         # Order#listing is a single FK; set it to the first supplier-listing item
         # so quotation_or_listing_present is satisfied for listing-only groups
         # (an aggregator-listing-sourced item satisfies it on its own — see
@@ -574,6 +810,17 @@ module Dscf
         order
       end
 
+      # Item-level workflow (validate/split/confirm/complete/invoice/…) happens
+      # on the per-business sub-orders — a parent has no items to act on. The
+      # retailer-facing actions that DO work on a parent (retailer_confirm,
+      # cancel) fan out explicitly instead of calling this guard.
+      def parent_order_guard(order)
+        return false unless order.parent?
+
+        render_error(errors: "Action not available on a parent order; act on its sub-orders", status: :unprocessable_entity)
+        true
+      end
+
       def direct_listing_request?
         %w[direct_listing 1].include?(model_params[:order_type].to_s)
       end
@@ -590,15 +837,15 @@ module Dscf
       end
 
       def eager_loaded_associations
-        [ :quotation, :listing, :user, :ordered_by, :ordered_to, :delivery_order, :order_items ]
+        [ :quotation, :listing, :user, :ordered_by, :ordered_to, :delivery_order, :order_items, { sub_orders: :order_items } ]
       end
 
       def default_serializer_includes
         {
-          index: [ :user, :ordered_by, :ordered_to, :quotation, :order_items ],
-          show: [ :user, :ordered_by, :ordered_to, :quotation, :listing, :delivery_order, :order_items ],
-          create: [ :user, :ordered_by, :ordered_to, :quotation, :listing, :order_items ],
-          update: [ :user, :ordered_by, :ordered_to, :quotation, :listing, :order_items ]
+          index: [ :user, :ordered_by, :ordered_to, :quotation, :order_items, "sub_orders.order_items" ],
+          show: [ :user, :ordered_by, :ordered_to, :quotation, :listing, :delivery_order, :order_items, "sub_orders.order_items" ],
+          create: [ :user, :ordered_by, :ordered_to, :quotation, :listing, :order_items, "sub_orders.order_items" ],
+          update: [ :user, :ordered_by, :ordered_to, :quotation, :listing, :order_items, "sub_orders.order_items" ]
         }
       end
 

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

@@ -36,8 +36,94 @@ module Dscf::Marketplace
     scope :active, -> { where(status: :active) }
     scope :by_aggregator, ->(aggregator_id) { where(aggregator_id: aggregator_id) }
 
+    # SQL equivalent of #available? — the retailer-facing "truly offerable" set.
+    # Kept as a scope (rather than `select(&:available?)`) so the feed stays a
+    # relation and can be filtered, counted and paginated in the database.
+    scope :offerable, lambda {
+      active
+        .where("#{table_name}.quantity > 0")
+        .where(
+          <<~SQL.squish,
+            #{table_name}.source_kind = :catalog
+            OR (
+              #{table_name}.source_kind = :supplier AND EXISTS (
+                SELECT 1 FROM #{SupplierProduct.table_name} sp
+                WHERE sp.id = #{table_name}.supplier_product_id
+                  AND sp.status = :sp_active
+                  AND sp.available_quantity > 0
+              )
+            )
+            OR (
+              #{table_name}.source_kind = :sub_supplier AND EXISTS (
+                SELECT 1 FROM #{SubSupplierProduct.table_name} ssp
+                WHERE ssp.id = #{table_name}.sub_supplier_product_id
+              )
+            )
+          SQL
+          catalog: source_kinds[:catalog],
+          supplier: source_kinds[:supplier],
+          sub_supplier: source_kinds[:sub_supplier],
+          sp_active: SupplierProduct.statuses[:active]
+        )
+    }
+
+    # Resolves the catalogue product id in SQL, mirroring #product: which column
+    # holds the reference depends on source_kind, so a plain association join
+    # can't reach it. Used by the ransackers below so retailers can filter the
+    # feed on product attributes regardless of how a listing was sourced.
+    def self.resolved_product_id_sql
+      <<~SQL.squish
+        CASE #{table_name}.source_kind
+          WHEN #{source_kinds[:supplier]} THEN (
+            SELECT sp.product_id FROM #{SupplierProduct.table_name} sp
+            WHERE sp.id = #{table_name}.supplier_product_id
+          )
+          WHEN #{source_kinds[:sub_supplier]} THEN (
+            SELECT ssp.product_id FROM #{SubSupplierProduct.table_name} ssp
+            WHERE ssp.id = #{table_name}.sub_supplier_product_id
+          )
+          ELSE #{table_name}.product_id
+        END
+      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
+        (SELECT p.#{column} FROM #{Product.table_name} p
+         WHERE p.id = (#{resolved_product_id_sql}))
+      SQL
+    end
+
+    ransacker :product_name do
+      Arel.sql(resolved_product_column_sql(:name))
+    end
+
+    ransacker :product_description do
+      Arel.sql(resolved_product_column_sql(:description))
+    end
+
+    ransacker :product_category_id, type: :integer do
+      Arel.sql(resolved_product_column_sql(:category_id))
+    end
+
+    # Category *name*, so `q[product_category_cont]=Spice` works without the
+    # client having to look the category id up first.
+    ransacker :product_category do
+      Arel.sql(<<~SQL.squish)
+        (SELECT c.name FROM #{Category.table_name} c
+         WHERE c.id = #{resolved_product_column_sql(:category_id)})
+      SQL
+    end
+
     def self.ransackable_attributes(_auth_object = nil)
-      %w[id aggregator_id supplier_product_id product_id sub_supplier_product_id source_kind price quantity status created_at updated_at]
+      %w[id aggregator_id supplier_product_id product_id sub_supplier_product_id source_kind price quantity status created_at updated_at] +
+        %w[product_name product_description product_category product_category_id]
     end
 
     def self.ransackable_associations(_auth_object = nil)

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

@@ -20,22 +20,39 @@ module Dscf::Marketplace
     belongs_to :listing, optional: true
     belongs_to :user, class_name: "Dscf::Core::User" # Keep for backward compatibility
     belongs_to :ordered_by, class_name: "Dscf::Core::User"
-    belongs_to :ordered_to, class_name: "Dscf::Core::Business"
+    # optional at the association level; presence is enforced below for every
+    # order except a parent (which spans businesses).
+    belongs_to :ordered_to, class_name: "Dscf::Core::Business", optional: true
     belongs_to :delivery_order, optional: true
     belongs_to :dropoff_address, class_name: "Dscf::Core::Address", optional: true
     belongs_to :agent, class_name: "Dscf::Marketplace::Agent", optional: true
+    # A multi-business cart checks out as one retailer-facing parent order with
+    # one sub-order per fulfilling business. The parent carries no order_items
+    # of its own — items, stock, validation, splitting and invoicing all live on
+    # the sub-orders, which are exactly what standalone orders always were.
+    belongs_to :parent_order, class_name: "Dscf::Marketplace::Order", optional: true
+    has_many :sub_orders, class_name: "Dscf::Marketplace::Order",
+      foreign_key: :parent_order_id, inverse_of: :parent_order, dependent: :destroy
     has_many :order_items, dependent: :destroy, autosave: true
     has_one :order_invoice, class_name: "Dscf::Marketplace::OrderInvoice", dependent: :destroy
     has_many :otp_verifications, as: :verifiable, class_name: "Dscf::Marketplace::OtpVerification", dependent: :destroy
     accepts_nested_attributes_for :order_items, allow_destroy: true
 
+    # Marks an order being built as a parent before its sub-orders exist (they
+    # are created after the parent inside the checkout transaction, so
+    # `sub_orders.exists?` alone can't answer "am I a parent?" on first save).
+    attr_accessor :acts_as_parent
+
     validates :order_type, presence: true
     validates :status, presence: true
     validates :fulfillment_type, presence: true
     validates :payment_method, presence: true
     validates :user, presence: true # Keep for backward compatibility
     validates :ordered_by, presence: true
-    validates :ordered_to, presence: true
+    # A parent spans several fulfilling businesses, so it has no single
+    # counterparty; each sub-order carries its own ordered_to.
+    validates :ordered_to, presence: true, unless: :parent?
+    validates :parent_order_id, absence: true, if: :acts_as_parent
     validates :dropoff_address, presence: true, if: :delivery?
     validates :received_bank_name, :transaction_reference, absence: true, if: :cash?
     validate :quotation_or_listing_present
@@ -45,14 +62,20 @@ module Dscf::Marketplace
     before_validation :clear_payment_references_for_cash
     before_validation :auto_assign_dropoff_address, if: :delivery?
     before_save :calculate_total_amount
+    # Keep the parent's persisted status/total in step with its sub-orders so
+    # retailer-side filtering and ordering (ransack on my_orders) keep working.
+    # Reliable because sub-order status always changes via save/update! —
+    # update_all is only ever used on order_items.
+    after_save :sync_parent_aggregates,
+      if: -> { parent_order_id? && (saved_change_to_status? || saved_change_to_total_amount?) }
 
     # Ransack configuration for secure filtering
     def self.ransackable_attributes(_auth_object = nil)
-      %w[id quotation_id listing_id user_id ordered_by_id ordered_to_id delivery_order_id dropoff_address_id agent_id order_type status fulfillment_type payment_method received_bank_name transaction_reference total_amount created_at updated_at]
+      %w[id quotation_id listing_id user_id ordered_by_id ordered_to_id parent_order_id delivery_order_id dropoff_address_id agent_id order_type status fulfillment_type payment_method received_bank_name transaction_reference total_amount created_at updated_at]
     end
 
     def self.ransackable_associations(_auth_object = nil)
-      %w[quotation listing user ordered_by ordered_to delivery_order dropoff_address order_items]
+      %w[quotation listing user ordered_by ordered_to delivery_order dropoff_address order_items parent_order sub_orders]
     end
 
     def self.create_from_quotation(quotation, dropoff_address = nil, payment_method = nil)
@@ -180,9 +203,47 @@ module Dscf::Marketplace
     end
 
     def calculate_total_amount
+      # A parent has no items; its total is synced from sub-orders — don't
+      # zero it out on save.
+      return if parent?
+
       self.total_amount = billable_order_items.sum { |item| item.quantity * item.unit_price }
     end
 
+    # Retailer-facing umbrella over per-business sub-orders. The virtual flag
+    # covers the parent's own creation (before sub-orders exist); afterwards
+    # the association is authoritative.
+    def parent?
+      acts_as_parent.present? || (persisted? && sub_orders.exists?)
+    end
+
+    # Recompute the parent's status/total from its sub-orders. update_columns
+    # on purpose: aggregation must not re-trigger validations or callbacks.
+    def sync_aggregates!
+      return unless parent?
+
+      update_columns(
+        status: self.class.statuses[compute_aggregate_status],
+        total_amount: sub_orders.sum(:total_amount),
+        updated_at: Time.current
+      )
+    end
+
+    # The parent's status mirrors the furthest-behind live sub-order: it only
+    # advances once every live (non-cancelled) sub-order has advanced.
+    def compute_aggregate_status
+      statuses = sub_orders.pluck(:status).map { |s| self.class.statuses.key(s) || s.to_s }
+      live = statuses.reject { |s| s == "cancelled" }
+
+      return :cancelled if live.empty?
+      return :completed if live.all? { |s| s == "completed" }
+      return :confirmed if live.all? { |s| %w[confirmed processing completed].include?(s) }
+      return :waiting_supplier_confirmation if live.any? { |s| %w[waiting_supplier_confirmation splitting].include?(s) }
+      return :waiting_retailer_confirmation if live.any? { |s| s == "waiting_retailer_confirmation" }
+
+      :pending
+    end
+
     # Workflow helpers for Sprint 2 order validation + splitting.
     # Note: `validating?` is the enum-generated predicate (true only when
     # status == "validating"). Use this for "can still be run through
@@ -237,11 +298,17 @@ module Dscf::Marketplace
     end
 
     def otp_verified?
-      otp_verifications.verified.exists?
+      # A split (multi-business) agent order carries ONE OTP on the parent —
+      # the retailer confirms the whole cart once; sub-orders inherit it.
+      otp_verifications.verified.exists? || (parent_order.present? && parent_order.otp_verified?)
     end
 
   private
 
+    def sync_parent_aggregates
+      parent_order&.sync_aggregates!
+    end
+
     def auto_assign_dropoff_address
       return if dropoff_address_id.present? || dropoff_address.present?
 
@@ -275,6 +342,10 @@ module Dscf::Marketplace
     end
 
     def quotation_or_listing_present
+      # A parent order carries no lines of its own — its sub-orders each ground
+      # themselves in a listing/quotation/source.
+      return if parent?
+
       # A feed-purchased order has no order.listing (Order#listing is a single
       # FK; nothing to point it at when every item came from the aggregator's
       # feed) but each item's own presence validation already requires it to

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/app/serializers/dscf/marketplace/aggregator_listing_serializer.rb

@@ -4,8 +4,8 @@ module Dscf
       attributes :id, :aggregator_id, :source_kind, :supplier_product_id, :product_id,
                  :sub_supplier_product_id, :price, :quantity, :cost_price, :margin,
                  :status, :effective_status, :created_at, :updated_at, :total_value, :available?,
-                 :product_name, :product_description, :thumbnail_url, :images_urls,
-                 :source_label
+                 :product_name, :product_description, :product_category, :product_category_id,
+                 :thumbnail_url, :images_urls, :source_label
 
       belongs_to :aggregator
 
@@ -17,6 +17,14 @@ module Dscf
         object.product&.description
       end
 
+      def product_category
+        object.product&.category&.name
+      end
+
+      def product_category_id
+        object.product&.category_id
+      end
+
       def thumbnail_url
         object.product&.thumbnail_url
       end

data/app/serializers/dscf/marketplace/order_serializer.rb

@@ -1,7 +1,7 @@
 module Dscf
   module Marketplace
     class OrderSerializer < ActiveModel::Serializer
-      attributes :id, :quotation_id, :listing_id, :user_id, :ordered_by_id, :ordered_to_id, :delivery_order_id, :dropoff_address_id, :agent_id,
+      attributes :id, :quotation_id, :listing_id, :user_id, :ordered_by_id, :ordered_to_id, :parent_order_id, :delivery_order_id, :dropoff_address_id, :agent_id,
         :order_type, :status, :workflow_status, :has_validation_issues, :fulfillment_type, :payment_method, :received_bank_name, :transaction_reference, :total_amount,
         :buyer_name, :buyer_phone, :buyer_email, :seller_name, :seller_phone, :seller_email,
         :created_at, :updated_at
@@ -15,6 +15,11 @@ module Dscf
       belongs_to :dropoff_address
       belongs_to :agent
       has_many :order_items
+      # Per-business sub-orders of a retailer-facing parent order. Only ever
+      # rendered when explicitly asked for via serializer include
+      # ("sub_orders.order_items"), and sub-orders themselves have no
+      # sub-orders, so recursion is bounded.
+      has_many :sub_orders, serializer: OrderSerializer
 
       # Retailer's registered display name (users have no name field of their
       # own — only email/phone) so admin can see who placed the order, per

data/app/services/dscf/marketplace/my_resource_service.rb

@@ -6,8 +6,11 @@ module Dscf
       end
 
       def my_orders(params = {})
-        orders = Dscf::Marketplace::Order.where(ordered_by: @current_user)
-          .includes(:quotation, :listing, :user, :ordered_by, :ordered_to, :delivery_order, :order_items)
+        # Sub-orders are the per-business halves of a split cart — the retailer
+        # sees only the parent (with sub_orders nested), never the children as
+        # separate rows.
+        orders = Dscf::Marketplace::Order.where(ordered_by: @current_user, parent_order_id: nil)
+          .includes(:quotation, :listing, :user, :ordered_by, :ordered_to, :delivery_order, :order_items, sub_orders: :order_items)
 
         apply_filters(orders, params)
       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/db/migrate/20260725000001_add_parent_order_to_dscf_marketplace_orders.rb

@@ -0,0 +1,11 @@
+class AddParentOrderToDscfMarketplaceOrders < ActiveRecord::Migration[8.0]
+  def change
+    # Retailer-facing umbrella order: a multi-business cart creates one parent
+    # (what the retailer sees) plus one sub-order per fulfilling business (what
+    # each supplier sees). Standalone orders keep parent_order_id nil.
+    add_reference :dscf_marketplace_orders, :parent_order,
+      null: true,
+      index: {name: "parent_order_id_on_dm_orders_idx"},
+      foreign_key: {to_table: :dscf_marketplace_orders}
+  end
+end

data/lib/dscf/marketplace/version.rb

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

data/spec/factories/dscf/marketplace/orders.rb

@@ -56,5 +56,14 @@ FactoryBot.define do
     trait :cancelled do
       status { :cancelled }
     end
+
+    # Retailer-facing umbrella over per-business sub-orders: no counterparty,
+    # no listing/quotation, no items of its own.
+    trait :parent do
+      acts_as_parent { true }
+      ordered_to { nil }
+      quotation { nil }
+      listing { nil }
+    end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dscf-marketplace
 version: !ruby/object:Gem::Version
-  version: 0.13.13
+  version: 0.16.0
 platform: ruby
 authors:
 - Asrat
 bindir: bin
 cert_chain: []
-date: 2026-07-09 00:00:00.000000000 Z
+date: 2026-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -601,6 +601,7 @@ files:
 - db/migrate/20260708000001_make_retailer_tin_number_optional.rb
 - db/migrate/20260708000002_make_product_gross_weight_optional.rb
 - db/migrate/20260709000001_remove_supplier_from_dscf_marketplace_sub_suppliers.rb
+- db/migrate/20260725000001_add_parent_order_to_dscf_marketplace_orders.rb
 - db/seeds.rb
 - lib/dscf/marketplace.rb
 - lib/dscf/marketplace/engine.rb