chore: repair analytics module

improve queries and adjust dashboards

Author: MichaelPlathanus

app/controllers/api/v1/admin/players_controller.rb

@@ -16,7 +16,7 @@ module Admin
       #
       class PlayersController < Api::V1::BaseController
         before_action :require_admin_access
-        before_action :set_player, only: %i[soft_delete restore enable_access disable_access transfer]
+        before_action :set_player, only: %i[soft_delete restore enable_access disable_access transfer change_status]
 
         # GET /api/v1/admin/players
         # Lists all players including soft-deleted ones
@@ -187,6 +187,55 @@ def disable_access
           end
         end
 
+        # POST /api/v1/admin/players/:id/change_status
+        # Changes the status of a non-deleted player (active / inactive / benched / trial).
+        # Use soft_delete to archive a player and restore to un-archive them.
+        def change_status
+          new_status = params[:status].to_s.strip
+
+          # Disallow setting 'removed' via this endpoint — that is handled by soft_delete
+          allowed = Constants::Player::STATUSES - ['removed']
+          unless allowed.include?(new_status)
+            return render_error(
+              message: "Invalid status '#{new_status}'. Allowed: #{allowed.join(', ')}",
+              code: 'VALIDATION_ERROR',
+              status: :unprocessable_entity
+            )
+          end
+
+          if @player.deleted_at.present?
+            return render_error(
+              message: 'Cannot change status of an archived player. Use restore instead.',
+              code: 'PLAYER_ARCHIVED',
+              status: :unprocessable_entity
+            )
+          end
+
+          old_status = @player.status
+
+          if @player.update(status: new_status)
+            log_user_action(
+              action: 'change_status',
+              entity_type: 'Player',
+              entity_id: @player.id,
+              old_values: { status: old_status },
+              new_values: { status: new_status }
+            )
+
+            render_success({
+                             message: "Player status changed to #{new_status}",
+                             player: PlayerSerializer.render_as_hash(@player)
+                           })
+          else
+            render_error(
+              message: 'Failed to update player status',
+              code: 'CHANGE_STATUS_ERROR',
+              status: :unprocessable_entity,
+              details: @player.errors.as_json
+            )
+          end
+        end
+
         # POST /api/v1/admin/players/:id/transfer
         # Transfers a player to another organization
         def transfer

app/controllers/api/v1/analytics/laning_controller.rb

@@ -5,77 +5,77 @@ module V1
     module Analytics
       # Laning Phase Analytics Controller
       #
-      # Provides early game performance metrics focusing on CS (creep score) and gold acquisition.
-      # Tracks farming efficiency with CS per minute calculations and gold earnings.
+      # Returns CS, gold, and early-game metrics for a given player.
+      # Timeline data (gold_diff@10/@15) is not available from the data source,
+      # so those fields are omitted (nil) and the frontend falls back gracefully.
       #
-      # @example GET /api/v1/analytics/laning/:player_id
-      #   {
-      #     cs_performance: { avg_cs_total: 185.5, avg_cs_per_min: 7.4, best_cs_game: 245 },
-      #     gold_performance: { avg_gold: 12500, best_gold_game: 15000 }
-      #   }
-      #
-      # Main endpoints:
-      # - GET show: Returns laning statistics for the last 20 matches with CS and gold metrics
       class LaningController < Api::V1::BaseController
         def show
           player = organization_scoped(Player).find(params[:player_id])
 
           stats = PlayerMatchStat.joins(:match)
+                                 .includes(:match)
                                  .where(player: player, match: { organization: current_organization })
                                  .order('matches.game_start DESC')
                                  .limit(20)
 
