WIP

Author: vtm9

services/app/apps/codebattle/lib/codebattle/tournament/helpers.ex

@@ -3,14 +3,16 @@ defmodule Codebattle.Tournament.Helpers do
   alias Codebattle.Tournament
   alias Codebattle.User
 
-  def get_player(%{players_table: nil} = tournament, id), do: Map.get(tournament.players, to_id(id))
+  def get_player(%{players_table: nil} = tournament, id),
+    do: Map.get(tournament.players, to_id(id))
 
   def get_player(tournament, id), do: Tournament.Players.get_player(tournament, id)
 
   def get_players(%{players_table: nil} = tournament), do: Map.values(tournament.players)
   def get_players(tournament), do: Tournament.Players.get_players(tournament)
 
-  def get_players(%{players_table: nil} = tournament, ids), do: Enum.map(ids, &get_player(tournament, &1))
+  def get_players(%{players_table: nil} = tournament, ids),
+    do: Enum.map(ids, &get_player(tournament, &1))
 
   def get_players(tournament, ids), do: Tournament.Players.get_players(tournament, ids)
 
@@ -44,20 +46,23 @@ defmodule Codebattle.Tournament.Helpers do
     tournament |> get_team_players(team_id) |> Enum.count()
   end
 
-  def get_match(%{matches_table: nil} = tournament, id), do: Map.get(tournament.matches, to_id(id))
+  def get_match(%{matches_table: nil} = tournament, id),
+    do: Map.get(tournament.matches, to_id(id))
 
   def get_match(tournament, id), do: Tournament.Matches.get_match(tournament, id)
 
   def get_matches(%{matches_table: nil} = tournament), do: Map.values(tournament.matches)
   def get_matches(tournament), do: Tournament.Matches.get_matches(tournament)
 
-  def get_matches(tournament, ids) when is_list(ids), do: Enum.map(ids, &get_match(tournament, &1))
+  def get_matches(tournament, ids) when is_list(ids),
+    do: Enum.map(ids, &get_match(tournament, &1))
 
   def get_matches(tournament, state) when is_binary(state) do
     tournament |> get_matches() |> Enum.filter(&(&1.state == state))
   end
 
-  def get_matches(tournament, ids_or_state), do: Tournament.Matches.get_matches(tournament, ids_or_state)
+  def get_matches(tournament, ids_or_state),
+    do: Tournament.Matches.get_matches(tournament, ids_or_state)
 
   def get_matches_by_players(tournament, player_ids) do
     matches_ids =
@@ -125,7 +130,9 @@ defmodule Codebattle.Tournament.Helpers do
   def get_current_round_playing_matches(tournament) do
     tournament
     |> get_matches()
-    |> Enum.filter(&(&1.round_position == tournament.current_round_position and &1.state == "playing"))
+    |> Enum.filter(
+      &(&1.round_position == tournament.current_round_position and &1.state == "playing")
+    )
   end
 
   def match_player?(match, player_id), do: Enum.any?(match.player_ids, &(&1 == player_id))
@@ -351,7 +358,10 @@ defmodule Codebattle.Tournament.Helpers do
     ])
   end
 
-  def get_players_total_games_count(%{task_provider: "task_pack", task_strategy: "sequential"} = t, _player) do
+  def get_players_total_games_count(
+        %{task_provider: "task_pack", task_strategy: "sequential"} = t,
+        _player
+      ) do
     t |> Tournament.Tasks.get_task_ids() |> Enum.count()
   end
 
@@ -360,7 +370,15 @@ defmodule Codebattle.Tournament.Helpers do
 
   def get_player_ranking_stats(tournament) do
     players = get_players(tournament)
-    total_ranking = Tournament.TournamentResult.get_user_ranking(tournament)
+
+    total_ranking =
+      tournament
+      |> Tournament.TournamentResult.get_user_ranking()
+      |> Map.values()
+      |> Enum.sort_by(& &1.place)
+
+    top_8_ids = Enum.take(total_ranking, 8) |> Enum.map(& &1.id)
+    user_history = Tournament.TournamentResult.get_users_history(tournament, top_8_ids)
 
     %{
       "tournament_id" => tournament.id,
@@ -376,9 +394,10 @@ defmodule Codebattle.Tournament.Helpers do
             "total_tasks" => Enum.count(player.matches_ids),
             "won_tasks" => player.wins_count,
             "rank" => player.rank,
+            # TODO: do win_prob based on the top 8 people
             "win_prob" => "42",
             "active" => if(player.in_main_draw, do: 1, else: 0),
-            "history" => []
+            "history" => user_history[player.id] || []
           }
         end)
         |> Enum.sort_by(& &1["rank"])

services/app/apps/codebattle/lib/codebattle/tournament/ranking/by_percentile.ex

@@ -47,7 +47,8 @@ defmodule Codebattle.Tournament.Ranking.ByPercentile do
   end
 
   def set_ranking(tournament) do
-    ranking = TournamentResult.get_user_ranking(tournament)
+    ranking = tournament |> TournamentResult.get_user_ranking() |> Map.values()
+
     set_places_with_score(tournament, ranking)
     Ranking.put_ranking(tournament, ranking)
     tournament
@@ -59,7 +60,8 @@ defmodule Codebattle.Tournament.Ranking.ByPercentile do
     :ok
   end
 
-  def add_new_player(%{state: state} = tournament, player) when state in ["waiting_participants", "active"] do
+  def add_new_player(%{state: state} = tournament, player)
+      when state in ["waiting_participants", "active"] do
     place = Ranking.count(tournament) + 1
 
     Ranking.put_single_record(tournament, place, %{
@@ -78,8 +80,13 @@ defmodule Codebattle.Tournament.Ranking.ByPercentile do
 
   def update_player_result(tournament, _player, _score), do: tournament
 
+  def set_places_with_score(%{type: "top200"} = _tournament, _ranking) do
+    :ok
+  end
+
   def set_places_with_score(tournament, ranking) do
-    Enum.each(ranking, fn %{id: id, place: place, score: score} ->
+    ranking
+    |> Enum.each(fn %{id: id, place: place, score: score} ->
       tournament
       |> Players.get_player(id)
       |> case do