spree_cm_commissioner 1.10.0.pre.pre1 → 1.11.0.pre.pre

data/app/models/spree_cm_commissioner/inventory_item.rb

@@ -8,19 +8,37 @@ module SpreeCmCommissioner
     # Validation
     validates :quantity_available, numericality: { greater_than_or_equal_to: 0 }
     validates :max_capacity, numericality: { greater_than_or_equal_to: 0 } # Originally inventory of each variant.
-    validates :inventory_date, presence: true, if: -> { permanent_stock? }
+    validates :inventory_date, presence: true, if: :permanent_stock?
     validates :variant_id, uniqueness: { scope: :inventory_date, message: -> (object, _data) { "The variant is taken on #{object.inventory_date}" } }
 
     # Scope
-    scope :for_product, -> (type) { where(product_type: type) }
     scope :active, -> { where(inventory_date: nil).or(where('inventory_date >= ?', Time.zone.today)) }
 
+    before_save -> { self.product_type = variant.product_type }, if: -> { product_type.nil? }
+
     def adjust_quantity!(quantity)
       with_lock do
         self.max_capacity = max_capacity + quantity
         self.quantity_available = quantity_available + quantity
-
         save!
+
+        # When user has been searched or booked a product, it has cached the quantity in redis,
+        # So we need to update redis cache if inventory key has been created in redis
+        adjust_quantity_in_redis(quantity)
+      end
+    end
+
+    def adjust_quantity_in_redis(quantity)
+      SpreeCmCommissioner.redis_pool.with do |redis|
+        cached_quantity_available = redis.get("inventory:#{id}")
+        # ignore if redis doesn't exist
+        return if cached_quantity_available.nil? # rubocop:disable Lint/NonLocalExitFromIterator
+
+        if quantity.positive?
+          redis.incrby("inventory:#{id}", quantity)
+        else
+          redis.decrby("inventory:#{id}", quantity.abs)
+        end
       end
     end
 

data/app/models/spree_cm_commissioner/line_item_decorator.rb

@@ -1,6 +1,6 @@
 module SpreeCmCommissioner
   module LineItemDecorator
-    def self.prepended(base) # rubocop:disable Metrics/MethodLength
+    def self.prepended(base) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
       include_modules(base)
 
       base.belongs_to :accepter, class_name: 'Spree::User', optional: true
@@ -9,7 +9,11 @@ module SpreeCmCommissioner
       base.has_one :google_wallet, class_name: 'SpreeCmCommissioner::GoogleWallet', through: :product
 
       base.has_many :option_types, through: :product
-      base.has_many :inventory_items, through: :variant
+
+      base.has_many :inventory_items, lambda { |line_item|
+        where(inventory_date: nil).or(where(inventory_date: line_item.date_range))
+      }, through: :variant
+
       base.has_many :taxons, class_name: 'Spree::Taxon', through: :product
       base.has_many :guests, class_name: 'SpreeCmCommissioner::Guest', dependent: :destroy
       base.has_many :pending_guests, pending_guests_query, class_name: 'SpreeCmCommissioner::Guest', dependent: :destroy
@@ -22,16 +26,15 @@ module SpreeCmCommissioner
       base.validate :validate_seats_reservation, if: :transit?
 
       base.before_create :add_due_date, if: :subscription?
+      base.before_save -> { self.product_type = variant.product_type }, if: -> { product_type.nil? }
 
       base.validate :ensure_not_exceed_max_quantity_per_order, if: -> { variant&.max_quantity_per_order.present? }
 
       base.whitelisted_ransackable_associations |= %w[guests order]
       base.whitelisted_ransackable_attributes |= %w[number to_date from_date vendor_id]
 
-      base.delegate :delivery_required?, :permanent_stock?, :high_demand, :transit?,
+      base.delegate :delivery_required?, :high_demand,
                     to: :variant
-      base.delegate :discontinue_on, :product_type, :accommodation?, :service?, :ecommerce?, :need_confirmation,
-                    to: :product
 
       base.accepts_nested_attributes_for :guests, allow_destroy: true
       base.accepts_nested_attributes_for :line_item_seats, allow_destroy: true
@@ -42,6 +45,10 @@ module SpreeCmCommissioner
         json_api_columns << :vendor_id
       end
 
+      def discontinue_on
+        variant.discontinue_on || product.discontinue_on
+      end
+
       def base.search_by_qr_data!(data)
         matches = data.match(/(R\d+)-([A-Za-z0-9_\-]+)-(L\d+)/)&.captures
 
