spree_cm_commissioner 1.21.0 → 2.0.0.pre.pre

data/app/models/spree_cm_commissioner/redis_stock/line_items_cached_inventory_items_builder.rb

@@ -0,0 +1,36 @@
+module SpreeCmCommissioner
+  module RedisStock
+    class LineItemsCachedInventoryItemsBuilder
+      attr_reader :line_item_ids
+
+      def initialize(line_item_ids:)
+        @line_item_ids = line_item_ids
+      end
+
+      # return list of inventory items group by :line_item_id:
+      # {
+      #   1: [ CachedInventoryItem(...), CachedInventoryItem(...) ],
+      #   2: [ CachedInventoryItem(...), CachedInventoryItem(...) ],
+      # }
+      def call
+        cached_inventory_items.group_by do |cached_inventory_item|
+          line_item = line_items.find { |item| item.variant_id == cached_inventory_item.variant_id }
+          line_item.id
+        end
+      end
+
+      def cached_inventory_items
+        @cached_inventory_items ||= SpreeCmCommissioner::RedisStock::CachedInventoryItemsBuilder.new(inventory_items)
+                                                                                                .call
+      end
+
+      def inventory_items
+        @inventory_items ||= line_items.flat_map(&:inventory_items)
+      end
+
+      def line_items
+        @line_items ||= Spree::LineItem.where(id: line_item_ids).includes(:inventory_items)
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/redis_stock/variant_cached_inventory_items_builder.rb

@@ -0,0 +1,25 @@
+module SpreeCmCommissioner
+  module RedisStock
+    class VariantCachedInventoryItemsBuilder
+      attr_reader :variant_id, :dates
+
+      def initialize(variant_id:, dates: [])
+        @variant_id = variant_id
+        @dates = dates
+      end
+
+      # output: [ CachedInventoryItem(...), CachedInventoryItem(...) ]
+      def call
+        ::SpreeCmCommissioner::RedisStock::CachedInventoryItemsBuilder.new(inventory_items).call
+      end
+
+      def inventory_items
+        variant = Spree::Variant.find(variant_id)
+
+        inventory_items = variant.inventory_items
+        inventory_items = inventory_items.where(inventory_date: dates) if variant.permanent_stock?
+        inventory_items
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/reserved_block.rb

@@ -0,0 +1,30 @@
+module SpreeCmCommissioner
+  class ReservedBlock < Base
+    has_paper_trail
+
+    belongs_to :updated_by, optional: true, class_name: 'Spree::User'
+    belongs_to :guest, optional: true, class_name: 'SpreeCmCommissioner::Guest'
+    belongs_to :inventory_item, class_name: 'SpreeCmCommissioner::InventoryItem'
+    belongs_to :block, class_name: 'SpreeCmCommissioner::Block'
+
+    enum status: {
+      reserved: 0, # confirmed reservation
+      on_hold: 1, # temporary hold
+      canceled: 2
+    }
+
+    validates :status, presence: true
+    validates :expired_at, presence: true, if: -> { on_hold? }
+
+    scope :active_on_hold, -> { on_hold.where('expired_at IS NULL OR expired_at > ?', Time.current) }
+    scope :active, -> { where('expired_at IS NULL OR expired_at > ?', Time.current) }
+
+    def expired?
+      expired_at.present? && expired_at <= Time.current
+    end
+
+    def active_on_hold?
+      on_hold? && !expired?
+    end
+  end
+end

data/app/models/spree_cm_commissioner/seat_layout.rb

@@ -0,0 +1,20 @@
+module SpreeCmCommissioner
+  class SeatLayout < Base
+    has_many :seat_sections, class_name: 'SpreeCmCommissioner::SeatSection', dependent: :destroy
+
+    has_many :top_level_blocks, -> { where(seat_section_id: nil) }, class_name: 'SpreeCmCommissioner::Block', dependent: :destroy
+    has_many :section_blocks, -> { where.not(seat_section_id: nil) }, class_name: 'SpreeCmCommissioner::Block', dependent: :destroy
+
+    belongs_to :layoutable, polymorphic: true
+
+    enum status: {
+      inactive: 0,
+      active: 1,
+      archived: 2
+    }
+
+    validates :name, presence: true
+
+    accepts_nested_attributes_for :seat_sections, :top_level_blocks
+  end
+end

data/app/models/spree_cm_commissioner/seat_section.rb

