spree_cm_commissioner 2.5.16.pre.pre8 → 2.5.16.pre.pre9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 659785b7538c0a039babbe93d0c14a08171ecc75c4131cb0de992da84d3bfac0
-  data.tar.gz: 548dff81e18f044aaedb94cc3a886cfd2c2600338a6760fc2e2c1ef04d75508c
+  metadata.gz: 2046dd747c4cf51ac0d7e234515660e7245e55327647299bf7f132bf4aae78e8
+  data.tar.gz: fd9229c34306586e999a0fbaab5e2a8e90b57ceed353eba6fe6b3e6230105eb1
 SHA512:
-  metadata.gz: 43a7f398986a3b4ed009505986cd705d7556d9b2413f8ff003ab7f9d0bd099e52b69bd86717fd4b927e87fd1bfa4e5e1b2b6df39233b83cb1f2685dc27613b3e
-  data.tar.gz: e3e9ffda8081870c8fe88d1d4c61f1b57495825d194c62c790698e4d0c00d44a2afffe4cffe06e5b7fe99a65127fbbd2989266d37b2b494f0c1e337c732c74d5
+  metadata.gz: 8472c56f7159e01aea47fbb5add8613d6f9b0158c95de0bca11c149fd7e8c15e2d8e67fa69b3bd97ccef545c7e94a4d580bd2f4e604d54ca6914948c62a3c6bd
+  data.tar.gz: 3d78511c0dd9b9d21c9bf26c044fe304d88f246f243ce7a81101bc9ea42172cc9127ba6db150f7e4923060fb3e0d6c1140b1d35076c56b8b1e9838e2fabe3ab4

data/Gemfile.lock

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

data/app/controllers/spree/api/v2/organizer/invite_guests_controller.rb

