spree_cm_commissioner 2.0.3.pre.pre5 → 2.0.3.pre.pre.pre7

data/app/models/spree_cm_commissioner/guest_dynamic_field.rb

@@ -4,10 +4,13 @@ module SpreeCmCommissioner
     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? }
+    validate :validate_phase_sequence
     validate :check_required_fields_based_on_phase
+    validate :reject_empty_string_for_text_fields
+
+    after_commit :sync_guest_data_fill_stage_phase
 
     private
 
@@ -15,6 +18,8 @@ module SpreeCmCommissioner
       return if dynamic_field.blank?
 
       case dynamic_field.data_type.to_s
+      when 'text', 'textarea'
+        errors.add(:value, "can't be blank") if value.is_a?(String) && value.strip == ''
       when 'number'
         errors.add(:value, 'must be a number') unless value.to_s.match?(/\A\d+\z/)
       when 'boolean'
@@ -40,44 +45,49 @@ module SpreeCmCommissioner
       errors.add(:dynamic_field_option, 'must belong to the same dynamic field')
     end
 
-    def before_checkin_phase?
-      guest.present? && guest.line_item.present? && guest.check_in.nil?
-    end
+    def validate_phase_sequence
+      return if dynamic_field.blank? || guest.blank?
 
-    def after_purchase_phase?
-      guest.present? && guest.line_item.present? && guest.line_item.completed? && guest.check_in.nil?
+      case dynamic_field.data_fill_stage.to_sym
+      when :post_registration
+        errors.add(:base, 'Must complete pre_registration fields first') unless guest.pre_registration_completed?
+      when :during_check_in
+        unless guest.post_registration_completed? || !guest.post_registration_fields?
+          errors.add(:base, 'Must complete post_registration fields first')
+        end
+      end
     end
 
-    def during_checkin_phase?
-      guest.present? && guest.check_in.present?
-    end
+    def field_required_in_current_phase?
+      return false if dynamic_field.blank? || guest.blank?
 
-    def pre_registration_required?
-      dynamic_field.data_fill_stage.to_sym == :pre_registration &&
+      case dynamic_field.data_fill_stage.to_sym
+      when :pre_registration, :post_registration
         guest.line_item.order.completed? && guest.check_in.blank?
+      when :during_check_in
+        guest.check_in.present?
+      else
+        false
+      end
     end
 
-    def post_registration_required?
-      dynamic_field.data_fill_stage.to_sym == :post_registration &&
-        guest.line_item.order.completed? && guest.check_in.blank?
+    def check_required_fields_based_on_phase
+      return if dynamic_field.blank? || value.present?
+      return unless field_required_in_current_phase?
+
+      errors.add(:value, I18n.t("guest_dynamic_field.errors.#{dynamic_field.data_fill_stage}_required"))
     end
 
-    def during_check_in_required?
-      dynamic_field.data_fill_stage.to_sym == :during_check_in &&
-        guest.check_in.present?
+    def sync_guest_data_fill_stage_phase
+      guest&.save_and_move_to_next_stage
     end
 
-    def check_required_fields_based_on_phase
-      return if dynamic_field.blank? || value.present?
+    def reject_empty_string_for_text_fields
+      return if dynamic_field.blank?
+      return unless %w[text textarea].include?(dynamic_field.data_type.to_s)
+      return unless value.is_a?(String)
 
