spree_cm_commissioner 2.5.1.pre.pre1 → 2.5.1.pre.pre2

data/lib/spree_cm_commissioner/test_helper/factories/vendor_factory.rb

@@ -1,11 +1,13 @@
 FactoryBot.define do
   factory :cm_transit_vendor, parent: :vendor do
+    from_email { FFaker::Internet.email } # required only when tenant exist.
     state { :active }
     primary_product_type { :transit }
   end
 
   factory :cm_vendor, parent: :vendor do
     sequence(:name) { |n| "#{FFaker::Company.name} #{n}#{Kernel.rand(9999)}" }
+    from_email { FFaker::Internet.email } # required only when tenant exist.
     state { :active }
     default_state_id { Spree::State.first&.id }
     primary_product_type { :ecommerce }

data/lib/spree_cm_commissioner/test_helper/factories/vendor_place_factory.rb

@@ -7,6 +7,17 @@ FactoryBot.define do
     position  { FFaker::Number.number }
 
     place_type { :location }
+
+    transient do
+      place_name { nil }
+    end
+
+    before :create do |vendor_place, evaluator|
+      if evaluator.place_name.present?
+        vendor_place.place.name = evaluator.place_name
+        vendor_place.place.save!
+      end
+    end
   end
 
   factory :cm_vendor_place, class: SpreeCmCommissioner::VendorPlace do
@@ -30,5 +41,16 @@ FactoryBot.define do
       place_type { :location }
       location { nil }
     end
+
+    transient do
+      place_name { nil }
+    end
+
+    before :create do |vendor_place, evaluator|
+      if evaluator.place_name.present?
+        vendor_place.place.name = evaluator.place_name
+        vendor_place.place.save!
+      end
+    end
   end
 end

data/lib/spree_cm_commissioner/transit/route_stop.rb

@@ -0,0 +1,61 @@
+module SpreeCmCommissioner::Transit
+  class RouteStop
+    attr_accessor :location_id, :vendor_place_id, :type, :sequence, :vendor_place
+
+    STOP_TYPES = %i[branch stop].freeze
+
+    def initialize(options = {})
+      @location_id = options[:location_id]
+      @type = options[:type]&.to_sym
+      @sequence = options[:sequence]
+
+      # vendor place is either stop or branch
+      @vendor_place_id = options[:vendor_place_id]
+    end
+
+    def self.from_hash(hash)
+      hash = hash.symbolize_keys
+
+      new(
+        location_id: hash[:location_id],
+        vendor_place_id: hash[:vendor_place_id],
+        type: hash[:type],
+        sequence: hash[:sequence]
+      )
+    end
+
+    def to_h
+      {
+        location_id: @location_id,
+        vendor_place_id: @vendor_place_id,
+        type: @type,
+        sequence: @sequence
+      }
+    end
+
+    def branch?
+      @type == :branch
+    end
+
+    def stop?
+      @type == :stop
+    end
+
+    def valid?
+      errors.empty?
+    end
+
+    def errors
+      @errors ||= []
+      @errors.clear
+
+      @errors << 'location_id is required' if @location_id.blank?
+      @errors << 'vendor_place_id is required' if @vendor_place_id.blank?
+      @errors << 'type is required' if @type.blank?
+      @errors << 'type must be :branch or :stop' if @type.present? && STOP_TYPES.exclude?(@type)
+      @errors << 'sequence is required' if @sequence.nil?
+
+      @errors
+    end
+  end
+end

data/lib/spree_cm_commissioner/transit/route_stop_collection.rb

