Add a Score counter to task overview and sidebar

cms/db/contest.py

@@ -107,6 +107,12 @@ class Contest(Base):
         nullable=False,
         default=False)
 
+    # Whether to show task scores in the overview page
+    show_task_scores_in_overview: bool = Column(Boolean, nullable=False, default=True)
+
+    # Whether to show task scores in the sidebar task list.
+    show_task_scores_in_sidebar: bool = Column(Boolean, nullable=False, default=True)
+
     # Whether to prevent hidden participations to log in.
     block_hidden_participations: bool = Column(
         Boolean,

cms/server/admin/handlers/contest.py

@@ -13,6 +13,7 @@
 # Copyright © 2026 Tobias Lenz <t_lenz94@web.de>
 # Copyright © 2026 Chuyang Wang <mail@chuyang-wang.de>
 # Copyright © 2026 Jonathan Baumann <Jonathan.Baumann@edu.ruhr-uni-bochum.de>
+# Copyright © 2026 Pasit Sangprachathanarak <ouipingpasit@gmail.com>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as
@@ -106,6 +107,8 @@ def post(self, contest_id: str):
             self.get_bool(attrs, "allow_questions")
             self.get_bool(attrs, "allow_user_tests")
             self.get_bool(attrs, "allow_unofficial_submission_before_analysis_mode")
+            self.get_bool(attrs, "show_task_scores_in_overview")
+            self.get_bool(attrs, "show_task_scores_in_sidebar")
             self.get_bool(attrs, "block_hidden_participations")
             self.get_bool(attrs, "allow_password_authentication")
             self.get_bool(attrs, "allow_registration")

cms/server/admin/templates/contest.html

@@ -90,6 +90,24 @@ <h1>Contest configuration</h1>
         <input type="checkbox" id="allow_unofficial_submission_before_analysis_mode" name="allow_unofficial_submission_before_analysis_mode" {{ "checked" if contest.allow_unofficial_submission_before_analysis_mode else "" }}/>
       </td>
     </tr>
+    <tr>
+      <td>
+        <span class="info" title="Whether to show task scores in the overview page for contestants."></span>
+        <label for="show_task_scores_in_overview">Show task scores in overview page</label>
+      </td>
+      <td>
+        <input type="checkbox" id="show_task_scores_in_overview" name="show_task_scores_in_overview" {{ "checked" if contest.show_task_scores_in_overview else "" }}/>
+      </td>
+    </tr>
+    <tr>
+      <td>
+        <span class="info" title="Whether to show task scores next to task names in the sidebar for contestants."></span>
+        <label for="show_task_scores_in_sidebar">Show task scores in sidebar</label>
+      </td>
+      <td>
+        <input type="checkbox" id="show_task_scores_in_sidebar" name="show_task_scores_in_sidebar" {{ "checked" if contest.show_task_scores_in_sidebar else "" }}/>
+      </td>
+    </tr>
     <tr>
       <td>
         <span class="info" title="Timezone of the server, used to display start, end times and the current server time to contestants.

cms/server/contest/handlers/contest.py

@@ -48,9 +48,11 @@
     collections.MutableMapping = collections.abc.MutableMapping
 
 import tornado.web
+from sqlalchemy.orm import joinedload, selectinload
 
 from cms import config, TOKEN_MODE_MIXED
-from cms.db import Contest, Submission, Task, UserTest
+from cms.db import Contest, Dataset, Submission, Task, UserTest
+from cms.grading.scoring import task_score
 from cms.locale import filter_language_codes
 from cms.server import FileHandlerMixin
 from cms.server.contest.authentication import authenticate_request
@@ -193,6 +195,78 @@ def get_current_user(self) -> Participation | None:
         self.impersonated_by_admin = impersonated
         return participation
 
+    def _load_participation_for_scores(
+        self, participation: Participation
+    ) -> Participation | None:
+        """Load participation with relationships needed for task score computation."""
+        return (
+            self.sql_session.query(Participation)
+            .filter(Participation.id == participation.id)
+            .options(
+                joinedload(Participation.user),
+                joinedload(Participation.contest)
+                .joinedload(Contest.tasks)
+                .joinedload(Task.active_dataset)
+                .selectinload(Dataset.testcases),
+                selectinload(Participation.submissions).joinedload(Submission.token),
+                selectinload(Participation.submissions).joinedload(Submission.results),
+            )
+            .first()
+        )
+
+    def _compute_task_scores(
+        self,
+        participation: Participation,
+        *,
+        actual_phase: int,
+    ) -> dict[int, tuple[float, float, str]]:
+        """Compute per-task scores for UI task lists.
+
+        By default, this shows public scores. If a token has been played on a
+        task (or we're in analysis mode), it shows the tokened/total score for
+        that task instead.
+        """
+        task_scores: dict[int, tuple[float, float, str]] = {}
+        tokened_task_ids = {
+            s.task_id for s in participation.submissions if s.official and s.tokened()
+        }
+
+        for task in participation.contest.tasks:
+            if task.active_dataset is None:
+                continue
+            score_type = task.active_dataset.score_type_object
+
+            has_tokened_submission = task.id in tokened_task_ids
+            show_tokened_total = (
+                score_type.max_public_score < score_type.max_score
+                and (has_tokened_submission or actual_phase == 3)
+            )
+
+            if show_tokened_total:
+                score_value, _ = task_score(
+                    participation, task, only_tokened=actual_phase != 3)
+                max_score_value = score_type.max_score
+            else:
+                max_score_value = score_type.max_public_score
+                if max_score_value <= 0:
+                    continue
+                score_value, _ = task_score(participation, task, public=True)
+
+            score_message = score_type.format_score(
+                score_value, max_score_value, None, translation=self.translation)
+            task_scores[task.id] = (score_value, max_score_value, score_message)
+
+        return task_scores
+
+    @functools.cached_property
+    def task_scores(self) -> dict[int, tuple[float, float, str]]:
+        """Load scores only when a template displays them, once per request."""
+        participation = self._load_participation_for_scores(self.current_user)
+        if participation is None:
+            return {}
+        return self._compute_task_scores(
+            participation, actual_phase=self.r_params["actual_phase"])
+
     def render_params(self):
         ret = super().render_params()
 

cms/server/contest/handlers/main.py

@@ -10,6 +10,8 @@
 # Copyright © 2014 Fabian Gundlach <320pointsguy@gmail.com>
 # Copyright © 2015-2018 William Di Luigi <williamdiluigi@gmail.com>
 # Copyright © 2021 Grace Hawkins <amoomajid99@gmail.com>
+# Copyright © 2025 Pasit Sangprachathanarak <ouipingpasit@gmail.com>
+# Copyright © 2025 kk@cscmu-cnx
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as

cms/server/contest/handlers/tasksubmission.py

@@ -145,7 +145,7 @@ def get(self, task_name):
         public_score, is_public_score_partial = task_score(
             participation, task, public=True)
         tokened_score, is_tokened_score_partial = task_score(
-            participation, task, only_tokened=True)
+            participation, task, only_tokened=self.r_params["actual_phase"] != 3)
         # These two should be the same, anyway.
         is_score_partial = is_public_score_partial or is_tokened_score_partial
 