@@ -0,0 +1,16 @@
+module SpreeCmCommissioner
+  class SeatSection < Base
+    belongs_to :seat_layout, class_name: 'SpreeCmCommissioner::SeatLayout', optional: false
+
+    has_many :blocks, class_name: 'SpreeCmCommissioner::Block', dependent: :destroy
+
+    validates :name, presence: true
+    validates :width, presence: true, numericality: { greater_than: 0 }
+    validates :height, presence: true, numericality: { greater_than: 0 }
+    validates :x, presence: true, numericality: true
+    validates :y, presence: true, numericality: true
+    validates :rotation, presence: true, numericality: { greater_than_or_equal_to: -360, less_than_or_equal_to: 360 }
+
+    accepts_nested_attributes_for :blocks
+  end
+end

data/app/models/spree_cm_commissioner/seats/blocks_canceler.rb

@@ -0,0 +1,30 @@
+module SpreeCmCommissioner
+  module Seats
+    class BlocksCanceler
+      def initialize(order_id:, cancel_by: nil)
+        @order_id = order_id
+        @cancel_by = cancel_by
+      end
+
+      # Cancels all reserved blocks associated with a given order.
+      #
+      # Typically used when:
+      # - The order is canceled.
+      # - The user abandons the order before completing checkout.
+      def cancel_blocks!
+        order = Spree::Order.find(@order_id)
+
+        ActiveRecord::Base.transaction do
+          order.reserved_blocks.each do |reserved_block|
+            reserved_block.assign_attributes(
+              status: :canceled,
+              expired_at: nil,
+              updated_by: @cancel_by
+            )
+            raise Errors::UnableToSaveReservedBlockRecord unless reserved_block.save
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/seats/blocks_holder.rb

@@ -0,0 +1,53 @@
+module SpreeCmCommissioner
+  module Seats
+    class BlocksHolder
+      HOLD_DURATION = 8.minutes
+
+      def initialize(line_item_ids:, hold_by: nil)
+        @line_item_ids = line_item_ids
+        @hold_by = hold_by
+      end
+
+      # Hold blocks for the given line items, preventing dublicate block selection.
+      #
+      # It ensures:
+      # - Raises an error if already reserved.
+      # - Raises an error if currently on_hold by someone else.
+      # - Allows re-locking if already on_hold by the same guest.
+      # - Otherwise, proceeds to lock the given blocks.
+      def hold_blocks!
+        line_items = Spree::LineItem.where(id: @line_item_ids).includes(:inventory_items, guests_with_blocks: :block)
+        guests_with_blocks = line_items.flat_map(&:guests_with_blocks).compact
+        inventory_items = line_items.flat_map(&:inventory_items).compact
+
+        ActiveRecord::Base.transaction do
+          guests_with_blocks.each do |guest|
+            inventory_items.each do |inventory_item|
+              hold_specific_block!(inventory_item, guest)
+            end
+          end
+        end
+      end
+
+      private
+
+      def hold_specific_block!(inventory_item, guest)
+        reserved_block = SpreeCmCommissioner::ReservedBlock.find_or_initialize_by(inventory_item: inventory_item, block: guest.block)
+
+        raise Errors::BlocksAreReservedByOtherGuest if reserved_block.reserved? && reserved_block.guest_id != guest.id
+        raise Errors::BlocksAreReservedBySameGuest if reserved_block.reserved? && reserved_block.guest_id == guest.id
+        raise Errors::BlocksAreOnHoldByOtherGuest if reserved_block.active_on_hold? && reserved_block.guest_id != guest.id
+
+        reserved_block.assign_attributes(
+          status: :on_hold,
+          guest: guest,
+          expired_at: HOLD_DURATION.from_now,
+          inventory_date: inventory_item.inventory_date,
+          updated_by: @hold_by
+        )
+
+        raise Errors::UnableToSaveReservedBlockRecord unless reserved_block.save
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/seats/blocks_reserver.rb

