spree_cm_commissioner 2.8.2.pre.pre.2 → 2.8.2

data/app/services/spree_cm_commissioner/vote_counters/snapshot_to_db.rb

@@ -1,113 +0,0 @@
-# Snapshots final vote counts from cm_votes into:
-#   - cm_voting_contestants: vote_count, unique_voter_count (per contestant)
-#   - cm_voting_session_stats: unique_voter_count, total_vote_count, vote_velocity, leading_contestant_id
-#
-# Called after a voting session closes so the leaderboard can be read from DB
-# permanently — no dependency on Redis keys that may expire.
-#
-# Usage:
-#   SpreeCmCommissioner::VoteCounters::SnapshotToDb.call(voting_session_id: id)
-module SpreeCmCommissioner
-  module VoteCounters
-    class SnapshotToDb
-      prepend ::Spree::ServiceModule::Base
-
-      def call(voting_session_id:)
-        voting_session = SpreeCmCommissioner::VotingSession.find(voting_session_id)
-
-        # TODO: manual/judge-driven sessions (scoring_model: :manual) should skip vote tallying
-        # and derive leading_contestant_id from Advancer data (contestants not eliminated) instead.
-        # Will be implemented in the next PR alongside the full scoring_model enum.
-
-        # Sum all votes per contestant and count how many distinct users voted per contestant.
-        db_counts           = fetch_vote_counts(voting_session_id)
-        unique_voter_counts = fetch_unique_voter_counts(voting_session_id)
-
-        # Persist per-contestant tallies, then write session-level aggregates.
-        upsert_contestant_counts(voting_session_id, db_counts, unique_voter_counts)
-        upsert_session_stat(voting_session, db_counts)
-
-        success(nil)
-      end
-
-      private
-
-      # Returns { contestant_id => total_quantity } for every vote in the session.
-      def fetch_vote_counts(voting_session_id)
-        SpreeCmCommissioner::Vote.for_session(voting_session_id)
-                                 .group(:contestant_id)
-                                 .sum(:quantity)
-      end
-
-      # Returns { contestant_id => distinct_user_count } — anonymous votes (user_id nil) are excluded.
-      def fetch_unique_voter_counts(voting_session_id)
-        SpreeCmCommissioner::Vote.for_session(voting_session_id)
-                                 .where.not(user_id: nil)
-                                 .group(:contestant_id)
-                                 .distinct
-                                 .count(:user_id)
-      end
-
-      # Writes vote_count + unique_voter_count to each contestant row.
-      # Uses update_all (not upsert_all) because contestants always pre-exist —
-      # upsert_all's INSERT path would violate NOT NULL constraints on other columns.
-      def upsert_contestant_counts(voting_session_id, db_counts, unique_voter_counts)
-        updates = build_contestant_updates(voting_session_id, db_counts, unique_voter_counts)
-        updates.each do |attrs|
-          SpreeCmCommissioner::VotingContestant
-            .where(id: attrs[:id])
-            .update_all(vote_count: attrs[:vote_count], unique_voter_count: attrs[:unique_voter_count]) # rubocop:disable Rails/SkipsModelValidations
-        end
-      end
-
-      # Maps each contestant ID to its tallied counts; defaults to 0 when no votes exist.
-      def build_contestant_updates(voting_session_id, db_counts, unique_voter_counts)
-        SpreeCmCommissioner::VotingContestant
-          .where(voting_session_id: voting_session_id)
-          .pluck(:id)
-          .map do |id|
-            {
-              id: id,
-              vote_count: db_counts[id].to_i,
-              unique_voter_count: unique_voter_counts[id].to_i
-            }
-          end
-      end
-
-      # Calculates session-level aggregates and upserts the VotingSessionStat record.
-      def upsert_session_stat(voting_session, db_counts)
-        total_vote_count      = db_counts.values.sum
-        unique_voter_count    = fetch_session_unique_voter_count(voting_session.id)
-        leading_contestant_id = find_leading_contestant_id(db_counts)
-        vote_velocity         = calculate_vote_velocity(voting_session, total_vote_count)
-
-        stat = SpreeCmCommissioner::VotingSessionStat.find_or_initialize_by(voting_session_id: voting_session.id)
-        stat.update!(
-          unique_voter_count: unique_voter_count,
-          total_vote_count: total_vote_count,
-          vote_velocity: vote_velocity,
-          leading_contestant_id: leading_contestant_id
-        )
-      end
-
-      # Counts distinct users who cast at least one vote in the session (cross-contestant deduplication).
-      def fetch_session_unique_voter_count(voting_session_id)
-        SpreeCmCommissioner::Vote.for_session(voting_session_id)
-                                 .where.not(user_id: nil)
-                                 .distinct
-                                 .count(:user_id)
-      end
-
-      # Returns the contestant_id with the highest vote total, or nil when db_counts is empty.
-      def find_leading_contestant_id(db_counts)
-        db_counts.max_by { |_, v| v }&.first
-      end
-
-      # Votes per minute over the session window; minimum 1 minute prevents division by zero.
-      def calculate_vote_velocity(voting_session, total_vote_count)
-        duration_minutes = [(voting_session.closes_at - voting_session.opens_at) / 60.0, 1].max
-        (total_vote_count / duration_minutes).round(2)
-      end
-    end
-  end
-end

