spree_cm_commissioner 2.0.3.pre.pre5 → 2.0.3

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

@@ -1,21 +1,13 @@
-# Number of guests are depend on the variant, but user is allowed to input custom number of guests
-# which will be stored in public_metadata.
-#
-# metadata {
-#   'number_of_adults': 2,
-#   'number_of_kids': 1,
-# }
 module SpreeCmCommissioner
   module LineItemGuestsConcern
     extend ActiveSupport::Concern
 
     included do
-      validate :validate_total_adults, if: -> { valid_integer_metadata?('number_of_adults') }
-      validate :validate_total_kids, if: -> { valid_integer_metadata?('number_of_kids') }
+      validate :validate_total_adults, if: -> { public_metadata[:number_of_adults].present? }
+      validate :validate_total_kids, if: -> { public_metadata[:number_of_kids].present? }
     end
 
-    def number_of_adults = public_metadata['number_of_adults']&.to_i || (variant.number_of_adults * quantity)
-    def number_of_kids = public_metadata['number_of_kids']&.to_i || (variant.number_of_kids * quantity)
+    def remaining_total_guests = [number_of_guests - guests.size, 0].max
     def number_of_guests = number_of_adults + number_of_kids
 
     def allowed_extra_adults = variant.allowed_extra_adults * quantity
@@ -24,7 +16,8 @@ module SpreeCmCommissioner
     def allowed_total_adults = (variant.number_of_adults * quantity) + allowed_extra_adults
     def allowed_total_kids = (variant.number_of_kids * quantity) + allowed_extra_kids
 
-    def remaining_total_guests = [number_of_guests - guests.size, 0].max
+    def number_of_adults = public_metadata[:number_of_adults] || (variant.number_of_adults * quantity)
+    def number_of_kids = public_metadata[:number_of_kids] || (variant.number_of_kids * quantity)
 
     def generate_remaining_guests
       return if remaining_total_guests.zero?
@@ -35,17 +28,15 @@ module SpreeCmCommissioner
     end
 
     def extra_adults
-      return 0 unless valid_integer_metadata?('number_of_adults')
       return 0 unless extra_adults?
 
-      public_metadata['number_of_adults'].to_i - (variant.number_of_adults * quantity)
+      public_metadata[:number_of_adults] - (variant.number_of_adults * quantity)
     end
 
     def extra_kids
-      return 0 unless valid_integer_metadata?('number_of_kids')
       return 0 unless extra_kids?
 
-      public_metadata['number_of_kids'].to_i - (variant.number_of_kids * quantity)
+      public_metadata[:number_of_kids] - (variant.number_of_kids * quantity)
     end
 
     def guest_options
@@ -64,30 +55,25 @@ module SpreeCmCommissioner
     end
 
     def extra_adults?
-      return false unless valid_integer_metadata?('number_of_adults')
-
-      public_metadata['number_of_adults'].to_i > variant.number_of_adults * quantity
+      public_metadata[:number_of_adults].present? && public_metadata[:number_of_adults] > variant.number_of_adults * quantity
     end
 
     def extra_kids?
-      return false unless valid_integer_metadata?('number_of_kids')
-
-      public_metadata['number_of_kids'].to_i > variant.number_of_kids * quantity
+      public_metadata[:number_of_kids].present? && public_metadata[:number_of_kids] > variant.number_of_kids * quantity
     end
 
     private
 
-    def valid_integer_metadata?(key)
-      value = public_metadata[key.to_s]
-      value.present? && value.to_s.match?(/\A-?\d+\z/)
-    end
-
     def validate_total_adults
-      errors.add(:quantity, 'exceed_total_adults') if public_metadata['number_of_adults'].to_i > allowed_total_adults
+      return if public_metadata[:number_of_adults] <= allowed_total_adults
+
+      errors.add(:quantity, 'exceed_total_adults')
     end
 
     def validate_total_kids
-      errors.add(:quantity, 'exceed_total_kids') if public_metadata['number_of_kids'].to_i > allowed_total_kids
+      return if public_metadata[:number_of_kids] <= allowed_total_kids
+
+      errors.add(:quantity, 'exceed_total_kids')
     end
   end
 end

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

@@ -14,6 +14,13 @@ module SpreeCmCommissioner
       state_selection
       payment_option
       delivery_option
+      amenity
+      departure_time
+      duration
+      vehicle_id
+      origin
+      destination
+      place_id
     ].freeze
 
     RESERVED_OPTIONS = {
@@ -41,8 +48,11 @@ module SpreeCmCommissioner
       'bib-display-prefix' => 'boolean',
       'bib-pre-generation-on-create' => 'boolean',
       'seat-number-positions' => 'array',
-      'seat-type' => 'string',
-      'intercity-taxi' => 'string'
+      'origin' => 'place_id',
+      'destination' => 'place_id',
+      'departure-time' => 'time',
+      'vehicle' => 'vehicle_id',
+      'allow-seat-selection' => 'boolean'
     }.freeze
 
     included do

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