@@ -0,0 +1,49 @@
+module SpreeCmCommissioner
+  module Seats
+    class BlocksReserver
+      def initialize(line_item_ids:, reserve_by: nil)
+        @line_item_ids = line_item_ids
+        @reserve_by = reserve_by
+      end
+
+      # Mark blocks as reserved for the given line items.
+      #
+      # It ensures:
+      # - Raises an error if already reserved by same guest or other guest.
+      # - Raises an error if currently on_hold by someone else.
+      # - Otherwise, proceeds to reserve the given blocks.
+      def reserve_blocks!
+        line_items = Spree::LineItem.where(id: @line_item_ids).includes(:inventory_items, guests_with_blocks: :block)
+        guests_with_blocks = line_items.flat_map(&:guests_with_blocks).compact
+        inventory_items = line_items.flat_map(&:inventory_items).compact
+
+        ActiveRecord::Base.transaction do
+          guests_with_blocks.each do |guest|
+            inventory_items.each do |inventory_item|
+              reserve_specific_block!(inventory_item, guest)
+            end
+          end
+        end
+      end
+
+      def reserve_specific_block!(inventory_item, guest)
+        reserved_block = SpreeCmCommissioner::ReservedBlock.find_or_initialize_by(inventory_item_id: inventory_item.id, block_id: guest.block_id)
+
+        raise Errors::BlocksAreReservedByOtherGuest if reserved_block.reserved? && reserved_block.guest_id != guest.id
+        raise Errors::BlocksAreReservedBySameGuest if reserved_block.reserved? && reserved_block.guest_id == guest.id
+        raise Errors::BlocksAreOnHoldByOtherGuest if reserved_block.active_on_hold? && reserved_block.guest_id != guest.id
+
+        # mark the block as reserved if not on_hold or lock by anyone but already expired
+        reserved_block.assign_attributes(
+          guest: guest,
+          status: :reserved,
+          expired_at: nil,
+          inventory_date: inventory_item.inventory_date,
+          updated_by: @reserve_by
+        )
+
+        raise Errors::UnableToSaveReservedBlockRecord unless reserved_block.save
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/seats/errors/blocks_are_on_hold_by_other_guest.rb

@@ -0,0 +1,4 @@
+module SpreeCmCommissioner
+  class Seats::Errors::BlocksAreOnHoldByOtherGuest < StandardError
+  end
+end

data/app/models/spree_cm_commissioner/seats/errors/blocks_are_reserved_by_other_guest.rb

@@ -0,0 +1,4 @@
+module SpreeCmCommissioner
+  class Seats::Errors::BlocksAreReservedByOtherGuest < StandardError
+  end
+end

data/app/models/spree_cm_commissioner/seats/errors/blocks_are_reserved_by_same_guest.rb

@@ -0,0 +1,4 @@
+module SpreeCmCommissioner
+  class Seats::Errors::BlocksAreReservedBySameGuest < StandardError
+  end
+end

data/app/models/spree_cm_commissioner/seats/errors/unable_to_save_reserved_block_record.rb

@@ -0,0 +1,4 @@
+module SpreeCmCommissioner
+  class Seats::Errors::UnableToSaveReservedBlockRecord < StandardError
+  end
+end

data/app/models/spree_cm_commissioner/service_calendar.rb

@@ -1,5 +1,3 @@
-require_dependency 'spree_cm_commissioner'
-
 module SpreeCmCommissioner
   class ServiceCalendar < SpreeCmCommissioner::Base
     # exception_rules = [

data/app/models/spree_cm_commissioner/state_decorator.rb

@@ -3,7 +3,6 @@ module SpreeCmCommissioner
     def self.prepended(base)
       base.whitelisted_ransackable_attributes |= %w[name abbr country_id]
       base.has_many :vendors, foreign_key: 'default_state_id', class_name: 'Spree::Vendor', inverse_of: :default_state, dependent: :nullify
-      base.has_many :stops, class_name: 'SpreeCmCommissioner::Place'
 
       def update_total_inventory
         update(total_inventory: vendors.pluck(:total_inventory).compact.sum)

data/app/models/spree_cm_commissioner/stock/availability_checker.rb

@@ -1,47 +1,48 @@
 module SpreeCmCommissioner
   module Stock
     class AvailabilityChecker
-      attr_reader :variant, :error_message
+      attr_reader :variant, :options, :error_message
 
-      def initialize(variant)
+      def initialize(variant, options = {})
         @variant = variant
+        @options = options
         @error_message = nil
       end
 
-      def can_supply?(quantity = 1, options = {})
+      def can_supply?(quantity = 1)
         return false unless variant.available?
         return true unless variant.should_track_inventory?
         return true if variant.backorderable?
         return true if variant.need_confirmation?
 
-        # when delivery required, shipment will dynamically add / remove unit from stock item.
-        # so we can directly check can_supply with stock items directly.
-        return variant.stock_items.sum(:count_on_hand) >= quantity if variant.delivery_required?
+        variant_available?(quantity)
+      end
 
