spree_cm_commissioner 2.0.3.pre.pre5 → 2.0.3.pre.pre.pre7

data/app/models/spree_cm_commissioner/stock_item_decorator.rb

@@ -3,28 +3,11 @@ 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/stop.rb

@@ -0,0 +1,23 @@
+require_dependency 'spree_cm_commissioner'
+
+module SpreeCmCommissioner
+  class Stop < SpreeCmCommissioner::Place
+    belongs_to :branch, class_name: 'SpreeCmCommissioner::Branch'
+    belongs_to :state,  class_name: 'Spree::State', optional: true
+    belongs_to :vendor, class_name: 'Spree::Vendor'
+
+    after_save :add_to_option_value
+
+    def validate_reference?
+      false
+    end
+
+    def add_to_option_value
+      origin = Spree::OptionType.find_by(attr_type: 'origin')&.id
+      destination = Spree::OptionType.find_by(attr_type: 'destination')&.id
+
+      Spree::OptionValue.create(option_type_id: origin, name: name, presentation: id)
+      Spree::OptionValue.create(option_type_id: destination, name: name, presentation: id)
+    end
+  end
+end

data/app/models/spree_cm_commissioner/taxon_decorator.rb

@@ -2,6 +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
 

data/app/models/spree_cm_commissioner/taxonomy_decorator.rb

@@ -8,6 +8,12 @@ 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,38 +1,31 @@
+require_dependency 'spree_cm_commissioner'
 module SpreeCmCommissioner
-  class Trip < Base
-    include SpreeCmCommissioner::RouteType
-
+  class Trip < SpreeCmCommissioner::Base
     attr_accessor :hours, :minutes, :seconds
 
     before_validation :convert_duration_to_seconds
 
-    belongs_to :vendor, class_name: 'Spree::Vendor', inverse_of: :trips, optional: false
     belongs_to :product, class_name: 'Spree::Product', inverse_of: :trip, optional: false
     belongs_to :vehicle, class_name: 'SpreeCmCommissioner::Vehicle', optional: false
-
-    belongs_to :origin_place, class_name: 'SpreeCmCommissioner::Place', optional: false
-    belongs_to :destination_place, class_name: 'SpreeCmCommissioner::Place', optional: false
+    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 :boarding_trip_stops, -> { boarding }, class_name: 'SpreeCmCommissioner::TripStop'
-    has_many :drop_off_trip_stops, -> { drop_off }, class_name: 'SpreeCmCommissioner::TripStop'
-
     has_many :variants, through: :product
     has_many :inventory_items, through: :variants
-    has_many :variant_blocks, through: :variants
-    has_many :blocks, through: :variant_blocks
+    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, :product, allow_destroy: true
-
-    self.whitelisted_ransackable_associations = %w[product vehicle]
-
     def convert_duration_to_seconds
       return if hours.blank? && minutes.blank? && seconds.blank?
 
@@ -57,7 +50,7 @@ module SpreeCmCommissioner
     private
 
     def origin_and_destination_cannot_be_the_same
-      return unless origin_place_id == destination_place_id
+      return unless origin_id == destination_id
 
       errors.add(:base, 'Origin and destination cannot be the same')
     end

data/app/models/spree_cm_commissioner/trip_connection.rb

@@ -1,7 +1,7 @@
 module SpreeCmCommissioner
-  class TripConnection < Base
-    belongs_to :from_trip, class_name: 'SpreeCmCommissioner::Trip'
-    belongs_to :to_trip, class_name: 'SpreeCmCommissioner::Trip'
+  class TripConnection < ApplicationRecord
+    belongs_to :from_trip, class_name: 'Spree::Variant'
+    belongs_to :to_trip, class_name: 'Spree::Variant'
 
     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.arrival_time.seconds_since_midnight
-      departure_seconds = to_trip.departure_time.seconds_since_midnight
+      arrival_seconds   = from_trip.trip.arrival_time.seconds_since_midnight
+      departure_seconds = to_trip.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,25 +1,36 @@
+require_dependency 'spree_cm_commissioner'
 module SpreeCmCommissioner
-  class TripStop < Base
+  class TripStop < SpreeCmCommissioner::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 :trip, class_name: 'Spree::Variant'
+    belongs_to :stop, class_name: 'SpreeCmCommissioner::Place'
 
     before_validation :set_stop_name
-    validates :stop_place_id, uniqueness: { scope: :trip_id }
+    after_destroy :decrement_trip_count
+    after_commit :create_vendor_stop
+    validates :stop_id, uniqueness: { scope: :trip_id }
 
     def set_stop_name
