feat: implement result report

Author: Bulletdev

app/jobs/scrim_result_reminder_job.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+# Daily job that manages scrim result reporting lifecycle.
+#
+# Responsibilities:
+#   1. Initialize report records for accepted scrims that have passed their scheduled time
+#   2. Send reminders to orgs that haven't reported (at 24h and 48h before deadline)
+#   3. Expire reports where the deadline has passed without a submission
+#
+# Scheduled: daily at 10:00 UTC via sidekiq-scheduler
+class ScrimResultReminderJob < ApplicationJob
+  queue_as :default
+
+  REMINDER_THRESHOLDS = [
+    { days_before_deadline: 1, label: '24h' },
+    { days_before_deadline: 3, label: '3 days' }
+  ].freeze
+
+  def perform
+    initialize_pending_reports
+    send_reminders
+    expire_overdue_reports
+    record_job_heartbeat
+  rescue StandardError => e
+    Rails.logger.error("[ScrimResultReminderJob] Failed: #{e.message}\n#{e.backtrace.first(5).join("\n")}")
+    raise
+  end
+
+  private
+
+  # Creates ScrimResultReport records for accepted scrims that ended but haven't been reported yet
+  def initialize_pending_reports
+    accepted_past_scrims.find_each do |request|
+      deadline = [request.proposed_at, Time.current].max + ScrimResultReport::DEADLINE_DAYS.days
+
+      [request.requesting_organization_id, request.target_organization_id].each do |org_id|
+        ScrimResultReport.find_or_create_by!(
+          scrim_request_id: request.id,
+          organization_id: org_id
+        ) do |r|
+          r.status       = 'pending'
+          r.deadline_at  = deadline
+          r.attempt_count = 0
+        end
+      rescue ActiveRecord::RecordNotUnique
+        # Race condition — already exists, ignore
+      end
+    end
+  end
+
+  def send_reminders
+    REMINDER_THRESHOLDS.each do |threshold|
+      window_start = threshold[:days_before_deadline].days.from_now
+      window_end   = window_start + 1.hour
+
+      ScrimResultReport
+        .actionable
+        .where(deadline_at: window_start..window_end)
+        .includes(:organization, scrim_request: %i[requesting_organization target_organization])
+        .find_each do |report|
+          notify_pending_report(report, threshold[:label])
+        end
+    end
+  end
+
+  def expire_overdue_reports
+    ScrimResultReport.overdue.find_each do |report|
+      report.update_columns(status: 'expired', updated_at: Time.current)
+      Rails.logger.info("[ScrimResultReminderJob] Expired report id=#{report.id} org=#{report.organization_id}")
+    end
+  end
+
+  def accepted_past_scrims
+    ScrimRequest
+      .where(status: 'accepted')
+      .where('proposed_at < ?', Time.current)
+      .where(
+        'NOT EXISTS (' \
+        'SELECT 1 FROM scrim_result_reports srr ' \
+        'WHERE srr.scrim_request_id = scrim_requests.id)'
+      )
+  end
+
+  def notify_pending_report(report, deadline_label)
+    org  = report.organization
+    req  = report.scrim_request
+    opp  = req.requesting_organization_id == org.id ? req.target_organization : req.requesting_organization
+
+    Rails.logger.info(
+      "[ScrimResultReminderJob] Reminding org=#{org.id} (#{org.name}) " \
+      "to report scrim_request=#{req.id} vs #{opp.name} — #{deadline_label} before deadline"
+    )
+
+    # TODO: replace with in-app/email notification when notification system is implemented
+    # NotificationService.notify(org, :scrim_result_reminder, scrim_request: req, ...)
+  rescue StandardError => e
+    Rails.logger.warn("[ScrimResultReminderJob] Reminder failed for report=#{report.id}: #{e.message}")
+  end
+end