-        if variant.permanent_stock?
-          permanent_stock_variant_available?(quantity, options)
-        else
-          variant_available?(quantity, options)
+      def variant_available?(quantity = 1)
+        return false if cached_inventory_items.empty?
+
+        cached_inventory_items.all? do |cached_inventory_item|
+          cached_inventory_item.active? && cached_inventory_item.quantity_available >= quantity
         end
       end
 
-      def variant_available?(quantity = 1, options = {})
-        query = SpreeCmCommissioner::VariantAvailability::NonPermanentStockQuery.new(
-          variant: variant,
-          except_line_item_id: options[:except_line_item_id]
-        )
-        result = query.available?(quantity)
-        @error_message = query.error_message unless result
-        result
+      def cached_inventory_items
+        return @cached_inventory_items if defined?(@cached_inventory_items)
+
+        if variant.permanent_stock?
+          return [] if options[:from_date].blank? || options[:to_date].blank?
+
+          dates = options[:from_date].to_date..options[:to_date].to_date
+          @cached_inventory_items = builder_klass.new(variant_id: variant.id, dates: dates).call
+          @cached_inventory_items = [] if @cached_inventory_items.size != dates.count
+          @cached_inventory_items
+        else
+          @cached_inventory_items = builder_klass.new(variant_id: variant.id).call
+        end
       end
 
-      def permanent_stock_variant_available?(quantity = 1, options = {})
-        SpreeCmCommissioner::VariantAvailability::PermanentStockQuery.new(
-          variant: variant,
-          from_date: options[:from_date].to_date,
-          to_date: options[:to_date].to_date,
-          except_line_item_id: options[:except_line_item_id]
-        ).available?(quantity)
+      def builder_klass
+        ::SpreeCmCommissioner::RedisStock::VariantCachedInventoryItemsBuilder
       end
     end
   end

data/app/models/spree_cm_commissioner/stock/availability_validator_decorator.rb

@@ -3,7 +3,8 @@ module SpreeCmCommissioner
     module AvailabilityValidatorDecorator
       # override
       def item_available?(line_item, quantity)
-        SpreeCmCommissioner::Stock::LineItemAvailabilityChecker.new(line_item).can_supply?(quantity)
+        SpreeCmCommissioner::Stock::LineItemAvailabilityChecker.new(line_item)
+                                                               .can_supply?(quantity)
       end
     end
   end

data/app/models/spree_cm_commissioner/stock/line_item_availability_checker.rb

@@ -8,14 +8,14 @@ module SpreeCmCommissioner
       end
 
       def can_supply?(quantity)
-        AvailabilityChecker.new(line_item.variant).can_supply?(quantity, options)
+        ::SpreeCmCommissioner::Stock::AvailabilityChecker.new(line_item.variant, options)
+                                                         .can_supply?(quantity)
       end
 
       def options
         {
           from_date: line_item.from_date,
-          to_date: line_item.to_date,
-          except_line_item_id: line_item.id
+          to_date: line_item.to_date
         }
       end
     end

data/app/models/spree_cm_commissioner/stock/order_availability_checker.rb

@@ -0,0 +1,44 @@
+# On top of SpreeCmCommissioner::Stock::AvailabilityChecker, this class does the same thing but in bulk check with redis.
+# Which mean, it check basic condition with db first, once pass, it check with redis.
+module SpreeCmCommissioner
+  module Stock
+    class OrderAvailabilityChecker
+      attr_reader :order
+
+      def initialize(order)
+        @order = order
+      end
+
+      def can_supply_all?
+        insufficient_stock_lines.empty?
+      end
+
+      def insufficient_stock_lines
+        cached_inventory_items_group_by_line_item_id.map do |line_item_id, cached_inventory_items|
+          line_item = order.line_items.find { |item| item.id == line_item_id }
+          line_item unless sufficient_stock_for?(line_item, cached_inventory_items)
+        end.compact
+      end
+
+      # {
+      #   1: [ {inventory_key: "inventory:1", active: true, quantity_available: 5, inventory_item_id: 1, variant_id: 1}],
+      #   2: [ {inventory_key: "inventory:2", active: true, quantity_available: 5, inventory_item_id: 2, variant_id: 2}],
+      # }
+      def cached_inventory_items_group_by_line_item_id
+        @cached_inventory_items_group_by_line_item_id ||=
+          ::SpreeCmCommissioner::RedisStock::LineItemsCachedInventoryItemsBuilder.new(
+            line_item_ids: order.line_items.pluck(:id)
+          ).call
+      end
+
+      def sufficient_stock_for?(line_item, cached_inventory_items)
+        return false unless line_item.variant.available?
+        return true unless line_item.variant.should_track_inventory?
+        return true if line_item.variant.backorderable?
+        return true if line_item.variant.need_confirmation?
+
+        cached_inventory_items.all? { |item| item.active? && item.quantity_available >= line_item.quantity }
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/stock_item_decorator.rb

