spree_cm_commissioner 2.3.0.pre.pre20 → 2.3.0.pre.pre21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f73314825dc2db092e1255e49203ceb8e1071e0dac1c11803d8343b8dc37fafa
-  data.tar.gz: 32c25a52977a2f20591b8650ece48a69e517845b3431b79e3c57da63cf8ddb50
+  metadata.gz: cfed0f91fdd9c96b14fdd179bfca7cdce626d8268468b3d6a22b7622c8aee3f5
+  data.tar.gz: b2e6802c655db5e83abb39e20f3478b0068a79a847744e1a812b7f22191ac345
 SHA512:
-  metadata.gz: 1bd90e765ad3bdd9f28b6199900a7ea4f587dd11732af3a03c8bd3b13d234eb83765740de6619223dd03cbe77cb4b865c82c12c8a1845bc05157977463bf17d6
-  data.tar.gz: ef7380007df4d1ee55da2fea5d2d9cb2b3b5d931c44d17a955b9925c338f8a6285df1df59459b643152cd03fda819bcdd264075bc87eaaff5961e93d08b84606
+  metadata.gz: 7cdfd95dbabf86d3201d45b5ba89987d572850707f652a4b55432c08b4245604dbb4f3b8b9edf62661d3c78c7b65b8c0cddfffb00a331bb1f4721c56ce034f97
+  data.tar.gz: c7c061df9dc72b3c0fc8cc49b01fbb424b65f75a67bca9586c743093a20508dc6a7be1adaa219d1d1ca32c0cef86c3976ae88abae5d19241f257b6b3e2098cd1

data/Gemfile.lock

@@ -34,7 +34,7 @@ GIT
 PATH
   remote: .
   specs:
-    spree_cm_commissioner (2.3.0.pre.pre20)
+    spree_cm_commissioner (2.3.0.pre.pre21)
       activerecord-multi-tenant
       activerecord_json_validator (~> 2.1, >= 2.1.3)
       aws-sdk-cloudfront

data/app/controllers/spree/api/v2/storefront/trip_search_controller.rb

@@ -12,6 +12,7 @@ module Spree
                   origin_id: params[:origin_id],
                   destination_id: params[:destination_id],
                   date: params[:date],
+                  route_type: params[:route_type],
                   vendor_id: params[:vendor_id],
                   number_of_guests: params[:number_of_guests],
                   params: params
@@ -36,6 +37,7 @@ module Spree
               params[:origin_id],
               params[:destination_id],
               params[:date],
+              params[:route_type],
               params[:vendor_id],
               params[:number_of_guests],
               resource_includes&.sort&.join(','),
@@ -62,6 +64,7 @@ module Spree
               'trips.vendor',
               'trips.vendor.logo',
               'trips.vehicle',
+              'trips.vehicle.vehicle_photos',
               'trips.amenities'
             ]
           end

data/app/interactors/spree_cm_commissioner/google_routes_distance_calculator.rb