-      self.stop_name = stop_place.name if stop_place.present?
+      self.stop_name = stop.name if stop.present?
     end
 
-    def self.ransackable_attributes(_auth_object = nil)
-      %w[stop_name stop_type]
+    def create_vendor_stop
+      vendor_stop = vendor.vendor_stops.where(stop_id: stop_id, stop_type: stop_type).first_or_create
+      vendor_stop.update(trip_count: vendor_stop.trip_count.to_i + 1)
     end
 
-    def self.ransackable_associations(_auth_object = nil)
-      ['stop_place']
+    private
+
+    def decrement_trip_count
+      vendor.vendor_stops.where(stop_id: stop_id, stop_type: stop_type).find_each do |vendor_stop|
+        vendor_stop.update(trip_count: [vendor_stop.trip_count - 1, 0].max)
+      end
+    end
+
+    def vendor
+      Spree::Product.find(trip&.product_id).vendor
     end
   end
 end

data/app/models/spree_cm_commissioner/user_decorator.rb

@@ -90,7 +90,7 @@ module SpreeCmCommissioner
 
     def vendor_organizer?(vendor)
       spree_roles.any? do |role|
-        role.name == "#{vendor.name.downcase.parameterize(separator: '-')}-organizer"
+        role.name == "#{vendor.id}-organizer"
       end
     end
 

data/app/models/spree_cm_commissioner/variant_decorator.rb

@@ -1,7 +1,6 @@
 module SpreeCmCommissioner
   module VariantDecorator
-    def self.prepended(base) # rubocop:disable Metrics/AbcSize
-      base.include SpreeCmCommissioner::ProductType
+    def self.prepended(base)
       base.include SpreeCmCommissioner::ProductDelegation
       base.include SpreeCmCommissioner::VariantOptionsConcern
       base.include SpreeCmCommissioner::KycBitwise
@@ -21,21 +20,24 @@ module SpreeCmCommissioner
       base.has_many :video_on_demands, class_name: 'SpreeCmCommissioner::VideoOnDemand', dependent: :destroy
       base.has_many :complete_line_items, -> { complete }, class_name: 'Spree::LineItem'
 
-      base.has_many :variant_blocks, class_name: 'SpreeCmCommissioner::VariantBlock', dependent: :destroy
-      base.has_many :blocks, class_name: 'SpreeCmCommissioner::Block', through: :variant_blocks
-
       base.has_many :variant_guest_card_class, class_name: 'SpreeCmCommissioner::VariantGuestCardClass'
       base.has_many :guest_card_classes, class_name: 'SpreeCmCommissioner::GuestCardClass', through: :variant_guest_card_class
 
-      base.has_many :inventory_items, class_name: 'SpreeCmCommissioner::InventoryItem'
-
       base.scope :subscribable, -> { active.joins(:product).where(product: { subscribable: true, status: :active }) }
-      base.scope :with_permanent_stock, -> { where(product_type: base::PERMANENT_STOCK_PRODUCT_TYPES) }
-      base.scope :with_non_permanent_stock, -> { where.not(product_type: base::PERMANENT_STOCK_PRODUCT_TYPES) }
-
+      base.has_one :trip,
+                   class_name: 'SpreeCmCommissioner::Trip'
+      base.has_many :trip_stops, class_name: 'SpreeCmCommissioner::TripStop', dependent: :destroy, foreign_key: :trip_id
       base.accepts_nested_attributes_for :option_values
+      base.after_commit :sync_trip, if: :transit?
+      base.accepts_nested_attributes_for :trip_stops, allow_destroy: true
+      base.after_commit :create_trip_stops, if: :transit?
+    end
+
+    def create_trip_stops
+      return if is_master?
 
-      base.before_save -> { self.product_type = product.product_type }, if: -> { product_type.nil? }
+      trip_stops.find_or_create_by(stop_type: :boarding, stop_id: options.origin)
+      trip_stops.find_or_create_by(stop_type: :drop_off, stop_id: options.destination)
     end
 
     def delivery_required?
@@ -51,20 +53,8 @@ module SpreeCmCommissioner
       super || product.discontinued?
     end
 
