spree_cm_commissioner 2.5.0.pre.pre6 → 2.5.0.pre.pre8

data/app/controllers/spree/admin/integration_mappings_controller.rb

@@ -1,21 +0,0 @@
-module Spree
-  module Admin
-    class IntegrationMappingsController < Spree::Admin::BaseController
-      helper SpreeCmCommissioner::ExternalIntegrationsHelper
-      before_action :load_integration
-
-      def index
-        @mappings = @integration.integration_mappings
-                                .order(updated_at: :desc)
-                                .page(params[:page])
-                                .per(params[:per_page] || 25)
-      end
-
-      private
-
-      def load_integration
-        @integration ||= SpreeCmCommissioner::Integration.find(params[:integration_id])
-      end
-    end
-  end
-end

data/app/controllers/spree/admin/integration_sessions_controller.rb

@@ -1,21 +0,0 @@
-module Spree
-  module Admin
-    class IntegrationSessionsController < Spree::Admin::BaseController
-      helper SpreeCmCommissioner::ExternalIntegrationsHelper
-      before_action :load_integration
-
-      def index
-        @sync_sessions = @integration.integration_sync_sessions
-                                     .order(created_at: :desc)
-                                     .page(params[:page])
-                                     .per(params[:per_page] || 25)
-      end
-
-      private
-
-      def load_integration
-        @integration ||= SpreeCmCommissioner::Integration.find(params[:integration_id])
-      end
-    end
-  end
-end

data/app/controllers/spree/admin/integrations_controller.rb

@@ -1,83 +0,0 @@
-module Spree
-  module Admin
-    class IntegrationsController < Spree::Admin::ResourceController
-      helper SpreeCmCommissioner::ExternalIntegrationsHelper
-      before_action :load_form_collections, only: %i[new create edit update]
-      before_action :load_integration, only: %i[enqueue_polling]
-
-      def index
-        @integrations = model_class.all
-      end
-
-      def enqueue_polling
-        sync_type = params[:sync_type].presence || :full
-
-        if @integration.active?
-          SpreeCmCommissioner::Integrations::PollingJob.perform_later(
-            integration_id: @integration.id,
-            sync_type: sync_type
-          )
-          flash[:success] = Spree.t('admin.integration_sync_enqueued')
-        else
-          flash[:error] = Spree.t('admin.integration_inactive')
-        end
-
-        redirect_to admin_integration_sessions_path(@integration)
-      end
-
-      # override
-      def model_class
-        SpreeCmCommissioner::Integration
-      end
-
-      # override
-      def collection_url(options = {})
-        admin_integrations_url(options)
-      end
-
-      private
-
-      def permitted_resource_params
-        params.require(:spree_cm_commissioner_integration).permit(
-          :name,
-          :type,
-          :status,
-          :conflict_strategy,
-          :incremental_sync_interval_seconds,
-          :full_sync_interval_hours,
-          :tenant_id,
-          :vendor_id,
-          public_metadata: {},
-          private_metadata: {}
-        )
-      end
-
-      def load_integration
-        @integration ||= SpreeCmCommissioner::Integration.find(params[:id])
-      end
-
-      def load_form_collections
-        @integration_type_options ||= integration_type_options
-        @status_options ||= enum_to_options(SpreeCmCommissioner::Integration.statuses)
-        @conflict_strategy_options ||= enum_to_options(SpreeCmCommissioner::Integration.conflict_strategies)
-        @tenants ||= SpreeCmCommissioner::Tenant.select(:id, :name).order(:name)
-        @vendors ||= Spree::Vendor.select(:id, :name).order(:name)
-      end
-
-      def enum_to_options(enum_hash)
-        enum_hash.keys.map { |key| [key.humanize, key] }
-      end
-
-      def integration_type_options
-        files = Dir[SpreeCmCommissioner::Engine.root.join('app/models/spree_cm_commissioner/integrations/*.rb')]
-
-        return [[Spree.t(:type), 'SpreeCmCommissioner::Integration']] if files.blank?
-
-        files.map do |path|
-          class_name = "SpreeCmCommissioner::Integrations::#{File.basename(path, '.rb').camelize}"
-          [class_name, class_name]
-        end.sort_by(&:first)
-      end
-    end
-  end
-end

data/app/controllers/spree/api/v2/storefront/event_matches_controller.rb