-          laning_data = {
-            player: PlayerSerializer.render_as_hash(player),
-            cs_performance: {
-              avg_cs_total: stats.average('minions_killed + jungle_minions_killed')&.round(1),
-              avg_cs_per_min: calculate_avg_cs_per_min(stats),
-              best_cs_game: stats.maximum('minions_killed + jungle_minions_killed'),
-              worst_cs_game: stats.minimum('minions_killed + jungle_minions_killed')
-            },
-            gold_performance: {
-              avg_gold: stats.average(:gold_earned)&.round(0),
-              best_gold_game: stats.maximum(:gold_earned),
-              worst_gold_game: stats.minimum(:gold_earned)
-            },
-            cs_by_match: stats.map do |stat|
-              match_duration_mins = stat.match.game_duration ? stat.match.game_duration / 60.0 : 25
-              cs_total = (stat.minions_killed || 0) + (stat.jungle_minions_killed || 0)
-              cs_per_min = cs_total / match_duration_mins
+          games = stats.count
+          wins  = stats.joins(:match).where(matches: { victory: true }).count
 
-              {
-                match_id: stat.match.id,
-                date: stat.match.game_start,
-                cs_total: cs_total,
-                cs_per_min: cs_per_min.round(1),
-                gold: stat.gold_earned,
-                champion: stat.champion,
-                victory: stat.match.victory
-              }
-            end
+          laning_data = {
+            player:           PlayerSerializer.render_as_hash(player),
+            avg_cs_per_min:   stats.average(:cs_per_min)&.round(1) || calculate_avg_cs_per_min(stats),
+            avg_cs_total:     stats.average(:cs)&.round(1) || 0,
+            lane_win_rate:    games.zero? ? nil : ((wins.to_f / games) * 100).round(1),
+            first_blood_rate: games.zero? ? nil : ((stats.where(first_blood: true).count.to_f / games) * 100).round(1),
+            first_tower_rate: games.zero? ? nil : ((stats.where(first_tower: true).count.to_f / games) * 100).round(1),
+            avg_gold:         stats.average(:gold_earned)&.round(0) || 0,
+            # Timeline fields not available from data source
+            gold_diff_10:     nil,
+            gold_diff_15:     nil,
+            cs_diff_10:       nil,
+            cs_diff_15:       nil,
+            solo_kills:       nil,
+            laning_trend:     build_laning_trend(stats)
           }
 
           render_success(laning_data)
         end
 
         private
 
+        def build_laning_trend(stats)
+          stats.map do |stat|
+            next unless stat.match.game_start
+
+            duration_mins = stat.match.game_duration ? stat.match.game_duration / 60.0 : 25
+            cs = stat.cs || 0
+            cs_pm = duration_mins > 0 ? (cs / duration_mins).round(1) : 0
+
+            {
+              date:      stat.match.game_start.strftime('%Y-%m-%d'),
+              cs_total:  cs,
+              cs_per_min: cs_pm,
+              gold:      stat.gold_earned || 0,
+              gold_diff: 0,  # not available
+              champion:  stat.champion,
+              victory:   stat.match.victory
+            }
+          end.compact.sort_by { |d| d[:date] }
+        end
+
         def calculate_avg_cs_per_min(stats)
-          total_cs = 0
+          total_cs      = 0
           total_minutes = 0
 
           stats.each do |stat|
             next unless stat.match.game_duration
 
-            cs = (stat.minions_killed || 0) + (stat.jungle_minions_killed || 0)
-            minutes = stat.match.game_duration / 60.0
-            total_cs += cs
-            total_minutes += minutes
+            total_cs      += stat.cs || 0
+            total_minutes += stat.match.game_duration / 60.0
           end
 
-          return 0 if total_minutes.zero?
-
-          (total_cs / total_minutes).round(1)
+          total_minutes.zero? ? 0 : (total_cs / total_minutes).round(1)
         end
       end
     end

app/controllers/api/v1/analytics/performance_controller.rb

@@ -45,20 +45,24 @@ class PerformanceController < Api::V1::BaseController
         # @return [JSON] Performance analytics data
         def index
           matches = apply_date_filters(organization_scoped(Match))
-          players = organization_scoped(Player).active
 
-          # Only process player_id if it's present and valid
+          # Use active players for team-wide stats (best performers, role breakdown, etc.)
+          # but validate player_id against ALL org players so that bench/trial/inactive
+          # players can still have their individual stats viewed.
+          active_players = organization_scoped(Player).active
+          all_org_players = organization_scoped(Player)
+
           player_id = params[:player_id].presence
-          if player_id.present? && !players.exists?(id: player_id)
+          if player_id.present? && !all_org_players.exists?(id: player_id)
             return render_error(
               message: 'Player not found',
               code: 'PLAYER_NOT_FOUND',
               status: :not_found
             )
           end
 
-          service = ::Analytics::Services::PerformanceAnalyticsService.new(matches, players)
-          performance_data = service.calculate_performance_data(player_id: player_id)
+          service = ::Analytics::Services::PerformanceAnalyticsService.new(matches, active_players)
+          performance_data = service.calculate_performance_data(player_id: player_id, all_players: all_org_players)
 
           render_success(performance_data)
         rescue StandardError => e

app/controllers/api/v1/analytics/team_comparison_controller.rb

@@ -19,7 +19,7 @@ def index
         private
 
         def fetch_active_players
-          organization_scoped(Player).active.includes(:player_match_stats)
+          organization_scoped(Player).active
         end
 
         def build_matches_query
@@ -60,27 +60,58 @@ def build_comparison_data(players, matches)
           }
         end
 
+        # Single GROUP BY query replaces one query per player (N+1 → 1)
         def build_player_comparisons(players, matches)
