dscf-marketplace 0.8.9 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce8356967d3398e0db71eeea4bb7c4c4ab29b7755a6709728b4e221ed66d66b7
-  data.tar.gz: 29a36ec8dee0f6b151e204678199122ca6f4876201c3afb0eaaabceb11cd3ca4
+  metadata.gz: 06e78b71c3cb2e9a47b73bdc71eb3c221e6ef2c00fae135fbe6f4b9f6b76c0ad
+  data.tar.gz: f416eef38f577530f81e698f6c0fbccfbca0e18b342866e50736a3a328bd65e4
 SHA512:
-  metadata.gz: 0d1ee57848f223f11bbe6953b603e639cd4e71972056a36b73c95c8265e742df4872cfc095ef373b1bf11ef1dae3c41f6be9ed64baf4957b7b36d6b119f3b74b
-  data.tar.gz: '07086f8b707602c32ebfa535c572642edd0f8d7d12ef39443f1aff18e9670eadc8a01cdaedf20c53dc0ccb115ca86e259edfb5b71e1564077d718885e0ee378c'
+  metadata.gz: 58a193bbca932e849a71adfe6faad3bb2b9b79a8cb312fcb4973aeec8e650b740ae6d10977548b8c94633616fbdeb5089570e332d205ef83e77538e5af6953b6
+  data.tar.gz: 727fd25dd31d44c4f52544ecd161096a502ca4168ca934e1bcd4324ac4b9dcff57c37c268607e4f081ede2e88227441aeef35cd021dd8a7333313a451349de23

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

@@ -104,47 +104,215 @@ module Dscf
         render_success("orders.success.index", data: orders, serializer_options: options)
       end
 
+      def validate
+        obj = find_record
+        authorize obj, :validate?
+
+        Dscf::Marketplace::OrderValidationService.validate(obj)
+        create_notification_for_order(obj, :validation_completed)
+        render_success(data: obj, serializer_options: { include: default_serializer_includes[:show] || [] })
+      rescue => e
+        render_error(errors: e.message, status: :unprocessable_entity)
+      end
+
+      def resolve_item
+        obj = find_record
+        authorize obj, :resolve_item?
+
+        item = obj.order_items.find(params[:order_item_id])
+        # Example: for price_changed, accept optional resolved_unit_price from params
+        if params[:resolved_unit_price].present?
+          item.resolved_unit_price = params[:resolved_unit_price]
+          item.validation_status = :validated
+        end
+        if params[:resolved_quantity].present?
+          item.resolved_quantity = params[:resolved_quantity]
+          item.validation_status = :validated
+        end
+        if params[:action_type] == "remove"
+          item.validation_status = :validated
+          item.quantity = 0 # will be cleaned or marked
+        end
+
+        item.save!
+        create_notification_for_order(obj, :item_resolved)
+        render_success(data: item)
+      rescue => e
+        render_error(errors: e.message, status: :unprocessable_entity)
+      end
+
+      def assign_source
+        obj = find_record
+        authorize obj, :split?
+
+        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])
+        render_success(data: item)
+      rescue => e
+        render_error(errors: e.message, status: :unprocessable_entity)
+      end
+
+      def split
+        obj = find_record
+        authorize obj, :split?
+
+        return render_error(errors: "All items must be validated before splitting") unless obj.all_items_validated?
+
+        Dscf::Marketplace::OrderSplittingService.perform_split(obj)
+        create_notification_for_order(obj, :split_ready)
+        render_success(data: obj, serializer_options: { include: default_serializer_includes[:show] || [] })
+      rescue => e
+        render_error(errors: e.message, status: :unprocessable_entity)
+      end
+
+      def supplier_confirm
+        obj = find_record
+        authorize obj, :supplier_confirm?
+
+        confirmed = params[:confirmed]
+        reason = params[:reason]
+        Dscf::Marketplace::OrderSplittingService.supplier_confirm(obj, confirmed: confirmed != false, reason: reason)
+
+        create_notification_for_order(obj, confirmed ? :supplier_confirmed : :supplier_rejected, reason: 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_confirm
+        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?
+
+        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)
+        end
+
+        render_success(data: obj, serializer_options: { include: default_serializer_includes[:show] || [] })
+      rescue => e
+        render_error(errors: e.message, status: :unprocessable_entity)
+      end
+
+
+      def create_notification_for_order(order, action, reason: nil)
+        recipient = order.ordered_by || order.user
+        return unless recipient
+
+        title = case action
+        when :validation_completed then "Order ##{order.id} validation complete"
+        when :item_resolved then "Item resolved in order ##{order.id}"
+        when :split_ready then "Order ##{order.id} ready for supplier confirmation"
+        when :supplier_confirmed then "Supplier confirmed order ##{order.id}"
+        when :supplier_rejected then "Supplier rejected item in order ##{order.id}"
+        when :retailer_confirmed then "Retailer confirmed order ##{order.id}"
+        when :retailer_rejected then "Retailer cancelled order ##{order.id}"
+        else "Order ##{order.id} update"
+        end
+
+        body = case action
+        when :supplier_rejected, :retailer_rejected then "Reason: #{reason}" if reason
+        else "Status: #{order.status}"
+        end
+
+        notification = Dscf::Core::Notification.create!(
+          notifiable: order,
+          recipient: recipient,
+          notification_type: :general,
+          title: title,
+          body: body.to_s
+        )
+        Dscf::Core::NotificationService.deliver(notification)
+      end
+
       private
 
       def create_direct_listing_order
