dscf-marketplace 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6818b94cd7c2f6c55d5e39da13eee317dbfa3879e17d442be6821a50f993659
-  data.tar.gz: 840863a3f380843728489b4b6e6518fa0d5bed4cb73a5dd3bddde05f8c525c56
+  metadata.gz: 16b43241cc7e4a81527b02646b620a5d89ff4836aa1f14877d80a8c20e8b8b69
+  data.tar.gz: 9cf97a1241386f95e9af9088d740cbbf4a69734b40d1f29218d50e002775f20f
 SHA512:
-  metadata.gz: efa76d0e7f656a6af4de6a2fce5923992872da28135c6a8c723f35717926cd1326aad14a10a5a8ce5ce5961f369f0872fb7d4ef3bdfaff3dc1f83c1b90c5177f
-  data.tar.gz: d0f773b3303836c0dec8d963bc5397a93846d26a0ba83adc9625800a1c4c2239afec6e8fc25cdb15e9dfa2c8fcca6152ca4e02d7810a66ebc5b5c5af531e6420
+  metadata.gz: 906229d9cc272a399446d8d997ee880b7b66a1ca404eca3ea0ee6f23ab51ade9c45dfe517a04129cf09c6f1660a3d241637d8ba22405ac4d4ea952bdd959674e
+  data.tar.gz: 64e5345ccf614806d09b410be755e16e8a33ec58793443715f669bdcc934f034da085f78642e2b70638e75c2002df322bc099ce516a53ca6b0a2a470a3be656b

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

@@ -319,71 +319,124 @@ module Dscf
 
       private
 
+      # Builds one or more direct-listing orders from a cart of one or more
+      # listings. Order.ordered_to is a single business, so items are grouped
+      # by the business that fulfils them (a supplier Listing's business, or
+      # an AggregatorListing's aggregator); each group becomes one Order with
+      # one line per item, all created/decremented atomically in one
+      # transaction (a multi-vendor cart either checks out completely or not
+      # at all — mirrors how the single-item path already behaved).
       def create_direct_listing_order
-        listing = nil
-        aggregator_listing = nil
+        resolved_items = resolve_direct_listing_items
+        return if performed? # resolve_direct_listing_items already rendered an error
 
-        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])
+        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
-          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?
+        orders = orders.map { |o| @clazz.includes(eager_loaded_associations).find(o.id) } if eager_loaded_associations.present?
+        includes = default_serializer_includes[:create] || []
+        options = {include: includes} if includes.present?
 
-        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)
+        if orders.size == 1
+          render_success(data: orders.first, serializer_options: options, status: :created)
+        else
+          render_success(data: orders, serializer_options: options, status: :created,
+            meta: {split_by_business: true, order_count: orders.size})
         end
+      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
+
+      # Resolves each cart line to its Listing or AggregatorListing + quantity +
+      # the business it's ordered to. Falls back to the legacy top-level
+      # listing_id/listing_type params when a line doesn't carry its own
+      # (single-item callers built before the cart existed).
+      def resolve_direct_listing_items
+        items_params = model_params[:order_items_attributes]
+        if items_params.blank?
+          render_error(errors: "At least one item is required", status: :unprocessable_entity)
+          return []
+        end
+
+        items_params.map do |item_params|
+          listing_id = item_params[:listing_id] || model_params[:listing_id]
+          listing_type = item_params[:listing_type] || model_params[:listing_type]
+          quantity = item_params[:quantity].to_i
+
+          if quantity <= 0
+            render_error(errors: "Quantity must be greater than 0", status: :unprocessable_entity)
+            return []
+          end
+
+          listing = nil
+          aggregator_listing = nil
+
+          if listing_type == "AggregatorListing"
+            aggregator_listing = Dscf::Marketplace::AggregatorListing.active.find_by(id: listing_id)
+          else
+            listing = Dscf::Marketplace::Listing.active.find_by(id: listing_id)
+            aggregator_listing = Dscf::Marketplace::AggregatorListing.active.find_by(id: listing_id) if listing.blank? && listing_type.blank?
+          end
+
+          if listing.blank? && aggregator_listing.blank?
+            render_error(errors: "Listing is not available", status: :unprocessable_entity)
+            return []
+          end
 
-        order = nil
-        ActiveRecord::Base.transaction do
           if listing