@@ -0,0 +1,211 @@
+module SpreeCmCommissioner
+  # Interactor wrapper around Google Routes API v2 to compute trip details.
+  #
+  # Inputs via context:
+  # - origin: { lat:, lng: } | "lat,lng" | [lat, lng]
+  # - destination: { lat:, lng: } | "lat,lng" | [lat, lng]
+  # - Optional arrays: waypoints, pickups, dropoffs (same point formats)
+  # - Optional boolean: optimize (default: true) to let Google reorder waypoints
+  #
+  # Outputs via context on success:
+  # - distance_km (Float)
+  # - ordered_waypoints (Array<Hash>)
+  # - ordered_points (Array<Hash>)
+  # - directions_url (String)
+  # - estimated_time_minutes (Integer) when optimize is true
+  #
+  # On failure, context.fail!(message: ...) is called.
+  class GoogleRoutesDistanceCalculator < BaseInteractor
+    delegate :origin, :destination, :waypoints, :pickups, :dropoffs, :optimize, to: :context
+
+    def call
+      initialize_points_and_options
+
+      via_points = combined_via_points
+      json = fetch_routes_for(@origin, @destination, via_points)
+
+      if json.nil?
+        context.fail!(message: 'Failed to fetch routes from Google API')
+        return
+      end
+
+      if json['error']
+        error_message = json.dig('error', 'message') || json.dig('error', 'status')
+        context.fail!(message: "Google Routes API error: #{error_message}")
+        return
+      end
+
+      route = json['routes']&.first
+      context.fail!(message: 'No route found') if route.nil?
+
+      distance_meters = total_distance_of(route)
+      duration_seconds = total_duration_of(route)
+      ordered_waypoints = build_ordered_waypoints_from(route, via_points)
+
+      ordered_points = [@origin] + ordered_waypoints + [@destination]
+
+      context.distance_km = (distance_meters / 1000.0).round(3)
+      context.ordered_waypoints = ordered_waypoints
+      context.ordered_points = ordered_points
+      context.directions_url = build_human_link(ordered_waypoints)
+      # Only expose estimated time when optimize is enabled (per requirement)
+      context.estimated_time_minutes = (@optimize ? (duration_seconds / 60.0).round : nil)
+    end
+
+    private
+
+    def initialize_points_and_options
+      context.fail!(message: 'origin is required') if origin.blank?
+      context.fail!(message: 'destination is required') if destination.blank?
+
+      begin
+        @origin = normalize_point(origin)
+        @destination = normalize_point(destination)
+
+        extra_waypoints = Array(waypoints).compact
+        pickups_points = Array(pickups).compact
+        dropoff_points = Array(dropoffs).compact
+
+        @extra_waypoints = extra_waypoints.map { |p| normalize_point(p) }
+        @pickups_points = pickups_points.map { |p| normalize_point(p) }
+        @dropoff_points = dropoff_points.map { |p| normalize_point(p) }
+      rescue ArgumentError => e
+        context.fail!(message: e.message)
+      end
+
+      @optimize = optimize.nil? ? true : !!optimize
+    end
+
+    def google_map_key
+      @google_map_key ||= ENV.fetch('GOOGLE_MAP_KEY')
+    end
+
+    def fetch_routes_for(from, to_point, via_waypoints)
+      url = "https://routes.googleapis.com/directions/v2:computeRoutes?key=#{google_map_key}"
+      headers = {
+        'Content-Type' => 'application/json',
+        'X-Goog-FieldMask' => [
+          'routes.duration',
+          'routes.distanceMeters',
+          'routes.legs',
+          'routes.optimizedIntermediateWaypointIndex',
+          'routes.legs.duration',
+          'routes.legs.distanceMeters'
+        ].join(',')
+      }
+      body = build_request_body(from: from, to: to_point, via_waypoints: via_waypoints)
+
+      response = Faraday.post(url, body.to_json, headers)
+      return nil unless response.success?
+
+      JSON.parse(response.body)
+    end
+
+    def build_request_body(from:, to:, via_waypoints: [])
+      request = {
+        origin: {
+          location: {
+            latLng: {
+              latitude: from[:lat],
+              longitude: from[:lng]
+            }
+          }
+        },
+        destination: {
+          location: {
+            latLng: {
+              latitude: to[:lat],
+              longitude: to[:lng]
+            }
+          }
+        },
+        travelMode: 'DRIVE',
+        routingPreference: 'TRAFFIC_AWARE',
+        computeAlternativeRoutes: false,
+        units: 'METRIC'
+      }
+
+      if via_waypoints.any?
+        intermediates = via_waypoints.map do |point|
+          {
+            location: {
+              latLng: {
+                latitude: point[:lat],
+                longitude: point[:lng]
+              }
+            }
+          }
+        end
+
+        request[:optimizeWaypointOrder] = true if @optimize
+
+        request[:intermediates] = intermediates
+      end
+
+      request
+    end
+
+    def normalize_point(point)
+      return { lat: point[:lat].to_f, lng: point[:lng].to_f } if point.is_a?(Hash)
+      return { lat: point[0].to_f, lng: point[1].to_f } if point.is_a?(Array) && point.size == 2
+
+      if point.is_a?(String) && point.include?(',')
+        lat_str, lng_str = point.split(',', 2)
+        return { lat: lat_str.to_f, lng: lng_str.to_f }
+      end
+      raise ArgumentError, 'Invalid point format; expected { lat:, lng: }'
+    end
+
+    def same_point?(point_a, point_b)
+      (point_a[:lat].to_f - point_b[:lat].to_f).abs < 1e-9 && (point_a[:lng].to_f - point_b[:lng].to_f).abs < 1e-9
+    end
+
+    def combined_via_points
+      points = @extra_waypoints + @pickups_points + @dropoff_points
+      points.reject { |p| same_point?(p, @origin) || same_point?(p, @destination) }
+    end
+
+    def total_distance_of(route)
+      # Routes API v2 provides distanceMeters at route level
+      distance = route['distanceMeters']
+      return distance.to_i if distance
+
+      # Fallback: sum from legs if route-level distance not available
+      route.fetch('legs', []).sum { |leg| leg['distanceMeters'].to_i }
+    end
+
+    def total_duration_of(route)
+      # Routes API v2 provides duration at route level as string "3600s"
+      duration_str = route['duration']
+      return duration_str.to_s.gsub('s', '').to_i if duration_str
+
+      # Fallback: sum from legs if route-level duration not available
+      route.fetch('legs', []).sum do |leg|
+        leg_duration = leg['duration']
+        leg_duration ? leg_duration.to_s.gsub('s', '').to_i : 0
+      end
+    end
+
+    def build_ordered_waypoints_from(route, base_waypoints)
+      optimized_indices = route['optimizedIntermediateWaypointIndex'] || []
+      return base_waypoints if optimized_indices.empty? || !@optimize
+
+      optimized_indices.map { |idx| base_waypoints[idx] }
+    end
+
+    def format_point(point)
+      "#{point[:lat]},#{point[:lng]}"
+    end
+
+    def build_human_link(ordered_waypoints)
+      params = {
+        api: 1,
+        origin: format_point(@origin),
+        destination: format_point(@destination),
+        travelmode: 'driving'
+      }
+      params[:waypoints] = ordered_waypoints.map { |p| format_point(p) }.join('|') if ordered_waypoints.any?
+      "https://www.google.com/maps/dir/?#{URI.encode_www_form(params)}"
+    end
+  end
+end

