spree_cm_commissioner 2.5.1.pre.pre3 → 2.5.1.pre.pre4

data/app/jobs/spree_cm_commissioner/route_metrics/increase_trip_count_job.rb

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

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
-        SpreeCmCommissioner::Stock::PermanentInventoryItemsGenerator.call
+      def perform(options = {})
+        SpreeCmCommissioner::Stock::PermanentInventoryItemsGenerator.call(options)
       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::Transit::RouteFulfilledOrderCountIncrementerJob.perform_later(order_id: id)
+      SpreeCmCommissioner::RouteMetrics::IncreaseFulfilledOrderCountJob.perform_later(order_id: id)
     end
 
     def increment_route_order_count
       return unless has_trip_ids?
 
-      SpreeCmCommissioner::Transit::RouteOrderCountIncrementerJob.perform_later(order_id: id)
+      SpreeCmCommissioner::RouteMetrics::IncreaseOrderCountJob.perform_later(order_id: id)
     end
   end
 end

data/app/models/spree_cm_commissioner/place.rb

@@ -21,15 +21,12 @@ module SpreeCmCommissioner
     has_many :taxon_places, class_name: 'SpreeCmCommissioner::TaxonPlace', dependent: :destroy
     has_many :taxons, through: :taxon_places
 
-    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
+    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 :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 }
+    # 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 }
 
     def self.ransackable_attributes(auth_object = nil)
       super & %w[name code]

data/app/models/spree_cm_commissioner/product_decorator.rb

@@ -48,6 +48,7 @@ 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,12 +1,52 @@
 module SpreeCmCommissioner
   class Route < Base
-    has_many :vendor_routes, class_name: 'SpreeCmCommissioner::VendorRoute', dependent: :destroy
-    has_many :vendors, through: :vendor_routes
+    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 :trips, inverse_of: :route
 
-    belongs_to :origin_place, class_name: 'SpreeCmCommissioner::Place'
-    belongs_to :destination_place, class_name: 'SpreeCmCommissioner::Place'
+    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?
 
-    validates :origin_place_id, uniqueness: { scope: :destination_place_id }
+      route_stops.errors.each { |error| errors.add(:route_stops, error) }
+    end
   end
 end

data/app/models/spree_cm_commissioner/route_metric.rb

@@ -0,0 +1,21 @@
+module SpreeCmCommissioner
+  class RouteMetric < Base
+    include SpreeCmCommissioner::RouteType
+
+    belongs_to :origin_place, class_name: 'SpreeCmCommissioner::Place', optional: false
+    belongs_to :destination_place, class_name: 'SpreeCmCommissioner::Place', optional: false
+
+    validates :route_type, presence: true
+    validates :route_type, uniqueness: { scope: %i[origin_place_id destination_place_id] }
+
+    validate :origin_and_destination_cannot_be_the_same
+
+    private
+
+    def origin_and_destination_cannot_be_the_same
+      return unless origin_place_id == destination_place_id
+
+      errors.add(:base, 'Origin and destination cannot be the same')
+    end
+  end
+end

data/app/models/spree_cm_commissioner/route_photo.rb

@@ -0,0 +1,12 @@
+module SpreeCmCommissioner
+  class RoutePhoto < Asset
+    # 16x9
+    def asset_styles
+      {
+        mini: '160x90>',
+        small: '480x270>',
+        medium: '960x540>'
+      }
+    end
+  end
+end

data/app/models/spree_cm_commissioner/trip.rb

@@ -2,7 +2,6 @@ module SpreeCmCommissioner
   class Trip < Base
     include SpreeCmCommissioner::StoreMetadata
     include SpreeCmCommissioner::RouteType
-    include SpreeCmCommissioner::RouteTripCountCallbacks
 
     attr_accessor :hours, :minutes, :seconds
 
@@ -15,7 +14,9 @@ module SpreeCmCommissioner
 
     # before create, duplicate seat layout from vehicle_type if present
     before_validation :duplicate_seat_layout_from_vehicle, if: -> { seat_layout.nil? && vehicle_type&.seat_layout.present? }
