feat: implement inhouse

Author: Bulletdev

app/modules/inhouses/controllers/inhouses_controller.rb

@@ -21,6 +21,87 @@ module Controllers
     class InhousesController < Api::V1::BaseController
       before_action :set_inhouse, only: %i[join balance_teams record_game close]
 
+      # GET /api/v1/inhouse/ladder
+      # Returns per-player win/loss/win-rate aggregated across all done sessions.
+      def ladder
+        authorize Inhouse
+
+        rows = InhouseParticipation
+               .joins(:inhouse, :player)
+               .where(inhouses: { organization_id: current_organization.id, status: 'done' })
+               .where.not(team: 'none')
+               .group(:player_id)
+               .select(
+                 'player_id',
+                 'SUM(wins) AS total_wins',
+                 'SUM(losses) AS total_losses'
+               )
+               .to_a
+
+        player_ids = rows.map(&:player_id)
+        players_by_id = current_organization.players
+                          .where(id: player_ids)
+                          .index_by(&:id)
+
+        entries = rows.map do |row|
+          player = players_by_id[row.player_id]
+          next unless player
+
+          total = row.total_wins.to_i + row.total_losses.to_i
+          win_rate = total.zero? ? 0.0 : (row.total_wins.to_f / total * 100).round(1)
+
+          {
+            player_id: row.player_id,
+            player_name: player.summoner_name,
+            role: player.role,
+            wins: row.total_wins.to_i,
+            losses: row.total_losses.to_i,
+            total_games: total,
+            win_rate: win_rate
+          }
+        end.compact
+
+        entries.sort_by! { |e| [-e[:wins], e[:losses]] }
+        entries.each_with_index { |e, i| e[:rank] = i + 1 }
+
+        render_success({ entries: entries, total: entries.size })
+      end
+
+      # GET /api/v1/inhouse/sessions
+      # Returns paginated history of completed inhouse sessions with summary.
+      def sessions
+        authorize Inhouse
+
+        inhouses = current_organization.inhouses.history.recent
+                     .includes(:inhouse_participations)
+
+        page     = (params[:page] || 1).to_i
+        per_page = [(params[:per_page] || 10).to_i, 50].min
+        inhouses = inhouses.page(page).per(per_page)
+
+        sessions = inhouses.map do |ih|
+          {
+            id: ih.id,
+            games_played: ih.games_played,
+            blue_wins: ih.blue_wins,
+            red_wins: ih.red_wins,
+            player_count: ih.inhouse_participations.size,
+            formation_mode: nil,
+            created_at: ih.created_at,
+            closed_at: ih.updated_at
+          }
+        end
+
+        render_success({
+          sessions: sessions,
+          meta: {
+            current_page: inhouses.current_page,
+            total_pages: inhouses.total_pages,
+            total_count: inhouses.total_count
+          }
+        })
+      end
+
       # GET /api/v1/inhouse/inhouses
       # Returns paginated history of completed inhouse sessions.
       # Pass ?all=true to include active ones too.

app/modules/matchmaking/serializers/scrim_request_serializer.rb

@@ -2,25 +2,16 @@ class ScrimRequestSerializer < Blueprinter::Base
   identifier :id
 
   fields :status, :game, :message, :proposed_at, :expires_at,
+         :games_planned, :draft_type,
          :requesting_scrim_id, :target_scrim_id,
          :created_at, :updated_at
 
   field :requesting_organization do |req|
-    {
-      id: req.requesting_organization.id,
-      name: req.requesting_organization.name,
-      slug: req.requesting_organization.slug,
-      region: req.requesting_organization.region
-    }
+    serialize_org(req.requesting_organization)
   end
 
   field :target_organization do |req|
-    {
-      id: req.target_organization.id,
-      name: req.target_organization.name,
-      slug: req.target_organization.slug,
-      region: req.target_organization.region
-    }
+    serialize_org(req.target_organization)
   end
 
   field :pending do |req|
