spree_cm_commissioner 2.5.0.pre.pre2 → 2.5.0.pre.pre3

data/app/models/concerns/spree_cm_commissioner/integrations/integration_mappable.rb

@@ -0,0 +1,61 @@
+module SpreeCmCommissioner
+  module Integrations
+    # IntegrationMappable provides a polymorphic mapping layer between internal records and external integration IDs.
+    #
+    # Design Rationale: Why use a separate mapping table instead of adding external_id columns directly?
+    #
+    # 1. **No Schema Changes Required**: Adding a new integration doesn't require migrations to add columns to every table.
+    #    The mapping table is reusable across all models that include this concern.
+    #
+    # 2. **Polymorphic Scalability**: A single mapping table handles multiple record types (Spree::Product, Spree::Taxon,
+    #    SeatLayout, etc.) without duplicating external_id columns across the schema.
+    #
+    # 3. **Multiple Source Support**: Records can have mappings to multiple integrations simultaneously. A single product
+    #    might be synced from StadiumXV1, LarrytaV1, and other sources. Direct columns would require one per integration.
+    #
+    # 4. **Acceptable Performance Trade-off**: While joins are slightly slower than direct column lookups, the performance
+    #    impact is negligible in practice because:
+    #    - Lookups occur primarily during background jobs (async, not blocking user requests)
+    #    - Integration sync operations (incremental, full, webhook)
+    #    - Occasional user-triggered operations (not on every page load)
+    #    The flexibility and maintainability gains far outweigh the minimal performance cost.
+    module IntegrationMappable
+      extend ActiveSupport::Concern
+
+      included do
+        has_many :integration_mappings, as: :internal, class_name: 'SpreeCmCommissioner::IntegrationMapping', dependent: :destroy
+        has_many :external_wins_integration_mappings, lambda {
+                                                        joins(:integration).where(integration: { conflict_strategy: :external_wins })
+                                                      }, as: :internal, class_name: 'SpreeCmCommissioner::IntegrationMapping'
+      end
+
+      class_methods do
+        def find_or_initialize_integration_mapping(integration_id:, external_id:)
+          IntegrationMapping.includes(:internal).find_or_initialize_by(
+            integration_id: integration_id,
+            internal_type: name,
+            external_id: external_id
+          ) do |mapping|
+            mapping.internal = new
+            mapping.external_id = external_id
+          end
+        end
+
+        def find_integration_mapping(integration_id:, external_id:)
+          IntegrationMapping.includes(:internal).find_by(
+            integration_id: integration_id,
+            internal_type: name,
+            external_id: external_id
+          )
+        end
+
+        def find_oldest_active_mapping(integration_id:)
+          IntegrationMapping.where(
+            integration_id: integration_id,
+            internal_type: name
+          ).active.order(:last_synced_at).first
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# Caches the integration status of a line item's variant in private_metadata.
+#
+# Why cache?
+# Most products don't have integrations, so checking `variant.vendor.integration.present?`
+# on every read would cause N+1 queries. Caching avoids this performance hit.
+#
+# Behavior:
+# The flag is set once at line item creation and remains immutable. This preserves
+# the historical integration state of the order, even if the vendor's integration
+# status changes later. We don't have use cases requiring dynamic updates of this yet,
+# so we keep it constant for simplicity and consistency.
+module SpreeCmCommissioner
+  module LineItemIntegration
+    extend ActiveSupport::Concern
+
+    included do
+      before_create :set_integration_flag
+    end
+
+    def integration?
+      return false if private_metadata['integration'].nil?
+
+      ActiveModel::Type::Boolean.new.cast(private_metadata['integration'])
+    end
+
+    private
+
+    def set_integration_flag
+      return if private_metadata.key?('integration')
+      return if variant.nil? || variant.vendor.nil?
+
+      # We use variant.vendor instead of .vendor directly as on create, the association may not be set to line item yet.
+      private_metadata['integration'] ||= variant.vendor.integration.present?
+    end
+  end
+end

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

