Improve

Author: vtm9

apps/codebattle/assets/js/widgets/middlewares/GroupTournament.js

@@ -116,6 +116,7 @@ export const load = (groupTournamentId) => async (dispatch) => {
       "x-csrf-token": window.csrf_token,
     },
   });
+  console.log(response);
 
   dispatch(actions.setData(response));
-}
+};

apps/codebattle/assets/js/widgets/pages/groupTournament/EvolutionPanel.jsx

@@ -2,6 +2,45 @@ import React from "react";
 
 const getExternalUrl = (url) => `${url}/browse/README.md?rev=main&chatMessage=""`;
 
+const formatInsertedAt = (insertedAt) => {
+  if (!insertedAt) {
+    return null;
+  }
+
+  const date = new Date(insertedAt);
+
+  if (Number.isNaN(date.getTime())) {
+    return null;
+  }
+
+  return date.toLocaleString();
+};
+
+const buildRunSummary = (item, idx) => {
+  if (!item || typeof item !== "object") {
+    return {
+      key: idx,
+      title: `v${idx + 1}`,
+      meta: item ? String(item) : null,
+    };
+  }
+
+  const playersCount = item.playerIds?.length;
+  const meta = [
+    item.status,
+    playersCount ? `${playersCount} players` : null,
+    formatInsertedAt(item.insertedAt),
+  ]
+    .filter(Boolean)
+    .join(" • ");
+
+  return {
+    key: item.id ?? idx,
+    title: `Run #${item.id ?? idx + 1}`,
+    meta,
+  };
+};
+
 function EvolutionPanel({ items, tournamentStatus, runId, setRunId, repoUrl }) {
   return (
     <div className="card cb-card border cb-border-color rounded h-100">
@@ -18,17 +57,32 @@ function EvolutionPanel({ items, tournamentStatus, runId, setRunId, repoUrl }) {
           {items && items.length > 0 && (
             <div className="mt-2 small">
               <div className="list-group list-group-flush">
-                {items.map((item, idx) => (
-                  <button
-                    key={idx}
-                    type="button"
-                    onClick={() => setRunId(item.id)}
-                    className="list-group-item list-group-item-action px-0 py-1 border-0 text-left bg-transparent"
-                  >
-                    <span className="badge badge-secondary mr-2">v{idx + 1}</span>
-                    <span className="text-truncate">{item}</span>
-                  </button>
-                ))}
+                {items.map((item, idx) => {
+                  const summary = buildRunSummary(item, idx);
+
+                  return (
+                    <button
+                      key={summary.key}
+                      type="button"
+                      onClick={() => setRunId(item?.id)}
+                      className="list-group-item list-group-item-action px-0 py-1 border-0 text-left bg-transparent"
+                      style={{
+                        backgroundColor:
+                          runId === item?.id ? "rgba(40, 167, 69, 0.14)" : "transparent",
+                      }}
+                    >
+                      <div className="d-flex align-items-center">
+                        <span className="badge badge-secondary mr-2">v{idx + 1}</span>
+                        <span className="text-truncate">{summary.title}</span>
+                      </div>
+                      {summary.meta ? (
+                        <small className="d-block text-muted text-truncate mt-1">
+                          {summary.meta}
+                        </small>
+                      ) : null}
+                    </button>
+                  );
+                })}
               </div>
             </div>
           )}

apps/codebattle/assets/js/widgets/pages/groupTournament/GroupTournamentPage.jsx

@@ -1,4 +1,4 @@
-import React, { useEffect, useState } from "react";
+import React, { useEffect, useMemo, useState } from "react";
 import { useDispatch, useSelector } from "react-redux";
 
 import Header from "./Header";
@@ -11,6 +11,47 @@ import * as selectors from "../../selectors";
 import Loading from "@/components/Loading";
 import { load, requestInviteUpdate } from "@/middlewares/GroupTournament";
 
+const getDateTimestamp = (value) => {
+  if (!value) {
+    return null;
+  }
+
+  const timestamp = new Date(value).getTime();
+
+  return Number.isNaN(timestamp) ? null : timestamp;
+};
+
+const findSolutionForRun = (run, solutionHistory) => {
+  if (!run || !solutionHistory?.length) {
+    return null;
+  }
+
+  const solutionWithSameId = solutionHistory.find((solution) => solution.id === run.id);
+
+  if (solutionWithSameId) {
+    return solutionWithSameId;
+  }
+
+  const runInsertedAtTimestamp = getDateTimestamp(run.insertedAt);
+
+  if (runInsertedAtTimestamp === null) {
+    return solutionHistory[0] || null;
+  }
+
+  return (
+    solutionHistory.find((solution) => {
+      const solutionInsertedAtTimestamp = getDateTimestamp(solution.insertedAt);
+
+      return (
+        solutionInsertedAtTimestamp !== null &&
+        solutionInsertedAtTimestamp <= runInsertedAtTimestamp
+      );
+    }) ||
+    solutionHistory[solutionHistory.length - 1] ||
+    null
+  );
+};
+
 function GroupTournamentPage({ tournamentId, tournamentName, tournamentDescription }) {
   const dispatch = useDispatch();
 
@@ -35,6 +76,14 @@ function GroupTournamentPage({ tournamentId, tournamentName, tournamentDescripti
     data,
   } = useSelector(selectors.groupTournamentSelector);
 
+  const solutionHistory = useMemo(() => data?.solutionHistory || [], [data?.solutionHistory]);
+  const selectedRunSolution = useMemo(
+    () => findSolutionForRun(selectedRun, solutionHistory),
+    [selectedRun, solutionHistory],
+  );
+  const editorText = selectedRunSolution?.solution || code;
+  const editorLang = selectedRunSolution?.lang || langSlug;
+
   const openExternalRegistrationWindow = () => {
     setShowInviteWindow(true);
   };
@@ -60,7 +109,7 @@ function GroupTournamentPage({ tournamentId, tournamentName, tournamentDescripti
     if (tournamentId) {
       load(tournamentId)(dispatch);
     }
-  }, [tournamentId, dispatch])
+  }, [tournamentId, dispatch]);
 
   if (invite.state === "loading" && requireInvitation) {
     return <Loading />;
@@ -124,7 +173,7 @@ function GroupTournamentPage({ tournamentId, tournamentName, tournamentDescripti
           />
         </div>
         <div className="col-lg-4 col-md-4 col-12 p-1 pb-4">
-          <EditorPanel text={code} lang={langSlug} />
+          <EditorPanel text={editorText} lang={editorLang} />
           <LogPanel logs={logs} />
         </div>
       </div>

apps/codebattle/lib/codebattle/external_platform.ex

@@ -200,22 +200,45 @@ defmodule Codebattle.ExternalPlatform do
   def get_invite(_), do: {:error, :invalid_invite_id}
 
   @doc """
-  Forks a repository into the target organization.
-  POST /repos/{org_slug}/{repo_slug}/fork
+  Creates a repository in the target organization from a template repository.
+  POST /orgs/{org_slug}/repos
   """
-  @spec fork_repo(String.t(), String.t(), keyword()) :: {:ok, map()} | {:error, term()}
-  def fork_repo(repo_slug, target_org_slug, opts \\ []) do
-    source_org_slug = Keyword.get(opts, :source_org_slug, default_org_slug())
+  @spec create_repo_from_template(String.t(), keyword()) :: {:ok, map()} | {:error, term()}
+  def create_repo_from_template(target_org_slug, opts \\ []) do
+    slug = opts[:slug]
+    template_id = opts[:template_id]
 
-    body = %{org_slug: target_org_slug}
-    body = if opts[:slug], do: Map.put(body, :slug, opts[:slug]), else: body
+    cond do
+      !is_binary(target_org_slug) || String.trim(target_org_slug) == "" ->
+        {:error, :invalid_org_slug}
 
-    body =
-      if Keyword.has_key?(opts, :default_branch_only),
-        do: Map.put(body, :default_branch_only, opts[:default_branch_only]),
-        else: body
+      !is_binary(slug) || String.trim(slug) == "" ->
+        {:error, :invalid_repo_slug}
+
+      !is_binary(template_id) || String.trim(template_id) == "" ->
+        {:error, :invalid_template_id}
+
+      true ->
+        do_create_repo_from_template(String.trim(target_org_slug), opts)
+    end
+  end
 
-    url = "#{external_platform_service_url()}/repos/#{source_org_slug}/#{repo_slug}/fork"
+  defp do_create_repo_from_template(target_org_slug, opts) do
+    slug = String.trim(opts[:slug])
+    template_id = String.trim(opts[:template_id])
+
+    body =
+      %{
+        name: Keyword.get(opts, :name, slug),
+        slug: slug,
+        description: opts[:description],
+        visibility: Keyword.get(opts, :visibility, "public"),
+        templating_options: %{template_id: template_id}
+      }
+      |> Enum.reject(fn {_key, value} -> is_nil(value) end)
+      |> Map.new()
+
+    url = "#{external_platform_service_url()}/orgs/#{target_org_slug}/repos"
 
     req_opts =
       Keyword.merge(
@@ -225,7 +248,7 @@ defmodule Codebattle.ExternalPlatform do
         receive_timeout: @invite_timeout_ms
       )
 
-    Logger.info("ExternalPlatform.fork_repo START method=POST url=#{url} body=#{inspect(body)}")
+    Logger.info("ExternalPlatform.create_repo_from_template START method=POST url=#{url} body=#{inspect(body)}")
 
     started_at = System.monotonic_time(:millisecond)
     result = safe_request(:post, url, req_opts)
@@ -234,20 +257,22 @@ defmodule Codebattle.ExternalPlatform do
     case result do
       {:ok, %{status: status, body: resp_body}} when status in [200, 201] ->
         Logger.info(
-          "ExternalPlatform.fork_repo OK url=#{url} status=#{status} duration_ms=#{duration_ms} body=#{inspect(resp_body)}"
+          "ExternalPlatform.create_repo_from_template OK url=#{url} status=#{status} duration_ms=#{duration_ms} body=#{inspect(resp_body)}"
         )
 
         {:ok, resp_body}
 
       {:ok, %{status: status, body: resp_body}} ->
         Logger.warning(
-          "ExternalPlatform.fork_repo FAIL url=#{url} status=#{status} duration_ms=#{duration_ms} body=#{inspect(resp_body)}"
+          "ExternalPlatform.create_repo_from_template FAIL url=#{url} status=#{status} duration_ms=#{duration_ms} body=#{inspect(resp_body)}"
         )
 
         {:error, resp_body}
 
       {:error, reason} ->
-        Logger.warning("ExternalPlatform.fork_repo ERROR url=#{url} duration_ms=#{duration_ms} reason=#{inspect(reason)}")
+        Logger.warning(
+          "ExternalPlatform.create_repo_from_template ERROR url=#{url} duration_ms=#{duration_ms} reason=#{inspect(reason)}"
+        )
 
         {:error, reason}
     end

apps/codebattle/lib/codebattle/group_tournament.ex

@@ -33,7 +33,8 @@ defmodule Codebattle.GroupTournament do
              :last_round_ended_at,
              :meta,
              :require_invitation,
-             :run_on_external_platform
+             :run_on_external_platform,
+             :template_id
            ]}
 
   schema "group_tournaments" do
@@ -53,6 +54,7 @@ defmodule Codebattle.GroupTournament do
     field(:include_bots, :boolean, default: false)
     field(:require_invitation, :boolean, default: false)
     field(:run_on_external_platform, :boolean, default: false)
+    field(:template_id, :string)
     field(:last_round_started_at, :naive_datetime)
     field(:last_round_ended_at, :naive_datetime)
     field(:meta, :map, default: %{})
@@ -84,6 +86,7 @@ defmodule Codebattle.GroupTournament do
       :include_bots,
       :require_invitation,
       :run_on_external_platform,
+      :template_id,
       :last_round_started_at,
       :last_round_ended_at,
       :meta
@@ -99,12 +102,15 @@ defmodule Codebattle.GroupTournament do
       :round_timeout_seconds
     ])
     |> update_change(:slug, &normalize_slug/1)
+    |> update_change(:template_id, &normalize_optional_string/1)
     |> validate_inclusion(:state, @states)
     |> validate_length(:name, min: 2, max: 255)
     |> validate_length(:slug, min: 2, max: 255)
     |> validate_length(:description, min: 3, max: 7531)
+    |> validate_length(:template_id, max: 255)
     |> validate_number(:rounds_count, greater_than: 0)
     |> validate_number(:round_timeout_seconds, greater_than: 0)
+    |> validate_template_id()
     |> foreign_key_constraint(:creator_id)
     |> foreign_key_constraint(:group_task_id)
   end
@@ -113,4 +119,23 @@ defmodule Codebattle.GroupTournament do
 
   defp normalize_slug(nil), do: nil
   defp normalize_slug(slug), do: slug |> String.trim() |> String.downcase()
+
+  defp normalize_optional_string(nil), do: nil
+
+  defp normalize_optional_string(value) when is_binary(value) do
+    case String.trim(value) do
+      "" -> nil
+      trimmed -> trimmed
+    end
+  end
+
+  defp normalize_optional_string(value), do: value
+
+  defp validate_template_id(changeset) do
+    if get_field(changeset, :run_on_external_platform) do
+      validate_required(changeset, [:template_id])
+    else
+      changeset
+    end
+  end
 end

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

@@ -1400,7 +1400,8 @@ defmodule Codebattle.Tournament.Base do
           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
+          run_on_external_platform: meta[:run_on_external_platform] || false,
+          template_id: meta[:template_id]
         }
 
         case Codebattle.GroupTournament.Context.create_group_tournament(attrs) do

apps/codebattle/lib/codebattle/user_group_tournament/context.ex

@@ -173,7 +173,9 @@ defmodule Codebattle.UserGroupTournament.Context do
   defp ensure_repo(%UserGroupTournament{repo_state: "completed"} = record, _group_tournament, _user), do: {:ok, record}
 
   defp ensure_repo(%UserGroupTournament{} = record, %GroupTournament{} = group_tournament, %User{} = user) do
-    case ExternalPlatform.fork_repo(group_tournament.slug, target_org_slug(), slug: repo_slug_for(user, group_tournament)) do
+    repo_slug = repo_slug_for(user, group_tournament)
+
+    case create_repo_for_tournament(group_tournament, repo_slug) do
       {:ok, response} ->
         {:ok,
          update!(record, %{
@@ -301,6 +303,19 @@ defmodule Codebattle.UserGroupTournament.Context do
   defp repo_slug(group_tournament_slug, ""), do: group_tournament_slug
   defp repo_slug(group_tournament_slug, login), do: "#{group_tournament_slug}-#{login}"
 
+  defp create_repo_for_tournament(%GroupTournament{template_id: template_id} = group_tournament, repo_slug)
+       when is_binary(template_id) and template_id != "" do
+    ExternalPlatform.create_repo_from_template(
+      target_org_slug(),
+      name: repo_slug,
+      slug: repo_slug,
+      description: group_tournament.description,
+      template_id: template_id
+    )
+  end
+
+  defp create_repo_for_tournament(_group_tournament, _repo_slug), do: {:error, %{error: "template_id is required"}}
+
   defp ensure_platform_identity(%User{} = user) do
     lookup_login = platform_identity_lookup_login(user)
 
@@ -352,6 +367,8 @@ defmodule Codebattle.UserGroupTournament.Context do
     |> Repo.update!()
   end
 
+  defp extract_repo_url(%{"web_url" => repo_url}) when is_binary(repo_url) and repo_url != "", do: repo_url
+  defp extract_repo_url(%{web_url: repo_url}) when is_binary(repo_url) and repo_url != "", do: repo_url
   defp extract_repo_url(%{"repo_url" => repo_url}) when is_binary(repo_url) and repo_url != "", do: repo_url
   defp extract_repo_url(%{repo_url: repo_url}) when is_binary(repo_url) and repo_url != "", do: repo_url
   defp extract_repo_url(%{"url" => repo_url}) when is_binary(repo_url) and repo_url != "", do: repo_url