spree_cm_commissioner 2.8.2.pre.pre.2 → 2.8.2

data/app/services/spree_cm_commissioner/voting_contestants/advancer.rb

@@ -1,334 +0,0 @@
-module SpreeCmCommissioner
-  module VotingContestants
-    # Keeps one VotingContestant row in sync with the "next" round (another session or episode).
-    #
-    # Flow (after +update!+ on the current row):
-    #
-    # 1. **Elimination changed** (`eliminated` toggled) and this row has an +advanced_to+:
-    #    - Marking eliminated: validate reversion order (block if the advance chain continues in a
-    #      later session or the next hop has votes), then remove only the **immediate** linked row
-    #      in the destination session (if no votes). Unwind later rounds first, then earlier ones.
-    #    - Un-eliminating: +create_or_update_destination_record+ (restore the linked row).
-    #
-    # 2. **Advance target changed** (+advanced_to_type+ / +advanced_to_id+):
-    #    - +cleanup_previous_destination+, then if still active and pointing somewhere,
-    #      +create_or_update_destination_record+ at the new destination.
-    #
-    # Linked row = the VotingContestant in the next session with the same +show_contestant+,
-    # +advanced_from+ = this row's +voting_session+.
-    class Advancer
-      prepend ::Spree::ServiceModule::Base
-
-      def call(voting_contestant:, attributes:)
-        @voting_contestant = voting_contestant
-        @attributes = attributes || {}
-
-        ActiveRecord::Base.transaction do
-          update_contestant
-          sync_advancement
-        end
-
-        success(voting_contestant: @voting_contestant.reload)
-      rescue StandardError => e
-        failure(nil, e.message)
-      end
-
-      private
-
-      def update_contestant
-        # Persist whatever fields the caller changed.
-        # e.g. @attributes = { eliminated: true } → vc_a.eliminated becomes true
-        @voting_contestant.update!(@attributes)
-      end
-
-      def sync_advancement
-        # Each flag is checked independently — both branches can fire in one request.
-        # e.g. attributes = { eliminated: true, advanced_to_id: 2 } → both branches run
-
-        # eliminated flag toggled (false → true or true → false)
-        sync_elimination_status if @voting_contestant.saved_change_to_eliminated?
-
-        # advanced_to pointer assigned, changed, or cleared
-        sync_advanced_to if advanced_to_changed?
-      end
-
-      def advanced_to_changed?
-        # Either part of the polymorphic pair changing counts as a destination change.
-        # e.g. advanced_to_id: 1 → 2 (same type, different session) → true
-        # e.g. only eliminated changed, advanced_to untouched → false
-        @voting_contestant.saved_change_to_advanced_to_id? ||
-          @voting_contestant.saved_change_to_advanced_to_type?
-      end
-
-      # --- Elimination ---------------------------------------------------------
-
-      def sync_elimination_status
-        # No destination id — contestant was never advanced forward; nothing to mirror.
-        # e.g. vc_a { advanced_to_id: nil } → return
-        return if @voting_contestant.advanced_to_id.blank?
-
-        # Incomplete polymorphic ref — can't resolve a session without both parts.
-        # e.g. vc_a { advanced_to_type: nil } → return
-        return if @voting_contestant.advanced_to_type.blank?
-
-        if @voting_contestant.eliminated?
-          # Guard unwind order: refuse if downstream chain still has votes or extends further.
-          # e.g. chain A → B → C; vc_b → vc_c exists → raise (must eliminate C before A)
-          validate_reversion!
-
-          # Destroy the immediate mirror row in the destination session when it has 0 votes.
-          # e.g. vc_b (Alice, Session B, 0 votes) → destroy vc_b → clear vc_a.advanced_to
-          # If vc_b has votes → destroy_destination_record returns false → pointer kept
-          clear_advanced_to_pointer if destroy_destination_record(@voting_contestant.advanced_to_type, @voting_contestant.advanced_to_id)
-        else
-          # Un-eliminating: recreate the mirror row so Alice re-enters the next session.
-          # e.g. vc_a.eliminated true → false → create (or restore) vc_b in Session B
-          create_or_update_destination_record
-        end
-      end
-
-      # --- advanced_to pointer ------------------------------------------------
-
-      def sync_advanced_to
-        # Remove the mirror row we created for the *old* destination before pointing elsewhere.
-        # e.g. vc_a.advanced_to changed Session B → Session C → destroy vc_b first
-        cleanup_previous_destination
-
-        # Create a fresh mirror at the new destination (skipped if eliminated or no destination).
-        # e.g. vc_a now points to Session C → create vc_c for Alice in Session C
-        create_or_update_destination_record if should_create_destination_record?
-      end
-
-      def should_create_destination_record?
-        # No destination id — nothing to mirror.
-        # e.g. vc_a { advanced_to_id: nil } → false
-        return false if @voting_contestant.advanced_to_id.blank?
-
-        # Incomplete polymorphic ref — can't resolve the session.
-        # e.g. vc_a { advanced_to_type: nil } → false
-        return false if @voting_contestant.advanced_to_type.blank?
-
-        # Eliminated contestants must not be mirrored forward.
-        # e.g. vc_a { eliminated: true } → false
-        return false if @voting_contestant.eliminated?
-
-        true
-      end
-
-      def cleanup_previous_destination
-        # Read values that were set *before* the current save.
-        # e.g. advanced_to was Session B before user changed it to Session C
-        old_type = @voting_contestant.advanced_to_type_before_last_save
-        old_id   = @voting_contestant.advanced_to_id_before_last_save
-
-        # No previous destination — nothing to clean up.
-        # e.g. contestant had no advanced_to before this save → return
-        return if old_type.blank? || old_id.blank?
-
-        # Resolve the old session from the previous polymorphic pointer.
-        # e.g. old_type='VotingSession', old_id=2 → Session B
-        old_session = find_target_session(old_type, old_id)
-
-        # Old session was deleted or not found — nothing to clean up.
-        return unless old_session
-
-        # Find the mirror row we previously created in the old session.
-        # e.g. vc_b (Alice, advanced_from: Session A) inside old Session B
-        linked = find_linked_voting_contestant(old_session, @voting_contestant)
-
-        # Mirror was never created (e.g. contestant was eliminated at the time) — skip.
-        return unless linked
-
-        # Refuse if vc_b has votes or if vc_b itself advances further (vc_c exists).
-        # e.g. vc_b.vote_count = 3 → raise; or vc_b → vc_c exists → raise
-        validate_cleanup_old_mirror!(linked)
-
-        # Recursively destroy vc_b and any children (vc_c, vc_d …) that have 0 votes.
-        destroy_mirror_branch_from(linked)
-      end
-
-      def create_or_update_destination_record
-        # Resolve the destination session from the current polymorphic pointer.
-        # e.g. advanced_to: VotingSession#2 → Session B
-        session = find_target_session(@voting_contestant.advanced_to_type, @voting_contestant.advanced_to_id)
-
-        # Target session not found (deleted or bad reference) — nothing to mirror.
-        return unless session
-
-        # Find an existing mirror or initialize a new one, keyed by show_contestant.
-        # e.g. find vc_b (Alice in Session B) or build a new record
-        record = session.voting_contestants.find_or_initialize_by(show_contestant_id: @voting_contestant.show_contestant_id)
-
-        # Stamp the mirror with a back-reference so we can locate it later.
-        # advanced_from links vc_b → Session A (source of the advancement).
-        record.assign_attributes(
-          show_id: @voting_contestant.show_id,
-          advanced_from: @voting_contestant.voting_session,
-          eliminated: @voting_contestant.eliminated
-        )
-        record.save!
-      end
-
-      # Single-hop destroy: removes only the immediate mirror row (used when eliminating).
-      # Returns true  → caller may clear the advanced_to pointer.
-      # Returns false → mirror has votes; pointer must be kept so the record stays traceable.
-      def destroy_destination_record(type, id)
-        # Resolve the destination session.
-        # e.g. type='VotingSession', id=2 → Session B
-        session = find_target_session(type, id)
-
-        # Session not found — treat as already gone; pointer can be cleared.
-        return true unless session
-
-        # Look for the mirror row (Alice in Session B, advanced_from Session A).
-        linked = find_linked_voting_contestant(session, @voting_contestant)
-
-        # No mirror exists (never created or already removed) — pointer can be cleared.
-        return true if linked.nil?
-
-        # Mirror has votes — destroying it would erase vote history; keep the pointer.
-        # e.g. vc_b.vote_count = 5 → return false
-        return false if linked.vote_count.to_i.positive?
-
-        # Safe to destroy (0 votes); signal that the pointer can be cleared.
-        # e.g. vc_b.vote_count = 0 → destroy vc_b, return true
-        linked.destroy!
-        true
-      end
-
-      def clear_advanced_to_pointer
-        # Sever the forward link after the mirror row has been safely destroyed.
-        # e.g. vc_a { advanced_to_type: 'VotingSession', advanced_to_id: 2 } → both set to nil
-        @voting_contestant.update!(
-          advanced_to_type: nil,
-          advanced_to_id: nil,
-          updated_at: Time.current
-        )
-      end
-
-      def validate_cleanup_old_mirror!(linked_row)
-        # Mirror has votes — deleting it would lose cast vote data.
-        # e.g. vc_b.vote_count = 3 → raise
-        raise Spree.t('voting_contestant_advancer.reversion_error') if linked_row.vote_count.to_i.positive?
-
-        # Mirror itself advances further — unwind the outer hop first.
-        # e.g. vc_b.advanced_to = Session C and vc_c exists → raise
-        raise Spree.t('voting_contestant_advancer.reversion_error') if downstream_mirror_chain_continues?(linked_row)
-      end
-
-      # Recursively destroys a mirror branch deepest-first (vc_c before vc_b).
-      # Only recurses into a child when the child has 0 votes (safe to remove).
-      def destroy_mirror_branch_from(linked_row)
-        # If this row points forward, try to remove its child subtree first.
-        if linked_row.advanced_to_id.present? && linked_row.advanced_to_type.present?
-          # Resolve the next session in the chain.
-          # e.g. vc_b.advanced_to = Session C → grandchild_session = Session C
-          session = find_target_session(linked_row.advanced_to_type, linked_row.advanced_to_id)
-
-          if session
-            # Find the grandchild mirror (Alice in Session C).
-            child = find_linked_voting_contestant(session, linked_row)
-
-            # Recurse only when the grandchild has no votes; leave it intact otherwise.
-            # e.g. vc_c.vote_count = 0 → destroy_mirror_branch_from(vc_c) → destroy vc_c
-            destroy_mirror_branch_from(child) if child && child.vote_count.to_i.zero?
-          end
-        end
-
-        # Destroy this node after its subtree is cleaned up (post-order).
-        # e.g. destroy vc_b after vc_c was already removed
-        linked_row.destroy!
-      end
-
-      # --- Reversion order (unwind from furthest session toward this one) -----
-
-      def validate_reversion!
-        # Enforce unwind order: eliminate the furthest-advanced session first.
-        # e.g. chain A → B → C; must eliminate C before B, then B before A → raise if locked
-        raise Spree.t('voting_contestant_advancer.reversion_error') if reversion_locked?(@voting_contestant)
-      end
-
-      def reversion_locked?(source_vc)
-        # Find the immediate downstream mirror.
-        # e.g. source_vc = vc_a → downstream = vc_b (Alice in Session B)
-        downstream = find_downstream_voting_contestant(source_vc)
-
-        # No mirror downstream — nothing blocking the reversion.
-        # e.g. vc_a has no vc_b → not locked
-        return false if downstream.blank?
-
-        # Mirror has votes — cannot eliminate source while destination is still active.
-        # e.g. vc_b.vote_count = 5 → locked
-        return true if downstream.vote_count.to_i.positive?
-
-        # Mirror itself advances further — must unwind the further chain first.
-        # e.g. vc_b → vc_c exists → locked (eliminate C before A)
-        return true if downstream_mirror_chain_continues?(downstream)
-
-        false
-      end
-
-      def downstream_mirror_chain_continues?(downstream)
-        # Downstream row has no forward pointer — chain ends here.
-        # e.g. vc_b { advanced_to_id: nil } → false
-        return false if downstream.advanced_to_id.blank? || downstream.advanced_to_type.blank?
-
-        # Resolve the session two hops away (grandchild session).
-        # e.g. vc_b.advanced_to = Session C → grandchild_session = Session C
-        grandchild_session = find_target_session(downstream.advanced_to_type, downstream.advanced_to_id)
-
-        # Grandchild session not found — chain doesn't continue.
-        return false unless grandchild_session
-
-        # Chain continues only when a mirror actually exists in the grandchild session.
-        # e.g. vc_c (Alice, Session C) exists → true (must unwind C first)
-        # e.g. no vc_c yet → false (safe to proceed)
-        find_linked_voting_contestant(grandchild_session, downstream).present?
-      end
-
-      def find_downstream_voting_contestant(source_vc)
-        # source_vc must have a forward pointer to look for a downstream mirror.
-        # e.g. vc_a { advanced_to_id: nil } → nil (no downstream)
-        return unless source_vc.advanced_to_id.present? && source_vc.advanced_to_type.present?
-
-        # Resolve the destination session from the polymorphic pointer.
-        # e.g. vc_a.advanced_to = VotingSession#2 → Session B
-        session = find_target_session(source_vc.advanced_to_type, source_vc.advanced_to_id)
-
-        # Destination session deleted or not found.
-        return unless session
-
-        # Return the mirror row for source_vc in that session.
-        # e.g. vc_b (Alice in Session B, advanced_from: Session A)
-        find_linked_voting_contestant(session, source_vc)
-      end
-
-      def find_linked_voting_contestant(session, source_vc)
-        # Match by same show_contestant AND the back-reference to the source session.
-        # Both must match to avoid false positives when the same contestant appears in
-        # multiple chains (e.g. re-advanced after un-elimination).
-        # e.g. session=B, source=vc_a
-        #   → find_by(show_contestant_id: Alice.id, advanced_from: Session A) → vc_b
-        session.voting_contestants.find_by(
-          show_contestant_id: source_vc.show_contestant_id,
-          advanced_from: source_vc.voting_session
-        )
-      end
-
-      # advanced_to is polymorphic: either a VotingSession directly or a ShowEpisode
-      # (resolved to the first session of that episode, ordered by position).
-      def find_target_session(type, id)
-        case type.to_s
-        when 'SpreeCmCommissioner::VotingSession'
-          # Direct session reference — straightforward lookup.
-          # e.g. type='...VotingSession', id=2 → VotingSession#2
-          ::SpreeCmCommissioner::VotingSession.find_by(id: id)
-        when 'SpreeCmCommissioner::ShowEpisode'
-          # Episode reference — resolve to the opening (lowest-position) session of that episode.
-          # e.g. Episode#5 has sessions [position:1, position:2] → returns the position:1 session
-          ::SpreeCmCommissioner::ShowEpisode.find_by(id: id)&.voting_sessions&.order(:position)&.first
-        end
-      end
-    end
-  end
-end

