spree_cm_commissioner 2.5.1.pre.pre5 → 2.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c04c1030a47ee44d31fbec31880fae41a769bcf41e7b700d9b35cbdceb71d36d
-  data.tar.gz: 2d729e1df109b0e69ad397b3b80a8212162772caaf6bdaf19b25e06f55876ab5
+  metadata.gz: 5b7e70b6ad87db5a4bd6b3879754f7ce8a753e1323d07ac754adea1426ef74b4
+  data.tar.gz: 699aa89f466074b9d86b8b0ddf39a7a8bf41f6edb4dda640f647dd33651bc9eb
 SHA512:
-  metadata.gz: 1d176ff6f8ab61f5b1e57983f864da966b0e90200bf1abc8cc6f57f69b25fdf8aa2d6a9eabfb8a23da96075a05082491e9be97611ba034675f91faf7c42a32d9
-  data.tar.gz: 5e569ceb12a0d2e533957ca83679e3738720cdb48e64e25d584bb4bac3ef2f9ab9bfab3ae89d325a1e070e4dc53d1ff068843a99ed08e6867d4e45d851257092
+  metadata.gz: 9f60f4b8646f3537f616fe2d15b4f49b0bfa335acd1f61d4a97c6d25dc4a891ced787c0d2983f0dc327b2a125f643adebdc1a9ce59025436d74c507761a773f1
+  data.tar.gz: 18584fa23c8784b390a5b076fd7a855fb101db7c6bd5ea60159e6fdf6072fcac9441a9daddb2f9bc3f89351faf03b2792b6ef7864b63b081429752ce98d1f11a

data/.github/workflows/test_and_build_gem.yml

@@ -45,7 +45,7 @@ jobs:
             const commits_url = pr.commits_url;
 
             const commits = await github.request(commits_url);
