spree_cm_commissioner 2.0.3.pre.pre.pre7 → 2.1.0.pre.pre1

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

data/app/models/spree_cm_commissioner/order/address_book_decorator.rb

@@ -5,30 +5,48 @@
 module SpreeCmCommissioner
   module Order
     module AddressBookDecorator
-      def guest_order? = user.blank?
-
       # override
       def bill_address_attributes=(attributes)
-        attributes[:id] = bill_address&.id if attributes[:id].blank?
-        return if guest_order? && !basic_info_included?(attributes)
+        attributes[:id] = bill_address_id if attributes[:id].blank?
+        attributes[:phone] = intel_phone_number if intel_phone_number.present?
 
-        super
+        self.bill_address = assign_address_attributes(attributes)
+        user.bill_address = bill_address if user && user.bill_address.nil?
       end
 
       # override
       def ship_address_attributes=(attributes)
-        attributes[:id] = bill_address&.id if attributes[:id].blank?
-        return if guest_order? && !basic_info_included?(attributes)
+        attributes[:id] = ship_address_id if attributes[:id].blank?
+        attributes[:phone] = intel_phone_number if intel_phone_number.present?
 
-        super
+        self.ship_address = assign_address_attributes(attributes)
+        user.ship_address = ship_address if user && user.ship_address.nil?
       end
 
-      private
+      def assign_address_attributes(attributes = {})
+        return if attributes.blank?
+
+        attributes.transform_values! { |v| v == '' ? nil : v }
+        attributes = attributes.to_h.symbolize_keys
 
-      def basic_info_included?(attributes)
-        return true if attributes[:id].present?
+        existing_address = attributes[:id].present? ? find_existing_address(attributes[:id]) : nil
+
+        if existing_address&.editable?
+          existing_address.assign_attributes(attributes)
+          existing_address
+        else
+          ::Spree::Address.new(attributes.except(:id, :updated_at, :created_at))
+        end
+      end
 
-        %i[firstname lastname phone].all? { |key| attributes[key].present? }
+      def find_existing_address(id)
+        if user.present?
+          ::Spree::Address.where('(user_id = ? OR user_id IS NULL) AND deleted_at IS NULL', user.id)
+                          .find_by(id: id)
+        else
+          ::Spree::Address.where(user_id: nil, deleted_at: nil)
+                          .find_by(id: id)
+        end
       end
     end
   end

data/app/models/spree_cm_commissioner/order_decorator.rb

@@ -2,6 +2,7 @@ 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) }
@@ -42,6 +43,14 @@ 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,
+                    through: :guests,
+                    source: :saved_guest,
+                    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
@@ -49,6 +58,8 @@ module SpreeCmCommissioner
       base.whitelisted_ransackable_associations |= %w[customer taxon payments guests invoice]
       base.whitelisted_ransackable_attributes |= %w[intel_phone_number phone_number email number state]
 
+      base.accepts_nested_attributes_for :saved_guests, allow_destroy: true
+
       def base.search_by_qr_data!(data)
         token = data.match(/^R\d{9,}-([A-Za-z0-9_\-]+)$/)&.captures
 
@@ -58,6 +69,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?
 
@@ -106,7 +124,14 @@ module SpreeCmCommissioner
     end
 
     def mark_as_archive
-      update(archived_at: Time.current)
+      blocks_canceled = begin
+        cancel_blocks!
+        true
+      rescue StandardError
+        false
+      end
+
+      update(archived_at: Time.current) if blocks_canceled
     end
 
     # overrided
@@ -199,6 +224,18 @@ 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,7 +1,5 @@
-require_dependency 'spree_cm_commissioner'
-
 module SpreeCmCommissioner
-  class Place < ApplicationRecord
+  class Place < Base
     acts_as_nested_set
 
     validates :reference, presence: true, if: :validate_reference?
@@ -16,8 +14,9 @@ module SpreeCmCommissioner
     has_many :product_places, class_name: 'SpreeCmCommissioner::ProductPlace', dependent: :destroy
     has_many :products, through: :product_places
 
+    has_many :location_vendor_places, -> { where(place_type: :location) }, class_name: 'SpreeCmCommissioner::VendorPlace'
+
     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/price_decorator.rb