data/app/services/spree_cm_commissioner/vote_credit_deductor.rb

@@ -1,68 +0,0 @@
-# Deducts voting credits for one vote submission.
-#
-# Finds the eligible VotingCredit for the user scoped to the session's show,
-# locks the row, deducts free votes first then paid, and records transactions.
-# Raises RuntimeError on any business-rule violation so the caller rolls back.
-module SpreeCmCommissioner
-  class VoteCreditDeductor
-    attr_reader :voting_session, :contestant, :user, :quantity
-
-    def initialize(
-      voting_session:, # VotingSession the vote belongs to
-      contestant:,     # VotingContestant being voted for
-      user:,           # Spree::User casting the vote
-      quantity:        # number of votes to cast
-    )
-      @voting_session = voting_session
-      @contestant = contestant
-      @user = user
-      @quantity = quantity
-    end
-
-    # Returns the VotingCredit that was deducted.
-    def call
-      credit = find_eligible_credit
-      raise 'No eligible voting credits available' if credit.nil?
-
-      credit.with_lock do
-        raise 'Insufficient voting credits' unless credit.can_use?(quantity)
-
-        # Deduct free votes first, then paid.
-        # Example: quantity=5, free_remaining=3, paid_remaining=10
-        #   free_deduct=3, paid_deduct=2
-        free_deduct = [credit.free_votes_remaining, quantity].min
-        paid_deduct = quantity - free_deduct
-
-        credit.update!(
-          free_votes_used: credit.free_votes_used + free_deduct,
-          paid_votes_used: credit.paid_votes_used + paid_deduct
-        )
-
-        memo = "Used #{quantity}, paid: #{paid_deduct}, free: #{free_deduct} votes for voting session #{voting_session.id}"
-        SpreeCmCommissioner::VotingCreditTransaction.create!(
-          tenant_id: credit.tenant_id,
-          vote_credit: credit,
-          action: :use,
-          amount: quantity,
-          originator: voting_session,
-          episode_id: voting_session.episode_id,
-          user_total_amount: credit.available_votes,
-          memo: memo
-        )
-      end
-
-      credit
-    end
-
-    private
-
-    def find_eligible_credit
-      votable_type = voting_session.show.credit_votable_type
-
-      user.voting_credits
-          .eligible(voting_session)
-          .where(votable_type: votable_type)
-          .first
-    end
-  end
-end

data/app/services/spree_cm_commissioner/vote_package/create.rb

