spree_cm_commissioner 2.8.2.pre.pre.2 → 2.8.2

data/app/services/spree_cm_commissioner/fraud_check.rb

@@ -1,279 +0,0 @@
-# Real-time fraud detection for vote submissions.
-#
-# Runs four checks in order:
-#   1. User rate limit   – max votes per minute per user
-#   2. IP rate limit     – max votes per minute per IP
-#   3. Device account limit – max distinct accounts per device fingerprint
-#   4. VPN / proxy block – reject known VPN IPs (when enabled)
-
-# On any violation, raises RuntimeError with an I18n user-facing message
-# and enqueues a VoteFraudEventJob asynchronously.
-
-# All Redis operations use SpreeCmCommissioner.voting_redis_pool.
-module SpreeCmCommissioner
-  class FraudCheck
-    prepend ::Spree::ServiceModule::Base
-
-    DEFAULTS = {
-      'max_votes_per_minute_per_user' => 5,
-      'max_votes_per_minute_per_ip' => 10,
-      'max_accounts_per_device' => 3,
-      'block_vpn' => false
-    }.freeze
-
-    RATE_WINDOW = 60 # seconds
-    VPN_CACHE_TTL = 3600 # 1 hour
-
-    attr_reader :voting_session, :contestant, :user, :params, :request
-
-    def call(voting_session:, user:, params:, request:, contestant: nil)
-      @voting_session = voting_session
-      @contestant     = contestant
-      @user           = user
-      @params         = params
-      @request        = request
-
-      return success(nil) if fraud_config.blank?
-
-      check_user_rate_limit!
-      check_ip_rate_limit!
-      check_device_account_limit!
-      check_vpn_block!
-
-      success(nil)
-    rescue Redis::BaseError, ConnectionPool::TimeoutError => e
-      # Fail-open: a Redis outage should not take down voting entirely.
-      # Catches both Redis protocol errors and connection pool exhaustion/timeout.
-      # Must be rescued BEFORE RuntimeError because Redis::BaseError < RuntimeError
-      # in redis gem v4.x — placing it after RuntimeError would let the wrong clause win.
-      # Log the error so it is visible in monitoring, but let the vote through.
-      # If the policy should be fail-closed instead, replace the rescue body
-      # with: failure(I18n.t('voting.errors.service_unavailable'))
-      CmAppLogger.error(
-        label: 'FraudCheck Redis error — failing open',
-        data: {
-          voting_session_id: voting_session.id,
-          user_id: user&.id,
-          error_class: e.class.name,
-          error_message: e.message
-        }
-      )
-      success(nil)
-    rescue RuntimeError => e
-      failure(nil, e.message)
-    end
-
-    private
-
-    def fraud_config
-      @fraud_config ||= voting_session.effective_fraud_config
-    end
-
-    def config_value(key)
-      value = fraud_config.fetch(key, DEFAULTS[key])
-      default = DEFAULTS[key]
-      default.is_a?(Integer) ? value.to_i : value
-    end
-
-    def session_id
-      voting_session.id
-    end
-
-    def user_identifier
-      user&.id || params[:voter_identifier]
-    end
-
-    def ip_address
-      request&.remote_ip || params[:ip_address]
-    end
-
-    def device_fingerprint
-      params[:device_fingerprint]
-    end
-
-    def quantity
-      [params[:quantity].to_i, 1].max
-    end
-
-    # --- Check 1: User rate limit ---
-
-    def check_user_rate_limit!
-      threshold = config_value('max_votes_per_minute_per_user')
-      return if threshold.nil? || threshold <= 0
-
-      key = "fraud:rate:user:#{session_id}:#{user_identifier}"
-      count = increment_with_expiry(key, RATE_WINDOW, by: quantity)
-
-      return unless count > threshold
-
-      log_fraud_event(:rate_limit, :medium)
-      raise I18n.t('voting.errors.rate_limit_user')
-    end
-
-    # --- Check 2: IP rate limit ---
-
-    def check_ip_rate_limit!
-      return if ip_address.blank?
-
-      threshold = config_value('max_votes_per_minute_per_ip')
-      return if threshold.nil? || threshold <= 0
-
-      key = "fraud:rate:ip:#{session_id}:#{ip_address}"
-      count = increment_with_expiry(key, RATE_WINDOW, by: quantity)
-
-      return unless count > threshold
-
-      log_fraud_event(:ip_cluster, :medium)
-      raise I18n.t('voting.errors.rate_limit_ip')
-    end
-
-    # --- Check 3: Device account limit ---
-
-    def check_device_account_limit!
-      return if device_fingerprint.blank?
-
-      threshold = config_value('max_accounts_per_device')
-      return if threshold.nil? || threshold <= 0
-
-      key = "fraud:device:#{session_id}:#{device_fingerprint}"
-      member = user_identifier.to_s
-
-      card = sadd_with_expiry(key, member, session_ttl)
-
-      return unless card > threshold
-
-      log_fraud_event(:device_duplicate, :high)
-      raise I18n.t('voting.errors.device_account_limit')
-    end
-
-    # --- Check 4: VPN / proxy block ---
-
-    def check_vpn_block!
-      return unless config_value('block_vpn')
-      return if ip_address.blank?
-
-      return unless vpn_detected?(ip_address)
-
-      log_fraud_event(:anomaly, :high)
-      raise I18n.t('voting.errors.vpn_blocked')
-    end
-
-    # --- Redis helpers ---
-
-    # Atomically increments a counter key and sets its TTL on the first write.
-    #
-    # Why Lua: issuing INCRBY then EXPIRE as two separate commands creates a race
-    # where another request can read the key between the two commands, or the TTL
-    # can be set more than once (resetting the window) if two requests race on the
-    # first write. Running both commands inside a Lua script executes them as a
-    # single atomic unit in Redis, eliminating the race entirely.
-    #
-    # KEYS[1] – the Redis key to increment
-    # ARGV[1] – increment amount (quantity)
-    # ARGV[2] – TTL in seconds for the rate window
-    #
-    # Returns the new count after incrementing.
-    INCRBY_WITH_EXPIRY_SCRIPT = <<~LUA.freeze
-      local count = redis.call('INCRBY', KEYS[1], ARGV[1])
-      if count == tonumber(ARGV[1]) then
-        redis.call('EXPIRE', KEYS[1], ARGV[2])
-      end
-      return count
-    LUA
-
-    # Atomically adds a member to a set, sets TTL on the first write, and
-    # returns the set cardinality.
-    #
-    # Why Lua: SADD, EXPIRE, and SCARD as separate commands can interleave with
-    # other requests — a concurrent SADD could reset the TTL unintentionally, or
-    # SCARD could be read before EXPIRE is applied. The Lua script runs all three
-    # atomically, guaranteeing a consistent view of the set on every call.
-    #
-    # KEYS[1] – the Redis set key
-    # ARGV[1] – the member to add (user identifier)
-    # ARGV[2] – TTL in seconds; skipped when 0
-    #
-    # Returns the number of distinct members in the set after the add.
-    SADD_WITH_EXPIRY_SCRIPT = <<~LUA.freeze
-      redis.call('SADD', KEYS[1], ARGV[1])
-      if redis.call('TTL', KEYS[1]) == -1 and tonumber(ARGV[2]) > 0 then
-        redis.call('EXPIRE', KEYS[1], ARGV[2])
-      end
-      return redis.call('SCARD', KEYS[1])
-    LUA
-
-    def increment_with_expiry(key, ttl, by: 1)
-      with_redis { |r| r.eval(INCRBY_WITH_EXPIRY_SCRIPT, keys: [key], argv: [by, ttl]) }
-    end
-
-    def sadd_with_expiry(key, member, ttl)
-      with_redis { |r| r.eval(SADD_WITH_EXPIRY_SCRIPT, keys: [key], argv: [member, ttl]) }
-    end
-
-    def with_redis(&block)
-      SpreeCmCommissioner.voting_redis_pool.with(&block)
-    end
-
-    def session_ttl
-      return RATE_WINDOW unless voting_session.closes_at
-
-      remaining = (voting_session.closes_at - Time.current).to_i
-      [remaining, RATE_WINDOW].max
-    end
-
-    # --- VPN detection ---
-    # Checks a Redis cache first (TTL = VPN_CACHE_TTL). If no cached result,
-    # delegates to lookup_vpn and caches the outcome.
-    #
-    # Cache values: '1' = VPN/proxy detected, '0' = clean.
-    # This avoids hitting the external provider on every vote request.
-    #
-    # To manually mark an IP as a VPN for testing:
-    #   SpreeCmCommissioner.voting_redis_pool.with { |r| r.setex("fraud:vpn:<ip>", 3600, '1') }
-
-    def vpn_detected?(ip)
-      cache_key = "fraud:vpn:#{ip}"
-
-      cached = with_redis { |r| r.get(cache_key) }
-      return cached == '1' unless cached.nil?
-
-      result = lookup_vpn(ip)
-      with_redis { |r| r.setex(cache_key, VPN_CACHE_TTL, result ? '1' : '0') }
-      result
-    end
-
-    # Placeholder for external VPN/proxy detection. Currently always returns
-    # false, making block_vpn a no-op unless Redis is pre-seeded manually.
-    #
-    # To activate, replace this method body with a real provider call, e.g.:
-    #   - ip-api.com  → HTTP GET http://ip-api.com/json/<ip>?fields=proxy,hosting
-    #   - MaxMind     → local GeoIP2 DB lookup (no network call, best for high traffic)
-    #   - Blocklist   → check against a maintained list of known VPN/datacenter CIDRs
-    #
-    # The Redis caching in vpn_detected? is already in place, so the provider
-    # is only called once per unique IP per VPN_CACHE_TTL window.
-    def lookup_vpn(_ip)
-      false
-    end
-
-    # --- Fraud event logging (async) ---
-
-    def log_fraud_event(fraud_type, severity)
-      SpreeCmCommissioner::VoteFraudEventJob.perform_later(
-        tenant_id: voting_session.vendor.tenant_id,
-        user_id: user&.id,
-        voting_session_id: voting_session.id,
-        fraud_type: fraud_type,
-        severity: severity,
-        action_taken: :blocked,
-        details: {
-          ip_address: ip_address,
-          device_fingerprint: device_fingerprint,
-          voter_identifier: params[:voter_identifier],
-          contestant_id: contestant&.id,
-          contestant_name: contestant&.name
-        }
-      )
-    end
-  end
-end