-    before_validation :assign_route_and_vendor_route, if: :changed_route_attributes?
+
+    after_create :increment_route_metric_trip_count
+    before_destroy :decrement_route_metric_trip_count
 
     belongs_to :vendor, class_name: 'Spree::Vendor', inverse_of: :trips, optional: false
     belongs_to :product, class_name: 'Spree::Product', inverse_of: :trip, optional: false
@@ -26,7 +27,7 @@ module SpreeCmCommissioner
 
     belongs_to :origin_place, class_name: 'SpreeCmCommissioner::Place', optional: false
     belongs_to :destination_place, class_name: 'SpreeCmCommissioner::Place', optional: false
-    belongs_to :route, inverse_of: :trips
+    belongs_to :route, class_name: 'SpreeCmCommissioner::Route', inverse_of: :trips, optional: true
 
     has_many :trip_blazer_queries, as: :queryable, class_name: 'SpreeCmCommissioner::BlazerQueryable'
     has_many :blazer_queries, through: :trip_blazer_queries, source: :blazer_query, class_name: 'Blazer::Query'
@@ -48,10 +49,6 @@ module SpreeCmCommissioner
     self.whitelisted_ransackable_associations = %w[product vehicle vehicle_type]
     self.whitelisted_ransackable_attributes = %w[origin_place_id destination_place_id]
 
-    def changed_route_attributes?
-      origin_place_id_changed? || destination_place_id_changed? || vendor_id_changed?
-    end
-
     def convert_duration_to_seconds
       return if hours.blank? && minutes.blank? && seconds.blank?
 
@@ -104,34 +101,12 @@ module SpreeCmCommissioner
                 )
     end
 
-    # Check if any of the route context attributes are changing
-    def will_route_context_change?
-      # Returns true if any of the route context attributes will change on save.
-      will_save_change_to_route_id? ||
-        will_save_change_to_origin_place_id? ||
-        will_save_change_to_destination_place_id? ||
-        will_save_change_to_vendor_id?
-    end
-
-    def changed_route_context?
-      saved_change_to_route_id? ||
-        saved_change_to_origin_place_id? ||
-        saved_change_to_destination_place_id? ||
-        saved_change_to_vendor_id?
+    def increment_route_metric_trip_count
+      SpreeCmCommissioner::RouteMetrics::IncreaseTripCountJob.perform_later(trip_id: id)
     end
 
-    # Find or create the Route for this trip (by origin/destination) and
-    # assign it to the trip. Also populate a default route_name from the
-    # product when the route is new/blank.
-    def assign_route_and_vendor_route
-      route = SpreeCmCommissioner::Route.find_or_create_by!(
-        origin_place_id: origin_place_id,
-        destination_place_id: destination_place_id
-      )
-      route.route_name = product.name if route.route_name.blank?
-      route.save! if route.changed?
-
-      self.route_id = route.id
+    def decrement_route_metric_trip_count
+      SpreeCmCommissioner::RouteMetrics::DecreaseTripCountJob.perform_later(trip_id: id)
     end
   end
 end

data/app/models/spree_cm_commissioner/trip_stop.rb

@@ -1,25 +1,39 @@
 module SpreeCmCommissioner
   class TripStop < Base
     acts_as_list column: :sequence, scope: :trip_id
-    enum :stop_type, { boarding: 0, drop_off: 1 }
 
     belongs_to :trip, class_name: 'SpreeCmCommissioner::Trip', optional: false
     belongs_to :stop_place, class_name: 'SpreeCmCommissioner::Place', optional: false
     belongs_to :location_place, class_name: 'SpreeCmCommissioner::Place', optional: false
 
+    belongs_to :board_to_trip, class_name: 'SpreeCmCommissioner::Trip', optional: true
+
     before_validation :set_stop_name
+
     validates :stop_place_id, uniqueness: { scope: :trip_id }
+    validate :boarding_trip_requires_allow_boarding
+
+    scope :boarding, -> { where(allow_boarding: true) }
+    scope :drop_off, -> { where(allow_drop_off: true) }
 
     def set_stop_name
       self.stop_name = stop_place.name if stop_place.present?
     end
 
     def self.ransackable_attributes(_auth_object = nil)