data/app/interactors/spree_cm_commissioner/intercity_taxi_order_creator.rb

@@ -49,10 +49,21 @@ module SpreeCmCommissioner
           :passenger_count,
           :pickup_oob_confirmed,
           :drop_off_oob_confirmed,
+          :distance_km,
+          :directions_url,
+          :ordered_points,
+          :base_km,
+          :detour_pickup_km,
+          :detour_dropoff_km,
+          :extra_pickup_km,
+          :extra_dropoff_km,
+          :extra_pickup_charge_usd,
+          :extra_dropoff_charge_usd,
+          :estimated_time_minutes,
           { guests_attributes: %i[
             first_name last_name gender age nationality_id
           ]
-}
+          }
         ]
       )
 
@@ -61,25 +72,54 @@ module SpreeCmCommissioner
     end
 
     def process_line_items_attributes(params)
-      date_param = raw_params[:date] || Date.current.to_s
+      date_param = request_date
 
       load_variant
 
       params[:line_items_attributes].each_value do |item|
+        normalize_coordinate_group!(item, :pickup, :pickup_lat, :pickup_lng)
+        normalize_coordinate_group!(item, :drop_off, :drop_off_lat, :drop_off_lng)
+
         pickup_time_minutes = item[:from_date]
-        combined_datetime = "#{date_param} #{pickup_time_minutes}"
-
-        item[:from_date] = combined_datetime
-        item[:to_date] = combined_datetime
-        item[:variant_id] = @variant.id
-        item[:vendor_id] = current_vendor.id
-        item[:quantity] = 1
-        item[:currency] = 'USD'
-        item[:direction] = 'outbound'
-        item[:trip_id] = trip.id
+        combined_datetime = build_datetime(date_param, pickup_time_minutes)
+
+        assign_default_line_item_fields!(item, combined_datetime)
       end
     end
 