data/app/services/spree_cm_commissioner/show_contestants/normalize_video_highlights.rb

@@ -1,57 +0,0 @@
-module SpreeCmCommissioner
-  module ShowContestants
-    class NormalizeVideoHighlights
-      prepend ::Spree::ServiceModule::Base
-
-      def call(raw_video_highlights: nil)
-        return success(video_highlights: []) if raw_video_highlights.blank?
-
-        video_highlights = normalize_video_highlights(raw_video_highlights: raw_video_highlights)
-
-        success(video_highlights: video_highlights)
-      rescue StandardError => e
-        failure(nil, e.message)
-      end
-
-      private
-
-      def normalize_video_highlights(raw_video_highlights:)
-        return [] if raw_video_highlights.blank?
-
-        source = normalize_source(raw_video_highlights)
-        normalized = source.map { |payload| normalize_video(payload) }
-        normalized.reject { |video| video_empty?(video) }
-      end
-
-      def normalize_source(raw_video_highlights)
-        return raw_video_highlights if raw_video_highlights.is_a?(Array)
-
-        raw_video_highlights.to_h.sort_by { |index, _| index.to_i }.map(&:last)
-      end
-
-      def normalize_video(payload)
-        payload_hash = payload.to_h
-        uri = extract_value(payload_hash, 'uri').to_s.strip
-
-        {
-          'title' => extract_value(payload_hash, 'title').to_s.strip,
-          'description' => extract_value(payload_hash, 'description').to_s.strip,
-          'uri' => uri.present? ? embed_youtube_url(uri) : uri
-        }
-      end
-
-      def extract_value(hash, key)
-        hash[key] || hash[key.to_sym]
-      end
-
-      def embed_youtube_url(uri)
-        result = UrlEmbed::YoutubeEmbed.call(url: uri)
-        result.success? ? result.value : uri
-      end
-
-      def video_empty?(video)
-        video&.dig('title').blank? && video&.dig('description').blank? && video&.dig('uri').blank?
-      end
-    end
-  end
-end