@@ -60,6 +67,7 @@ module SpreeCmCommissioner
       base.include SpreeCmCommissioner::LineItemDurationable
       base.include SpreeCmCommissioner::LineItemsFilterScope
       base.include SpreeCmCommissioner::LineItemGuestsConcern
+      base.include SpreeCmCommissioner::ProductType
       base.include SpreeCmCommissioner::ProductDelegation
       base.include SpreeCmCommissioner::KycBitwise
     end
@@ -175,7 +183,7 @@ module SpreeCmCommissioner
 
     # override
     def sufficient_stock?
-      return transit_sufficient_stock? if variant.product.product_type == 'transit'
+      return transit_sufficient_stock? if transit?
 
       SpreeCmCommissioner::Stock::LineItemAvailabilityChecker.new(self).can_supply?(quantity)
     end
@@ -231,6 +239,8 @@ module SpreeCmCommissioner
     end
 
     def validate_seats_reservation
+      return if reservation_trip.blank?
+
       if reservation_trip.allow_seat_selection && !selected_seats_available?
         errors.add(:base, :some_seats_are_booked, message: 'Some seats are already booked')
       elsif !reservation_trip.allow_seat_selection && !seat_quantity_available?(reservation_trip)

data/app/models/spree_cm_commissioner/place.rb

@@ -2,6 +2,8 @@ require_dependency 'spree_cm_commissioner'
 
 module SpreeCmCommissioner
   class Place < ApplicationRecord
+    acts_as_nested_set
+
     validates :reference, presence: true, if: :validate_reference?
     validates :lat, presence: true, if: :validate_lat?
     validates :lon, presence: true, if: :validate_lon?
@@ -13,15 +15,22 @@ module SpreeCmCommissioner
 
     has_many :product_places, class_name: 'SpreeCmCommissioner::ProductPlace', dependent: :destroy
     has_many :products, through: :product_places
-    has_many :children, class_name: 'SpreeCmCommissioner::Place', foreign_key: :parent_id, dependent: :destroy
-    belongs_to :parent, class_name: 'SpreeCmCommissioner::Place', optional: true
 
+    has_many :children, -> { order(:lft) }, class_name: 'SpreeCmCommissioner::Place', foreign_key: :parent_id, dependent: :destroy
     has_many :vendor_stops, class_name: 'SpreeCmCommissioner::VendorStop', dependent: :destroy
 
     def self.ransackable_attributes(auth_object = nil)
       super & %w[name code]
     end
 
+    def full_path_name
+      self_and_ancestors.map(&:name).reverse.join(', ')
+    end
+
+    def path_ids
+      self_and_ancestors.map(&:id)
+    end
+
     def validate_reference?
       Spree::Store.default.code.exclude?('billing')
     end

data/app/models/spree_cm_commissioner/product_decorator.rb

@@ -58,9 +58,8 @@ module SpreeCmCommissioner
       base.scope :subscribable, -> { where(subscribable: 1) }
 
       base.validate :validate_event_taxons, if: -> { taxons.event.present? }
-
       base.validate :validate_product_date, if: -> { available_on.present? && discontinue_on.present? }
-
+      base.validate :product_type_unchanged, on: :update
       base.validates :commission_rate, numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 100 }, allow_nil: true
 
       base.whitelisted_ransackable_attributes = %w[description name slug discontinue_on status vendor_id short_name route_type]
@@ -103,6 +102,13 @@ module SpreeCmCommissioner
 
       errors.add(:discontinue_on, 'must be after the available on date')
     end
+
+    def product_type_unchanged
+      return if product_type_was.nil?
+      return unless product_type_changed?
+
+      errors.add(:product_type, 'cannot be changed once set')
+    end
   end
 end
 

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

@@ -34,8 +34,20 @@ module SpreeCmCommissioner
 
       private
 
+      # only unstock or restock when variants is available, track inventory, not backorderable & not need_confirmation.
+      # otherwise, we can ignore them.
       def line_items
-        @line_items ||= Spree::LineItem.where(id: @line_item_ids)
+        return @line_items if defined?(@line_items)
+
+        @line_items = Spree::LineItem.where(id: @line_item_ids).includes(variant: :stock_items)
+        @line_items = @line_items.map do |line_item|
+          next unless line_item.variant.available?
+          next unless line_item.variant.should_track_inventory?
+          next if line_item.variant.backorderable?
+          next if line_item.variant.need_confirmation?
+
+          line_item
+        end.compact
       end
 
       def unstock(keys, quantities)