-      case dynamic_field.data_fill_stage.to_sym
-      when :pre_registration
-        errors.add(:value, I18n.t('guest_dynamic_field.errors.pre_registration_required')) if pre_registration_required?
-      when :post_registration
-        errors.add(:value, I18n.t('guest_dynamic_field.errors.post_registration_required')) if post_registration_required?
-      when :during_check_in
-        errors.add(:value, I18n.t('guest_dynamic_field.errors.during_check_in_required')) if during_check_in_required?
-      end
+      errors.add(:value, "can't be blank") if value.strip == ''
     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,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(

data/app/models/spree_cm_commissioner/place.rb

@@ -1,5 +1,7 @@
+require_dependency 'spree_cm_commissioner'
+
 module SpreeCmCommissioner
-  class Place < Base
+  class Place < ApplicationRecord
     acts_as_nested_set
 
     validates :reference, presence: true, if: :validate_reference?
@@ -15,6 +17,7 @@ module SpreeCmCommissioner
     has_many :products, through: :product_places
 
     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, foreign_key: :stop_id
 
     has_many :taxon_places, class_name: 'SpreeCmCommissioner::TaxonPlace', dependent: :destroy
     has_many :taxons, through: :taxon_places

data/app/models/spree_cm_commissioner/product_decorator.rb

@@ -6,6 +6,7 @@ module SpreeCmCommissioner
       base.include SpreeCmCommissioner::KycBitwise
       base.include SpreeCmCommissioner::Metafield
       base.include SpreeCmCommissioner::TenantUpdatable
+      base.include SpreeCmCommissioner::RouteType
 
       base.has_many :variant_kind_option_types, -> { where(kind: :variant).order(:position) },
                     through: :product_option_types, source: :option_type
@@ -32,7 +33,6 @@ 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 :guests, through: :line_items
 
       base.has_many :product_places, class_name: 'SpreeCmCommissioner::ProductPlace', dependent: :destroy
@@ -48,6 +48,9 @@ module SpreeCmCommissioner
 
       base.belongs_to :event, class_name: 'Spree::Taxon', optional: true
 
+      base.has_many :industry_classifications, -> { joins(:taxon).where(spree_taxons: { kind: :industry }) }, class_name: 'Spree::Classification'
+      base.has_many :industry_taxons, through: :industry_classifications, source: :taxon
+
       base.scope :min_price, lambda { |vendor|
         joins(:prices_including_master)
           .where(vendor_id: vendor.id, product_type: vendor.primary_product_type)
@@ -64,16 +67,29 @@ module SpreeCmCommissioner
       base.before_validation :set_event_id
 
       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]
+      base.whitelisted_ransackable_attributes = %w[description name slug discontinue_on status vendor_id short_name route_type]
 
       base.after_update :update_variants_vendor_id, if: :saved_change_to_vendor_id?
       base.after_update :sync_event_id_to_children, if: :saved_change_to_event_id?
 
       base.enum purchasable_on: { both: 0, web: 1, app: 2 }
+      base.enum call_to_action: { buy_now: 0,
+                                  book_now: 1,
+                                  reserve: 2,
+                                  register: 3,
+                                  apply: 4,
+                                  get_ticket: 5,
+                                  secure_your_seat: 6,
+                                  join_the_event: 7,
+                                  request_to_book: 8
+                                }
+
+      base.accepts_nested_attributes_for :trip, allow_destroy: true
 
       base.multi_tenant :tenant, class_name: 'SpreeCmCommissioner::Tenant'
       base.before_save :set_tenant
@@ -83,6 +99,22 @@ module SpreeCmCommissioner
       "#{Spree::Store.default.formatted_url}/tickets/#{slug}"
     end
 
+    def action_button
+      return :request_to_book if need_confirmation?
+      return :reserve if free?
+      return call_to_action.to_sym if call_to_action.present?
+
+      :buy_now
+    end
+
+    def free?
+      return false if prices_including_master.empty?
+
+      prices_including_master.all? do |master_price|
+        master_price.price.zero? && (master_price.compare_at_price.nil? || master_price.compare_at_price.zero?)
+      end
+    end
+
     def dynamic_fields_by_collection_phase
       {
         pre_registration: dynamic_fields.pre_registration.order(:position),
@@ -133,13 +165,6 @@ module SpreeCmCommissioner
 
       errors.add(:discontinue_on, 'must be after the available on date')
     end
-
-    def product_type_unchanged
-      return if product_type_was.nil?
-      return unless product_type_changed?
-
-      errors.add(:product_type, 'cannot be changed once set')
-    end
   end
 end
 

data/app/models/spree_cm_commissioner/service_calendar.rb

@@ -1,3 +1,5 @@
+require_dependency 'spree_cm_commissioner'
+
 module SpreeCmCommissioner
   class ServiceCalendar < SpreeCmCommissioner::Base
     # exception_rules = [

data/app/models/spree_cm_commissioner/state_decorator.rb

@@ -3,6 +3,7 @@ module SpreeCmCommissioner
     def self.prepended(base)
       base.whitelisted_ransackable_attributes |= %w[name abbr country_id]
       base.has_many :vendors, foreign_key: 'default_state_id', class_name: 'Spree::Vendor', inverse_of: :default_state, dependent: :nullify
+      base.has_many :stops, class_name: 'SpreeCmCommissioner::Place'
 
       def update_total_inventory
         update(total_inventory: vendors.pluck(:total_inventory).compact.sum)

data/app/models/spree_cm_commissioner/stock/availability_checker.rb

@@ -1,48 +1,47 @@
 module SpreeCmCommissioner
   module Stock
     class AvailabilityChecker
-      attr_reader :variant, :options, :error_message
+      attr_reader :variant, :error_message
 
-      def initialize(variant, options = {})
+      def initialize(variant)
         @variant = variant
-        @options = options
         @error_message = nil
       end
 
-      def can_supply?(quantity = 1)
+      def can_supply?(quantity = 1, options = {})
         return false unless variant.available?
         return true unless variant.should_track_inventory?
         return true if variant.backorderable?
         return true if variant.need_confirmation?
 
-        variant_available?(quantity)
-      end
-
-      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 cached_inventory_items
-        return @cached_inventory_items if defined?(@cached_inventory_items)
+        # 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?
 
         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
+          permanent_stock_variant_available?(quantity, options)
         else
-          @cached_inventory_items = builder_klass.new(variant_id: variant.id).call
+          variant_available?(quantity, options)
         end
       end
 
-      def builder_klass
-        ::SpreeCmCommissioner::RedisStock::VariantCachedInventoryItemsBuilder
+      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
+      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)
       end
     end
   end

data/app/models/spree_cm_commissioner/stock/availability_validator_decorator.rb

@@ -3,8 +3,7 @@ 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)
-        ::SpreeCmCommissioner::Stock::AvailabilityChecker.new(line_item.variant, options)
-                                                         .can_supply?(quantity)
+        AvailabilityChecker.new(line_item.variant).can_supply?(quantity, options)
       end
 
       def options
         {
           from_date: line_item.from_date,
-          to_date: line_item.to_date
+          to_date: line_item.to_date,
+          except_line_item_id: line_item.id
         }
       end
     end