@@ -45,7 +45,8 @@ module SpreeCmCommissioner
       'color' => 'color',
       'ticket-type' => 'string',
       'seat-type' => 'string',
-      'intercity-taxi' => 'string'
+      'intercity-taxi' => 'string',
+      'rules' => 'string'
     }.freeze
 
     included do
@@ -56,7 +57,7 @@ module SpreeCmCommissioner
 
       validate :ensure_name_is_not_changed, on: :update
 
-      before_validation :set_reverved_options_attributes, if: :reserved_option?
+      before_validation :set_reserved_options_attributes, if: :reserved_option?
 
       after_save :sort_date_time_option_values, if: -> { attr_type == 'date' || attr_type == 'time' }
       after_save :update_variants_metadata, if: :saved_change_to_name?
@@ -68,6 +69,17 @@ module SpreeCmCommissioner
       end
     end
 
+    class_methods do
+      def rules_option_type = find_by(name: 'rules')
+
+      def ticket_type
+        Spree::OptionType.find_or_create_by!(name: 'ticket-type') do |ot|
+          ot.presentation = 'Ticket Type'
+          ot.kind = :variant
+        end
+      end
+    end
+
     def reserved_option?
       return name_was.in?(RESERVED_OPTIONS.keys) if name_changed?
 
@@ -78,7 +90,7 @@ module SpreeCmCommissioner
       name == 'ticket-type'
     end
 
-    def set_reverved_options_attributes
+    def set_reserved_options_attributes
       self.attr_type = RESERVED_OPTIONS[name]
       self.kind = :variant
     end

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

@@ -0,0 +1,33 @@
+module SpreeCmCommissioner
+  module OrderIntegration
+    # Checks if any line item in this order has an integration (i.e., is from a vendor with an integration).
+    # This is used to determine if inventory management operations should be delegated to an external system.
+    def integration?
+      line_items.any?(&:integration?)
+    end
+
+    # Attempts to unstock inventory for all integration line items in this order.
+    # Groups line items by vendor and delegates to the vendor's integration service.
+    def unstock_inventory_from_external_system!
+      integration_line_items = line_items.select(&:integration?)
+      return if integration_line_items.empty?
+
+      integration_line_items.group_by(&:vendor_id).each do |_, line_items|
+        integration = line_items.first&.vendor&.integration
+        integration.unstock_external_inventory!(self, line_items) if integration.present?
+      end
+    end
+
+    # Attempts to restock inventory for all integration line items in this order.
+    # Groups line items by vendor and delegates to the vendor's integration service.
+    def restock_inventory_from_external_system!
+      integration_line_items = line_items.select(&:integration?)
+      return if integration_line_items.empty?
+
+      integration_line_items.group_by(&:vendor_id).each do |_, line_items|
+        integration = line_items.first&.vendor&.integration
+        integration.restock_external_inventory!(self, line_items) if integration.present?
+      end
+    end
+  end
+end

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

@@ -143,6 +143,7 @@ module SpreeCmCommissioner
         # The payment will be reversed in vPago gem, and `Spree::Checkout::Complete` will be called, which checks `order.reload.complete?`.
         # This is critical because if the order state is complete, the payment will be marked as paid.
 
+        unstock_inventory_from_external_system!
         reserve_blocks!
         unstock_inventory_in_redis!
 
@@ -161,6 +162,7 @@ module SpreeCmCommissioner
 
     def restock_inventory!
       ActiveRecord::Base.transaction do
+        restock_inventory_from_external_system!
         cancel_blocks!
         restock_inventory_in_redis!
       end

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

@@ -13,6 +13,7 @@
 # - integer
 # - array
 # - datetime
+# - hash
 #
 # Example usage:
 # ```
@@ -22,6 +23,7 @@
 #   store_public_metadata :completed, :boolean, default: true
 #   store_public_metadata :count, :integer, default: 5
 #   store_public_metadata :tags, :array, default: []