-    def default_inventory_item_exist?
-      inventory_items.exists?(inventory_date: nil)
-    end
-
-    def create_default_non_permanent_inventory_item!(quantity_available: nil, max_capacity: nil)
-      return if product_type.blank? # handle in case product not exist for variant.
-      return unless should_track_inventory?
-      return if default_inventory_item_exist?
-
-      inventory_items.create!(
-        product_type: product_type,
-        quantity_available: [0, quantity_available || total_on_hand].max,
-        max_capacity: [0, max_capacity || total_on_hand].max
-      )
+    def permanent_stock?
+      accommodation?
     end
 
     # override
@@ -82,26 +72,30 @@ module SpreeCmCommissioner
       "#{display_sku} - #{display_price}"
     end
 
+    def transit?
+      product.product_type == 'transit'
+    end
+
     # override
-    def in_stock?(options = {})
-      SpreeCmCommissioner::Stock::AvailabilityChecker.new(self, options).can_supply?
+    def in_stock?
+      available_quantity.positive?
     end
 
-    def price_for_date(currency:, date:)
-      currency = currency.upcase
+    private
 
-      prices.joins(:inventory_item)
-            .find_by(
-              currency: currency,
-              inventory_item: { inventory_date: date }
-            )
+    def total_purchases
+      Spree::LineItem.complete.where(variant_id: id).sum(:quantity).to_i
     end
 
-    private
+    def available_quantity
+      stock_count = stock_items.sum(&:count_on_hand)
+      return stock_count if delivery_required?
+
+      stock_count - total_purchases
+    end
 
     def update_vendor_price
-      return unless vendor.present? && product_type == vendor&.primary_product_type
-      return if price.blank?
+      return unless vendor.present? && product&.product_type == vendor&.primary_product_type
 
       vendor.update(min_price: price) if vendor.min_price.nil? || price < vendor.min_price
       vendor.update(max_price: price) if vendor.max_price.nil? || price > vendor.max_price
@@ -125,6 +119,22 @@ module SpreeCmCommissioner
         end
       end
     end
+
+    def sync_trip
+      return unless product.product_type == 'transit'
+
+      trip = SpreeCmCommissioner::Trip.find_or_initialize_by(variant_id: id)
+
+      trip.assign_attributes(
+        product_id: product_id,
+        origin_id: options.origin,
+        destination_id: options.destination,
+        departure_time: options.departure_time,
+        duration: options.total_duration_in_seconds,
+        vehicle_id: options.vehicle
+      )
+      trip.save
+    end
   end
 end
 

data/app/models/spree_cm_commissioner/variant_options.rb

@@ -143,5 +143,28 @@ module SpreeCmCommissioner
     def number_of_guests
       number_of_adults + number_of_kids
     end
+
+    def origin
+      @origin ||= option_value_name_for(option_type_name: 'origin')&.to_i
+    end
+
+    def destination
+      @destination ||= option_value_name_for(option_type_name: 'destination')&.to_i
+    end
+
+    def vehicle
+      @vehicle ||= option_value_name_for(option_type_name: 'vehicle')&.to_i
+    end
+
+    def allow_seat_selection
+      @allow_seat_selection ||= option_value_name_for(option_type_name: 'allow-seat-selection')&.to_i
+    end
+
+    def departure_time
+      @departure_time ||= begin
+        time = option_value_name_for(option_type_name: 'departure-time')
+        Time.zone.parse(time) if time.present?
+      end
+    end
   end
 end

data/app/models/spree_cm_commissioner/vehicle.rb

@@ -1,24 +1,29 @@
+require_dependency 'spree_cm_commissioner'
+
 module SpreeCmCommissioner
-  class Vehicle < Base
-    include SpreeCmCommissioner::VehicleType
+  class Vehicle < SpreeCmCommissioner::Base
+    include SpreeCmCommissioner::RouteType
 
+    belongs_to :vehicle_type, class_name: 'SpreeCmCommissioner::VehicleType'
+    has_one :primary_photo, -> { order(position: :asc) }, class_name: 'SpreeCmCommissioner::VehiclePhoto', as: :viewable, dependent: :destroy
     belongs_to :vendor, class_name: 'Spree::Vendor'
 
-    has_one :primary_photo, -> { order(position: :asc) }, class_name: 'SpreeCmCommissioner::VehiclePhoto', as: :viewable, dependent: :destroy
-    has_one :seat_layout, as: :layoutable, class_name: 'SpreeCmCommissioner::SeatLayout', dependent: :destroy
+    after_commit :create_vehicle_option_value
 