-            listing.lock!
+            {listing: listing, quantity: quantity, ordered_to: listing.business}
+          else
+            {aggregator_listing: aggregator_listing, quantity: quantity, ordered_to: aggregator_listing.aggregator}
+          end
+        end
+      end
+
+      # Locks + validates stock for every item in a business group, builds one
+      # 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)
+        items.each { |ri| (ri[:listing] || ri[:aggregator_listing]).lock! }
 
-            if quantity > listing.quantity
-              listing.errors.add(:base, "Requested quantity exceeds available listing quantity")
-              raise ActiveRecord::RecordInvalid.new(listing)
-            end
+        items.each do |ri|
+          source = ri[:listing] || ri[:aggregator_listing]
+          next unless ri[:quantity] > source.quantity
 
-            order = @clazz.new(model_params.except(:order_items_attributes, :listing_type))
-            order.order_type = :direct_listing
-            order.status = :pending
-            order.listing = listing
-            order.ordered_to = listing.business
+          source.errors.add(:base, "Requested quantity exceeds available listing quantity for #{source.product&.name}")
+          raise ActiveRecord::RecordInvalid.new(source)
+        end
 
+        order = @clazz.new(model_params.except(:order_items_attributes, :listing_id, :listing_type))
+        order.order_type = :direct_listing
+        order.status = :pending
+        order.ordered_to = items.first[:ordered_to]
+        # 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
+        # Order#quotation_or_listing_present).
+        order.listing = items.find { |ri| ri[:listing] }&.dig(:listing)
+
+        items.each do |ri|
+          if ri[:listing]
+            listing = ri[:listing]
             product = listing.supplier_product.product
             order.order_items.build(
               listing: listing,
               product: product,
               unit: product.unit,
-              quantity: quantity,
+              quantity: ri[: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, :listing_type))
-            order.order_type = :direct_listing
-            order.status = :pending
-            order.ordered_to = aggregator_listing.aggregator
-
+            aggregator_listing = ri[:aggregator_listing]
             product = aggregator_listing.product
             # Order lines from the aggregator feed are auto-sourced to the originating
             # AggregatorListing (regardless of source_kind) — the aggregator already
@@ -394,42 +447,33 @@ module Dscf
               source: aggregator_listing,
               product: product,
               unit: product.unit,
-              quantity: quantity,
+              quantity: ri[: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
         end
 
-        order = @clazz.includes(eager_loaded_associations).find(order.id) if eager_loaded_associations.present?
-        includes = default_serializer_includes[:create] || []
-        options = {include: includes} if includes.present?
-        render_success(data: order, serializer_options: options, status: :created)
-      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)
+        order.save!
+
+        items.each do |ri|
+          source = ri[:listing] || ri[:aggregator_listing]
+          new_quantity = source.quantity - ri[:quantity]
+          source.update!(quantity: new_quantity, status: (new_quantity.zero? ? :sold_out : source.status))
+        end
+
+        order
       end
 
       def direct_listing_request?
         %w[direct_listing 1].include?(model_params[:order_type].to_s)
       end
 
-      def direct_listing_quantity
-        item = model_params[:order_items_attributes]&.first
-        (item&.[](:quantity) || item&.[]("quantity")).to_i
-      end
-
       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, :listing_type,
-          order_items_attributes: [ :id, :quotation_item_id, :listing_id, :product_id, :unit_id, :quantity, :unit_price, :status, :_destroy ]
+          order_items_attributes: [ :id, :quotation_item_id, :listing_id, :listing_type, :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)
         @model_params

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

@@ -5,7 +5,7 @@ module Dscf
         :product_id, :unit_id, :quantity, :unit_price,
         :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,
+        :subtotal, :product_name, :product_sku, :unit_name, :thumbnail_url, :images_urls,
         :supplier_adjusted_unit_price, :supplier_adjusted_quantity, :supplier_adjustment_note
 
       belongs_to :order
@@ -14,6 +14,10 @@ module Dscf
       belongs_to :product
       belongs_to :unit
 
+      def product_sku
+        object.product&.sku
+      end
+
       def source_name
         return nil unless object.source
         case object.source_type

data/lib/dscf/marketplace/version.rb

@@ -1,5 +1,5 @@
 module Dscf
   module Marketplace
-    VERSION = "0.12.0".freeze
+    VERSION = "0.13.0".freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dscf-marketplace
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Asrat