+    def request_date
+      raw_params[:date] || Date.current.to_s
+    end
+
+    def build_datetime(date_string, time_string)
+      "#{date_string} #{time_string}"
+    end
+
+    def normalize_coordinate_group!(item, group_key, lat_key, lng_key)
+      group = item[group_key]
+      return if group.blank?
+
+      if group.is_a?(Array)
+        item[lat_key], item[lng_key] = group
+      elsif group.is_a?(ActionController::Parameters) || group.is_a?(Hash)
+        item[lat_key] = group[:lat] || group['lat']
+        item[lng_key] = group[:lng] || group['lng']
+      end
+
+      item.delete(group_key)
+    end
+
+    def assign_default_line_item_fields!(item, combined_datetime)
+      item[:from_date] = combined_datetime
+      item[:to_date] = combined_datetime
+      item[:variant_id] = @variant.id
+      item[:vendor_id] = current_vendor.id
+      item[:quantity] = 1
+      item[:currency] = 'USD'
+      item[:direction] = 'outbound'
+      item[:trip_id] = trip.id
+    end
+
     def create_order
       context.order = Spree::Order.create(context.order_params)
 

data/app/interactors/spree_cm_commissioner/trip_distance_calculator.rb

@@ -0,0 +1,165 @@
+module SpreeCmCommissioner
+  # Computes trip distance details and pricing payload.
+  #
+  # Inputs via context:
+  # - origin: { lat:, lng: }
+  # - configured_destination: { lat:, lng: }
+  # - pickups: Array<{ lat:, lng: }> (optional)
+  # - dropoffs: Array<{ lat:, lng: }> (optional)
+  # - pickup_oob_confirmed: Boolean (optional)
+  # - dropoff_oob_confirmed: Boolean (optional)
+  # - base_price_usd: Numeric
+  # - boundary_km: Numeric (optional, default 0)
+  #
+  # Outputs via context on success:
+  # - payload: Hash (compatible with previous controller response)
+  # - base_km, detour_pickup_km, detour_dropoff_km: Floats or nil
+  # - distance_km, directions_url, ordered_points, estimated_time_minutes (when optimize true)
+  class TripDistanceCalculator < BaseInteractor
+    delegate :origin,
+             :configured_destination,
+             :pickups,
+             :dropoffs,
+             :pickup_oob_confirmed,
+             :dropoff_oob_confirmed,
+             :base_price_usd,
+             :boundary_km,
+             to: :context
+
+    def call
+      validate_inputs
+
+      pickups_points, dropoffs_points, final_destination = prepare_points
+      base_km, detour_pickup_km, detour_dropoff_km = compute_route_kms(pickups_points, dropoffs_points, final_destination)
+      details_ctx = fetch_details(final_destination, pickups_points, dropoffs_points)
+      extra_data = compute_extra_data(base_km, detour_pickup_km, detour_dropoff_km)
+      payload = build_payload(details_ctx, base_km, detour_pickup_km, detour_dropoff_km, extra_data)
+      assign_context(details_ctx, base_km, detour_pickup_km, detour_dropoff_km, payload)
+    end
+
+    private
+
+    def validate_inputs
+      context.fail!(message: 'origin is required') if origin.blank?
+      context.fail!(message: 'configured_destination is required') if configured_destination.blank?
+    end
+
+    def compute_km(origin:, destination:, pickups: nil, dropoffs: nil, optimize: nil)
+      ctx = SpreeCmCommissioner::GoogleRoutesDistanceCalculator.call(
+        origin: origin,
+        destination: destination,
+        pickups: pickups,
+        dropoffs: dropoffs,
+        optimize: optimize
+      )
+      return nil unless ctx.success?
+
+      ctx.distance_km
+    end
+
+    def prepare_points
+      pickups_points = Array(pickups).compact
+      dropoffs_points = Array(dropoffs).compact
+      final_destination = dropoffs_points.last || configured_destination
+      [pickups_points, dropoffs_points, final_destination]
+    end
+
+    def compute_route_kms(pickups_points, dropoffs_points, final_destination)
+      base_km = compute_km(origin: origin, destination: configured_destination)
+      detour_pickup_km =
+        if pickups_points.any?
+          compute_km(
+            origin: origin,
+            destination: configured_destination,
+            pickups: pickups_points,
+            optimize: false
+          )
+        end
+      detour_dropoff_km =
+        if dropoffs_points.any?
+          compute_km(
+            origin: origin,
+            destination: final_destination,
+            dropoffs: dropoffs_points,
+            optimize: false
+          )
+        end
+      [base_km, detour_pickup_km, detour_dropoff_km]
+    end
+
+    def fetch_details(final_destination, pickups_points, dropoffs_points)
+      ctx = SpreeCmCommissioner::GoogleRoutesDistanceCalculator.call(
+        origin: origin,
+        destination: final_destination,
+        pickups: pickups_points,
+        dropoffs: dropoffs_points,
+        optimize: true
+      )
+      context.fail!(message: ctx.message || 'Unable to calculate') unless ctx.success?
+      ctx
+    end
+
+    def compute_extra_data(base_km, detour_pickup_km, detour_dropoff_km)
+      extra_pickup_km = compute_extra_km(detour_pickup_km, base_km, pickup_oob_confirmed)
+      extra_dropoff_km = compute_extra_km(detour_dropoff_km, base_km, dropoff_oob_confirmed)
+      extra_pickup_charge_usd = charge_for_extra_km(extra_pickup_km)
+      extra_dropoff_charge_usd = charge_for_extra_km(extra_dropoff_km)
+      extra_charge_usd = (extra_pickup_charge_usd + extra_dropoff_charge_usd).round(2)
+      total_price_usd = (base_price_usd.to_f + extra_charge_usd).round(2)
+
+      {
+        extra_pickup_km: extra_pickup_km,
+        extra_dropoff_km: extra_dropoff_km,
+        extra_pickup_charge_usd: extra_pickup_charge_usd,
+        extra_dropoff_charge_usd: extra_dropoff_charge_usd,
+        total_price_usd: total_price_usd
+      }
+    end
+
+    def build_payload(details_ctx, base_km, detour_pickup_km, detour_dropoff_km, data)
+      {
+        distance_km: details_ctx.distance_km,
+        directions_url: details_ctx.directions_url,
+        ordered_points: details_ctx.ordered_points,
+        estimated_time_minutes: details_ctx.estimated_time_minutes,
+        base_price_usd: base_price_usd.to_f,
+        total_price_usd: data[:total_price_usd],
+        extra_pickup_km: data[:extra_pickup_km],
+        extra_dropoff_km: data[:extra_dropoff_km],
+        extra_pickup_charge_usd: data[:extra_pickup_charge_usd],
+        extra_dropoff_charge_usd: data[:extra_dropoff_charge_usd],
+        extra_charge_usd: data[:extra_charge_usd],
+        base_km: base_km,
+        detour_pickup_km: detour_pickup_km,
+        detour_dropoff_km: detour_dropoff_km
+      }
+    end
+
+    def assign_context(details_ctx, base_km, detour_pickup_km, detour_dropoff_km, payload)
+      context.payload = payload
+      context.distance_km = details_ctx.distance_km
+      context.directions_url = details_ctx.directions_url
+      context.ordered_points = details_ctx.ordered_points
+      context.estimated_time_minutes = details_ctx.estimated_time_minutes
+      context.base_km = base_km
+      context.detour_pickup_km = detour_pickup_km
+      context.detour_dropoff_km = detour_dropoff_km
+    end
+
+    def compute_extra_km(detour_km, base_km, confirmed)
+      return 0.0 unless confirmed && detour_km && base_km
+
+      [(detour_km - base_km - boundary_km), 0.0].max
+    end
+
+    def charge_for_extra_km(extra_km)
+      x = extra_km.to_f
+      return 0.0 if x <= 0
+      return 2.0 if x <= 5.0
+      return 5.0 if x <= 10.0
+      return 10.0 if x <= 20.0
+
+      (10.0 + ((x - 20.0) * 0.5)).round(2)
+    end
+  end
+end