-    has_many :vehicle_photos, class_name: 'SpreeCmCommissioner::VehiclePhoto', as: :viewable, dependent: :destroy
+    has_many :vehicle_photo, class_name: 'SpreeCmCommissioner::VehiclePhoto', as: :viewable, dependent: :destroy
+    has_many :vehicle_seats, class_name: 'SpreeCmCommissioner::VehicleSeat', through: :vehicle_type
 
     has_many :vehicle_option_types, class_name: 'SpreeCmCommissioner::VehicleOptionType', dependent: :destroy
     has_many :option_value_vehicles, class_name: 'SpreeCmCommissioner::OptionValueVehicle', dependent: :destroy
-    has_many :option_values, through: :option_value_vehicles, class_name: 'Spree::OptionValue'
-    validates :code, uniqueness: { scope: :vendor_id }, presence: true
-    validates :license_plate, uniqueness: true, allow_blank: true
 
-    self.whitelisted_ransackable_attributes = %w[license_plate code vehicle_type]
+    validates :code, uniqueness: { scope: :vendor_id }, presence: true
+    validates :license_plate, uniqueness: {}, allow_blank: true
 
-    def display_name
-      "#{code} (#{license_plate})"
+    def create_vehicle_option_value
+      SpreeCmCommissioner::VehicleOptionValueCreator.call(self)
     end
+
+    self.whitelisted_ransackable_attributes = %w[license_plate code]
+    self.whitelisted_ransackable_associations = %w[vehicle_type]
   end
 end

data/app/models/spree_cm_commissioner/vehicle_seat.rb

@@ -0,0 +1,11 @@
+module SpreeCmCommissioner
+  class VehicleSeat < SpreeCmCommissioner::Base
+    belongs_to :vehicle_type, class_name: 'SpreeCmCommissioner::VehicleType', dependent: :destroy
+    has_many :line_item_seats, class_name: 'SpreeCmCommissioner::LineItemSeat', dependent: :destroy
+    counter_culture :vehicle_type, column_name: proc { |model|
+                                                  model.seat_type.in?(%w[normal vip]) && model.vehicle_type.allow_seat_selection == true ? 'vehicle_seats_count' : nil # rubocop:disable Layout/LineLength
+                                                },
+                                   column_names: { ['cm_vehicle_seats.seat_type IN (?)', %i[0 2]] => 'vehicle_seats_count' }
+    enum seat_type: %i[normal empty vip driver].freeze
+  end
+end

data/app/models/spree_cm_commissioner/vehicle_type.rb

@@ -0,0 +1,76 @@
+module SpreeCmCommissioner
+  class VehicleType < SpreeCmCommissioner::Base
+    include SpreeCmCommissioner::RouteType
+
+    after_commit :recalculate_vehicle_seats_count, if: -> { saved_change_to_allow_seat_selection? && allow_seat_selection }
+    after_commit :set_vehicles_attributes
+
+    has_many :vehicle_seats, class_name: 'SpreeCmCommissioner::VehicleSeat', dependent: :destroy
+    has_many :option_value_vehicle_types, class_name: 'SpreeCmCommissioner::OptionValueVehicleType'
+    has_many :option_values, through: :option_value_vehicle_types, class_name: 'Spree::OptionValue'
+    has_many :vehicles, class_name: 'SpreeCmCommissioner::Vehicle', dependent: :destroy
+    belongs_to :vendor, class_name: 'Spree::Vendor'
+
+    validates :code, presence: true
+    validates :code, uniqueness: true
+    validates :name, presence: true
+    validates :name, uniqueness: true
+    accepts_nested_attributes_for :vehicle_seats, allow_destroy: true
+
+    state_machine :status, initial: :draft do
+      event :draft do
+        transition to: :draft
+      end
+      after_transition to: :draft, do: :after_draft
+
+      event :activate do
+        transition to: :active
+      end
+      after_transition to: :active, do: :after_activate
+
+      event :archive do
+        transition to: :archived
+      end
+      after_transition to: :archived, do: :after_archive
+    end
+
+    self.whitelisted_ransackable_attributes = %w[name code route_type id status]
+
+    def after_activate; end
+    def after_archive; end
+    def after_draft; end
+
+    def set_vehicles_attributes
+      vehicles.each(&:set_attributes)
+      vehicles.each(&:save)
+    end
+
+    def recalculate_vehicle_seats_count
+      self.vehicle_seats_count = vehicle_seats.where(seat_type: %w[normal vip]).count
+      save
+    end
+
+    def seat_layers
+      grouped_seats = SpreeCmCommissioner::VehicleSeat.where(vehicle_type_id: id).group_by(&:layer).transform_values do |seats|
+        seats.group_by(&:row).transform_values do |row_seats|
+          row_seats.sort_by(&:column).map do |seat|
+            {
+              row: seat.row,
+              column: seat.column,
+              label: seat.label,
+              layer: seat.layer,
+              seat_type: seat.seat_type,
+              created_at: seat.created_at,
+              vehicle_type_id: seat.vehicle_type_id
+            }
+          end
+        end
+      end
+      grouped_seats.map do |_layer, layer_seats|
+        layer_seats.map do |_row, row_seats|
+          row_seats
+        end
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/vendor_decorator.rb