@@ -30,4 +21,47 @@ class ScrimRequestSerializer < Blueprinter::Base
   field :expired do |req|
     req.expired?
   end
+
+  class << self
+    TIER_SCORE = {
+      'CHALLENGER'  => 9, 'GRANDMASTER' => 8, 'MASTER'    => 7,
+      'DIAMOND'     => 6, 'EMERALD'     => 5, 'PLATINUM'  => 4,
+      'GOLD'        => 3, 'SILVER'      => 2, 'BRONZE'    => 1
+    }.freeze
+
+    TIER_LABEL = {
+      9 => 'Challenger', 8 => 'Grandmaster', 7 => 'Master',
+      6 => 'Diamond',    5 => 'Emerald',     4 => 'Platinum',
+      3 => 'Gold',       2 => 'Silver',      1 => 'Bronze', 0 => 'Iron'
+    }.freeze
+
+    def serialize_org(org)
+      players = org.players.active.select(:summoner_name, :role, :solo_queue_tier)
+
+      scores = players.map { |p| TIER_SCORE[p.solo_queue_tier.to_s.upcase] || 0 }
+      avg_score = scores.empty? ? 0 : (scores.sum.to_f / scores.size).round
+      avg_tier  = TIER_LABEL[avg_score] || 'Iron'
+
+      {
+        id:            org.id,
+        name:          org.name,
+        slug:          org.slug,
+        region:        org.region,
+        tier:          org.tier,
+        public_tagline: org.public_tagline,
+        discord_server: org.discord_invite_url,
+        scrims_won:    org.scrims_won   || 0,
+        scrims_lost:   org.scrims_lost  || 0,
+        total_scrims:  org.total_scrims || 0,
+        avg_tier:      avg_tier,
+        roster: players.map do |p|
+          {
+            summoner_name: p.summoner_name,
+            role:          p.role,
+            tier:          p.solo_queue_tier
+          }
+        end
+      }
+    end
+  end
 end

app/modules/scrims/controllers/scrims_controller.rb

@@ -83,7 +83,6 @@ def show
 
       # POST /api/v1/scrims
       def create
