spree_cm_commissioner 1.18.1 → 2.0.0.pre.pre

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

@@ -5,6 +5,8 @@ module SpreeCmCommissioner
     extend ActiveSupport::Concern
 
     included do
+      state_machine.before_transition to: :payment, do: :hold_blocks!
+
       state_machine.before_transition to: :complete, do: :request, if: :need_confirmation?
       state_machine.before_transition to: :complete, do: :generate_bib_number
 
@@ -14,10 +16,14 @@ module SpreeCmCommissioner
       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: :unstock_inventory!
+
       state_machine.after_transition to: :complete, do: :send_transaction_email_to_user, if: :user_has_email?
       state_machine.after_transition to: :resumed, do: :precalculate_conversion
+      state_machine.around_transition to: :resumed, do: :unstock_inventory!
 
       state_machine.after_transition to: :canceled, do: :precalculate_conversion
+      state_machine.after_transition to: :canceled, do: :restock_inventory!
 
       scope :accepted, -> { where(request_state: 'accepted') }
 
@@ -67,6 +73,39 @@ module SpreeCmCommissioner
       end
     end
 
+    def unstock_inventory!
+      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 `reserve_blocks!` or `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.
+
+        reserve_blocks!
+        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.
+      end
+    rescue StandardError => e
+      CmAppLogger.log(
+        label: 'SpreeCmCommissioner::OrderStateMachine#reserve_inventory failed',
+        data: { order_id: id, error: e.message, type: e.class.name, backtrace: e.backtrace&.first(5)&.join("\n") }
+      )
+
+      raise e
+    end
+
+    def restock_inventory!
+      ActiveRecord::Base.transaction do
+        cancel_blocks!
+        restock_inventory_in_redis!
+      end
+    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,
                :allow_anonymous_booking,
-               :accommodation?, :service?, :ecommerce?,
                :allow_self_check_in,
                :allow_self_check_in?,
                :required_self_check_in_location,

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/concerns/spree_cm_commissioner/taxon_kind.rb

@@ -3,7 +3,7 @@ module SpreeCmCommissioner
     extend ActiveSupport::Concern
 
     included do
-      enum kind: { category: 0, cms: 1, event: 2, occupation: 3, nationality: 4, organization: 5, transit: 6 }
+      enum kind: { category: 0, cms: 1, event: 2, occupation: 3, nationality: 4, organization: 5 }
     end
   end
 end

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

@@ -5,10 +5,6 @@ module SpreeCmCommissioner
     included do
       preference :assetlinks, :string, default: ''
       preference :apple_app_site_association, :string, default: ''
-      preference :payment_checkout_image, :string, default: ''
-      preference :payment_failed_image, :string, default: ''
-      preference :payment_success_image, :string, default: ''
-      preference :payment_loader, :string, default: ''
     end
   end
 end

data/app/models/spree_cm_commissioner/block.rb

@@ -0,0 +1,23 @@
+module SpreeCmCommissioner
+  class Block < Base
+    belongs_to :seat_section, class_name: 'SpreeCmCommissioner::SeatSection', optional: true
+    belongs_to :seat_layout, class_name: 'SpreeCmCommissioner::SeatLayout', optional: false
+
+    validates :label, presence: true
+
+    has_many :variant_blocks, class_name: 'SpreeCmCommissioner::VariantBlock', dependent: :destroy
+    has_many :variants, class_name: 'Spree::Variant', through: :variant_blocks
+
+    validates :width, presence: true, numericality: { greater_than: 0 }
+    validates :height, presence: true, numericality: { greater_than: 0 }
+    validates :x, presence: true, numericality: true
+    validates :y, presence: true, numericality: true
+    validates :rotation, presence: true, numericality: { greater_than_or_equal_to: -360, less_than_or_equal_to: 360 }
+
+    before_validation :assign_layout_from_section, if: -> { seat_layout.nil? && seat_section.present? }
+
+    def assign_layout_from_section
+      self.seat_layout = seat_section.seat_layout
+    end
+  end
+end

data/app/models/spree_cm_commissioner/dynamic_field.rb

@@ -6,27 +6,15 @@ module SpreeCmCommissioner
     has_many :guest_dynamic_fields, class_name: 'SpreeCmCommissioner::GuestDynamicField', dependent: :destroy
     has_many :product_dynamic_fields, class_name: 'SpreeCmCommissioner::ProductDynamicField', dependent: :destroy
 
-    enum data_type: { text: 0, number: 1, boolean: 2, checkbox: 3, radio: 4, selection: 5, textarea: 6 }
+    enum data_type: { string: 0, integer: 1, boolean: 2, checkbox: 3, radio: 4 }
 
     accepts_nested_attributes_for :dynamic_field_options, allow_destroy: true, reject_if: :all_blank
 
     validates :label, presence: true
     validates :data_type, presence: true
-    validates :configurations, presence: true, allow_blank: false
 
-    def requires_dynamic_field_options?
-      checkbox? || radio? || selection?
-    end
-
-    def multiple_select
-      return nil unless selection?
-
-      configurations['multiple_select'] == true
-    end
-
-    def multiple_select=(value)
-      self.configurations ||= {}
-      self.configurations['multiple_select'] = ActiveModel::Type::Boolean.new.cast(value)
+    def selection?
+      checkbox? || radio?
     end
   end
 end

data/app/models/spree_cm_commissioner/dynamic_field_option.rb

@@ -1,12 +1,8 @@
 module SpreeCmCommissioner
   class DynamicFieldOption < SpreeCmCommissioner::Base
     belongs_to :dynamic_field, class_name: 'SpreeCmCommissioner::DynamicField', optional: false
-    has_many :guest_dynamic_fields, class_name: 'SpreeCmCommissioner::GuestDynamicField', dependent: :restrict_with_error
-
-    enum status: { active: 0, draft: 1, archived: 2 }
 
     validates :value, presence: true, uniqueness: { scope: :dynamic_field_id }
-    validates :status, presence: true
     validate :parent_field_must_be_selection_type
 
     private
@@ -14,7 +10,7 @@ module SpreeCmCommissioner
     def parent_field_must_be_selection_type
       return unless dynamic_field
 
-      return if dynamic_field.requires_dynamic_field_options?
+      return if dynamic_field.selection?
 
       errors.add(:dynamic_field, 'must be a selection type field')
     end

data/app/models/spree_cm_commissioner/guest.rb

@@ -24,10 +24,16 @@ module SpreeCmCommissioner
     scope :none_bib, -> { where(bib_prefix: [nil, '']) }
 
     belongs_to :line_item, class_name: 'Spree::LineItem'
+
     has_one :variant, class_name: 'Spree::Variant', through: :line_item
+
     belongs_to :user, class_name: 'Spree::User'
     belongs_to :occupation, class_name: 'Spree::Taxon'
     belongs_to :nationality, class_name: 'Spree::Taxon'
+    belongs_to :block, class_name: 'SpreeCmCommissioner::Block', optional: true
+
+    has_one :reserved_block, class_name: 'SpreeCmCommissioner::ReservedBlock'
+
     scope :checked_ins, -> { joins(:check_in) }
     scope :no_show, -> { left_outer_joins(:check_in).where(cm_check_ins: { id: nil }) }
 
@@ -48,10 +54,14 @@ module SpreeCmCommissioner
 
     before_create :generate_bib, if: -> { line_item.reload && variant.bib_pre_generation_on_create? }
 
+    after_create :preload_order_block_ids, if: -> { block_id.present? }
+    after_update :preload_order_block_ids, if: :saved_change_to_block_id?
+    after_destroy :preload_order_block_ids
+
     validates :seat_number, uniqueness: { scope: :event_id }, allow_nil: true, if: -> { event_id.present? }
     validates :bib_index, uniqueness: true, allow_nil: true
 
-    self.whitelisted_ransackable_associations = %w[id_card event line_item]
+    self.whitelisted_ransackable_associations = %w[id_card event]
     self.whitelisted_ransackable_attributes = %w[first_name last_name phone_number gender contact occupation_id card_type created_at check_in_status]
 
     def self.csv_importable_columns
@@ -227,6 +237,14 @@ module SpreeCmCommissioner
         filled_bib_number
       end
     end
+
+    def preload_order_block_ids
+      return if line_item.blank?
+      return if line_item.order.blank?
+
+      block_ids = line_item.order.blocks.pluck(:id)
+      line_item.order.update(preload_block_ids: block_ids)
+    end
   end
 end
 # rubocop:enable Metrics/ClassLength

data/app/models/spree_cm_commissioner/guest_dynamic_field.rb

@@ -2,11 +2,9 @@ module SpreeCmCommissioner
   class GuestDynamicField < SpreeCmCommissioner::Base
     belongs_to :guest, class_name: 'SpreeCmCommissioner::Guest', optional: false
     belongs_to :dynamic_field, class_name: 'SpreeCmCommissioner::DynamicField', optional: false
-    belongs_to :dynamic_field_option, class_name: 'SpreeCmCommissioner::DynamicFieldOption', optional: true
 
     validates :value, presence: true
     validate :validate_value_format, if: -> { value.present? && dynamic_field.present? }
-    validate :validate_option_reference, if: -> { dynamic_field_option.present? }
 
     private
 
@@ -14,30 +12,14 @@ module SpreeCmCommissioner
       return if dynamic_field.blank?
 
       case dynamic_field.data_type.to_s
-      when 'number'
+      when 'integer'
         errors.add(:value, 'must be a number') unless value.to_s.match?(/\A\d+\z/)
       when 'boolean'
-        errors.add(:value, 'must be true or false') unless %w[true false].include?(value.to_s.downcase)
-      when 'checkbox', 'radio', 'selection'
-        validate_option_value
-      end
-    end
-
-    def validate_option_value
-      if dynamic_field_option.present?
-        self.value ||= dynamic_field_option.value
-      else
+        errors.add(:value, 'must be true or false') unless %w[true false 1 0].include?(value.to_s.downcase)
+      when 'checkbox', 'radio'
         valid_options = dynamic_field.dynamic_field_options.pluck(:id).map(&:to_s)
         errors.add(:value, 'is not a valid option') unless valid_options.include?(value)
       end
     end
-
-    def validate_option_reference
-      return if dynamic_field.blank? || dynamic_field_option.blank?
-
-      return if dynamic_field_option.dynamic_field_id == dynamic_field_id
-
-      errors.add(:dynamic_field_option, 'must belong to the same dynamic field')
-    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,69 @@
+module SpreeCmCommissioner
+  class InventoryItem < Base
+    include SpreeCmCommissioner::ProductType
+
+    # Association
+    belongs_to :variant, class_name: 'Spree::Variant', optional: false
+    has_many :prices, class_name: 'Spree::Price', inverse_of: :inventory_item
+
+    # 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? }
+
+    # This method is only used when admin update stock
+    def adjust_quantity!(quantity)
+      with_lock do
+        self.max_capacity = [max_capacity + quantity, 0].max
+        self.quantity_available = [quantity_available + quantity, 0].max
+        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 redis_key
+      "inventory:#{id}"
+    end
+
+    def adjust_quantity_in_redis(quantity)
+      SpreeCmCommissioner.redis_pool.with do |redis|
+        cached_quantity_available = redis.get(redis_key)
+        # ignore if redis doesn't exist
+        return if cached_quantity_available.nil? # rubocop:disable Lint/NonLocalExitFromIterator
+
+        script = <<~LUA
+          local key = KEYS[1]
+          local increment = tonumber(ARGV[1])
+          local current = tonumber(redis.call('GET', key) or 0)
+          local new_value = current + increment
+          if new_value < 0 then
+            new_value = 0
+          end
+          redis.call('SET', key, new_value)
+          return new_value
+        LUA
+
+        redis.eval(script, keys: [redis_key], argv: [quantity])
+      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/invite_team.rb

@@ -1,7 +1,5 @@
 module SpreeCmCommissioner
   class InviteTeam < SpreeCmCommissioner::Base
-    validates :email, presence: true, uniqueness: { scope: :vendor_id, message: I18n.t('invite.already_invited') }
-
     belongs_to :user, class_name: 'Spree::User', optional: true
     belongs_to :inviter, class_name: 'Spree::User'
     belongs_to :vendor, class_name: 'Spree::Vendor'
@@ -36,7 +34,7 @@ module SpreeCmCommissioner
     end
 
     def invitation_link
-      "#{ENV.fetch('ORGANIZER_URL')}/invite_teams/#{token}?utm_source=email"
+      "http://#{ENV.fetch('APP_HOST')}/organizer/invite_teams/#{token}?utm_source=email"
     end
 
     def url_valid?

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
@@ -10,31 +10,32 @@ 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 :guests_with_blocks, -> { where.not(block_id: nil) }, class_name: 'SpreeCmCommissioner::Guest'
+      base.has_many :reserved_blocks, through: :guests, class_name: 'SpreeCmCommissioner::ReservedBlock'
       base.has_many :pending_guests, pending_guests_query, class_name: 'SpreeCmCommissioner::Guest', dependent: :destroy
       base.has_many :product_completion_steps, class_name: 'SpreeCmCommissioner::ProductCompletionStep', through: :product
-      base.has_many :line_item_seats, class_name: 'SpreeCmCommissioner::LineItemSeat', dependent: :destroy
 
       base.before_save :update_vendor_id
-      base.before_save :update_quantity, if: :transit?
-
-      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
 
       def base.json_api_columns
         json_api_columns = column_names.reject { |c| c.match(/_id$|id|preferences|(.*)password|(.*)token|(.*)api_key/) }
@@ -42,6 +43,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 +65,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
@@ -75,24 +81,39 @@ module SpreeCmCommissioner
       }
     end
 
-    def reservation?
-      date_present? && !subscription?
-    end
+    # override to calculate price per date for permanent stock
+    def update_price_from_modifier(currency, opts)
+      self.currency = currency
 
-    # date_unit could be number of nights, or days or hours depending on usecases
-    # For example:
-    # - accomodation uses number of nights.
-    # - appointment uses number of hours, etc.
-    #
-    # override
-    def amount
-      base_price = price * quantity
+      # these fields can be null during this process below.
+      # it is needed for permanent_stock?, date_range to work.
+      self.product_type = variant.product_type
+      self.from_date = opts.delete(:from_date)&.to_date
+      self.to_date = opts.delete(:to_date)&.to_date
 
-      if permanent_stock? && date_unit.present?
-        base_price * date_unit
-      else
-        base_price
-      end
+      base_price = variant.price_in(currency)
+
+      self.price = if permanent_stock?
+                     date_range.map do |date|
+                       selected_price = variant.price_for_date(date: date, currency: currency) || base_price
+                       (selected_price.amount || 0) + variant.price_modifier_amount_in(currency, opts.merge(date: date))
+                     end.sum
+                   else
+                     (base_price.amount || 0) + variant.price_modifier_amount_in(currency, opts)
+                   end
+    end
+
+    # override to calculate price per date for permanent stock
+    def update_price
+      base_price = variant.price_in(order.currency)
+      self.price = if permanent_stock?
+                     date_range.map do |date|
+                       selected_price = variant.price_for_date(date: date, currency: order.currency) || base_price
+                       selected_price.amount || 0
+                     end.sum
+                   else
+                     base_price.amount || 0
+                   end
     end
 
     def allowed_self_check_in?
@@ -179,8 +200,6 @@ module SpreeCmCommissioner
 
     # override
     def sufficient_stock?
-      return transit_sufficient_stock? if variant.product.product_type == 'transit'
-
       SpreeCmCommissioner::Stock::LineItemAvailabilityChecker.new(self).can_supply?(quantity)
     end
 
@@ -199,18 +218,6 @@ module SpreeCmCommissioner
       errors.add(:quantity, 'exceeded_max_quantity_per_order') if quantity > variant.max_quantity_per_order
     end
 
-    def transit_sufficient_stock?
-      return selected_seats_available? if reservation_trip.allow_seat_selection
-
-      seat_quantity_available?(reservation_trip)
-    end
-
-    def update_quantity
-      return if line_item_seats.blank?
-
-      self.quantity = line_item_seats.size
-    end
-
     def update_vendor_id
       self.vendor_id = variant.vendor_id
     end
@@ -233,45 +240,6 @@ module SpreeCmCommissioner
 
       from_date + variant.month.month + day.days
     end
-
-    def validate_seats_reservation
-      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)
-        errors.add(:quantity, :exceeded_available_quantity, message: 'exceeded available quantity')
-      end
-    end
-
-    def selected_seats_available?
-      selected_seat_ids = line_item_seats.map(&:seat_id)
-      !selected_seat_ids_occupied?(selected_seat_ids)
-    end
-
-    def seat_quantity_available?(trip)
-      booked_quantity = Spree::LineItem.joins(:order)
-                                       .where(variant_id: variant_id, date: date, spree_orders: { state: 'complete' })
-                                       .where.not(spree_line_items: { id: id })
-                                       .sum(:quantity)
-      remaining_quantity = trip.vehicle.number_of_seats - booked_quantity
-      remaining_quantity >= quantity
-    end
-
-    def reservation_trip
-      return @trip if defined? @trip
-
-      route = Spree::Variant.find_by(id: variant_id).product
-      @trip = route.trip
-    end
-
-    def selected_seat_ids_occupied?(selected_seat_ids)
-      # check to see if there are any selected_ids exist in the line_item_seats and belongs to completed order
-      SpreeCmCommissioner::LineItemSeat.joins(line_item: :order)
-                                       .where(seat_id: selected_seat_ids, date: date, variant_id: variant_id, spree_orders: { state: 'complete',
-                                                                                                                              canceled_at: nil
-}
-                                       )
-                                       .present?
-    end
   end
 end
 

data/app/models/spree_cm_commissioner/notification_taxon.rb

@@ -1,5 +1,5 @@
 module SpreeCmCommissioner
-  class NotificationTaxon < SpreeCmCommissioner::Base
+  class NotificationTaxon < Base
     belongs_to :customer_notification, class_name: 'SpreeCmCommissioner::CustomerNotification'
     belongs_to :taxon, class_name: 'Spree::Taxon'
   end

data/app/models/spree_cm_commissioner/option_type_decorator.rb

@@ -6,7 +6,7 @@ module SpreeCmCommissioner
       base.include SpreeCmCommissioner::ParameterizeName
       base.include SpreeCmCommissioner::OptionTypeAttrType
 
-      base.enum kind: %i[variant product vendor vehicle_type transit]
+      base.enum kind: %i[variant product vendor vehicle]
 
       base.validates :name, presence: true
 
@@ -19,16 +19,6 @@ module SpreeCmCommissioner
       base.scope :promoted, -> { where(promoted: true) }
       base.whitelisted_ransackable_attributes = %w[kind]
 
-      def base.amenities
-        Spree::OptionType.where(kind: 'vehicle_type', name: 'amenities', presentation: 'Amenities', attr_type: 'amenity').first_or_create
-      end
-
-      def base.vehicle
-        Spree::OptionType.where(presentation: 'vehicle', attr_type: 'vehicle_id', kind: 'variant',
-                                name: 'vehicle'
-        ).first_or_create
-      end
-
       def base.rules_option_type
         Spree::OptionType.find_by(name: RULES_OPTION_TYPE_NAME)
       end