@@ -0,0 +1,91 @@
+module Spree
+  module Api
+    module V2
+      module Organizer
+        class InviteGuestsController < ::Spree::Api::V2::Organizer::BaseController
+          before_action :load_invite_guest_by_token, only: :show
+          before_action :load_invite_guest, :assign_line_item_data, only: :update
+
+          def show
+            render_serialized_payload { serialize_resource(@invite_guest) }
+          end
+
+          def update
+            return render_error(:revoked) if @invite_guest.revoked?
+            return render_error(:closed) if @invite_guest.expired?
+            return render_error(:fully_claimed) if @invite_guest.fully_claimed?
+
+            guest = @line_item.guests.new(guest_params)
+            guest.event_id = @invite_guest.event_id
+
+            if guest.save
+              @invite_guest.update(claimed_status: :claimed) if @line_item.guests.count == @invite_guest.quantity
+              send_guest_claimed_invitation_telegram_alert_to_vendor(guest) if guest.event.vendor.preferred_telegram_chat_id.present?
+
+              render json: SpreeCmCommissioner::V2::Storefront::GuestSerializer.new(guest.reload).serializable_hash
+            else
+              render_error_payload(guest.errors.full_messages.to_sentence)
+            end
+          end
+
+          private
+
+          def send_guest_claimed_invitation_telegram_alert_to_vendor(guest)
+            title = '📣 --- [NEW GUEST CLAIMED INVITATION] ---' # Style/StringLiterals
+            chat_id = guest.event.vendor.preferred_telegram_chat_id
+            return if chat_id.blank?
+
+            factory = SpreeCmCommissioner::InviteGuestClaimedTelegramMessageFactory.new(
+              title: title,
+              order: @invite_guest.order,
+              guest: guest,
+              vendor: guest.event.vendor
+            )
+            SpreeCmCommissioner::TelegramNotificationSenderJob.perform_later(
+              chat_id: chat_id,
+              message: factory.message,
+              parse_mode: factory.parse_mode
+            )
+          end
+
+          def load_invite_guest_by_token
+            @invite_guest = SpreeCmCommissioner::InviteGuest.find_by(token: params[:id])
+          rescue ActiveRecord::RecordNotFound
+            render_error_payload(I18n.t('invite.url_not_found'))
+          end
+
+          def load_invite_guest
+            @invite_guest = SpreeCmCommissioner::InviteGuest.find(params[:id])
+          end
+
+          def assign_line_item_data
+            @line_item = @invite_guest.order.line_items.first
+            @guests = @line_item.guests
+          end
+
+          def render_error(message)
+            render json: { errors: message }
+          end
+
+          def guest_params
+            params.require(:invite_guest).permit(
+              :first_name,
+              :last_name,
+              :dob,
+              :gender,
+              :age,
+              :emergency_contact,
+              :phone_number,
+              :address,
+              :other_organization
+            )
+          end
+
+          def resource_serializer
+            ::Spree::V2::Organizer::InviteGuestSerializer
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class SavedGuestsController < ::Spree::Api::V2::ResourceController
+          before_action :require_spree_current_user
+          before_action :load_saved_guest, only: %i[show update destroy]
+
+          def collection
+            spree_current_user.saved_guests.order(created_at: :desc)
+                              .page(params[:page])
+                              .per(params[:per_page])
+          end
+
+          def create
+            saved_guest = spree_current_user.saved_guests.new(saved_guest_params)
+
+            if saved_guest.save
+              render_serialized_payload(201) { serialize_resource(saved_guest) }
+            else
+              render_error_payload(saved_guest.errors.full_messages.to_sentence, 422)
+            end
+          end
+
+          def update
+            if @saved_guest.update(saved_guest_params)
+              render_serialized_payload { serialize_resource(@saved_guest) }
+            else
+              render_error_payload(@saved_guest.errors.full_messages.to_sentence, 400)
+            end
+          end
+
+          def destroy
+            @saved_guest.destroy
+            head :no_content
+          end
+
+          private
+
+          def model_class
+            SpreeCmCommissioner::SavedGuest
+          end
+
+          def collection_serializer
+            resource_serializer
+          end
+
+          def resource_serializer
+            SpreeCmCommissioner::V2::Storefront::SavedGuestSerializer
+          end
+
+          def load_saved_guest
+            @saved_guest = spree_current_user.saved_guests.find(params[:id])
+          end
+
+          def saved_guest_params
+            params.require(:saved_guest).permit(
+              :first_name,
+              :last_name,
+              :dob,
+              :age,
+              :gender,
+              :email,
+              :country_code,
+              :phone_number,
+              :intel_phone_number,
+              :nationality_id,
+              :occupation_id,
+              :nationality_group,
+              :age_group
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/helpers/spree_cm_commissioner/transit/trip_helper.rb

@@ -7,34 +7,6 @@ module SpreeCmCommissioner
         formatted_time = Time.zone.parse(time.to_s)
         timezone ? formatted_time.in_time_zone(timezone) : formatted_time
       end
-
-      # Helper to parse date strings or return date objects
-      def parse_date(date_obj)
-        return date_obj if date_obj.is_a?(Date)
-
-        Date.parse(date_obj.to_s)
-      rescue ArgumentError
-        nil
-      end
-
-      def normalize_date(value)
-        if value.respond_to?(:to_date) && value.to_date == Time.zone.now.to_date
-          Time.zone.now
-        else
-          Time.zone.parse(value.to_s)
-        end
-      end
-
-      def minutes_since_midnight(value)
-        case value
-        when Time, ActiveSupport::TimeWithZone
-          (value.hour * 60) + value.min
-        else
-          str = value.to_s.strip
-          h, m = str.split(':', 2).map(&:to_i)
-          (h * 60) + (m || 0)
-        end
-      end
     end
   end
 end

data/app/interactors/spree_cm_commissioner/create_vendor.rb

@@ -11,6 +11,8 @@ module SpreeCmCommissioner
         create_logo
         create_role
       end
+
+      context.vendor = @vendor
     end
 
     private

data/app/models/spree_cm_commissioner/trip.rb

@@ -5,8 +5,6 @@ module SpreeCmCommissioner
 
     attr_accessor :hours, :minutes, :seconds
 
-    enum trip_type: { direct: 0, multi_leg: 1 }
-
     # This model has no seat_layout column (polymorphic association), so we store the preload_seat_layout_id ID in public_metadata.
     # This lets us check if a seat layout exists without triggering a database query.
     # The ID is automatically updated whenever the seat_layout is saved.

data/app/models/spree_cm_commissioner/user_decorator.rb

@@ -24,6 +24,7 @@ module SpreeCmCommissioner
       base.has_many :user_events, class_name: 'SpreeCmCommissioner::UserEvent'
       base.has_many :events, through: :user_events, class_name: 'Spree::Taxon', source: 'taxon'
       base.has_many :guests, class_name: 'SpreeCmCommissioner::Guest', dependent: :destroy
+      base.has_many :saved_guests, class_name: 'SpreeCmCommissioner::SavedGuest', dependent: :nullify
 
       base.has_many :google_user_identity_providers,
                     -> { where(identity_type: :google) },

data/app/queries/spree_cm_commissioner/trip_query.rb

@@ -16,39 +16,139 @@ module SpreeCmCommissioner
     end
 
     def call
-      return Kaminari.paginate_array([]).page(@page).per(@per_page) if date.to_date < Date.current
+      return Kaminari.paginate_array([]) if date.to_date < Date.current
 
-      result = direct_trips
-      result += multi_leg_trips if result.empty? || result.size < 3 || @params[:include_multi_leg] == true
-      Kaminari.paginate_array(result).page(@page).per(@per_page)
+      paginated_relation = direct_trips
+      return Kaminari.paginate_array([]) if paginated_relation.empty?
+
+      unique_trips = paginated_relation.uniq(&:id)
+      results_array = unique_trips.map do |trip|
+        result = build_trip_result(trip)
+        SpreeCmCommissioner::TripQueryResult.new([result])
+      end
+
+      Kaminari.paginate_array(
+        results_array,
+        total_count: unique_trips.size,
+        limit: unique_trips.size,
+        offset: paginated_relation.offset_value
+      )
+    end
+
+    def direct_trips
+      result = trip_scope
+      result = result.where({ vendor_id: vendor_id }.compact) if vendor_id.present?
+      result = result.where(route_type: route_type) if route_type.present?
+      result = result.where(spree_vendors: { tenant_id: tenant_id }) if tenant_id.present?
+      paginate(result)
+    end
+
+    def product_inventory_totals
+      Spree::Product
+        .select(
+          'spree_products.id AS product_id,
+              SUM(cm_inventory_items.max_capacity) AS max_capacity,
+              SUM(cm_inventory_items.quantity_available) AS quantity_available'
+        )
+        .joins(variants: :inventory_items)
+        .where('cm_inventory_items.inventory_date = ? AND cm_inventory_items.quantity_available >= ?', @date.to_date, @number_of_guests)
+        .group('spree_products.id')
     end
 
     private
 
-    def direct_trips
-      SpreeCmCommissioner::SingleLegTripsQuery.new(
-        origin_id: origin_id,
-        destination_id: destination_id,
-        date: date,
-        route_type: route_type,
-        vendor_id: vendor_id,
-        tenant_id: tenant_id,
-        number_of_guests: number_of_guests,
-        params: params
-      ).call
-    end
-
-    def multi_leg_trips
-      SpreeCmCommissioner::MultiLegTripsQuery.new(
-        origin_id: origin_id,
-        destination_id: destination_id,
-        date: date,
-        route_type: route_type,
-        vendor_id: vendor_id,
-        tenant_id: tenant_id,
-        number_of_guests: number_of_guests,
-        params: params
-      ).call
+    def trip_scope
+      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_type: :option_values, route: {}, open_dated_product: %i[trip variants])
+
+      scope = scope.joins(:vendor) if tenant_id.present?
+
+      scope
+        .joins(<<~SQL.squish)
+          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
+          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_type = trip&.vehicle_type
+      vendor = trip&.vendor
+      trip_result_options = {
+        id: trip&.id,
+        departure_time: trip&.departure_time,
+        duration: trip&.duration,
+        distance: trip&.distance,
+        allow_seat_selection: trip&.allow_seat_selection,
+        route_type: trip&.route_type,
+        origin_place: {
+          id: trip&.origin_place_id,
+          name: trip&.origin_place_name
+        },
+        destination_place: {
+          id: trip&.destination_place_id,
+          name: trip&.destination_place_name
+        },
+        vehicle_type_id: trip&.vehicle_type_id,
+        vehicle_type: vehicle_type,
+        vendor_id: trip&.vendor_id,
+        vendor: vendor,
+        product_id: trip&.product_id,
+        price: trip&.amount,
+        currency: trip&.currency,
+        compare_at_amount: trip&.compare_at_amount,
+        boarding: build_boarding_info(trip),
+        drop_off: build_drop_off_info(trip),
+        quantity_available: trip&.quantity_available,
+        max_capacity: trip&.max_capacity,
+        amenities: (trip.vehicle_type&.option_values || []),
+        open_dated_product: trip&.open_dated_product
+      }
+      SpreeCmCommissioner::TripResult.new(trip_result_options)
+    end
+
+    def build_boarding_info(trip)
+      {
+        stop_id: trip&.boarding_stop_id,
+        stop_name: trip&.boarding_stop_name,
+        departure_time: trip&.boarding_departure_time
+      }
+    end
+
+    def build_drop_off_info(trip)
+      {
+        stop_id: trip&.drop_off_stop_id,
+        stop_name: trip&.drop_off_stop_name,
+        arrival_time: trip&.drop_off_arrival_time
+      }
     end
   end
 end