@@ -52,7 +64,7 @@ module SpreeCmCommissioner
 
       # Return: [CachedInventoryItem(...), CachedInventoryItem(...)]
       def cached_inventory_items
-        @cached_inventory_items ||= SpreeCmCommissioner::RedisStock::LineItemsCachedInventoryItemsBuilder.new(line_item_ids: @line_item_ids)
+        @cached_inventory_items ||= SpreeCmCommissioner::RedisStock::LineItemsCachedInventoryItemsBuilder.new(line_item_ids: line_items.pluck(:id))
                                                                                                          .call.values.flatten
       end
 

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

@@ -25,17 +25,11 @@ module SpreeCmCommissioner
       end
 
       def inventory_items
-        @inventory_items ||= line_items.flat_map do |line_item|
-          # TODO: N+1, we could fix but have a product_type in line item
-          # then include inventory_items in line item directly #2581
-          scope = line_item.inventory_items
-          scope = scope.where(inventory_date: line_item.date_range) if line_item.permanent_stock?
-          scope
-        end
+        @inventory_items ||= line_items.flat_map(&:inventory_items)
       end
 
       def line_items
-        @line_items ||= Spree::LineItem.where(id: line_item_ids).includes(variant: %i[product])
+        @line_items ||= Spree::LineItem.where(id: line_item_ids).includes(:inventory_items)
       end
     end
   end

data/app/models/spree_cm_commissioner/stock_item_decorator.rb

@@ -3,11 +3,29 @@ 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
+      if variant.permanent_stock?
+        SpreeCmCommissioner::Stock::PermanentInventoryItemsGeneratorJob.perform_later(variant_ids: [variant.id])
+      else
+        variant.create_default_non_permanent_inventory_item! unless variant.default_inventory_item_exist?
+      end
+    end
+
+    # When admin delete stock item, it will deduct stock from inventory item
+    def adjust_inventory_items_async
+      SpreeCmCommissioner::Stock::InventoryItemsAdjusterJob.perform_later(variant_id: variant_id, quantity: -count_on_hand)
+    end
   end
 end
 

data/app/models/spree_cm_commissioner/taxon_decorator.rb

@@ -57,6 +57,9 @@ module SpreeCmCommissioner
       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'
