spree_cm_commissioner 2.5.0.pre.pre1 → 2.5.0.pre.pre2

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

data/app/services/spree_cm_commissioner/integrations/stadium_x_v1/external_client/client.rb

@@ -1,152 +0,0 @@
-class SpreeCmCommissioner::Integrations::StadiumXV1
-  module ExternalClient
-    class Client
-      BASE_PATH = '/api/v1'.freeze
-      RATE_LIMIT = 100
-
-      def initialize(public_key:, private_key:, base_url:)
-        @public_key = public_key
-        @private_key = private_key
-        @base_url = base_url
-        @connection = build_connection
-      end
-
-      # Ticket Operations
-
-      # Get a specific ticket by ID
-      # @param id [String] The ticket ID
-      # @return [Resources::Ticket] The ticket object
-      def get_ticket!(id:)
-        response = @connection.get("#{BASE_PATH}/tickets/#{id}") do |req|
-          req.body = auth_params.to_json
-        end
-
-        handle_response(response, Resources::Ticket)
-      end
-
-      # Get all tickets for a specific user
-      # @param user_id [String] The user ID
-      # @return [Array<Resources::Ticket>] Array of ticket objects
-      def get_tickets_by_user!(user_id:)
-        response = @connection.get("#{BASE_PATH}/tickets/user/#{user_id}") do |req|
-          req.body = auth_params.merge(user_id: user_id).to_json
-        end
-
-        handle_response(response, Resources::Ticket, collection: true)
-      end
-
-      # Create a new ticket
-      # @param match_id [String] The match ID
-      # @param user_id [String] The user ID
-      # @param club_id [String] The club ID
-      # @param zone_id [String] The zone ID
-      # @param quantity [Integer] The quantity of tickets to create
-      # @return [Array<Resources::Ticket>] Array of created ticket objects
-      def create_tickets!(match_id:, user_id:, club_id:, zone_id:, quantity:)
-        params = {
-          match_id: match_id,
-          user_id: user_id,
-          club_id: club_id,
-          zone_id: zone_id,
-          quantity: quantity
-        }
-
-        response = @connection.post("#{BASE_PATH}/tickets") do |req|
-          req.body = auth_params.merge(params).to_json
-          req.headers['Content-Type'] = 'application/json'
-        end
-
-        handle_response(response, Resources::Ticket, collection: true)
-      end
-
-      # Match Operations
-
-      # Get all available matches
-      # @return [Array<Resources::Match>] Array of match objects
-      def get_matches! # rubocop:disable Naming/AccessorMethodName
-        response = @connection.get("#{BASE_PATH}/matches") do |req|
-          req.params = auth_params
-        end
-
-        handle_response(response, Resources::Match, collection: true)
-      end
-
-      # Get a specific match by ID
-      # @param id [String] The match ID
-      # @return [Resources::Match] The match object
-      def get_match!(id:)
-        response = @connection.get("#{BASE_PATH}/matches/#{id}") do |req|
-          req.params = auth_params
-        end
-
-        handle_response(response, Resources::Match)
-      end
-
-      # Zone Operations
-
-      # Get available zones for a club and match
-      # @param club_id [String] The club ID
-      # @param match_id [String] The match ID
-      # @return [Array<Resources::Zone>] Array of zone objects
-      def get_zones!(club_id:, match_id:)
-        response = @connection.get("#{BASE_PATH}/zones/club") do |req|
-          req.params = auth_params.merge(
-            club_id: club_id,
-            match_id: match_id
-          )
-        end
-
-        handle_response(response, Resources::Zone, collection: true)
-      end
-
-      private
-
-      def build_connection
-        Faraday.new(url: @base_url) do |faraday|
-          faraday.request :json
-          faraday.response :json, content_type: /\bjson$/
-          faraday.adapter Faraday.default_adapter
-        end
-      end
-
-      def auth_params
-        {
-          public_key: @public_key,
-          private_key: @private_key
-        }
-      end
-
-      def handle_response(response, model_class, collection: false)
-        if response.success?
-          data = response.body
-          unless data['success']
-            raise SpreeCmCommissioner::Integrations::ExternalClientError.new(
-              "API request failed: #{data['error']}",
-              response.status
-            )
-          end
-
-          collection ? model_class.from_collection(data) : model_class.new(data['data'])
-        else
-          handle_error_response(response)
-        end
-      end
-
-      def handle_error_response(response)
-        error_message = "API request failed with status #{response.status}"
-
-        # Response body is already parsed by Faraday's JSON middleware
-        error_body = response.body
-
-        if error_body.is_a?(Hash)
-          error = error_body['error'] || error_body['message'] || error_body
-          error_message = error.is_a?(Hash) ? error.to_json : error.to_s
-        else
-          error_message = error_body.to_s.presence || error_message
-        end
-
-        raise SpreeCmCommissioner::Integrations::ExternalClientError.new(error_message, response.status)
-      end
-    end
-  end
-end

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