data/app/models/concerns/spree_cm_commissioner/order_scopes.rb

@@ -17,16 +17,15 @@ module SpreeCmCommissioner
       # Inactive orders scopes with parameterized dates
       # Usage: Spree::Order.inactive_incomplete_all(threshold: 14.days.ago)
       scope :inactive_incomplete_all, lambda { |threshold: 14.days.ago|
-        where(archived_at: nil, completed_at: nil)
-          .where('updated_at < ?', threshold)
+        where('updated_at < ?', threshold)
+          .where(archived_at: nil, completed_at: nil)
       }
 
       # Usage: Spree::Order.inactive_incomplete(threshold: 14.days.ago, window: 7.days)
       # Returns orders updated between (threshold - window) and threshold
       scope :inactive_incomplete, lambda { |threshold: 14.days.ago, window: 7.days|
-        where(archived_at: nil, completed_at: nil)
-          .where('updated_at >= ?', threshold - window)
-          .where('updated_at < ?', threshold)
+        where('updated_at >= ? AND updated_at < ?', threshold - window, threshold)
+          .where(archived_at: nil, completed_at: nil)
       }
 
       # Filter scopes

data/app/queries/spree_cm_commissioner/trip_query.rb

@@ -1,13 +1,14 @@
 module SpreeCmCommissioner
   class TripQuery