@@ -36,17 +36,21 @@ module SpreeCmCommissioner
       base.has_many :vendor_kind_option_values,
                     through: :option_value_vendors, source: :option_value
 
-      base.has_many :branches, -> { branch }, class_name: 'SpreeCmCommissioner::VendorPlace'
-      base.has_many :stops, -> { stop }, class_name: 'SpreeCmCommissioner::VendorPlace'
-      base.has_many :locations, -> { location }, class_name: 'SpreeCmCommissioner::VendorPlace'
-
-      base.has_many :branch_places, through: :branches, class_name: 'SpreeCmCommissioner::Place', source: :place
-      base.has_many :stop_places, through: :stops, class_name: 'SpreeCmCommissioner::Place', source: :place
-      base.has_many :location_places, through: :locations, class_name: 'SpreeCmCommissioner::Place', source: :place
+      base.has_many :branches, lambda {
+                                 where(cm_vendor_places: { place_type: 0 })
+                               }, through: :vendor_places, class_name: 'SpreeCmCommissioner::VendorPlace'
+      base.has_many :stops, -> { where(cm_vendor_places: { place_type: 1 }) }, through: :vendor_places, class_name: 'SpreeCmCommissioner::VendorPlace'
+      base.has_many :locations, -> { where(cm_vendor_places: { place_type: 2 }) },
+                    through: :vendor_places, class_name: 'SpreeCmCommissioner::VendorPlace'
 
       base.has_many :places,
                     through: :nearby_places, source: :place, class_name: 'SpreeCmCommissioner::Place'
 
+      base.has_many :vendor_stops, class_name: 'SpreeCmCommissioner::VendorStop', dependent: :destroy
+      base.has_many :boarding_points, -> { where(cm_vendor_stops: { stop_type: 0 }) },
+                    through: :vendor_stops, source: :stop, class_name: 'SpreeCmCommissioner::Place'
+      base.has_many :drop_off_points, -> { where(cm_vendor_stops: { stop_type: 1 }) },
+                    through: :vendor_stops, source: :stop, class_name: 'SpreeCmCommissioner::Place'
       base.has_many :dynamic_fields, class_name: 'SpreeCmCommissioner::DynamicField', foreign_key: :vendor_id, dependent: :destroy
 
       base.has_one  :logo, as: :viewable, dependent: :destroy, class_name: 'SpreeCmCommissioner::VendorLogo'
@@ -77,13 +81,12 @@ module SpreeCmCommissioner
       base.has_many :promotion_categories, class_name: 'Spree::PromotionCategory', foreign_key: :vendor_id, dependent: :destroy
 
       base.has_many :homepage_section_relatables,
-                    as: :relatable,
                     class_name: 'SpreeCmCommissioner::HomepageSectionRelatable',
-                    dependent: :destroy,
-                    inverse_of: :relatable
+                    dependent: :destroy, inverse_of: :relatable
 
+      base.has_many :vehicle_types, class_name: 'SpreeCmCommissioner::VehicleType', dependent: :destroy
       base.has_many :vehicles, class_name: 'SpreeCmCommissioner::Vehicle', dependent: :destroy