app/models/scrim_result_report.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# Stores one organization's reported outcome for a scrim series.
+#
+# Each ScrimRequest produces two reports — one per participating org.
+# The system compares both to determine if results match and marks the
+# confrontation as confirmed or disputed.
+#
+# Lifecycle:
+#   pending      → org has not reported yet
+#   reported     → this org reported, waiting for opponent
+#   confirmed    → both orgs reported matching results
+#   disputed     → reports conflict; orgs can re-report (up to MAX_ATTEMPTS)
+#   unresolvable → MAX_ATTEMPTS exceeded with persistent conflict
+#   expired      → DEADLINE_DAYS passed without a report from this org
+class ScrimResultReport < ApplicationRecord
+  STATUSES      = %w[pending reported confirmed disputed unresolvable expired].freeze
+  MAX_ATTEMPTS  = 3
+  DEADLINE_DAYS = 7
+
+  belongs_to :scrim_request
+  belongs_to :organization
+
+  validates :status, inclusion: { in: STATUSES }
+  validates :game_outcomes, presence: true, if: :reported_at?
+  validate  :outcomes_are_valid, if: :reported_at?
+  validate  :attempts_not_exceeded, if: :reported_at?
+
+  scope :actionable,    -> { where(status: %w[pending disputed]) }
+  scope :confirmed,     -> { where(status: 'confirmed') }
+  scope :overdue,       -> { actionable.where('deadline_at < ?', Time.current) }
+  scope :needs_reminder, lambda {
+    actionable
+      .where('deadline_at > ?', Time.current)
+      .where('deadline_at < ?', (ScrimResultReport::DEADLINE_DAYS - 1).days.from_now)
+  }
+
+  def series_winner_org_id
+    return nil unless status == 'confirmed'
+
+    wins   = game_outcomes.count('win')
+    losses = game_outcomes.count('loss')
+    wins > losses ? organization_id : opponent_organization_id
+  end
+
+  def opponent_organization_id
+    req = scrim_request
+    req.requesting_organization_id == organization_id ? req.target_organization_id : req.requesting_organization_id
+  end
+
+  def re_reportable?
+    status == 'disputed' && attempt_count < MAX_ATTEMPTS
+  end
+
+  def attempts_remaining
+    MAX_ATTEMPTS - attempt_count
+  end
+
+  private
+
+  def outcomes_are_valid
+    return if game_outcomes.blank?
+
+    return if game_outcomes.all? { |o| %w[win loss].include?(o) }
+
+    errors.add(:game_outcomes, 'must only contain "win" or "loss"')
+  end
+
+  def attempts_not_exceeded
+    return unless attempt_count >= MAX_ATTEMPTS && status_was == 'disputed'
+
+    errors.add(:base, 'Maximum reporting attempts exceeded')
+  end
+end

app/modules/matchmaking/services/match_suggestion_service.rb

@@ -39,7 +39,7 @@ def find_candidate_windows
                       .active
                       .by_game(@game)
                       .where.not(organization_id: @organization.id)
-                      .includes(:organization)
+                      .includes(organization: :players)
   end
 
   def score_window(window)
@@ -75,7 +75,9 @@ def build_suggestion(window, score)
         region: org.region,
         tier: map_subscription_to_tier(org.subscription_plan),
         public_tagline: org.try(:public_tagline),
-        discord_invite_url: org.try(:discord_invite_url)
+        discord_invite_url: org.try(:discord_invite_url),
+        avg_tier: compute_avg_tier(org),
+        **compute_record(org)
       },
       availability_window: {
         id: window.id,
@@ -84,11 +86,45 @@ def build_suggestion(window, score)
         time_range: window.time_range_display,
         start_hour: window.start_hour,
         end_hour: window.end_hour,
-        timezone: window.timezone
+        timezone: window.timezone,
+        focus_area: window.focus_area,
+        draft_type: window.draft_type,
+        tier_preference: window.tier_preference
       }
     }
   end
 
+  TIER_SCORE = {
+    'CHALLENGER' => 9, 'GRANDMASTER' => 8, 'MASTER' => 7,
+    'DIAMOND' => 6, 'EMERALD' => 5, 'PLATINUM' => 4,
+    'GOLD' => 3, 'SILVER' => 2, 'BRONZE' => 1, 'IRON' => 0
+  }.freeze
+
+  TIER_LABEL = {
+    9 => 'Challenger', 8 => 'Grandmaster', 7 => 'Master',
+    6 => 'Diamond', 5 => 'Emerald', 4 => 'Platinum',
+    3 => 'Gold', 2 => 'Silver', 1 => 'Bronze', 0 => 'Iron'
+  }.freeze
+
+  # Returns confirmed W/L from cross-org validated reports only
+  def compute_record(org)
+    confirmed = ScrimResultReport.confirmed.where(organization: org)
+    won  = confirmed.count { |r| r.series_winner_org_id == org.id }
+    lost = confirmed.size - won
+    { scrims_won: won, scrims_lost: lost, total_scrims: confirmed.size }
+  rescue StandardError
+    { scrims_won: nil, scrims_lost: nil, total_scrims: nil }
+  end
+
+  def compute_avg_tier(org)
+    players = org.players.active.select(:solo_queue_tier)
+    scores = players.map { |p| TIER_SCORE[p.solo_queue_tier.to_s.upcase] || 0 }
+    return nil if scores.empty?
+
+    avg = (scores.sum.to_f / scores.size).round
+    TIER_LABEL[avg]
+  end
+
   def map_subscription_to_tier(plan)
     case plan
     when 'professional', 'enterprise' then 'professional'

