spree_cm_commissioner 1.10.0 → 1.11.0.pre.pre

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

@@ -0,0 +1,40 @@
+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?
+
+        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,27 @@
+module SpreeCmCommissioner
+  module RedisStock
+    class VariantCachedInventoryItemsBuilder
+      attr_reader :variant_id, :from_date, :to_date
+
+      def initialize(variant_id:, from_date: nil, to_date: nil)
+        @variant_id = variant_id
+        @from_date = from_date
+        @to_date = to_date
+      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.where(inventory_date: from_date..to_date) if variant.permanent_stock?
+
+        inventory_items
+      end
+    end
+  end
+end

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

@@ -1,47 +1,49 @@
 module SpreeCmCommissioner
   module Stock
     class AvailabilityChecker
-      attr_reader :variant, :error_message
+      attr_reader :variant, :options, :error_message
 
-      def initialize(variant)
+      def initialize(variant, options = {})
         @variant = variant
+        @options = options
         @error_message = nil
       end
 
-      def can_supply?(quantity = 1, options = {})
+      def can_supply?(quantity = 1)
         return false unless variant.available?
         return true unless variant.should_track_inventory?
         return true if variant.backorderable?
         return true if variant.need_confirmation?
 
-        # when delivery required, shipment will dynamically add / remove unit from stock item.
-        # so we can directly check can_supply with stock items directly.
-        return variant.stock_items.sum(:count_on_hand) >= quantity if variant.delivery_required?
+        variant_available?(quantity)
+      end
 
-        if variant.permanent_stock?
-          permanent_stock_variant_available?(quantity, options)
-        else
-          variant_available?(quantity, options)
+      def variant_available?(quantity = 1)
+        return false if cached_inventory_items.empty?
+
+        cached_inventory_items.all? do |cached_inventory_item|
+          cached_inventory_item.active? && cached_inventory_item.quantity_available >= quantity
         end
       end
 
-      def variant_available?(quantity = 1, options = {})
-        query = SpreeCmCommissioner::VariantAvailability::NonPermanentStockQuery.new(
-          variant: variant,
-          except_line_item_id: options[:except_line_item_id]
-        )
-        result = query.available?(quantity)
-        @error_message = query.error_message unless result
-        result
+      def cached_inventory_items
+        return @cached_inventory_items if defined?(@cached_inventory_items)
+
+        if variant.permanent_stock?
+          return [] if options[:from_date].blank? || options[:to_date].blank?
+
+          @cached_inventory_items = builder_klass.new(
+            variant_id: variant.id,
+            from_date: options[:from_date].to_date,
+            to_date: options[:to_date].to_date
+          ).call
+        else
+          @cached_inventory_items = builder_klass.new(variant_id: variant.id).call
+        end
       end
 
-      def permanent_stock_variant_available?(quantity = 1, options = {})
-        SpreeCmCommissioner::VariantAvailability::PermanentStockQuery.new(
-          variant: variant,
-          from_date: options[:from_date].to_date,
-          to_date: options[:to_date].to_date,
-          except_line_item_id: options[:except_line_item_id]
-        ).available?(quantity)
+      def builder_klass
+        ::SpreeCmCommissioner::RedisStock::VariantCachedInventoryItemsBuilder
       end
     end
   end

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

@@ -3,7 +3,8 @@ module SpreeCmCommissioner
     module AvailabilityValidatorDecorator
       # override
       def item_available?(line_item, quantity)
-        SpreeCmCommissioner::Stock::LineItemAvailabilityChecker.new(line_item).can_supply?(quantity)
+        SpreeCmCommissioner::Stock::LineItemAvailabilityChecker.new(line_item)
+                                                               .can_supply?(quantity)
       end
     end
   end

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

@@ -8,14 +8,14 @@ module SpreeCmCommissioner
       end
 
       def can_supply?(quantity)
-        AvailabilityChecker.new(line_item.variant).can_supply?(quantity, options)
+        ::SpreeCmCommissioner::Stock::AvailabilityChecker.new(line_item.variant, options)
+                                                         .can_supply?(quantity)
       end
 
       def options
         {
           from_date: line_item.from_date,
-          to_date: line_item.to_date,
-          except_line_item_id: line_item.id
+          to_date: line_item.to_date
         }
       end
     end

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

@@ -0,0 +1,44 @@
+# 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/stock_item_decorator.rb

@@ -3,11 +3,29 @@ module SpreeCmCommissioner
     def self.prepended(base)
       base.has_one :vendor, through: :variant
       base.after_save :update_vendor_total_inventory, if: :saved_change_to_count_on_hand?
+
+      base.after_commit :create_inventory_items, on: :create
+      base.after_commit :adjust_inventory_items_async, on: :destroy
     end
 
     def update_vendor_total_inventory
       SpreeCmCommissioner::VendorJob.perform_later(vendor.id) if vendor.present?
     end