+
       def base.active_homepage_events
         joins(:homepage_section_relatables)
           .joins("INNER JOIN spree_taxons taxon ON taxon.id = cm_homepage_section_relatables.relatable_id
@@ -96,6 +99,14 @@ module SpreeCmCommissioner
                        .uniq
     end
 
+    def selected_option_types
+      taxon_option_types.pluck(:option_type_id)
+    end
+
+    def selected_option_values
+      taxon_option_values.pluck(:option_value_id)
+    end
+
     def event_url
       "https://#{Spree::Store.default.url}/t/#{permalink}"
     end

data/app/models/spree_cm_commissioner/taxon_option_type.rb

@@ -0,0 +1,8 @@
+require_dependency 'spree_cm_commissioner'
+
+module SpreeCmCommissioner
+  class TaxonOptionType < ApplicationRecord
+    belongs_to :taxon, class_name: 'Spree::Taxon', dependent: :destroy
+    belongs_to :option_type, class_name: 'Spree::OptionType', dependent: :destroy
+  end
+end

data/app/models/spree_cm_commissioner/taxon_option_value.rb

@@ -0,0 +1,8 @@
+require_dependency 'spree_cm_commissioner'
+
+module SpreeCmCommissioner
+  class TaxonOptionValue < ApplicationRecord
+    belongs_to :taxon, class_name: 'Spree::Taxon', dependent: :destroy
+    belongs_to :option_value, class_name: 'Spree::OptionValue', dependent: :destroy
+  end
+end

data/app/models/spree_cm_commissioner/trip.rb

@@ -14,23 +14,12 @@ module SpreeCmCommissioner
     validates :duration, numericality: { greater_than: 0 }
     validate :origin_and_destination_cannot_be_the_same
 
-    has_many :trip_stops, class_name: 'SpreeCmCommissioner::TripStop', dependent: :destroy
-
-    after_commit :create_trip_stops
-
-    accepts_nested_attributes_for :trip_stops, allow_destroy: true
-
     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.create(stop_type: :boarding, stop_id: origin_id)
-      trip_stops.create(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

@@ -5,6 +5,7 @@ module SpreeCmCommissioner
 
     validate :both_trip_cannot_be_the_same
     before_validation :calculate_connection_time_minutes
+    validates :from_trip_id, uniqueness: { scope: :to_trip_id }
 
     private
 

data/app/models/spree_cm_commissioner/trip_stop.rb

@@ -8,22 +8,29 @@ module SpreeCmCommissioner
     belongs_to :stop, class_name: 'SpreeCmCommissioner::Place'
 
     before_validation :set_stop_name
-    after_create :create_vendor_stop
-
+    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.name
+      self.stop_name = stop.name if stop.present?
     end
 
     def create_vendor_stop
-      vendor.vendor_stops.where(stop_id: stop_id, stop_type: stop_type).first_or_create
+      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
 
     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
+      Spree::Product.find(trip&.product_id).vendor
     end
   end
 end

data/app/models/spree_cm_commissioner/variant_decorator.rb

@@ -1,10 +1,9 @@
 module SpreeCmCommissioner
   module VariantDecorator
-    def self.prepended(base)
+    def self.prepended(base) # rubocop:disable Metrics/AbcSize
       base.include SpreeCmCommissioner::ProductType
       base.include SpreeCmCommissioner::ProductDelegation
       base.include SpreeCmCommissioner::VariantOptionsConcern
-
       base.after_commit :update_vendor_price
       base.validate     :validate_option_types
       base.before_save -> { self.track_inventory = false }, if: :subscribable?
@@ -25,13 +24,26 @@ module SpreeCmCommissioner
       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, -> { joins(:product).where(product: { product_type: base::PERMANENT_STOCK_PRODUCT_TYPES }) }
-      base.scope :with_non_permanent_stock, -> { joins(:product).where.not(product: { product_type: base::PERMANENT_STOCK_PRODUCT_TYPES }) }
+      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: -> { product.product_type == 'transit' }
+
+      base.before_save -> { self.product_type = product.product_type }, if: -> { product_type.nil? }
+
+      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?
+
+      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?
@@ -82,10 +94,6 @@ 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?
@@ -94,7 +102,7 @@ module SpreeCmCommissioner
     private
 
     def update_vendor_price
-      return unless vendor.present? && product&.product_type == vendor&.primary_product_type
+      return unless vendor.present? && product_type == vendor&.primary_product_type
 
       vendor.update(min_price: price) if price < vendor.min_price
       vendor.update(max_price: price) if price > vendor.max_price
@@ -120,7 +128,7 @@ module SpreeCmCommissioner
     end
 
     def sync_trip
-      return unless product.product_type == 'transit'
+      return unless transit?
 
       trip = SpreeCmCommissioner::Trip.find_or_initialize_by(variant_id: id)
 

data/app/models/spree_cm_commissioner/variant_options.rb

@@ -166,19 +166,5 @@ module SpreeCmCommissioner
         Time.zone.parse(time) if time.present?
       end
     end
-
-    def arrival_time
-      @arrival_time ||= departure_time + total_duration_in_minutes.minutes
-    end
-
-    def total_duration_in_minutes
-      total_duration_in_minutes = 0
-
-      total_duration_in_minutes += duration_in_hours * 60 if duration_in_hours.present?
-      total_duration_in_minutes += duration_in_minutes if duration_in_minutes.present?
-      total_duration_in_minutes += duration_in_seconds / 60 if duration_in_seconds.present?
-
-      total_duration_in_minutes
-    end
   end
 end

data/app/models/spree_cm_commissioner/vendor_stop.rb

@@ -4,6 +4,7 @@ module SpreeCmCommissioner
     belongs_to :vendor, class_name: 'Spree::Vendor'
     belongs_to :stop, class_name: 'SpreeCmCommissioner::Place'
 
-    enum stop_type: { boarding: 0, drop_off: 1 }
+    validates :trip_count, numericality: { greater_than_or_equal_to: 0 }
+    enum :stop_type, { boarding: 0, drop_off: 1 }
   end
 end

data/app/queries/spree_cm_commissioner/trip_query.rb

@@ -34,11 +34,11 @@ module SpreeCmCommissioner
                         trips.vehicle_id AS vehicle_id'
                       )
                .joins('INNER JOIN cm_trips AS trips ON trips.variant_id = spree_variants.id')
-               .joins('INNER JOIN cm_trip_stops AS boarding ON boarding.trip_id = trips.id AND boarding.stop_type = 0')
-               .joins('INNER JOIN cm_trip_stops AS drop_off ON drop_off.trip_id = trips.id AND drop_off.stop_type = 1')
+               .joins('INNER JOIN cm_trip_stops AS boarding ON boarding.trip_id = spree_variants.id AND boarding.stop_type = 0')
+               .joins('INNER JOIN cm_trip_stops AS drop_off ON drop_off.trip_id = spree_variants.id AND drop_off.stop_type = 1')
                .joins('INNER JOIN spree_vendors AS vendors ON vendors.id = spree_variants.vendor_id')
                .joins('INNER JOIN spree_products AS routes ON routes.id = spree_variants.product_id')
-               .where('trips.origin_id = ? AND trips.destination_id = ?', origin_id, destination_id)
+               .where('boarding.stop_id = ? AND drop_off.stop_id = ?', origin_id, destination_id)
 
       result.map do |trip|
         trip_result_options = {
@@ -69,9 +69,9 @@ module SpreeCmCommissioner
                  INNER JOIN spree_products AS routes2 ON routes2.id = variant2.product_id
                  INNER JOIN cm_trips AS trip1 ON trip1.variant_id = cm_trip_connections.from_trip_id
                  INNER JOIN cm_trips AS trip2 ON trip2.variant_id = cm_trip_connections.to_trip_id
-                 INNER JOIN cm_places trip1_origin ON trip1_origin.id = trip1.origin_id
-                 INNER JOIN cm_places trip2_origin ON trip2_origin.id = trip2.origin_id
-                 INNER JOIN cm_places trip2_destination ON trip2_destination.id = trip2.destination_id
+                 INNER JOIN cm_trip_stops trip1_origin ON trip1_origin.trip_id = variant1.id AND trip1_origin.stop_type = 0
+                 INNER JOIN cm_trip_stops trip2_origin ON trip2_origin.trip_id = variant2.id AND trip2_origin.stop_type = 0
+                 INNER JOIN cm_trip_stops trip2_destination ON trip2_destination.trip_id = variant2.id AND trip2_destination.stop_type = 1
                  INNER JOIN spree_vendors AS vendor1 ON vendor1.id = variant1.vendor_id
                  INNER JOIN spree_vendors AS vendor2 ON vendor2.id = variant2.vendor_id'
                      )
@@ -93,12 +93,12 @@ module SpreeCmCommissioner
                         trip2.vehicle_id AS trip2_vehicle,
                         routes2.short_name AS route2_short_name,
                         routes2.name AS route2_name,
-                        trip1_origin.name AS trip1_origin,
-                        trip2_origin.name AS trip2_origin,
-                        trip2_destination.name AS trip2_destination,
+                        trip1_origin.stop_name AS trip1_origin,
+                        trip2_origin.stop_name AS trip2_origin,
+                        trip2_destination.stop_name AS trip2_destination,
                         vendor2.name AS trip2_vendor_name'
-                      )
-               .where('trip1_origin.id = ? AND trip2_destination.id = ?', origin_id, destination_id)
+                      ).where('trip1_origin.stop_id = ? AND trip2_destination.stop_id = ?', origin_id, destination_id
+                      ).uniq
 
       return [] if result.blank?
 

