spree_cm_commissioner 1.18.2.pre.pre1 → 2.0.0.pre.pre

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_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

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,25 +1,39 @@
-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
-    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
+    belongs_to :product, class_name: 'Spree::Product', inverse_of: :trip, optional: false
+    belongs_to :vehicle, class_name: 'SpreeCmCommissioner::Vehicle', optional: false
+    belongs_to :origin, class_name: 'SpreeCmCommissioner::Place', optional: true
+    belongs_to :destination, class_name: 'SpreeCmCommissioner::Place', optional: true
+
+    has_many :trip_stops, class_name: 'SpreeCmCommissioner::TripStop', dependent: :destroy
+    has_many :variants, through: :product
+    has_many :inventory_items, through: :variants
 
     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

data/app/models/spree_cm_commissioner/user_taxon.rb

@@ -2,6 +2,5 @@ module SpreeCmCommissioner
   class UserTaxon < Base
     belongs_to :user, class_name: Spree.user_class.to_s, optional: false
     belongs_to :taxon, class_name: 'Spree::Taxon', optional: false
-    has_many :invite_user_taxons, class_name: 'SpreeCmCommissioner::InviteUserTaxon', dependent: :destroy
   end
 end

data/app/models/spree_cm_commissioner/variant_block.rb

@@ -0,0 +1,9 @@
+module SpreeCmCommissioner
+  class VariantBlock < Base
+    belongs_to :variant, class_name: 'Spree::Variant', optional: false
+    belongs_to :trip, class_name: 'SpreeCmCommissioner::Trip', optional: false
+    belongs_to :block, class_name: 'SpreeCmCommissioner::Block', optional: false
+
+    validates :block_id, uniqueness: { scope: %i[variant_id trip_id] }
+  end
+end

data/app/models/spree_cm_commissioner/variant_decorator.rb

@@ -1,6 +1,7 @@
 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.include SpreeCmCommissioner::KycBitwise
@@ -20,24 +21,21 @@ 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.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
+      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) }
 
-    def create_trip_stops
-      return if is_master?
+      base.accepts_nested_attributes_for :option_values
 
-      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)
+      base.before_save -> { self.product_type = product.product_type }, if: -> { product_type.nil? }
     end
 
     def delivery_required?
@@ -53,8 +51,20 @@ module SpreeCmCommissioner
       super || product.discontinued?
     end
 
-    def permanent_stock?
-      accommodation?
+    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
+      )
     end
 
     # override
@@ -72,30 +82,25 @@ module SpreeCmCommissioner
       "#{display_sku} - #{display_price}"
     end
 
-    def transit?
-      product.product_type == 'transit'
-    end
-
     # override
-    def in_stock?
-      available_quantity.positive?
+    def in_stock?(options = {})
+      SpreeCmCommissioner::Stock::AvailabilityChecker.new(self, options).can_supply?
     end
 
-    private
+    def price_for_date(currency:, date:)
+      currency = currency.upcase
 
-    def total_purchases
-      Spree::LineItem.complete.where(variant_id: id).sum(:quantity).to_i
+      prices.joins(:inventory_item)
+            .find_by(
+              currency: currency,
+              inventory_item: { inventory_date: date }
+            )
     end
 
-    def available_quantity
-      stock_count = stock_items.sum(&:count_on_hand)
-      return stock_count if delivery_required?
-
-      stock_count - total_purchases
-    end
+    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 vendor.min_price.nil? || price < vendor.min_price
       vendor.update(max_price: price) if vendor.max_price.nil? || price > vendor.max_price
@@ -119,22 +124,6 @@ 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,28 +143,5 @@ 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,29 +1,24 @@
-require_dependency 'spree_cm_commissioner'
-
 module SpreeCmCommissioner
-  class Vehicle < SpreeCmCommissioner::Base
+  class Vehicle < 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'
 
-    after_commit :create_vehicle_option_value
+    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'
 
-    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_photos, class_name: 'SpreeCmCommissioner::VehiclePhoto', as: :viewable, dependent: :destroy
 
     has_many :vehicle_option_types, class_name: 'SpreeCmCommissioner::VehicleOptionType', dependent: :destroy
     has_many :option_value_vehicles, class_name: 'SpreeCmCommissioner::OptionValueVehicle', dependent: :destroy
 
     validates :code, uniqueness: { scope: :vendor_id }, presence: true
