spree_cm_commissioner 2.0.3.pre.pre4 → 2.0.3.pre.pre6

data/app/models/spree_cm_commissioner/inventory_item.rb

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

@@ -1,6 +1,6 @@
 module SpreeCmCommissioner
   module LineItemDecorator
-    def self.prepended(base) # rubocop:disable Metrics/MethodLength
+    def self.prepended(base) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
       include_modules(base)
 
       base.belongs_to :accepter, class_name: 'Spree::User', optional: true
@@ -10,31 +10,32 @@ module SpreeCmCommissioner
       base.has_one :google_wallet, class_name: 'SpreeCmCommissioner::GoogleWallet', through: :product
 
       base.has_many :option_types, through: :product
+
+      base.has_many :inventory_items, lambda { |line_item|
+        where(inventory_date: nil).or(where(inventory_date: line_item.date_range))
+      }, through: :variant
+
       base.has_many :taxons, class_name: 'Spree::Taxon', through: :product
       base.has_many :guests, class_name: 'SpreeCmCommissioner::Guest', dependent: :destroy
+      base.has_many :guests_with_blocks, -> { where.not(block_id: nil) }, class_name: 'SpreeCmCommissioner::Guest'
+      base.has_many :reserved_blocks, through: :guests, class_name: 'SpreeCmCommissioner::ReservedBlock'
       base.has_many :pending_guests, pending_guests_query, class_name: 'SpreeCmCommissioner::Guest', dependent: :destroy
       base.has_many :product_completion_steps, class_name: 'SpreeCmCommissioner::ProductCompletionStep', through: :product
-      base.has_many :line_item_seats, class_name: 'SpreeCmCommissioner::LineItemSeat', dependent: :destroy
 
       base.before_save :update_vendor_id
-      base.before_save :update_quantity, if: :transit?
-
-      base.validate :validate_seats_reservation, if: :transit?
 
       base.before_create :add_due_date, if: :subscription?
+      base.before_save -> { self.product_type = variant.product_type }, if: -> { product_type.nil? }
 
       base.validate :ensure_not_exceed_max_quantity_per_order, if: -> { variant&.max_quantity_per_order.present? }
 
       base.whitelisted_ransackable_associations |= %w[guests order]
       base.whitelisted_ransackable_attributes |= %w[number to_date from_date vendor_id]
 
-      base.delegate :delivery_required?, :permanent_stock?, :high_demand, :transit?,
+      base.delegate :delivery_required?, :high_demand,
                     to: :variant
-      base.delegate :discontinue_on, :product_type, :accommodation?, :service?, :ecommerce?, :need_confirmation,
-                    to: :product
 
       base.accepts_nested_attributes_for :guests, allow_destroy: true
-      base.accepts_nested_attributes_for :line_item_seats, allow_destroy: true
 
       def base.json_api_columns
         json_api_columns = column_names.reject { |c| c.match(/_id$|id|preferences|(.*)password|(.*)token|(.*)api_key/) }
@@ -42,6 +43,10 @@ module SpreeCmCommissioner
         json_api_columns << :vendor_id
       end
 
+      def discontinue_on
+        variant.discontinue_on || product.discontinue_on
+      end
+
       def base.search_by_qr_data!(data)
         matches = data.match(/(R\d+)-([A-Za-z0-9_\-]+)-(L\d+)/)&.captures
 
@@ -60,6 +65,8 @@ module SpreeCmCommissioner
       base.include SpreeCmCommissioner::LineItemDurationable
       base.include SpreeCmCommissioner::LineItemsFilterScope
       base.include SpreeCmCommissioner::LineItemGuestsConcern
+      base.include SpreeCmCommissioner::LineItemTransitable
+      base.include SpreeCmCommissioner::ProductType
       base.include SpreeCmCommissioner::ProductDelegation
       base.include SpreeCmCommissioner::KycBitwise
     end
@@ -75,24 +82,39 @@ module SpreeCmCommissioner
       }
     end
 
-    def reservation?
-      date_present? && !subscription?
-    end
+    # override to calculate price per date for permanent stock
+    def update_price_from_modifier(currency, opts)
+      self.currency = currency
 
-    # date_unit could be number of nights, or days or hours depending on usecases
-    # For example:
-    # - accomodation uses number of nights.
-    # - appointment uses number of hours, etc.
-    #
-    # override
-    def amount
-      base_price = price * quantity
+      # these fields can be null during this process below.
+      # it is needed for permanent_stock?, date_range to work.
+      self.product_type = variant.product_type
+      self.from_date = opts.delete(:from_date)&.to_datetime
+      self.to_date = opts.delete(:to_date)&.to_datetime
 