-    attr_reader :origin_id, :destination_id, :date, :vendor_id, :number_of_guests, :params
+    attr_reader :origin_id, :destination_id, :date, :vendor_id, :number_of_guests, :route_type, :params
 
-    def initialize(origin_id:, destination_id:, date:, vendor_id: nil, number_of_guests: nil, params: {}) # rubocop:disable Metrics/ParameterLists
+    def initialize(origin_id:, destination_id:, date:, route_type: nil, vendor_id: nil, number_of_guests: nil, params: {}) # rubocop:disable Metrics/ParameterLists
       @origin_id = origin_id
       @destination_id = destination_id
       @date = date.to_date == Time.zone.now.to_date ? Time.zone.now : Time.zone.parse(date.to_s)
       @vendor_id = vendor_id
       @number_of_guests = number_of_guests || 1
+      @route_type = route_type
       @params = params
       @page = (params[:page] || 1).to_i
       @per_page = params[:per_page]
@@ -34,37 +35,10 @@ module SpreeCmCommissioner
     end
 
     def direct_trips
-      @inventory_sql ||= product_inventory_totals
-      result = SpreeCmCommissioner::Trip
-               .select(<<~SQL.squish)
-                 cm_trips.*,
-                 boarding.departure_time AS boarding_departure_time,
-                 boarding.stop_place_id AS boarding_stop_id, boarding.stop_name AS boarding_stop_name,
-                 drop_off.stop_name AS drop_off_stop_name, drop_off.stop_place_id AS drop_off_stop_id,
-                 drop_off.arrival_time AS drop_off_arrival_time,
-                 COALESCE(iv.quantity_available, 0) AS quantity_available,
-                 COALESCE(iv.max_capacity, 0) AS max_capacity,
-                 origin_places.name AS origin_place_name, dest_places.name AS destination_place_name,
-                 prices.amount AS amount, prices.compare_at_amount AS compare_at_amount,
-                 prices.currency AS currency
-               SQL
-               .includes(vendor: :logo, vehicle: :option_values)
-               .joins(<<~SQL.squish)
-                 INNER JOIN cm_trip_stops AS boarding ON boarding.trip_id = cm_trips.id AND boarding.stop_type = 0
-                 INNER JOIN cm_trip_stops AS drop_off ON drop_off.trip_id = cm_trips.id AND drop_off.stop_type = 1
-                 INNER JOIN cm_places AS origin_places ON origin_places.id = cm_trips.origin_place_id
-                 INNER JOIN cm_places AS dest_places ON dest_places.id = cm_trips.destination_place_id
-                 INNER JOIN spree_variants AS master ON master.product_id = cm_trips.product_id AND master.is_master = true
-                 INNER JOIN spree_prices AS prices ON prices.variant_id = master.id AND prices.deleted_at IS NULL
-               SQL
-               .where('(boarding.location_place_id = ? OR boarding.stop_place_id = ? OR cm_trips.origin_place_id = ?)
-                        AND (drop_off.location_place_id = ? OR drop_off.stop_place_id = ? OR cm_trips.destination_place_id = ?)',
-                      origin_id, origin_id, origin_id, destination_id, destination_id, destination_id
-               )
-               .joins("INNER JOIN (#{@inventory_sql.to_sql}) iv ON cm_trips.product_id = iv.product_id")
-
-      result = result.where(vendor_id: vendor_id) if vendor_id.present?
-      @per_page.to_i.positive? ? result.page(@page).per(@per_page) : result.page(@page)
+      result = trip_scope
+      result = result.where({ vendor_id: vendor_id }.compact)
+      result = result.where(route_type: route_type) if route_type.present?
+      paginate(result)
     end
 
     def product_inventory_totals
