spree_cm_commissioner 2.3.0.pre.pre19 → 2.3.0.pre.pre21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba19c5f6b8ae1e8a80fb0128bf1f58b1a653d6430aa11d46ae3722b13e2d17be
-  data.tar.gz: 7993749d255ca3800e9d200adc21820bad68ac350a60b88882a5bda4ee054701
+  metadata.gz: cfed0f91fdd9c96b14fdd179bfca7cdce626d8268468b3d6a22b7622c8aee3f5
+  data.tar.gz: b2e6802c655db5e83abb39e20f3478b0068a79a847744e1a812b7f22191ac345
 SHA512:
-  metadata.gz: 83ffc09e4828acf4abb37b4d10e537f2302f967dca20fdf86a806f260fe733dbd9da4097a2f813650e29f2f1420350c538ec4aa8eedc7d9b7543a68e9c535d07
-  data.tar.gz: 40448782e45555c79e319cca373607a53ca34125ce1c5e13f45a74aa0014992a7294c768fdca9826287e645b2073a2f953eb2956ce983d1147d810f68a31c608
+  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.pre19)
+    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/interactors/spree_cm_commissioner/user_registration_with_id_token.rb

@@ -2,26 +2,54 @@ module SpreeCmCommissioner
   class UserRegistrationWithIdToken < BaseInteractor
     # :id_token
     def call
+      firebase_context = validate_firebase_token!
+      return if firebase_context.nil?
+
+      ActiveRecord::Base.transaction do
+        find_or_register_user!(firebase_context.provider[:name], firebase_context.provider[:email])
+        link_user_account!(firebase_context.provider)
+      end
+    end
+
+    private
+
+    def validate_firebase_token!
       firebase_context = SpreeCmCommissioner::FirebaseIdTokenProvider.call(id_token: context.id_token)
+      return firebase_context if firebase_context.success?
 
-      if firebase_context.success?
-        ActiveRecord::Base.transaction do
-          register_user!(firebase_context.provider[:name], firebase_context.provider[:email])
-          link_user_account!(firebase_context.provider)
-        end
+      context.fail!(message: firebase_context.message)
+      nil
+    end
+
+    def find_or_register_user!(name, email)
+      if email.present?
+        register_user_with_email!(name, email)
       else
-        context.fail!(message: firebase_context.message)
+        register_user_without_email!(name)
       end
     end
 
-    def register_user!(name, email)
-      user = Spree.user_class.new(
-        password: SecureRandom.base64(16),
-        email: email,
-        tenant_id: context.tenant_id,
-        **name_attributes(name)
-      )
-      user.confirmed_at = Time.zone.now
+    def register_user_with_email!(name, email)
+      user = Spree.user_class.find_by(email: email, tenant_id: context.tenant_id)
+      return context.user = ensure_user_confirmed!(user) if user.present?
+
+      begin
+        context.user = Spree.user_class.find_or_create_by!(email: email, tenant_id: context.tenant_id) do |u|
+          assign_user_attributes(u, name)
+        end
+      # Handle potential race condition: Another request might have created the user
+      # between our find_by and find_or_create_by calls. If we get a RecordNotUnique,
+      # it means the user was created by another process, so we find and return it.
+      rescue ActiveRecord::RecordNotUnique
+        user = Spree.user_class.find_by!(email: email, tenant_id: context.tenant_id)
+        context.user = ensure_user_confirmed!(user)
+      end
+    end
+
+    def register_user_without_email!(name)
+      user = Spree.user_class.new(email: nil, tenant_id: context.tenant_id)
+      assign_user_attributes(user, name)
+
       if user.save(validate: false)
         context.user = user
       else
@@ -29,39 +57,32 @@ module SpreeCmCommissioner
       end
     end
 
+    def assign_user_attributes(user, name)
+      user.password = SecureRandom.base64(16)
+      user.confirmed_at = Time.zone.now
+      user.assign_attributes(name_attributes(name))
+    end
+
     def name_attributes(name)
       full_name = name&.strip
       return {} if full_name.blank?
 
-      split = full_name.split
-      first_name = split[0]
-      last_name = split[1..].join(' ')
-
-      attributes = {}
-      attributes[:first_name] = first_name if first_name.present?
-      attributes[:last_name] = last_name if last_name.present?
+      parts = full_name.split
+      attributes = { first_name: parts[0] }
+      attributes[:last_name] = parts[1..].join(' ') if parts.size > 1
 
       attributes
     end
 