@@ -1,15 +0,0 @@
-module Spree
-  module Api
-    module V2
-      module Storefront
-        class EventMatchesController < TaxonsController
-          private
-
-          def collection_finder
-            SpreeCmCommissioner::Events::FindMatches
-          end
-        end
-      end
-    end
-  end
-end

data/app/errors/spree_cm_commissioner/integrations/external_client_error.rb

@@ -1,10 +0,0 @@
-module SpreeCmCommissioner::Integrations
-  class ExternalClientError < StandardError
-    attr_reader :status_code
-
-    def initialize(message, status_code = nil)
-      super(message)
-      @status_code = status_code
-    end
-  end
-end

data/app/errors/spree_cm_commissioner/integrations/sync_error.rb

@@ -1,4 +0,0 @@
-module SpreeCmCommissioner::Integrations
-  class SyncError < StandardError
-  end
-end

data/app/finders/spree_cm_commissioner/events/find_matches.rb

@@ -1,15 +0,0 @@
-module SpreeCmCommissioner
-  module Events
-    class FindMatches < ::Spree::BaseFinder
-      # currently, there is no way to determine if an event is a match yet.
-      # this finder returns all events that have active integration mappings (synced from external systems like StadiumX)
-      # as a temporary workaround to filter out non-match events.
-      def execute
-        scope.joins(:integration_mappings).where(
-          kind: :event,
-          integration_mappings: { status: :active }
-        ).distinct
-      end
-    end
-  end
-end

data/app/helpers/spree_cm_commissioner/external_integrations_helper.rb

@@ -1,58 +0,0 @@
-module SpreeCmCommissioner
-  module ExternalIntegrationsHelper
-    def integration_status_badge(status)
-      badge_class = case status.to_s
-                    when 'active' then 'badge-success'
-                    when 'paused' then 'badge-warning'
-                    else 'badge-secondary'
-                    end
-
-      content_tag(:span, status.to_s.humanize, class: "badge badge-pill #{badge_class}")
-    end
-
-    def integration_conflict_strategy_badge(strategy)
-      content_tag(:span, strategy.to_s.humanize, class: 'badge badge-pill badge-secondary')
-    end
-
-    def integration_interval_badge(value, unit)
-      content_tag(:span, "#{value}#{unit}", class: 'badge badge-pill badge-info')
-    end
-
-    def integration_base_url_link(url)
-      if url.present?
-        link_to url, url, target: '_blank', rel: 'noopener', class: 'text-decoration-underline'
-      else
-        content_tag(:span, '—', class: 'text-muted')
-      end
-    end
-
-    def integration_mapping_internal_link(mapping)
-      return mapping.internal_id if mapping.internal.blank?
-
-      begin
-        case mapping.internal_type
-        when 'Spree::Taxon'
-          taxon = mapping.internal
-          taxonomy_id = taxon.taxonomy_id || taxon.taxonomy&.id
-          if taxonomy_id
-            link_to mapping.internal_id,
-                    edit_admin_taxonomy_taxon_path(taxonomy_id, taxon.id),
-                    class: 'text-primary'
-          end
-        when 'Spree::Product'
-          link_to mapping.internal_id, edit_admin_product_path(mapping.internal), class: 'text-primary'
-        when 'Spree::Variant'
-          link_to mapping.internal_id, edit_admin_product_variant_path(mapping.internal.product_id, mapping.internal), class: 'text-primary'
-        when 'Spree::Vendor'
-          link_to mapping.internal_id, edit_admin_vendor_path(mapping.internal), class: 'text-primary'
-        else
-          # Try polymorphic route as fallback
-          link_to mapping.internal_id, [:edit, :admin, mapping.internal], class: 'text-primary'
-        end
-      rescue StandardError => e
-        Rails.logger.warn("Failed to generate link for mapping #{mapping.id}: #{e.message}")
-        mapping.internal_id
-      end
-    end
-  end
-end

data/app/jobs/spree_cm_commissioner/integrations/base_job.rb

