spree_cm_commissioner 2.3.0.pre.pre20 → 2.3.1.pre.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f73314825dc2db092e1255e49203ceb8e1071e0dac1c11803d8343b8dc37fafa
-  data.tar.gz: 32c25a52977a2f20591b8650ece48a69e517845b3431b79e3c57da63cf8ddb50
+  metadata.gz: 7791d1c6474375315937bc020c5bb5274abecbddc5e9b9f5df5a73e53576d626
+  data.tar.gz: 03c0f3ccc698d12697c135f4daaab5718b1a72117288de9270069397660d62a5
 SHA512:
-  metadata.gz: 1bd90e765ad3bdd9f28b6199900a7ea4f587dd11732af3a03c8bd3b13d234eb83765740de6619223dd03cbe77cb4b865c82c12c8a1845bc05157977463bf17d6
-  data.tar.gz: ef7380007df4d1ee55da2fea5d2d9cb2b3b5d931c44d17a955b9925c338f8a6285df1df59459b643152cd03fda819bcdd264075bc87eaaff5961e93d08b84606
+  metadata.gz: 5cb82c98aac134ebedbdb29c1daf2cc22035ac4e5856c548b22015ffb9a574e6873e897407b8043d899164a9a1ffa941ec04fc25df2263e255e5fd1ad362531c
+  data.tar.gz: 4ff0e66a420d2e7f589f2c63d55ca18acc0065aa015033b3917a5dbf603440df4f8a56a32834a02135f5e216a2e5f7d82e8e78f5c6d1df571dc7b261ddb90a79

data/Gemfile.lock

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

data/app/controllers/spree/admin/product_completion_steps_controller.rb

@@ -4,6 +4,7 @@ module Spree
       belongs_to 'spree/product', find_by: :slug
 
       before_action :load_step_types, if: :member_action?