-      if permanent_stock? && date_unit.present?
-        base_price * date_unit
-      else
-        base_price
-      end
+      base_price = variant.price_in(currency)
+
+      self.price = if permanent_stock?
+                     date_range.map do |date|
+                       selected_price = variant.price_for_date(date: date, currency: currency) || base_price
+                       (selected_price.amount || 0) + variant.price_modifier_amount_in(currency, opts.merge(date: date))
+                     end.sum
+                   else
+                     (base_price.amount || 0) + variant.price_modifier_amount_in(currency, opts)
+                   end
+    end
+
+    # override to calculate price per date for permanent stock
+    def update_price
+      base_price = variant.price_in(order.currency)
+      self.price = if permanent_stock?
+                     date_range.map do |date|
+                       selected_price = variant.price_for_date(date: date, currency: order.currency) || base_price
+                       selected_price.amount || 0
+                     end.sum
+                   else
+                     base_price.amount || 0
+                   end
     end
 
     def allowed_self_check_in?
@@ -179,8 +201,6 @@ module SpreeCmCommissioner
 
     # override
     def sufficient_stock?
-      return transit_sufficient_stock? if variant.product.product_type == 'transit'
-
       SpreeCmCommissioner::Stock::LineItemAvailabilityChecker.new(self).can_supply?(quantity)
     end
 
@@ -199,18 +219,6 @@ module SpreeCmCommissioner
       errors.add(:quantity, 'exceeded_max_quantity_per_order') if quantity > variant.max_quantity_per_order
     end
 
-    def transit_sufficient_stock?
-      return selected_seats_available? if reservation_trip.allow_seat_selection
-
-      seat_quantity_available?(reservation_trip)
-    end
-
-    def update_quantity
-      return if line_item_seats.blank?
-
-      self.quantity = line_item_seats.size
-    end
-
     def update_vendor_id
       self.vendor_id = variant.vendor_id
     end
@@ -233,45 +241,6 @@ module SpreeCmCommissioner
 
       from_date + variant.month.month + day.days
     end
-
-    def validate_seats_reservation
-      if reservation_trip.allow_seat_selection && !selected_seats_available?
-        errors.add(:base, :some_seats_are_booked, message: 'Some seats are already booked')
-      elsif !reservation_trip.allow_seat_selection && !seat_quantity_available?(reservation_trip)
-        errors.add(:quantity, :exceeded_available_quantity, message: 'exceeded available quantity')
-      end
-    end
-
-    def selected_seats_available?
-      selected_seat_ids = line_item_seats.map(&:seat_id)
-      !selected_seat_ids_occupied?(selected_seat_ids)
-    end
-
-    def seat_quantity_available?(trip)
-      booked_quantity = Spree::LineItem.joins(:order)
-                                       .where(variant_id: variant_id, date: date, spree_orders: { state: 'complete' })
-                                       .where.not(spree_line_items: { id: id })
-                                       .sum(:quantity)
-      remaining_quantity = trip.vehicle.number_of_seats - booked_quantity
-      remaining_quantity >= quantity
-    end
-
-    def reservation_trip
-      return @trip if defined? @trip
-
-      route = Spree::Variant.find_by(id: variant_id).product
-      @trip = route.trip
-    end
-
-    def selected_seat_ids_occupied?(selected_seat_ids)
-      # check to see if there are any selected_ids exist in the line_item_seats and belongs to completed order
-      SpreeCmCommissioner::LineItemSeat.joins(line_item: :order)
-                                       .where(seat_id: selected_seat_ids, date: date, variant_id: variant_id, spree_orders: { state: 'complete',
-                                                                                                                              canceled_at: nil
-}
-                                       )
-                                       .present?
-    end
   end
 end
 

data/app/models/spree_cm_commissioner/notification_taxon.rb

@@ -1,5 +1,5 @@
 module SpreeCmCommissioner
-  class NotificationTaxon < SpreeCmCommissioner::Base
+  class NotificationTaxon < Base
     belongs_to :customer_notification, class_name: 'SpreeCmCommissioner::CustomerNotification'
     belongs_to :taxon, class_name: 'Spree::Taxon'
   end

data/app/models/spree_cm_commissioner/option_type_decorator.rb

@@ -6,7 +6,7 @@ module SpreeCmCommissioner
       base.include SpreeCmCommissioner::ParameterizeName
       base.include SpreeCmCommissioner::OptionTypeAttrType
 
-      base.enum kind: %i[variant product vendor vehicle_type transit]
+      base.enum kind: %i[variant product vendor vehicle]
 
       base.validates :name, presence: true
 
@@ -19,16 +19,6 @@ module SpreeCmCommissioner
       base.scope :promoted, -> { where(promoted: true) }
       base.whitelisted_ransackable_attributes = %w[kind]
 