@@ -0,0 +1,9 @@
+module SpreeCmCommissioner
+  module PriceDecorator
+    def self.prepended(base)
+      base.belongs_to :inventory_item, class_name: 'SpreeCmCommissioner::InventoryItem', inverse_of: :prices, optional: true
+    end
+  end
+end
+
+Spree::Price.prepend(SpreeCmCommissioner::PriceDecorator) unless Spree::Price.included_modules.include?(SpreeCmCommissioner::PriceDecorator)

data/app/models/spree_cm_commissioner/product_decorator.rb

@@ -6,7 +6,6 @@ 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
@@ -33,6 +32,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 :guests, through: :line_items
 
       base.has_many :product_places, class_name: 'SpreeCmCommissioner::ProductPlace', dependent: :destroy
@@ -50,7 +50,6 @@ module SpreeCmCommissioner
 
       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)
@@ -67,12 +66,11 @@ 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 route_type]
+      base.whitelisted_ransackable_attributes = %w[description name slug discontinue_on status vendor_id short_name]
 
       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?
@@ -89,8 +87,6 @@ module SpreeCmCommissioner
                                   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
     end
@@ -117,9 +113,9 @@ module SpreeCmCommissioner
 
     def dynamic_fields_by_collection_phase
       {
-        pre_registration: dynamic_fields.pre_registration.order(:position),
-        post_registration: dynamic_fields.post_registration.order(:position),
-        during_check_in: dynamic_fields.during_check_in.order(:position)
+        pre_registration: dynamic_fields.pre_registration.includes(:dynamic_field_options).order(:position),
+        post_registration: dynamic_fields.post_registration.includes(:dynamic_field_options).order(:position),
+        during_check_in: dynamic_fields.during_check_in.includes(:dynamic_field_options).order(:position)
       }
     end
 
@@ -165,6 +161,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
 

data/app/models/spree_cm_commissioner/redis_stock/cached_inventory_items_builder.rb

@@ -0,0 +1,41 @@
+module SpreeCmCommissioner
+  module RedisStock
+    class CachedInventoryItemsBuilder
+      attr_reader :inventory_items
+
+      def initialize(inventory_items)
+        @inventory_items = inventory_items
+      end
+
+      # output: [ CachedInventoryItem(...), CachedInventoryItem(...) ]
+      def call
+        keys = inventory_items.map { |item| "inventory:#{item.id}" }
+        return [] unless keys.any?
+
+        counts = SpreeCmCommissioner.redis_pool.with { |redis| redis.mget(*keys) }
+        inventory_items.map.with_index do |inventory_item, i|
+          ::SpreeCmCommissioner::CachedInventoryItem.new(
+            inventory_key: keys[i],
+            active: inventory_item.active?,
+            quantity_available: cache_inventory(keys[i], inventory_item, counts[i]),
+            inventory_item_id: inventory_item.id,
+            variant_id: inventory_item.variant_id
+          )
+        end
+      end
+
+      private
+
+      def cache_inventory(key, inventory_item, count_in_redis)
+        return count_in_redis.to_i if count_in_redis.present?
+        return inventory_item.quantity_available unless inventory_item.active?
+
+        SpreeCmCommissioner.redis_pool.with do |redis|
+          redis.set(key, inventory_item.quantity_available, ex: inventory_item.redis_expired_in)
+        end
+
+        inventory_item.quantity_available
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/redis_stock/inventory_updater.rb

