spree_cm_commissioner 2.0.1.pre.pre → 2.0.1.pre.pre1

data/app/finders/spree_cm_commissioner/accommodations/find.rb

@@ -1,37 +0,0 @@
-module SpreeCmCommissioner
-  module Accommodations
-    class Find
-      attr_reader :from_date, :to_date, :state_id, :number_of_guests
-
-      def initialize(from_date:, to_date:, state_id:, number_of_adults:, number_of_kids:)
-        @from_date = from_date
-        @to_date = to_date
-        @state_id = state_id
-        @number_of_guests = number_of_adults.to_i + number_of_kids.to_i
-      end
-
-      def execute
-        scope
-          .where(default_state_id: state_id)
-          .where(inventory_items: { inventory_date: stay_dates })
-          .where('CAST(spree_variants.public_metadata->\'cm_options\'->>\'number-of-adults\' AS INTEGER) +
-                  CAST(spree_variants.public_metadata->\'cm_options\'->>\'number-of-kids\' AS INTEGER) >= ?', number_of_guests
-          )
-          .where('inventory_items.quantity_available > 0')
-          .distinct
-      end
-
-      private
-
-      def scope
-        Spree::Vendor
-          .joins(variants: :inventory_items)
-          .where(primary_product_type: :accommodation, state: :active)
-      end
-
-      def stay_dates
-        from_date..to_date
-      end
-    end
-  end
-end

data/app/finders/spree_cm_commissioner/accommodations/find_variant.rb

@@ -1,32 +0,0 @@
-module SpreeCmCommissioner
-  module Accommodations
-    class FindVariant
-      attr_reader :vendor_id, :from_date, :to_date, :number_of_guests
-
-      def initialize(vendor_id:, from_date:, to_date:, number_of_adults:, number_of_kids:)
-        @vendor_id = vendor_id
-        @from_date = from_date
-        @to_date = to_date
-        @number_of_guests = number_of_adults.to_i + number_of_kids.to_i
-      end
-
-      def execute
-        Spree::Variant
-          .joins(:inventory_items)
-          .where(vendor_id: vendor_id)
-          .where(inventory_items: { inventory_date: stay_dates })
-          .where('CAST(public_metadata->\'cm_options\'->>\'number-of-adults\' AS INTEGER) +
-                  CAST(public_metadata->\'cm_options\'->>\'number-of-kids\' AS INTEGER) >= ?', number_of_guests
-          )
-          .where('inventory_items.quantity_available > 0')
-          .distinct
-      end
-
-      private
-
-      def stay_dates
-        from_date..to_date
-      end
-    end
-  end
-end

data/app/interactors/spree_cm_commissioner/ensure_correct_product_type.rb

@@ -1,40 +0,0 @@
-module SpreeCmCommissioner
-  class EnsureCorrectProductType < BaseInteractor
-    def call
-      Spree::Product
-        .left_joins(variants_including_master: %i[inventory_items line_items])
-        .where(
-          'spree_variants.product_type IS NULL OR
-          spree_variants.product_type != spree_products.product_type OR
-
-          cm_inventory_items.product_type IS NULL OR
-          cm_inventory_items.product_type != spree_products.product_type OR
-
-          spree_line_items.product_type IS NULL OR
-          spree_line_items.product_type != spree_products.product_type OR
-
-          spree_products.product_type IS NOT NULL
-          '
-        )
-        .distinct.find_each do |product|
-        sync_product_type_for(product)
-      end
-    end
-
-    def sync_product_type_for(product)
-      product_type = Spree::Variant.product_types[product.product_type]
-
-      product.variants_including_master
-             .where('spree_variants.product_type IS NULL OR spree_variants.product_type != ?', product_type)
-             .update_all(product_type: product_type) # rubocop:disable Rails/SkipsModelValidations
-
-      product.line_items
-             .where('spree_line_items.product_type IS NULL OR spree_line_items.product_type != ?', product_type)
-             .update_all(product_type: product_type) # rubocop:disable Rails/SkipsModelValidations
-
-      product.inventory_items
-             .where('cm_inventory_items.product_type IS NULL OR cm_inventory_items.product_type != ?', product_type)
-             .update_all(product_type: product_type) # rubocop:disable Rails/SkipsModelValidations
-    end
-  end
-end

data/app/interactors/spree_cm_commissioner/inventory_item_syncer.rb

@@ -1,25 +0,0 @@
-module SpreeCmCommissioner
-  class InventoryItemSyncer < BaseInteractor
-    # inventory_id_and_quantities = [{ inventory_id: inventory_item1.id, quantity: 5 } ]
-    delegate :inventory_id_and_quantities, to: :context
-
-    def call
-      ActiveRecord::Base.transaction do
-        inventory_items.each do |inventory_item|
-          quantity = inventory_id_and_quantities.find { |item| item[:inventory_id] == inventory_item.id }&.dig(:quantity) || 0
-          adjust_quantity_available(inventory_item, quantity)
-        end
-      end
-    end
-
-    private
-
-    def adjust_quantity_available(inventory_item, quantity)
-      inventory_item.update!(quantity_available: inventory_item.quantity_available + quantity)
-    end
-
-    def inventory_items
-      @inventory_items ||= InventoryItem.where(id: inventory_id_and_quantities.pluck(:inventory_id))
-    end
-  end
-end

data/app/interactors/spree_cm_commissioner/stock/inventory_item_resetter.rb

@@ -1,44 +0,0 @@
-module SpreeCmCommissioner
-  module Stock
-    class InventoryItemResetter < BaseInteractor
-      delegate :inventory_item, to: :context
-
-      def call
-        max_capacity = variant_total_inventory
-        total_purchases = variant_total_purchases
-        quantity_available = [max_capacity - total_purchases, 0].max
-
-        updated = inventory_item.update(max_capacity: max_capacity, quantity_available: quantity_available)
-        return context.fail!(message: 'Failed to update inventory item', errors: inventory_item.errors.full_messages) unless updated
-
-        clear_inventory_cache
-      end
-
-      def variant_total_inventory
-        # for shipment, total_on_hand is not orignal stock. shipment does subtract the stock.
-        # to get desire result, we need to add to total_purchase.
-        if inventory_item.variant.delivery_required?
-          inventory_item.variant.total_on_hand.to_i + variant_total_purchases
-        else
-          inventory_item.variant.total_on_hand.to_i
-        end
-      end
-
-      def variant_total_purchases
-        scope = inventory_item.variant.complete_line_items
-
-        if inventory_item.permanent_stock?
-          scope.where('? BETWEEN from_date AND to_date', inventory_item.inventory_date).sum(:quantity).to_i
-        else
-          scope.sum(:quantity).to_i
-        end
-      end
-
-      def clear_inventory_cache
-        SpreeCmCommissioner.redis_pool.with do |redis|
-          redis.del(inventory_item.redis_key)
-        end
-      end
-    end
-  end
-end

data/app/interactors/spree_cm_commissioner/stock/inventory_items_adjuster.rb

@@ -1,13 +0,0 @@
-module SpreeCmCommissioner
-  module Stock
-    class InventoryItemsAdjuster < BaseInteractor
-      delegate :variant, :quantity, to: :context
-
-      def call
-        variant.inventory_items.active.find_each do |inventory_item|
-          inventory_item.adjust_quantity!(quantity)
-        end
-      end
-    end
-  end
-end

data/app/interactors/spree_cm_commissioner/stock/inventory_items_generator.rb

@@ -1,15 +0,0 @@
-module SpreeCmCommissioner
-  module Stock
-    class InventoryItemsGenerator < BaseInteractor
-      delegate :variant, to: :context
-
-      def call
-        if variant.permanent_stock?
-          SpreeCmCommissioner::Stock::PermanentInventoryItemsGenerator.call(variant_ids: [variant.id])
-        else
-          variant.create_default_non_permanent_inventory_item! unless variant.default_inventory_item_exist?
-        end
-      end
-    end
-  end
-end

data/app/interactors/spree_cm_commissioner/stock/permanent_inventory_items_generator.rb

@@ -1,75 +0,0 @@
-module SpreeCmCommissioner
-  module Stock
-    class PermanentInventoryItemsGenerator < BaseInteractor
-      delegate :variant_ids, to: :context
-
-      def variants_per_batch = 1000
-
-      def pre_inventory_days_for(variant)
-        context.pre_inventory_days || variant.pre_inventory_days
-      end
-
-      def call
-        variants.in_batches(of: variants_per_batch) do |batch|
-          generate_inventory_items_for_batch(batch)
-        end
-      end
-
-      private
-
-      def generate_inventory_items_for_batch(batch)
-        total_on_hand_by_variant = total_on_hand_for(batch)
-        batch.each do |variant|
-          count_on_hand = total_on_hand_by_variant[variant.id] || 0
-          generate_inventory_items_for_variant(variant, count_on_hand)
-        end
-      end
-
-      def generate_inventory_items_for_variant(variant, count_on_hand)
-        inventory_dates_for(variant).each do |inventory_date|
-          next if inventory_exist?(variant, inventory_date)
-
-          create_inventory_item(variant, inventory_date, count_on_hand)
-        end
-      end
-
-      def inventory_dates_for(variant)
-        start_date = Time.zone.tomorrow
-        end_date = Time.zone.today + pre_inventory_days_for(variant)
-
-        (start_date..end_date)
-      end
-
-      def inventory_exist?(variant, inventory_date)
-        variant.inventory_items.exists?(inventory_date: inventory_date)
-      end
-
-      def create_inventory_item(variant, inventory_date, count_on_hand)
-        variant.inventory_items.create!(
-          inventory_date: inventory_date,
-          quantity_available: count_on_hand,
-          max_capacity: count_on_hand,
-          product_type: variant.product_type
-        )
-      end
-
-      # Returns a hash: { variant_id => total_on_hand, ... }
-      def total_on_hand_for(variants)
-        variant_ids = variants.pluck(:id)
-
-        Spree::StockItem
-          .joins(:stock_location)
-          .where(deleted_at: nil, variant_id: variant_ids)
-          .where(spree_stock_locations: { active: true })
-          .group(:variant_id)
-          .sum(:count_on_hand)
-      end
-
-      def variants
-        scope = Spree::Variant.active.with_permanent_stock.where(is_master: false)
-        scope = scope.where(id: variant_ids) if variant_ids.present?
-        scope
-      end
-    end
-  end
-end

data/app/interactors/spree_cm_commissioner/stock/stock_movement_creator.rb

@@ -1,32 +0,0 @@
-module SpreeCmCommissioner
-  module Stock
-    class StockMovementCreator < BaseInteractor
-      delegate :variant_id, :stock_location_id, :current_store, :stock_movement_params, to: :context
-
-      def call
-        variant = current_store.variants.find(variant_id)
-
-        return context.fail!(message: Spree.t(:doesnt_track_inventory)) unless variant.track_inventory?
-
-        stock_location = Spree::StockLocation.find(stock_location_id)
-        stock_movement = stock_location.stock_movements.build(stock_movement_params)
-        stock_movement.stock_item = stock_location.set_up_stock_item(variant)
-
-        if stock_movement.save
-          adjust_inventory_items_async(variant_id, stock_movement.quantity)
-          context.stock_movement = stock_movement
-        else
-          context.fail!(message: stock_movement.errors.full_messages.join(', '))
-        end
-      end
-
-      private
-
-      def adjust_inventory_items_async(variant_id, quantity)
-        CmAppLogger.log(label: "#{self.class.name}#adjust_inventory_items_async", data: { variant_id: variant_id, quantity: quantity }) do
-          SpreeCmCommissioner::Stock::InventoryItemsAdjusterJob.perform_later(variant_id: variant_id, quantity: quantity)
-        end
-      end
-    end
-  end
-end

data/app/jobs/spree_cm_commissioner/ensure_correct_product_type_job.rb

@@ -1,7 +0,0 @@
-module SpreeCmCommissioner
-  class EnsureCorrectProductTypeJob < ApplicationJob
-    def perform
-      SpreeCmCommissioner::EnsureCorrectProductType.call
-    end
-  end
-end

data/app/jobs/spree_cm_commissioner/inventory_item_syncer_job.rb

@@ -1,7 +0,0 @@
-module SpreeCmCommissioner
-  class InventoryItemSyncerJob < ApplicationUniqueJob
-    def perform(inventory_id_and_quantities:)
-      InventoryItemSyncer.call(inventory_id_and_quantities:)
-    end
-  end
-end

data/app/jobs/spree_cm_commissioner/stock/inventory_items_adjuster_job.rb

@@ -1,11 +0,0 @@
-module SpreeCmCommissioner
-  module Stock
-    class InventoryItemsAdjusterJob < ApplicationUniqueJob
-      def perform(variant_id:, quantity:)
-        variant = Spree::Variant.find(variant_id)
-
-        SpreeCmCommissioner::Stock::InventoryItemsAdjuster.call(variant: variant, quantity: quantity)
-      end
-    end
-  end
-end

data/app/jobs/spree_cm_commissioner/stock/inventory_items_generator_job.rb

@@ -1,11 +0,0 @@
-module SpreeCmCommissioner
-  module Stock
-    class InventoryItemsGeneratorJob < ApplicationUniqueJob
-      def perform(variant_id:)
-        variant = Spree::Variant.find(variant_id)
-
-        SpreeCmCommissioner::Stock::InventoryItemsGenerator.call(variant: variant)
-      end
-    end
-  end
-end

data/app/jobs/spree_cm_commissioner/stock/permanent_inventory_items_generator_job.rb

@@ -1,9 +0,0 @@
-module SpreeCmCommissioner
-  module Stock
-    class PermanentInventoryItemsGeneratorJob < ApplicationUniqueJob
-      def perform
-        SpreeCmCommissioner::Stock::PermanentInventoryItemsGenerator.call
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-module SpreeCmCommissioner
-  module OrderSeatable
-    def should_manage_blocks?
-      preload_block_ids.any?
-    end
-
-    def hold_blocks!
-      return unless should_manage_blocks?
-
-      CmAppLogger.log(label: "#{self.class.name}#hold_blocks!", data: { order_id: id }) do
-        SpreeCmCommissioner::Seats::BlocksHolder.new(line_item_ids: line_item_ids, hold_by: user).hold_blocks!
-      end
-    end
-
-    def cancel_blocks!
-      return unless should_manage_blocks?
-
-      CmAppLogger.log(label: "#{self.class.name}#cancel_blocks!", data: { order_id: id }) do
-        SpreeCmCommissioner::Seats::BlocksCanceler.new(order_id: id, cancel_by: user).cancel_blocks!
-      end
-    end
-
-    def reserve_blocks!
-      return unless should_manage_blocks?
-
-      CmAppLogger.log(label: "#{self.class.name}#reserve_blocks!", data: { order_id: id }) do
-        SpreeCmCommissioner::Seats::BlocksReserver.new(line_item_ids: line_item_ids, reserve_by: user).reserve_blocks!
-      end
-    end
-
-    # Calling `.block_ids` directly can cause many slow database queries (N+1 problem)
-    # every time `.should_manage_blocks?` or `.preload_block_ids` runs.
-    # To avoid this, we store a precomputed list of block IDs in `private_metadata`.
-    # This list is updated whenever a guest’s block is saved or destroy.
-    def preload_block_ids=(preload_block_ids = [])
-      self.private_metadata ||= {}
-      self.private_metadata['preload_block_ids'] = preload_block_ids
-    end
-
-    def preload_block_ids
-      self.private_metadata&.fetch('preload_block_ids', []) || []
-    end
-  end
-end

data/app/models/spree_cm_commissioner/block.rb

@@ -1,23 +0,0 @@
-module SpreeCmCommissioner
-  class Block < Base
-    belongs_to :seat_section, class_name: 'SpreeCmCommissioner::SeatSection', optional: true
-    belongs_to :seat_layout, class_name: 'SpreeCmCommissioner::SeatLayout', optional: false
-
-    validates :label, presence: true
-
-    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 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