Add upcoming tournaments runner

Author: Vitaly

docker-compose.yml

@@ -1,5 +1,3 @@
-version: "3.3"
-
 services:
   app:
     build:

services/app/apps/codebattle/assets/css/style.scss

@@ -2785,7 +2785,3 @@ a:hover {
   width: auto;
   height: auto;
 }
-
-body {
-  background-image: url('../static/images/main_background.png');
-}

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

@@ -21,6 +21,7 @@ defmodule Codebattle.Application do
         {Codebattle.TasksImporter, []},
         {Codebattle.UsersRankUpdateServer, []},
         {Codebattle.Bot.GameCreator, []},
+        {Codebattle.Tournament.UpcomingRunner, []},
         {Codebattle.ImageCache, []},
         {Codebattle.Repo, []},
         {Registry, keys: :unique, name: Codebattle.Registry},

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

@@ -109,6 +109,63 @@ defmodule Codebattle.Tournament.Context do
     )
   end
 
+  @spec get_waiting_participants_to_start_candidates() :: list(Tournament.t())
+  def get_waiting_participants_to_start_candidates do
+    Enum.filter(get_live_tournaments(), fn tournament ->
+      tournament.state == "waiting_participants" &&
+        tournament.grade != "open" &&
+        tournament.starts_at
+
+      # &&
+      # DateTime.compare(tournament.starts_at, DateTime.utc_now()) == :lt
+    end)
+  end
+
+  @spec get_upcoming_to_live_candidate(non_neg_integer()) :: Tournament.t() | nil
+  def get_upcoming_to_live_candidate(starts_at_delay_mins) do
+    delay_time = DateTime.add(DateTime.utc_now(), starts_at_delay_mins, :minute)
+
+    Repo.one(
+      from(t in Tournament,
+        limit: 1,
+        order_by: t.id,
+        where:
+          t.state == "upcoming" and
+            t.starts_at < ^delay_time
+      )
+    )
+  end
+
+  @spec get_upcoming_tournaments(%{
+          date_from: DateTime.t(),
+          date_to: DateTime.t()
+        }) :: list(Tournament.t())
+  def get_upcoming_tournaments(filter) do
+    %{date_from: date_from, date_to: date_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.grade != "open" and
+            t.state == "upcoming"
+      )
+    )
+  end
+
+  @spec get_live_tournaments_for_user(User.t()) :: list(Tournament.t())
+  def get_live_tournaments_for_user(user) do
+    get_live_tournaments()
+    |> Enum.filter(fn tournament ->
+      tournament.grade != "open" ||
+        Tournament.Helpers.can_access?(tournament, user, %{})
+    end)
+    |> Enum.uniq_by(& &1.id)
+    |> Enum.sort_by(& &1.id, :desc)
+  end
+
   @spec get_live_tournaments() :: list(Tournament.t())
   def get_live_tournaments do
     Tournament.GlobalSupervisor
@@ -120,7 +177,7 @@ defmodule Codebattle.Tournament.Context do
     |> Enum.map(fn {id, _, _, _} -> Tournament.Context.get(id) end)
     |> Enum.filter(fn
       nil -> false
-      tournament -> tournament.state in ["waiting_participants", "active"]
+      tournament -> tournament.state in ["waiting_participants", "active", "finished"]
     end)
   end
 
@@ -166,6 +223,11 @@ defmodule Codebattle.Tournament.Context do
     Tournament.Server.handle_event(tournament_id, event_type, params)
   end
 
+  @spec get_live_tournament_players(Tournament.t()) :: [Tournament.Player.t()]
+  def get_live_tournament_players(tournament) do
+    Tournament.Players.get_players(tournament)
+  end
+
   @spec update(Tournament.t(), map()) :: {:ok, Tournament.t()} | {:error, Ecto.Changeset.t()}
   def update(tournament, params) do
     tournament
@@ -223,6 +285,18 @@ defmodule Codebattle.Tournament.Context do
     :ok
   end
 
+  @spec move_upcoming_to_live(Tournament.t()) :: :ok
+  def move_upcoming_to_live(tournament) do
+    tournament
+    |> Tournament.changeset(%{state: "waiting_participants"})
+    |> Repo.update!()
+
+    :timer.sleep(1000)
+
+    Tournament.GlobalSupervisor.start_tournament(tournament)
+    :ok
+  end
+
   defp prepare_tournament_params(params) do
     params =
       params

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

@@ -258,6 +258,8 @@ defmodule Codebattle.Tournament.Base do
         end
       end
 
+      def cancel(tournament, params \\ %{})
+
       def cancel(tournament, %{user: user}) do
         if can_moderate?(tournament, user) do
           new_tournament = tournament |> update_struct(%{state: "canceled"}) |> db_save!()