-            const pattern = /^(Close flow|Close\s+#\d+\s.+|Merge.*)/;
+            const pattern = /^Close\s+#\d+\s.+/;
 
             let invalidCommits = [];
 
@@ -63,7 +63,7 @@ jobs:
               core.setFailed(
                 `The following commit messages are not in the correct format:\n\n${invalidCommits.join(
                   '\n'
-                )}\n\nEach commit message must start with "Close #<issue_number> <message>" or "Merge pull request #<number>"`
+                )}\n\nEach commit message must start with "Close #<issue_number> <message>"`
               );
             } else {
               console.log("All commit messages are correctly formatted.");

data/Gemfile.lock

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

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

@@ -31,7 +31,7 @@ module Spree
 
           # override
           def collection_finder
-            SpreeCmCommissioner::RouteMetrics::FindPopular
+            SpreeCmCommissioner::Routes::FindPopular
           end
 
           # override
@@ -41,7 +41,7 @@ module Spree
 
           # override
           def resource_serializer
-            SpreeCmCommissioner::V2::Storefront::RouteMetricSerializer
+            SpreeCmCommissioner::V2::Storefront::RouteSerializer
           end
 
           # override

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

@@ -15,7 +15,7 @@ module Spree
               @outbound_legs = params[:outbound_legs].is_a?(Array) && params[:outbound_legs].any? ? build_legs(:outbound, params[:outbound_legs]) : []
               @inbound_legs  = params[:inbound_legs].is_a?(Array) && params[:inbound_legs].any? ? build_legs(:inbound, params[:inbound_legs]) : []
 
-              result = SpreeCmCommissioner::TransitOrder::Create.call(
+              context = SpreeCmCommissioner::Transit::DraftOrderCreator.call(
                 outbound_date: params[:outbound_date]&.to_date,
                 inbound_date: params[:inbound_date]&.to_date,
                 outbound_legs: @outbound_legs,
@@ -23,10 +23,10 @@ module Spree
                 user: spree_current_user
               )
 
-              if result.success?
-                render_serialized_payload { serialize_resource(result.value[:order]) }
+              if context.success?
+                render_serialized_payload { serialize_resource(context.order) }
               else
-                render_error_payload(result.error)
+                render_error_payload(context.message)
               end
             end
 

data/app/controllers/spree/transit/trips_controller.rb

@@ -48,13 +48,13 @@ module Spree
         boarding_points_attributes = (cm_params.delete('boarding_points') || []).compact_blank
                                                                                 .map do |point_id|
           trip_stop = trip_stops.delete(point_id.to_i)
-          { stop_id: point_id, allow_boarding: true, id: trip_stop.try(:id) }
+          { stop_id: point_id, stop_type: 'boarding', id: trip_stop.try(:id) }
         end
 
         drop_off_points_attributes = (cm_params.delete('drop_off_points') || []).compact_blank
                                                                                 .map do |point_id|
           trip_stop = trip_stops.delete(point_id.to_i)
-          { stop_id: point_id, allow_drop_off: true, id: trip_stop.try(:id) }
+          { stop_id: point_id, stop_type: 'drop_off', id: trip_stop.try(:id) }
         end
 
         trip_stops.each_value do |trip_stop|
@@ -74,7 +74,7 @@ module Spree
           :origin_id, :destination_id, :vehicle_id, :hours, :minutes, :seconds,
           'departure_time(1i)', 'departure_time(2i)', 'departure_time(3i)',
           'departure_time(4i)', 'departure_time(5i)', :product_id,
-          trip_stops_attributes: %i[stop_id allow_boarding allow_drop_off _destroy id]
+          trip_stops_attributes: %i[stop_id stop_type _destroy id]
         )
       end
 

data/app/finders/spree_cm_commissioner/places/find_with_route.rb

@@ -1,20 +1,20 @@
-# Finds places connected via route metrics with optional filtering.
+# Finds places connected via routes with optional filtering.
 #
 # @param place_type [String] Required. 'origin' or 'destination'
 # @param place_id [Integer] Optional. Filter by connected place ID
 # @param query [String] Optional. Filter by place name (case-insensitive)
-# @param route_type [Symbol, String] Optional. Filter by route type from route metrics (e.g., :ferry, :bus)
+# @param route_type [Symbol, String] Optional. Filter by route type from associated trips (e.g., :ferry, :bus)
 #
 # @return [ActiveRecord::Relation<SpreeCmCommissioner::Place>]
 #
 # Modes:
 #   - place_id only: returns connected places (origins TO or destinations FROM given place)
 #   - query only: filters by name
-#   - route_type only: filters by route type on route metrics
+#   - route_type only: filters by trip route types on those routes
 #   - combinations: connected places filtered by name and/or route type
-#   - neither: all origins/destinations in route metrics
+#   - neither: all origins/destinations in routes
 #
-# @example Origins with ferry route metrics to place 123
+# @example Origins with ferry trips to place 123
 #   FindWithRoute.new(place_type: 'origin', place_id: 123, route_type: :ferry).execute
 #
 # @example Destinations filtered by query and route type
@@ -46,14 +46,14 @@ module SpreeCmCommissioner
       def scope
         return SpreeCmCommissioner::Place.none unless valid_place_type?
 
-        base_scope = origin? ? SpreeCmCommissioner::Place.with_route_metrics_as_origin : SpreeCmCommissioner::Place.with_route_metrics_as_destination
+        base_scope = origin? ? SpreeCmCommissioner::Place.with_routes_as_origin : SpreeCmCommissioner::Place.with_routes_as_destination
 
         return base_scope if place_id.blank?
 
         if origin?
-          base_scope.where(route_metrics_as_origin: { destination_place_id: place_id })
+          base_scope.where(routes_as_origin: { destination_place_id: place_id })
         else
-          base_scope.where(route_metrics_as_destination: { origin_place_id: place_id })
+          base_scope.where(routes_as_destination: { origin_place_id: place_id })
         end
       end
 
@@ -62,10 +62,10 @@ module SpreeCmCommissioner
       end
 
       def apply_route_type_filter(result)
-        # Use the association name as the table alias in the WHERE clause
-        # This works whether the association is already joined or not
-        association_name = origin? ? :route_metrics_as_origin : :route_metrics_as_destination
-        result.where(association_name => { route_type: route_type.to_sym })
+        trips_association = origin? ? :trips_as_origin : :trips_as_destination
+        result.joins(trips_association)
+              .where(cm_trips: { route_type: route_type.to_sym })
+              .distinct
       end
 
       def origin?

data/app/finders/spree_cm_commissioner/routes/find_popular.rb

@@ -1,30 +1,46 @@
-# Finder to get popular route metrics scoped to a vendor or tenant.
-# Orders by fulfilled_order_count DESC, then order_count DESC.
-# Usage:
-#   finder = SpreeCmCommissioner::Routes::FindPopular.new(vendor: vendor, route_type: :bus, limit: 10)
-#   finder.execute
+# Finds routes ordered by popularity based on order metrics.
+#
+# Routes are sorted by:
+# 1. fulfilled_order_count (completed orders) - DESC
+# 2. order_count (total orders including incomplete) - DESC
+#
+# @param route_type [Symbol, String] Optional. Filter by route type from associated trips (e.g., :ferry, :bus)
+#
+# @return [ActiveRecord::Relation<SpreeCmCommissioner::Route>] Routes with origin and destination places loaded,
+#   ordered from most to least popular
+#
+# @example Get all popular routes
+#   finder = SpreeCmCommissioner::Routes::FindPopular.new
+#   finder.execute # => Returns all routes sorted by fulfillment and order counts
+#
+# @example Get popular ferry routes
+#   finder = SpreeCmCommissioner::Routes::FindPopular.new
+#   finder.execute(route_type: :ferry) # => Returns ferry routes sorted by popularity
+#
+# @example Get popular bus routes
+#   finder = SpreeCmCommissioner::Routes::FindPopular.new
+#   finder.execute(route_type: :bus) # => Returns bus routes sorted by popularity
 
 module SpreeCmCommissioner
   module Routes
     class FindPopular
-      def initialize(vendor: nil, tenant: nil, route_type: nil, limit: 20)
-        @vendor = vendor
-        @tenant = tenant
-        @route_type = route_type
-        @limit = limit.to_i
-      end
-
-      def execute
-        scope = SpreeCmCommissioner::Route.includes(:origin_place, :destination_place, :route_photos)
-        scope = scope.where(vendor_id: vendor.id) if vendor.present?
-        scope = scope.where(tenant_id: tenant.id) if tenant.present?
-        scope = scope.where(route_type: route_type.to_s) if route_type.present?
-        scope.order(fulfilled_order_count: :desc, order_count: :desc).limit(limit)
+      def execute(route_type: nil, query: nil)
+        scope(route_type: route_type, query: query)
       end
 
       private
 
-      attr_reader :vendor, :tenant, :route_type, :limit
+      def scope(route_type:, query:)
+        includes_associations = %i[origin_place destination_place]
+        includes_associations << :trips if route_type.present?
+        result = SpreeCmCommissioner::Route.includes(*includes_associations)
+
+        result = result.joins(:trips).where(cm_trips: { route_type: route_type.to_sym }) if route_type.present?
+
+        result = result.where('cm_routes.route_name ILIKE ?', "%#{query}%") if query.present?
+
+        result.distinct.order(fulfilled_order_count: :desc, order_count: :desc)
+      end
     end
   end
 end

data/app/interactors/spree_cm_commissioner/stock/permanent_inventory_items_generator.rb

@@ -33,18 +33,11 @@ module SpreeCmCommissioner
         end
       end
 
-      # Returns dates for which inventory should be generated, based on calendar or default period.
       def inventory_dates_for(variant)
-        calendar = variant.product&.service_calendar
+        start_date = Time.zone.tomorrow
+        end_date = Time.zone.today + pre_inventory_days_for(variant)
 
-        if calendar.present?
-          calendar.start_date.upto(calendar.end_date).select { |date| calendar.service_available?(date) }
-        else
-          start_date = Time.zone.tomorrow
-          end_date = Time.zone.today + pre_inventory_days_for(variant)
-
-          start_date.upto(end_date).to_a
-        end
+        (start_date..end_date)
       end
 
       def inventory_exist?(variant, inventory_date)
@@ -75,7 +68,7 @@ module SpreeCmCommissioner
       def variants
         scope = Spree::Variant.active.with_permanent_stock.where(is_master: false)
         scope = scope.where(id: variant_ids) if variant_ids.present?
-        scope.includes(product: :service_calendar)
+        scope
       end
     end
   end

data/app/interactors/spree_cm_commissioner/stock/stock_movement_creator.rb

@@ -8,8 +8,7 @@ module SpreeCmCommissioner
 
         return context.fail!(message: Spree.t(:doesnt_track_inventory)) unless variant.track_inventory?
 
-        stock_location = resolve_stock_location(variant, stock_location_id)
-
+        stock_location = Spree::StockLocation.find(stock_location_id)
         stock_movement = stock_location.stock_movements.build(stock_movement_params)
         stock_movement.stock_item = stock_location.set_up_stock_item(variant)
 
@@ -23,14 +22,6 @@ module SpreeCmCommissioner
 
       private
 
-      def resolve_stock_location(variant, stock_location_id = nil)
-        if stock_location_id.present?
-          Spree::StockLocation.find(stock_location_id)
-        else
-          variant.vendor.stock_locations.first || variant.vendor.send(:create_stock_location)
-        end
-      end
-
       def adjust_inventory_items_async(variant_id, quantity)
         args = { variant_id: variant_id, quantity: quantity }
         CmAppLogger.log(label: "#{self.class.name}#adjust_inventory_items_async", data: args) do

data/app/{services/spree_cm_commissioner/transit_order/create.rb → interactors/spree_cm_commissioner/transit/draft_order_creator.rb}

@@ -1,4 +1,4 @@
-# SpreeCmCommissioner::TransitOrder::Create creates a new order for a entire journey, including outbound and (if present) inbound directions.
+# DraftOrderCreator creates a new order for a entire journey, including outbound and (if present) inbound directions.
 #
 # Attributes:
 # - outbound_date: [Date] The date of outbound transit
@@ -12,22 +12,25 @@
 #
 # Note: inbound_legs and inbound_date are optional; the order may represent a one-way (outbound only) journey.
 module SpreeCmCommissioner
-  module TransitOrder
-    class Create
-      prepend ::Spree::ServiceModule::Base
+  module Transit
+    class DraftOrderCreator < BaseInteractor
+      delegate :outbound_date,
+               :inbound_date,
+               :outbound_legs,
+               :inbound_legs,
+               :user, to: :context
 
-      def call(outbound_date:, inbound_date:, outbound_legs:, inbound_legs: [], user: nil)
-        return failure(nil, 'Outbound legs are missing') if outbound_legs.blank?
+      def call
+        return context.fail!(message: 'Outbound legs are missing') if outbound_legs.blank?
 
         begin
-          order = create_order!(outbound_date, inbound_date, outbound_legs, inbound_legs, user)
-          success(order: order)
+          context.order = create_order!
         rescue StandardError => e
-          failure(nil, e.message)
+          context.fail!(message: e.message)
         end
       end
 
-      def create_order!(outbound_date, inbound_date, outbound_legs, inbound_legs, user)
+      def create_order!
         order = Spree::Order.new(state: 'cart', use_billing: true, user: user)
 
         outbound_line_items = build_line_items_for_legs!(order: order, legs: outbound_legs, initial_date: outbound_date)
@@ -109,10 +112,10 @@ module SpreeCmCommissioner
 
       def insert_saved_guests_per_line_items_leg(line_items)
         line_items.flat_map(&:guests).each_with_index do |guest, index|
-          @saved_guests ||= []
-          @saved_guests << SpreeCmCommissioner::SavedGuest.new if @saved_guests[index].blank?
+          context.saved_guests ||= []
+          context.saved_guests << SpreeCmCommissioner::SavedGuest.new if context.saved_guests[index].blank?
 
-          guest.saved_guest = @saved_guests[index]
+          guest.saved_guest = context.saved_guests[index]
         end
 
         line_items

data/app/interactors/spree_cm_commissioner/trip_clone_creator.rb

@@ -91,10 +91,9 @@ module SpreeCmCommissioner
       stop_params = params.dig(:trip_stops_attributes, index.to_s)
       return unless stop_params
 
-      cloned_stop.departure_time = parse_time(stop_params[:departure_time])
-      cloned_stop.arrival_time = parse_time(stop_params[:arrival_time])
-      cloned_stop.allow_boarding = stop_params[:allow_boarding] if stop_params.key?(:allow_boarding)
-      cloned_stop.allow_drop_off = stop_params[:allow_drop_off] if stop_params.key?(:allow_drop_off)
+      cloned_stop.departure_time    = parse_time(stop_params[:departure_time])
+      cloned_stop.arrival_time      = parse_time(stop_params[:arrival_time])
+      cloned_stop.stop_type         = stop_params[:stop_type].presence
       cloned_stop.location_place_id = stop_params[:location_place_id].presence
     end
 

data/app/interactors/spree_cm_commissioner/trip_stops_creator.rb

@@ -26,7 +26,7 @@ module SpreeCmCommissioner
         trip: trip,
         stop_place: origin_place,
         location_place: origin_place,
-        allow_boarding: true
+        stop_type: :boarding
       }
 
       attributes[:departure_time] = departure_time
@@ -42,7 +42,7 @@ module SpreeCmCommissioner
         trip: trip,
         stop_place: destination_place,
         location_place: destination_place,
-        allow_drop_off: true
+        stop_type: :drop_off
       }
 
       attributes[:arrival_time] = departure_time + duration_seconds.seconds

data/app/jobs/spree_cm_commissioner/stock/permanent_inventory_items_generator_job.rb

@@ -1,8 +1,8 @@
 module SpreeCmCommissioner
   module Stock
     class PermanentInventoryItemsGeneratorJob < ApplicationUniqueJob
-      def perform(options = {})
-        SpreeCmCommissioner::Stock::PermanentInventoryItemsGenerator.call(options)
+      def perform
+        SpreeCmCommissioner::Stock::PermanentInventoryItemsGenerator.call
       end
     end
   end

data/app/jobs/spree_cm_commissioner/transit/route_fulfilled_order_count_incrementer_job.rb

@@ -0,0 +1,10 @@
+module SpreeCmCommissioner
+  module Transit
+    class RouteFulfilledOrderCountIncrementerJob < ApplicationUniqueJob
+      def perform(options = {})
+        order = Spree::Order.find(options[:order_id])
+        SpreeCmCommissioner::Routes::IncrementFulfilledOrderCount.call(order: order)
+      end
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/transit/route_order_count_incrementer_job.rb

@@ -0,0 +1,10 @@
+module SpreeCmCommissioner
+  module Transit
+    class RouteOrderCountIncrementerJob < ApplicationUniqueJob
+      def perform(options = {})
+        order = Spree::Order.find(options[:order_id])
+        SpreeCmCommissioner::Routes::IncrementOrderCount.call(order: order)
+      end
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/transit/route_previous_trip_count_decrementer_job.rb

@@ -0,0 +1,13 @@
+# Perform the previous-route decrement outside the Trip transaction.
+
+module SpreeCmCommissioner
+  module Transit
+    class RoutePreviousTripCountDecrementerJob < ApplicationUniqueJob
+      queue_as :default
+
+      def perform(options = {})
+        SpreeCmCommissioner::Routes::DecrementPreviousTripCount.call(previous_route_id: options[:previous_route_id])
+      end
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/transit/route_trip_count_decrementer_job.rb

@@ -0,0 +1,10 @@
+module SpreeCmCommissioner
+  module Transit
+    class RouteTripCountDecrementerJob < ApplicationUniqueJob
+      def perform(options = {})
+        trip = SpreeCmCommissioner::Trip.find(options[:trip_id])
+        SpreeCmCommissioner::Routes::DecrementTripCount.call(trip: trip)
+      end
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/transit/route_trip_count_incrementer_job.rb

@@ -0,0 +1,10 @@
+module SpreeCmCommissioner
+  module Transit
+    class RouteTripCountIncrementerJob < ApplicationUniqueJob
+      def perform(options = {})
+        trip = SpreeCmCommissioner::Trip.find(options[:trip_id])
+        SpreeCmCommissioner::Routes::IncrementTripCount.call(trip: trip)
+      end
+    end
+  end
+end

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

@@ -7,13 +7,13 @@ module SpreeCmCommissioner
     def increment_route_fulfilled_order_count
       return unless has_trip_ids?
 
-      SpreeCmCommissioner::RouteMetrics::IncreaseFulfilledOrderCountJob.perform_later(order_id: id)
+      SpreeCmCommissioner::Transit::RouteFulfilledOrderCountIncrementerJob.perform_later(order_id: id)
     end
 
     def increment_route_order_count
       return unless has_trip_ids?
 
-      SpreeCmCommissioner::RouteMetrics::IncreaseOrderCountJob.perform_later(order_id: id)
+      SpreeCmCommissioner::Transit::RouteOrderCountIncrementerJob.perform_later(order_id: id)
     end
   end
 end

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

@@ -0,0 +1,48 @@
+module SpreeCmCommissioner
+  module RouteTripCountCallbacks
+    extend ActiveSupport::Concern
+
+    included do
+      after_create :increase_trip_count
+      before_destroy :decrease_trip_count
+
+      # When route context may change, enqueue an async job after commit that
+      # reads the previous values from `previous_changes` to decrement counts
+      # on the old route/vendor. This avoids keeping in-memory state and keeps
+      # the Trip update fast.
+      after_commit :enqueue_decrement_previous_route_trip_counts, on: :update
+
+      after_commit :increment_new_route_trip_counts, on: :update, if: :changed_route_context?
+    end
+
+    private
+
+    def decrease_trip_count
+      SpreeCmCommissioner::Transit::RouteTripCountDecrementerJob.perform_now(trip_id: id)
+    end
+
+    def increase_trip_count
+      SpreeCmCommissioner::Transit::RouteTripCountIncrementerJob.perform_later(trip_id: id)
+    end
+
+    # Read previous_changes to find prior route context and enqueue the job.
+    def enqueue_decrement_previous_route_trip_counts
+      prev_route_id = previous_changes['route_id']&.first
+      prev_origin_id = previous_changes['origin_place_id']&.first
+      prev_destination_id = previous_changes['destination_place_id']&.first
+
+      return unless prev_route_id.present? && prev_origin_id.present? && prev_destination_id.present?
+
+      SpreeCmCommissioner::Transit::RoutePreviousTripCountDecrementerJob.perform_later(
+        previous_route_id: prev_route_id
+      )
+    end
+
+    # Safely increment the trip_count for the trip's (new) route after update.
+    def increment_new_route_trip_counts
+      return if origin_place_id.blank? || destination_place_id.blank? || route_id.blank?
+
+      SpreeCmCommissioner::Transit::RouteTripCountIncrementerJob.perform_later(trip_id: id)
+    end
+  end
+end

data/app/models/spree_cm_commissioner/place.rb

@@ -21,12 +21,15 @@ module SpreeCmCommissioner
     has_many :taxon_places, class_name: 'SpreeCmCommissioner::TaxonPlace', dependent: :destroy
     has_many :taxons, through: :taxon_places
 
-    has_many :route_metrics_as_origin, class_name: 'SpreeCmCommissioner::RouteMetric', foreign_key: :origin_place_id
-    has_many :route_metrics_as_destination, class_name: 'SpreeCmCommissioner::RouteMetric', foreign_key: :destination_place_id
+    has_many :routes_as_origin, class_name: 'SpreeCmCommissioner::Route', foreign_key: :origin_place_id
+    has_many :routes_as_destination, class_name: 'SpreeCmCommissioner::Route', foreign_key: :destination_place_id
 
-    # Scopes for route metric filtering
-    scope :with_route_metrics_as_origin, -> { joins(:route_metrics_as_origin).distinct }
-    scope :with_route_metrics_as_destination, -> { joins(:route_metrics_as_destination).distinct }
+    has_many :trips_as_origin, through: :routes_as_origin, source: :trips
+    has_many :trips_as_destination, through: :routes_as_destination, source: :trips
+
+    # Scopes for route-based filtering
+    scope :with_routes_as_origin, -> { joins(:routes_as_origin).distinct }
+    scope :with_routes_as_destination, -> { joins(:routes_as_destination).distinct }
 
     def self.ransackable_attributes(auth_object = nil)
       super & %w[name code]

data/app/models/spree_cm_commissioner/product_decorator.rb

@@ -48,7 +48,6 @@ module SpreeCmCommissioner
       base.accepts_nested_attributes_for :product_places, allow_destroy: true
 
       base.has_one :trip, class_name: 'SpreeCmCommissioner::Trip', dependent: :destroy
-      base.has_one :service_calendar, as: :calendarable, class_name: 'SpreeCmCommissioner::ServiceCalendar', dependent: :destroy
 
       base.belongs_to :event, class_name: 'Spree::Taxon', optional: true
 

data/app/models/spree_cm_commissioner/route.rb

@@ -1,52 +1,12 @@
 module SpreeCmCommissioner
   class Route < Base
-    include SpreeCmCommissioner::RouteType
-
-    belongs_to :vendor, class_name: 'Spree::Vendor', optional: false
-    belongs_to :tenant, class_name: 'SpreeCmCommissioner::Tenant', optional: true
-
-    belongs_to :origin_place, class_name: 'SpreeCmCommissioner::Place', optional: false
-    belongs_to :destination_place, class_name: 'SpreeCmCommissioner::Place', optional: false
-
-    has_one :primary_photo, -> { order(position: :asc) }, class_name: 'SpreeCmCommissioner::RoutePhoto',
-                                                          as: :viewable,
-                                                          dependent: :destroy
-    has_many :route_photos, class_name: 'SpreeCmCommissioner::RoutePhoto', as: :viewable, dependent: :destroy
-
+    has_many :vendor_routes, class_name: 'SpreeCmCommissioner::VendorRoute', dependent: :destroy
+    has_many :vendors, through: :vendor_routes
     has_many :trips, inverse_of: :route
 
-    validates :route_name, presence: true
-
-    validate :validate_route_stops
-
-    delegate :multi_leg?, to: :route_stops
-
-    def self.ransackable_attributes(_auth_object = nil)
-      %w[route_type short_name route_name]
-    end
-
-    def route_stops
-      Transit::RouteStopCollection.from_hash(read_attribute(:route_stops))
-    end
-
-    def route_stops=(value)
-      if value.is_a?(Transit::RouteStopCollection)
-        @route_stops = value
-        self[:route_stops] = value.to_h
-      elsif value.is_a?(Array)
-        @route_stops = Transit::RouteStopCollection.from_hash(value)
-        self[:route_stops] = @route_stops.to_h
-      else
-        raise ArgumentError, 'route_stops must be an Array or RouteStopCollection'
-      end
-    end
-
-    private
-
-    def validate_route_stops
-      return if route_stops.valid?
+    belongs_to :origin_place, class_name: 'SpreeCmCommissioner::Place'
+    belongs_to :destination_place, class_name: 'SpreeCmCommissioner::Place'
 
-      route_stops.errors.each { |error| errors.add(:route_stops, error) }
-    end
+    validates :origin_place_id, uniqueness: { scope: :destination_place_id }
   end
 end