-        listing = Dscf::Marketplace::Listing.active.find_by(id: model_params[:listing_id])
-        return render_error(errors: "Listing is not available", status: :unprocessable_entity) unless listing
+        listing = nil
+        aggregator_listing = nil
+
+        if model_params[:listing_type] == "AggregatorListing"
+          aggregator_listing = Dscf::Marketplace::AggregatorListing.active.find_by(id: model_params[:listing_id])
+          return render_error(errors: "Listing is not available", status: :unprocessable_entity) unless aggregator_listing
+        else
+          listing = Dscf::Marketplace::Listing.active.find_by(id: model_params[:listing_id])
+          if listing.blank? && model_params[:listing_type].blank?
+            aggregator_listing = Dscf::Marketplace::AggregatorListing.active.find_by(id: model_params[:listing_id])
+          end
+          return render_error(errors: "Listing is not available", status: :unprocessable_entity) if listing.blank? && aggregator_listing.blank?
+        end
 
         quantity = direct_listing_quantity
         return render_error(errors: "Quantity must be greater than 0", status: :unprocessable_entity) unless quantity.positive?
 
-        if quantity > listing.quantity
+        limit_quantity = listing ? listing.quantity : aggregator_listing.quantity
+        if quantity > limit_quantity
           return render_error(errors: "Requested quantity exceeds available listing quantity", status: :unprocessable_entity)
         end
 
         order = nil
         ActiveRecord::Base.transaction do
-          listing.lock!
-
-          if quantity > listing.quantity
-            listing.errors.add(:base, "Requested quantity exceeds available listing quantity")
-            raise ActiveRecord::RecordInvalid.new(listing)
+          if listing
+            listing.lock!
+
+            if quantity > listing.quantity
+              listing.errors.add(:base, "Requested quantity exceeds available listing quantity")
+              raise ActiveRecord::RecordInvalid.new(listing)
+            end
+
+            order = @clazz.new(model_params.except(:order_items_attributes))
+            order.order_type = :direct_listing
+            order.status = :pending
+            order.listing = listing
+            order.ordered_to = listing.business
+
+            product = listing.supplier_product.product
+            order.order_items.build(
+              listing: listing,
+              product: product,
+              unit: product.unit,
+              quantity: quantity,
+              unit_price: listing.price,
+              status: :pending
+            )
+            order.save!
+
+            new_quantity = listing.quantity - quantity
+            listing.update!(quantity: new_quantity, status: (new_quantity.zero? ? :sold_out : listing.status))
+          else
+            aggregator_listing.lock!
+
+            if quantity > aggregator_listing.quantity
+              aggregator_listing.errors.add(:base, "Requested quantity exceeds available listing quantity")
+              raise ActiveRecord::RecordInvalid.new(aggregator_listing)
+            end
+
+            order = @clazz.new(model_params.except(:order_items_attributes, :listing_id))
+            order.order_type = :direct_listing
+            order.status = :pending
+            order.ordered_to = aggregator_listing.aggregator
+
+            product = aggregator_listing.supplier_product.product
+            order.order_items.build(
+              source: aggregator_listing,
+              product: product,
+              unit: product.unit,
+              quantity: quantity,
+              unit_price: aggregator_listing.price,
+              status: :pending
+            )
+            order.save!
+
+            new_quantity = aggregator_listing.quantity - quantity
+            aggregator_listing.update!(quantity: new_quantity, status: (new_quantity.zero? ? :sold_out : aggregator_listing.status))
           end