-        # Check scrim creation limit
         unless current_organization.can_create_scrim?
           return render json: {
             error: 'Scrim Limit Reached',
@@ -93,6 +92,16 @@ def create
 
         scrim = current_organization.scrims.new(scrim_params)
 
+        opponent_name = params.dig(:scrim, :opponent_team_name).to_s.strip
+        if opponent_name.present?
+          tag = opponent_name.split.map(&:first).join.upcase.first(5)
+          opponent = OpponentTeam.find_or_initialize_by(name: opponent_name)
+          opponent.tag ||= tag
+          opponent.region ||= current_organization.region
+          opponent.save
+          scrim.opponent_team = opponent
+        end
+
         if scrim.save
           render json: { data: ScrimSerializer.new(scrim).as_json }, status: :created
         else

app/modules/scrims/serializers/scrim_serializer.rb

@@ -54,13 +54,82 @@ def timestamps_fields
 
   def detailed_attributes
     {
-      match_id: @scrim.match_id,
+      match_id:       @scrim.match_id,
       pre_game_notes: @scrim.pre_game_notes,
       post_game_notes: @scrim.post_game_notes,
-      game_results: @scrim.game_results,
-      objectives: @scrim.objectives,
-      outcomes: @scrim.outcomes,
-      objectives_met: @scrim.objectives_met?
+      game_results:   @scrim.game_results,
+      objectives:     @scrim.objectives,
+      outcomes:       @scrim.outcomes,
+      objectives_met: @scrim.objectives_met?,
+      opponent_detail: opponent_detail,
+      head_to_head:   head_to_head
+    }
+  end
+
+  TIER_SCORE = {
+    'CHALLENGER' => 9, 'GRANDMASTER' => 8, 'MASTER'   => 7,
+    'DIAMOND'    => 6, 'EMERALD'     => 5, 'PLATINUM' => 4,
+    'GOLD'       => 3, 'SILVER'      => 2, 'BRONZE'   => 1
+  }.freeze
+
+  TIER_LABEL = {
+    9 => 'Challenger', 8 => 'Grandmaster', 7 => 'Master',
+    6 => 'Diamond',    5 => 'Emerald',     4 => 'Platinum',
+    3 => 'Gold',       2 => 'Silver',      1 => 'Bronze', 0 => 'Iron'
+  }.freeze
+
+  def opponent_detail
+    return nil unless @scrim.opponent_team
+
+    t = @scrim.opponent_team
+
+    # Try to find the registered Organization with the same name
+    org = Organization.unscoped.find_by(name: t.name)
+    roster, avg_tier = org_roster_and_avg(org)
+
+    {
+      league:          t.league,
+      discord_server:  t.discord_server || org&.discord_invite_url,
+      known_players:   Array(t.known_players),
+      playstyle_notes: t.playstyle_notes,
+      strengths:       Array(t.strengths),
+      weaknesses:      Array(t.weaknesses),
+      roster:          roster,
+      avg_tier:        avg_tier
+    }
+  end
+
+  def org_roster_and_avg(org)
+    return [[], nil] unless org
+
+    players = org.players.active.select(:summoner_name, :role, :solo_queue_tier)
+    scores  = players.map { |p| TIER_SCORE[p.solo_queue_tier.to_s.upcase] || 0 }
+    avg     = scores.empty? ? nil : TIER_LABEL[(scores.sum.to_f / scores.size).round]
+
+    roster = players.map { |p| { summoner_name: p.summoner_name, role: p.role, tier: p.solo_queue_tier } }
+    [roster, avg]
+  end
+
+  def head_to_head
+    return nil unless @scrim.opponent_team_id
+
+    past = Scrim.unscoped
+                .where(organization_id: @scrim.organization_id,
+                       opponent_team_id: @scrim.opponent_team_id)
+                .where.not(id: @scrim.id)
+                .where.not(games_completed: nil)
+                .where('games_completed >= games_planned')
+                .order(scheduled_at: :desc)
+                .limit(10)
+                .to_a
+
+    wins   = past.count { |s| s.win_rate.to_f >= 50 }
+    losses = past.count - wins
+
+    {
+      wins:   wins,
+      losses: losses,
+      total:  past.count
     }
   end
 
@@ -76,12 +145,16 @@ def calendar_attributes
   def opponent_team_summary
     return nil unless @scrim.opponent_team
 
+    t = @scrim.opponent_team
     {
-      id: @scrim.opponent_team.id,
-      name: @scrim.opponent_team.name,
-      tag: @scrim.opponent_team.tag,
-      tier: @scrim.opponent_team.tier,
-      logo_url: @scrim.opponent_team.logo_url
+      id:          t.id,
+      name:        t.name,
+      tag:         t.tag,
+      tier:        t.tier,
+      region:      t.region,
+      scrims_won:  t.scrims_won  || 0,
+      scrims_lost: t.scrims_lost || 0,
+      logo_url:    t.logo_url
     }
   end
 

app/policies/inhouse_policy.rb

@@ -14,6 +14,14 @@ def active?
     user.present?
   end
 
+  def ladder?
+    user.present?
+  end
+
+  def sessions?
+    user.present?
+  end
+
   def create?
     coach?
   end

config/routes.rb

@@ -287,6 +287,9 @@
 
       # Inhouse Module — internal practice sessions between org's own players
       scope '/inhouse', as: 'inhouse' do
+        get 'ladder',   to: '/inhouses/controllers/inhouses#ladder'
+        get 'sessions', to: '/inhouses/controllers/inhouses#sessions'
+
         resources :inhouses, controller: '/inhouses/controllers/inhouses', only: %i[index create] do
           collection do
             get :active