spree_cm_commissioner 1.10.0 → 1.11.0.pre.pre

data/app/interactors/spree_cm_commissioner/create_event.rb

@@ -10,6 +10,8 @@ module SpreeCmCommissioner
         assign_prototype
         create_child_taxon
         build_home_banner
+        assign_option_types
+        assign_option_values
       end
     end
 
@@ -61,5 +63,26 @@ module SpreeCmCommissioner
 
       context.fail!(message: 'Home banner upload failed') unless banner.persisted?
     end
+
+    def assign_options(model_class, param_key, foreign_key)
+      return unless params[param_key]
+
+      params[param_key].each do |id|
+        record = model_class.new(
+          taxon_id: @parent_taxon.id,
+          foreign_key => id
+        )
+
+        context.fail!(message: record.errors.full_messages.join(', ')) unless record.save
+      end
+    end
+
+    def assign_option_types
+      assign_options(SpreeCmCommissioner::TaxonOptionType, :option_type_id, :option_type_id)
+    end
+
+    def assign_option_values
+      assign_options(SpreeCmCommissioner::TaxonOptionValue, :option_value_id, :option_value_id)
+    end
   end
 end

data/app/interactors/spree_cm_commissioner/ensure_correct_product_type.rb

@@ -0,0 +1,40 @@
+module SpreeCmCommissioner
+  class EnsureCorrectProductType < BaseInteractor
+    def call
+      Spree::Product
+        .left_joins(variants_including_master: %i[inventory_items line_items])
+        .where(
+          'spree_variants.product_type IS NULL OR
+          spree_variants.product_type != spree_products.product_type OR
+
+          cm_inventory_items.product_type IS NULL OR
+          cm_inventory_items.product_type != spree_products.product_type OR
+
+          spree_line_items.product_type IS NULL OR
+          spree_line_items.product_type != spree_products.product_type OR
+
+          spree_products.product_type IS NOT NULL
+          '
+        )
+        .distinct.find_each do |product|
+        sync_product_type_for(product)
+      end
+    end
+
+    def sync_product_type_for(product)
+      product_type = Spree::Variant.product_types[product.product_type]
+
+      product.variants_including_master
+             .where('spree_variants.product_type IS NULL OR spree_variants.product_type != ?', product_type)
+             .update_all(product_type: product_type) # rubocop:disable Rails/SkipsModelValidations
+
+      product.line_items
+             .where('spree_line_items.product_type IS NULL OR spree_line_items.product_type != ?', product_type)
+             .update_all(product_type: product_type) # rubocop:disable Rails/SkipsModelValidations
+
+      product.inventory_items
+             .where('cm_inventory_items.product_type IS NULL OR cm_inventory_items.product_type != ?', product_type)
+             .update_all(product_type: product_type) # rubocop:disable Rails/SkipsModelValidations
+    end
+  end
+end

data/app/interactors/spree_cm_commissioner/inventory_item_syncer.rb

@@ -0,0 +1,25 @@
+module SpreeCmCommissioner
+  class InventoryItemSyncer < BaseInteractor
+    # inventory_id_and_quantities = [{ inventory_id: inventory_item1.id, quantity: 5 } ]
+    delegate :inventory_id_and_quantities, to: :context
+
+    def call
+      ActiveRecord::Base.transaction do
+        inventory_items.each do |inventory_item|
+          quantity = inventory_id_and_quantities.find { |item| item[:inventory_id] == inventory_item.id }&.dig(:quantity) || 0
+          adjust_quantity_available(inventory_item, quantity)
+        end
+      end
+    end
+
+    private
+
+    def adjust_quantity_available(inventory_item, quantity)
+      inventory_item.update!(quantity_available: inventory_item.quantity_available + quantity)
+    end
+
+    def inventory_items
+      @inventory_items ||= InventoryItem.where(id: inventory_id_and_quantities.pluck(:inventory_id))
+    end
+  end
+end