@@ -5,8 +5,6 @@ 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
 
@@ -16,14 +14,10 @@ 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') }
 
@@ -73,39 +67,6 @@ 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,10 +3,12 @@ module SpreeCmCommissioner
     extend ActiveSupport::Concern
 
     included do
-      delegate :subscribable?,
+      delegate :product_type,
+               :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,20 +6,10 @@ 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/route_type.rb

@@ -2,7 +2,7 @@ module SpreeCmCommissioner
   module RouteType
     extend ActiveSupport::Concern
 
-    ROUTE_TYPES = %i[bus intercity_taxi airport_shuttle rails ferry].freeze
+    ROUTE_TYPES = %i[automobile subway rails ferry].freeze
 
     included do
       enum route_type: ROUTE_TYPES if table_exists? && column_names.include?('route_type')

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 }
+      enum kind: { category: 0, cms: 1, event: 2, occupation: 3, nationality: 4, organization: 5, transit: 6 }
     end
   end
 end

data/app/models/spree_cm_commissioner/address_decorator.rb

@@ -1,30 +1,10 @@
 module SpreeCmCommissioner
   module AddressDecorator
     def self.prepended(base)
+      # Field is not mandatory
       base.enum gender: { :not_selected => 0, :male => 1, :female => 2, :other => 3 }
-
-      base.validates :address1, presence: true, if: :require_address1?
-      base.validates :city, presence: true, if: :require_city?
-      base.validates :country, presence: true, if: :require_country?
-    end
-
-    def require_address1?
-      false
-    end
-
-    def require_city?
-      false
-    end
-
-    def require_country?
-      false
     end
   end
 end
 
-unless Spree::Address.included_modules.include?(SpreeCmCommissioner::AddressDecorator)
-  # remove validators for the specified attributes
-  %i[address1 city country].each { |attr| Spree::Address._validators.delete(attr) }
-
-  Spree::Address.prepend(SpreeCmCommissioner::AddressDecorator)
-end
+Spree::Address.prepend(SpreeCmCommissioner::AddressDecorator) unless Spree::Address.included_modules.include?(SpreeCmCommissioner::AddressDecorator)

data/app/models/spree_cm_commissioner/branch.rb

@@ -0,0 +1,12 @@
+require_dependency 'spree_cm_commissioner'
+
+module SpreeCmCommissioner
+  class Branch < SpreeCmCommissioner::Place
+    belongs_to :state,  class_name: 'Spree::State', optional: true
+    belongs_to :vendor, class_name: 'Spree::Vendor'
+
+    def validate_reference?
+      false
+    end
+  end
+end

data/app/models/spree_cm_commissioner/guest.rb

@@ -24,17 +24,10 @@ 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
-    belongs_to :saved_guest, class_name: 'SpreeCmCommissioner::SavedGuest', 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 }) }
 
@@ -55,15 +48,9 @@ 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
 
-    validate :validate_block, if: :should_validate_block?
-
     self.whitelisted_ransackable_associations = %w[id_card event line_item]
     self.whitelisted_ransackable_attributes = %w[first_name last_name phone_number gender contact occupation_id card_type created_at check_in_status]
 
@@ -296,28 +283,6 @@ module SpreeCmCommissioner
         filled_bib_number
       end
     end
-
-    # validate only if block_id is present AND (new record OR block_id is changing)
-    # goal: don't bother re-validating when block_id stays the same
-    def should_validate_block?
-      block_id.present? && (new_record? || will_save_change_to_block_id?)
-    end
-
-    def validate_block
-      return if block_id.blank?
-      return if line_item.blank? || line_item.variant.blank?
-      return if line_item.variant.variant_blocks.exists?(block_id: block_id)
-
-      errors.add(:block, "does not exist in variant #{line_item.variant_id}")
-    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/line_item_decorator.rb

@@ -1,6 +1,6 @@
 module SpreeCmCommissioner
   module LineItemDecorator
-    def self.prepended(base) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+    def self.prepended(base) # rubocop:disable Metrics/MethodLength
       include_modules(base)
 
       base.belongs_to :accepter, class_name: 'Spree::User', optional: true
@@ -10,32 +10,31 @@ 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?, :high_demand,
+      base.delegate :delivery_required?, :permanent_stock?, :high_demand, :transit?,
                     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/) }
@@ -43,10 +42,6 @@ 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
 