data/app/queries/spree_cm_commissioner/vendor_stop_place_query.rb

@@ -0,0 +1,54 @@
+module SpreeCmCommissioner
+  class VendorStopPlaceQuery
+    attr_reader :query, :vendor_id, :stop_type, :reference_stop_id
+
+    def initialize(query:, vendor_id:, stop_type: :boarding, reference_stop_id: nil)
+      @query = query.to_s.strip
+      @vendor_id = vendor_id
+      @stop_type = stop_type
+      @reference_stop_id = reference_stop_id
+    end
+
+    def call
+      results = vendor_stops
+      return [] if results.empty?
+
+      places = results.includes(:stop).map(&:stop).compact.uniq
+
+      format_places(places)
+    end
+
+    private
+
+    def vendor_stops
+      scope = base_scope
+      return scope if query.blank?
+
+      scope = scope.where.not(stop_id: reference_stop_id) if reference_stop_id.present?
+      scope.where('cm_places.name ILIKE ?', "%#{query}%")
+    end
+
+    def base_scope
+      SpreeCmCommissioner::VendorStop
+        .joins(:stop)
+        .where(vendor_id: vendor_id)
+        .where(stop_type: stop_type)
+        .order(trip_count: :desc)
+        .where.not(trip_count: 0)
+    end
+
+    def format_places(places)
+      places
+        .sort_by { |p| [-p.depth, -p.lft] }
+        .filter_map do |place|
+          next if place.depth.zero?
+
+          {
+            id: place.id,
+            parent_id: place.parent_id,
+            name: place.self_and_ancestors.map(&:name).reverse.join(', ')
+          }
+        end
+    end
+  end
+end

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

