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

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/saved_guest.rb

@@ -1,13 +0,0 @@
-# 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
-    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
-  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,17 +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] }
-
-    before_validation :set_trip, if: -> { trip_id.blank? }
-
-    private
-
-    def set_trip
-      self.trip = variant&.product&.trip
-    end
-  end
-end

data/app/request_schemas/spree_cm_commissioner/trip_search_request_schema.rb

@@ -1,20 +0,0 @@
-module SpreeCmCommissioner
-  class TripSearchRequestSchema < ApplicationRequestSchema
-    params do
-      required(:origin_id).value(:integer)
-      required(:destination_id).value(:integer)
-      required(:date).value(:date)
-    end
-
-    rule(:date) do
-      key.failure(:must_be_in_future) if value < Time.zone.today
-    end
-
-    rule(:origin_id, :destination_id) do
-      origin_id = values[:origin_id]
-      destination_id = values[:destination_id]
-
-      key.failure(:must_be_different) if origin_id == destination_id
-    end
-  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

data/app/serializers/spree/v2/storefront/amenity_serializer.rb

@@ -1,15 +0,0 @@
-module Spree
-  module V2
-    module Storefront
-      class AmenitySerializer < BaseSerializer
-        set_type :amenity
-        attributes :name, :presentation
-        attribute :display_icon do |option_value|
-          ActionController::Base.helpers.image_url(option_value.display_icon)
-        rescue StandardError
-          nil
-        end
-      end
-    end
-  end
-end

data/app/serializers/spree/v2/storefront/trip_query_result_serializer.rb

@@ -1,14 +0,0 @@
-module Spree
-  module V2
-    module Storefront
-      class TripQueryResultSerializer < BaseSerializer
-        set_type :trip_query_result
-
-        attributes :quantity_available, :max_capacity
-
-        attribute :direct, &:direct?
-        has_many :trips, serializer: Spree::V2::Storefront::TripResultSerializer
-      end
-    end
-  end
-end

data/app/serializers/spree/v2/storefront/trip_result_serializer.rb

@@ -1,16 +0,0 @@
-module Spree
-  module V2
-    module Storefront
-      class TripResultSerializer < BaseSerializer
-        set_type :trip_result
-
-        attributes :origin_place, :destination_place, :boarding, :drop_off, :price, :compare_at_amount, :currency, :quantity_available, :max_capacity,
-                   :allow_seat_selection, :departure_time
-        attribute :duration_in_hms, &:duration_in_hms
-        belongs_to :vendor, serializer: Spree::V2::Storefront::TripVendorSerializer
-        belongs_to :vehicle, serializer: Spree::V2::Storefront::TripVehicleSerializer
-        has_many :amenities, serializer: Spree::V2::Storefront::AmenitySerializer
-      end
-    end
-  end
-end

data/app/serializers/spree/v2/storefront/trip_vehicle_serializer.rb

@@ -1,11 +0,0 @@
-module Spree
-  module V2
-    module Storefront
-      class TripVehicleSerializer < BaseSerializer
-        set_type :vehicle
-
-        attributes :id, :code
-      end
-    end
-  end
-end

data/app/serializers/spree/v2/storefront/trip_vendor_serializer.rb

@@ -1,13 +0,0 @@
-module Spree
-  module V2
-    module Storefront
-      class TripVendorSerializer < BaseSerializer
-        set_type :vendor
-
-        attributes :name, :star_rating
-
-        has_one :logo, serializer: ::SpreeCmCommissioner::V2::Storefront::AssetSerializer
-      end
-    end
-  end
-end