Add tournmanets api

Author: Vitaly

services/app/apps/codebattle/lib/codebattle/event.ex

@@ -66,7 +66,7 @@ defmodule Codebattle.Event do
     timestamps()
   end
 
-  @spec get_stage(t(), String.t()) :: __MODULE__.Stage.t() | nil
+  @spec get_stage(t(), String.t()) :: map() | nil
   def get_stage(%__MODULE__{stages: stages}, slug) when is_binary(slug) do
     Enum.find(stages, fn stage -> stage.slug == slug end)
   end
@@ -83,12 +83,12 @@ defmodule Codebattle.Event do
     |> Repo.all()
   end
 
-  @spec get!(String.t()) :: t() | no_return()
+  @spec get!(String.t() | non_neg_integer()) :: t() | no_return()
   def get!(id) do
     Repo.get!(__MODULE__, id)
   end
 
-  @spec get(String.t()) :: t() | no_return()
+  @spec get(String.t() | non_neg_integer()) :: t() | nil
   def get(id) do
     Repo.get(__MODULE__, id)
   end

services/app/apps/codebattle/lib/codebattle/event/context.ex

@@ -20,9 +20,9 @@ defmodule Codebattle.Event.Context do
     user_event = UserEvent.get_by_user_id_and_event_id(user.id, event.id)
     user_event_stage = UserEvent.get_stage(user_event, stage_slug)
 
-    with true <- not is_nil(user_event),
-         true <- not is_nil(event_stage),
-         true <- not is_nil(user_event_stage),
+    with false <- is_nil(user_event),
+         false <- is_nil(event_stage),
+         false <- is_nil(user_event_stage),
          true <- event_stage.status in [:active],
          true <- user_event_stage.status in [:pending],
          {:ok, result} <-

services/app/apps/codebattle/lib/codebattle/event/user_event.ex

@@ -64,7 +64,7 @@ defmodule Codebattle.UserEvent do
     timestamps()
   end
 
-  @spec get_stage(t(), String.t()) :: __MODULE__.Stage.t() | nil
+  @spec get_stage(t(), String.t()) :: map() | nil
   def get_stage(%{stages: stages}, slug) when is_list(stages) do
     Enum.find(stages, fn stage -> stage.slug == slug end)
   end
@@ -134,7 +134,13 @@ defmodule Codebattle.UserEvent do
   end
 
   def mark_stage_as_completed(event_id, user_id, tournament_info) do
-    user_event = Repo.one(from(ue in __MODULE__, where: ue.event_id == ^event_id and ue.user_id == ^user_id, limit: 1))
+    user_event =
+      Repo.one(
+        from(ue in __MODULE__,
+          where: ue.event_id == ^event_id and ue.user_id == ^user_id,
+          limit: 1
+        )
+      )
 
     if user_event do
       stages =

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

@@ -25,7 +25,7 @@ defmodule Codebattle.Tournament.Clans do
   def put_clans(%{clans_table: nil}, _clans), do: :ok
   def put_clans(tournament, clans), do: Clans.put_clans(tournament, clans)
 
-  @spec get_all(tournament :: Tournament.t()) :: list(map())
+  @spec get_all(tournament :: Tournament.t()) :: map()
   def get_all(%{clans_table: nil}), do: %{}
   def get_all(tournament), do: Clans.get_all(tournament)
 

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

@@ -137,24 +137,47 @@ defmodule Codebattle.Tournament.Context do
   end
 
   @spec get_upcoming_tournaments(%{
-          date_from: DateTime.t(),
-          date_to: DateTime.t()
+          from: DateTime.t(),
+          to: DateTime.t(),
+          user_id: non_neg_integer() | nil
         }) :: list(Tournament.t())
   def get_upcoming_tournaments(filter) do