data/app/services/spree_cm_commissioner/voting_contestants/assigner.rb

@@ -1,32 +0,0 @@
-module SpreeCmCommissioner
-  module VotingContestants
-    class Assigner
-      prepend ::Spree::ServiceModule::Base
-
-      def call(voting_session:, show_contestant_ids: [])
-        @voting_session = voting_session
-        @episode = voting_session.episode
-        @show_contestant_ids = show_contestant_ids || []
-
-        assign_contestants
-
-        success(voting_session: @voting_session)
-      rescue StandardError => e
-        failure(nil, e.message)
-      end
-
-      private
-
-      def assign_contestants
-        target_ids = @show_contestant_ids.uniq
-        return if target_ids.empty?
-
-        @episode.season.show_contestants.where(id: target_ids).find_each do |show_contestant|
-          @voting_session.voting_contestants.find_or_create_by!(show_contestant: show_contestant) do |voting_contestant|
-            voting_contestant.show_id = @voting_session.show_id
-          end
-        end
-      end
-    end
-  end
-end

data/app/services/spree_cm_commissioner/voting_contestants/bulk_updater.rb

@@ -1,106 +0,0 @@
-module SpreeCmCommissioner
-  module VotingContestants
-    # Updates multiple voting contestants in a single transaction.
-    # Accepts a hash of { contestant_id => attributes } and delegates
-    # each update to Advancer. Rolls back all changes if any update fails.
-    class BulkUpdater
-      prepend ::Spree::ServiceModule::Base
-
-      # Polymorphic targets a contestant may advance to after a round.
-      ALLOWED_ADVANCED_TO_TYPES = %w[
-        SpreeCmCommissioner::VotingSession
-        SpreeCmCommissioner::ShowEpisode
-      ].freeze
-
-      def call(voting_session:, updates:)
-        @voting_session = voting_session
-        @updates = updates || {}
-        @errors = []
-
-        ActiveRecord::Base.transaction do
-          process_updates
-          raise ActiveRecord::Rollback if @errors.any?
-        end
-
-        if @errors.empty?
-          success(voting_session: @voting_session)
-        else
-          failure(nil, @errors.to_sentence)
-        end
-      rescue StandardError => e
-        failure(nil, e.message)
-      end
-
-      private
-
-      # Iterates over each update entry and delegates to Advancer.
-      def process_updates
-        @updates.each do |id, attrs|
-          vc = @voting_session.voting_contestants.find(id)
-          sanitized = sanitize_attrs(attrs)
-          next if sanitized.nil?
-
-          result = Advancer.call(voting_contestant: vc, attributes: sanitized)
-          update_eliminated_contestant_status!(voting_contestant: vc, attributes: sanitized) if result.success?
-
-          @errors << (result.error&.value || "Failed to update contestant #{vc.id}") if result.failure?
-        end
-      end
-
-      def update_eliminated_contestant_status!(voting_contestant:, attributes:)
-        return unless attributes.key?(:eliminated)
-        return unless attributes[:eliminated]
-
-        voting_contestant.show_contestant.eliminate
-        voting_contestant.show_contestant.save!
-      end
-
-      # Normalizes raw params into a safe attributes hash.
-      # Returns nil and appends an error if advanced_to is invalid.
-      def sanitize_attrs(attrs)
-        params = (attrs.respond_to?(:to_unsafe_h) ? attrs.to_unsafe_h : (attrs || {})).with_indifferent_access
-        out = {}
-
-        if params.key?(:eliminated)
-          eliminated = ActiveModel::Type::Boolean.new.cast(params[:eliminated])
-          out.merge!(eliminated: eliminated, eliminated_via: eliminated ? params[:eliminated_via].presence : nil)
-        end
-
-        if params.key?(:advanced_to)
-          case (advanced = advanced_to_attrs(params[:advanced_to]))
-          when :invalid
-            @errors << 'Invalid advanced_to type'
-            return nil
-          when Hash
-            out.merge!(advanced)
-          end
-        end
-
-        out[:special_rule_type] = params[:special_rule_type] if params.key?(:special_rule_type)
-        out[:vote_number] = params[:vote_number] if params.key?(:vote_number)
-
-        out
-      end
-
-      # Parses "ClassName:id" format into { advanced_to_type:, advanced_to_id: }.
-      # Returns :invalid if the type is not in ALLOWED_ADVANCED_TO_TYPES.
-      # Returns {} (no-op) when the value doesn't include a colon separator.
-      def advanced_to_attrs(value)
-        return { advanced_to_type: nil, advanced_to_id: nil } if value.blank?
-
-        parts = value.to_s.split(':')
-        return {} if parts.size < 2
-
-        advanced_to_id = parts.pop.to_i
-        advanced_to_type = parts.join(':')
-
-        return :invalid unless ALLOWED_ADVANCED_TO_TYPES.include?(advanced_to_type)
-
-        {
-          advanced_to_id: advanced_to_id,
-          advanced_to_type: advanced_to_type
-        }
-      end
-    end
-  end
-end