+
+    private
+
+    def create_inventory_items
+      if variant.permanent_stock?
+        SpreeCmCommissioner::Stock::PermanentInventoryItemsGeneratorJob.perform_later(variant_ids: [variant.id])
+      else
+        variant.create_default_non_permanent_inventory_item! unless variant.default_inventory_item_exist?
+      end
+    end
+
+    # When admin delete stock item, it will deduct stock from inventory item
+    def adjust_inventory_items_async
+      SpreeCmCommissioner::Stock::InventoryItemsAdjusterJob.perform_later(variant_id: variant_id, quantity: -count_on_hand)
+    end
   end
 end
 

data/app/models/spree_cm_commissioner/taxon_decorator.rb

@@ -57,6 +57,9 @@ module SpreeCmCommissioner
       base.has_many :event_blazer_queries, class_name: 'SpreeCmCommissioner::TaxonBlazerQuery'
       base.has_many :blazer_queries, through: :event_blazer_queries, class_name: 'Blazer::Query'
 
+      base.has_many :taxon_option_types, class_name: 'SpreeCmCommissioner::TaxonOptionType'
+      base.has_many :taxon_option_values, class_name: 'SpreeCmCommissioner::TaxonOptionValue'
+
       def base.active_homepage_events
         joins(:homepage_section_relatables)
           .joins("INNER JOIN spree_taxons taxon ON taxon.id = cm_homepage_section_relatables.relatable_id
@@ -96,6 +99,14 @@ module SpreeCmCommissioner
                        .uniq
     end
 
+    def selected_option_types
+      taxon_option_types.pluck(:option_type_id)
+    end
+
+    def selected_option_values
+      taxon_option_values.pluck(:option_value_id)
+    end
+
     def event_url
       "https://#{Spree::Store.default.url}/t/#{permalink}"
     end

data/app/models/spree_cm_commissioner/taxon_option_type.rb

@@ -0,0 +1,8 @@
+require_dependency 'spree_cm_commissioner'
+
+module SpreeCmCommissioner
+  class TaxonOptionType < ApplicationRecord
+    belongs_to :taxon, class_name: 'Spree::Taxon', dependent: :destroy
+    belongs_to :option_type, class_name: 'Spree::OptionType', dependent: :destroy
+  end
+end

data/app/models/spree_cm_commissioner/taxon_option_value.rb

@@ -0,0 +1,8 @@
+require_dependency 'spree_cm_commissioner'
+
+module SpreeCmCommissioner
+  class TaxonOptionValue < ApplicationRecord
+    belongs_to :taxon, class_name: 'Spree::Taxon', dependent: :destroy
+    belongs_to :option_value, class_name: 'Spree::OptionValue', dependent: :destroy
+  end
+end

data/app/models/spree_cm_commissioner/trip.rb

@@ -14,23 +14,12 @@ module SpreeCmCommissioner
     validates :duration, numericality: { greater_than: 0 }
     validate :origin_and_destination_cannot_be_the_same
 
-    has_many :trip_stops, class_name: 'SpreeCmCommissioner::TripStop', dependent: :destroy
-
-    after_commit :create_trip_stops
-
-    accepts_nested_attributes_for :trip_stops, allow_destroy: true
-
     def convert_duration_to_seconds
       return if hours.blank? && minutes.blank? && seconds.blank?
 
       self.duration = (hours.to_i * 3600) + (minutes.to_i * 60) + seconds.to_i
     end
 
-    def create_trip_stops
-      trip_stops.create(stop_type: :boarding, stop_id: origin_id)
-      trip_stops.create(stop_type: :drop_off, stop_id: destination_id)
-    end
-
     def duration_in_hms
       return { hours: 0, minutes: 0, seconds: 0 } if duration.nil?
 

data/app/models/spree_cm_commissioner/trip_stop.rb

@@ -8,8 +8,8 @@ module SpreeCmCommissioner
     belongs_to :stop, class_name: 'SpreeCmCommissioner::Place'
 
     before_validation :set_stop_name
-    after_create :create_vendor_stop
-
+    after_destroy :decrement_trip_count
+    after_commit :create_vendor_stop
     validates :stop_id, uniqueness: { scope: :trip_id }
 
     def set_stop_name
@@ -17,13 +17,20 @@ module SpreeCmCommissioner
     end
 
     def create_vendor_stop
-      vendor.vendor_stops.where(stop_id: stop_id, stop_type: stop_type).first_or_create if trip.present?
+      vendor_stop = vendor.vendor_stops.where(stop_id: stop_id, stop_type: stop_type).first_or_create
+      vendor_stop.update(trip_count: vendor_stop.trip_count.to_i + 1)
     end
 
     private
 
+    def decrement_trip_count
+      vendor.vendor_stops.where(stop_id: stop_id, stop_type: stop_type).find_each do |vendor_stop|
+        vendor_stop.update(trip_count: [vendor_stop.trip_count - 1, 0].max)
+      end
+    end
+
     def vendor
-      Spree::Product.find(trip.product_id).vendor
+      Spree::Product.find(trip&.product_id).vendor
     end
   end
 end

data/app/models/spree_cm_commissioner/variant_decorator.rb

@@ -1,9 +1,9 @@
 module SpreeCmCommissioner
   module VariantDecorator
-    def self.prepended(base)
+    def self.prepended(base) # rubocop:disable Metrics/AbcSize
+      base.include SpreeCmCommissioner::ProductType
       base.include SpreeCmCommissioner::ProductDelegation
       base.include SpreeCmCommissioner::VariantOptionsConcern
-
       base.after_commit :update_vendor_price
       base.validate     :validate_option_types
       base.before_save -> { self.track_inventory = false }, if: :subscribable?
@@ -21,14 +21,29 @@ module SpreeCmCommissioner
       base.has_many :variant_guest_card_class, class_name: 'SpreeCmCommissioner::VariantGuestCardClass'
       base.has_many :guest_card_classes, class_name: 'SpreeCmCommissioner::GuestCardClass', through: :variant_guest_card_class
 
+      base.has_many :inventory_items, class_name: 'SpreeCmCommissioner::InventoryItem'
+
       base.scope :subscribable, -> { active.joins(:product).where(product: { subscribable: true, status: :active }) }
+      base.scope :with_permanent_stock, -> { where(product_type: base::PERMANENT_STOCK_PRODUCT_TYPES) }
+      base.scope :with_non_permanent_stock, -> { where.not(product_type: base::PERMANENT_STOCK_PRODUCT_TYPES) }
+
       base.has_one :trip,
                    class_name: 'SpreeCmCommissioner::Trip'
       base.has_many :trip_stops, class_name: 'SpreeCmCommissioner::TripStop', dependent: :destroy, foreign_key: :trip_id
       base.accepts_nested_attributes_for :option_values
-      base.has_many :trip_stops, class_name: 'SpreeCmCommissioner::TripStop', foreign_key: :trip_id, dependent: :destroy
-      base.after_commit :sync_trip, if: -> { product.product_type == 'transit' }
+
+      base.before_save -> { self.product_type = product.product_type }, if: -> { product_type.nil? }
+
+      base.after_commit :sync_trip, if: :transit?
       base.accepts_nested_attributes_for :trip_stops, allow_destroy: true
+      base.after_commit :create_trip_stops, if: :transit?
+    end
+
+    def create_trip_stops
+      return if is_master?
+
+      trip_stops.find_or_create_by(stop_type: :boarding, stop_id: options.origin)
+      trip_stops.find_or_create_by(stop_type: :drop_off, stop_id: options.destination)
     end
 
     def delivery_required?
@@ -44,14 +59,26 @@ module SpreeCmCommissioner
       super || product.discontinued?
     end
 
-    def permanent_stock?
-      accommodation?
-    end
-
     def event
       taxons.event.first
     end
 
+    def default_inventory_item_exist?
+      inventory_items.exists?(inventory_date: nil)
+    end
+
+    def create_default_non_permanent_inventory_item!(quantity_available: nil, max_capacity: nil)
+      return if product_type.blank? # handle in case product not exist for variant.
+      return unless should_track_inventory?
+      return if default_inventory_item_exist?
+
+      inventory_items.create!(
+        product_type: product_type,
+        quantity_available: [0, quantity_available || total_on_hand].max,
+        max_capacity: [0, max_capacity || total_on_hand].max
+      )
+    end
+
     # override
     def options_text
       @options_text ||= Spree::Variants::VisableOptionsPresenter.new(self).to_sentence
@@ -67,30 +94,15 @@ module SpreeCmCommissioner
       "#{display_sku} - #{display_price}"
     end
 
-    def transit?
-      product.product_type == 'transit'
-    end
-
     # override
-    def in_stock?
-      available_quantity.positive?
+    def in_stock?(options = {})
+      SpreeCmCommissioner::Stock::AvailabilityChecker.new(self, options).can_supply?
     end
 
     private
 
-    def total_purchases
-      Spree::LineItem.complete.where(variant_id: id).sum(:quantity).to_i
-    end
-
-    def available_quantity
-      stock_count = stock_items.sum(&:count_on_hand)
-      return stock_count if delivery_required?
-
-      stock_count - total_purchases
-    end
-
     def update_vendor_price
-      return unless vendor.present? && product&.product_type == vendor&.primary_product_type
+      return unless vendor.present? && product_type == vendor&.primary_product_type
 
       vendor.update(min_price: price) if price < vendor.min_price
       vendor.update(max_price: price) if price > vendor.max_price
@@ -116,7 +128,7 @@ module SpreeCmCommissioner
     end
 
     def sync_trip
-      return unless product.product_type == 'transit'
+      return unless transit?
 
       trip = SpreeCmCommissioner::Trip.find_or_initialize_by(variant_id: id)
 

data/app/models/spree_cm_commissioner/vendor_stop.rb

@@ -4,6 +4,7 @@ module SpreeCmCommissioner
     belongs_to :vendor, class_name: 'Spree::Vendor'
     belongs_to :stop, class_name: 'SpreeCmCommissioner::Place'
 
-    enum stop_type: { boarding: 0, drop_off: 1 }
+    validates :trip_count, numericality: { greater_than_or_equal_to: 0 }
+    enum :stop_type, { boarding: 0, drop_off: 1 }
   end
 end