-          player_stats = players.map { |player| build_player_stats(player, matches) }
-          sorted_stats = player_stats.compact
-          sorted_stats.sort_by { |p| -p[:avg_performance_score] }
-        end
-
-        def build_player_stats(player, matches)
-          stats = PlayerMatchStat.where(player: player, match: matches)
-          return nil if stats.empty?
-
-          {
-            player: PlayerSerializer.render_as_hash(player),
-            games_played: stats.count,
-            kda: calculate_kda(stats),
-            avg_damage: calculate_average(stats, :damage_dealt_total, 0),
-            avg_gold: calculate_average(stats, :gold_earned, 0),
-            avg_cs: calculate_average(stats, :cs, 1),
-            avg_vision_score: calculate_average(stats, :vision_score, 1),
-            avg_performance_score: calculate_average(stats, :performance_score, 1),
-            multikills: build_multikills(stats)
-          }
+          player_ids = players.pluck(:id)
+          match_ids  = matches.pluck(:id)
+          return [] if player_ids.empty? || match_ids.empty?
+
+          agg_rows = PlayerMatchStat
+            .where(player_id: player_ids, match_id: match_ids)
+            .group(:player_id)
+            .select(
+              'player_id',
+              'COUNT(*) AS games_played',
+              'SUM(kills) AS total_kills',
+              'SUM(deaths) AS total_deaths',
+              'SUM(assists) AS total_assists',
+              'AVG(damage_dealt_total) AS avg_damage',
+              'AVG(gold_earned) AS avg_gold',
+              'AVG(cs) AS avg_cs',
+              'AVG(vision_score) AS avg_vision_score',
+              'AVG(performance_score) AS avg_performance_score',
+              'SUM(double_kills) AS double_kills',
+              'SUM(triple_kills) AS triple_kills',
+              'SUM(quadra_kills) AS quadra_kills',
+              'SUM(penta_kills) AS penta_kills'
+            )
+
+          players_by_id = players.index_by(&:id)
+
+          agg_rows.filter_map do |agg|
+            player = players_by_id[agg.player_id]
+            next unless player
+
+            deaths = agg.total_deaths.to_i.zero? ? 1 : agg.total_deaths.to_i
+            kda    = ((agg.total_kills.to_i + agg.total_assists.to_i).to_f / deaths).round(2)
+
+            {
+              player:                PlayerSerializer.render_as_hash(player),
+              games_played:          agg.games_played.to_i,
+              kda:                   kda,
+              avg_damage:            agg.avg_damage.to_f.round(0),
+              avg_gold:              agg.avg_gold.to_f.round(0),
+              avg_cs:                agg.avg_cs.to_f.round(1),
+              avg_vision_score:      agg.avg_vision_score.to_f.round(1),
+              avg_performance_score: agg.avg_performance_score.to_f.round(1),
+              multikills: {
+                double: agg.double_kills.to_i,
+                triple: agg.triple_kills.to_i,
+                quadra: agg.quadra_kills.to_i,
+                penta:  agg.penta_kills.to_i
+              }
+            }
+          end.sort_by { |p| -p[:avg_performance_score] }
         end
 
         def calculate_average(stats, column, precision)
@@ -117,33 +148,39 @@ def calculate_team_averages(matches)
           }
         end
 
+        # Single GROUP BY across all roles — replaces 3N per-player queries
         def calculate_role_rankings(players, matches)
-          rankings = {}
-
-          %w[top jungle mid adc support].each do |role|
-            rankings[role] = calculate_role_ranking(players, matches, role)
+          player_ids = players.pluck(:id)
+          match_ids  = matches.pluck(:id)
+
+          rankings = { 'top' => [], 'jungle' => [], 'mid' => [], 'adc' => [], 'support' => [] }
+          return rankings if player_ids.empty? || match_ids.empty?
+
+          agg_rows = PlayerMatchStat
+            .joins(:player)
+            .where(player_id: player_ids, match_id: match_ids)
+            .group('player_id, players.role, players.summoner_name')
+            .select(
+              'player_id',
+              'players.role AS role',
+              'players.summoner_name AS summoner_name',
+              'COUNT(*) AS games',
+              'AVG(performance_score) AS avg_performance'
+            )
+
+          agg_rows.each do |agg|
+            role = agg.role
+            next unless rankings.key?(role)
+
+            rankings[role] << {
+              player_id:    agg.player_id,
+              summoner_name: agg.summoner_name,
+              avg_performance: agg.avg_performance.to_f.round(1),
+              games:           agg.games.to_i
+            }
           end
 
-          rankings
-        end
-
-        def calculate_role_ranking(players, matches, role)
-          role_players = players.where(role: role)
-          role_data = role_players.map { |player| build_role_player_data(player, matches) }
-          sorted_data = role_data.compact
-          sorted_data.sort_by { |p| -p[:avg_performance] }
-        end
-
-        def build_role_player_data(player, matches)
-          stats = PlayerMatchStat.where(player: player, match: matches)
-          return nil if stats.empty?
-
-          {
-            player_id: player.id,
-            summoner_name: player.summoner_name,
-            avg_performance: stats.average(:performance_score)&.round(1) || 0,
-            games: stats.count
-          }
+          rankings.transform_values { |list| list.sort_by { |p| -p[:avg_performance] } }
         end
       end
     end

app/controllers/api/v1/analytics/teamfights_controller.rb

@@ -21,6 +21,7 @@ def show
           player = organization_scoped(Player).find(params[:player_id])
 
           stats = PlayerMatchStat.joins(:match)
+                                 .includes(:match)
                                  .where(player: player, match: { organization: current_organization })
                                  .order('matches.game_start DESC')
                                  .limit(20)