Add oban

Author: vtm9

apps/codebattle/lib/codebattle/application.ex

@@ -26,6 +26,7 @@ defmodule Codebattle.Application do
         {Codebattle.Tournament.UpcomingRunner, []},
         {Codebattle.ImageCache, []},
         {Codebattle.Repo, []},
+        {Oban, Application.fetch_env!(:codebattle, Oban)},
         {Registry, keys: :unique, name: Codebattle.Registry},
         CodebattleWeb.Telemetry,
         %{id: Codebattle.PubSub, start: {Phoenix.PubSub.Supervisor, :start_link, [[name: Codebattle.PubSub]]}},

apps/codebattle/lib/codebattle/event.ex

@@ -43,8 +43,10 @@ defmodule Codebattle.Event do
                  :action_button_text,
                  :confirmation_text,
                  :dates,
+                 :group_tournament_id,
                  :group_tournament_meta,
                  :name,
+                 :save_results,
                  :slug,
                  :status,
                  :tournament_id,
@@ -56,7 +58,9 @@ defmodule Codebattle.Event do
       field(:action_button_text, :string)
       field(:confirmation_text, :string)
       field(:dates, :string)
+      field(:group_tournament_id, :integer)
       field(:name, :string)
+      field(:save_results, :boolean, default: true)
       field(:slug, :string)
       field(:status, Ecto.Enum, values: [:pending, :passed, :active])
       field(:tournament_id, :integer)
@@ -145,8 +149,10 @@ defmodule Codebattle.Event do
       :action_button_text,
       :confirmation_text,
       :dates,
+      :group_tournament_id,
       :group_tournament_meta,
       :name,
+      :save_results,
       :slug,
       :status,
       :tournament_id,

apps/codebattle/lib/codebattle/event/user_event_stage.ex

@@ -14,6 +14,7 @@ defmodule Codebattle.UserEvent.Stage do
              :slug,
              :status,
              :tournament_id,
+             :group_tournament_id,
              :entrance_result,
              :place_in_total_rank,
              :place_in_category_rank,
@@ -31,6 +32,7 @@ defmodule Codebattle.UserEvent.Stage do
     field(:slug, :string)
     field(:status, Ecto.Enum, values: @statuses)
     field(:tournament_id, :integer)
+    field(:group_tournament_id, :integer)
     field(:entrance_result, Ecto.Enum, values: @entrance_results)
     field(:place_in_total_rank, :integer)
     field(:place_in_category_rank, :integer)
@@ -50,6 +52,7 @@ defmodule Codebattle.UserEvent.Stage do
       :slug,
       :status,
       :tournament_id,
+      :group_tournament_id,
       :entrance_result,
       :place_in_total_rank,
       :place_in_category_rank,

apps/codebattle/lib/codebattle/event/user_event_stage/context.ex

@@ -0,0 +1,67 @@
+defmodule Codebattle.UserEvent.Stage.Context do
+  @moduledoc false
+
+  import Ecto.Query
+
+  alias Codebattle.Repo
+  alias Codebattle.UserEvent
+  alias Codebattle.UserEvent.Stage
+  alias Codebattle.Workers.SaveGroupTournamentResultsWorker
+  alias Codebattle.Workers.SaveTournamentResultsWorker
+
+  @spec save_tournament_results_async(integer()) :: {:ok, Oban.Job.t()} | {:error, term()}
+  def save_tournament_results_async(tournament_id) do
+    %{tournament_id: tournament_id}
+    |> SaveTournamentResultsWorker.new()
+    |> Oban.insert()
+  end
+
+  @spec save_group_tournament_results_async(integer()) :: {:ok, Oban.Job.t()} | {:error, term()}
+  def save_group_tournament_results_async(group_tournament_id) do
+    %{group_tournament_id: group_tournament_id}
+    |> SaveGroupTournamentResultsWorker.new()
+    |> Oban.insert()
+  end
+
+  @spec save_tournament_results(integer(), list(map())) :: :ok
+  def save_tournament_results(event_id, player_results) do
+    Enum.each(player_results, fn player_result ->
+      with %UserEvent{} = user_event <- UserEvent.get_by_user_id_and_event_id(player_result.user_id, event_id),
+           %Stage{} = stage <- Enum.find(user_event.stages, &(&1.tournament_id == player_result.tournament_id)) do
+        stage
+        |> Stage.changeset(%{
+          wins_count: player_result.wins_count,
+          games_count: player_result.games_count,
+          time_spent_in_seconds: player_result.time_spent_in_seconds,
+          group_tournament_id: player_result[:group_tournament_id]
+        })
+        |> Repo.update()
+      end
+    end)
+
+    :ok
+  end
+
+  @spec mark_stages_completed(integer(), integer()) :: :ok
+  def mark_stages_completed(event_id, tournament_id) do
+    now = DateTime.utc_now()
+
+    Stage
+    |> join(:inner, [s], ue in UserEvent, on: s.user_event_id == ue.id)
+    |> where([s, ue], ue.event_id == ^event_id and s.tournament_id == ^tournament_id)
+    |> Repo.update_all(set: [status: :completed, finished_at: now])
+
+    :ok
+  end
+
+  @spec mark_stages_completed_by_group_tournament(integer()) :: :ok
+  def mark_stages_completed_by_group_tournament(group_tournament_id) do
+    now = DateTime.utc_now()
+
+    Stage
+    |> where([s], s.group_tournament_id == ^group_tournament_id)
+    |> Repo.update_all(set: [status: :completed, finished_at: now])
+
+    :ok
+  end
+end