@@ -1,113 +0,0 @@
-class SpreeCmCommissioner::Integrations::StadiumXV1
-  module Polling
-    class SyncMatches
-      def initialize(client:, integration:, sync_result: nil)
-        @client = client
-        @integration = integration
-        @sync_result = sync_result || SpreeCmCommissioner::Integrations::Base::SyncResult.new
-      end
-
-      def call
-        synced_match_mappings = sync_matches!
-        cleanup_stale_mappings!(synced_match_mappings)
-      end
-
-      # Sync all available matches from the API and create them as events
-      def sync_matches!
-        external_matches = begin
-          @sync_result.track_api_call('get_matches') { @client.get_matches! }
-        rescue SpreeCmCommissioner::Integrations::ExternalClientError => e
-          raise SpreeCmCommissioner::Integrations::SyncError, "Failed to sync matches: #{e.message}"
-        end
-
-        external_matches.map do |external_match|
-          sync_match!(external_match)
-        end
-      end
-
-      # Sync a single match and create it as an event taxon under events/
-      # Match data might be incomplete in the matches list, so we fetch full details
-      def sync_match!(external_match)
-        external_match = begin
-          @sync_result.track_api_call('get_match_details') { @client.get_match!(id: external_match._id) }
-        rescue SpreeCmCommissioner::Integrations::ExternalClientError => e
-          raise SpreeCmCommissioner::Integrations::SyncError, "Failed to sync matches: #{e.message}"
-        end
-
-        match_mapping = Spree::Taxon.find_or_initialize_integration_mapping(integration_id: @integration.id, external_id: external_match._id)
-        match_taxon = match_mapping.internal
-
-        # Track match sync and create event taxon directly under events/
-        @sync_result.track(:match, match_taxon) do |tracker|
-          match_taxon.assign_attributes(
-            vendor: @integration.vendor,
-            parent: events_root_taxon,
-            taxonomy: events_taxonomy,
-            name: "#{external_match.home_name} vs #{external_match.away_name}",
-            kind: :event,
-            from_date: external_match.match_datetime,
-            to_date: external_match.match_datetime + 120.minutes,
-
-            # seo
-            meta_title: external_match.meta_title,
-            meta_description: external_match.meta_description,
-
-            # Sync common match fields for cross-integration compatibility
-            # Only include fields that other integrations typically provide to avoid data gaps.
-            public_metadata: {
-              home_name: external_match.home_name,
-              home_score: external_match.home_score,
-              home_logo_url: external_match.home_logo,
-              away_name: external_match.away_name,
-              away_score: external_match.away_score,
-              away_logo_url: external_match.away_logo,
-              stadium: external_match.stadium,
-              league_name: external_match.league&.name,
-              league_logo_url: external_match.league&.logo
-            }
-          )
-          tracker.save_if_changed!(match_taxon)
-        end
-
-        match_mapping.mark_as_active!(external_payload: external_match.to_h)
-        match_mapping
-      end
-
-      # Archive stale match mappings that are no longer in the external API
-      # Finds all active event taxon mappings for this integration and archives any
-      # that weren't included in the latest API response
-      def cleanup_stale_mappings!(synced_match_mappings)
-        synced_external_match_ids = synced_match_mappings.map(&:external_id)
-
-        # Find all active match mappings (event taxons) for this integration
-        active_match_mappings = SpreeCmCommissioner::IntegrationMapping.where(
-          integration_id: @integration.id,
-          internal_type: 'Spree::Taxon',
-          status: :active
-        ).where(internal_id: Spree::Taxon.where(kind: :event).select(:id))
-
-        # Archive matches that are no longer in the API response
-        active_match_mappings.find_each do |mapping|
-          next if synced_external_match_ids.include?(mapping.external_id)
-
-          # Discontinue all products associated with this match
-          mapping.internal.event_products.find_each do |product|
-            product.discontinue!
-            @sync_result.increment_metric(:zone, :discontinued)
-          end
-
-          mapping.mark_as_archived!
-          @sync_result.increment_metric(:match, :archived)
-        end
-      end
-
-      def events_root_taxon
-        events_taxonomy.root
-      end
-
-      def events_taxonomy
-        @events_taxonomy ||= Spree::Taxonomy.events
-      end
-    end
-  end
-end

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