data/app/serializers/spree/v2/organizer/invite_guest_serializer.rb

@@ -0,0 +1,13 @@
+module Spree
+  module V2
+    module Organizer
+      class InviteGuestSerializer < BaseSerializer
+        attributes :email, :quantity, :token, :invite_type, :claimed_status, :issued_to, :expiration_date,
+                   :email_send_at, :created_at, :updated_at, :remark
+        belongs_to :variant, serializer: SpreeCmCommissioner::V2::Storefront::EventVariantSerializer
+        belongs_to :order, serializer: Spree::V2::Storefront::OrderSerializer
+        belongs_to :event, serializer: Spree::V2::Storefront::TaxonSerializer
+      end
+    end
+  end
+end

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

@@ -54,61 +54,24 @@ module SpreeCmCommissioner
 
       # Build line items for each leg, using the previous leg's to_date as the next leg's date,
       # or the initial date for the first leg.
-      # Automatically detects if a leg crosses into the next day based on departure/arrival times.
       def build_line_items_for_legs!(order:, legs:, initial_date:)
         all_line_items = []
         current_leg_date = initial_date
-        previous_arrival_time = nil
 
         # Use main_trip_id for connected trips (when legs have multiple trips)
         connected_trip_id = legs.size > 1 ? legs.first.main_trip_id&.to_s : nil
 
         legs.each do |leg|