app/modules/scrims/controllers/scrim_result_reports_controller.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Scrims
+  module Controllers
+    # Handles submission and retrieval of scrim series result reports.
+    #
+    # POST   /api/v1/scrims/scrims/:scrim_id/result — submit outcome
+    # GET    /api/v1/scrims/scrims/:scrim_id/result — fetch current report status
+    class ScrimResultReportsController < Api::V1::BaseController
+      before_action :set_authorized_scrim
+      before_action :set_scrim_request
+
+      # GET /api/v1/scrims/scrims/:scrim_id/result
+      def show
+        my_report       = report_for(current_organization)
+        opponent_report = report_for(opponent_organization)
+
+        render_success({
+                         my_report: serialize_report(my_report),
+                         opponent_report: serialize_opponent_report(opponent_report),
+                         status: combined_status(my_report, opponent_report),
+                         deadline_at: my_report&.deadline_at&.iso8601,
+                         attempts_remaining: my_report ? my_report.attempts_remaining : ScrimResultReport::MAX_ATTEMPTS,
+                         max_attempts: ScrimResultReport::MAX_ATTEMPTS,
+                         games_planned: @scrim_request&.games_planned
+                       })
+      end
+
+      # POST /api/v1/scrims/scrims/:scrim_id/result
+      def create
+        unless @scrim_request
+          return render_error(
+            message: 'This scrim is not linked to a matchmaking request and cannot use cross-org result reporting.',
+            code: 'NO_SCRIM_REQUEST',
+            status: :unprocessable_entity
+          )
+        end
+
+        outcomes = params[:game_outcomes]
+        unless outcomes.is_a?(Array) && outcomes.present?
+          return render_error(
+            message: 'game_outcomes must be a non-empty array of "win"/"loss" values',
+            code: 'INVALID_PARAMS',
+            status: :unprocessable_entity
+          )
+        end
+
+        result = ScrimResultValidationService.new(
+          scrim_request: @scrim_request,
+          organization: current_organization,
+          game_outcomes: outcomes.map(&:to_s)
+        ).call
+
+        if result[:status] == :error
+          render_error(message: result[:message], code: 'VALIDATION_ERROR', status: :unprocessable_entity)
+        else
+          render_success({
+                           status: result[:status],
+                           report: serialize_report(result[:report]),
+                           message: status_message(result[:status])
+                         })
+        end
+      end
+
+      private
+
+      def set_authorized_scrim
+        @scrim = current_organization.scrims.find_by(id: params[:scrim_id])
+        render_error(message: 'Scrim not found', code: 'NOT_FOUND', status: :not_found) unless @scrim
+      end
+
+      def set_scrim_request
+        return unless @scrim
+
+        @scrim_request = ScrimRequest.find_by(id: @scrim.scrim_request_id)
+      end
+
+      def opponent_organization
+        return nil unless @scrim_request
+
+        opp_id = if @scrim_request.requesting_organization_id == current_organization.id
+                   @scrim_request.target_organization_id
+                 else
+                   @scrim_request.requesting_organization_id
+                 end
+        Organization.find_by(id: opp_id)
+      end
+
+      def report_for(org)
+        return nil unless @scrim_request && org
+
+        ScrimResultReport.find_by(scrim_request: @scrim_request, organization: org)
+      end
+
+      def combined_status(my, opponent)
+        return 'no_request'     unless @scrim_request
+        return 'pending'        unless my
+        return my.status        if %w[confirmed unresolvable expired].include?(my.status)
+        return 'waiting_opponent' if my.status == 'reported' && (!opponent || opponent.status == 'pending')
+
+        my.status
+      end
+
+      def serialize_report(report)
+        return nil unless report
+
+        {
+          id: report.id,
+          status: report.status,
+          game_outcomes: report.game_outcomes,
+          reported_at: report.reported_at&.iso8601,
+          confirmed_at: report.confirmed_at&.iso8601,
+          deadline_at: report.deadline_at&.iso8601,
+          attempt_count: report.attempt_count,
+          attempts_remaining: report.attempts_remaining
+        }
+      end
+
+      # Only exposes confirmation status to avoid leaking opponent's reported outcomes
+      # before both sides have submitted (prevents copying the opponent's report).
+      def serialize_opponent_report(report)
+        return nil unless report
+
+        exposable = %w[confirmed unresolvable expired]
+        {
+          status: report.status,
+          has_reported: report.reported_at?,
+          confirmed_at: report.confirmed_at&.iso8601,
+          # Only expose outcomes once both have reported (no oracle attack)
+          game_outcomes: exposable.include?(report.status) ? report.game_outcomes : nil
+        }
+      end
+
+      def status_message(status)
+        {
+          reported: 'Result submitted. Waiting for opponent to report.',
+          confirmed: 'Results match! Series result confirmed.',
+          disputed: 'Results conflict with opponent\'s report. Both teams must re-report. ' \
+                    "#{ScrimResultReport::MAX_ATTEMPTS} attempts total.",
+          unresolvable: 'Maximum attempts reached with conflicting reports. Result marked unresolvable.'
+        }[status] || 'Report received.'
+      end
+    end
+  end
+end