@@ -65,8 +60,6 @@ module SpreeCmCommissioner
       base.include SpreeCmCommissioner::LineItemDurationable
       base.include SpreeCmCommissioner::LineItemsFilterScope
       base.include SpreeCmCommissioner::LineItemGuestsConcern
-      base.include SpreeCmCommissioner::LineItemTransitable
-      base.include SpreeCmCommissioner::ProductType
       base.include SpreeCmCommissioner::ProductDelegation
       base.include SpreeCmCommissioner::KycBitwise
     end
@@ -82,39 +75,24 @@ module SpreeCmCommissioner
       }
     end
 
-    # override to calculate price per date for permanent stock
-    def update_price_from_modifier(currency, opts)
-      self.currency = currency
-
-      # 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_datetime
-      self.to_date = opts.delete(:to_date)&.to_datetime
-
-      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
+    def reservation?
+      date_present? && !subscription?
     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
+    # 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
+
+      if permanent_stock? && date_unit.present?
+        base_price * date_unit
+      else
+        base_price
+      end
     end
 
     def allowed_self_check_in?
@@ -201,6 +179,8 @@ 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
 
@@ -219,6 +199,18 @@ 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
@@ -241,6 +233,45 @@ 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/line_item_seat.rb

@@ -0,0 +1,10 @@
+require_dependency 'spree_cm_commissioner'
+module SpreeCmCommissioner
+  class LineItemSeat < SpreeCmCommissioner::Base
+    belongs_to :line_item, class_name: 'Spree::LineItem'
+    belongs_to :seat, class_name: 'SpreeCmCommissioner::VehicleSeat'
+    belongs_to :variant, class_name: 'Spree::Variant'
+
+    validates :date, presence: true
+  end
+end

data/app/models/spree_cm_commissioner/notification_taxon.rb

@@ -1,5 +1,5 @@
 module SpreeCmCommissioner
-  class NotificationTaxon < Base
+  class NotificationTaxon < SpreeCmCommissioner::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]
+      base.enum kind: %i[variant product vendor vehicle_type transit]
 
       base.validates :name, presence: true
 
@@ -19,6 +19,16 @@ 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

data/app/models/spree_cm_commissioner/option_value_vehicle_type.rb

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

data/app/models/spree_cm_commissioner/order_decorator.rb

@@ -2,7 +2,6 @@ module SpreeCmCommissioner
   module OrderDecorator
     def self.prepended(base) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
       base.include SpreeCmCommissioner::PhoneNumberSanitizer
-      base.include SpreeCmCommissioner::OrderSeatable
       base.include SpreeCmCommissioner::OrderStateMachine
 
       base.scope :subscription, -> { where.not(subscription_id: nil) }
@@ -43,9 +42,6 @@ module SpreeCmCommissioner
       base.has_many :vendors, through: :products, class_name: 'Spree::Vendor'
       base.has_many :taxons, through: :products, class_name: 'Spree::Taxon'
       base.has_many :guests, through: :line_items, class_name: 'SpreeCmCommissioner::Guest'
-      base.has_many :saved_guests, -> { distinct }, through: :guests, class_name: 'SpreeCmCommissioner::SavedGuest'
-      base.has_many :blocks, through: :guests, class_name: 'SpreeCmCommissioner::Block', source: :block
-      base.has_many :reserved_blocks, through: :guests, class_name: 'SpreeCmCommissioner::ReservedBlock'
       base.has_many :guest_card_classes, class_name: 'SpreeCmCommissioner::GuestCardClass', through: :variants
 
       base.delegate :customer, to: :user, allow_nil: true
@@ -62,13 +58,6 @@ 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?
 
@@ -117,14 +106,7 @@ module SpreeCmCommissioner
     end
 
     def mark_as_archive
-      blocks_canceled = begin
-        cancel_blocks!
-        true
-      rescue StandardError
-        false
-      end
-
-      update(archived_at: Time.current) if blocks_canceled
+      update(archived_at: Time.current)
     end
 
     # overrided
@@ -217,18 +199,6 @@ module SpreeCmCommissioner
 
     private
 
-    def unstock_inventory_in_redis!
-      CmAppLogger.log(label: "#{self.class.name}#unstock_inventory_in_redis!", data: { order_id: id }) do
-        SpreeCmCommissioner::RedisStock::InventoryUpdater.new(line_item_ids).unstock!
-      end
-    end
-
-    def restock_inventory_in_redis!
-      CmAppLogger.log(label: "#{self.class.name}#restock_inventory_in_redis!", data: { order_id: id }) do
-        SpreeCmCommissioner::RedisStock::InventoryUpdater.new(line_item_ids).restock!
-      end
-    end
-
     # override :spree_api
     def webhook_payload_body
       resource_serializer.new(