@@ -0,0 +1,175 @@
+module SpreeCmCommissioner::Transit
+  class RouteStopCollection
+    include Enumerable
+
+    attr_reader :stops
+
+    def initialize(stops = [])
+      @stops = stops
+      @errors = []
+    end
+
+    def self.from_hash(array)
+      # Handle nil, empty array, or string "[]" when loaded from database
+      parsed_array = case array
+                     when nil
+                       []
+                     when String
+                       JSON.parse(array)
+                     else
+                       array
+                     end
+
+      stops = Array(parsed_array).each_with_index.map do |raw, index|
+        hash = raw.to_h.symbolize_keys
+        RouteStop.from_hash(hash.merge(sequence: index))
+      end
+
+      new(stops)
+    end
+
+    def to_h
+      @stops.map(&:to_h)
+    end
+
+    def each(&block)
+      @stops.each(&block)
+    end
+
+    def [](index)
+      @stops[index]
+    end
+
+    def first
+      @stops.first
+    end
+
+    def last
+      @stops.last
+    end
+
+    def length
+      @stops.length
+    end
+
+    def empty?
+      @stops.empty?
+    end
+
+    def multi_leg?
+      branch_location_ids = @stops.select(&:branch?).map(&:location_id).uniq
+      branch_location_ids.length >= 3
+    end
+
+    def by_location
+      @stops.group_by(&:location_id)
+    end
+
+    # Fetches vendor places and groups route stops by their location object
+    # Returns: { location_obj => [route_stop_a, route_stop_b], location_obj_2 => [...] }
+    # Example: If you have stops for branches in "Bangkok" and "Chiang Mai",
+    #          this returns all stops grouped by their location object
+    def by_location_with_data
+      return {} if @stops.empty?
+
+      # Extract unique vendor_place_ids from all stops
+      vendor_place_ids = @stops.map(&:vendor_place_id).compact.uniq
+      return {} if vendor_place_ids.empty?
+
+      # Single query: fetch all vendor places with their locations
+      # index_by(:id) creates a hash for O(1) lookup: { vendor_place_id => vendor_place_obj }
+      vendor_places = SpreeCmCommissioner::VendorPlace.where(id: vendor_place_ids).includes(:location).index_by(&:id)
+
+      grouped = {}
+      @stops.each do |stop|
+        # Set the vendor_place object on the stop for later use
+        stop.vendor_place = vendor_places[stop.vendor_place_id]
+
+        # Get the location from the vendor_place (e.g., "Bangkok" location)
+        location = stop.vendor_place&.location
+        next if location.nil?
+
+        # Group stops by location object
+        grouped[location] ||= []
+        grouped[location] << stop
+      end
+
+      grouped
+    end
+
+    # Groups route stops by their location in sequence order
+    # Returns an array of hashes where each hash contains:
+    #   - location: the VendorPlace representing the location
+    #   - stops: array of route stops at that location, sorted by sequence
+    # Example usage: @stops.group_by_sequence
+    # {
+    #   location_object_1 => [stop1, stop2, stop3],
+    #   location_object_2 => [stop4, stop5]
+    # }
+    # Stop 0: Location A
+    # Stop 1: Location A
+    # Stop 2: Location B
+    # Stop 3: Location A ← Same location again (For case when the bus has the same origin/destination)
+    def group_by_sequence
+      return [] if @stops.blank?
+
+      by_location = by_location_with_data || {}
+
+      # location_id => location_vendor_place (the "location" vendor_place in the hash key)
+      location_by_id = by_location.keys.index_by(&:id)
+
+      ordered_stops =
+        by_location.values
+                   .flatten
+                   .compact
+                   .sort_by { |s| s.sequence.to_i }
+
+      grouped_stops = []
+      current_location_id = nil
+      current_group = nil
+
+      ordered_stops.each do |stop|
+        stop_location_id = stop.location_id
+
+        if stop_location_id != current_location_id
+          current_location_id = stop_location_id
+          current_group = {
+            location: location_by_id[stop_location_id],
+            stops: []
+          }
+          grouped_stops << current_group
+        end
+
+        current_group[:stops] << stop
+      end
+
+      grouped_stops
+    end
+
+    def valid?
+      errors.empty?
+    end
+
+    def errors
+      @errors = []
+
+      # Check each stop is valid
+      @stops.each_with_index do |stop, index|
+        next if stop.valid?
+
+        stop.errors.each do |error|
+          @errors << "Stop #{index}: #{error}"
+        end
+      end
+
+      # Check for duplicate vendor_place_ids
+      vendor_place_ids = @stops.map(&:vendor_place_id)
+      duplicates = vendor_place_ids.tally.select { |_, count| count > 1 }.keys
+      duplicates.each do |dup_id|
+        @errors << "vendor_place_id #{dup_id} appears more than once"
+      end
+
+      @errors
+    end
+  end
+end

data/lib/spree_cm_commissioner/transit/trip_form.rb