-    %{date_from: date_from, date_to: date_to} = filter
+    %{from: datetime_from, to: datetime_to} = filter
 
     Repo.all(
       from(t in Tournament,
         order_by: t.id,
         where:
-          t.starts_at > ^date_from and
-            t.starts_at < ^date_to and
+          t.starts_at >= ^datetime_from and
+            t.starts_at <= ^datetime_to and
             t.grade != "open" and
             t.state == "upcoming"
       )
     )
   end
 
+  @spec get_user_tournaments(%{
+          from: DateTime.t(),
+          to: DateTime.t(),
+          user_id: non_neg_integer() | nil
+        }) :: list(Tournament.t())
+  def get_user_tournaments(%{user_id: nil}), do: []
+
+  def get_user_tournaments(filter) do
+    %{from: datetime_from, to: datetime_to, user_id: user_id} = filter
+
+    Repo.all(
+      from(t in Tournament,
+        order_by: t.id,
+        where:
+          t.starts_at >= ^datetime_from and
+            t.starts_at <= ^datetime_to and
+            t.grade == "open" and
+            (t.creator_id == ^user_id or fragment("? = ANY(?)", ^user_id, t.winner_ids))
+      )
+    )
+  end
+
   @spec get_live_tournaments_for_user(User.t()) :: list(Tournament.t())
   def get_live_tournaments_for_user(user) do
     get_live_tournaments()

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

@@ -3,6 +3,8 @@ defmodule Codebattle.Tournament.Helpers do
   alias Codebattle.Tournament
   alias Codebattle.User
 
+  @spec get_player(tournament :: Tournament.t(), id :: String.t() | non_neg_integer()) ::
+          Tournament.Player.t() | nil
   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)

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

@@ -48,7 +48,7 @@ defmodule Codebattle.Tournament.Ranking do
     get_module(tournament).add_new_player(tournament, player)
   end
 
-  @spec drop_player(Tournament.t(), player_id :: pos_integer()) :: Tournament.t()
+  @spec drop_player(Tournament.t(), player_id :: pos_integer()) :: nil | :ok | non_neg_integer()
   def drop_player(tournament, player_id) do
     if get_module(tournament) == ByUser do
       Ranking.drop_player(tournament, player_id)

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

@@ -62,7 +62,7 @@ defmodule Codebattle.Tournament.Round do
       :module,
       :task_pack_id
     ])
-    |> validate_inclusion(:level, Tournament.Task.levels())
+    |> validate_inclusion(:level, Codebattle.Task.levels())
     |> validate_inclusion(:state, @states)
     |> validate_inclusion(:task_provider, Tournament.task_providers())
     |> validate_inclusion(:task_strategy, Tournament.task_strategies())

services/app/apps/codebattle/lib/codebattle/tournament/round/context.ex

@@ -36,7 +36,7 @@ defmodule Codebattle.Tournament.Round.Context do
     )
   end
 
-  @spec upsert_all(list(Round.t())) :: list(Round.t())
+  @spec upsert_all(list(Round.t())) :: {non_neg_integer(), nil | [any()]}
   def upsert_all(rounds) do
     rounds = Enum.map(rounds, &Map.put(&1, :updated_at, TimeHelper.utc_now()))
 

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

@@ -5,13 +5,12 @@ defmodule Codebattle.Tournament.Server do
   import Codebattle.Tournament.Helpers
 
   alias Codebattle.Tournament
-  alias Codebattle.WaitingRoom
 
   require Logger
 
   @type tournament_id :: pos_integer()
   @tournament_info_table :tournament_info_cache
-  @waiting_room_timeout_ms to_timeout(second: 1)
+  # @waiting_room_timeout_ms to_timeout(second: 1)
   # API
   def start_link(tournament_id) do
     GenServer.start(__MODULE__, tournament_id, name: server_name(tournament_id))
@@ -330,53 +329,53 @@ defmodule Codebattle.Tournament.Server do
   #   {:noreply, %{tournament: new_tournament}}
   # end
 