@@ -3,11 +3,28 @@ module SpreeCmCommissioner
     def self.prepended(base)
       base.has_one :vendor, through: :variant
       base.after_save :update_vendor_total_inventory, if: :saved_change_to_count_on_hand?
+
+      base.after_commit :create_inventory_items, on: :create
+      base.after_commit :adjust_inventory_items_async, on: :destroy
     end
 
     def update_vendor_total_inventory
       SpreeCmCommissioner::VendorJob.perform_later(vendor.id) if vendor.present?
     end
+
+    private
+
+    def create_inventory_items
+      SpreeCmCommissioner::Stock::InventoryItemsGeneratorJob.perform_later(variant_id: variant.id)
+    end
+
+    # When admin delete stock item, it will deduct stock from inventory item
+    def adjust_inventory_items_async
+      params = { variant_id: variant.id, quantity: -count_on_hand }
+      CmAppLogger.log(label: "#{self.class.name}#adjust_inventory_items_async", data: params) do
+        SpreeCmCommissioner::Stock::InventoryItemsAdjusterJob.perform_later(**params)
+      end
+    end
   end
 end
 

data/app/models/spree_cm_commissioner/taxon_blazer_query.rb

@@ -0,0 +1,8 @@
+module SpreeCmCommissioner
+  class TaxonBlazerQuery < SpreeCmCommissioner::Base
+    belongs_to :taxon, class_name: 'Spree::Taxon'
+    belongs_to :blazer_query, class_name: 'Blazer::Query'
+
+    validates :taxon_id, uniqueness: { scope: :blazer_query_id, message: I18n.t('event_blazer_queries.fail') }
+  end
+end

data/app/models/spree_cm_commissioner/taxon_decorator.rb

@@ -2,9 +2,7 @@ module SpreeCmCommissioner
   module TaxonDecorator
     def self.prepended(base) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
       base.include SpreeCmCommissioner::TaxonKind
-      base.include SpreeCmCommissioner::Transit::TaxonBitwise
       base.include SpreeCmCommissioner::ParticipationTypeBitwise
-      base.include SpreeCmCommissioner::EventCheckInFlowable
 
       base.preference :background_color, :string
       base.preference :foreground_color, :string
@@ -57,16 +55,14 @@ module SpreeCmCommissioner
       base.has_many :crew_invites, class_name: 'SpreeCmCommissioner::CrewInvite', dependent: :destroy
       base.has_many :invite_user_events, through: :user_events, class_name: 'SpreeCmCommissioner::InviteUserEvent'
 
-      base.has_many :crew_invite_links, class_name: 'SpreeCmCommissioner::CrewInviteLink', dependent: :destroy
-
       base.has_many :invite_guests, class_name: 'SpreeCmCommissioner::InviteGuest', foreign_key: :event_id
 
       base.has_many :line_items, through: :products
       base.has_many :event_line_items, class_name: 'Spree::LineItem', foreign_key: :event_id
       base.has_many :event_products, class_name: 'Spree::Product', foreign_key: :event_id
 
-      base.has_many :event_blazer_queries, as: :queryable, class_name: 'SpreeCmCommissioner::BlazerQueryable'
-      base.has_many :blazer_queries, through: :event_blazer_queries, source: :blazer_query, class_name: 'Blazer::Query'
+      base.has_many :event_blazer_queries, class_name: 'SpreeCmCommissioner::TaxonBlazerQuery'
+      base.has_many :blazer_queries, through: :event_blazer_queries, class_name: 'Blazer::Query'
 
       base.has_many :taxon_option_types, class_name: 'SpreeCmCommissioner::TaxonOptionType'
       base.has_many :taxon_option_values, class_name: 'SpreeCmCommissioner::TaxonOptionValue'

