spree_cm_commissioner 2.5.0.pre.pre7 → 2.5.0.pre.pre8

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

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

@@ -1,33 +0,0 @@
-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/spree_cm_commissioner/integration.rb

@@ -1,29 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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/overrides/spree/admin/shared/sub_menu/_integrations/external_integrations.html.erb.deface

@@ -1,6 +0,0 @@
-<!-- insert_bottom "[data-hook='admin_integrations']" -->
-
-<%= tab :integrations,
-        match_path: '/integrations',
-        label: Spree.t('admin.external_integrations_title'),
-        if: can?(:manage, SpreeCmCommissioner::Integration) %>

data/app/services/spree_cm_commissioner/integrations/base/sync_manager.rb

@@ -1,69 +0,0 @@
-module SpreeCmCommissioner::Integrations::Base
-  class SyncManager
-    def initialize(integration:, client:)
-      @integration = integration
-      @client = client
-      @sync_session = nil
-    end
-
-    # Perform a full synchronization (initial setup or complete refresh)
-    # Override in subclass and use run_execution to wrap your sync logic
-    # @return [SpreeCmCommissioner::IntegrationSyncSession] The sync session record
-    # @raise [SyncError] if sync fails
-    def sync_full!
-      raise NotImplementedError, "#{self.class.name} must implement #sync_full!"
-    end
-
-    # Perform an incremental synchronization (delta updates)
-    # Override in subclass and use run_execution to wrap your sync logic
-    # @return [SpreeCmCommissioner::IntegrationSyncSession] The sync session record
-    # @raise [SyncError] if sync fails or not supported
-    def sync_incremental!
-      raise NotImplementedError, "#{self.class.name} must implement #sync_incremental!"
-    end
-
-    # Perform a webhook-triggered synchronization (real-time event)
-    # Override in subclass and use run_execution to wrap your sync logic
-    # @param event_type [String] The type of event (e.g., 'match.updated', 'ticket.created')
-    # @param event_data [Hash] The event payload
-    # @return [SpreeCmCommissioner::IntegrationSyncSession] The sync session record
-    # @raise [SyncError] if sync fails or not supported
-    def sync_webhook!(event_type:, event_data:)
-      raise NotImplementedError, "#{self.class.name} must implement #sync_webhook!"
-    end
-
-    protected
-
-    # Wrapper for sync execution that handles session creation and persistence
-    # Strategies handle errors internally and always return a SyncResult object
-    # This method never throws errors - it always returns a sync session
-    #
-    # @param sync_type [Symbol] The type of sync (:full, :incremental, :webhook_triggered)
-    # @yield Block containing the actual sync logic, must return a SyncResult object
-    # @return [SpreeCmCommissioner::IntegrationSyncSession] The sync session record
-    def run_execution(sync_type)
-      @sync_session = create_sync_session(sync_type)
-      sync_result = yield
-
-      @sync_session.update!(
-        status: sync_result.success? ? :completed : :failed,
-        ended_at: Time.zone.now,
-        sync_result: sync_result.to_h
-      )
-
-      @sync_session
-    end
-
-    private
-
-    def create_sync_session(sync_type)
-      SpreeCmCommissioner::IntegrationSyncSession.create!(
-        integration: @integration,
-        tenant: @integration.tenant,
-        status: :in_progress,
-        started_at: Time.zone.now,
-        sync_type: sync_type
-      )
-    end
-  end
-end

data/app/services/spree_cm_commissioner/integrations/base/sync_result.rb