-
-          order = @clazz.new(model_params.except(:order_items_attributes))
-          order.order_type = :direct_listing
-          order.status = :pending
-          order.listing = listing
-          order.ordered_to = listing.business
-
-          product = listing.supplier_product.product
-          order.order_items.build(
-            listing: listing,
-            product: product,
-            unit: product.unit,
-            quantity: quantity,
-            unit_price: listing.price,
-            status: :pending
-          )
-          order.save!
-
-          new_quantity = listing.quantity - quantity
-          listing.update!(quantity: new_quantity, status: (new_quantity.zero? ? :sold_out : listing.status))
         end
 
         order = @clazz.includes(eager_loaded_associations).find(order.id) if eager_loaded_associations.present?
@@ -170,7 +338,7 @@ module Dscf
       def model_params
         @model_params ||= params.require(:order).permit(
           :quotation_id, :listing_id, :user_id, :ordered_by_id, :ordered_to_id, :delivery_order_id, :dropoff_address_id,
-          :order_type, :status, :fulfillment_type, :payment_method, :received_bank_name, :transaction_reference,
+          :order_type, :status, :fulfillment_type, :payment_method, :received_bank_name, :transaction_reference, :listing_type,
           order_items_attributes: [ :id, :quotation_item_id, :listing_id, :product_id, :unit_id, :quantity, :unit_price, :status, :_destroy ]
         )
         @model_params[:payment_method] = normalize_payment_method(@model_params[:payment_method]) if @model_params.key?(:payment_method)
@@ -183,7 +351,7 @@ module Dscf
 
       def default_serializer_includes
         {
-          index: [ :user, :ordered_by, :ordered_to, :quotation, order_items: [ :product ] ],
+          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 ]

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

@@ -1,7 +1,18 @@
 module Dscf::Marketplace
   class Order < ApplicationRecord
     enum :order_type, {rfq_based: 0, direct_listing: 1}
-    enum :status, {pending: 0, confirmed: 1, processing: 2, completed: 3, cancelled: 4}
+    # Workflow statuses aligned with requirements doc for Sprint 2 order management
+    enum :status, {
+      pending: 0,                    # initial / validating
+      validating: 1,
+      splitting: 2,
+      waiting_supplier_confirmation: 3,
+      waiting_retailer_confirmation: 4,
+      confirmed: 5,
+      processing: 6,                 # legacy / fulfillment
+      completed: 7,
+      cancelled: 8
+    }
     enum :fulfillment_type, {self_pickup: 0, delivery: 1}
     enum :payment_method, {cash: 0, credit: 1, bank_transfer: 2}, default: :cash
 
@@ -46,7 +57,7 @@ module Dscf::Marketplace
 
       attributes = {
         order_type: :rfq_based,
-        status: :processing,
+        status: :validating,
         fulfillment_type: dropoff_address.present? ? :delivery : :self_pickup,
         quotation: quotation,
         user: quotation.request_for_quotation.user, # Keep for backward compatibility
@@ -66,19 +77,21 @@ module Dscf::Marketplace
           unit: item.unit,
           quantity: item.quantity,
           unit_price: item.unit_price,
-          status: :pending
+          status: :pending,
+          validation_status: :validated # initial from accepted quote; validation can re-run
         )
       end
 
       order
     end
 
+
     def self.create_from_listing(listing, user, quantity, dropoff_address = nil, payment_method = nil)
       return nil unless listing.visible? && quantity <= listing.quantity
 
       attributes = {
         order_type: :direct_listing,
-        status: :pending,
+        status: :validating,
         fulfillment_type: dropoff_address.present? ? :delivery : :self_pickup,
         listing: listing,
         user: user, # Keep for backward compatibility
@@ -97,12 +110,14 @@ module Dscf::Marketplace
         unit: listing.supplier_product.product.unit,
         quantity: quantity,
         unit_price: listing.price,
-        status: :pending
+        status: :pending,
+        validation_status: :validated
       )
 
       order
     end
 