@@ -1,215 +0,0 @@
-class SpreeCmCommissioner::Integrations::StadiumXV1
-  module Polling
-    class SyncZones
-      def initialize(client:, integration:, sync_result:)
-        @client = client
-        @integration = integration
-        @sync_result = sync_result
-      end
-
-      def call(external_match_id:)
-        raise SpreeCmCommissioner::Integrations::SyncError, 'external_match_id is required' if external_match_id.nil?
-
-        match_mapping = Spree::Taxon.find_integration_mapping(integration_id: @integration.id, external_id: external_match_id)
-        raise SpreeCmCommissioner::Integrations::SyncError, "Match not found: #{external_match_id}" if match_mapping.blank?
-
-        synced_zone_mappings = sync_zones!(match_mapping)
-        cleanup_stale_mappings!(match_mapping, synced_zone_mappings)
-      end
-
-      # Sync zones for a specific club and match
-      def sync_zones!(match_mapping)
-        external_club_id = match_mapping.external_payload&.dig('club_id')
-        raise SpreeCmCommissioner::Integrations::SyncError, 'club_id is required' if external_club_id.blank?
-
-        external_zones = begin
-          @sync_result.track_api_call('get_zones') { @client.get_zones!(club_id: external_club_id, match_id: match_mapping.external_id) }
-        rescue SpreeCmCommissioner::Integrations::ExternalClientError => e
-          raise SpreeCmCommissioner::Integrations::SyncError, "Failed to sync zones match #{match_mapping.external_id}: #{e.message}"
-        end
-
-        # match ID is not returned by API, but it is important info when creating tickets in the external system
-        # We need to set it manually on each zone object so that it can be used when creating tickets.
-        # This is a temporary workaround until the API returns the match ID
-        external_zones.each do |zone|
-          zone.set_match_id(match_mapping.external_id)
-        end
-
-        taxon_match_section = match_mapping.internal.children.first_or_create! { |s| s.name = 'Zones' }
-        synced_zone_mappings = external_zones.map do |external_zone|
-          sync_zone!(external_zone, match_mapping.internal, taxon_match_section)
-        end
-
-        CmAppLogger.log(
-          label: 'SyncZones#sync_zones! Zones synced for match',
-          data: { external_match_id: match_mapping.external_id }
-        )
-
-        synced_zone_mappings
-      end
-
-      private
-
-      def sync_zone!(external_zone, internal_match, taxon_match_section)
-        Spree::Product.transaction do
-          product_mapping = Spree::Product.find_or_initialize_integration_mapping(integration_id: @integration.id, external_id: external_zone._id)
-          product = product_mapping.internal
-
-          zone_option_type = Spree::OptionType.ticket_type
-          color_option_type = external_zone.color_brand.present? ? Spree::OptionType.color : nil
-
-          # Track zone sync
-          @sync_result.track(:zone, product) do |tracker|
-            product.assign_attributes(
-              status: :active,
-              tenant: @integration.tenant,
-              vendor: @integration.vendor,
-              product_type: :ecommerce,
-              event: internal_match,
-              taxons: [taxon_match_section],
-              name: external_zone.title.strip,
-              price: external_zone.online_price,
-              available_on: external_zone.start_datetime,
-              discontinue_on: external_zone.end_datetime,
-              option_types: [zone_option_type, color_option_type].compact,
-              shipping_category: Spree::ShippingCategory.first,
-              stores: [Spree::Store.default]
-            )
-            tracker.save_if_changed!(product)
-          end
-
-          product_mapping.mark_as_active!(external_payload: external_zone.to_h)
-
-          ensure_variant_with_zone_option_value!(product, external_zone, zone_option_type, color_option_type)
-          ensure_inventory!(product.variants[0], external_zone)
-
-          product_mapping
-        end
-      rescue ActiveRecord::RecordInvalid => e
-        CmAppLogger.error(
-          label: 'SyncZones#sync_zone Failed to save zone',
-          data: { zone_id: external_zone._id, error: e.message, backtrace: e.backtrace }
-        )
-        raise SpreeCmCommissioner::Integrations::SyncError, "Failed to save zone #{external_zone.title}: #{e.message}"
-      end
-
-      def ensure_variant_with_zone_option_value!(product, external_zone, zone_option_type, color_option_type)
-        option_values = [Spree::OptionValue.find_or_create_by_name!(zone_option_type, external_zone.title)]
-
-        if color_option_type.present? && external_zone.color_brand.present?
-          option_values << Spree::OptionValue.find_or_create_by_name!(color_option_type, external_zone.color_brand)
-        end
-
-        variant = product.variants.first_or_initialize
-
-        # Track variant sync
-        @sync_result.track(:variant, variant) do |tracker|
-          variant.assign_attributes(
-            vendor: @integration.vendor,
-            track_inventory: true,
-            product_type: :ecommerce,
-            price: external_zone.online_price,
-            discontinue_on: external_zone.end_datetime,
-            option_values: option_values
-          )
-          tracker.save_if_changed!(variant)
-        end
-      end
-
-      # Synchronize variant inventory with external StadiumX API
-      # Calculates the difference between external available seats and system inventory,
-      # then creates a stock movement to align system inventory with the external source.
-      #
-      # EXECUTION FLOW:
-      # 1. Calculate quantity difference between external and system inventory
-      # 2. Create StockMovement via StockMovementCreator (if difference != 0)
-      # 3. StockMovement.save triggers after_create callback → update_stock_item_quantity
-      # 4. StockItem.adjust_count_on_hand(quantity) updates count_on_hand
-      # 5. StockItem.save triggers after_commit callback → create_inventory_items (on first create)
-      # 6. InventoryItemsGeneratorJob → InventoryItemsGenerator → create_default_non_permanent_inventory_item!
-      # 7. Creates InventoryItem with quantity_available = stock_item.count_on_hand
-      # 8. StockMovementCreator enqueues InventoryItemsAdjusterJob (async)
-      # 9. InventoryItemsAdjuster.adjust_quantity!(quantity) updates existing inventory_items
-      # 10. Updates both DB (quantity_available, max_capacity) and Redis cache
-      #
-      # IMPORTANT: Inventory items are created AFTER stock item is saved (via callback).
-      # On first sync, the flow is: StockMovement → StockItem → InventoryItem creation → InventoryItem adjustment.
-      # On subsequent syncs: StockMovement → StockItem → InventoryItem adjustment only.
-      #
-      # Examples:
-      #
-      # 1. First sync (no inventory items yet):
-      #    - External available seats: 50
-      #    - System inventory: 0 (no inventory_items created)
-      #    - Stock movement created: +50 (initialize system to 50)
-      #    - Flow: StockMovement(+50) → StockItem.count_on_hand=50 → InventoryItem created with quantity=50 → Adjuster adjusts by +50
-      #
-      # 2. System has more inventory than external:
-      #    - External available seats: 20
-      #    - System inventory: 30
-      #    - Stock movement created: -10 (adjust system down to 20)
-      #    - Flow: StockMovement(-10) → StockItem.count_on_hand=20 → Adjuster adjusts inventory_item by -10
-      #
-      # 3. System has less inventory than external:
-      #    - External available seats: 50
-      #    - System inventory: 30
-      #    - Stock movement created: +20 (adjust system up to 50)
-      #    - Flow: StockMovement(+20) → StockItem.count_on_hand=50 → Adjuster adjusts inventory_item by +20
-      #
-      # 4. Already in sync:
-      #    - External available seats: 25
-      #    - System inventory: 25
-      #    - Stock movement created: 0 (no change needed)
-      #    - Flow: Early return, no operations performed
-      def ensure_inventory!(variant, external_zone)
-        raise ArgumentError, 'variant cannot be nil' if variant.nil? || variant.id.blank?
-        raise ArgumentError, 'external_zone cannot be nil' if external_zone.nil?
-
-        # NOTE: StadiumX zones have no permanent stock or date-based inventory, so we expect
-        # only one inventory item (index 0) per variant. Uses safe navigation to handle cases
-        # where inventory items haven't been created yet (first sync).
-        stock_location = variant.vendor.stock_locations.first || variant.vendor.send(:create_stock_location)
-        system_quantity = variant.inventory_items.active[0]&.quantity_in_redis || 0
-        external_quantity = external_zone.available_seats || 0
-
-        quantity_difference = external_quantity - system_quantity
-        return if quantity_difference.zero?
-
-        context = SpreeCmCommissioner::Stock::StockMovementCreator.call(
-          variant_id: variant.id,
-          stock_location_id: stock_location.id,
-          current_store: Spree::Store.default,
-          stock_movement_params: { quantity: quantity_difference }
-        )
-
-        return unless context.success?
-
-        @sync_result.increment_metric(:inventory, :adjusted, quantity_difference.abs)
-      end
-
-      # Archive stale zone mappings that are no longer in the external API
-      # Finds all active zone mappings for this integration and archives any
-      # that weren't included in the latest API response.
-      def cleanup_stale_mappings!(match_mapping, synced_zone_mappings)
-        synced_external_zone_ids = synced_zone_mappings.map(&:external_id)
-
-        # Find all active zone mappings for this integration and match
-        active_zone_mappings = SpreeCmCommissioner::IntegrationMapping.where(
-          integration_id: @integration.id,
-          internal_type: 'Spree::Product',
-          status: :active
-        ).where(internal_id: Spree::Product.where(event_id: match_mapping.internal_id).select(:id))
-
-        # Archive zones that are no longer in the API response
-        active_zone_mappings.find_each do |mapping|
-          next if synced_external_zone_ids.include?(mapping.external_id)
-
-          mapping.internal.discontinue!
-
-          mapping.mark_as_archived!
-          @sync_result.increment_metric(:zone, :discontinued)
-        end
-      end
-    end
-  end
-end

data/app/services/spree_cm_commissioner/integrations/stadium_x_v1/resources/base.rb

@@ -1,20 +0,0 @@
-class SpreeCmCommissioner::Integrations::StadiumXV1
-  module Resources
-    class Base
-      class << self
-        def from_collection(data)
-          return [] unless data['data'].is_a?(Array)
-
-          data['data'].map { |item| new(item) }
-        end
-      end
-
-      def initialize(attributes = {})
-        attributes.each do |key, value|
-          setter = "#{key}="
-          send(setter, value) if respond_to?(setter)
-        end
-      end
-    end
-  end
-end

data/app/services/spree_cm_commissioner/integrations/stadium_x_v1/resources/league.rb

@@ -1,19 +0,0 @@
-class SpreeCmCommissioner::Integrations::StadiumXV1
-  module Resources
-    class League < Base
-      attr_accessor :_id, :name, :logo
-
-      def initialize(attributes = {})
-        super(attributes)
-      end
-
-      def to_h
-        {
-          _id: _id,
-          name: name,
-          logo: logo
-        }.compact
-      end
-    end
-  end
-end