dscf-marketplace 0.7.2 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81c4fc2b3cbb08308f4da22f26a56d9d7a3ca197325c340d491dacfe4adbaa6f
-  data.tar.gz: 1c89213f1171138ea6efc0c8566a60a6937348c7c934cfacc8ccecd53f35c310
+  metadata.gz: 6868f5b7cbade52d287939591c2011a7140b76eda6f3223ba7f66a3a51fb3d08
+  data.tar.gz: dd56581029c76743ec281f4de717f00410a38d780b68ad57a13a11cd36e8ddd2
 SHA512:
-  metadata.gz: 2f812ce7f37138fbf88cfed6c03233193b12fef8a194f8cd632c8006b86814201af5877122679c9634920bcb4ba73291e7ea2171009be15265a38cd9dad524c5
-  data.tar.gz: e6ffd5232a4f43d7d4020f789a0ce6b400858ffd2801192a7008dab0ffd4f66f3dcd3488c0364f26d8861c2b451eb2d6f1f2edcfbd9b990363cd121b6905a3b6
+  metadata.gz: 1d7737babebba09f37154720fea2502464ad2c71cac4007114a40d3d22529efc664091d8f96a26086140bdd66696cfffa0bf7b1d828b6764f833e1497327940e
+  data.tar.gz: a2f2b76706da91f693a76cbe47e6b913b97819777f81ef3dacd354a83e59d8106dfcca11402af054493c1dcda586edca8b998858adbcfaeb11297aea302ffff2

data/app/controllers/concerns/dscf/marketplace/demo_permission_bypass.rb

@@ -0,0 +1,44 @@
+module Dscf
+  module Marketplace
+    module DemoPermissionBypass
+      extend ActiveSupport::Concern
+
+      included do
+        before_action :demo_bypass_permissions!
+      end
+
+      def bypass_permissions_for_demo?
+        true
+      end
+
+      def pundit_user
+        user = current_user
+        return nil unless user
+
+        bypass_permissions_on_user!(user)
+      end
+
+      def authorize_review_action!
+        skip_authorization if respond_to?(:skip_authorization, true)
+      end
+
+      private
+
+      def demo_bypass_permissions!
+        skip_authorization if respond_to?(:skip_authorization, true)
+        skip_policy_scope if respond_to?(:skip_policy_scope, true)
+      end
+
+      def bypass_permissions_on_user!(user)
+        return user if user.instance_variable_defined?(:@_banking_demo_permission_bypass)
+
+        user.define_singleton_method(:has_permission?) { |_permission_code| true }
+        user.define_singleton_method(:can?) { |permission_code| has_permission?(permission_code) }
+        user.define_singleton_method(:super_admin?) { true }
+        user.instance_variable_set(:@_banking_demo_permission_bypass, true)
+
+        user
+      end
+    end
+  end
+end

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

@@ -1,6 +1,42 @@
 module Dscf
   module Marketplace
-    class ApplicationController < Dscf::Core::ApplicationController
+    class ApplicationController < ActionController::API
+      include Dscf::Core::Authenticatable
+      include Dscf::Core::JsonResponse
+      before_action :authenticate_user
+      before_action :demo_bypass_permissions!
+
+      # TEMPORARY DEMO BYPASS:
+      # Bypass marketplace authorization checks for authenticated users only.
+      # Remove after the demo.
+      def bypass_permissions_for_demo?
+        true
+      end
+
+      def pundit_user
+        user = current_user
+        return nil unless user
+
+        bypass_permissions_on_user!(user)
+      end
+
+      private
+
+      def demo_bypass_permissions!
+        skip_authorization if respond_to?(:skip_authorization, true)
+        skip_policy_scope if respond_to?(:skip_policy_scope, true)
+      end
+
+      def bypass_permissions_on_user!(user)
+        return user if user.instance_variable_defined?(:@_banking_demo_permission_bypass)
+
+        user.define_singleton_method(:has_permission?) { |_permission_code| true }
+        user.define_singleton_method(:can?) { |permission_code| has_permission?(permission_code) }
+        user.define_singleton_method(:super_admin?) { true }
+        user.instance_variable_set(:@_banking_demo_permission_bypass, true)
+
+        user
+      end
     end
   end
 end

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

@@ -3,6 +3,24 @@ module Dscf
     class OrdersController < ApplicationController
       include Dscf::Core::Common
 