+
     def total_amount
       # Return stored value if it exists and is greater than 0, otherwise calculate
       stored_value = super
@@ -117,7 +132,7 @@ module Dscf::Marketplace
       if rfq_based?
         quotation&.business
       elsif direct_listing?
-        listing&.business
+        listing&.business || ordered_to
       end
     end
 
@@ -157,10 +172,44 @@ module Dscf::Marketplace
       self.total_amount = order_items.sum { |item| item.quantity * item.unit_price }
     end
 
+    # Workflow helpers for Sprint 2 order validation + splitting
+    def validating?
+      pending? || status.to_s == "processing"
+    end
+
+    def all_items_validated?
+      order_items.all? { |i| i.validation_status == "validated" }
+    end
+
+    def validation_summary
+      order_items.group_by(&:validation_status).transform_values(&:count)
+    end
+
+    def mark_splitting!
+      update!(status: :splitting)
+    end
+
+    def mark_waiting_supplier_confirmation!
+      update!(status: :waiting_supplier_confirmation)
+    end
+
+    def mark_waiting_retailer_confirmation!
+      update!(status: :waiting_retailer_confirmation)
+    end
+
+    def retailer_can_confirm?
+      waiting_retailer_confirmation? || confirmed? # allow re-confirm safety
+    end
+
+    def supplier_confirmation_complete?
+      # simplistic: all items have source and are confirmed or cancelled
+      order_items.all? { |i| i.source_id.present? && (i.status.to_s == "confirmed" || i.status.to_s == "cancelled") }
+    end
+
   private
 
     def quotation_or_listing_present
-      unless quotation.present? || listing.present?
+      unless quotation.present? || listing.present? || order_items.any? { |item| item.source_type == "Dscf::Marketplace::AggregatorListing" }
         errors.add(:base, "Either quotation or listing must be present")
       end
     end

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

@@ -1,6 +1,12 @@
 module Dscf::Marketplace
   class OrderItem < ApplicationRecord
     enum :status, {pending: 0, confirmed: 1, processing: 2, fulfilled: 3, cancelled: 4}
+    enum :validation_status, {
+      validated: 0,
+      no_longer_listed: 1,
+      price_changed: 2,
+      low_quantity: 3
+    }, default: :validated
 
     delegate :name, :description, :thumbnail_url, :images_urls, to: :product, allow_nil: true
 
@@ -9,6 +15,7 @@ module Dscf::Marketplace
     belongs_to :listing, optional: true
     belongs_to :product
     belongs_to :unit
+    belongs_to :source, polymorphic: true, optional: true
 
     validates :quantity, presence: true, numericality: {greater_than: 0}
     validates :unit_price, presence: true, numericality: {greater_than_or_equal_to: 0}
@@ -19,11 +26,11 @@ module Dscf::Marketplace
 
     # Ransack configuration for secure filtering
     def self.ransackable_attributes(_auth_object = nil)
-      %w[id order_id quotation_item_id listing_id product_id unit_id quantity unit_price status created_at updated_at]
+      %w[id order_id quotation_item_id listing_id product_id unit_id quantity unit_price status validation_status validation_note resolved_unit_price resolved_quantity source_type source_id created_at updated_at]
     end
 
     def self.ransackable_associations(_auth_object = nil)
-      %w[order quotation_item listing product unit]
+      %w[order quotation_item listing product unit source]
     end
 
     def subtotal
@@ -49,8 +56,8 @@ module Dscf::Marketplace
     private
 
     def quotation_item_or_listing_present
-      unless quotation_item.present? || listing.present?
-        errors.add(:base, "Either quotation_item or listing must be present")
+      unless quotation_item.present? || listing.present? || (source_type == "Dscf::Marketplace::AggregatorListing" && source_id.present?)
+        errors.add(:base, "Either quotation_item, listing, or aggregator listing source must be present")
       end
     end
   end

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

@@ -20,6 +20,30 @@ module Dscf
       def my_orders?
         user.has_permission?("orders.my_orders")
       end