@@ -0,0 +1,126 @@
+module SpreeCmCommissioner
+  module RedisStock
+    class InventoryUpdater
+      class UnableToRestock < StandardError; end
+      class UnableToUnstock < StandardError; end
+
+      def initialize(line_item_ids)
+        @line_item_ids = line_item_ids
+      end
+
+      def unstock!
+        keys, quantities, inventory_ids = extract_inventory_data
+
+        raise UnableToUnstock, Spree.t(:insufficient_stock_lines_present) unless unstock(keys, quantities)
+
+        inventory_id_and_quantities = inventory_ids.map.with_index do |inventory_id, i|
+          { inventory_id: inventory_id, quantity: -quantities[i] }
+        end
+
+        schedule_sync_inventory(inventory_id_and_quantities)
+      end
+
+      def restock!
+        keys, quantities, inventory_ids = extract_inventory_data
+
+        raise UnableToRestock unless restock(keys, quantities)
+
+        inventory_id_and_quantities = inventory_ids.map.with_index do |inventory_id, i|
+          { inventory_id: inventory_id, quantity: quantities[i] }
+        end
+
+        schedule_sync_inventory(inventory_id_and_quantities)
+      end
+
+      private
+
+      # only unstock or restock when variants is available, track inventory, not backorderable & not need_confirmation.
+      # otherwise, we can ignore them.
+      def line_items
+        return @line_items if defined?(@line_items)
+
+        @line_items = Spree::LineItem.where(id: @line_item_ids).includes(variant: :stock_items)
+        @line_items = @line_items.map do |line_item|
+          next unless line_item.variant.available?
+          next unless line_item.variant.should_track_inventory?
+          next if line_item.variant.backorderable?
+          next if line_item.variant.need_confirmation?
+
+          line_item
+        end.compact
+      end
+
+      def unstock(keys, quantities)
+        SpreeCmCommissioner.redis_pool.with do |redis|
+          redis.eval(unstock_redis_script, keys: keys, argv: quantities)
+        end.positive?
+      end
+
+      def restock(keys, quantities)
+        SpreeCmCommissioner.redis_pool.with do |redis|
+          redis.eval(restock_redis_script, keys: keys, argv: quantities)
+        end.positive?
+      end
+
+      # Return: [CachedInventoryItem(...), CachedInventoryItem(...)]
+      def cached_inventory_items
+        @cached_inventory_items ||= SpreeCmCommissioner::RedisStock::LineItemsCachedInventoryItemsBuilder.new(line_item_ids: line_items.pluck(:id))
+                                                                                                         .call.values.flatten
+      end
+
+      def extract_inventory_data
+        keys = []
+        quantities = []
+        inventory_ids = []
+
+        cached_inventory_items.each do |cached_inventory_item|
+          keys << cached_inventory_item.inventory_key
+          quantities << line_items.find { |item| item.variant_id == cached_inventory_item.variant_id }.quantity
+          inventory_ids << cached_inventory_item.inventory_item_id
+        end
+
+        [keys, quantities, inventory_ids]
+      end
+
+      def unstock_redis_script
+        <<~LUA
+          local keys = KEYS
+          local quantities = ARGV
+
+          -- Check availability first
+          for i, key in ipairs(keys) do
+            local current = tonumber(redis.call('GET', key) or 0)
+            if current - tonumber(quantities[i]) < 0 then
+              return 0
+            end
+          end
+
+          -- Apply updates
+          for i, key in ipairs(keys) do
+            redis.call('DECRBY', key, tonumber(quantities[i]))
+          end
+
+          return 1
+        LUA
+      end
+
+      def restock_redis_script
+        <<~LUA
+          local keys = KEYS
+          local quantities = ARGV
+
+          -- Apply restock updates
+          for i, key in ipairs(keys) do
+            redis.call('INCRBY', key, tonumber(quantities[i]))
+          end
+
+          return 1
+        LUA
+      end
+
+      def schedule_sync_inventory(inventory_id_and_quantities)
+        SpreeCmCommissioner::InventoryItemSyncerJob.perform_later(inventory_id_and_quantities:)
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/redis_stock/line_items_cached_inventory_items_builder.rb

@@ -0,0 +1,36 @@
+module SpreeCmCommissioner
+  module RedisStock
+    class LineItemsCachedInventoryItemsBuilder
+      attr_reader :line_item_ids
+
+      def initialize(line_item_ids:)
+        @line_item_ids = line_item_ids
+      end
+
+      # return list of inventory items group by :line_item_id:
+      # {
+      #   1: [ CachedInventoryItem(...), CachedInventoryItem(...) ],
+      #   2: [ CachedInventoryItem(...), CachedInventoryItem(...) ],
+      # }
+      def call
+        cached_inventory_items.group_by do |cached_inventory_item|
+          line_item = line_items.find { |item| item.variant_id == cached_inventory_item.variant_id }
+          line_item.id
+        end
+      end
+
+      def cached_inventory_items
+        @cached_inventory_items ||= SpreeCmCommissioner::RedisStock::CachedInventoryItemsBuilder.new(inventory_items)
+                                                                                                .call
+      end
+
+      def inventory_items
+        @inventory_items ||= line_items.flat_map(&:inventory_items)
+      end
+
+      def line_items
+        @line_items ||= Spree::LineItem.where(id: line_item_ids).includes(:inventory_items)
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/redis_stock/variant_cached_inventory_items_builder.rb