data/app/services/spree_cm_commissioner/voting_credits/allocate.rb

@@ -1,77 +0,0 @@
-module SpreeCmCommissioner
-  module VotingCredits
-    class Allocate
-      def initialize(order)
-        @order = order
-      end
-
-      def call
-        return unless @order.completed?
-        return if episode_line_items.empty?
-
-        ActiveRecord::Base.transaction do
-          voting_credit = find_or_create_credit
-          allocations = episode_line_items.map do |line_item|
-            SpreeCmCommissioner::VotingCredits::CreditCalculator.new(line_item).call
-          end
-          total_paid_vote_credits = allocations.sum
-
-          # Use with_lock to ensure we have a lock on the voting credit record while we:
-          # - Modify data inside the block
-          # - Need to prevent race conditions
-          voting_credit.with_lock do
-            voting_credit.paid_votes_amount += total_paid_vote_credits
-            voting_credit.save!
-          end
-
-          record_transaction(voting_credit, total_paid_vote_credits) if total_paid_vote_credits.positive?
-        end
-      rescue ActiveRecord::RecordNotUnique
-        # already allocated — safe to ignore
-      rescue StandardError => e
-        CmAppLogger.error(
-          label: 'VotingCredits::Allocate failed',
-          data: {
-            order_id: @order.try(:id),
-            error_class: e.class.name,
-            error_message: e.message
-          }
-        )
-        false
-      end
-
-      private
-
-      def vote_pack_product
-        @vote_pack_product ||= episode_line_items.first&.variant&.product
-      end
-
-      def episode_line_items
-        @episode_line_items ||= @order.line_items
-                                      .joins(variant: :product)
-                                      .where(spree_products: { type: SpreeCmCommissioner::ShowEpisode.name, product_type: :vote_package })
-                                      .to_a
-      end
-
-      def find_or_create_credit
-        SpreeCmCommissioner::VotingCredit.active.find_or_create_by!(
-          tenant_id: @order.tenant_id,
-          user: @order.user,
-          votable_type: vote_pack_product.votable_type,
-          votable_id: vote_pack_product.votable_id
-        ) { |c| c.category = :purchase }
-      end
-
-      def record_transaction(vote_credit, total_amount)
-        vote_credit.voting_credit_transactions.create!(
-          tenant_id: @order.tenant_id,
-          action: :purchase,
-          amount: total_amount,
-          originator: @order,
-          memo: "Purchase for order ##{@order.number}",
-          user_total_amount: vote_credit.available_votes
-        )
-      end
-    end
-  end
-end