-    # provider object
-
-    # {
-    #   identity_type: identity_type,
-    #   sub: sub
-    # }
-
     def link_user_account!(provider)
       identity_type = SpreeCmCommissioner::UserIdentityProvider.identity_types[provider[:identity_type]]
+      user_identity_provider = find_or_initialize_identity_provider(identity_type)
 
-      user_identity_provider = SpreeCmCommissioner::UserIdentityProvider.where(
-        user_id: context.user,
-        identity_type: identity_type
-      ).first_or_initialize
-
-      user_identity_provider.sub = provider[:sub]
-      user_identity_provider.email = provider[:email]
-      user_identity_provider.name = provider[:name]
+      user_identity_provider.assign_attributes(
+        sub: provider[:sub],
+        email: provider[:email],
+        name: provider[:name]
+      )
 
       if user_identity_provider.save
         context.user_identity_provider = user_identity_provider
@@ -69,5 +90,20 @@ module SpreeCmCommissioner
         context.fail!(message: user_identity_provider.errors.full_messages)
       end
     end
+
+    def find_or_initialize_identity_provider(identity_type)
+      SpreeCmCommissioner::UserIdentityProvider.where(
+        user_id: context.user,
+        identity_type: identity_type
+      ).first_or_initialize
+    end
+
+    # Ensure user is confirmed when linking with identity provider.
+    # Users created via OAuth should be auto-confirmed since they've proven
+    # their identity through the OAuth provider.
+    def ensure_user_confirmed!(user)
+      user.update(confirmed_at: Time.zone.now) if user.confirmed_at.nil?
+      user
+    end
   end
 end

data/app/jobs/spree_cm_commissioner/orders/bulk_archive_inactive_orders_job.rb

@@ -0,0 +1,13 @@
+module SpreeCmCommissioner
+  module Orders
+    class BulkArchiveInactiveOrdersJob < ApplicationJob
+      # Manual job that archives ALL incomplete orders inactive for 14+ days.
+      # Thin wrapper that calls BulkArchiveInactiveOrders service.
+      # ApplicationJob handles error logging via around_perform hook.
+      # Triggered manually via Sidekiq (not scheduled).
+      def perform
+        SpreeCmCommissioner::Orders::BulkArchiveInactiveOrders.new.call
+      end
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/orders/{archive_inactive_orders_job.rb → daily_archive_inactive_orders_job.rb}

@@ -1,11 +1,11 @@
 module SpreeCmCommissioner
   module Orders
-    class ArchiveInactiveOrdersJob < ApplicationJob
+    class DailyArchiveInactiveOrdersJob < ApplicationJob
       # Scheduled job that runs daily to archive incomplete orders inactive for 14+ days.
-      # Thin wrapper that calls ArchiveInactiveOrders service.
+      # Thin wrapper that calls DailyArchiveInactiveOrders service.
       # ApplicationJob handles error logging via around_perform hook.
       def perform
-        SpreeCmCommissioner::Orders::ArchiveInactiveOrders.new.call
+        SpreeCmCommissioner::Orders::DailyArchiveInactiveOrders.new.call
       end
     end
   end

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

@@ -0,0 +1,45 @@
+module SpreeCmCommissioner
+  module OrderScopes
+    extend ActiveSupport::Concern
+
+    included do
+      # Archiving scopes
+      scope :archived, -> { where.not(archived_at: nil) }
+      scope :not_archived, -> { where(archived_at: nil) }
+
+      # Payment and state scopes
+      scope :subscription, -> { where.not(subscription_id: nil) }
+      scope :paid, -> { where(payment_state: :paid) }
+      scope :complete_or_canceled, -> { complete.or(where(state: 'canceled')) }
+      scope :payment, -> { incomplete.where(state: 'payment') }
+      scope :without_user, -> { where(user_id: nil) }
+
+      # 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('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('updated_at >= ? AND updated_at < ?', threshold - window, threshold)
+          .where(archived_at: nil, completed_at: nil)
+      }
+
+      # Filter scopes
+      scope :filter_by_match_user_contact, lambda { |user|
+        complete.where(
+          '(email = :email OR intel_phone_number = :intel_phone_number) AND user_id IS NULL',
+          email: user.email,
+          intel_phone_number: user.intel_phone_number
+        )
+      }
+
+      scope :filter_by_vendor, lambda { |vendor|
+        joins(:line_items).where(spree_line_items: { vendor_id: vendor }).distinct
+      }
+    end
+  end
+end