-          # Intelligently calculate the date for this leg
-          leg_date = calculate_leg_date(leg, current_leg_date, previous_arrival_time)
-
-          leg_line_items = build_line_items_for!(leg, order, leg_date, connected_trip_id)
+          leg_line_items = build_line_items_for!(leg, order, current_leg_date, connected_trip_id)
           leg_line_items = insert_saved_guests_per_line_items_leg(leg_line_items)
 
           all_line_items.concat(leg_line_items)
-
-          # Store the arrival time and date for the next leg's calculation
-          if leg_line_items.any?
-            previous_arrival_time = extract_leg_arrival_time(leg)
-            current_leg_date = leg_line_items.last.to_date.to_date
-          end
+          current_leg_date = leg_line_items.last.to_date.to_date if leg_line_items.any?
         end
 
         all_line_items
       end
 
-      # Calculate the date for a leg by checking if its departure time suggests it's on a later day
-      def calculate_leg_date(leg, current_leg_date, previous_arrival_time)
-        return current_leg_date if previous_arrival_time.nil?
-
-        trip = SpreeCmCommissioner::Trip.find(leg.trip_id)
-        boarding_stop_id = leg.boarding_trip_stop_id.presence || trip.trip_stops.first&.id
-        boarding_stop = trip.trip_stops.find(boarding_stop_id)
-
-        departure_time = boarding_stop&.departure_time
-        return current_leg_date if departure_time.nil?
-
-        # If next leg's departure time is less than previous leg's arrival time,
-        # it indicates crossing into the next day
-        if departure_time < previous_arrival_time
-          current_leg_date + 1.day
-        else
-          current_leg_date
-        end
-      end
-
-      # Extract the arrival time from the last line item for comparison with the next leg
-      def extract_leg_arrival_time(leg)
-        trip = SpreeCmCommissioner::Trip.find(leg.trip_id)
-        drop_off_stop_id = leg.drop_off_trip_stop_id.presence || trip.trip_stops.last&.id
-        trip.trip_stops.find(drop_off_stop_id)&.arrival_time
-      end
-
       def build_line_items_for!(leg, order, date, connected_trip_id = nil)
         trip = SpreeCmCommissioner::Trip.find(leg.trip_id)
         from_date, to_date = resolve_leg_dates(trip, leg, date)
@@ -140,14 +103,12 @@ module SpreeCmCommissioner
       def resolve_leg_dates(trip, leg, date)
         return open_dated_leg_dates(trip, leg, date) if trip.open_dated?
 
-        boarding_stop_id = leg.boarding_trip_stop_id.presence || trip.trip_stops.first&.id
-        drop_off_stop_id = leg.drop_off_trip_stop_id.presence || trip.trip_stops.last&.id
+        trip_stops = trip.trip_stops.where(id: [leg.boarding_trip_stop_id, leg.drop_off_trip_stop_id]).index_by(&:id)
 