+
+      def validate?
+        user.has_permission?("orders.validate")
+      end
+
+      def split?
+        user.has_permission?("orders.split")
+      end
+
+      def resolve_item?
+        user.has_permission?("orders.resolve_item")
+      end
+
+      def supplier_confirm?
+        user.has_permission?("orders.supplier_confirm")
+      end
+
+      def retailer_confirm?
+        user.has_permission?("orders.confirm") # or dedicated permission
+      end
+
+      def show?
+        user.has_permission?("orders.show") || user.has_permission?("orders.filter") || user.super_admin?
+      end
     end
   end
 end

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

@@ -3,7 +3,8 @@ module Dscf
     class OrderItemSerializer < ActiveModel::Serializer
       attributes :id, :order_id, :quotation_item_id, :listing_id,
         :product_id, :unit_id, :quantity, :unit_price,
-        :status, :created_at, :updated_at,
+        :status, :validation_status, :validation_note, :resolved_unit_price, :resolved_quantity,
+        :source_type, :source_id, :source_name, :created_at, :updated_at,
         :subtotal, :product_name, :unit_name, :thumbnail_url, :images_urls
 
       belongs_to :order
@@ -11,6 +12,23 @@ module Dscf
       belongs_to :listing
       belongs_to :product
       belongs_to :unit
+
+      def source_name
+        return nil unless object.source
+        case object.source_type
+        when 'Dscf::Marketplace::SubSupplier'
+          object.source.try(:business_name) || object.source.try(:name)
+        when 'Dscf::Marketplace::Supplier'
+          object.source.try(:name)
+        when 'Dscf::Core::Business'
+          object.source.try(:name)
+        else
+          object.source.try(:name) || object.source.try(:business_name)
+        end
+      end
+
+      # Note: source association is polymorphic; use source_name + source_* attrs for most clients.
+      # belongs_to :source would be possible but we keep it attribute-based for simplicity.
     end
   end
 end

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

@@ -2,7 +2,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,
-        :order_type, :status, :fulfillment_type, :payment_method, :received_bank_name, :transaction_reference, :total_amount,
+        :order_type, :status, :workflow_status, :has_validation_issues, :fulfillment_type, :payment_method, :received_bank_name, :transaction_reference, :total_amount,
         :buyer_phone, :buyer_email, :seller_name, :seller_phone, :seller_email,
         :created_at, :updated_at
 
@@ -34,6 +34,15 @@ module Dscf
       def seller_email
         object.ordered_to&.contact_email
       end
+
+      # Sprint 2 workflow helpers for new order handling (validation + splitting)
+      def workflow_status
+        object.status
+      end
+
+      def has_validation_issues
+        object.order_items.any? { |i| i.validation_status.present? && i.validation_status.to_s != 'validated' }
+      end
     end
   end
 end

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