@@ -0,0 +1,25 @@
+module SpreeCmCommissioner
+  module RedisStock
+    class VariantCachedInventoryItemsBuilder
+      attr_reader :variant_id, :dates
+
+      def initialize(variant_id:, dates: [])
+        @variant_id = variant_id
+        @dates = dates
+      end
+
+      # output: [ CachedInventoryItem(...), CachedInventoryItem(...) ]
+      def call
+        ::SpreeCmCommissioner::RedisStock::CachedInventoryItemsBuilder.new(inventory_items).call
+      end
+
+      def inventory_items
+        variant = Spree::Variant.find(variant_id)
+
+        inventory_items = variant.inventory_items
+        inventory_items = inventory_items.where(inventory_date: dates) if variant.permanent_stock?
+        inventory_items
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/reserved_block.rb

@@ -0,0 +1,31 @@
+module SpreeCmCommissioner
+  class ReservedBlock < Base
+    has_paper_trail
+
+    belongs_to :updated_by, optional: true, class_name: 'Spree::User'
+    belongs_to :guest, optional: true, class_name: 'SpreeCmCommissioner::Guest'
+    belongs_to :inventory_item, class_name: 'SpreeCmCommissioner::InventoryItem'
+    belongs_to :block, class_name: 'SpreeCmCommissioner::Block'
+
+    enum status: {
+      reserved: 0, # confirmed reservation
+      on_hold: 1, # temporary hold
+      canceled: 2
+    }
+
+    validates :status, presence: true
+    validates :expired_at, presence: true, if: -> { on_hold? }
+
+    scope :reserved_or_on_hold, -> { where(status: %i[reserved on_hold]).where('expired_at IS NULL OR expired_at > ?', Time.current) }
+    scope :active_on_hold, -> { on_hold.where('expired_at IS NULL OR expired_at > ?', Time.current) }
+    scope :active, -> { where('expired_at IS NULL OR expired_at > ?', Time.current) }
+
+    def expired?
+      expired_at.present? && expired_at <= Time.current
+    end
+
+    def active_on_hold?
+      on_hold? && !expired?
+    end
+  end
+end

data/app/models/spree_cm_commissioner/saved_guest.rb

@@ -0,0 +1,21 @@
+# Reusable guest profile, can be linked to a user or be nil for anonymous checkouts.
+# Orders associate to saved_guest through guests. If an order later associates to a user, the saved_guest is assigned to that user.
+module SpreeCmCommissioner
+  class SavedGuest < Base
+    include SpreeCmCommissioner::PhoneNumberSanitizer
+
+    enum gender: { :other => 0, :male => 1, :female => 2 }
+
+    belongs_to :user, class_name: 'Spree::User', optional: true
+    belongs_to :occupation, class_name: 'Spree::Taxon', optional: true
+    belongs_to :nationality, class_name: 'Spree::Taxon', optional: true
+
+    has_many :guests, class_name: 'SpreeCmCommissioner::Guest', dependent: :nullify
+
+    accepts_nested_attributes_for :guests, allow_destroy: true
+
+    def full_name
+      [first_name, last_name].compact_blank.join(' ')
+    end
+  end
+end

data/app/models/spree_cm_commissioner/seat_layout.rb