+#   store_public_metadata :tags, :hash
 #   store_private_metadata :app_token, :string,  default: "XYZ"
 #   store_public_metadata :scheduled_at, :datetime, default: Time.now
 # end
@@ -92,7 +94,7 @@ module SpreeCmCommissioner
       # - Return default if nil
       # - Cast to correct type
       # - Add `?` predicate for booleans
-      def define_metadata_reader(column_name, key, type, default)
+      def define_metadata_reader(column_name, key, type, default) # rubocop:disable Metrics/CyclomaticComplexity
         define_method(key) do
           metadata = send(column_name) || {}
           raw_value = metadata[key.to_s]
@@ -109,6 +111,8 @@ module SpreeCmCommissioner
             Array(raw_value)
           when :datetime
             Time.zone.parse(raw_value.to_s)
+          when :hash
+            raw_value.is_a?(Hash) ? raw_value : {}
           else
             raw_value
           end
@@ -118,7 +122,7 @@ module SpreeCmCommissioner
       end
 
       # Validates only new assignments (raw JSON values) for type safety
-      def define_metadata_validation(column_name, key, type) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+      def define_metadata_validation(column_name, key, type) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity,Metrics/AbcSize
         case type
         when :boolean
           validates key, inclusion: { in: [true, false] }, allow_nil: true
@@ -160,6 +164,14 @@ module SpreeCmCommissioner
               errors.add(key, 'is not a valid datetime')
             end
           end
+        when :hash
+          validate do
+            metadata = send(column_name) || {}
+            raw_value = metadata[key.to_s]
+            next if raw_value.nil?
+
+            errors.add(key, 'must be a hash') unless raw_value.is_a?(Hash)
+          end
         end
       end
     end

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

@@ -12,9 +12,6 @@ module SpreeCmCommissioner
       preference :brand_primary_color, :string, default: ''
       preference :redirect_target_host, :string, default: ''
       preference :redirect_excluded_paths, :string, default: ''
-      preference :facebook, :string, default: ''
-      preference :twitter, :string, default: ''
-      preference :instagram, :string, default: ''
     end
   end
 end

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

@@ -35,12 +35,6 @@ module SpreeCmCommissioner
                to: :options
     end
 
-    # Override variant.rb to return cached formatted options text, avoiding repeated database queries.
-    # Falls back to database queries & computing the format if preload data is unavailable.
-    def options_text
-      @options_text ||= public_metadata[:preload_options_text].presence || Spree::Variants::VisableOptionsPresenter.new(self).to_sentence
-    end
-
     def options
       @options ||= VariantOptions.new(self)
     end
@@ -111,7 +105,7 @@ module SpreeCmCommissioner
       # Precomputes the human-readable format (e.g., "Red, 256GB") to avoid
       # repeated formatting and association queries.
       # Example: {"color" => "red", "storage" => "256GB"} - option_type_name => option_value_name pairs
-      self.public_metadata[:preload_options_text] = Spree::Variants::VisableOptionsPresenter.new(self).to_sentence
+      self.public_metadata[:preload_options_text] = Spree::Variants::VisibleOptionsPresenter.new(self).to_sentence
     end
 
     def set_options_to_public_metadata!

data/app/models/spree_cm_commissioner/guest.rb

@@ -3,6 +3,8 @@ module SpreeCmCommissioner
   class Guest < SpreeCmCommissioner::Base # rubocop:disable Metrics/ClassLength
     include SpreeCmCommissioner::KycBitwise
     include SpreeCmCommissioner::PhoneNumberSanitizer
+    include SpreeCmCommissioner::StoreMetadata
+    include SpreeCmCommissioner::Integrations::IntegrationMappable
 
     delegate :kyc, to: :line_item, allow_nil: true
     delegate :allowed_upload_later?, to: :line_item, allow_nil: true
@@ -212,9 +214,20 @@ module SpreeCmCommissioner
     end
 
     def qr_data
+      return external_qr_data if external_qr_data.present?
+
       token
     end
 
