Stay with only swiss tournament

Author: Vitaly

services/app/apps/codebattle/assets/js/widgets/pages/tournament/Tournament.jsx

@@ -189,7 +189,6 @@ function Tournament({ waitingRoomMachine }) {
   useEffect(() => {
     if (tournament.isLive) {
       const channel = connectToChat(tournament.useChat, 'channel')(dispatch);
-
       return () => {
         if (channel) {
           channel.leave();
@@ -199,7 +198,7 @@ function Tournament({ waitingRoomMachine }) {
 
     return () => {};
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
+  }, [tournament.isLive]);
 
   useEffect(() => {
     if (matchConfirmationModalShowing) {

services/app/apps/codebattle/assets/js/widgets/pages/tournament/TournamentChat.jsx

@@ -2,6 +2,7 @@ import React, {
   memo,
   useCallback,
   useRef,
+  useEffect,
 } from 'react';
 
 import { useSelector } from 'react-redux';
@@ -36,34 +37,48 @@ function TournamentChat() {
 
   useChatRooms('channel');
 
+  const messagesContainerRef = useRef(null);
+
+  // Auto-scroll to bottom when messages change
+  useEffect(() => {
+    if (messagesContainerRef.current) {
+      const { scrollHeight, clientHeight } = messagesContainerRef.current;
+      messagesContainerRef.current.scrollTop = scrollHeight - clientHeight;
+    }
+  }, [messages]);
+
   return (
     <ChatContextMenu menuId={menuId} inputRef={inputRef} request={menuRequest}>
-      <div className="my-2 mt-lg-0 sticky-top bg-white rounded-lg position-relative">
-        <div className="rounded-top shadow-sm" style={{ height: '350px' }}>
+      <div className="my-2 mt-lg-0 sticky-top bg-white rounded-lg position-relative d-flex flex-column" style={{ height: '450px' }}>
+        <div className="d-flex border-bottom align-items-center p-2">
+          <Rooms disabled={!isOnline} />
+          {currentUserIsAdmin && (
+            <button
+              type="button"
+              className="btn btn-sm btn-link text-danger"
+              onClick={handleCleanBanned}
+              disabled={!isOnline}
+            >
+              Clean banned
+            </button>
+          )}
+        </div>
+        <div className="px-2">
+          <small className="text-muted text-nowrap">Please, be nice in chat</small>
+        </div>
+        <div className="flex-grow-1 overflow-hidden d-flex flex-column">
           <div
-            className="overflow-auto h-100 text-break"
+            ref={messagesContainerRef}
+            className="overflow-auto h-100"
             id="new-chat-message"
+            style={{ scrollBehavior: 'smooth' }}
           >
-            <div className="d-flex border-bottom align-items-center">
-              <Rooms disabled={!isOnline} />
-              {currentUserIsAdmin && (
-                <button
-                  type="button"
-                  className="btn btn-sm btn-link text-danger"
-                  onClick={handleCleanBanned}
-                  disabled={!isOnline}
-                >
-                  Clean banned
-                </button>
-              )}
-            </div>
-            <div>
-              <small className="pl-3 text-muted text-nowrap">Please, be nice in chat</small>
-            </div>
             <Messages displayMenu={displayMenu} messages={messages} />
           </div>
         </div>
-        <TournamentChatInput disabled={!isOnline} />
+        <div className="border-top p-2">
+          <TournamentChatInput disabled={!isOnline} />
+        </div>
       </div>
     </ChatContextMenu>
   );

services/app/apps/codebattle/assets/js/widgets/pages/tournament/TournamentChatInput.jsx

@@ -1,19 +1,75 @@
-import React, { useState, useCallback, useRef } from 'react';
+import React, {
+ useState, useCallback, useRef, useEffect,
+} from 'react';
 
+import BadWordsNext from 'bad-words-next';
+
+import messageTypes from '../../config/messageTypes';
 import { addMessage } from '../../middlewares/Chat';
 
 export default function TournamentChatInput({ disabled }) {
   const [message, setMessage] = useState('');
+  const [badwordsReady, setBadwordsReady] = useState(false);
+
   const inputRef = useRef(null);
-  const handleChange = useCallback(({ target: { value } }) => {
-    setMessage(value);
-  }, [setMessage]);
-
-  const handleSubmit = useCallback(e => {
-    e.preventDefault();
-    addMessage(message);
-    setMessage('');
-  }, [message]);
+  const badwordsRef = useRef(new BadWordsNext());
+  const handleChange = useCallback(
+    ({ target: { value } }) => {
+      setMessage(value);
+    },
+    [setMessage],
+  );
+
+  const handleSubmit = useCallback(
+    e => {
+      e.preventDefault();
+      let filteredText = message;
+
+      if (badwordsReady) {
+        try {
+          filteredText = badwordsRef.current.filter(filteredText);
+        } catch (error) {
+          console.error('Error filtering text:', error);
+        }
+      }
+
+      const msg = {
+        text: filteredText,
+        meta: { type: messageTypes.general },
+      };
+
+      addMessage(msg);
+      setMessage('');
+    },
+    [message, badwordsReady],
+  );
+
+  useEffect(() => {
+    let mounted = true;
+    async function loadBadwords() {
+      try {
+        // Import without extension to let webpack resolve the correct file
+        const enData = await import('bad-words-next/lib/en');
+        const ruData = await import('bad-words-next/lib/ru');
+        const rlData = await import('bad-words-next/lib/ru_lat');
+
+        if (mounted) {
+          badwordsRef.current.add(enData.default || enData);
+          badwordsRef.current.add(ruData.default || ruData);
+          badwordsRef.current.add(rlData.default || rlData);
+          setBadwordsReady(true);
+        }
+      } catch (error) {
+        console.error('Error loading bad words dictionaries:', error);
+      }
+    }
+
+    loadBadwords();
+
+    return () => {
+      mounted = false;
+    };
+  }, []);
 
   return (
     <form className="m-0" onSubmit={handleSubmit}>

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

@@ -104,7 +104,8 @@ defmodule Codebattle.Tournament.Context do
     Repo.all(
       from(t in Tournament,
         order_by: t.starts_at,
-        where: t.event_id == ^event_id and t.state in ["waiting_participants", "active", "finished"]
+        where:
+          t.event_id == ^event_id and t.state in ["waiting_participants", "active", "finished"]
       )
     )
   end
@@ -252,67 +253,17 @@ defmodule Codebattle.Tournament.Context do
         _ -> nil
       end
 
-    event_id =
-      case params[:event_id] do
-        nil -> nil
-        "" -> nil
-        str when is_binary(str) -> String.to_integer(str)
-        int -> int
-      end
-
     show_results = params[:show_results] || true
 
     Map.merge(params, %{
       access_token: access_token,
       match_timeout_seconds: match_timeout_seconds,
       starts_at: starts_at,
-      meta: get_meta_from_params(params),
-      event_id: event_id,
+      meta: %{},
       show_results: show_results
     })
   end
 
-  defp get_meta_from_params(%{meta: %{} = meta}) do
-    meta
-  end
-
-  defp get_meta_from_params(%{meta_json: meta_json}) do
-    meta_json
-    |> Jason.decode!()
-    |> AtomizedMap.atomize()
-  end
-
-  defp get_meta_from_params(params) do
-    case params[:type] do
-      "show" ->
-        rounds_config =
-          params
-          |> Map.get(:rounds_config_json)
-          |> cast_json_value()
-
-        game_passwords =
-          params
-          |> Map.get(:game_passwords_json)
-          |> cast_json_value()
-
-        %{
-          game_passwords: game_passwords,
-          rounds_config: rounds_config
-        }
-
-      "versus" ->
-        %{rounds_limit: 1000}
-
-      type when type in ["arena", "swiss", "squad", "top200"] ->
-        rounds_limit = params |> Map.get(:rounds_limit, "3") |> String.to_integer()
-
-        %{rounds_limit: rounds_limit}
-
-      _ ->
-        %{}
-    end
-  end
-
   def get_tournament_for_restore do
     @states_from_restore
     |> get_db_tournaments()
@@ -341,12 +292,4 @@ defmodule Codebattle.Tournament.Context do
   defp generate_access_token do
     17 |> :crypto.strong_rand_bytes() |> Base.url_encode64() |> binary_part(0, 17)
   end
-
-  defp cast_json_value(value) do
-    case value do
-      nil -> nil
-      "" -> nil
-      value -> value |> Jason.decode!() |> AtomizedMap.atomize()
-    end
-  end
 end

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

@@ -957,7 +957,7 @@ defmodule Codebattle.Tournament.Base do
           use_waiting_room?(tournament) or tournament.type in ["top200"] ->
             min(seconds_to_end_round(tournament), tournament.match_timeout_seconds)
 
-          :default ->
+          true ->
             get_round_timeout_seconds(tournament)
         end
       end

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

@@ -11,27 +11,36 @@ defmodule Codebattle.Tournament.TaskProvider do
     level |> Codebattle.Task.get_tasks_by_level() |> Enum.shuffle()
   end
 
-  def get_all_tasks(%{task_provider: "task_pack", task_pack_name: tp_name}) when not is_nil(tp_name) do
+  def get_all_tasks(%{task_provider: "task_pack", task_pack_name: tp_name})
+      when not is_nil(tp_name) do
     TaskPack.get_tasks_by_pack_name(tp_name)
   end
 
-  def get_all_tasks(%{task_provider: "task_pack_per_round", task_pack_name: tp_name}) when not is_nil(tp_name) do
+  def get_all_tasks(%{task_provider: "task_pack_per_round", task_pack_name: tp_name})
+      when not is_nil(tp_name) do
     tp_name
     |> get_task_pack_names()
     |> Enum.map(&TaskPack.get_tasks_by_pack_name/1)
     |> Enum.with_index(&{&2, &1})
     |> Map.new()
   end
 
-  def get_round_task_ids(%{task_provider: "task_pack", task_strategy: "sequential", task_pack_name: tp_name}, _round)
+  def get_round_task_ids(
+        %{task_provider: "task_pack", task_strategy: "sequential", task_pack_name: tp_name},
+        _round
+      )
       when not is_nil(tp_name) do
     [name: tp_name]
     |> TaskPack.get_by!()
     |> Map.get(:task_ids)
   end
 
   def get_round_task_ids(
-        %{task_provider: "task_pack_per_round", task_strategy: "sequential", task_pack_name: tp_name},
+        %{
+          task_provider: "task_pack_per_round",
+          task_strategy: "sequential",
+          task_pack_name: tp_name
+        },
         round
       )
       when not is_nil(tp_name) do
@@ -64,8 +73,6 @@ defmodule Codebattle.Tournament.TaskProvider do
     Tasks.get_random_task_id_by_level(tournament, level)
   end
 
-  def get_common_round_task_id(%{task_strategy: "random_per_game"}, _params), do: nil
-
   def get_common_round_task_id(%{task_strategy: "random_per_round"} = tournament, _params) do
     safe_random(tournament.round_task_ids)
   end
@@ -92,7 +99,10 @@ defmodule Codebattle.Tournament.TaskProvider do
     end
   end
 
-  def get_task(%{task_provider: "task_pack_per_round", task_strategy: "sequential"} = tournament, nil) do
+  def get_task(
+        %{task_provider: "task_pack_per_round", task_strategy: "sequential"} = tournament,
+        nil
+      ) do
     tournament.round_task_ids
     |> Enum.at(0)
     |> case do

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

@@ -6,7 +6,7 @@ defmodule Codebattle.Tournament do
   import Ecto.Changeset
 
   alias Codebattle.Event
-  alias Codebattle.Tournament.Individual
+  alias Codebattle.Tournament.Swiss
   alias Runner.AtomizedMap
 
   @type t :: %__MODULE__{}
@@ -56,10 +56,10 @@ defmodule Codebattle.Tournament do
   @levels ~w(elementary easy medium hard)
   @states ~w(waiting_participants canceled active timeout finished)
   @task_providers ~w(level task_pack task_pack_per_round all)
-  @task_strategies ~w(random_per_game random_per_round sequential)
+  @task_strategies ~w(random_per_round sequential)
   @ranking_types ~w(void by_clan by_percentile by_win_loss)
-  @types ~w(individual show swiss arena versus squad top200)
-  @public_types ~w(individual top200 swiss arena versus)
+  @types ~w(swiss)
+  @public_types ~w(swiss)
 
   @default_match_timeout Application.compile_env(:codebattle, :tournament_match_timeout)
 
@@ -87,16 +87,17 @@ defmodule Codebattle.Tournament do
     field(:players_limit, :integer)
     field(:ranking_type, :string, default: "by_player")
     field(:round_timeout_seconds, :integer)
+    field(:rounds_limit, :integer)
     field(:show_results, :boolean, default: true)
     field(:started_at, :utc_datetime)
     field(:starts_at, :utc_datetime)
     field(:state, :string, default: "waiting_participants")
     field(:stats, AtomizedMap, default: %{})
     field(:task_pack_name, :string)
     field(:task_provider, :string, default: "level")
-    field(:task_strategy, :string, default: "random_per_game")
+    field(:task_strategy, :string, default: "random_per_round")
     field(:tournament_timeout_seconds, :integer)
-    field(:type, :string, default: "individual")
+    field(:type, :string, default: "swiss")
     field(:use_chat, :boolean, default: true)
     field(:use_clan, :boolean, default: false)
     field(:use_event_ranking, :boolean, default: false)
@@ -112,7 +113,7 @@ defmodule Codebattle.Tournament do
     field(:tasks_table, :string, virtual: true)
 
     field(:is_live, :boolean, virtual: true, default: false)
-    field(:module, :any, virtual: true, default: Individual)
+    field(:module, :any, virtual: true, default: Swiss)
     field(:played_pair_ids, EctoMapSet, of: {:array, :integer}, virtual: true, default: [])
     field(:players_count, :integer, virtual: true, default: 0)
     field(:event_ranking, :map, virtual: true, default: %{})