@@ -1,145 +0,0 @@
-module SpreeCmCommissioner
-  module VotePackage
-    class Create
-      prepend Spree::ServiceModule::Base
-
-      def call(params:)
-        @params = params
-
-        # First build the vote package object
-        build_vote_package
-
-        # Prepare data outside transaction to reduce lock time
-        assign_store
-        assign_season
-        set_public_metadata
-        set_option_value
-
-        # Only include actual database writes in the transaction
-        ActiveRecord::Base.transaction do
-          save_vote_package
-          create_variant
-          create_stock_item
-        end
-
-        success(vote_package: @vote_package)
-      rescue StandardError => e
-        failure(nil, e.message)
-      end
-
-      private
-
-      def build_vote_package
-        @vote_package = SpreeCmCommissioner::ShowEpisode.new(vote_package_params)
-        @vote_package.product_type = :vote_package
-      end
-
-      def save_vote_package
-        return if @vote_package.save
-
-        raise @vote_package.errors.full_messages.join(', ')
-      end
-
-      def assign_store
-        @store = Spree::Store.default
-        @vote_package.stores << @store if @vote_package.stores.empty?
-      end
-
-      def assign_season
-        @season = Spree::Taxon.find_by(id: @params[:event_id])
-        raise 'Season not found.' unless @season
-
-        @vote_package.event_id = @season.id
-        @vote_package.taxons = [@season]
-        @vote_package.vendor = @season.vendor || @params[:vendor]
-        @vote_package.shipping_category = Spree::ShippingCategory.first_or_create!(name: 'Default')
-      end
-
-      def set_public_metadata
-        @vote_package.votable_type = @params[:votable_type]
-        @vote_package.votable_id = @params[:votable_id] if @params[:votable_id].present?
-      end
-
-      def set_option_value
-        @option_type = Spree::OptionType.find_or_create_by!(
-          name: 'vote-package',
-          presentation: 'Vote Package'
-        )
-
-        @color_option_type = Spree::OptionType.find_or_create_by!(
-          name: 'color',
-          presentation: 'Color'
-        )
-
-        @label_option_type = Spree::OptionType.find_or_create_by!(
-          name: 'label',
-          presentation: 'Label'
-        )
-
-        @option_type.update(attr_type: 'integer') if @option_type.respond_to?(:attr_type)
-        @color_option_type.update(attr_type: 'color') if @color_option_type.respond_to?(:attr_type)
-        @label_option_type.update(attr_type: 'string') if @label_option_type.respond_to?(:attr_type)
-
-        # auto assign the option types to the vote package
-        @vote_package.option_types << @option_type unless @vote_package.option_types.include?(@option_type)
-        @vote_package.option_types << @color_option_type unless @vote_package.option_types.include?(@color_option_type)
-        @vote_package.option_types << @label_option_type unless @vote_package.option_types.include?(@label_option_type)
-
-        # get vote credit options from params for scalability
-        # can be either an array of options or a single number
-        raise 'Vote credits is required.' if @params[:vote_credits].blank?
-
-        vote_credit_options = [
-          {
-            name: @params[:vote_credits].to_s,
-            presentation: "#{@params[:vote_credits]} Vote Credits"
-          }
-        ]
-
-        @option_values = vote_credit_options.map do |option|
-          Spree::OptionValue.find_or_create_by!(
-            name: option[:name],
-            presentation: option[:presentation],
-            option_type_id: @option_type.id
-          )
-        end
-      end
-
-      def create_variant
-        @variant = @vote_package.variants.new(
-          price: @vote_package.price,
-          compare_at_price: @vote_package.compare_at_price,
-          option_value_ids: @option_values.map(&:id)
-        )
-
-        return if @variant.save
-
-        raise @variant.errors.full_messages.join(', ')
-      end
-
-      def create_stock_item
-        stock_movement_context = SpreeCmCommissioner::Stock::StockMovementCreator.call(
-          variant_id: @variant.id,
-          stock_location_id: @params[:stock_location_id],
-          current_store: @store,
-          stock_movement_params: { quantity: @params[:count_on_hand] }
-        )
-
-        return if stock_movement_context.success?
-
-        raise stock_movement_context.message
-      end
-
-      def vote_package_params
-        {
-          name: "#{@params[:vote_credits]} Vote Packs",
-          price: @params[:price],
-          compare_at_price: @params[:compare_at_price],
-          available_on: @params[:available_on],
-          discontinue_on: @params[:discontinue_on],
-          status: @params[:status]
-        }
-      end
-    end
-  end
-end