apps/codebattle/lib/codebattle/group_tournament/context.ex

@@ -249,6 +249,55 @@ defmodule Codebattle.GroupTournament.Context do
     |> ensure_server_started()
   end
 
+  @spec bulk_transfer_players(pos_integer(), list(map())) :: :ok
+  def bulk_transfer_players(group_tournament_id, players) do
+    now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
+
+    player_entries =
+      Enum.map(players, fn player ->
+        %{
+          group_tournament_id: group_tournament_id,
+          user_id: player.id,
+          lang: player.lang || "js",
+          state: "active",
+          inserted_at: now,
+          updated_at: now
+        }
+      end)
+
+    user_group_tournament_entries =
+      Enum.map(players, fn player ->
+        %{
+          group_tournament_id: group_tournament_id,
+          user_id: player.id,
+          state: "pending",
+          repo_state: "pending",
+          role_state: "pending",
+          secret_state: "pending",
+          repo_response: %{},
+          role_response: %{},
+          secret_response: %{},
+          last_error: %{},
+          inserted_at: now,
+          updated_at: now
+        }
+      end)
+
+    player_entries
+    |> Enum.chunk_every(1000)
+    |> Enum.each(fn chunk ->
+      Repo.insert_all(GroupTournamentPlayer, chunk, on_conflict: :nothing)
+    end)
+
+    user_group_tournament_entries
+    |> Enum.chunk_every(1000)
+    |> Enum.each(fn chunk ->
+      Repo.insert_all(UserGroupTournament, chunk, on_conflict: :nothing)
+    end)
+
+    :ok
+  end
+
   defp enrich(%GroupTournament{} = group_tournament) do
     Map.put(group_tournament, :players_count, length(group_tournament.players || []))
   end

…attle/lib/codebattle/group_tournament.ex …tle/group_tournament/group_tournament.exapps/codebattle/lib/codebattle/group_tournament.ex renamed to apps/codebattle/lib/codebattle/group_tournament/group_tournament.ex apps/codebattle/lib/codebattle/group_tournament.ex renamed to apps/codebattle/lib/codebattle/group_tournament/group_tournament.ex

@@ -5,8 +5,10 @@ defmodule Codebattle.GroupTournament do
 
   import Ecto.Changeset
 
+  alias Codebattle.Event
   alias Codebattle.GroupTask
   alias Codebattle.GroupTournamentPlayer
+  alias Codebattle.Tournament
   alias Codebattle.User
 
   @states ~w(waiting_participants active finished canceled)
@@ -17,6 +19,7 @@ defmodule Codebattle.GroupTournament do
            only: [
              :id,
              :creator_id,
+             :event_id,
              :group_task_id,
              :name,
              :slug,
@@ -34,12 +37,15 @@ defmodule Codebattle.GroupTournament do
              :meta,
              :require_invitation,
              :run_on_external_platform,
-             :template_id
+             :template_id,
+             :tournament_id
            ]}
 
   schema "group_tournaments" do
     belongs_to(:creator, User)
+    belongs_to(:event, Event)
     belongs_to(:group_task, GroupTask)
+    belongs_to(:tournament, Tournament)
 
     field(:name, :string)
     field(:slug, :string)