-      %w[stop_name stop_type]
+      %w[stop_name allow_boarding allow_drop_off]
     end
 
     def self.ransackable_associations(_auth_object = nil)
       ['stop_place']
     end
+
+    private
+
+    def boarding_trip_requires_allow_boarding
+      return unless board_to_trip_id.present? && !allow_boarding?
+
+      errors.add(:board_to_trip, 'requires allow_boarding to be true')
+    end
   end
 end

data/app/models/spree_cm_commissioner/vendor_decorator.rb

@@ -82,7 +82,9 @@ module SpreeCmCommissioner
       base.has_many :subscriptions, through: :customers, class_name: 'SpreeCmCommissioner::Subscription'
       base.has_many :subscription_orders, through: :subscriptions, class_name: 'Spree::Order', source: :orders
       base.has_many :promotion_categories, class_name: 'Spree::PromotionCategory', foreign_key: :vendor_id, dependent: :destroy
-      base.has_many :vendor_routes, class_name: 'SpreeCmCommissioner::VendorRoute'
+      base.has_many :routes, class_name: 'SpreeCmCommissioner::Route', dependent: :destroy
+      base.has_many :popular_routes, -> { order(fulfilled_order_count: :desc, order_count: :desc) },
+                    class_name: 'SpreeCmCommissioner::Route'
 
       base.has_many :homepage_section_relatables,
                     as: :relatable,

data/app/queries/spree_cm_commissioner/trip_query.rb

@@ -77,8 +77,8 @@ module SpreeCmCommissioner
 
       scope
         .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_trip_stops AS boarding ON boarding.trip_id = cm_trips.id AND boarding.allow_boarding = true
+          INNER JOIN cm_trip_stops AS drop_off ON drop_off.trip_id = cm_trips.id AND drop_off.allow_drop_off = true
           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

data/app/serializers/spree/v2/tenant/transit_cart_serializer.rb

@@ -0,0 +1,11 @@
+module Spree
+  module V2
+    module Tenant
+      class TransitCartSerializer < CartSerializer
+        has_many :line_items, serializer: SpreeCmCommissioner::V2::Storefront::TransitLineItemSerializer
+
+        cache_options store: nil
+      end
+    end
+  end
+end

data/app/serializers/spree_cm_commissioner/v2/storefront/route_metric_serializer.rb

@@ -0,0 +1,13 @@
+module SpreeCmCommissioner
+  module V2
+    module Storefront
+      class RouteMetricSerializer < BaseSerializer
+        set_type :route
+        attributes :route_name
+
+        has_one :origin_place, serializer: ::Spree::V2::Storefront::PlaceSerializer
+        has_one :destination_place, serializer: ::Spree::V2::Storefront::PlaceSerializer
+      end
+    end
+  end
+end

data/app/serializers/spree_cm_commissioner/v2/storefront/route_serializer.rb

@@ -2,8 +2,9 @@ module SpreeCmCommissioner
   module V2
     module Storefront
       class RouteSerializer < BaseSerializer
-        attributes :route_name
+        attributes :route_name, :route_type, :short_name
 
+        has_many :route_photos, serializer: ::SpreeCmCommissioner::V2::Storefront::AssetSerializer
         has_one :origin_place, serializer: ::Spree::V2::Storefront::PlaceSerializer
         has_one :destination_place, serializer: ::Spree::V2::Storefront::PlaceSerializer
       end

data/app/serializers/spree_cm_commissioner/v2/storefront/transit_line_item_serializer.rb

@@ -0,0 +1,17 @@
+module SpreeCmCommissioner
+  module V2
+    module Storefront
+      class TransitLineItemSerializer < BaseSerializer
+        # Nested-only API shape
+        attributes :from_date,
+                   :to_date,
+                   :trip_id,
+                   :direction,
+                   :boarding_trip_stop_id,
+                   :drop_off_trip_stop_id
+
+        cache_options store: nil
+      end
+    end
+  end
+end

data/app/serializers/spree_cm_commissioner/v2/storefront/trip_stop_serializer.rb

@@ -2,7 +2,7 @@ module SpreeCmCommissioner
   module V2
     module Storefront
       class TripStopSerializer < BaseSerializer