data/app/models/spree_cm_commissioner/order_decorator.rb

@@ -1,31 +1,12 @@
 module SpreeCmCommissioner
   module OrderDecorator
-    def self.prepended(base) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+    def self.prepended(base) # rubocop:disable Metrics/MethodLength
       base.include SpreeCmCommissioner::StoreMetadata
       base.include SpreeCmCommissioner::PhoneNumberSanitizer
       base.include SpreeCmCommissioner::OrderSeatable
       base.include SpreeCmCommissioner::OrderStateMachine
       base.include SpreeCmCommissioner::RouteOrderCountable
-
-      base.scope :subscription, -> { where.not(subscription_id: nil) }
-      base.scope :paid, -> { where(payment_state: :paid) }
-      base.scope :complete_or_canceled, -> { complete.or(where(state: 'canceled')) }
-      base.scope :payment, -> { incomplete.where(state: 'payment') }
-      base.scope :archived, -> { where.not(archived_at: nil) }
-      base.scope :not_archived, -> { where(archived_at: nil) }
-      base.scope :without_user, -> { where(user_id: nil) }
-
-      base.scope :filter_by_match_user_contact, lambda { |user|
-        complete.where(
-          '(email = :email OR intel_phone_number = :intel_phone_number) AND user_id IS NULL',
-          email: user.email,
-          intel_phone_number: user.intel_phone_number
-        )
-      }
-
-      base.scope :filter_by_vendor, lambda { |vendor|
-        joins(:line_items).where(spree_line_items: { vendor_id: vendor }).distinct
-      }
+      base.include SpreeCmCommissioner::OrderScopes
 
       base.before_create :link_by_phone_number
       base.before_create :associate_customer

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

@@ -0,0 +1,60 @@
+module SpreeCmCommissioner
+  module Orders
+    class BulkArchiveInactiveOrders
+      prepend ::Spree::ServiceModule::Base
+
+      # Archives ALL incomplete orders inactive for 14+ days (no time range limit).
+      # This is a bulk operation for manual cleanup via Sidekiq.
+      # Archived orders are hidden from users (Orders::Find filters them out).
+      #
+      # Criteria for archiving:
+      # - archived_at IS NULL (not already archived)
+      # - completed_at IS NULL (incomplete/unfinished orders)
+      # - updated_at < 14 days ago (inactive for 2+ weeks)
+      #
+      # 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
+      def call
+        # Archives ALL orders inactive for 14+ days (no time range limit)
+        # Uses parameterized scope: threshold=14.days.ago
+        inactive_orders = Spree::Order.inactive_incomplete_all(threshold: 14.days.ago)
+
+        count = inactive_orders.count
+
+        # Archive all inactive orders with reason in internal_note.
+        # We use bulk update_all instead of find_each because:
+        # - We rarely use internal_note, so preserving history is not critical
+        # - Bulk update is significantly faster (1 query vs N queries)
+        # - For bulk operations, performance is critical
+        inactive_orders.update_all( # rubocop:disable Rails/SkipsModelValidations
+          archived_at: Time.current,
+          internal_note: 'Auto-archived: inactive for 14 days',
+          updated_at: Time.current
+        )
+
+        CmAppLogger.log(
+          label: 'SpreeCmCommissioner::Orders::BulkArchiveInactiveOrders#call completed',
+          data: {
+            archived_count: count,
+            threshold_days: 14
+          }
+        )
+
+        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
+  end
+end

data/app/services/spree_cm_commissioner/orders/{archive_inactive_orders.rb → daily_archive_inactive_orders.rb}

@@ -1,6 +1,6 @@
 module SpreeCmCommissioner
   module Orders
-    class ArchiveInactiveOrders
+    class DailyArchiveInactiveOrders
       prepend ::Spree::ServiceModule::Base
 
       # Archives incomplete orders that haven't been updated for 14 days.
@@ -24,14 +24,17 @@ module SpreeCmCommissioner
       # - Keeps user-facing order history clean (hidden from Orders::Find queries)
       # - Reduces clutter in active carts/orders
       def call
-        inactive_orders = Spree::Order
-                          .where(archived_at: nil)
-                          .where(completed_at: nil)
-                          .where('updated_at < ?', 14.days.ago)
+        # Archives orders from the 1-week window (21-14 days ago)
+        # Uses parameterized scope: threshold=14.days.ago, window=7.days
+        inactive_orders = Spree::Order.inactive_incomplete(threshold: 14.days.ago, window: 7.days)
 
         count = inactive_orders.count
 
