Mix format

Author: vtm9

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

@@ -3,16 +3,14 @@ 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)
 
@@ -46,23 +44,20 @@ 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 =
@@ -130,9 +125,7 @@ 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))
@@ -358,10 +351,7 @@ 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
 
@@ -377,7 +367,7 @@ defmodule Codebattle.Tournament.Helpers do
       |> Map.values()
       |> Enum.sort_by(& &1.place)
 
-    top_8_ids = Enum.take(total_ranking, 8) |> Enum.map(& &1.id)
+    top_8_ids = total_ranking |> Enum.take(8) |> Enum.map(& &1.id)
     user_history = Tournament.TournamentResult.get_users_history(tournament, top_8_ids)
 
     %{

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

@@ -60,8 +60,7 @@ 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, %{
@@ -85,8 +84,7 @@ defmodule Codebattle.Tournament.Ranking.ByPercentile do
   end
 
   def set_places_with_score(tournament, ranking) do
-    ranking
-    |> Enum.each(fn %{id: id, place: place, score: score} ->
+    Enum.each(ranking, fn %{id: id, place: place, score: score} ->
       tournament
       |> Players.get_player(id)
       |> case do

services/app/apps/codebattle/lib/codebattle/tournament/strategy/top200.ex

@@ -419,10 +419,7 @@ defmodule Codebattle.Tournament.Top200 do
     end
   end
 
-  defp has_more_games_in_round?(
-         %{task_provider: "task_pack_per_round", round_task_ids: round_task_ids},
-         game_params
-       ) do
+  defp has_more_games_in_round?(%{task_provider: "task_pack_per_round", round_task_ids: round_task_ids}, game_params) do
     game_params.task_id != List.last(round_task_ids)
   end
 

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

@@ -151,8 +151,7 @@ defmodule Codebattle.Tournament.TournamentResult do
     tournament
   end
 
-  def upsert_results(%{type: type, ranking_type: "by_win_loss"} = tournament)
-      when type in ["swiss", "arena"] do
+  def upsert_results(%{type: type, ranking_type: "by_win_loss"} = tournament) when type in ["swiss", "arena"] do
     clean_results(tournament.id)
 
     Repo.query!("""
@@ -229,33 +228,32 @@ defmodule Codebattle.Tournament.TournamentResult do
   end
 
   def get_users_history(tournament, user_ids) do
-    Repo.all(
-      from(tr in __MODULE__,
-        where: tr.tournament_id == ^tournament.id,
-        where: tr.user_id in ^user_ids,
-        inner_join: tr2 in __MODULE__,
-        on: tr.game_id == tr2.game_id and tr2.user_id != tr.user_id,
-        group_by: [tr.round_position, tr.user_id, tr2.user_id],
-        select: %{
-          user_id: tr.user_id,
-          user_name: max(tr.user_name),
-          opponent_id: tr2.user_id,
-          round_position: tr.round_position,
-          score: coalesce(sum(tr.score), 0),
-          opponent_score: coalesce(sum(tr2.score), 0),
-          game_details:
-            fragment(
-              "array_agg(json_build_object('task_id', ?, 'game_id', ?, 'result_percent', ?, 'opponent_result_percent', ?))",
-              tr.task_id,
-              tr.game_id,
-              tr.result_percent,
-              tr2.result_percent
-            ),
-          opponent_name: max(tr2.user_name),
-          opponent_clan_id: max(tr2.clan_id)
-        }
-      )
+    from(tr in __MODULE__,
+      where: tr.tournament_id == ^tournament.id,
+      where: tr.user_id in ^user_ids,
+      inner_join: tr2 in __MODULE__,
+      on: tr.game_id == tr2.game_id and tr2.user_id != tr.user_id,
+      group_by: [tr.round_position, tr.user_id, tr2.user_id],
+      select: %{
+        user_id: tr.user_id,
+        user_name: max(tr.user_name),
+        opponent_id: tr2.user_id,
+        round_position: tr.round_position,
+        score: coalesce(sum(tr.score), 0),
+        opponent_score: coalesce(sum(tr2.score), 0),
+        game_details:
+          fragment(
+            "array_agg(json_build_object('task_id', ?, 'game_id', ?, 'result_percent', ?, 'opponent_result_percent', ?))",
+            tr.task_id,
+            tr.game_id,
+            tr.result_percent,
+            tr2.result_percent
+          ),
+        opponent_name: max(tr2.user_name),
+        opponent_clan_id: max(tr2.clan_id)
+      }
     )
+    |> Repo.all()
     |> Enum.reduce(%{}, fn result, acc ->
       task_history = %{
         score: result.score,

services/app/apps/codebattle/lib/codebattle_web/channels/tournament_admin_channel.ex

@@ -413,8 +413,7 @@ defmodule CodebattleWeb.TournamentAdminChannel do
 
   defp cast_game_params(%{"task_level" => level}), do: %{task_level: level}
 
-  defp cast_game_params(%{"task_id" => id, "timeout_seconds" => seconds}),
-    do: %{task_id: id, timeout_seconds: seconds}
+  defp cast_game_params(%{"task_id" => id, "timeout_seconds" => seconds}), do: %{task_id: id, timeout_seconds: seconds}
 
   defp cast_game_params(%{"task_id" => id}), do: %{task_id: id}
   defp cast_game_params(_params), do: %{}