data/app/services/spree_cm_commissioner/url_embed/youtube_embed.rb

@@ -1,44 +0,0 @@
-# Converts various YouTube URL formats to embeddable iframe URLs.
-#
-# Examples:
-#   result = YoutubeEmbed.call(url: "https://www.youtube.com/watch?v=dQw4w9WgXcQ")
-#   result.success? # => true
-#   result.value    # => "https://www.youtube.com/embed/dQw4w9WgXcQ"
-#
-#   result = YoutubeEmbed.call(url: "https://youtu.be/dQw4w9WgXcQ")
-#   result.success? # => true
-module SpreeCmCommissioner
-  module UrlEmbed
-    class YoutubeEmbed
-      prepend ::Spree::ServiceModule::Base
-
-      def call(url:)
-        return failure(nil, 'URL is blank') if url.blank?
-
-        video_id = self.class.extract_video_id(url.to_s.strip)
-        return failure(nil, 'Invalid YouTube URL') unless video_id
-
-        success("https://www.youtube.com/embed/#{video_id}")
-      end
-
-      # Extracts video ID from YouTube URL (used for thumbnails, etc.)
-      def self.extract_video_id(url_string)
-        return nil if url_string.blank?
-
-        PATTERNS.lazy.map { |pattern| url_string[pattern, 1] }.find(&:present?)
-      end
-
-      # Regex patterns to extract video IDs from various YouTube URL formats
-      # Supports: watch?v=, youtu.be, embed, shorts, live, and /v/ URLs
-      # All patterns capture alphanumeric characters, underscores, and hyphens as video IDs
-      PATTERNS = [
-        %r{youtube\.com/watch\?v=([a-zA-Z0-9_-]+)}, # Standard watch URL
-        %r{youtu\.be/([a-zA-Z0-9_-]+)},              # Shortened youtu.be URL
-        %r{youtube\.com/embed/([a-zA-Z0-9_-]+)},     # Already embedded URL
-        %r{youtube\.com/shorts/([a-zA-Z0-9_-]+)},    # YouTube Shorts
-        %r{youtube\.com/live/([a-zA-Z0-9_-]+)},      # YouTube Live
-        %r{youtube\.com/v/([a-zA-Z0-9_-]+)}          # Legacy /v/ format
-      ].freeze
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-# Compares Redis vote counters against cm_votes for a given voting session.
-#
-# Logs a mismatch via CmAppLogger when Redis and DB counts diverge.
-# Use for post-session auditing or on-demand reconciliation.
-#
-# Usage:
-#   SpreeCmCommissioner::VoteCounters::AuditCounters.call(voting_session_id: id)
-module SpreeCmCommissioner
-  module VoteCounters
-    class AuditCounters < Base
-      prepend ::Spree::ServiceModule::Base
-
-      def call(voting_session_id:)
-        @voting_session_id = voting_session_id
-
-        db_counts = SpreeCmCommissioner::Vote.for_session(voting_session_id)
-                                             .group(:contestant_id)
-                                             .sum(:quantity)
-        per_contestant_result = SpreeCmCommissioner::VoteCounters::PerContestantCounter
-                                .call(voting_session_id: voting_session_id)
-        return failure(nil, per_contestant_result.error.value) if per_contestant_result.failure?
-
-        redis_counts = per_contestant_result.value[:counts]
-
-        redis_counts.each do |contestant_id, redis_count|
-          db_count = db_counts[contestant_id] || 0
-          next if redis_count == db_count
-
-          CmAppLogger.log(
-            label: 'VoteCounter mismatch',
-            data: {
-              voting_session_id: voting_session_id,
-              contestant_id: contestant_id,
-              redis_count: redis_count,
-              db_count: db_count
-            }
-          )
-        end
-        success(nil)
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-module SpreeCmCommissioner
-  module VoteCounters
-    class Base
-      REDIS_KEY_TTL = 86_400 # 24 hours
-
-      attr_reader :voting_session_id
-
-      private
-
-      def vote_key(contestant_id)
-        "vote:session:#{voting_session_id}:contestant:#{contestant_id}"
-      end
-
-      def contestant_ids
-        @contestant_ids ||= voting_session.voting_contestants.pluck(:id)
-      end
-
-      def voting_session
-        @voting_session ||= SpreeCmCommissioner::VotingSession.find(voting_session_id)
-      end
-
-      def session_ttl
-        [(voting_session.closes_at - Time.current).to_i + 1.day.to_i, 1].max
-      end
-
-      def with_redis(&block)
-        SpreeCmCommissioner.voting_redis_pool.with(&block)
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-# Atomically increments a contestant's Redis vote counter.
-#
-# Uses a Lua script so INCRBY+EXPIRE is a single atomic round trip.
-# Unique voter counts are read from cm_votes table, not tracked here.
-#
-# Usage:
-#   SpreeCmCommissioner::VoteCounters::Increment.call(
-#     voting_session_id: id,
-#     contestant_id: id,
-#     quantity: 3
-#   )
-module SpreeCmCommissioner
-  module VoteCounters
-    class Increment < Base
-      prepend ::Spree::ServiceModule::Base
-
-      def call(voting_session_id:, contestant_id:, quantity: 1)
-        @voting_session_id = voting_session_id
-
-        with_redis do |redis|
-          redis.eval(
-            increment_script,
-            keys: [vote_key(contestant_id)],
-            argv: [quantity, session_ttl]
-          )
-        end
-
-        success(nil)
-      end
-
-      private
-
-      # INCRBY + EXPIRE in one atomic round trip.
-      # TTL is closes_at + 1 day so the key outlives the session and cleans up naturally.
-      def increment_script
-        <<~LUA
-          local new_count = redis.call('INCRBY', KEYS[1], tonumber(ARGV[1]))
-          redis.call('EXPIRE', KEYS[1], tonumber(ARGV[2]))
-          return new_count
-        LUA
-      end
-    end
-  end
-end

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