data/app/interactors/spree_cm_commissioner/stock/inventory_items_adjuster.rb

@@ -0,0 +1,13 @@
+module SpreeCmCommissioner
+  module Stock
+    class InventoryItemsAdjuster < BaseInteractor
+      delegate :variant, :quantity, to: :context
+
+      def call
+        variant.inventory_items.active.find_each do |inventory_item|
+          inventory_item.adjust_quantity!(quantity)
+        end
+      end
+    end
+  end
+end

data/app/interactors/spree_cm_commissioner/stock/permanent_inventory_items_generator.rb

@@ -0,0 +1,75 @@
+module SpreeCmCommissioner
+  module Stock
+    class PermanentInventoryItemsGenerator < BaseInteractor
+      delegate :variant_ids, to: :context
+
+      def variants_per_batch = 1000
+
+      def pre_inventory_days_for(variant)
+        context.pre_inventory_days || variant.pre_inventory_days
+      end
+
+      def call
+        variants.in_batches(of: variants_per_batch) do |batch|
+          generate_inventory_items_for_batch(batch)
+        end
+      end
+
+      private
+
+      def generate_inventory_items_for_batch(batch)
+        total_on_hand_by_variant = total_on_hand_for(batch)
+        batch.each do |variant|
+          count_on_hand = total_on_hand_by_variant[variant.id] || 0
+          generate_inventory_items_for_variant(variant, count_on_hand)
+        end
+      end
+
+      def generate_inventory_items_for_variant(variant, count_on_hand)
+        inventory_dates_for(variant).each do |inventory_date|
+          next if inventory_exist?(variant, inventory_date)
+
+          create_inventory_item(variant, inventory_date, count_on_hand)
+        end
+      end
+
+      def inventory_dates_for(variant)
+        start_date = Time.zone.tomorrow
+        end_date = Time.zone.today + pre_inventory_days_for(variant)
+
+        (start_date..end_date)
+      end
+
+      def inventory_exist?(variant, inventory_date)
+        variant.inventory_items.exists?(inventory_date: inventory_date)
+      end
+
+      def create_inventory_item(variant, inventory_date, count_on_hand)
+        variant.inventory_items.create!(
+          inventory_date: inventory_date,
+          quantity_available: count_on_hand,
+          max_capacity: count_on_hand,
+          product_type: variant.product_type
+        )
+      end
+
+      # Returns a hash: { variant_id => total_on_hand, ... }
+      def total_on_hand_for(variants)
+        variant_ids = variants.pluck(:id)
+
+        Spree::StockItem
+          .joins(:stock_location)
+          .where(deleted_at: nil, variant_id: variant_ids)
+          .where(spree_stock_locations: { active: true })
+          .group(:variant_id)
+          .sum(:count_on_hand)
+      end
+
+      def variants
+        scope = Spree::Variant.active.with_permanent_stock.where(is_master: false)
+        scope = scope.where(id: variant_ids) if variant_ids.present?
+        scope
+      end
+    end
+  end
+end

data/app/interactors/spree_cm_commissioner/stock/stock_movement_creator.rb

@@ -0,0 +1,24 @@
+module SpreeCmCommissioner
+  module Stock
+    class StockMovementCreator < BaseInteractor
+      delegate :variant_id, :stock_location_id, :current_store, :stock_movement_params, to: :context
+
+      def call
+        variant = current_store.variants.find(variant_id)
+
+        return context.fail!(message: Spree.t(:doesnt_track_inventory)) unless variant.track_inventory?
+
+        stock_location = Spree::StockLocation.find(stock_location_id)
+        stock_movement = stock_location.stock_movements.build(stock_movement_params)
+        stock_movement.stock_item = stock_location.set_up_stock_item(variant)
+
+        if stock_movement.save
+          SpreeCmCommissioner::Stock::InventoryItemsAdjusterJob.perform_later(variant_id: variant.id, quantity: stock_movement.quantity)
+          context.stock_movement = stock_movement
+        else
+          context.fail!(message: stock_movement.errors.full_messages.join(', '))
+        end
+      end
+    end
+  end
+end

