spree_cm_commissioner 2.0.2.pre.pre → 2.0.3.pre.pre1

data/app/models/spree_cm_commissioner/block.rb

@@ -1,39 +0,0 @@
-module SpreeCmCommissioner
-  class Block < Base
-    enum block_type: {
-      seat: 1,
-      sleeping_seat: 2,
-      driver: 3,
-      bathroom: 4,
-      other: 0
-    }
-
-    belongs_to :seat_section, class_name: 'SpreeCmCommissioner::SeatSection', optional: true
-    belongs_to :seat_layout, class_name: 'SpreeCmCommissioner::SeatLayout', optional: false
-
-    validates :label, presence: true, if: -> { seatable? && other? }
-
-    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 self.seatable?(block_type)
-      block_type.in?(%w[sleeping_seat seat])
-    end
-
-    def seatable?
-      self.class.seatable?(block_type)
-    end
-
-    def assign_layout_from_section
-      self.seat_layout = seat_section.seat_layout
-    end
-  end
-end

data/app/models/spree_cm_commissioner/inventory.rb

@@ -1,11 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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/price_decorator.rb

@@ -1,9 +0,0 @@
-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/redis_stock/cached_inventory_items_builder.rb

@@ -1,41 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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 :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/seat_layout.rb

@@ -1,20 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

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

@@ -1,49 +0,0 @@
-module SpreeCmCommissioner
-  module Seats
-    class BlocksReserver
-      def initialize(line_item_ids:, reserve_by: nil)
-        @line_item_ids = line_item_ids
-        @reserve_by = reserve_by
-      end
-
-      # Mark blocks as reserved for the given line items.
-      #
-      # It ensures:
-      # - Raises an error if already reserved by same guest or other guest.
-      # - Raises an error if currently on_hold by someone else.
-      # - Otherwise, proceeds to reserve the given blocks.
-      def reserve_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|
-              reserve_specific_block!(inventory_item, guest)
-            end
-          end
-        end
-      end
-
-      def reserve_specific_block!(inventory_item, guest)
-        reserved_block = SpreeCmCommissioner::ReservedBlock.find_or_initialize_by(inventory_item_id: inventory_item.id, block_id: guest.block_id)
-
-        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
-
-        # mark the block as reserved if not on_hold or lock by anyone but already expired
-        reserved_block.assign_attributes(
-          guest: guest,
-          status: :reserved,
-          expired_at: nil,
-          inventory_date: inventory_item.inventory_date,
-          updated_by: @reserve_by
-        )
-
-        raise Errors::UnableToSaveReservedBlockRecord unless reserved_block.save
-      end
-    end
-  end
-end

data/app/models/spree_cm_commissioner/seats/errors/blocks_are_on_hold_by_other_guest.rb

@@ -1,4 +0,0 @@
-module SpreeCmCommissioner
-  class Seats::Errors::BlocksAreOnHoldByOtherGuest < StandardError
-  end
-end

data/app/models/spree_cm_commissioner/seats/errors/blocks_are_reserved_by_other_guest.rb

@@ -1,4 +0,0 @@
-module SpreeCmCommissioner
-  class Seats::Errors::BlocksAreReservedByOtherGuest < StandardError
-  end
-end

data/app/models/spree_cm_commissioner/seats/errors/blocks_are_reserved_by_same_guest.rb

@@ -1,4 +0,0 @@
-module SpreeCmCommissioner
-  class Seats::Errors::BlocksAreReservedBySameGuest < StandardError
-  end
-end

data/app/models/spree_cm_commissioner/seats/errors/unable_to_save_reserved_block_record.rb

@@ -1,4 +0,0 @@
-module SpreeCmCommissioner
-  class Seats::Errors::UnableToSaveReservedBlockRecord < StandardError
-  end
-end

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

@@ -1,44 +0,0 @@
-# On top of SpreeCmCommissioner::Stock::AvailabilityChecker, this class does the same thing but in bulk check with redis.
-# Which mean, it check basic condition with db first, once pass, it check with redis.
-module SpreeCmCommissioner
-  module Stock
-    class OrderAvailabilityChecker
-      attr_reader :order
-
-      def initialize(order)
-        @order = order
-      end
-
-      def can_supply_all?
-        insufficient_stock_lines.empty?
-      end
-
-      def insufficient_stock_lines
-        cached_inventory_items_group_by_line_item_id.map do |line_item_id, cached_inventory_items|
-          line_item = order.line_items.find { |item| item.id == line_item_id }
-          line_item unless sufficient_stock_for?(line_item, cached_inventory_items)
-        end.compact
-      end
-
-      # {
-      #   1: [ {inventory_key: "inventory:1", active: true, quantity_available: 5, inventory_item_id: 1, variant_id: 1}],
-      #   2: [ {inventory_key: "inventory:2", active: true, quantity_available: 5, inventory_item_id: 2, variant_id: 2}],
-      # }
-      def cached_inventory_items_group_by_line_item_id
-        @cached_inventory_items_group_by_line_item_id ||=
-          ::SpreeCmCommissioner::RedisStock::LineItemsCachedInventoryItemsBuilder.new(
-            line_item_ids: order.line_items.pluck(:id)
-          ).call
-      end
-
-      def sufficient_stock_for?(line_item, cached_inventory_items)
-        return false unless line_item.variant.available?
-        return true unless line_item.variant.should_track_inventory?
-        return true if line_item.variant.backorderable?
-        return true if line_item.variant.need_confirmation?
-
-        cached_inventory_items.all? { |item| item.active? && item.quantity_available >= line_item.quantity }
-      end
-    end
-  end
-end

data/app/models/spree_cm_commissioner/variant_block.rb

@@ -1,9 +0,0 @@
-module SpreeCmCommissioner
-  class VariantBlock < Base
-    belongs_to :variant, class_name: 'Spree::Variant', optional: false
-    belongs_to :trip, class_name: 'SpreeCmCommissioner::Trip', optional: false
-    belongs_to :block, class_name: 'SpreeCmCommissioner::Block', optional: false
-
-    validates :block_id, uniqueness: { scope: %i[variant_id trip_id] }
-  end
-end

data/app/request_schemas/spree_cm_commissioner/variant_request_schema.rb

@@ -1,19 +0,0 @@
-module SpreeCmCommissioner
-  class VariantRequestSchema < ApplicationRequestSchema
-    params do
-      required(:from_date).value(:date)
-      required(:to_date).value(:date)
-      required(:adult).value(:integer)
-      required(:children).value(:integer)
-    end
-
-    rule(:from_date, :to_date) do
-      from_date = values[:from_date]
-      to_date   = values[:to_date]
-
-      key.failure(:must_be_in_future) if from_date < Time.zone.today
-      key.failure(:must_be_later_than_start_date) if from_date > to_date
-      key.failure(:stay_is_too_long) if (to_date - from_date).to_i > ENV.fetch('ACCOMMODATION_MAX_STAY_DAYS', 10).to_i
-    end
-  end
-end