+    # QR data for check-in. If external_wins? is true, use their QR data (they have their own check-in system).
+    # Otherwise, use our system's QR data. Only applicable to models with QR support (e.g., line_item, guest).
+    def external_qr_data
+      return nil if line_item.nil? || !line_item.integration?
+
+      mapping = external_wins_integration_mappings.first
+      mapping.external_qr_data if mapping.present?
+    end
+
     def current_age
       return nil if dob.nil?
 

data/app/models/spree_cm_commissioner/integration.rb

@@ -0,0 +1,29 @@
+module SpreeCmCommissioner
+  class Integration < Base
+    include StoreMetadata
+
+    enum status: { inactive: 0, active: 1, paused: 2 }
+    enum conflict_strategy: { newest_wins: 0, internal_wins: 1, external_wins: 2, manual_resolution: 3 }
+
+    belongs_to :tenant, class_name: 'SpreeCmCommissioner::Tenant', optional: true
+    belongs_to :vendor, class_name: 'Spree::Vendor', optional: false, inverse_of: :integration
+
+    has_many :integration_mappings, class_name: 'SpreeCmCommissioner::IntegrationMapping', dependent: :destroy, inverse_of: :integration
+    has_many :integration_sync_sessions, class_name: 'SpreeCmCommissioner::IntegrationSyncSession', dependent: :destroy, inverse_of: :integration
+
+    validates :incremental_sync_interval_seconds, presence: true, numericality: { only_integer: true, greater_than: 0, less_than_or_equal_to: 3600 }
+    validates :full_sync_interval_hours, presence: true, numericality: { only_integer: true, greater_than: 0, less_than_or_equal_to: 168 }
+
+    def sync_manager
+      raise NotImplementedError, 'Subclasses must implement the sync_manager method'
+    end
+
+    def restock_external_inventory!(_order, _line_items)
+      raise NotImplementedError, 'Subclasses must implement the restock_external_inventory! method'
+    end
+
+    def unstock_external_inventory!(_order, _line_items)
+      raise NotImplementedError, 'Subclasses must implement the unstock_external_inventory! method'
+    end
+  end
+end

data/app/models/spree_cm_commissioner/integration_mapping.rb

@@ -0,0 +1,41 @@
+module SpreeCmCommissioner
+  class IntegrationMapping < Base
+    include StoreMetadata
+
+    enum status: { active: 0, archived: 1 }
+
+    # polymorphic (Spree::Taxon, Spree::Product, Spree::Variant, Spree::Vendor)
+    belongs_to :internal, polymorphic: true, optional: false
+    belongs_to :integration, class_name: 'SpreeCmCommissioner::Integration', inverse_of: :integration_mappings, optional: false
+
+    validates :external_id, presence: true, uniqueness: { scope: %i[integration_id internal_type internal_id date] }
+    validate :validate_internal_exists, if: -> { internal_type.present? && internal_id.present? }
+
+    # QR data for check-in. If external_wins? is true, use their QR data (they have their own check-in system).
+    # Otherwise, use our system's QR data. Only applicable to map with internal that has QR support (e.g., line_item, guest).
+    store_public_metadata :external_qr_data, :string, default: nil
+
+    def mark_as_archived!
+      self.status = :archived
+      self.last_synced_at = Time.zone.now
+
+      save!
+    end
+
+    def mark_as_active!(external_payload:)
+      self.external_payload = external_payload
+      self.last_synced_at = Time.zone.now
+      self.status = :active
+
+      save!
+    end
+
+    private
+
+    def validate_internal_exists
+      return if internal_type.safe_constantize&.exists?(id: internal_id)
+
+      errors.add(:internal, "record (#{internal_type}##{internal_id}) does not exist")
+    end
+  end
+end

data/app/models/spree_cm_commissioner/integration_sync_session.rb