@@ -0,0 +1,20 @@
+module SpreeCmCommissioner
+  class SeatLayout < Base
+    has_many :seat_sections, class_name: 'SpreeCmCommissioner::SeatSection', dependent: :destroy
+
+    has_many :top_level_blocks, -> { where(seat_section_id: nil) }, class_name: 'SpreeCmCommissioner::Block', dependent: :destroy
+    has_many :section_blocks, -> { where.not(seat_section_id: nil) }, class_name: 'SpreeCmCommissioner::Block'
+
+    belongs_to :layoutable, polymorphic: true
+
+    enum status: {
+      inactive: 0,
+      active: 1,
+      archived: 2
+    }
+
+    validates :name, presence: true
+
+    accepts_nested_attributes_for :seat_sections, :top_level_blocks
+  end
+end

data/app/models/spree_cm_commissioner/seat_section.rb

@@ -0,0 +1,16 @@
+module SpreeCmCommissioner
+  class SeatSection < Base
+    belongs_to :seat_layout, class_name: 'SpreeCmCommissioner::SeatLayout', optional: false
+
+    has_many :blocks, class_name: 'SpreeCmCommissioner::Block', dependent: :destroy
+
+    validates :name, presence: true
+    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 }
+
+    accepts_nested_attributes_for :blocks
+  end
+end

data/app/models/spree_cm_commissioner/seats/blocks_canceler.rb

@@ -0,0 +1,30 @@
+module SpreeCmCommissioner
+  module Seats
+    class BlocksCanceler
+      def initialize(order_id:, cancel_by: nil)
+        @order_id = order_id
+        @cancel_by = cancel_by
+      end
+
+      # Cancels all reserved blocks associated with a given order.
+      #
+      # Typically used when:
+      # - The order is canceled.
+      # - The user abandons the order before completing checkout.
+      def cancel_blocks!
+        order = Spree::Order.find(@order_id)
+
+        ActiveRecord::Base.transaction do
+          order.reserved_blocks.each do |reserved_block|
+            reserved_block.assign_attributes(
+              status: :canceled,
+              expired_at: nil,
+              updated_by: @cancel_by
+            )
+            raise Errors::UnableToSaveReservedBlockRecord unless reserved_block.save
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/seats/blocks_holder.rb

@@ -0,0 +1,53 @@
+module SpreeCmCommissioner
+  module Seats
+    class BlocksHolder
+      HOLD_DURATION = 8.minutes
+
+      def initialize(line_item_ids:, hold_by: nil)
+        @line_item_ids = line_item_ids
+        @hold_by = hold_by
+      end
+
+      # Hold blocks for the given line items, preventing dublicate block selection.
+      #
+      # It ensures:
+      # - Raises an error if already reserved.
+      # - Raises an error if currently on_hold by someone else.
+      # - Allows re-locking if already on_hold by the same guest.
+      # - Otherwise, proceeds to lock the given blocks.
+      def hold_blocks!
+        line_items = Spree::LineItem.where(id: @line_item_ids).includes(:inventory_items, guests_with_blocks: :block)
+        guests_with_blocks = line_items.flat_map(&:guests_with_blocks).compact
+        inventory_items = line_items.flat_map(&:inventory_items).compact
+
+        ActiveRecord::Base.transaction do
+          guests_with_blocks.each do |guest|
+            inventory_items.each do |inventory_item|
+              hold_specific_block!(inventory_item, guest)
+            end
+          end
+        end
+      end
+
+      private
+
+      def hold_specific_block!(inventory_item, guest)
+        reserved_block = SpreeCmCommissioner::ReservedBlock.find_or_initialize_by(inventory_item: inventory_item, block: guest.block)
+
+        raise Errors::BlocksAreReservedByOtherGuest if reserved_block.reserved? && reserved_block.guest_id != guest.id
+        raise Errors::BlocksAreReservedBySameGuest if reserved_block.reserved? && reserved_block.guest_id == guest.id
+        raise Errors::BlocksAreOnHoldByOtherGuest if reserved_block.active_on_hold? && reserved_block.guest_id != guest.id
+
+        reserved_block.assign_attributes(
+          status: :on_hold,
+          guest: guest,
+          expired_at: HOLD_DURATION.from_now,
+          inventory_date: inventory_item.inventory_date,
+          updated_by: @hold_by
+        )
+
+        raise Errors::UnableToSaveReservedBlockRecord unless reserved_block.save
+      end
+    end
+  end
+end