-        attributes :id, :stop_type, :stop_name, :arrival_time, :departure_time
+        attributes :id, :allow_boarding, :allow_drop_off, :stop_name, :arrival_time, :departure_time
 
         has_one :stop_place, serializer: ::SpreeCmCommissioner::V2::Storefront::TripPlaceSerializer
       end

data/app/services/spree_cm_commissioner/route_metrics/decrease_trip_count.rb

@@ -0,0 +1,31 @@
+module SpreeCmCommissioner
+  module RouteMetrics
+    class DecreaseTripCount
+      prepend ::Spree::ServiceModule::Base
+
+      def call(trip:)
+        return failure(nil, 'Trip not found') unless trip
+
+        route_metric = find_or_create_route_metric(trip)
+
+        route_metric.with_lock do
+          route_metric.update!(trip_count: [route_metric.trip_count - 1, 0].max)
+        end
+
+        success(trip: trip)
+      rescue StandardError => e
+        failure(nil, e.message)
+      end
+
+      private
+
+      def find_or_create_route_metric(trip)
+        SpreeCmCommissioner::RouteMetric.find_or_create_by!(
+          origin_place_id: trip.origin_place_id,
+          destination_place_id: trip.destination_place_id,
+          route_type: trip.route_type
+        )
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/{routes/increment_fulfilled_order_count.rb → route_metrics/increase_fulfilled_order_count.rb}

@@ -1,12 +1,12 @@
 module SpreeCmCommissioner
-  module Routes
-    class IncrementFulfilledOrderCount
+  module RouteMetrics
+    class IncreaseFulfilledOrderCount
       prepend ::Spree::ServiceModule::Base
 
       def call(order:)
         return failure(nil, 'Order not found') unless order
 
-        SpreeCmCommissioner::Routes::BaseUpdateOrderMetrics
+        SpreeCmCommissioner::RouteMetrics::UpdateRouteMetrics
           .call(order: order, attribute: :fulfilled_order_count)
 
         success(order: order)

data/app/services/spree_cm_commissioner/{routes/increment_order_count.rb → route_metrics/increase_order_count.rb}

@@ -1,12 +1,12 @@
 module SpreeCmCommissioner
-  module Routes
-    class IncrementOrderCount
+  module RouteMetrics
+    class IncreaseOrderCount
       prepend ::Spree::ServiceModule::Base
 
       def call(order:)
         return failure(nil, 'Order not found') unless order
 
-        SpreeCmCommissioner::Routes::BaseUpdateOrderMetrics
+        SpreeCmCommissioner::RouteMetrics::UpdateRouteMetrics
           .new(order: order, attribute: :order_count)
           .call
 

data/app/services/spree_cm_commissioner/route_metrics/increase_trip_count.rb

@@ -0,0 +1,31 @@
+module SpreeCmCommissioner
+  module RouteMetrics
+    class IncreaseTripCount
+      prepend ::Spree::ServiceModule::Base
+
+      def call(trip:)
+        return failure(nil, 'Trip not found') unless trip
+
+        route_metric = find_or_create_route_metric(trip)
+
+        route_metric.with_lock do
+          route_metric.update!(trip_count: route_metric.trip_count + 1)
+        end
+
+        success(trip: trip)
+      rescue StandardError => e
+        failure(nil, e.message)
+      end
+
+      private
+
+      def find_or_create_route_metric(trip)
+        SpreeCmCommissioner::RouteMetric.find_or_create_by!(
+          origin_place_id: trip.origin_place_id,
+          destination_place_id: trip.destination_place_id,
+          route_type: trip.route_type
+        )
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/{routes/base_update_order_metrics.rb → route_metrics/update_route_metrics.rb}

@@ -1,6 +1,6 @@
 module SpreeCmCommissioner
-  module Routes
-    class BaseUpdateOrderMetrics
+  module RouteMetrics
+    class UpdateRouteMetrics
       attr_reader :order, :attribute
 
       SUPPORTED_ATTRIBUTES = %i[order_count fulfilled_order_count].freeze
@@ -31,26 +31,21 @@ module SpreeCmCommissioner
         trip = product&.trip
         return unless trip
 