@@ -72,6 +78,7 @@ defmodule Codebattle.GroupTournament do
     group_tournament
     |> cast(attrs, [
       :creator_id,
+      :event_id,
       :group_task_id,
       :name,
       :slug,
@@ -87,6 +94,7 @@ defmodule Codebattle.GroupTournament do
       :require_invitation,
       :run_on_external_platform,
       :template_id,
+      :tournament_id,
       :last_round_started_at,
       :last_round_ended_at,
       :meta

apps/codebattle/lib/codebattle/group_tournament/server.ex

@@ -138,6 +138,8 @@ defmodule Codebattle.GroupTournament.Server do
       |> Repo.preload([:creator, :group_task, players: [:user]])
       |> Map.put(:is_live, true)
 
+    Codebattle.UserEvent.Stage.Context.save_group_tournament_results_async(updated.id)
+
     next_state =
       state
       |> cancel_finish_timer()

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

@@ -7,7 +7,6 @@ defmodule Codebattle.Tournament.Base do
   alias Codebattle.Event
   alias Codebattle.Game
   alias Codebattle.Tournament
-  alias Codebattle.UserEvent
   alias Codebattle.UserGameReport
 
   @callback build_round_pairs(Tournament.t()) :: {Tournament.t(), list(list(pos_integer()))}
@@ -1328,96 +1327,13 @@ defmodule Codebattle.Tournament.Base do
         tournament
       end
 
-      defp maybe_save_event_results(%{event_id: event_id} = tournament) when not is_nil(event_id) do
-        event = Event.get!(event_id)
-        event_stage = find_event_stage_for_tournament(event, tournament)
-
-        has_group_tournament =
-          match?(%{group_tournament_meta: meta} when is_map(meta) and map_size(meta) > 0, event_stage)
-
-        if !has_group_tournament do
-          tournament
-          |> get_players()
-          |> Enum.reject(& &1.is_bot)
-          |> Enum.each(fn player ->
-            UserEvent.mark_stage_as_completed(event_id, player.id, %{
-              id: tournament.id,
-              wins_count: player.wins_count,
-              games_count: get_players_total_games_count(tournament, player),
-              time_spent_in_seconds:
-                tournament
-                |> get_matches(player.matches_ids)
-                |> Enum.map(&(&1.duration_sec || 0))
-                |> Enum.sum()
-            })
-          end)
-        end
-
-        maybe_create_group_tournament(tournament, event, event_stage)
+      defp maybe_save_event_results(%{event_id: _event_id} = tournament) do
+        Codebattle.UserEvent.Stage.Context.save_tournament_results_async(tournament.id)
+        tournament
       end
 
       defp maybe_save_event_results(t), do: t
 
-      defp maybe_create_group_tournament(tournament, _event, %{group_tournament_meta: meta})
-           when is_map(meta) and map_size(meta) > 0 do
-        create_group_tournament_for_stage(tournament, meta)
-      end
-
-      defp maybe_create_group_tournament(tournament, _event, _stage), do: tournament
-
-      defp find_event_stage_for_tournament(event, tournament) do
-        # For global tournaments, the event stage has tournament_id set
-        stage = Enum.find(event.stages, &(&1.tournament_id == tournament.id))
-
-        if stage, do: stage, else: find_event_stage_by_slug(event, tournament)
-      end
-
-      defp find_event_stage_by_slug(event, tournament) do
-        # For single play tournaments, find via user_event_stage
-        case find_stage_slug_from_user_event(tournament) do
-          nil -> nil
-          slug -> Event.get_stage(event, slug)
-        end
-      end
-
-      defp find_stage_slug_from_user_event(tournament) do
-        import Ecto.Query, only: [where: 3, select: 3, limit: 2]
-
-        Codebattle.UserEvent.Stage
-        |> where([s], s.tournament_id == ^tournament.id)
-        |> select([s], s.slug)
-        |> limit(1)
-        |> Codebattle.Repo.one()
-      end
-
-      defp create_group_tournament_for_stage(tournament, meta) do
-        attrs = %{
-          creator_id: tournament.creator_id,
-          group_task_id: meta[:group_task_id],
-          name: meta[:name] || "#{tournament.name} - Review",
-          slug: meta[:slug] || "event-#{tournament.event_id}-t-#{tournament.id}",
-          description: meta[:description] || tournament.description,
-          starts_at: DateTime.utc_now(),
-          rounds_count: meta[:rounds_count] || 1,
-          round_timeout_seconds: meta[:round_timeout_seconds] || 3600,
-          run_on_external_platform: meta[:run_on_external_platform] || false,
-          template_id: meta[:template_id]
-        }
-
-        case Codebattle.GroupTournament.Context.create_group_tournament(attrs) do
-          {:ok, group_tournament} ->
-            Tournament.Context.update(tournament, %{
-              "group_tournament_id" => group_tournament.id
-            })
-
-            update_struct(tournament, %{group_tournament_id: group_tournament.id})
-
-          {:error, reason} ->
-            Logger.error("Failed to create group tournament: #{inspect(reason)}")
-            tournament
-        end
-      end
-
       defp maybe_activate_players(%{current_round_position: 0} = t), do: t
 
       defp maybe_activate_players(t), do: t

apps/codebattle/lib/codebattle/workers/save_group_tournament_results_worker.ex

@@ -0,0 +1,25 @@
+defmodule Codebattle.Workers.SaveGroupTournamentResultsWorker do
+  @moduledoc false
+
+  use Oban.Worker
+
+  alias Codebattle.Event
+  alias Codebattle.GroupTournament
+  alias Codebattle.UserEvent.Stage.Context, as: StageContext
+
+  @impl Oban.Worker
+  def perform(%Oban.Job{args: %{"group_tournament_id" => group_tournament_id}}) do
+    group_tournament = GroupTournament.Context.get_group_tournament!(group_tournament_id)
+
+    if group_tournament.event_id do
+      event = Event.get!(group_tournament.event_id)
+      event_stage = Enum.find(event.stages, &(&1.group_tournament_id == group_tournament_id))
+
+      if event_stage && event_stage.save_results != false do
+        StageContext.mark_stages_completed_by_group_tournament(group_tournament_id)
+      end
+    end
+
+    :ok
+  end
+end