@@ -207,10 +207,12 @@ def add_task_score(self, participation: Participation, task: Task, data: dict):
         task: task for which we want the score.
         data: where to put the data; all fields will start with "task",
             followed by "public" if referring to the public scores, or
-            "tokened" if referring to the total score (always limited to
-            tokened submissions); for both public and tokened, the fields are:
+            "tokened" if referring to the total score (limited to tokened
+            submissions during contest, full score in analysis mode); for both
+            public and tokened, the fields are:
             "score" and "score_message"; in addition we have
             "task_is_score_partial" as partial info is the same for both.
+            "task_use_tokened_score" selects the full score for task badges.
 
         """
         # Just to preload all information required to compute the task score.
@@ -223,7 +225,11 @@ def add_task_score(self, participation: Participation, task: Task, data: dict):
         data["task_public_score"], public_score_is_partial = \
             task_score(participation, task, public=True)
         data["task_tokened_score"], tokened_score_is_partial = \
-            task_score(participation, task, only_tokened=True)
+            task_score(participation, task,
+                       only_tokened=self.r_params["actual_phase"] != 3)
+        data["task_use_tokened_score"] = self.r_params["actual_phase"] == 3 or any(
+            s.official and s.task_id == task.id and s.tokened()
+            for s in participation.submissions)
         # These two should be the same, anyway.
         data["task_score_is_partial"] = \
             public_score_is_partial or tokened_score_is_partial

cms/server/contest/static/cws_style.css

@@ -462,6 +462,21 @@ td.token_rules p:last-child {
     background-color: hsla(120, 100%, 50%, 0.4);
 }
 
+.nav-list .nav-header .task_score_badge {
+    float: right;
+    margin-right: 5px;
+    padding: 1px 6px;
+    border-radius: 4px;
+    font-size: 10px;
+    line-height: 14px;
+    font-weight: bold;
+    color: #333;
+    text-transform: none;
+}
+.nav-list .nav-header .task_score_badge.undefined {
+    color: #888;
+    background-color: transparent;
+}
 /*** Submit a solution */
 
 #submit_solution {
@@ -559,27 +574,33 @@ td.token_rules p:last-child {
     color: #AAA;
 }
 
-.submission_list td.public_score.score_0 {
+.submission_list td.public_score.score_0,
+.main_task_list td.public_score.score_0 {
     background-color: hsla(0, 100%, 50%, 0.4);
 }
 
-.submission_list tr:hover td.public_score.score_0 {
+.submission_list tr:hover td.public_score.score_0,
+.main_task_list tr:hover td.public_score.score_0 {
     background-color: hsla(0, 100%, 50%, 0.5);
 }
 
-.submission_list td.public_score.score_0_100 {
+.submission_list td.public_score.score_0_100,
+.main_task_list td.public_score.score_0_100 {
     background-color: hsla(60, 100%, 50%, 0.4);
 }
 
-.submission_list tr:hover td.public_score.score_0_100 {
+.submission_list tr:hover td.public_score.score_0_100,
+.main_task_list tr:hover td.public_score.score_0_100 {
     background-color: hsla(60, 100%, 50%, 0.5);
 }
 
-.submission_list td.public_score.score_100 {
+.submission_list td.public_score.score_100,
+.main_task_list td.public_score.score_100 {
     background-color: hsla(120, 100%, 50%, 0.4);
 }
 
-.submission_list tr:hover td.public_score.score_100 {
+.submission_list tr:hover td.public_score.score_100,
+.main_task_list tr:hover td.public_score.score_100 {
     background-color: hsla(120, 100%, 50%, 0.5);
 }
 

cms/server/contest/templates/contest.html

@@ -178,9 +178,21 @@ <h3 id="countdown_box">
                                 </a>
                             </li>
     {% if actual_phase >= 0 or participation.unrestricted %}
+        {% if contest.show_task_scores_in_sidebar %}
+            {% set sidebar_task_scores = handler.task_scores %}
+        {% endif %}
         {% for t_iter in contest.tasks %}
-                            <li class="nav-header">
-                                {{ t_iter.name }}
+                            <li class="nav-header" data-task-name="{{ t_iter.name }}">
+                                <span>{{ t_iter.name }}</span>
+            {% if contest.show_task_scores_in_sidebar %}
+                {% if sidebar_task_scores is defined and t_iter.id in sidebar_task_scores %}
+                                <span class="task_score_badge task_score {{ get_score_class(sidebar_task_scores[t_iter.id][0], sidebar_task_scores[t_iter.id][1]) }}">
+                                    {{ sidebar_task_scores[t_iter.id][2] }}
+                                </span>
+                {% else %}
+                                <span class="task_score_badge task_score undefined">{% trans %}N/A{% endtrans %}</span>
+                {% endif %}
+            {% endif %}
                             </li>
                             <li{% if page == "task_description" and task == t_iter %} class="active"{% endif %}>
                                 <a href="{{ contest_url("tasks", t_iter.name, "description") }}">{% trans %}Statement{% endtrans %}</a>

cms/server/contest/templates/overview.html

@@ -180,9 +180,12 @@ <h2>{% trans %}General information{% endtrans %}</h2>
 
 
 {% if actual_phase >= 0 or participation.unrestricted %}
+    {% if contest.show_task_scores_in_overview %}
+        {% set task_scores = handler.task_scores %}
+    {% endif %}
 <h2>{% trans %}Task overview{% endtrans %}</h2>
 
-<table class="table table-bordered table-striped">
+<table class="main_task_list table table-bordered table-striped">
     <!-- <colgroup>
         <col class="task"/>
         <col class="time_limit"/>
@@ -193,6 +196,9 @@ <h2>{% trans %}Task overview{% endtrans %}</h2>
     </colgroup> -->
     <thead>
         <tr>
+{% if contest.show_task_scores_in_overview and task_scores is defined%}
+            <th>{% trans %}Score{% endtrans %}</th>
+{% endif %}
             <th>{% trans %}Task{% endtrans %}</th>
             <th>{% trans %}Name{% endtrans %}</th>
             <th>{% trans %}Time limit{% endtrans %}</th>
@@ -209,23 +215,30 @@ <h2>{% trans %}Task overview{% endtrans %}</h2>
         {% set task_allowed_languages = t_iter.get_allowed_languages() %}
         {% set extensions = "[%s]"|format(task_allowed_languages|map("to_language")|map(attribute="source_extension")|unique|join("|")) %}
         <tr>
+{% if contest.show_task_scores_in_overview and task_scores is defined %}
+    {% if t_iter.id in task_scores %}
+            <td class="public_score {{ get_score_class(task_scores[t_iter.id][0], task_scores[t_iter.id][1]) }}">{{ task_scores[t_iter.id][2] }}</td>
+    {% else %}
+            <td class="public_score undefined">{% trans %}N/A{% endtrans %}</td>
+    {% endif %}
+{% endif %}
             <th>{{ t_iter.name }}</th>
             <td>{{ t_iter.title }}</td>
             <td>
-    {% if t_iter.active_dataset.time_limit is not none %}
+    {% if t_iter.active_dataset is not none and t_iter.active_dataset.time_limit is not none %}
         {{ t_iter.active_dataset.time_limit|format_duration(length="long") }}
     {% else %}
         {% trans %}N/A{% endtrans %}
     {% endif %}
             </td>
             <td>
-    {% if t_iter.active_dataset.memory_limit is not none %}
+    {% if t_iter.active_dataset is not none and t_iter.active_dataset.memory_limit is not none %}
         {{ t_iter.active_dataset.memory_limit|format_size }}
     {% else %}
         {% trans %}N/A{% endtrans %}
     {% endif %}
             </td>
-            <td>{{ get_task_type(dataset=t_iter.active_dataset).name }}</td>
+            <td>{% if t_iter.active_dataset is not none %}{{ get_task_type(dataset=t_iter.active_dataset).name }}{% else %}{% trans %}N/A{% endtrans %}{% endif %}</td>
             <td>{{ t_iter.submission_format|map("replace", ".%l", extensions)|join(" ") }}</td>
     {% if tokens_contest != TOKEN_MODE_DISABLED and tokens_tasks != TOKEN_MODE_DISABLED %}
             <td>