+      before_action :build_assets, only: %i[create update]
 
       def load_step_types
         @step_types = [
@@ -14,10 +15,13 @@ module Spree
 
       # override
       def permitted_resource_params
+        return @permitted_resource_params if defined?(@permitted_resource_params)
+
         key = ActiveModel::Naming.param_key(@object)
         permit_keys = params.require(key).keys
 
-        params.require(key).permit(permit_keys)
+        @permitted_resource_params = params.require(key).permit(permit_keys)
+        @permitted_resource_params
       end
 
       # @overrided
@@ -54,6 +58,18 @@ module Spree
       def location_after_save
         edit_object_url(@object)
       end
+
+      def remove_banner
+        @object.banner&.destroy
+        flash[:success] = Spree.t(:successfully_removed)
+        redirect_to edit_object_url(@object)
+      end
+
+      private
+
+      def build_assets
+        @object.build_banner(attachment: permitted_resource_params.delete(:banner)) if permitted_resource_params[:banner].present?
+      end
     end
   end
 end

data/app/controllers/spree/admin/tenants_controller.rb

@@ -1,7 +1,7 @@
 module Spree
   module Admin
     class TenantsController < Spree::Admin::ResourceController
-      before_action :load_vector_icons, only: %i[new edit]
+      before_action :load_vector_icons, only: %i[new edit create update]
 
       # override
       def collection

data/app/controllers/spree/api/v2/storefront/intercity_taxi/draft_orders_controller.rb

@@ -20,7 +20,6 @@ module Spree
 
             def update
               order = SpreeCmCommissioner::IntercityTaxiOrder::Update.call(
-                order_number: params[:id],
                 params: params
               )
 

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/controllers/spree/api/v2/tenant/intercity_taxi/draft_orders_controller.rb

@@ -0,0 +1,41 @@
+module Spree
+  module Api
+    module V2
+      module Tenant
+        module IntercityTaxi
+          class DraftOrdersController < BaseController
+            def create
+              order = SpreeCmCommissioner::IntercityTaxiOrder::Create.call(
+                trip_id: params[:trip_id],
+                from_date: params[:from_date],
+                to_date: params[:to_date],
+                user_id: params[:user_id],
+                quantity: params[:quantity]
+              )
+
+              render_serialized_payload { serialize_resource(order) }
+            rescue StandardError => e
+              render_error_payload(e.message)
+            end
+
+            def update
+              order = SpreeCmCommissioner::IntercityTaxiOrder::Update.call(
+                params: params
+              )
+
+              render_serialized_payload { serialize_resource(order) }
+            rescue StandardError => e
+              render_error_payload(e.message)
+            end
+
+            private
+
+            def resource_serializer
+              SpreeCmCommissioner::V2::Storefront::IntercityTaxiCartSerializer
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/tenant/trip_places_controller.rb

@@ -0,0 +1,48 @@
+module Spree
+  module Api
+    module V2
+      module Tenant
+        class TripPlacesController < BaseController
+          def index
+            render_serialized_payload do
+              serialize_collection(paginated_collection)
+            end
+          end
+
+          private
+
+          def paginated_collection
+            collection.page(params[:page]).per(params[:per_page])
+          end
+
+          def collection
+            @collection ||= begin
+              base_scope = scope
+
+              if params[:q].present?
+                @search = base_scope.ransack(params[:q])
+                @search.result
+              else
+                base_scope
+              end
+            end
+          end
+
+          def scope
+            model_class.joins(:location_vendor_places)
+                       .where(location_vendor_places: { tenant_id: @tenant.id })
+                       .distinct
+          end
+
+          def model_class
+            SpreeCmCommissioner::Place
+          end
+
+          def collection_serializer
+            SpreeCmCommissioner::V2::Storefront::TripPlaceSerializer
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+module Spree
+  module Api
+    module V2
+      module Tenant
+        class TripSearchController < BaseController
+          CACHE_EXPIRES_IN = 5.minutes
+
+          def index
+            render_serialized_payload do
+              Rails.cache.fetch(collection_cache_key, collection_cache_opts) do
+                trips = SpreeCmCommissioner::TripQuery.new(
+                  origin_id: params[:origin_id],
+                  destination_id: params[:destination_id],
+                  date: params[:date],
+                  route_type: params[:route_type],
+                  number_of_guests: params[:number_of_guests],
+                  tenant_id: @tenant.id,
+                  params: params
+                ).call
+
+                serialize_collection(trips)
+              end
+            end
+          end
+
+          private
+
+          # override from ContentCacheable
+          def max_age
+            CACHE_EXPIRES_IN.to_i
+          end
+
+          # override
+          def collection_cache_key
+            cache_key_parts = [
+              'trip_search',
+              @tenant.id,
+              params[:origin_id],
+              params[:destination_id],
+              params[:date],
+              params[:route_type],
+              params[:number_of_guests],
+              resource_includes&.sort&.join(','),
+              sparse_fields&.sort&.join(','),
+              serializer_params.to_json,
+              params[:page]&.to_s&.strip,
+              params[:per_page]&.to_s&.strip
+            ].compact.join('-')
+
+            Digest::MD5.hexdigest(cache_key_parts)
+          end
+
+          # override
+          def collection_cache_opts
+            {
+              namespace: Spree::Api::Config[:api_v2_collection_cache_namespace],
+              expires_in: CACHE_EXPIRES_IN
+            }
+          end
+
+          # override
+          def default_resource_includes
+            [
+              'trips.vendor',
+              'trips.vendor.logo',
+              'trips.vehicle',
+              'trips.vehicle.vehicle_photos',
+              'trips.amenities'
+            ]
+          end
+
+          def serialize_collection(collection)
+            serialized_data = SpreeCmCommissioner::V2::Storefront::TripQueryResultSerializer.new(
+              collection,
+              include: default_resource_includes,
+              params: serializer_params
+            ).serializable_hash
+            serialized_data[:meta] = {
+              count: collection.size,
+              total_count: collection.respond_to?(:total_count) ? collection.total_count : collection.size,
+              current_page: collection.respond_to?(:current_page) ? collection.current_page : 1,
+              per_page: collection.respond_to?(:limit_value) ? collection.limit_value : collection.size,
+              pages: collection.respond_to?(:total_pages) ? collection.total_pages : 1,
+              next_page: collection.respond_to?(:next_page) ? collection.next_page : nil,
+              prev_page: collection.respond_to?(:prev_page) ? collection.prev_page : nil
+            }
+            serialized_data
+          end
+
+          # override
+          def serializer_params
+            params.permit(:include).to_hash
+          end
+
+          # override
+          def required_schema
+            SpreeCmCommissioner::TripSearchRequestSchema
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/tenant/trips_controller.rb

@@ -0,0 +1,32 @@
+module Spree
+  module Api
+    module V2
+      module Tenant
+        class TripsController < BaseController
+          def show
+            resource = scope.find(params[:id])
+
+            render_serialized_payload do
+              serialize_resource(resource)
+            end
+          end
+
+          private
+
+          def scope
+            model_class.joins(:vendor)
+                       .where(spree_vendors: { tenant_id: @tenant.id })
+          end
+
+          def model_class
+            SpreeCmCommissioner::Trip
+          end
+
+          def resource_serializer
+            SpreeCmCommissioner::V2::Storefront::TripSerializer
+          end
+        end
+      end
+    end
+  end
+end

data/app/interactors/spree_cm_commissioner/create_ticket.rb

@@ -48,6 +48,8 @@ module SpreeCmCommissioner
         name: 'ticket-type',
         presentation: 'Ticket Type'
       )
+      # auto assign the option type to the ticket
+      @ticket.option_types << @option_type unless @ticket.option_types.include?(@option_type)
 
       @option_value = Spree::OptionValue.find_or_create_by!(
         name: @ticket.name,

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/host_matcher.rb

@@ -22,7 +22,7 @@ module SpreeCmCommissioner
     end
 
     def find_tenant(normalized_host)
-      SpreeCmCommissioner::Tenant.find_by(host: "https://#{normalized_host}")
+      SpreeCmCommissioner::Tenant.find_by(host: normalized_host)
     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)