+      def create
+        authorize @clazz.new, :create?
+
+        return create_direct_listing_order if direct_listing_request?
+
+        obj = @clazz.new(model_params)
+        if obj.save
+          obj = @clazz.includes(eager_loaded_associations).find(obj.id) if eager_loaded_associations.present?
+          includes = default_serializer_includes[:create] || []
+          options = {include: includes} if includes.present?
+          render_success(data: obj, serializer_options: options, status: :created)
+        else
+          render_error(errors: obj.errors.full_messages.join(", "), status: :unprocessable_entity)
+        end
+      rescue => e
+        render_error(error: e.message)
+      end
+
       def filter
         authorize @clazz.new, :filter?
         orders = @clazz.all
@@ -48,7 +66,7 @@ module Dscf
         @obj = find_record
         authorize @obj, :complete?
         if @obj.can_be_completed? && @obj.update(status: :completed)
-          @obj.order_items.update_all(status: OrderItem.statuses[:completed])
+          @obj.order_items.update_all(status: OrderItem.statuses[:fulfilled])
           render_success("orders.success.completed", data: @obj)
         else
           render_error("orders.errors.complete_failed")
@@ -70,6 +88,67 @@ module Dscf
 
       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
+
+        quantity = direct_listing_quantity
+        return render_error(errors: "Quantity must be greater than 0", status: :unprocessable_entity) unless quantity.positive?
+
+        if quantity > listing.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)
+          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?
+        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)
+      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
         params.require(:order).permit(
           :quotation_id, :listing_id, :user_id, :ordered_by_id, :ordered_to_id, :delivery_order_id, :dropoff_address_id,

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

@@ -9,7 +9,7 @@ module Dscf::Marketplace
     def assign_driver(delivery_order, driver)
       raise ArgumentError, "Delivery order is required" unless delivery_order
       raise ArgumentError, "Driver is required" unless driver
-      
+
       validate_assignment(delivery_order)
 
       delivery_order.driver_id = driver.id
@@ -35,9 +35,15 @@ module Dscf::Marketplace
         delivery_order = create_delivery_order(vehicle_type, pickup_address, delivery_notes)
         create_delivery_stops_and_items(delivery_order, orders, pickup_address)
         associate_orders_with_delivery(delivery_order, orders)
-        
-        # Optimize route using Gebeta Maps
-        RouteOptimizationService.new(delivery_order).optimize!
+
+        # Best-effort route optimization using Gebeta Maps.
+        begin
+          RouteOptimizationService.new(delivery_order).optimize!
+        rescue StandardError => e
+          Rails.logger.warn(
+            "[DeliveryOrderService] Route optimization skipped for delivery_order=#{delivery_order.id}: #{e.class} - #{e.message}"
+          )
+        end
 
         delivery_order
       end
@@ -79,7 +85,7 @@ module Dscf::Marketplace
     def create_delivery_stops_and_items(delivery_order, orders, pickup_address)
       # Group orders by dropoff address to create stops
       orders_by_address = orders.group_by(&:dropoff_address_id)
-      
+
       orders_by_address.each do |dropoff_address_id, address_orders|
         # Create stop
         stop = DeliveryStop.create!(
@@ -87,7 +93,7 @@ module Dscf::Marketplace
           dropoff_address_id: dropoff_address_id,
           status: :pending
         )
-        
+
         # Create items for this stop
         address_orders.each do |order|
           order.order_items.reload.each do |order_item|

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

@@ -10,83 +10,71 @@ module Dscf
       def optimize!
         return unless delivery_order.pickup_address && delivery_order.delivery_stops.any?
 
-        # 1. Collect Coordinates
-        # Format: [[pickup_lat, pickup_lng], [stop1_lat, stop1_lng], ...]
-        pickup_coords = [delivery_order.pickup_address.latitude.to_f, delivery_order.pickup_address.longitude.to_f]
-        
-        # We map stops to their dropoff coordinates. 
-        # We need to keep track of the mapping between original index and stop ID to re-order later.
-        stops = delivery_order.delivery_stops.includes(:dropoff_address).to_a
-        stop_coords = stops.map { |stop| [stop.dropoff_address.latitude.to_f, stop.dropoff_address.longitude.to_f] }
-        
-        all_locations = [pickup_coords] + stop_coords
-
-        # 2. Call Gebeta API
-        response = GebetaService.new.tsp(all_locations)
-
-        # 3. Process Response
-        
-        # New Response Format:
-        # {
-        #   "best_order": [
-        #     {"lat":..., "lon":...},               # Start (Pickup)
-        #     {"lat":..., "original_index": 2},     # Stop A
-        #     {"lat":..., "original_index": 1}      # Stop B
-        #   ],
-        #   "total_distance": 13.474, # In KM? Diagnostic showed 13.474 for small distance. Need to verify unit.
-        #   "time_taken": 1033.263,
-        #   "Direction": [[lat,lon], ...]
-        # }
-        
-        # 'best_order' includes the start point at index 0 (usually without original_index or it's 0/1 based?)
-        # Based on diagnostic: "original_index": 2 for the 3rd point (index 2).
-        # So original_index is 0-based index from the input array.
-        
-        best_order = response["best_order"]
-        
-        # Filter out the pickup location (which should be the first one, or original_index == 0)
-        # We only want to re-sequence the STOPS.
-        # Stops in 'stops' array correspond to input indices 1..N.
-        
-        ordered_stops_data = best_order.select { |node| node["original_index"].to_i > 0 }
-        
+        stops = []
+        locations = []
+
+        stops = ordered_stops
+        locations = build_locations(stops)
+
+        apply_remote_optimization(stops, locations)
+      rescue StandardError => e
+        Rails.logger.warn(
+          "[RouteOptimizationService] Falling back to local route for delivery_order=#{delivery_order.id}: #{e.class} - #{e.message}"
+        )
+
+        apply_local_fallback(stops, locations)
+      end
+
+      private
+
+      def apply_remote_optimization(stops, locations)
+        response = GebetaService.new.tsp(locations)
+        best_order = Array(response["best_order"])
+        ordered_stops_data = best_order.select { |node| node["original_index"].to_i.positive? }
+
         ActiveRecord::Base.transaction do
           ordered_stops_data.each_with_index do |node, seq_num|
-            original_idx = node["original_index"]
-            # stops array is 0-indexed, corresponding to input indices 1, 2, 3...
-            # If original_idx is 1, it means stops[0]. If 2, stops[1].
+            original_idx = node["original_index"].to_i
             stop = stops[original_idx - 1]
-            
-            if stop
-              stop.update!(sequence_number: seq_num + 1)
-            end
+            stop.update!(sequence_number: seq_num + 1) if stop
           end
 
-          # Update DeliveryOrder metrics
-          # Check units: 
-          # time_taken: 1033.263 (likely seconds ~ 17 mins for decent distance).
-          # total_distance: 13.474. If this is KM, it's reasonable. (Distance between 9.02,38.80 and 9.028,38.75 is ~ small).
-          # If meters, 13 meters is too small. 1000 seconds for 13 meters is wrong.
-          # So total_distance is likely KM.
-          
           distance_km = response["total_distance"].to_f
-          
+
           delivery_order.update!(
             estimated_delivery_time: Time.current + response["time_taken"].to_f.seconds,
-            estimated_delivery_price: calculate_price(distance_km * 1000), # pass meters to calc
-            optimized_route: response["Direction"] 
+            estimated_delivery_price: calculate_price(distance_km * 1000),
+            optimized_route: response["Direction"]
           )
         end
       end
 
-      private
+      def apply_local_fallback(stops, locations)
+        ActiveRecord::Base.transaction do
+          stops.each_with_index do |stop, index|
+            stop.update!(sequence_number: index + 1)
+          end
+
+          delivery_order.update!(optimized_route: locations)
+        end
+      end
+
+      def ordered_stops
+        delivery_order.delivery_stops.includes(:dropoff_address).order(:id).to_a
+      end
+
+      def build_locations(stops)
+        pickup_coords = [ delivery_order.pickup_address.latitude.to_f, delivery_order.pickup_address.longitude.to_f ]
+        stop_coords = stops.map { |stop| [ stop.dropoff_address.latitude.to_f, stop.dropoff_address.longitude.to_f ] }
+
+        [ pickup_coords ] + stop_coords
+      end
 
-      # Placeholder pricing logic
       def calculate_price(distance_meters)
         base_rate = 50.0
-        km_rate = 10.0 # 10 ETB per km
+        km_rate = 10.0
         distance_km = distance_meters / 1000.0
-        
+
         base_rate + (distance_km * km_rate)
       end
     end

data/lib/dscf/marketplace/version.rb

@@ -1,5 +1,5 @@
 module Dscf
   module Marketplace
-    VERSION = "0.7.2".freeze
+    VERSION = "0.7.4".freeze
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dscf-marketplace
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.7.4
 platform: ruby
 authors:
 - Asrat
 bindir: bin
 cert_chain: []
-date: 2026-03-10 00:00:00.000000000 Z
+date: 2026-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -416,6 +416,7 @@ extra_rdoc_files: []
 files:
 - MIT-LICENSE
 - Rakefile
+- app/controllers/concerns/dscf/marketplace/demo_permission_bypass.rb
 - app/controllers/dscf/marketplace/application_controller.rb
 - app/controllers/dscf/marketplace/categories_controller.rb
 - app/controllers/dscf/marketplace/delivery_order_items_controller.rb