data/app/models/spree_cm_commissioner/taxonomy_decorator.rb

@@ -8,12 +8,6 @@ module SpreeCmCommissioner
           Spree::Taxonomy.find_or_create_by(name: 'Businesses', kind: 'category', store: Spree::Store.default)
         end
       end
-
-      def base.place
-        ActiveRecord::Base.connected_to(role: :writing) do
-          Spree::Taxonomy.find_or_create_by(name: 'Place', kind: 'transit', store: Spree::Store.default)
-        end
-      end
     end
   end
 end

data/app/models/spree_cm_commissioner/trip.rb

@@ -1,6 +1,7 @@
-require_dependency 'spree_cm_commissioner'
 module SpreeCmCommissioner
-  class Trip < SpreeCmCommissioner::Base
+  class Trip < Base
+    include SpreeCmCommissioner::RouteType
+
     attr_accessor :hours, :minutes, :seconds
 
     before_validation :convert_duration_to_seconds
@@ -10,28 +11,29 @@ module SpreeCmCommissioner
     belongs_to :origin, class_name: 'SpreeCmCommissioner::Place', optional: true
     belongs_to :destination, class_name: 'SpreeCmCommissioner::Place', 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'
-
     has_many :trip_stops, class_name: 'SpreeCmCommissioner::TripStop', dependent: :destroy
     has_many :variants, through: :product
     has_many :inventory_items, through: :variants
-    belongs_to :variant, class_name: 'Spree::Variant'
-
-    belongs_to :route, class_name: 'Spree::Product'
-    belongs_to :vehicle, class_name: 'SpreeCmCommissioner::Vehicle'
-    validates :departure_time, presence: true
 
     validates :departure_time, presence: true
     validates :duration, numericality: { greater_than: 0 }
     validate :origin_and_destination_cannot_be_the_same
 
+    accepts_nested_attributes_for :trip_stops, allow_destroy: true
+
+    after_create :create_trip_stops
+
     def convert_duration_to_seconds
       return if hours.blank? && minutes.blank? && seconds.blank?
 
       self.duration = (hours.to_i * 3600) + (minutes.to_i * 60) + seconds.to_i
     end
 
+    def create_trip_stops
+      trip_stops.find_or_create_by(stop_type: :boarding, stop_id: origin_id)
+      trip_stops.find_or_create_by(stop_type: :drop_off, stop_id: destination_id)
+    end
+
     def duration_in_hms
       return { hours: 0, minutes: 0, seconds: 0 } if duration.nil?
 

data/app/models/spree_cm_commissioner/trip_connection.rb

@@ -1,7 +1,7 @@
 module SpreeCmCommissioner
-  class TripConnection < ApplicationRecord
-    belongs_to :from_trip, class_name: 'Spree::Variant'
-    belongs_to :to_trip, class_name: 'Spree::Variant'
+  class TripConnection < Base
+    belongs_to :from_trip, class_name: 'SpreeCmCommissioner::Trip'
+    belongs_to :to_trip, class_name: 'SpreeCmCommissioner::Trip'
 
     validate :both_trip_cannot_be_the_same
     before_validation :calculate_connection_time_minutes
@@ -12,8 +12,8 @@ module SpreeCmCommissioner
     def calculate_connection_time_minutes
       return if from_trip.nil? || to_trip.nil?
 
-      arrival_seconds   = from_trip.trip.arrival_time.seconds_since_midnight
-      departure_seconds = to_trip.trip.departure_time.seconds_since_midnight
+      arrival_seconds   = from_trip.arrival_time.seconds_since_midnight
+      departure_seconds = to_trip.departure_time.seconds_since_midnight
 
       layover_seconds = departure_seconds - arrival_seconds
       layover_seconds += 86_400 if layover_seconds.negative?

data/app/models/spree_cm_commissioner/trip_stop.rb

@@ -1,10 +1,9 @@
-require_dependency 'spree_cm_commissioner'
 module SpreeCmCommissioner
-  class TripStop < SpreeCmCommissioner::Base
+  class TripStop < Base
     acts_as_list column: :sequence, scope: :trip_id
     enum :stop_type, { boarding: 0, drop_off: 1 }
 
-    belongs_to :trip, class_name: 'Spree::Variant'
+    belongs_to :trip, class_name: 'SpreeCmCommissioner::Trip'
     belongs_to :stop, class_name: 'SpreeCmCommissioner::Place'
 
     before_validation :set_stop_name