-      def base.amenities
-        Spree::OptionType.where(kind: 'vehicle_type', name: 'amenities', presentation: 'Amenities', attr_type: 'amenity').first_or_create
-      end
-
-      def base.vehicle
-        Spree::OptionType.where(presentation: 'vehicle', attr_type: 'vehicle_id', kind: 'variant',
-                                name: 'vehicle'
-        ).first_or_create
-      end
-
       def base.rules_option_type
         Spree::OptionType.find_by(name: RULES_OPTION_TYPE_NAME)
       end

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

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

data/app/models/spree_cm_commissioner/order_decorator.rb

@@ -2,6 +2,7 @@ module SpreeCmCommissioner
   module OrderDecorator
     def self.prepended(base) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
       base.include SpreeCmCommissioner::PhoneNumberSanitizer
+      base.include SpreeCmCommissioner::OrderSeatable
       base.include SpreeCmCommissioner::OrderStateMachine
 
       base.scope :subscription, -> { where.not(subscription_id: nil) }
@@ -42,6 +43,14 @@ module SpreeCmCommissioner
       base.has_many :vendors, through: :products, class_name: 'Spree::Vendor'
       base.has_many :taxons, through: :products, class_name: 'Spree::Taxon'
       base.has_many :guests, through: :line_items, class_name: 'SpreeCmCommissioner::Guest'
+
+      base.has_many :saved_guests, -> { distinct.reorder('cm_saved_guests.created_at DESC') },
+                    through: :guests,
+                    source: :saved_guest,
+                    class_name: 'SpreeCmCommissioner::SavedGuest'
+
+      base.has_many :blocks, through: :guests, class_name: 'SpreeCmCommissioner::Block', source: :block
+      base.has_many :reserved_blocks, through: :guests, class_name: 'SpreeCmCommissioner::ReservedBlock'
       base.has_many :guest_card_classes, class_name: 'SpreeCmCommissioner::GuestCardClass', through: :variants
 
       base.delegate :customer, to: :user, allow_nil: true
@@ -49,6 +58,8 @@ module SpreeCmCommissioner
       base.whitelisted_ransackable_associations |= %w[customer taxon payments guests invoice]
       base.whitelisted_ransackable_attributes |= %w[intel_phone_number phone_number email number state]
 
+      base.accepts_nested_attributes_for :saved_guests, allow_destroy: true
+
       def base.search_by_qr_data!(data)
         token = data.match(/^R\d{9,}-([A-Za-z0-9_\-]+)$/)&.captures
 
@@ -58,6 +69,13 @@ module SpreeCmCommissioner
       end
     end
 
+    # override
+    # spree use this method to check stock availability & consider whether :order can continue to next state.
+    def insufficient_stock_lines
+      checker = SpreeCmCommissioner::Stock::OrderAvailabilityChecker.new(self)
+      checker.insufficient_stock_lines
+    end
+
     def ticket_seller_user?
       return false if user.nil?
 
@@ -106,7 +124,14 @@ module SpreeCmCommissioner
     end
 
     def mark_as_archive
-      update(archived_at: Time.current)
+      blocks_canceled = begin
+        cancel_blocks!
+        true
+      rescue StandardError
+        false
+      end
+
+      update(archived_at: Time.current) if blocks_canceled
     end
 
     # overrided
@@ -199,6 +224,18 @@ module SpreeCmCommissioner
 
     private
 