-      base.has_many :trips, class_name: 'SpreeCmCommissioner::Trip', dependent: :destroy
+      # base.has_many :vehicles, through: :vehicle_types, class_name: 'SpreeCmCommissioner::Vehicle', dependent: :destroy
 
       base.validates :account_name, :account_number, presence: true, if: lambda {
                                                                            payment_qrcode.present? && Spree::Store.default.code.include?('billing')

data/app/models/spree_cm_commissioner/vendor_place.rb

@@ -5,25 +5,15 @@ module SpreeCmCommissioner
 
     belongs_to :vendor, class_name: 'Spree::Vendor', optional: false
     belongs_to :place, class_name: 'SpreeCmCommissioner::Place', optional: false
-    belongs_to :location, class_name: 'SpreeCmCommissioner::VendorPlace', optional: true
-
-    has_many :branches, -> { branch }, class_name: 'SpreeCmCommissioner::VendorPlace', foreign_key: :location_id, dependent: :restrict_with_error
-    has_many :stops, -> { stop }, class_name: 'SpreeCmCommissioner::VendorPlace', foreign_key: :location_id, dependent: :restrict_with_error
 
     validates :place_type, presence: true
     validates :place_id, uniqueness: { scope: %i[vendor_id place_type] }
-    validates :location, presence: true, if: -> { branch? || stop? }
 
     accepts_nested_attributes_for :place, allow_destroy: true
 
-    # include place when using these delegate to avoid N+1
-    def display_name
-      place&.name
-    end
-
-    def self.ransackable_associations(_auth_object = nil)
-      ['place']
-    end
+    scope :branches,  -> { where(place_type: :branch) }
+    scope :stops,     -> { where(place_type: :stop) }
+    scope :locations, -> { where(place_type: :location) }
 
     def selected
       vendor.selected_place_references.include?(place&.reference)

data/app/models/spree_cm_commissioner/vendor_stop.rb

@@ -0,0 +1,10 @@
+require_dependency 'spree_cm_commissioner'
+module SpreeCmCommissioner
+  class VendorStop < ApplicationRecord
+    belongs_to :vendor, class_name: 'Spree::Vendor'
+    belongs_to :stop, class_name: 'SpreeCmCommissioner::Place'
+
+    validates :trip_count, numericality: { greater_than_or_equal_to: 0 }
+    enum :stop_type, { boarding: 0, drop_off: 1 }
+  end
+end

data/app/overrides/spree/admin/products/_form/industry_taxons.html.erb.deface

@@ -0,0 +1,26 @@
+<!-- insert_after "[data-hook='admin_product_form_taxons']" -->
+
+<div data-hook="admin_product_form_industry_taxons">
+  <%= f.field_container :industry_taxons do %>
+    <%= f.label :industry_taxon_ids, Spree.t(:Industries) %>
+
+    <% if can? :modify, Spree::Classification %>
+      <%= f.select :industry_taxon_ids, options_from_collection_for_select(@product.industry_taxons, :id, :pretty_name, @product.industry_taxon_ids),
+                                { include_hidden: true },
+                                  multiple: true,
+                                  data: { autocomplete_url_value: 'taxons_api_v2',
+                                          autocomplete_return_attr_value: 'pretty_name',
+                                          autocomplete_multiple_value: true,
+                                          autocomplete_additional_url_params_value: "q[kind_eq]=7" } %>
+    <% elsif @product.industry_taxons.any? %>
+      <ul class="text_list">
+        <% @product.industry_taxons.each do |taxon| %>
+          <li><%= taxon.name %></li>
+        <% end %>
+      </ul>
+    <% else %>
+      <div class="alert alert-info"><%= Spree.t(:no_resource_found, resource: :taxons) %></div>
+    <% end %>
+
+  <% end %>
+</div>

data/app/overrides/spree/admin/products/_form/taxons.html.erb.deface

@@ -0,0 +1,26 @@
+<!-- replace "[data-hook='admin_product_form_taxons']" -->
+
+<div data-hook="admin_product_form_taxons">
+  <%= f.field_container :taxons do %>
+    <%= f.label :taxon_ids, Spree.t(:taxons) %>
+
+    <% if can? :modify, Spree::Classification %>
+      <%= f.select :taxon_ids, options_from_collection_for_select(@product.taxons, :id, :pretty_name, @product.taxon_ids.reject { |id| @product.industry_taxon_ids.include?(id) }),
+                                { include_hidden: true },
+                                  multiple: true,
+                                  data: { autocomplete_url_value: 'taxons_api_v2',
+                                          autocomplete_return_attr_value: 'pretty_name',
+                                          autocomplete_multiple_value: true,
+                                          autocomplete_additional_url_params_value: "q[kind_not_eq]=7" } %>
+    <% elsif @product.taxons.any? %>
+      <ul class="text_list">
+        <% @product.taxons.each do |taxon| %>
+          <li><%= taxon.name %></li>
+        <% end %>
+      </ul>
+    <% else %>
+      <div class="alert alert-info"><%= Spree.t(:no_resource_found, resource: :taxons) %></div>
+    <% end %>
+
+  <% end %>
+</div>