data/app/services/spree_cm_commissioner/vote_package/update.rb

@@ -1,91 +0,0 @@
-module SpreeCmCommissioner
-  module VotePackage
-    class Update
-      prepend Spree::ServiceModule::Base
-
-      def call(vote_package:, params:, place_params: nil, option_values_attributes: {})
-        @vote_package = vote_package
-        @params = params
-        @place_params = place_params || params
-        @option_values_attributes = option_values_attributes.presence || @params.dig(:variant, :option_values_attributes) || {}
-
-        ActiveRecord::Base.transaction do
-          set_public_metadata
-          update_variant_option_values
-          update_vote_package
-          update_variant_price
-        end
-
-        success(vote_package: @vote_package)
-      rescue StandardError => e
-        failure(nil, e.message)
-      end
-
-      private
-
-      def set_public_metadata
-        @vote_package.votable_type = @params[:votable_type] if @params[:votable_type].present?
-        @vote_package.votable_id = @params[:votable_id] if @params[:votable_id].present?
-      end
-
-      def update_vote_package
-        return if @vote_package.update(vote_package_params)
-
-        raise @vote_package.errors.full_messages.join(', ')
-      end
-
-      def update_variant_option_values
-        variant = @vote_package.variants.first
-        return unless variant
-        return if @option_values_attributes.blank?
-
-        option_values = @option_values_attributes.values
-        variant.option_values = option_values.each_with_object([]) do |option_value, new_option_values|
-          option_type_id = option_value[:option_type_id] || option_value['option_type_id']
-          option_value_name = validated_option_value_name(option_value[:name] || option_value['name'], option_type_id)
-          next if option_value_name.blank?
-
-          option_type = @vote_package.option_types.find(option_type_id)
-          existing_option_value = option_type.option_values.find_or_create_by(name: option_value_name) do |new_option_value|
-            new_option_value.presentation = option_value_name.to_s.strip.titleize
-          end
-
-          new_option_values << existing_option_value
-        end
-
-        variant.save!
-      end
-
-      def update_variant_price
-        variant = @vote_package.variants.first
-        return unless variant
-
-        return if variant.update(
-          price: @vote_package.price,
-          compare_at_price: @vote_package.compare_at_price
-        )
-
-        raise variant.errors.full_messages.join(', ')
-      end
-
-      def validated_option_value_name(name, option_type_id)
-        return nil if name.blank?
-
-        option_value = Spree::OptionValue.new(name: name, option_type_id: option_type_id)
-        option_value.validate
-        option_value.name
-      end
-
-      def vote_package_params
-        {
-          name: @params[:name],
-          price: @params[:price],
-          compare_at_price: @params[:compare_at_price],
-          available_on: @params[:available_on],
-          discontinue_on: @params[:discontinue_on],
-          status: @params[:status]
-        }
-      end
-    end
-  end
-end

data/app/services/spree_cm_commissioner/vote_processor.rb