@@ -0,0 +1,81 @@
+module SpreeCmCommissioner::Transit
+  class TripForm
+    include ActiveModel::Model
+
+    attr_accessor :route_id,
+                  :name,
+                  :short_name,
+                  :price,
+                  :allow_booking,
+                  :allow_seat_selection,
+                  :route_type,
+                  :trip_stops, # TripStopForm[]
+                  :service_calendar # monday, tuesday, wednesday, thursday, friday, saturday, sunday, start_date, end_date
+
+    def multi_leg?
+      trip_stops.map(&:location_id).uniq.size > 2
+    end
+
+    def total_duration_seconds
+      return 0 if trip_stops.size < 2
+
+      minutes = trip_stops[0...-1].sum { |s| s.duration_in_minutes || 0 }
+      minutes * 60
+    end
+
+    def valid_data? # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      errors.clear
+
+      errors.add(:route_id, 'must be present') if route_id.blank?
+      errors.add(:trip_stops, 'must be present') if trip_stops.blank? || trip_stops.size < 2
+
+      first_stop = trip_stops&.first
+      last_stop  = trip_stops&.last
+
+      errors.add(:trip_stops, 'first stop must allow boarding') unless first_stop&.allow_boarding?
+      errors.add(:trip_stops, 'last stop must allow drop off')   unless last_stop&.allow_drop_off
+      errors.add(:departure_time, 'missing on first stop')       if first_stop&.departure_time.blank?
+
+      errors.empty?
+    end
+
+    # Groups trip_stops into legs by location changes
+    # Separates legs when location_id changes (at branch stops)
+    # Break stops (stop_type = :stop) are included but don't trigger separation
+    #
+    # Example:
+    # [PP1, PP2, PTT1(break stop), BTB1, BTB2, PPT2(break stop), POIPET1, POIPET1]
+    #
+    # Output (legs):
+    # [
+    #   [PP1, PP2, PTT, BTB1, BTB2],
+    #   [BTB1, BTB2, PPT1, POIPET1, POIPET1]
+    # ]
+    def trip_stops_grouped_by_leg(stops)
+      return [] if trip_stops.empty?
+
+      legs = []
+      current_leg = []
+      last_location_id = nil
+
+      trip_stops.each do |trip_stop|
+        stop = stops[trip_stop.stop_id]
+
+        # If location changed and we have stops in current leg, start a new leg
+        current_leg << trip_stop
+        if last_location_id.present? && last_location_id != trip_stop.location_id && current_leg.any?
+          # Include the first stop of new location in previous leg
+          legs << current_leg
+          current_leg = [trip_stop]
+        end
+
+        # Update location only for branch stops (not for "just stops")
+        last_location_id = trip_stop.location_id if stop.branch?
+      end
+
+      # Add final leg if it has stops
+      legs << current_leg if current_leg.any?
+      legs
+    end
+  end
+end

data/lib/spree_cm_commissioner/transit/trip_stop_form.rb

@@ -0,0 +1,61 @@
+module SpreeCmCommissioner::Transit
+  class TripStopForm
+    attr_accessor :location_id,
+                  :stop_id,
+                  :departure_time,
+                  :duration_in_hours,
+                  :route_type,
+                  #
+                  # when create, vehicle_type_id is required. But if board_to_trip_id present (from another route), we can copy from that trip.
+                  # when edit, vehicle_type_id can be changed since we already copied the seat layout.
+                  :vehicle_type_id,
+                  #
+                  # (optional), same as vehicle_type_id.
+                  :vehicle_id,
+                  #
+                  # when create:
+                  # if board_to_trip_id present, it mean it link to another trip to board.
+                  #
+                  # when edit:
+                  # board_to_trip_id can't be set to nil or changed to another trip id.
+                  :board_to_trip_id,
+                  #
+                  # for first stop, allow_boarding must be true.
+                  # for last stop, allow_boarding must be false.
+                  # for middle stops, both can be true/false.
+                  #
+                  # but when stop.type is not branch (eg. stop), allow_boarding must be false.
+                  :allow_boarding,
+                  #
+                  # for first stop, allow_drop_off must be false.
+                  # for last stop, allow_drop_off must be true.
+                  # for middle stops, both can be true/false.
+                  #
+                  # but when stop.type is not branch (eg. stop), allow_drop_off must be false.
+                  :allow_drop_off,
+                  #
+                  # when stop.type is branch, admin can toggle allow_seat_selection.
+                  # but for edit, if board_to_trip_id is from another route, allow_seat_selection can't be changed.
+                  # only allow changed from its own route.
+                  :allow_seat_selection,
+                  #
+                  # when create, allow_booking only when stop.type is branch, use it to assign to create sub-trip.
+                  # but for edit, if board_to_trip_id is from another route, allow_booking can't be changed.
+                  # only allow changed from its own route.
+                  :allow_booking,
+                  :sequence,
+                  #
+                  # set from create service
+                  :vendor_id
+
+    def allow_boarding?
+      ActiveModel::Type::Boolean.new.cast(allow_boarding)
+    end
+
+    def duration_in_minutes
+      return nil if duration_in_hours.blank?
+
+      (duration_in_hours.to_f * 60).to_i
+    end
+  end
+end

data/lib/spree_cm_commissioner/version.rb

@@ -1,5 +1,5 @@
 module SpreeCmCommissioner
-  VERSION = '2.5.1-pre1'.freeze
+  VERSION = '2.5.1.pre.pre2'.freeze
 
   module_function
 

data/lib/spree_cm_commissioner.rb

@@ -23,6 +23,10 @@ require 'spree_cm_commissioner/trip_query_result'
 require 'spree_cm_commissioner/cached_inventory_item'
 require 'spree_cm_commissioner/transit/leg'
 require 'spree_cm_commissioner/transit/seat_selection'
+require 'spree_cm_commissioner/transit/route_stop'
+require 'spree_cm_commissioner/transit/route_stop_collection'
+require 'spree_cm_commissioner/transit/trip_form'
+require 'spree_cm_commissioner/transit/trip_stop_form'
 require 'spree_cm_commissioner/intercity_taxi/map_place'
 require 'spree_cm_commissioner/distance'