-        route = find_or_create_route_for_trip(trip)
-        ensure_trip_route(trip, route)
-        increment_route_by(route, line_item.quantity)
+        route_metric = find_or_create_route_metric_for_trip(trip)
+        increment_route_by(route_metric, line_item.quantity)
+
+        route = trip.route
+        increment_route_by(route, line_item.quantity) if route
       end
 
-      def find_or_create_route_for_trip(trip)
-        SpreeCmCommissioner::Route.find_or_create_by(
+      def find_or_create_route_metric_for_trip(trip)
+        SpreeCmCommissioner::RouteMetric.find_or_create_by(
           origin_place_id: trip.origin_place_id,
-          destination_place_id: trip.destination_place_id
+          destination_place_id: trip.destination_place_id,
+          route_type: trip.route_type
         )
       end
 
-      def ensure_trip_route(trip, route)
-        trip_route_id = trip.respond_to?(:route_id) ? trip.route_id : nil
-
-        return unless trip.respond_to?(:update_column) && trip_route_id != route.id
-
-        trip.update_column(:route_id, route.id) # rubocop:disable Rails/SkipsModelValidations
-      end
-
       def increment_route_by(route, qty)
         route.with_lock do
           current_value = route.public_send(attribute) || 0

data/app/services/spree_cm_commissioner/routes/create.rb

@@ -0,0 +1,51 @@
+module SpreeCmCommissioner
+  module Routes
+    class Create
+      prepend ::Spree::ServiceModule::Base
+
+      # @param vendor [Spree::Vendor]
+      # @param route_params [Hash]
+      # @param route_stops [SpreeCmCommissioner::Transit::RouteStopCollection]
+      def call(vendor:, route_params:, route_stops:)
+        # vendor_id, tenant_id, origin_place_id, destination_place_id are excluded and set automatically.
+        attrs = ::Spree::PermittedAttributes.route_attributes
+                                            .index_with { |attr_key| route_params[attr_key] }
+                                            .except(:vendor_id, :tenant_id, :route_stops, :origin_place_id, :destination_place_id)
+                                            .compact
+
+        return failure(nil, 'Route stops are required') if route_stops.length < 2
+
+        origin_place = find_place_for(route_stops, route_stops.first)
+        destination_place = find_place_for(route_stops, route_stops.last)
+
+        return failure(nil, 'Origin or destination place could not be determined') if origin_place.nil? || destination_place.nil?
+        return failure(nil, 'Route with origin & destination already exists') if vendor.routes.exists?(
+          origin_place_id: origin_place.id,
+          destination_place_id: destination_place.id
+        )
+
+        attrs = attrs.merge(
+          tenant_id: vendor.tenant_id,
+          route_name: attrs[:route_name] || "#{origin_place.name} -> #{destination_place.name}",
+          origin_place_id: origin_place.id,
+          destination_place_id: destination_place.id,
+          route_stops: route_stops
+        )
+
+        route = vendor.routes.new(attrs)
+        if route.save
+          success(route: route)
+        else
+          failure(route.errors)
+        end
+      end
+
+      def find_place_for(route_stops, route_stop)
+        return nil if route_stop.nil?
+
+        @locations ||= SpreeCmCommissioner::VendorPlace.where(id: route_stops.map(&:location_id).uniq).index_by(&:id)
+        @locations[route_stop.location_id]&.place
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/routes/update.rb

@@ -0,0 +1,25 @@
+module SpreeCmCommissioner
+  module Routes
+    class Update
+      prepend ::Spree::ServiceModule::Base
+
+      def call(vendor:, route:, route_params:)
+        # vendor_id, tenant_id, origin_place_id, destination_place_id are excluded and set automatically.
+        # route_stops is not updateable.
+        attrs = ::Spree::PermittedAttributes.route_attributes
+                                            .index_with { |attr_key| route_params[attr_key] }
+                                            .except(:vendor_id, :tenant_id, :route_stops, :origin_place_id, :destination_place_id)
+                                            .compact
+
+        route = vendor.routes.find_by(id: route.id)
+        return failure(nil, :route_not_found) if route.nil?
+
+        if route.update(attrs)
+          success(route: route)
+        else
+          failure(route.errors)
+        end
+      end
+    end
+  end
+end

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

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