-    validates :license_plate, uniqueness: {}, allow_blank: true
-
-    def create_vehicle_option_value
-      SpreeCmCommissioner::VehicleOptionValueCreator.call(self)
-    end
+    validates :license_plate, uniqueness: true, allow_blank: true
 
     self.whitelisted_ransackable_attributes = %w[license_plate code]
-    self.whitelisted_ransackable_associations = %w[vehicle_type]
+
+    def display_name
+      "#{code} (#{license_plate})"
+    end
   end
 end

data/app/models/spree_cm_commissioner/vendor_decorator.rb

@@ -36,12 +36,13 @@ module SpreeCmCommissioner
       base.has_many :vendor_kind_option_values,
                     through: :option_value_vendors, source: :option_value
 
-      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 :branches, -> { branches }, class_name: 'SpreeCmCommissioner::VendorPlace'
+      base.has_many :stops, -> { stops }, class_name: 'SpreeCmCommissioner::VendorPlace'
+      base.has_many :locations, -> { locations }, 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 :places,
                     through: :nearby_places, source: :place, class_name: 'SpreeCmCommissioner::Place'
@@ -78,16 +79,12 @@ module SpreeCmCommissioner
       base.has_many :invoices, class_name: 'SpreeCmCommissioner::Invoice', dependent: :destroy
       base.has_many :subscriptions, through: :customers, class_name: 'SpreeCmCommissioner::Subscription'
       base.has_many :subscription_orders, through: :subscriptions, class_name: 'Spree::Order', source: :orders
-      base.has_many :promotion_categories, class_name: 'Spree::PromotionCategory', foreign_key: :vendor_id, dependent: :destroy
 
       base.has_many :homepage_section_relatables,
                     class_name: 'SpreeCmCommissioner::HomepageSectionRelatable',
                     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 :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

@@ -7,13 +7,14 @@ module SpreeCmCommissioner
     belongs_to :place, class_name: 'SpreeCmCommissioner::Place', optional: false
 
     validates :place_type, presence: true
-    validates :place_id, uniqueness: { scope: %i[vendor_id place_type] }
+    validates :position, presence: true, numericality: { only_integer: true, greater_than: 0 }
 
-    accepts_nested_attributes_for :place, allow_destroy: true
+    # include place when using these delegate to avoid N+1
+    def display_name
+      place&.name
+    end
 
-    scope :branches,  -> { where(place_type: :branch) }
-    scope :stops,     -> { where(place_type: :stop) }
-    scope :locations, -> { where(place_type: :location) }
+    accepts_nested_attributes_for :place, allow_destroy: true
 
     def selected
       vendor.selected_place_references.include?(place&.reference)

data/app/models/spree_cm_commissioner/vendor_stop.rb

@@ -1,6 +1,5 @@
-require_dependency 'spree_cm_commissioner'
 module SpreeCmCommissioner
-  class VendorStop < ApplicationRecord
+  class VendorStop < Base
     belongs_to :vendor, class_name: 'Spree::Vendor'
     belongs_to :stop, class_name: 'SpreeCmCommissioner::Place'
 

data/app/overrides/spree/admin/variants/_form/kyc_field.html.erb.deface

@@ -2,13 +2,13 @@
 
 <p>Guest Information Fields</p>
 <div class="form-check mb-3">
-  <%= f.check_box :use_product_kyc, id: "toggleGuestInfo", class: 'form-check-input mr-2', checked: @variant.kyc.nil? %>
+  <%= f.check_box :use_product_kyc, id: "toggleGuestInfo", class: 'form-check-input mr-2', checked: (@variant.kyc == @product.kyc) %>
   <label for="toggleGuestInfo" class="form-check-label">
     Use Product Guest Information
   </label>
 </div>
 
-<div id="guestInfoForm" <% if @variant.kyc.nil? %>style="display: none;"<% end %>">
+<div id="guestInfoForm" <% if @variant.kyc == @product.kyc %>style="display: none;"<% end %>">
   <small class="form-text text-muted mb-4">
     <%= raw I18n.t('kyc.variant_note') %>
   </small>