@@ -271,6 +273,15 @@ defmodule Codebattle.Tournament.Base do
         end
       end
 
+      def cancel(tournament, _params) do
+        new_tournament = tournament |> update_struct(%{state: "canceled"}) |> db_save!()
+
+        Game.Context.terminate_tournament_games(tournament.id)
+        Tournament.GlobalSupervisor.terminate_tournament(tournament.id)
+
+        new_tournament
+      end
+
       def restart(tournament, %{user: user}) do
         if can_moderate?(tournament, user) do
           Tournament.Round.disable_all_rounds(tournament.id)
@@ -298,6 +309,8 @@ defmodule Codebattle.Tournament.Base do
 
       def restart(tournament, _user), do: tournament
 
+      def start(tournament, params \\ %{})
+
       def start(%{state: "waiting_participants"} = tournament, %{user: user} = params) do
         if can_moderate?(tournament, user) do
           start(tournament, Map.delete(params, :user))

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

@@ -22,11 +22,11 @@ defmodule Codebattle.Tournament do
              :current_round_position,
              :description,
              :event_id,
+             :grade,
              :id,
              :is_live,
              :last_round_ended_at,
              :last_round_started_at,
-             :level,
              :match_timeout_seconds,
              :matches,
              :meta,
@@ -55,15 +55,60 @@ defmodule Codebattle.Tournament do
 
   @access_types ~w(public token)
   @break_states ~w(on off)
+  @grades ~w(open rookie challenger pro elite masters grand_slam)
   @levels ~w(elementary easy medium hard)
   @public_types ~w(swiss)
   @ranking_types ~w(by_clan by_user)
   @score_strategies ~w(75_percentile win_loss)
-  @states ~w(waiting_participants canceled active timeout finished)
+  @states ~w(upcoming waiting_participants canceled active timeout finished)
   @task_providers ~w(level task_pack all)
   @task_strategies ~w(random sequential)
   @types ~w(swiss)
 
+  @grade_points %{
+    # Open tournaments
+    # All tasks are existing
+    # Casual/unranked mode, no points awarded
+    # Tasks: free play, any level, not ranked, created by user
+    "open" => [],
+
+    # Rookie — every 1 hours
+    # All tasks are existing
+    # Tasks: 5 existing easy tasks
+    # Designed for frequent play and grinding
+    "rookie" => [8, 4, 2],
+
+    # Challenger — daily
+    # All tasks are existing
+    # Tasks: 3 existing easy tasks + 1 existing medium task
+    # Daily backbone tournaments for steady point growth
+    "challenger" => [64, 32, 16, 8, 4, 2],
+
+    # Pro — weekly
+    # All tasks are existing
+    # Tasks: 4 existing easy tasks + 2 existing medium tasks
+    # Mid-level weekly tournaments with more challenges
+    "pro" => [128, 64, 32, 16, 8, 4, 2],
+
+    # Elite — every two weeks
+    # All tasks are existing
+    # Tasks: 5 existing easy tasks + 3 existing medium tasks
+    # Advanced difficulty and higher prestige
+    "elite" => [256, 128, 64, 32, 16, 8, 4, 2],
+
+    # Masters — once per month on the 21st (evening, two per day)
+    # All tasks are new
+    # Tasks: 5 easy tasks + 2 medium tasks
+    # Monthly major tournaments with fresh content
+    "masters" => [1024, 512, 256, 128, 64, 32, 16, 8, 4, 2],
+
+    # Grand Slam — four times per year (21 Mar, 21 Jun, 21 Sep, 21 Dec)
+    # All tasks are new
+    # Tasks: 5 easy tasks + 3 medium tasks + 1 hard task
+    # Seasonal finals, always ends the season
+    "grand_slam" => [2048, 1024, 512, 256, 128, 64, 32, 16, 8, 4, 2]
+  }
+
   @default_match_timeout Application.compile_env(:codebattle, :tournament_match_timeout)
 
   schema "tournaments" do
@@ -78,6 +123,7 @@ defmodule Codebattle.Tournament do
     field(:current_round_position, :integer, default: 0)
     field(:description, :string)
     field(:finished_at, :utc_datetime)
+    field(:grade, :string, default: "open")
     field(:labels, {:array, :string})
     field(:last_round_ended_at, :naive_datetime)
     field(:last_round_started_at, :naive_datetime)
@@ -89,9 +135,9 @@ defmodule Codebattle.Tournament do
     field(:players, AtomizedMap, default: %{})
     field(:players_limit, :integer)
     field(:ranking_type, :string, default: "by_user")
-    field(:score_strategy, :string, default: "75_percentile")
     field(:round_timeout_seconds, :integer)
     field(:rounds_limit, :integer, default: 1)