@@ -1,68 +0,0 @@
-# Fetches vote counts from Redis and unique voter counts from the database.
-#
-# Returns a Result whose value is:
-#   {
-#     counts:                       { contestant_id => Integer },
-#     unique_voters:                Integer,
-#     unique_voters_per_contestant: { contestant_id => Integer }
-#   }
-#
-# Vote counts come from Redis (fast, real-time leaderboard).
-# Unique voter counts come from cm_votes (accurate, no Redis set overhead).
-#
-# Usage:
-#   SpreeCmCommissioner::VoteCounters::PerContestantCounter.call(voting_session_id: id).value
-module SpreeCmCommissioner
-  module VoteCounters
-    class PerContestantCounter < Base
-      prepend ::Spree::ServiceModule::Base
-
-      EMPTY_RESULT = {
-        counts: {}.freeze,
-        unique_voters: 0,
-        unique_voters_per_contestant: {}.freeze
-      }.freeze
-
-      def call(voting_session_id:)
-        @voting_session_id = voting_session_id
-
-        ids = contestant_ids
-        return success(EMPTY_RESULT) if ids.empty?
-
-        counts = with_redis do |redis|
-          values = redis.mget(*ids.map { |id| vote_key(id) })
-          ids.zip(values).to_h { |id, v| [id, v.to_i] }
-        end
-
-        success(
-          counts: counts,
-          unique_voters: session_unique_voter_count,
-          unique_voters_per_contestant: contestant_unique_voter_counts(ids)
-        )
-      rescue StandardError => e
-        failure(nil, e.message)
-      end
-
-      private
-
-      def session_unique_voter_count
-        SpreeCmCommissioner::Vote
-          .where(voting_session_id: voting_session_id)
-          .where.not(user_id: nil)
-          .distinct
-          .count(:user_id)
-      end
-
-      def contestant_unique_voter_counts(ids)
-        rows = SpreeCmCommissioner::Vote
-               .where(voting_session_id: voting_session_id, contestant_id: ids)
-               .where.not(user_id: nil)
-               .group(:contestant_id)
-               .distinct
-               .count(:user_id)
-
-        ids.index_with { |id| rows.fetch(id, 0) }
-      end
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-# Rebuilds Redis vote counters from cm_votes for a given voting session.
-#
-# Overwrites existing Redis keys with DB totals — use to recover after
-# a Redis restart or counter drift.
-#
-# Usage:
-#   SpreeCmCommissioner::VoteCounters::RebuildFromDb.call(voting_session_id: id)
-module SpreeCmCommissioner
-  module VoteCounters
-    class RebuildFromDb < Base
-      prepend ::Spree::ServiceModule::Base
-
-      def call(voting_session_id:, ttl: nil)
-        @voting_session_id = voting_session_id
-        @ttl = ttl
-
-        rebuild_counts
-
-        success(nil)
-      end
-
-      private
-
-      # Rebuilds vote count keys for all contestants in the session.
-      #
-      # Queries VotingContestant (not Vote) so contestants with 0 DB votes are
-      # included — their stale Redis keys get DELed instead of left behind.
-      # Uses a single Lua EVAL so the entire operation is atomic: concurrent
-      # Increment calls cannot interleave between the DEL and SET commands.
-      def rebuild_counts
-        all_ids = SpreeCmCommissioner::VotingContestant
-                  .where(voting_session_id: @voting_session_id)
-                  .pluck(:id)
-        return if all_ids.empty?
-
-        db_counts = SpreeCmCommissioner::Vote.for_session(@voting_session_id)
-                                             .group(:contestant_id)
-                                             .sum(:quantity)
-
-        keys   = all_ids.map { |id| vote_key(id) }
-        counts = all_ids.map { |id| db_counts[id].to_i }
-
-        with_redis do |redis|
-          redis.eval(rebuild_counts_script, keys: keys, argv: counts + [@ttl])
-        end
-      end
-
-      # Atomically writes DB vote counts to Redis for all contestants.
-      # SET count + TTL for non-zero counts; DEL for zero-count contestants
-      # so stale keys from deleted votes are fully cleared.
-      def rebuild_counts_script
-        <<~LUA
-          local ttl = tonumber(ARGV[#ARGV])
-          for i, key in ipairs(KEYS) do
-            local count = tonumber(ARGV[i])
-            if count > 0 then
-              if ttl then
-                redis.call('SET', key, count, 'EX', ttl)
-              else
-                redis.call('SET', key, count)
-              end
-            else
-              redis.call('DEL', key)
-            end
-          end
-        LUA
-      end
-    end
-  end
-end