@@ -81,6 +55,44 @@ module SpreeCmCommissioner
 
     private
 
+    def trip_scope
+      SpreeCmCommissioner::Trip
+        .select(<<~SQL.squish)
+          cm_trips.*,
+          boarding.departure_time AS boarding_departure_time,
+          boarding.stop_place_id AS boarding_stop_id, boarding.stop_name AS boarding_stop_name,
+          drop_off.stop_name AS drop_off_stop_name, drop_off.stop_place_id AS drop_off_stop_id,
+          drop_off.arrival_time AS drop_off_arrival_time,
+          COALESCE(iv.quantity_available, 0) AS quantity_available,
+          COALESCE(iv.max_capacity, 0) AS max_capacity,
+          origin_places.name AS origin_place_name, dest_places.name AS destination_place_name,
+          prices.amount AS amount, prices.compare_at_amount AS compare_at_amount,
+          prices.currency AS currency
+        SQL
+        .includes(vendor: :logo, vehicle: :option_values)
+        .joins(<<~SQL.squish)
+          INNER JOIN cm_trip_stops AS boarding ON boarding.trip_id = cm_trips.id AND boarding.stop_type = 0
+          INNER JOIN cm_trip_stops AS drop_off ON drop_off.trip_id = cm_trips.id AND drop_off.stop_type = 1
+          INNER JOIN cm_places AS origin_places ON origin_places.id = cm_trips.origin_place_id
+          INNER JOIN cm_places AS dest_places ON dest_places.id = cm_trips.destination_place_id
+          INNER JOIN spree_variants AS master ON master.product_id = cm_trips.product_id AND master.is_master = true
+          INNER JOIN spree_prices AS prices ON prices.variant_id = master.id AND prices.deleted_at IS NULL
+        SQL
+        .where('(boarding.location_place_id = ? OR boarding.stop_place_id = ? OR cm_trips.origin_place_id = ?)
+                 AND (drop_off.location_place_id = ? OR drop_off.stop_place_id = ? OR cm_trips.destination_place_id = ?)',
+               origin_id, origin_id, origin_id, destination_id, destination_id, destination_id
+        )
+        .joins("INNER JOIN (#{inventory_sql.to_sql}) iv ON cm_trips.product_id = iv.product_id")
+    end
+
+    def paginate(result)
+      @per_page.to_i.positive? ? result.page(@page).per(@per_page) : result.page(@page)
+    end
+
+    def inventory_sql
+      @inventory_sql ||= product_inventory_totals
+    end
+
     def build_trip_result(trip)
       vehicle = trip&.vehicle
       vendor = trip&.vendor

data/app/services/spree_cm_commissioner/orders/bulk_archive_inactive_orders.rb

@@ -12,8 +12,8 @@ module SpreeCmCommissioner
       # - completed_at IS NULL (incomplete/unfinished orders)
       # - updated_at < 14 days ago (inactive for 2+ weeks)
       #
-      # Difference from ArchiveInactiveOrders:
-      # - ArchiveInactiveOrders: Runs daily, archives only 1-week window (21-14 days)
+      # Difference from DailyArchiveInactiveOrders:
+      # - DailyArchiveInactiveOrders: Runs daily, archives only 1-week window (21-14 days)
       # - BulkArchiveInactiveOrders: Manual job, archives ALL orders older than 14 days
       #
       # Use case: Bulk cleanup when needed, triggered manually via Sidekiq
@@ -45,6 +45,14 @@ module SpreeCmCommissioner
 
         success(archived_count: count)
       rescue StandardError => e
+        CmAppLogger.error(
+          label: 'SpreeCmCommissioner::Orders::BulkArchiveInactiveOrders#call failed',
+          data: {
+            error_class: e.class.name,
+            error_message: e.message,
+            backtrace: e.backtrace&.first(5)&.join("\n")
+          }
+        )
         failure(nil, e.message)
       end
     end

data/app/services/spree_cm_commissioner/orders/daily_archive_inactive_orders.rb

@@ -51,6 +51,14 @@ module SpreeCmCommissioner
 
         success(archived_count: count)
       rescue StandardError => e