@@ -1,183 +0,0 @@
-module SpreeCmCommissioner::Integrations::Base
-  # Base class for sync results
-  # Provides standardized tracking methods for API calls and record changes
-  #
-  # Persists to database as JSONB in CmIntegrationSyncSession#sync_result column
-  # Enables comprehensive sync monitoring and debugging:
-  #   - Track success/failure status
-  #   - Monitor API call counts and patterns
-  #   - Audit record creation/update counts
-  #   - Capture error details with automatic error codes
-  #   - Generate sync performance reports
-  #   - Identify patterns in failed syncs
-  #
-  # Example persisted results:
-  #
-  # Success:
-  #   {
-  #     "metrics": { "match": { "created": 2, "updated": 1, "total": 3 } },
-  #     "api_calls": { "get_matches": 1, "get_match_details": 3 }
-  #   }
-  #
-  # Failure:
-  #   {
-  #     "metrics": { "match": { "created": 1, "total": 1 } },
-  #     "api_calls": { "get_matches": 1 },
-  #     "error": { "message": "Failed to sync matches: Connection timeout", "code": "ExternalClientError" }
-  #   }
-  class SyncResult
-    def initialize
-      @metrics = {}
-      @api_calls = {}
-      @error = nil
-    end
-
-    # Track API call with block
-    # Automatically increments the call count and executes the block
-    # Failed calls (exceptions) are not counted
-    #
-    # @param call_name [String] Name of the API call (e.g., 'get_matches', 'get_zones')
-    # @yield Block containing the API call
-    # @return Result of the block
-    #
-    # Example:
-    #   external_matches = track_api_call('get_matches') { @client.get_matches! }
-    def track_api_call(call_name)
-      @api_calls[call_name] = (@api_calls[call_name] || 0) + 1
-      yield
-    end
-
-    # Track synced record with block
-    # Automatically detects if record was created or updated based on new_record? and saved_changes
-    #
-    # @param type [Symbol, String] Type of record (e.g., :match, :zone)
-    # @param record [Object] The record being synced (must respond to new_record? and saved_changes)
-    # @yield Block containing the save/update logic
-    # @return Result of the block
-    #
-    # Example:
-    #   track_synced_record(:match, match_taxon) do
-    #     match_taxon.assign_attributes(name: 'ISI Dangkorsenchey FC vs ANGKOR TIGER FC')
-    #     match_taxon.save!
-    #   end
-    def track_synced_record(type, record)
-      was_new = record.new_record?
-      result = yield
-
-      if was_new
-        increment_metric(type, :created)
-      elsif record.saved_changes.any?
-        increment_metric(type, :updated)
-      end
-
-      result
-    end
-
-    # Track and sync record with explicit tracker object
-    # Provides a tracker object with helper methods for explicit save/tracking operations
-    #
-    # @param type [Symbol, String] Type of record (e.g., :league, :match, :zone, :variant)
-    # @param record [Object] The record being synced (must respond to new_record? and saved_changes)
-    # @yield Block receiving tracker object for explicit operations
-    # @return Result of the block
-    #
-    # Example:
-    #   track(:zone, product) do |tracker|
-    #     product.assign_attributes(name: 'Zone A', price: 100)
-    #     tracker.save_if_changed!(product)
-    #   end
-    def track(type, record)
-      tracker = RecordTracker.new(self, type, record)
-      yield tracker
-      tracker
-    end
-
-    # Helper class for explicit record tracking and saving
-    class RecordTracker
-      def initialize(sync_result, type, record)
-        @sync_result = sync_result
-        @type = type
-        @record = record
-        @was_new = record.new_record?
-      end
-
-      # Save record if it's new or has changes, and track the operation
-      # Automatically detects create vs update based on initial state
-      #
-      # @param record [Object] The record to save (defaults to the tracked record)
-      def save_if_changed!(record = @record)
-        return unless record.new_record? || record.changed?
-
-        record.save!
-
-        # Track based on initial state
-        if @was_new
-          @sync_result.increment_metric(@type, :created)
-        else
-          @sync_result.increment_metric(@type, :updated)
-        end
-      end
-    end
-
-    # Increment a metric counter
-    # Useful for tracking actions that don't fit the created/updated pattern
-    #
-    # @param type [Symbol, String] Type of metric (e.g., :match, :inventory)
-    # @param action [Symbol, String] Action performed (e.g., :archived, :adjustments)
-    # @param amount [Integer] Amount to increment by (default: 1)
-    #
-    # Example:
-    #   increment_metric(:match, :archived)                              # increment by 1
-    #   increment_metric(:inventory, :total_quantity_adjusted, 50)       # increment by 50
-    def increment_metric(type, action, amount = 1)
-      @metrics[type.to_sym] ||= {}
-      @metrics[type.to_sym][action.to_sym] ||= 0
-      @metrics[type.to_sym][action.to_sym] += amount
-
-      update_metric_total(type)
-    end
-
-    # Record error
-    # @param error [StandardError] The error that occurred
-    def record_error(error)
-      @error = {
-        message: error.message,
-        code: error.class.name.split('::').last
-      }
-    end
-
-    # Check if sync was successful
-    # @return [Boolean] True if no error, false otherwise
-    def success?
-      @error.nil?
-    end
-
-    # Serialize to hash for JSONB persistence
-    # @return [Hash] Serialized representation
-    def to_h
-      {
-        metrics: @metrics,
-        api_calls: @api_calls,
-        error: @error
-      }.tap do |hash|
-        hash.delete(:error) if @error.nil?
-        hash.delete(:metrics) if @metrics.empty?
-        hash.delete(:api_calls) if @api_calls.empty?
-      end
-    end
-
-    private
-
-    # Update total for a metric type
-    # Sums all numeric values in the metric hash
-    def update_metric_total(type)
-      metric = @metrics[type.to_sym]
-      return unless metric.is_a?(Hash)
-
-      # Calculate total from numeric values only
-      numeric_values = metric.select { |k, v| v.is_a?(Integer) && k != :total }
-      total = numeric_values.values.sum
-      metric[:total] = total if total.positive?
-    end
-  end
-end

data/app/services/spree_cm_commissioner/integrations/polling.rb