@@ -0,0 +1,15 @@
+module SpreeCmCommissioner
+  class IntegrationSyncSession < Base
+    include StoreMetadata
+
+    enum status: { pending: 0, in_progress: 1, completed: 2, failed: 3, canceled: 4 }
+    enum :sync_type, {
+      full: 0, # on initial setup or periodic complete refresh
+      incremental: 1, # on scheduled intervals to fetch recent changes
+      webhook_triggered: 2 # immediately when an external webhook event is received
+    }, prefix: true
+
+    belongs_to :tenant, class_name: 'SpreeCmCommissioner::Tenant', optional: true
+    belongs_to :integration, class_name: 'SpreeCmCommissioner::Integration', inverse_of: :integration_sync_sessions, optional: false
+  end
+end

data/app/models/spree_cm_commissioner/integrations/stadium_x_v1.rb

@@ -0,0 +1,37 @@
+class SpreeCmCommissioner::Integrations::StadiumXV1 < SpreeCmCommissioner::Integration
+  store_private_metadata :public_key, :string
+  store_private_metadata :private_key, :string
+  store_private_metadata :base_url, :string # e.g. 'https://api.stadiumx.com'
+
+  # override
+  def sync_manager
+    SpreeCmCommissioner::Integrations::StadiumXV1::SyncManager.new(
+      integration: self,
+      client: client
+    )
+  end
+
+  # override
+  def unstock_external_inventory!(order, line_items)
+    result = SpreeCmCommissioner::Integrations::StadiumXV1::Inventory::UnstockInventory.new.call(
+      integration: self,
+      order: order,
+      line_items: line_items
+    )
+
+    raise SpreeCmCommissioner::Integrations::SyncError, result.error unless result.success?
+  end
+
+  # override
+  def restock_external_inventory!(_order, _line_items)
+    raise SpreeCmCommissioner::Integrations::SyncError, 'Ticket cannot be cancelled'
+  end
+
+  def client
+    SpreeCmCommissioner::Integrations::StadiumXV1::ExternalClient::Client.new(
+      public_key: public_key,
+      private_key: private_key,
+      base_url: base_url
+    )
+  end
+end

data/app/models/spree_cm_commissioner/inventory_item.rb

@@ -56,8 +56,12 @@ module SpreeCmCommissioner
       "inventory:#{id}"
     end
 
+    def quantity_in_redis
+      SpreeCmCommissioner.inventory_redis_pool.with { |redis| redis.get(redis_key).to_i }
+    end
+
     def adjust_quantity_in_redis(quantity)
-      SpreeCmCommissioner.redis_pool.with do |redis|
+      SpreeCmCommissioner.inventory_redis_pool.with do |redis|
         # Always update Redis cache, even if it doesn't exist yet.
         # This prevents admin adjustments from being lost when cache is later initialized.
         script = <<~LUA

data/app/models/spree_cm_commissioner/line_item_decorator.rb

@@ -72,10 +72,12 @@ module SpreeCmCommissioner
     def self.include_modules(base)
       base.include Spree::Core::NumberGenerator.new(prefix: 'L')
       base.include SpreeCmCommissioner::StoreMetadata
+      base.include SpreeCmCommissioner::LineItemIntegration
       base.include SpreeCmCommissioner::LineItemDurationable
       base.include SpreeCmCommissioner::LineItemsFilterScope
       base.include SpreeCmCommissioner::LineItemGuestsConcern
       base.include SpreeCmCommissioner::LineItemTransitable
+      base.include SpreeCmCommissioner::Integrations::IntegrationMappable
       base.include SpreeCmCommissioner::ProductType
       base.include SpreeCmCommissioner::ProductDelegation
       base.include SpreeCmCommissioner::KycBitwise
@@ -198,11 +200,21 @@ module SpreeCmCommissioner
     end
 
     def qr_data
+      return external_qr_data if external_qr_data.present?
       return nil if order.nil?
 
       "#{order.number}-#{order.token}-L#{id}"
     end
 
+    # QR data for check-in. If external_wins? is true, use their QR data (they have their own check-in system).
+    # Otherwise, use our system's QR data. Only applicable to models with QR support (e.g., line_item, guest).
+    def external_qr_data
+      return nil unless integration?
+
+      mapping = external_wins_integration_mappings.first
+      mapping.external_qr_data if mapping.present?
+    end
+
     def generate_completion_steps
       generate_completion_steps!
       true