@@ -1,144 +0,0 @@
-# Domain service: orchestrates a single vote submission end-to-end.
-#
-# Responsibilities (in order):
-#   1. Guard-clause validation (session open, contestant scoped, credit user check)
-#   2. Fraud detection hook (stub – implement rate-limiting here)
-#   3. Credit deduction via VoteCreditDeductor (free votes first, then paid)
-#   4. Vote persistence (cm_votes)
-#   5. Redis leaderboard increment
-#
-# Returns a Result value object – never raises to caller.
-# Steps 3-4 run inside a single DB transaction so a credit is never
-# deducted without a persisted vote row.
-# Step 5 (Redis) runs outside the transaction. A Redis failure is logged but
-# does NOT fail the request — the DB commit is the source of truth and counters
-# can be rebuilt via VoteCounters::RebuildFromDb.
-module SpreeCmCommissioner
-  class VoteProcessor
-    prepend ::Spree::ServiceModule::Base
-
-    attr_reader :voting_session, :contestant, :user, :params, :request
-
-    def call(voting_session:, contestant:, user:, params: {}, request: nil)
-      @voting_session = voting_session
-      @contestant     = contestant
-      @user           = user
-      @params         = params
-      @request        = request
-
-      validate!
-      vote = nil
-
-      ActiveRecord::Base.transaction do
-        check_fraud!
-        credit = allocate_credit
-        vote = persist_vote!(credit)
-      end
-
-      increment_redis_counter(vote)
-
-      success(vote)
-    rescue RuntimeError, ActiveRecord::RecordInvalid, ArgumentError => e
-      failure(nil, e.message)
-    rescue StandardError => e
-      CmAppLogger.error(
-        label: 'VoteProcessor unexpected error',
-        data: {
-          voting_session_id: voting_session.id,
-          contestant_id: contestant.id,
-          user_id: user&.id,
-          error_class: e.class.name,
-          error_message: e.message,
-          backtrace: e.backtrace&.first(5)&.join("\n")
-        }
-      )
-
-      failure(nil, 'Vote could not be processed')
-    end
-
-    private
-
-    def validate!
-      raise 'Voting session is not active'                         unless voting_session.can_vote?
-      raise 'Contestant does not belong to this voting session'    unless contestant_belongs_to_session?
-      raise 'Authenticated user is required'                       if user.nil?
-      raise 'Quantity must be a positive integer'                  unless quantity.positive?
-    end
-
-    def contestant_belongs_to_session?
-      voting_session.voting_contestants.exists?(id: contestant.id)
-    end
-
-    def check_fraud!
-      result = SpreeCmCommissioner::FraudCheck.call(
-        voting_session: voting_session,
-        contestant: contestant,
-        user: user,
-        params: params,
-        request: request
-      )
-
-      raise result.error.value if result.failure?
-    end
-
-    # Redis increment is best-effort: a failure here must not roll back the
-    # committed vote row or trigger a client retry (which would double-count).
-    # RebuildFromDb can reconcile counters if drift is detected.
-    def increment_redis_counter(vote)
-      SpreeCmCommissioner::VoteCounters::Increment.call(
-        voting_session_id: voting_session.id,
-        contestant_id: contestant.id,
-        quantity: quantity
-      )
-    rescue StandardError => e
-      CmAppLogger.error(
-        label: 'VoteProcessor Redis increment failed',
-        data: {
-          vote_id: vote.id,
-          voting_session_id: voting_session.id,
-          contestant_id: contestant.id,
-          error_class: e.class.name,
-          error_message: e.message
-        }
-      )
-
-      # Create the maintenance task row so OrchestrateJob picks it up once Redis recovers.
-      # async_execute is intentionally skipped here — it enqueues via Sidekiq which also
-      # needs Redis, so it would always fail when Redis is down.
-      SpreeCmCommissioner::MaintenanceTasks::VotingSession.pending.find_or_create_by(
-        maintainable_type: 'SpreeCmCommissioner::VotingSession',
-        maintainable_id: voting_session.id
-      )
-    end
-
-    def allocate_credit
-      SpreeCmCommissioner::VoteCreditDeductor.new(
-        voting_session: voting_session,
-        contestant: contestant,
-        user: user,
-        quantity: quantity
-      ).call
-    end
-
-    def persist_vote!(credit)
-      SpreeCmCommissioner::Vote.create!(
-        tenant_id: params[:tenant_id],
-        vendor_id: params[:vendor_id],
-        voting_session: voting_session,
-        contestant: contestant,
-        user: user,
-        vote_credit: credit,
-        voter_identifier: params[:voter_identifier],
-        channel: params[:channel],
-        quantity: quantity,
-        device_fingerprint: params[:device_fingerprint],
-        ip_address: request&.remote_ip,
-        public_metadata: params[:public_metadata] || {}
-      )
-    end
-
-    def quantity
-      @quantity ||= params[:quantity].to_i
-    end
-  end
-end