-        # Archive all inactive orders with reason in internal_note
+        # Archive all inactive orders with reason in internal_note.
+        # We use bulk update_all instead of find_each because:
+        # - We rarely use internal_note, so preserving history is not critical
+        # - Bulk update is significantly faster (1 query vs N queries)
+        # - For typical 100-500 orders/day, bulk update is worth the performance gain
         inactive_orders.update_all( # rubocop:disable Rails/SkipsModelValidations
           archived_at: Time.current,
           internal_note: 'Auto-archived: inactive for 14 days',
@@ -39,7 +42,7 @@ module SpreeCmCommissioner
         )
 
         CmAppLogger.log(
-          label: 'SpreeCmCommissioner::Orders::ArchiveInactiveOrders#call completed',
+          label: 'SpreeCmCommissioner::Orders::DailyArchiveInactiveOrders#call completed',
           data: {
             archived_count: count,
             threshold_days: 14
@@ -48,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/db/migrate/20251113081853_add_index_to_spree_orders_updated_at.rb

@@ -0,0 +1,7 @@
+class AddIndexToSpreeOrdersUpdatedAt < ActiveRecord::Migration[7.0]
+  def change
+    unless index_exists?(:spree_orders, :updated_at)
+      add_index :spree_orders, :updated_at, name: 'index_spree_orders_on_updated_at'
+    end
+  end
+end

data/lib/spree_cm_commissioner/version.rb

@@ -1,5 +1,5 @@
 module SpreeCmCommissioner
-  VERSION = '2.3.0-pre19'.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.pre19
+  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
@@ -1310,7 +1312,8 @@ files:
 - app/jobs/spree_cm_commissioner/option_type_variants_public_metadata_updater_job.rb
 - app/jobs/spree_cm_commissioner/option_value_variants_public_metadata_updater_job.rb
 - app/jobs/spree_cm_commissioner/order_complete_telegram_sender_job.rb
-- app/jobs/spree_cm_commissioner/orders/archive_inactive_orders_job.rb
+- app/jobs/spree_cm_commissioner/orders/bulk_archive_inactive_orders_job.rb
+- app/jobs/spree_cm_commissioner/orders/daily_archive_inactive_orders_job.rb
 - app/jobs/spree_cm_commissioner/product_event_id_to_children_syncer_job.rb
 - app/jobs/spree_cm_commissioner/queue_order_webhooks_requests_job.rb
 - app/jobs/spree_cm_commissioner/reports_assigner_job.rb
@@ -1358,6 +1361,7 @@ files:
 - app/models/concerns/spree_cm_commissioner/metafield.rb
 - app/models/concerns/spree_cm_commissioner/option_type_attr_type.rb
 - app/models/concerns/spree_cm_commissioner/option_value_attr_type.rb
+- app/models/concerns/spree_cm_commissioner/order_scopes.rb
 - app/models/concerns/spree_cm_commissioner/order_seatable.rb
 - app/models/concerns/spree_cm_commissioner/order_state_machine.rb
 - app/models/concerns/spree_cm_commissioner/parameterize_name.rb
@@ -1953,7 +1957,8 @@ files:
 - app/services/spree_cm_commissioner/intercity_taxi_order/update.rb
 - app/services/spree_cm_commissioner/metafields/product_metadata_service.rb
 - app/services/spree_cm_commissioner/order_params_checker.rb
-- app/services/spree_cm_commissioner/orders/archive_inactive_orders.rb
+- app/services/spree_cm_commissioner/orders/bulk_archive_inactive_orders.rb
+- app/services/spree_cm_commissioner/orders/daily_archive_inactive_orders.rb
 - app/services/spree_cm_commissioner/orders/generate_commissions_decorator.rb
 - app/services/spree_cm_commissioner/organizer/export_guest_csv_service.rb
 - app/services/spree_cm_commissioner/organizer/export_invite_guest_csv_service.rb
@@ -2844,6 +2849,7 @@ files:
 - db/migrate/20251009033331_add_registered_by_to_spree_users.rb
 - db/migrate/20251009073040_add_lock_version_to_cm_routes.rb
 - db/migrate/20251009073929_add_lock_version_to_cm_vendor_routes.rb
+- db/migrate/20251113081853_add_index_to_spree_orders_updated_at.rb
 - docker-compose.yml
 - docs/api/scoped-access-token-endpoints.md
 - docs/option_types/attr_types.md