@@ -255,7 +267,7 @@ module SpreeCmCommissioner
     end
 
     def update_vendor_id
-      self.vendor_id = variant.vendor_id
+      self.vendor_id = variant&.vendor_id
     end
 
     def subscription?

data/app/models/spree_cm_commissioner/option_type_decorator.rb

@@ -22,6 +22,14 @@ module SpreeCmCommissioner
       def base.rules_option_type
         Spree::OptionType.find_by(name: RULES_OPTION_TYPE_NAME)
       end
+
+      # override
+      def base.color
+        Spree::OptionType.find_or_create_by!(name: 'color') do |ot|
+          ot.presentation = 'Color'
+          ot.kind = :variant
+        end
+      end
     end
 
     private

data/app/models/spree_cm_commissioner/option_value_decorator.rb

@@ -3,6 +3,36 @@ module SpreeCmCommissioner
     def self.prepended(base)
       base.include SpreeCmCommissioner::OptionValueAttrType
       base.has_many :option_value_vehicles, class_name: 'SpreeCmCommissioner::OptionValueVehicle', foreign_key: :option_value_id, dependent: :destroy
+
+      base.validates :name, presence: true, uniqueness: { scope: :option_type_id, case_sensitive: -> { name_case_sensitive? } }
+
+      # Ticket types: case-SENSITIVE matching (preserve external API casing)
+      # Other types: case-INSENSITIVE storage (prevent duplicates from varying API casing; presentation keeps original)
+      def base.find_or_create_by_name!(option_type, name)
+        name = name.strip
+        if option_type.ticket_type?
+          where(option_type_id: option_type.id, name: name).first_or_create! do |ov|
+            ov.option_type = option_type
+            ov.name = name
+            ov.presentation = name
+          end
+        else
+          where(option_type_id: option_type.id).where('LOWER(name) = ?', name.downcase).first_or_create! do |ov|
+            ov.option_type = option_type
+            ov.name = name.downcase
+            ov.presentation = name
+          end
+        end
+      end
+    end
+
+    # Override Spree's name validation to make it case-sensitive only for ticket-type option values.
+    # Spree's default is case-insensitive (false), but we enforce case-sensitivity (true) for ticket-types.
+    # Which means ticket type "STANDARD" and "Standard" are different option values.
+    def name_case_sensitive?
+      return true if ticket_type?
+
+      false
     end
 
     def display_icon
@@ -14,5 +44,9 @@ module SpreeCmCommissioner
 end
 
 unless Spree::OptionValue.included_modules.include?(SpreeCmCommissioner::OptionValueDecorator)
+  # remove all name validations so we can override them in the decorator.
+  Spree::OptionValue._validators.reject! { |key, _| key == :name }
+  Spree::OptionValue._validate_callbacks.each { |c| c.filter.attributes.delete(:name) if c.filter.respond_to?(:attributes) }
+
   Spree::OptionValue.prepend SpreeCmCommissioner::OptionValueDecorator
 end

data/app/models/spree_cm_commissioner/order_decorator.rb

@@ -3,6 +3,7 @@ module SpreeCmCommissioner
     def self.prepended(base) # rubocop:disable Metrics/MethodLength
       base.include SpreeCmCommissioner::StoreMetadata
       base.include SpreeCmCommissioner::PhoneNumberSanitizer
+      base.include SpreeCmCommissioner::OrderIntegration
       base.include SpreeCmCommissioner::OrderSeatable
       base.include SpreeCmCommissioner::OrderStateMachine
       base.include SpreeCmCommissioner::RouteOrderCountable

data/app/models/spree_cm_commissioner/product_decorator.rb

@@ -8,6 +8,7 @@ module SpreeCmCommissioner
       base.include SpreeCmCommissioner::TenantUpdatable
       base.include SpreeCmCommissioner::ServiceType
       base.include SpreeCmCommissioner::ServiceRecommendations