data/app/interactors/spree_cm_commissioner/vattanac_bank_initiator.rb

@@ -25,10 +25,8 @@ module SpreeCmCommissioner
     end
 
     def verify_signature
-      public_key = ENV['VATTANAC_PUBLIC_KEY'].presence || Rails.application.credentials.vattanac.public_key
-
       rsa_service = SpreeCmCommissioner::RsaService.new(
-        public_key: public_key
+        public_key: vattanac_public_key
       )
 
       return if rsa_service.verify(context.encrypted_data, context.signature)
@@ -37,8 +35,6 @@ module SpreeCmCommissioner
     end
 
     def decrypt_payload
-      aes_key = ENV['VATTANAC_AES_SECRET_KEY'].presence || Rails.application.credentials.vattanac.aes_secret_key
-
       context.fail!(message: 'Invalid AES key length', status: :unprocessable_entity) unless aes_key
 
       begin
@@ -57,7 +53,7 @@ module SpreeCmCommissioner
       user_data = context.user_data
 
       identity = SpreeCmCommissioner::UserIdentityProvider.vattanac_bank
-                                                          .find_or_initialize_by(sub: user_data['id'])
+                                                          .find_or_initialize_by(sub: user_data['phoneNum'])
 
       if identity.persisted?
         context.user = identity.user
@@ -82,7 +78,7 @@ module SpreeCmCommissioner
       identity = context.identity
 
       identity.name = full_name