@@ -0,0 +1,49 @@
+module Dscf
+  module Marketplace
+    class OrderSplittingService
+      # Handles source assignment and the split operation per requirements.
+      # Sources can be:
+      # - Aggregator self (via aggregator listing or direct)
+      # - Sub-supplier
+      # - Other supplier
+
+      def self.assign_source(order_item, source_type:, source_id:)
+        order_item.source_type = source_type
+        order_item.source_id = source_id
+        order_item.save!
+        order_item
+      end
+
+      def self.perform_split(order)
+        raise "Cannot split order that is not ready" unless order.all_items_validated?
+
+        # Mark items ready for source assignment / supplier confirmation
+        order.order_items.each do |item|
+          if item.status.to_s == "pending" || item.status.to_s == "confirmed"
+            item.status = :processing
+          end
+          item.save! if item.changed?
+        end
+
+        order.mark_waiting_supplier_confirmation!
+
+        order
+      end
+
+      def self.supplier_confirm(order, confirmed: true, reason: nil)
+        if confirmed
+          # In full impl, mark specific allocation as confirmed
+          # For now advance whole if appropriate
+        else
+          order.order_items.where(status: :processing).update_all(status: OrderItem.statuses[:cancelled])
+        end
+
+        # Check if supplier side is done
+        if order.supplier_confirmation_complete?
+          order.mark_waiting_retailer_confirmation!
+        end
+        order
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+module Dscf
+  module Marketplace
+    class OrderValidationService
+      # Validates all items in an order against current listings / availability.
+      # Sets validation_status on each OrderItem per the requirements doc:
+      # validated, no_longer_listed, price_changed, low_quantity
+      # Also populates resolved_* fields where applicable.
+      def self.validate(order)
+        order.order_items.each do |item|
+          validate_item(item)
+        end
+        # Transition order to splitting ready if all validated
+        if order.order_items.all? { |i| i.validation_status == "validated" }
+          order.update!(status: :splitting) if order.validating?
+        end
+        order.reload
+      end
+
+
+      def self.validate_item(item)
+        current_listing = find_current_active_listing(item)
+        return mark_no_longer_listed(item) unless current_listing
+
+        current_price = current_listing.price
+        current_qty   = current_listing.quantity
+
+        if current_price != item.unit_price
+          item.validation_status = :price_changed
+          item.validation_note = "Price changed (listed: #{current_price})"
+          item.resolved_unit_price = item.unit_price # keep original order price by default (user can choose listed later)
+        elsif item.quantity > current_qty
+          item.validation_status = :low_quantity
+          item.validation_note = "Low quantity available (listed: #{current_qty})"
+          item.resolved_quantity = [ item.quantity, current_qty ].min
+        else
+          item.validation_status = :validated
+          item.validation_note = nil
+          item.resolved_unit_price = nil
+          item.resolved_quantity = nil
+        end
+
+        item.save! if item.changed?
+        item
+      end
+
+      private_class_method def self.find_current_active_listing(item)
+        # Prefer the original listing if still active
+        if item.listing && Listing.active.exists?(id: item.listing.id)
+          return item.listing
+        end
+
+        # Fallback: find cheapest active listing for the product
+        Listing.active
+               .joins(:supplier_product)
+               .where(supplier_products: {product_id: item.product_id})
+               .order(price: :asc)
+               .first
+      end
+
+      private_class_method def self.mark_no_longer_listed(item)
+        item.validation_status = :no_longer_listed
+        item.validation_note = "Product no longer listed"
+        item.save! if item.changed?
+        item
+      end
+    end
+  end
+end

data/config/routes.rb

@@ -125,6 +125,12 @@ Dscf::Marketplace::Engine.routes.draw do
       post "cancel"
       post "complete"
       get "invoice"
+      post "validate"
+      post "resolve_item"
+      post "assign_source"
+      post "split"
+      post "supplier_confirm"
+      post "retailer_confirm"
     end
     collection do
       get "my_orders"

data/db/demo_seeds.rb

@@ -22,6 +22,7 @@ Dscf::Marketplace::RfqItem.delete_all
 Dscf::Marketplace::RequestForQuotation.delete_all
 Dscf::Marketplace::AggregatorListing.delete_all
 Dscf::Marketplace::Listing.delete_all
+Dscf::Marketplace::ProductInclusionRequest.delete_all
 Dscf::Marketplace::Agent.delete_all
 Dscf::Marketplace::SupplierProduct.delete_all
 Dscf::Marketplace::Supplier.delete_all
@@ -41,6 +42,13 @@ end
 sa_role = Dscf::Core::Role.find_or_create_by!(code: "SUPER_ADMIN") { |r| r.name = "Super Admin"; r.active = true }
 Dscf::Core::UserRole.find_or_create_by!(user: admin, role: sa_role)
 
+# Ensure SUPER_ADMIN has basic orders permissions (show/filter etc) for detail views etc.
+orders_perms = Dscf::Core::Permission.where(resource: "orders")
+orders_perms.each do |perm|
+  Dscf::Core::RolePermission.find_or_create_by!(role: sa_role, permission: perm)
+end
+puts "  Granted orders permissions to SUPER_ADMIN"
+
 puts "🌱 Seeding demo data..."
 
 # ── Businesses ──