+    def unstock_inventory_in_redis!
+      CmAppLogger.log(label: "#{self.class.name}#unstock_inventory_in_redis!", data: { order_id: id }) do
+        SpreeCmCommissioner::RedisStock::InventoryUpdater.new(line_item_ids).unstock!
+      end
+    end
+
+    def restock_inventory_in_redis!
+      CmAppLogger.log(label: "#{self.class.name}#restock_inventory_in_redis!", data: { order_id: id }) do
+        SpreeCmCommissioner::RedisStock::InventoryUpdater.new(line_item_ids).restock!
+      end
+    end
+
     # override :spree_api
     def webhook_payload_body
       resource_serializer.new(

data/app/models/spree_cm_commissioner/place.rb

@@ -1,7 +1,5 @@
-require_dependency 'spree_cm_commissioner'
-
 module SpreeCmCommissioner
-  class Place < ApplicationRecord
+  class Place < Base
     acts_as_nested_set
 
     validates :reference, presence: true, if: :validate_reference?
@@ -16,8 +14,9 @@ module SpreeCmCommissioner
     has_many :product_places, class_name: 'SpreeCmCommissioner::ProductPlace', dependent: :destroy
     has_many :products, through: :product_places
 
+    has_many :location_vendor_places, -> { where(place_type: :location) }, class_name: 'SpreeCmCommissioner::VendorPlace'
+
     has_many :children, -> { order(:lft) }, class_name: 'SpreeCmCommissioner::Place', foreign_key: :parent_id, dependent: :destroy
-    has_many :vendor_stops, class_name: 'SpreeCmCommissioner::VendorStop', dependent: :destroy, foreign_key: :stop_id
 
     has_many :taxon_places, class_name: 'SpreeCmCommissioner::TaxonPlace', dependent: :destroy
     has_many :taxons, through: :taxon_places

data/app/models/spree_cm_commissioner/price_decorator.rb

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

data/app/models/spree_cm_commissioner/product_decorator.rb

@@ -6,7 +6,6 @@ module SpreeCmCommissioner
       base.include SpreeCmCommissioner::KycBitwise
       base.include SpreeCmCommissioner::Metafield
       base.include SpreeCmCommissioner::TenantUpdatable
-      base.include SpreeCmCommissioner::RouteType
 
       base.has_many :variant_kind_option_types, -> { where(kind: :variant).order(:position) },
                     through: :product_option_types, source: :option_type
@@ -33,6 +32,7 @@ module SpreeCmCommissioner
       base.has_one :google_wallet, class_name: 'SpreeCmCommissioner::GoogleWallet', dependent: :destroy
 
       base.has_many :complete_line_items, through: :classifications, source: :line_items
+      base.has_many :inventory_items, through: :variants
       base.has_many :guests, through: :line_items
 
       base.has_many :product_places, class_name: 'SpreeCmCommissioner::ProductPlace', dependent: :destroy
@@ -48,6 +48,9 @@ module SpreeCmCommissioner
 
       base.belongs_to :event, class_name: 'Spree::Taxon', optional: true
 
+      base.has_many :industry_classifications, -> { joins(:taxon).where(spree_taxons: { kind: :industry }) }, class_name: 'Spree::Classification'
+      base.has_many :industry_taxons, through: :industry_classifications, source: :taxon
+
       base.scope :min_price, lambda { |vendor|
         joins(:prices_including_master)
           .where(vendor_id: vendor.id, product_type: vendor.primary_product_type)
@@ -64,19 +67,26 @@ module SpreeCmCommissioner
       base.before_validation :set_event_id
 
       base.validate :validate_event_taxons, if: -> { taxons.event.present? }
-
       base.validate :validate_product_date, if: -> { available_on.present? && discontinue_on.present? }
-
+      base.validate :product_type_unchanged, on: :update
       base.validates :commission_rate, numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 100 }, allow_nil: true
 
-      base.whitelisted_ransackable_attributes = %w[description name slug discontinue_on status vendor_id short_name route_type]
+      base.whitelisted_ransackable_attributes = %w[description name slug discontinue_on status vendor_id short_name]
 
       base.after_update :update_variants_vendor_id, if: :saved_change_to_vendor_id?
       base.after_update :sync_event_id_to_children, if: :saved_change_to_event_id?
 
       base.enum purchasable_on: { both: 0, web: 1, app: 2 }
-
-      base.accepts_nested_attributes_for :trip, allow_destroy: true
+      base.enum call_to_action: { buy_now: 0,
+                                  book_now: 1,
+                                  reserve: 2,
+                                  register: 3,
+                                  apply: 4,
+                                  get_ticket: 5,
+                                  secure_your_seat: 6,
+                                  join_the_event: 7,
+                                  request_to_book: 8
+                                }
 
       base.multi_tenant :tenant, class_name: 'SpreeCmCommissioner::Tenant'
       base.before_save :set_tenant
@@ -86,6 +96,22 @@ module SpreeCmCommissioner
       "#{Spree::Store.default.formatted_url}/tickets/#{slug}"
     end
 
+    def action_button
+      return :request_to_book if need_confirmation?
+      return :reserve if free?
+      return call_to_action.to_sym if call_to_action.present?
+
+      :buy_now
+    end
+
+    def free?
+      return false if prices_including_master.empty?
+
+      prices_including_master.all? do |master_price|
+        master_price.price.zero? && (master_price.compare_at_price.nil? || master_price.compare_at_price.zero?)
+      end
+    end
+
     def dynamic_fields_by_collection_phase
       {
         pre_registration: dynamic_fields.pre_registration.order(:position),
@@ -136,6 +162,13 @@ module SpreeCmCommissioner
 
       errors.add(:discontinue_on, 'must be after the available on date')
     end
+
+    def product_type_unchanged
+      return if product_type_was.nil?
+      return unless product_type_changed?
+
+      errors.add(:product_type, 'cannot be changed once set')
+    end
   end
 end
 

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

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