+      base.include SpreeCmCommissioner::Integrations::IntegrationMappable
 
       base.has_many :variant_kind_option_types, -> { where(kind: :variant).order(:position) },
                     through: :product_option_types, source: :option_type
@@ -89,7 +90,7 @@ module SpreeCmCommissioner
                                   request_to_book: 8
                                 }
 
-      base.multi_tenant :tenant, class_name: 'SpreeCmCommissioner::Tenant'
+      base.belongs_to :tenant, class_name: 'SpreeCmCommissioner::Tenant'
       base.before_save :set_tenant
     end
 
@@ -142,7 +143,7 @@ module SpreeCmCommissioner
     end
 
     def set_event_id
-      self.event_id = taxons.select(&:event?).first&.parent_id
+      self.event_id ||= taxons.select(&:event?).first&.parent_id
     end
 
     def update_variants_vendor_id

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

@@ -12,7 +12,7 @@ module SpreeCmCommissioner
         keys = inventory_items.map { |item| "inventory:#{item.id}" }
         return [] unless keys.any?
 
-        counts = SpreeCmCommissioner.redis_pool.with { |redis| redis.mget(*keys) }
+        counts = SpreeCmCommissioner.inventory_redis_pool.with { |redis| redis.mget(*keys) }
         inventory_items.map.with_index do |inventory_item, i|
           ::SpreeCmCommissioner::CachedInventoryItem.new(
             inventory_key: keys[i],
@@ -32,7 +32,7 @@ module SpreeCmCommissioner
 
         # Use atomic SET NX to prevent race condition where multiple concurrent reads
         # initialize cache with stale values. Only the first thread wins.
-        SpreeCmCommissioner.redis_pool.with do |redis|
+        SpreeCmCommissioner.inventory_redis_pool.with do |redis|
           redis.eval(set_nx_with_expiry_script, keys: [key], argv: [inventory_item.quantity_available, inventory_item.redis_expired_in])
         end
 

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

@@ -51,13 +51,13 @@ module SpreeCmCommissioner
       end
 
       def unstock(keys, quantities)
-        SpreeCmCommissioner.redis_pool.with do |redis|
+        SpreeCmCommissioner.inventory_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|
+        SpreeCmCommissioner.inventory_redis_pool.with do |redis|
           redis.eval(restock_redis_script, keys: keys, argv: quantities)
         end.positive?
       end

data/app/models/spree_cm_commissioner/taxon_decorator.rb

@@ -5,6 +5,7 @@ module SpreeCmCommissioner
       base.include SpreeCmCommissioner::TaxonKind
       base.include SpreeCmCommissioner::ParticipationTypeBitwise
       base.include SpreeCmCommissioner::EventMetadata
+      base.include SpreeCmCommissioner::Integrations::IntegrationMappable
 
       base.has_many :taxon_vendors, class_name: 'SpreeCmCommissioner::TaxonVendor'
       base.has_many :vendors, through: :taxon_vendors

data/app/models/spree_cm_commissioner/taxonomy_decorator.rb

@@ -3,9 +3,21 @@ module SpreeCmCommissioner
     def self.prepended(base)
       base.include SpreeCmCommissioner::TaxonKind
 
+      def base.events
+        ActiveRecord::Base.connected_to(role: :writing) do
+          events = Spree::Taxonomy.find_or_create_by(name: 'Events', store: Spree::Store.default)
+          events.kind = :event
+          events.save if events.changed?
+          events
+        end
+      end
+
       def base.businesses
         ActiveRecord::Base.connected_to(role: :writing) do
-          Spree::Taxonomy.find_or_create_by(name: 'Businesses', kind: 'category', store: Spree::Store.default)
+          businesses = Spree::Taxonomy.find_or_create_by(name: 'Businesses', store: Spree::Store.default)
+          businesses.kind = :category
+          businesses.save if businesses.changed?
+          businesses
         end
       end
     end