@@ -113,8 +121,85 @@ Dscf::Marketplace::AggregatorListing.create!(aggregator: biz_agg, supplier_produ
 Dscf::Marketplace::AggregatorListing.create!(aggregator: biz_agg, supplier_product: sp6b, price: 420, quantity: 80, status: 0)
 puts "  Aggregator Listings: 3"
 
+# ── Demo Address ──
+address = Dscf::Core::Address.first || Dscf::Core::Address.create!(addressable: admin, address_line_1: "Bole Road, Building 12", city: "Addis Ababa", country: "Ethiopia")
+
+# ── Orders (Direct Purchases) ──
+l1 = Dscf::Marketplace::Listing.first
+if l1
+  order1 = Dscf::Marketplace::Order.create!(
+    order_type: :direct_listing,
+    status: :pending,
+    fulfillment_type: :self_pickup,
+    payment_method: :cash,
+    user: admin,
+    ordered_by: admin,
+    ordered_to: l1.business,
+    listing: l1,
+    total_amount: l1.price * 5
+  )
+  order1.order_items.create!(
+    listing: l1,
+    product: l1.supplier_product.product,
+    unit: l1.supplier_product.product.unit,
+    quantity: 5,
+    unit_price: l1.price,
+    status: :pending
+  )
+end
+
+l2 = Dscf::Marketplace::Listing.last
+if l2 && l2 != l1
+  order2 = Dscf::Marketplace::Order.create!(
+    order_type: :direct_listing,
+    status: :processing,
+    fulfillment_type: :delivery,
+    payment_method: :bank_transfer,
+    user: admin,
+    ordered_by: admin,
+    ordered_to: l2.business,
+    listing: l2,
+    dropoff_address: address,
+    total_amount: l2.price * 10
+  )
+  order2.order_items.create!(
+    listing: l2,
+    product: l2.supplier_product.product,
+    unit: l2.supplier_product.product.unit,
+    quantity: 10,
+    unit_price: l2.price,
+    status: :pending
+  )
+end
+puts "  Orders: 2"
+
+# ── RFQs (Request For Quotations) ──
+rfq1 = Dscf::Marketplace::RequestForQuotation.create!(
+  user: admin,
+  status: :sent,
+  notes: "Looking for 500kg of premium washed Yirgacheffe coffee in bulk for export."
+)
+rfq1.rfq_items.create!(
+  product: p1,
+  unit: p1.unit,
+  quantity: 500
+)
+
+rfq2 = Dscf::Marketplace::RequestForQuotation.create!(
+  user: admin,
+  status: :draft,
+  notes: "Checking prices for traditional Shema fabrics."
+)
+rfq2.rfq_items.create!(
+  product: p4,
+  unit: p4.unit,
+  quantity: 100
+)
+puts "  RFQs: 2"
+
 puts ""
 puts "✅ DONE."
 puts "  6 visible: Yirgacheffe, Sidamo(650), Shema(promoted), Habesha(580), Berbere, Harrar"
 puts "  2 hidden:  Sidamo(720), Habesha(650)"
 puts "  1 pending approval (sp6), 2 pending KYC, 1 inactive agent"
+puts "  2 test orders, 2 test RFQs added for UI validation."

data/db/migrate/20260622000001_add_validation_and_source_fields_to_dscf_marketplace_order_items.rb

@@ -0,0 +1,13 @@
+class AddValidationAndSourceFieldsToDscfMarketplaceOrderItems < ActiveRecord::Migration[8.0]
+  def change
+    add_column :dscf_marketplace_order_items, :validation_status, :integer, default: 0, null: false
+    add_column :dscf_marketplace_order_items, :validation_note, :text
+    add_column :dscf_marketplace_order_items, :resolved_unit_price, :decimal, precision: 15, scale: 6
+    add_column :dscf_marketplace_order_items, :resolved_quantity, :decimal, precision: 15, scale: 6
+    add_column :dscf_marketplace_order_items, :source_type, :string
+    add_column :dscf_marketplace_order_items, :source_id, :bigint
+
+    add_index :dscf_marketplace_order_items, :validation_status, name: "validation_status_on_dm_order_items_idx"
+    add_index :dscf_marketplace_order_items, [:source_type, :source_id], name: "source_on_dm_order_items_idx"
+  end
+end

data/db/seeds.rb

@@ -11,7 +11,7 @@ Dscf::Core::PermissionRegistry.register("dscf-marketplace") do
   resource :rfq_items, actions: %i[index show create update destroy]
   resource :quotations, actions: %i[index show create update destroy accept reject send_quotation my_quotes filter]
   resource :quotation_items, actions: %i[index show create update destroy]
-  resource :orders, actions: %i[index show create update destroy confirm cancel complete my_orders filter]
+  resource :orders, actions: %i[index show create update destroy confirm cancel complete my_orders filter validate resolve_item assign_source split supplier_confirm retailer_confirm]
   resource :order_items, actions: %i[index show create update destroy]
   resource :delivery_orders, actions: %i[
     index show create update destroy pickup start_delivery complete_delivery mark_failed accept summary
@@ -39,3 +39,15 @@ marketplace_permissions.find_each do |permission|
 end
 
 puts "✅ Seeded #{marketplace_permissions.count} marketplace permissions and assigned to USER role."
+
+# Also grant key orders permissions (incl. show for detail views) to SUPER_ADMIN if exists
+sa_role = Dscf::Core::Role.find_by(code: "SUPER_ADMIN")
+if sa_role
+  orders_actions = %i[show filter validate resolve_item assign_source split supplier_confirm retailer_confirm]
+  orders_actions.each do |action|
+    if perm = Dscf::Core::Permission.find_by(resource: "orders", action: action)
+      Dscf::Core::RolePermission.find_or_create_by!(role: sa_role, permission: perm)
+    end
+  end
+  puts "  Also granted key orders.* to SUPER_ADMIN"
+end

data/lib/dscf/marketplace/engine.rb

@@ -33,7 +33,7 @@ module Dscf
               resource :rfq_items, actions: %i[index show create update destroy]
               resource :quotations, actions: %i[index show create update destroy accept reject send_quotation my_quotes filter]
               resource :quotation_items, actions: %i[index show create update destroy]
-              resource :orders, actions: %i[index show create update destroy confirm cancel complete my_orders filter]
+              resource :orders, actions: %i[index show create update destroy confirm cancel complete my_orders filter validate resolve_item assign_source split supplier_confirm retailer_confirm]
               resource :order_items, actions: %i[index show create update destroy]
               resource :delivery_orders, actions: %i[
                 index show create update destroy pickup start_delivery complete_delivery mark_failed accept summary

data/lib/dscf/marketplace/version.rb

@@ -1,5 +1,5 @@
 module Dscf
   module Marketplace
-    VERSION = "0.8.9".freeze
+    VERSION = "0.9.1".freeze
   end
 end

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

@@ -4,6 +4,7 @@ FactoryBot.define do
     quantity { 5 }
     unit_price { 10.0 }
     status { :pending }
+    validation_status { :validated }
     quotation_item { nil } # Don't create by default
     listing { nil } # Don't create by default
 
@@ -45,5 +46,10 @@ FactoryBot.define do
     trait :cancelled do
       status { :cancelled }
     end
+
+    trait :price_changed do
+      validation_status { :price_changed }
+      validation_note { "Price changed" }
+    end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dscf-marketplace
 version: !ruby/object:Gem::Version
-  version: 0.8.9
+  version: 0.9.1
 platform: ruby
 authors:
 - Asrat
 bindir: bin
 cert_chain: []
-date: 2026-06-19 00:00:00.000000000 Z
+date: 2026-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -525,6 +525,8 @@ files:
 - app/services/dscf/marketplace/gebeta_service.rb
 - app/services/dscf/marketplace/invoice_pdf_generator.rb
 - app/services/dscf/marketplace/my_resource_service.rb
+- app/services/dscf/marketplace/order_splitting_service.rb
+- app/services/dscf/marketplace/order_validation_service.rb
 - app/services/dscf/marketplace/rfq_response_service.rb
 - app/services/dscf/marketplace/role_service.rb
 - app/services/dscf/marketplace/route_optimization_service.rb
@@ -586,6 +588,7 @@ files:
 - db/migrate/20260616000010_add_code_to_dscf_marketplace_categories_and_gender_to_dscf_marketplace_agents.rb
 - db/migrate/20260619210001_add_user_id_to_dscf_marketplace_agents.rb
 - db/migrate/20260619210002_add_user_id_to_dscf_marketplace_retailers.rb
+- db/migrate/20260622000001_add_validation_and_source_fields_to_dscf_marketplace_order_items.rb
 - db/seeds.rb
 - lib/dscf/marketplace.rb
 - lib/dscf/marketplace/engine.rb