@@ -1,70 +0,0 @@
-module SpreeCmCommissioner
-  module Integrations
-    class Polling
-      def call(integration:, sync_type:, event_type: nil, event_data: nil)
-        sync_manager = integration.sync_manager
-
-        case sync_type.to_sym
-        when :full
-          perform_full_sync!(sync_manager, integration)
-        when :incremental
-          perform_incremental_sync!(sync_manager, integration)
-        when :webhook_triggered
-          perform_webhook_sync!(sync_manager, integration, event_type, event_data)
-        else
-          raise ArgumentError, "Unknown sync type: #{sync_type}"
-        end
-      end
-
-      private
-
-      # Perform a full sync
-      # @param sync_manager [Object] The integration's sync manager
-      # @param integration [SpreeCmCommissioner::Integration]
-      def perform_full_sync!(sync_manager, integration)
-        CmAppLogger.log(
-          label: 'Integrations::IntegrationPullJob#perform_full_sync! Starting full sync',
-          data: {
-            integration_id: integration.id,
-            integration_type: integration.class.name
-          }
-        ) do
-          sync_manager.sync_full!
-        end
-      end
-
-      # Perform an incremental sync
-      # @param sync_manager [Object] The integration's sync manager
-      # @param integration [SpreeCmCommissioner::Integration]
-      def perform_incremental_sync!(sync_manager, integration)
-        CmAppLogger.log(
-          label: 'Integrations::IntegrationPullJob#perform_incremental_sync! Starting incremental sync',
-          data: {
-            integration_id: integration.id,
-            integration_type: integration.class.name
-          }
-        ) do
-          sync_manager.sync_incremental!
-        end
-      end
-
-      # Perform a webhook-triggered sync
-      # @param sync_manager [Object] The integration's sync manager
-      # @param integration [SpreeCmCommissioner::Integration]
-      # @param event_type [String] The event type
-      # @param event_data [Hash] The event data
-      def perform_webhook_sync!(sync_manager, integration, event_type, event_data)
-        CmAppLogger.log(
-          label: 'Integrations::IntegrationPullJob#perform_webhook_sync! Starting webhook sync',
-          data: {
-            integration_id: integration.id,
-            integration_type: integration.class.name,
-            event_type: event_type
-          }
-        ) do
-          sync_manager.sync_webhook!(event_type: event_type, event_data: event_data)
-        end
-      end
-    end
-  end
-end

data/app/services/spree_cm_commissioner/integrations/polling_scheduler.rb

@@ -1,79 +0,0 @@
-module SpreeCmCommissioner
-  module Integrations
-    class PollingScheduler
-      BATCH_SIZE = 10 # Process integrations in batches to avoid overwhelming the server
-
-      def call
-        SpreeCmCommissioner::Integration.active.find_each(batch_size: BATCH_SIZE) do |integration|
-          if should_run_full_sync?(integration)
-            schedule_full_sync(integration)
-          elsif should_run_incremental_sync?(integration)
-            schedule_incremental_sync(integration)
-          end
-        end
-      end
-
-      private
-
-      # Check if full sync should run
-      # Run full sync if:
-      # 1. No full sync is running or pending (excluding sessions older than 1 hour)
-      # 2. No previous full sync exists, OR
-      # 3. Last full sync was more than the configured interval ago (eg. 24 hours ago)
-      def should_run_full_sync?(integration)
-        return false if integration.integration_sync_sessions
-                                   .where(sync_type: %i[full], status: %i[in_progress pending])
-                                   .exists?(['created_at > ?', 1.hour.ago])
-
-        last_full_sync = integration.integration_sync_sessions
-                                    .where(sync_type: :full, status: :completed)
-                                    .order(created_at: :desc)
-                                    .first
-
-        return true if last_full_sync.blank?
-
-        full_sync_interval = integration.full_sync_interval_hours.hours
-        (Time.current - last_full_sync.created_at) > full_sync_interval
-      end
-
-      # Check if incremental sync should run
-      # Ignore sessions older than 1 hour to allow retry of stalled syncs
-      def should_run_incremental_sync?(integration)
-        return false if integration.integration_sync_sessions
-                                   .where(sync_type: %i[full incremental], status: %i[in_progress pending])
-                                   .exists?(['created_at > ?', 1.hour.ago])
-
-        last_incremental_sync = integration.integration_sync_sessions
-                                           .where(sync_type: :incremental, status: :completed)
-                                           .order(created_at: :desc)
-                                           .first
-
-        # Run incremental sync if:
-        # 1. No previous incremental sync exists, OR
-        # 2. Last incremental sync was more than the configured interval ago (eg. 10 seconds ago)
-        return true if last_incremental_sync.blank?
-
-        incremental_sync_interval = integration.incremental_sync_interval_seconds.seconds
-        (Time.current - last_incremental_sync.created_at) > incremental_sync_interval
-      end
-
-      def schedule_full_sync(integration)
-        CmAppLogger.log(
-          label: 'Integrations::PollingSchedulerJob#schedule_full_sync Enqueued full sync',
-          data: { integration_id: integration.id, integration_type: integration.class.name }
-        ) do
-          PollingJob.perform_later(integration_id: integration.id, sync_type: :full)
-        end
-      end
-
-      def schedule_incremental_sync(integration)
-        CmAppLogger.log(
-          label: 'Integrations::PollingSchedulerJob#schedule_incremental_sync Enqueued incremental sync',
-          data: { integration_id: integration.id, integration_type: integration.class.name }
-        ) do
-          PollingJob.perform_later(integration_id: integration.id, sync_type: :incremental)
-        end
-      end
-    end
-  end
-end