+    field(:score_strategy, :string, default: "75_percentile")
     field(:show_results, :boolean, default: true)
     field(:started_at, :utc_datetime)
     field(:starts_at, :utc_datetime)
@@ -139,6 +185,7 @@ defmodule Codebattle.Tournament do
       :current_round_position,
       :description,
       :event_id,
+      :grade,
       :last_round_ended_at,
       :last_round_started_at,
       :level,
@@ -173,12 +220,13 @@ defmodule Codebattle.Tournament do
     ])
     |> validate_inclusion(:access_type, @access_types)
     |> validate_inclusion(:break_state, @break_states)
+    |> validate_inclusion(:grade, @grades)
     |> validate_inclusion(:level, @levels)
+    |> validate_inclusion(:ranking_type, @ranking_types)
+    |> validate_inclusion(:score_strategy, @score_strategies)
     |> validate_inclusion(:state, @states)
     |> validate_inclusion(:task_provider, @task_providers)
     |> validate_inclusion(:task_strategy, @task_strategies)
-    |> validate_inclusion(:ranking_type, @ranking_types)
-    |> validate_inclusion(:score_strategy, @score_strategies)
     |> validate_inclusion(:type, @types)
     |> validate_number(:match_timeout_seconds, greater_than_or_equal_to: 1)
     |> validate_required([:name, :starts_at])
@@ -203,11 +251,11 @@ defmodule Codebattle.Tournament do
   end
 
   def access_types, do: @access_types
-  def levels, do: @levels
   def public_types, do: @public_types
   def ranking_types, do: @ranking_types
   def score_strategies, do: @score_strategies
   def task_providers, do: @task_providers
   def task_strategies, do: @task_strategies
   def types, do: @types
+  def grade_points, do: @grade_points
 end

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

@@ -0,0 +1,71 @@
+defmodule Codebattle.Tournament.UpcomingRunner do
+  @moduledoc """
+  This module is responsible for running every minute tournaments from schedule
+  """
+  use GenServer
+
+  alias Codebattle.Tournament
+
+  @tournament_run_upcoming Application.compile_env(:codebattle, :tournament_run_upcoming)
+  @worker_timeout 30_000
+
+  @upcoming_time_before_live_mins 10_000
+
+  @spec start_link([]) :: GenServer.on_start()
+  def start_link(_) do
+    GenServer.start_link(__MODULE__, :noop, name: __MODULE__)
+  end
+
+  @impl GenServer
+  def init(_state) do
+    if @tournament_run_upcoming do
+      Process.send_after(self(), :run_upcoming, @worker_timeout)
+    end
+
+    {:ok, :noop}
+  end
+
+  @impl GenServer
+  def handle_info(:run_upcoming, state) do
+    run_upcoming()
+    start_or_cancel_waiting_participants()
+
+    Process.send_after(self(), :run_upcoming, @worker_timeout)
+
+    {:noreply, state}
+  end
+
+  def handle_info(_, state), do: {:noreply, state}
+
+  def run_upcoming do
+    case Tournament.Context.get_upcoming_to_live_candidate(@upcoming_time_before_live_mins) do
+      %Tournament{} = tournament ->
+        Tournament.Context.move_upcoming_to_live(tournament)
+        :ok
+
+      _ ->
+        :noop
+    end
+  end
+
+  def start_or_cancel_waiting_participants do
+    case Tournament.Context.get_waiting_participants_to_start_candidates() do
+      tournaments when is_list(tournaments) ->
+        Enum.each(
+          tournaments,
+          fn
+            %{players_count: pc} = t when pc > 0 ->
+              Tournament.Context.handle_event(t.id, :start, %{})
+
+            %{players_count: 0} = t ->
+              Tournament.Context.handle_event(t.id, :cancel, %{})
+          end
+        )
+
+        :ok
+
+      _ ->
+        :noop
+    end
+  end
+end

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

@@ -37,6 +37,7 @@ defmodule Codebattle.User do
              :lang,
              :locale,
              :name,
+             :points,
              :rank,
              :rating,
              :sound_settings,
@@ -69,6 +70,7 @@ defmodule Codebattle.User do
     field(:locale, :string)
     field(:name, :string)
     field(:password_hash, :string)
+    field(:points, :integer, default: 0)
     field(:public_id, :binary_id)
     field(:rank, :integer, default: 5432)
     field(:rating, :integer, default: 1200)
@@ -147,6 +149,7 @@ defmodule Codebattle.User do
       lang: Application.get_env(:codebattle, :default_lang_slug),
       rating: 0,
       locale: "en",
+      points: 0,
       rank: 0,
       sound_settings: %SoundSettings{}
     }