-        trip_stops = trip.trip_stops.where(id: [boarding_stop_id, drop_off_stop_id]).index_by(&:id)
         calculate_line_item_duration!(
           date: date,
-          departure_time: trip_stops[boarding_stop_id]&.departure_time,
-          arrival_time: trip_stops[drop_off_stop_id]&.arrival_time
+          departure_time: trip_stops[leg.boarding_trip_stop_id]&.departure_time,
+          arrival_time: trip_stops[leg.drop_off_trip_stop_id]&.arrival_time
         )
       end
 
@@ -185,13 +146,10 @@ module SpreeCmCommissioner
 
       def calculate_line_item_duration!(date:, departure_time:, arrival_time:)
         raise StandardError, 'Departure or arrival time in trip stop is missing' if departure_time.blank? || arrival_time.blank?
+        raise StandardError, 'Arrival time cannot be before departure time' if arrival_time < departure_time
 
         trip_duration_in_seconds = arrival_time - departure_time
 
-        # If trip_duration_in_seconds is negative, the trip crosses midnight (e.g., 22:00 -> 01:00)
-        # Add 24 hours to get the correct duration and ensure to_date falls on the next day
-        trip_duration_in_seconds += 24 * 3600 if trip_duration_in_seconds.negative?
-
         # The input `date` is in local time (e.g., 10-10-2022).
         # Combine it with the departure_time in Rails default timezone so that
         # the resulting from_date stays on the intended local calendar day when stored in UTC.

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

@@ -66,11 +66,10 @@ module SpreeCmCommissioner
 
         route = vendor.routes.find(trip_form.route_id)
 
-        locations = vendor.locations.includes(:place).where(id: trip_form.trip_stops.map(&:location_id)).index_by(&:id)
+        locations = vendor.locations.where(id: trip_form.trip_stops.map(&:location_id)).index_by(&:id)
 
         # vendor_places are either stops or branches
         vendor_places = SpreeCmCommissioner::VendorPlace
-                        .includes(:place)
                         .where(id: trip_form.trip_stops.map(&:stop_id), vendor: vendor)
                         .index_by(&:id)
 

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

@@ -16,16 +16,14 @@ module SpreeCmCommissioner
         cache_key = cache_key(params, vendor)
 
         results = Rails.cache.fetch(cache_key, expires_in: SEARCH_CACHE_TTL) do
-          query_params = include_multi_leg?(params) ? { include_multi_leg: true } : {}
-
+          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(params),
+            route_type: route_type,
             vendor_id: vendor.id,
-            number_of_guests: params[:number_of_guests].present? ? params[:number_of_guests].to_i : 1,
-            params: query_params
+            number_of_guests: params[:number_of_guests] || 1
           ).call
 
           trips
@@ -42,13 +40,11 @@ module SpreeCmCommissioner
         params[:origin].present? && params[:destination].present? && params[:outbound_date].present?
       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 intercity_taxi?(params)    = params[:service_type] == 'intercity_taxi'
-      def route_type(params)         = (intercity_taxi?(params) ? 'intercity_taxi' : params[:route_type] || nil)
-      def include_multi_leg?(params) = params[:include_multi_leg].to_s == 'true'
+      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 intercity_taxi?(params) = params[:service_type] == 'intercity_taxi'
 
       def cache_key(params, vendor)
         [

data/config/routes.rb

@@ -473,6 +473,7 @@ Spree::Core::Engine.add_routes do
         resources :images
         resource :s3_signed_urls
         resources :invites
+        resources :invite_guests, only: %i[show update]
         resources :invite_crews, only: %i[show update]
       end
 
@@ -627,6 +628,7 @@ Spree::Core::Engine.add_routes do
           end
         end
 
+        resources :saved_guests
         resource :s3_signed_urls
         resources :google_wallet_object_tokens
         resources :provinces, only: %i[index]

data/lib/spree_cm_commissioner/transit/service_calendar_form.rb

@@ -22,25 +22,6 @@ module SpreeCmCommissioner::Transit
       @exception_rules ||= []
     end
 
-    # Create form from ServiceCalendar ActiveRecord object
-    def self.from_service_calendar(calendar)
-      return new if calendar.blank?
-
-      new(
-        name: calendar.name,
-        start_date: calendar.start_date,
-        end_date: calendar.end_date,
-        monday: calendar.monday,
-        tuesday: calendar.tuesday,
-        wednesday: calendar.wednesday,
-        thursday: calendar.thursday,
-        friday: calendar.friday,
-        saturday: calendar.saturday,
-        sunday: calendar.sunday,
-        exception_rules: calendar.exception_rules || []
-      )
-    end
-
     def weekdays
       {
         'monday' => monday,