@@ -13,6 +13,7 @@ module Spree
 
         belongs_to :occupation, serializer: Spree::V2::Tenant::TaxonSerializer
         belongs_to :nationality, serializer: Spree::V2::Tenant::TaxonSerializer
+        has_one :id_card, serializer: Spree::V2::Tenant::IdCardSerializer
 
         # allowed_checkout updates frequently
         cache_options store: nil

data/app/services/spree_cm_commissioner/organizer/export_guest_csv_service.rb

@@ -48,6 +48,8 @@ module SpreeCmCommissioner
       end
 
       def fetch_option_value(guest, option_type_name)
+        return guest.formatted_bib_number if option_type_name == 'bib-prefix'
+
         guest.line_item&.variant&.find_option_value_name_for(option_type_name: option_type_name)
       end
 

data/app/views/spree/admin/stock_managements/_events_popover.html.erb

@@ -1,17 +1,23 @@
 <div>
   <% events.each do |event| %>
-    <div>
-      <h6><%= event.options[:inventory_item].variant.options_text %></h6>
-      <ul class="list-group mt-1">
+    <% inventory_item = event.options[:inventory_item] %>
+
+    <div class="mb-3">
+      <h6><%= inventory_item.variant.options_text %></h6>
+      <ul class="list-group mt-1 mb-1">
         <li class="list-group-item d-flex justify-content-between align-items-center">
           Max capacity
-          <span class="badge badge-primary badge-pill"><%= event.options[:inventory_item].max_capacity %></span>
+          <span class="badge badge-primary badge-pill"><%= inventory_item.max_capacity %></span>
         </li>
         <li class="list-group-item d-flex justify-content-between align-items-center">
-          Quantity available
-          <span class="badge badge-primary badge-pill"><%= event.options[:inventory_item].quantity_available %></span>
+          Quantity available in DB
+          <span class="badge badge-primary badge-pill"><%= inventory_item.quantity_available %></span>
         </li>
       </ul>
+
+      <small class="text-muted">
+        <%= inventory_item_message(inventory_item, @cached_inventory_items[inventory_item.id]) %>
+      </small>
     </div>
   <% end %>
 </div>

data/app/views/spree/admin/stock_managements/_variant_stock_items.html.erb

@@ -17,9 +17,11 @@
           </td>
           <td class="text-center d-flex flex-column align-items-center justify-content-center">
             <div style="width: 90px;">
-              <%= form_tag admin_stock_items_path(variant_id: variant.id, stock_location_id: stock_location.id), method: :post do %>
+              <%= form_tag admin_product_stock_managements_path(product_id: params[:product_id], variant_id: variant.id, stock_location_id: stock_location.id), method: :post do %>
                 <div class="input-group input-group-sm">
                   <%= number_field_tag 'stock_movement[quantity]', 0, class: 'form-control text-center p-0' %>
+                  <%= hidden_field_tag 'stock_movement[originator_id]', spree_current_user.id %>
+                  <%= hidden_field_tag 'stock_movement[originator_type]', spree_current_user.class.name %>
                   <div class="input-group-append">
                     <%= button_tag(class: 'btn btn-outline-success pl-2 pr-1') do %>
                       <%= svg_icon(name: 'arrow-left-right.svg', classes: "icon", width: 14, height: 14) %>

data/app/views/spree/admin/stock_managements/calendar.html.erb

@@ -19,9 +19,12 @@
             <%= date.day %>
             <ul class="p-0 m-0 list-unstyled">
               <% events.each do |event| %>
-              <li class="badge badge-warning">
-                <%= event.options[:inventory_item].quantity_available %>
-              </li>
+                <% inventory_item = event.options[:inventory_item] %>
+                <% synced = inventory_item.quantity_available == @cached_inventory_items[inventory_item.id].quantity_available %>
+
+                <li class="badge <%= synced ? "badge-warning" : "badge-danger" %>">
+                  <%= inventory_item.quantity_available %>
+                </li>
               <% end %>
             </ul>
           </div>