data/app/services/spree_cm_commissioner/voting_credits/claim_free_votes.rb

@@ -1,119 +0,0 @@
-# Mobile can check that where ClaimFreeVotes Screen should Appear based on the show's voting_config.
-# free_vote_limit and voting_config.free_vote_limit_type, then call this service to claim free votes.
-#
-# Grants free votes to a user based on the show's free_vote_limit_type:
-#   - per_show          : once per show          (no extra params needed)
-#   - per_episode       : once per episode        (pass votable_type: 'SpreeCmCommissioner::ShowEpisode', votable_id: episode.id)
-#   - per_voting_session: once per voting session (pass votable_type: 'SpreeCmCommissioner::VotingSession', votable_id: voting_session.id)
-#
-# Idempotent: a unique idempotency_key on the transaction prevents double-claiming.
-#
-# Usage:
-#   Show with per_show limit:
-#   SpreeCmCommissioner::VotingCredits::ClaimFreeVotes.new(
-#     show: show,
-#     user: user,
-#     tenant_id: 1
-#   ).call
-#
-#   Show with per_episode limit:
-#   SpreeCmCommissioner::VotingCredits::ClaimFreeVotes.new(
-#     show: show,
-#     user: user,
-#     tenant_id: 1,
-#     votable_type: 'SpreeCmCommissioner::ShowEpisode',
-#     votable_id: episode.id
-#   ).call
-#
-#   Show with per_voting_session limit:
-#   SpreeCmCommissioner::VotingCredits::ClaimFreeVotes.new(
-#     show: show,
-#     user: user,
-#     tenant_id: 1,
-#     votable_type: 'SpreeCmCommissioner::VotingSession',
-#     votable_id: voting_session.id
-#   ).call
-module SpreeCmCommissioner
-  module VotingCredits
-    class ClaimFreeVotes
-      prepend ::Spree::ServiceModule::Base
-
-      attr_reader :show, :user, :tenant_id, :votable_type, :votable_id
-
-      def initialize(show:, user:, tenant_id:, votable_type: nil, votable_id: nil)
-        @show = show
-        @user = user
-        @tenant_id = tenant_id
-        @votable_type = votable_type
-        @votable_id = votable_id
-      end
-
-      # Returns the VotingCredit after granting free votes,
-      # or returns msg if free votes cannot be granted (e.g. limit reached).
-      def call # rubocop:disable Metrics/AbcSize
-        return success(nil) unless show.free_vote_limit_type
-
-        idempotency_key = show.free_vote_idempotency_key(user_id: user.id, votable_id: votable_id)
-
-        # idempotency_key is uniquely indexed — faster than scoping through user.voting_transactions association.
-        if SpreeCmCommissioner::VotingCreditTransaction.exists?(idempotency_key: idempotency_key)
-          return failure(nil, 'Free votes have already been claimed')
-        end
-
-        amount = show.free_vote_limit.to_i
-
-        return failure(nil, "Free votes are not available for #{show.voting_credit_scope}") if amount <= 0
-
-        case show.free_vote_limit_type
-        when 'per_episode', 'per_voting_session'
-          if votable_type.blank? || votable_id.blank?
-            return failure(nil, 'votable_type and votable_id are required for per_episode/per_voting_session')
-          end
-        end
-
-        credit = nil
-
-        ActiveRecord::Base.transaction do
-          credit = user.voting_credits.active.find_or_create_by!(
-            tenant_id: tenant_id,
-            votable: votable
-          ) { |c| c.category = :promo }
-
-          credit.with_lock do
-            credit.free_votes_amount += amount
-            credit.save!
-          end
-
-          credit.voting_credit_transactions.create!(
-            tenant_id: tenant_id,
-            action: :free_claim,
-            amount: amount,
-            originator: show,
-            free_claim_votable_id: votable_id,
-            user_total_amount: credit.available_votes,
-            memo: "Free claim: #{amount} votes | credit_scope: #{show.voting_credit_scope} | key: #{idempotency_key}"
-          )
-        end
-
-        success(credit)
-      rescue ActiveRecord::RecordNotUnique
-        # Two concurrent requests can both pass the existence check before either commits.
-        # The one that loses the unique-index race lands here — treat it as already claimed.
-        failure(nil, 'Free votes have already been claimed')
-      rescue StandardError => e
-        failure(nil, e.message)
-      end
-
-      # Always find votable by the show's credit_votable_type, to ensure consistency with where the credits are allocated.
-      # Resolves through the show association to prevent claiming against unrelated votable_ids.
-      def votable
-        case show.credit_votable_type
-        when 'SpreeCmCommissioner::Show'          then show
-        when 'SpreeCmCommissioner::ShowEpisode'   then show.episodes.find(votable_id)
-        when 'SpreeCmCommissioner::VotingSession' then show.voting_sessions.find(votable_id)
-        else raise ActiveRecord::RecordNotFound, "Unknown credit_votable_type: #{show.credit_votable_type}"
-        end
-      end
-    end
-  end
-end