+        CmAppLogger.error(
+          label: 'SpreeCmCommissioner::Orders::DailyArchiveInactiveOrders#call failed',
+          data: {
+            error_class: e.class.name,
+            error_message: e.message,
+            backtrace: e.backtrace&.first(5)&.join("\n")
+          }
+        )
         failure(nil, e.message)
       end
     end

data/app/services/spree_cm_commissioner/trips/search.rb

@@ -10,21 +10,23 @@ module SpreeCmCommissioner
         new.send(:cache_key, params, vendor)
       end
 
-      def call(params:, vendor:, is_intercity_taxi: false)
+      def call(params:, vendor:)
         return success(results: []) unless valid_search?(params)
 
         cache_key = cache_key(params, vendor)
 
         results = Rails.cache.fetch(cache_key, expires_in: SEARCH_CACHE_TTL) do
+          route_type = intercity_taxi?(params) ? 'intercity_taxi' : nil
           trips = SpreeCmCommissioner::TripQuery.new(
             origin_id: origin_id(params),
             destination_id: destination_id(params),
+            date: search_date(params).to_date,
+            route_type: route_type,
             vendor_id: vendor.id,
-            number_of_guests: params[:number_of_guests] || 1,
-            date: search_date(params).to_date
+            number_of_guests: params[:number_of_guests] || 1
           ).call
 
-          is_intercity_taxi || taxi?(params) ? filter_intercity(trips) : trips
+          trips
         end
 
         success(results: results)
@@ -38,17 +40,11 @@ module SpreeCmCommissioner
         params[:origin].present? && params[:destination].present? && params[:outbound_date].present?
       end
 
-      def filter_intercity(results)
-        Array(results).select do |res|
-          res.respond_to?(:trips) && res.trips.any? { |t| t.route_type.to_s == 'intercity_taxi' }
-        end
-      end
-
       def origin_id(params)      = outbound?(params) ? params[:origin]      : params[:destination]
       def destination_id(params) = outbound?(params) ? params[:destination] : params[:origin]
       def search_date(params)    = outbound?(params) ? params[:outbound_date] : params[:inbound_date]
       def outbound?(params)      = params[:direction] == 'outbound' || params[:direction].blank?
-      def taxi?(params)          = params[:service_type] == 'intercity_taxi'
+      def intercity_taxi?(params) = params[:service_type] == 'intercity_taxi'
 
       def cache_key(params, vendor)
         [

data/lib/spree_cm_commissioner/version.rb

@@ -1,5 +1,5 @@
 module SpreeCmCommissioner
-  VERSION = '2.3.0-pre20'.freeze
+  VERSION = '2.3.0-pre21'.freeze
 
   module_function
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spree_cm_commissioner
 version: !ruby/object:Gem::Version
-  version: 2.3.0.pre.pre20
+  version: 2.3.0.pre.pre21
 platform: ruby
 authors:
 - You
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-13 00:00:00.000000000 Z
+date: 2025-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: spree
@@ -1182,6 +1182,7 @@ files:
 - app/interactors/spree_cm_commissioner/firebase_email_fetcher_cron_executor.rb
 - app/interactors/spree_cm_commissioner/firebase_id_token_provider.rb
 - app/interactors/spree_cm_commissioner/google_places_fetcher.rb
+- app/interactors/spree_cm_commissioner/google_routes_distance_calculator.rb
 - app/interactors/spree_cm_commissioner/guest_dynamic_field_notification_sender.rb
 - app/interactors/spree_cm_commissioner/guest_dynamic_fields_manager.rb
 - app/interactors/spree_cm_commissioner/guest_id_card_manager.rb
@@ -1252,6 +1253,7 @@ files:
 - app/interactors/spree_cm_commissioner/transactional_email_sender.rb
 - app/interactors/spree_cm_commissioner/transit/draft_order_creator.rb
 - app/interactors/spree_cm_commissioner/trip_clone_creator.rb
+- app/interactors/spree_cm_commissioner/trip_distance_calculator.rb
 - app/interactors/spree_cm_commissioner/trip_stops_creator.rb
 - app/interactors/spree_cm_commissioner/unique_device_token_cron_executor.rb
 - app/interactors/spree_cm_commissioner/update_payment_gateway_status.rb