-
+      identity.email = user_data['email']
       context.user = Spree::User.new(
         first_name: user_data['firstName'],
         last_name: user_data['lastName'],
@@ -99,18 +95,41 @@ module SpreeCmCommissioner
 
     def construct_data
       user = context.user
-      context.data = {
+
+      raw_data = {
         sessionId: session_id,
         name: user.full_name,
         phone: user.phone_number,
         email: user.email,
         webUrl: "#{Spree::Store.default.formatted_url}/vattanac_bank_web_app?session_id=#{session_id}"
       }
+
+      json_data = raw_data.to_json
+
+      encrypted_data = SpreeCmCommissioner::AesEncryptionService.encrypt(json_data, aes_key)
+
+      rsa_service = SpreeCmCommissioner::RsaService.new(private_key: bookmeplus_private_key)
+
+      signed_data = rsa_service.sign(encrypted_data)
+
+      context.data = signed_data
     end
 
     def session_id
       payload = { user_id: context.user.id }
       SpreeCmCommissioner::UserSessionJwtToken.encode(payload, context.user.reload.secure_token)
     end
+
+    def aes_key
+      ENV['VATTANAC_AES_SECRET_KEY'].presence || Rails.application.credentials.vattanac.aes_secret_key
+    end
+
+    def bookmeplus_private_key
+      ENV['BOOKMEPLUS_PRIVATE_KEY'].presence || Rails.application.credentials.bookmeplus.private_key
+    end
+
+    def vattanac_public_key
+      ENV['VATTANAC_PUBLIC_KEY'].presence || Rails.application.credentials.vattanac.public_key
+    end
   end
 end

data/app/jobs/spree_cm_commissioner/ensure_correct_product_type_job.rb

@@ -0,0 +1,7 @@
+module SpreeCmCommissioner
+  class EnsureCorrectProductTypeJob < ApplicationJob
+    def perform
+      SpreeCmCommissioner::EnsureCorrectProductType.call
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/inventory_item_syncer_job.rb

@@ -0,0 +1,7 @@
+module SpreeCmCommissioner
+  class InventoryItemSyncerJob < ApplicationUniqueJob
+    def perform(inventory_id_and_quantities:)
+      InventoryItemSyncer.call(inventory_id_and_quantities:)
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/stock/inventory_items_adjuster_job.rb

@@ -0,0 +1,11 @@
+module SpreeCmCommissioner
+  module Stock
+    class InventoryItemsAdjusterJob < ApplicationUniqueJob
+      def perform(variant_id:, quantity:)
+        variant = Spree::Variant.find(variant_id)
+
+        SpreeCmCommissioner::Stock::InventoryItemsAdjuster.call(variant: variant, quantity: quantity)
+      end
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/stock/permanent_inventory_items_generator_job.rb

@@ -0,0 +1,9 @@
+module SpreeCmCommissioner
+  module Stock
+    class PermanentInventoryItemsGeneratorJob < ApplicationUniqueJob
+      def perform
+        SpreeCmCommissioner::Stock::PermanentInventoryItemsGenerator.call
+      end
+    end
+  end
+end

data/app/models/concerns/spree_cm_commissioner/order_state_machine.rb

@@ -13,10 +13,13 @@ module SpreeCmCommissioner
       state_machine.after_transition to: :complete, do: :notify_order_complete_telegram_notification_to_user, unless: :subscription?
       state_machine.after_transition to: :complete, do: :send_order_complete_telegram_alert_to_vendors, unless: :need_confirmation?
       state_machine.after_transition to: :complete, do: :send_order_complete_telegram_alert_to_store, unless: :need_confirmation?
+      state_machine.around_transition to: :complete, do: :handle_unstock_in_redis
 
       state_machine.after_transition to: :resumed, do: :precalculate_conversion
+      state_machine.around_transition to: :resumed, do: :handle_unstock_in_redis
 
       state_machine.after_transition to: :canceled, do: :precalculate_conversion
+      state_machine.after_transition to: :canceled, do: :restock_inventory_in_redis!
 
       scope :accepted, -> { where(request_state: 'accepted') }
 
@@ -66,6 +69,29 @@ module SpreeCmCommissioner
       end
     end
 
+    def handle_unstock_in_redis
+      ActiveRecord::Base.transaction do
+        yield # Equal to block.call
+
+        # After the transition is complete, the following code will execute first before proceeding to other `after_transition` callbacks.
+        # This ensures that if `unstock_inventory_in_redis!` fails, the state will be rolled back,
+        # and neither the `finalize!` method nor any notifications will be triggered.
+        # The payment will be reversed in vPago gem, and `Spree::Checkout::Complete` will be called, which checks `order.reload.complete?`.
+        # This is critical because if the order state is complete, the payment will be marked as paid.
+        CmAppLogger.log(label: 'order_state_machine_before_unstock', data: { order_id: id, state: state })
+        unstock_inventory_in_redis!
+        # We rollback only order state, and we keep payment state as it is.
+        # We implement payment in vPago gem, and it will be reversed in the gem.
+        # Some bank has api for refund, but some don't have the api to refund yet. So we keep the payment state as it is and refund manually.
+        CmAppLogger.log(label: 'order_state_machine_after_unstock', data: { order_id: id, state: state })
+      end
+    rescue StandardError => e
+      CmAppLogger.log(label: 'order_state_machine',
+                      data: { order_id: id, error: e.message, type: e.class.name, backtrace: e.backtrace.first(5).join("\n") }
+                     )
+      raise e
+    end
+
     def generate_bib_number
       line_items.find_each(&:generate_remaining_guests)
 

data/app/models/concerns/spree_cm_commissioner/product_delegation.rb

@@ -3,12 +3,10 @@ module SpreeCmCommissioner
     extend ActiveSupport::Concern
 
     included do
-      delegate :product_type,
-               :subscribable?,
+      delegate :subscribable?,
                :allowed_upload_later?,
                :need_confirmation?, :need_confirmation, :kyc,
                :allow_anonymous_booking,
-               :accommodation?, :service?, :ecommerce?,
                :associated_event,
                :allow_self_check_in,
                :allow_self_check_in?,

data/app/models/concerns/spree_cm_commissioner/product_type.rb

@@ -6,10 +6,20 @@ module SpreeCmCommissioner
     extend ActiveSupport::Concern
 
     PRODUCT_TYPES = %i[accommodation service ecommerce transit].freeze
+    PERMANENT_STOCK_PRODUCT_TYPES = %w[accommodation service transit].freeze
+    PRE_INVENTORY_DAYS = { 'transit' => 90, 'accommodation' => 365, 'service' => 30 }.freeze
 
     included do
       enum product_type: PRODUCT_TYPES if table_exists? && column_names.include?('product_type')
       enum primary_product_type: PRODUCT_TYPES if table_exists? && column_names.include?('primary_product_type')
     end
+
+    def permanent_stock?
+      PERMANENT_STOCK_PRODUCT_TYPES.include?(product_type)
+    end
+
+    def pre_inventory_days
+      PRE_INVENTORY_DAYS[product_type]
+    end
   end
 end

data/app/models/spree_cm_commissioner/inventory.rb

@@ -0,0 +1,11 @@
+module SpreeCmCommissioner
+  class Inventory
+    include ActiveModel::Model
+
+    attr_accessor :variant_id, :inventory_date, :quantity_available, :max_capacity, :product_type
+
+    validates :variant_id, presence: true
+    validates :quantity_available, numericality: { only_integer: true, greater_than_or_equal_to: 0 }, allow_nil: true
+    validates :max_capacity, numericality: { only_integer: true, greater_than_or_equal_to: 0 }, allow_nil: true
+  end
+end

data/app/models/spree_cm_commissioner/inventory_item.rb

@@ -0,0 +1,55 @@
+module SpreeCmCommissioner
+  class InventoryItem < ApplicationRecord
+    include SpreeCmCommissioner::ProductType
+
+    # Association
+    belongs_to :variant, class_name: 'Spree::Variant'
+
+    # 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 :variant_id, uniqueness: { scope: :inventory_date, message: -> (object, _data) { "The variant is taken on #{object.inventory_date}" } }
+
+    # Scope
+    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
+
+    def active?
+      inventory_date.nil? || inventory_date >= Time.zone.today
+    end
+
+    def redis_expired_in
+      expired_in = 31_536_000 # 1 year for normal stock
+      expired_in = Time.parse(inventory_date.to_s).end_of_day.to_i - Time.zone.now.to_i if inventory_date.present?
+      [expired_in, 0].max
+    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,6 +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, 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
@@ -21,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
@@ -41,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
 
@@ -59,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
@@ -174,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
@@ -230,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/order_decorator.rb

@@ -58,6 +58,13 @@ module SpreeCmCommissioner
       end
     end
 
+    # override
+    # spree use this method to check stock availability & consider whether :order can continue to next state.
+    def insufficient_stock_lines
+      checker = SpreeCmCommissioner::Stock::OrderAvailabilityChecker.new(self)
+      checker.insufficient_stock_lines
+    end
+
     def ticket_seller_user?
       return false if user.nil?
 
@@ -194,6 +201,14 @@ module SpreeCmCommissioner
 
     private
 
+    def unstock_inventory_in_redis!
+      SpreeCmCommissioner::RedisStock::InventoryUpdater.new(line_item_ids).unstock!
+    end
+
+    def restock_inventory_in_redis!
+      SpreeCmCommissioner::RedisStock::InventoryUpdater.new(line_item_ids).restock!
+    end
+
     # override :spree_api
     def webhook_payload_body
       resource_serializer.new(

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

@@ -33,6 +33,7 @@ module SpreeCmCommissioner
       base.has_one :google_wallet, class_name: 'SpreeCmCommissioner::GoogleWallet', dependent: :destroy
 
       base.has_many :complete_line_items, through: :classifications, source: :line_items
+      base.has_many :inventory_items, through: :variants
 
       base.has_many :product_places, class_name: 'SpreeCmCommissioner::ProductPlace', dependent: :destroy
       base.has_many :places, through: :product_places
@@ -57,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]
@@ -102,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