Added an option to display task scores in the contest sidebar

Add an option to display task scores in the contest sidebar and for both the overview and the sidebard task scores, when a tokened score is availble it will use that score, if not it will use the public score, if there is no public score it will show 0/0 (considering to change to N/A)

Author: pxsit

cms/db/contest.py

@@ -111,6 +111,9 @@ class Contest(Base):
     # 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

@@ -98,6 +98,7 @@ def post(self, contest_id: str):
             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

@@ -99,6 +99,15 @@ <h1>Contest configuration</h1>
         <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 colspan=2><h2>Logging in</h2></td></tr>
     <tr>

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.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,93 @@ 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(Participation.submissions).joinedload(Submission.token),
+                selectinload(Participation.submissions).joinedload(Submission.results),
+            )
+            .first()
+        )
+
+    def _compute_task_scores(
+        self,
+        participation: Participation,
+        *,
+        actual_phase: int,
+        hide_zero_max_public: bool = True,
+    ) -> 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:
+            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:
+                if actual_phase == 3:
+                    # In analysis mode users can see full scores, so do not
+                    # restrict to tokened submissions.
+                    score_value, _ = task_score(participation, task, rounded=True)
+                else:
+                    score_value, _ = task_score(
+                        participation, task, only_tokened=True, rounded=True
+                    )
+                max_score_value = round(score_type.max_score, task.score_precision)
+                score_message = score_type.format_score(
+                    score_value,
+                    score_type.max_score,
+                    None,
+                    task.score_precision,
+                    translation=self.translation,
+                )
+            else:
+                max_public_score = round(
+                    score_type.max_public_score, task.score_precision
+                )
+
+                # Optionally hide entries with no public score.
+                if hide_zero_max_public and max_public_score <= 0:
+                    continue
+
+                score_value, _ = task_score(
+                    participation, task, public=True, rounded=True
+                )
+                max_score_value = max_public_score
+                score_message = score_type.format_score(
+                    score_value,
+                    score_type.max_public_score,
+                    None,
+                    task.score_precision,
+                    translation=self.translation,
+                )
+
+            task_scores[task.id] = (score_value, max_score_value, score_message)
+
+        return task_scores
+
     def render_params(self):
         ret = super().render_params()
 
@@ -230,6 +319,23 @@ def render_params(self):
             # set the timezone used to format timestamps
             ret["timezone"] = get_timezone(participation.user, self.contest)
 
+            if self.contest.show_task_scores_in_sidebar and (
+                ret["actual_phase"] >= 0 or participation.unrestricted
+            ):
+                loaded_participation = self._load_participation_for_scores(participation)
+                if loaded_participation is not None:
+                    # Keep references synchronized with the fully loaded objects.
+                    participation = loaded_participation
+                    self.contest = participation.contest
+                    ret["contest"] = self.contest
+                    ret["participation"] = participation
+                    ret["user"] = participation.user
+                    ret["sidebar_task_scores"] = self._compute_task_scores(
+                        participation,
+                        actual_phase=ret["actual_phase"],
+                        hide_zero_max_public=True,
+                    )
+
         # some information about token configuration
         ret["tokens_contest"] = self.contest.token_mode
 

cms/server/contest/handlers/main.py

@@ -48,13 +48,11 @@
 
 import tornado.web
 from sqlalchemy.orm.exc import NoResultFound
-from sqlalchemy.orm import joinedload
 
 from cms import config
-from cms.db import User, Participation, Team, Submission, Task
+from cms.db import User, Participation, Team
 from cms.grading.languagemanager import get_language
 from cms.grading.steps import COMPILATION_MESSAGES, EVALUATION_MESSAGES
-from cms.grading.scoring import task_score
 from cms.server import multi_contest
 from cms.server.contest.authentication import validate_login
 from cms.server.contest.communication import get_communications
@@ -84,51 +82,31 @@ def render_params(self):
         ret = super().render_params()
 
         if self.current_user is not None:
-            # This massive joined load gets all the information which we will need
-            participation = (
-                self.sql_session.query(Participation)
-                .filter(Participation.id == self.current_user.id)
-                .options(
-                    joinedload(Participation.user),
-                    joinedload(Participation.contest)
-                    .joinedload(Contest.tasks)
-                    .joinedload(Task.active_dataset),
-                    joinedload(Participation.submissions).joinedload(Submission.token),
-                    joinedload(Participation.submissions).joinedload(
-                        Submission.results
-                    ),
-                )
-                .first()
-            )
-
-            self.contest = participation.contest
-            # Ensure the template sees this fully-loaded version
-            ret["contest"] = self.contest
-            ret["participation"] = participation
+            participation = ret["participation"]
 
-            # Compute public scores for all tasks only if they will be shown
+            # ContestHandler may have already loaded a fully-joined participation
+            # while computing sidebar scores. Reuse it to avoid a duplicate query.
+            already_preloaded_for_scores = "sidebar_task_scores" in ret
             if self.contest.show_task_scores_in_overview:
-                task_scores = {}
-                for task in self.contest.tasks:
-                    score_type = task.active_dataset.score_type_object
-                    max_public_score = round(
-                        score_type.max_public_score, task.score_precision
+                if not already_preloaded_for_scores:
+                    loaded_participation = self._load_participation_for_scores(
+                        participation
                     )
-                    public_score, _ = task_score(
-                        participation, task, public=True, rounded=True
-                    )
-                    task_scores[task.id] = (
-                        public_score,
-                        max_public_score,
-                        score_type.format_score(
-                            public_score,
-                            score_type.max_public_score,
-                            None,
-                            task.score_precision,
-                            translation=self.translation,
-                        ),
-                    )
-                ret["task_scores"] = task_scores
+                    if loaded_participation is None:
+                        return ret
+                    participation = loaded_participation
+
+                    self.contest = participation.contest
+                    # Ensure the template sees this fully-loaded version.
+                    ret["contest"] = self.contest
+                    ret["participation"] = participation
+                    ret["user"] = participation.user
+
+                ret["task_scores"] = self._compute_task_scores(
+                    participation,
+                    actual_phase=ret["actual_phase"],
+                    hide_zero_max_public=False,
+                )
 
         return ret
 

cms/server/contest/handlers/tasksubmission.py

@@ -207,8 +207,9 @@ 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.
 
@@ -222,8 +223,14 @@ def add_task_score(self, participation: Participation, task: Task, data: dict):
             .all()
         data["task_public_score"], public_score_is_partial = \
             task_score(participation, task, public=True, rounded=True)
-        data["task_tokened_score"], tokened_score_is_partial = \
-            task_score(participation, task, only_tokened=True, rounded=True)
+        if self.r_params["actual_phase"] == 3:
+            data["task_tokened_score"], tokened_score_is_partial = task_score(
+                participation, task, rounded=True
+            )
+        else:
+            data["task_tokened_score"], tokened_score_is_partial = task_score(
+                participation, task, only_tokened=True, rounded=True
+            )
         # 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 {

cms/server/contest/templates/contest.html

@@ -179,8 +179,17 @@ <h3 id="countdown_box">
                             </li>
     {% if actual_phase >= 0 or participation.unrestricted %}
         {% 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], t_iter.score_precision) }}">
+                                    {{ sidebar_task_scores[t_iter.id][2] }}
+                                </span>
+                {% else %}
+                                <span class="task_score_badge task_score score_0">0 / 0</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/task_submissions.html

@@ -35,6 +35,10 @@
 {% endfor %}
 };
 
+// If any existing submission has a played token, sidebar should show tokened
+// total score for this task.
+var sidebar_use_tokened_score = {% if submissions|selectattr("token")|list|length > 0 %}true{% else %}false{% endif %};
+
 $(document).on("click", ".submission_list tbody tr td.status .details", function (event) {
     var submission_id = $(this).parent().parent().attr("data-submission");
     var modal = $("#submission_detail");
@@ -117,6 +121,23 @@
     task_score_elem.addClass(get_score_class(task_score, max_score));
 };
 
+update_sidebar_task_score = function(task_score, task_score_message, max_score) {
+    var task_header = $('.nav-list li.nav-header[data-task-name="{{ task.name }}"]');
+    if (task_header.length === 0) {
+        return;
+    }
+
+    var badge = task_header.find('.task_score_badge');
+    if (badge.length === 0) {
+        return;
+    }
+
+    badge.removeClass('undefined score_0 score_0_100 score_100');
+    badge.addClass(get_score_class(task_score, max_score));
+    badge.text(task_score_message);
+    badge.show();
+};
+
 update_scores = function (submission_id, data) {
     var row = $(".submission_list tbody tr[data-submission=\"" + submission_id + "\"]");
     row.attr("data-status", data["status"]);
@@ -135,6 +156,29 @@
             data["public_score"], data["public_score_message"],
             data["task_public_score"], data["task_public_score_message"],
             data["task_score_is_partial"], data["max_public_score"]);
+
+        // If we can see full score for at least one submission (token played or
+        // analysis), switch sidebar to tokened total score.
+        if (data["score"] !== undefined) {
+            sidebar_use_tokened_score = true;
+        }
+
+        if (sidebar_use_tokened_score
+                && data["task_tokened_score"] !== undefined
+                && data["task_tokened_score_message"] !== undefined
+                && data["max_score"] !== undefined) {
+            update_sidebar_task_score(
+                data["task_tokened_score"],
+                data["task_tokened_score_message"],
+                data["max_score"]);
+        } else if (data["task_public_score"] !== undefined
+                && data["task_public_score_message"] !== undefined
+                && data["max_public_score"] !== undefined) {
+            update_sidebar_task_score(
+                data["task_public_score"],
+                data["task_public_score_message"],
+                data["max_public_score"]);
+        }
 {% if can_use_tokens %}
         update_score(
             row.children("td.total_score"), $("#task_score_tokened"),

cmscontrib/updaters/update_from_1.5.sql

@@ -44,7 +44,9 @@ ALTER TABLE user_test_results DROP COLUMN evaluation_sandbox;
 
 -- https://github.com/cms-dev/cms/pull/1476
 ALTER TABLE contests ADD COLUMN show_task_scores_in_overview boolean NOT NULL DEFAULT true;
+ALTER TABLE contests ADD COLUMN show_task_scores_in_sidebar boolean NOT NULL DEFAULT true;
 ALTER TABLE contests ALTER COLUMN show_task_scores_in_overview DROP DEFAULT;
+ALTER TABLE contests ALTER COLUMN show_task_scores_in_sidebar DROP DEFAULT;
 
 -- https://github.com/cms-dev/cms/pull/1486
 ALTER TABLE public.tasks ADD COLUMN allowed_languages varchar[];