@@ -1,39 +0,0 @@
-module SpreeCmCommissioner
-  module Integrations
-    # Base class for integration jobs
-    #
-    # Provides common error handling and alerting functionality for all integration jobs.
-    # Subclasses should implement their own perform logic and call the appropriate
-    # error handler methods.
-    class BaseJob < ApplicationJob
-      queue_as :integration
-
-      protected
-
-      # Handle error by logging and sending alert
-      # @param label [String] The error label for logging
-      # @param error [StandardError] The error that occurred
-      # @param data [Hash] Additional context data (e.g., sync_type, match_id, event_type)
-      def handle_error(label:, error:, data: {})
-        error_message = "#{error.class.name}: #{error.message}"
-
-        # Log the error with structured data
-        CmAppLogger.error(
-          label: label,
-          data: data.merge(
-            message: error_message,
-            backtrace: error.backtrace
-          )
-        )
-
-        # Send alert via Telegram
-        TelegramAlerts::IntegrationSyncFailureJob.perform_later(
-          error_message: error_message,
-          data: data
-        )
-
-        error_message
-      end
-    end
-  end
-end

data/app/jobs/spree_cm_commissioner/integrations/polling_job.rb

@@ -1,53 +0,0 @@
-module SpreeCmCommissioner
-  module Integrations
-    # Job that performs the actual polling (syncing) for a specific integration
-    #
-    # This job is enqueued by PollingSchedulerJob and handles:
-    # - Full syncs: Complete refresh of all data
-    # - Incremental syncs: Fetch only recent changes
-    # - Webhook syncs: Real-time event processing (triggered externally)
-    #
-    # Each integration type (StadiumXV1, LarrytaV1, etc.) must implement
-    # a sync_manager that responds to sync_full!, sync_incremental!, and sync_webhook!
-    class PollingJob < BaseJob
-      # Perform the integration pull
-      # @param integration_id [Integer] The integration ID
-      # @param sync_type [String] The sync type: 'full', 'incremental', or 'webhook_triggered'
-      # @param event_type [String] Optional event type for webhook syncs
-      # @param event_data [Hash] Optional event data for webhook syncs
-      def perform(options)
-        integration_id = options[:integration_id]
-        sync_type = options[:sync_type]
-        event_type = options[:event_type]
-        event_data = options[:event_data]
-        integration = SpreeCmCommissioner::Integration.find(integration_id)
-
-        # integration is no longer active, skip processing.
-        return unless integration.active?
-
-        SpreeCmCommissioner::Integrations::Polling.new.call(
-          integration: integration,
-          sync_type: sync_type,
-          event_type: event_type,
-          event_data: event_data
-        )
-      rescue StandardError => e
-        handle_sync_error(e, options)
-        raise
-      end
-
-      private
-
-      # Handle sync errors and alert
-      # @param error [StandardError] The error that occurred
-      # @param options [Hash] The options passed to perform
-      def handle_sync_error(error, options)
-        handle_error(
-          label: 'Integrations::IntegrationPullJob#perform Sync failed',
-          error: error,
-          data: options
-        )
-      end
-    end
-  end
-end

data/app/jobs/spree_cm_commissioner/integrations/polling_scheduler_job.rb

@@ -1,30 +0,0 @@
-module SpreeCmCommissioner
-  module Integrations
-    # Scheduler job that runs periodically to enqueue integration polling jobs
-    #
-    # This job is responsible for:
-    # - Running full syncs every 24 hours
-    # - Running incremental syncs every 10 seconds
-    # - Webhook syncs are triggered externally (not scheduled here)
-    #
-    # The job queries all active integrations and enqueues appropriate pull jobs
-    # based on their last sync time and sync type configuration.
-    class PollingSchedulerJob < BaseJob
-      def perform
-        SpreeCmCommissioner::Integrations::PollingScheduler.new.call
-      rescue StandardError => e
-        handle_scheduler_error(e)
-        raise
-      end
-
-      private
-
-      def handle_scheduler_error(error)
-        handle_error(
-          label: 'Integrations::PollingSchedulerJob#perform Error scheduling integration pulls',
-          error: error
-        )
-      end
-    end
-  end
-end

data/app/jobs/spree_cm_commissioner/telegram_alerts/integration_sync_failure_job.rb

@@ -1,17 +0,0 @@
-module SpreeCmCommissioner
-  module TelegramAlerts
-    class IntegrationSyncFailureJob < ApplicationJob
-      queue_as :telegram_bot
-
-      # Handle error by logging and sending alert
-      # @param error_message [String] The error message
-      # @param data [Hash] Additional context data (e.g., sync_type, match_id, event_type)
-      def perform(options)
-        SpreeCmCommissioner::TelegramAlerts::IntegrationSyncFailure.call(
-          error_message: options[:error_message],
-          data: options[:data] || {}
-        )
-      end
-    end
-  end
-end

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

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

@@ -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) %>