-  def handle_info(:match_waiting_room_players, %{
-        tournament: %Tournament{waiting_room_state: %WaitingRoom.State{state: "active"}} = tournament
-      }) do
-    players =
-      tournament
-      |> Tournament.Players.get_players("matchmaking_active")
-      |> Enum.map(&prepare_wr_player/1)
-
-    played_pair_ids = tournament.played_pair_ids
-
-    wr_new_state =
-      WaitingRoom.Engine.call(%{
-        tournament.waiting_room_state
-        | players: players,
-          played_pair_ids: played_pair_ids
-      })
-
-    tournament.module.create_games_for_waiting_room_pairs(
-      tournament,
-      wr_new_state.pairs,
-      wr_new_state.matched_with_bot
-    )
-
-    new_tournament = %{
-      tournament
-      | played_pair_ids: wr_new_state.played_pair_ids,
-        waiting_room_state: %{
-          wr_new_state
-          | pairs: [],
-            matched_with_bot: []
-        }
-    }
-
-    Process.send_after(self(), :match_waiting_room_players, @waiting_room_timeout_ms)
-    {:noreply, %{tournament: new_tournament}}
-  end
+  # def handle_info(:match_waiting_room_players, %{
+  #       tournament: %Tournament{waiting_room_state: %WaitingRoom.State{state: "active"}} = tournament
+  #     }) do
+  #   players =
+  #     tournament
+  #     |> Tournament.Players.get_players("matchmaking_active")
+  #     |> Enum.map(&prepare_wr_player/1)
+
+  #   played_pair_ids = tournament.played_pair_ids
+
+  #   wr_new_state =
+  #     WaitingRoom.Engine.call(%{
+  #       tournament.waiting_room_state
+  #       | players: players,
+  #         played_pair_ids: played_pair_ids
+  #     })
+
+  #   tournament.module.create_games_for_waiting_room_pairs(
+  #     tournament,
+  #     wr_new_state.pairs,
+  #     wr_new_state.matched_with_bot
+  #   )
+
+  #   new_tournament = %{
+  #     tournament
+  #     | played_pair_ids: wr_new_state.played_pair_ids,
+  #       waiting_room_state: %{
+  #         wr_new_state
+  #         | pairs: [],
+  #           matched_with_bot: []
+  #       }
+  #   }
+
+  #   Process.send_after(self(), :match_waiting_room_players, @waiting_room_timeout_ms)
+  #   {:noreply, %{tournament: new_tournament}}
+  # end
 
-  def handle_info(:match_waiting_room_players, %{
-        tournament: %Tournament{waiting_room_state: %WaitingRoom.State{state: "paused"}} = tournament
-      }) do
-    Process.send_after(self(), :match_waiting_room_players, @waiting_room_timeout_ms)
-    {:noreply, %{tournament: tournament}}
-  end
+  # def handle_info(:match_waiting_room_players, %{
+  #       tournament: %Tournament{waiting_room_state: %WaitingRoom.State{state: "paused"}} = tournament
+  #     }) do
+  #   Process.send_after(self(), :match_waiting_room_players, @waiting_room_timeout_ms)
+  #   {:noreply, %{tournament: tournament}}
+  # end
 
-  def handle_info(:match_waiting_room_players, state) do
-    {:noreply, state}
-  end
+  # def handle_info(:match_waiting_room_players, state) do
+  #   {:noreply, state}
+  # end
 
   def handle_info(_message, state) do
     {:noreply, state}
@@ -424,9 +423,9 @@ defmodule Codebattle.Tournament.Server do
 
   defp server_name(id), do: {:via, Registry, {Codebattle.Registry, "tournament_srv::#{id}"}}
 
-  defp prepare_wr_player(player) do
-    player
-    |> Map.take([:id, :clan_id, :score, :wr_joined_at])
-    |> Map.put(:tasks, Enum.count(player.task_ids))
-  end
+  # defp prepare_wr_player(player) do
+  #   player
+  #   |> Map.take([:id, :clan_id, :score, :wr_joined_at])
+  #   |> Map.put(:tasks, Enum.count(player.task_ids))
+  # end
 end