Display task scores in CWS

There's a little issue here when there are many submissions waiting
for score updates: since the request for each submission is
independent, and now we also return the task score with each, it might
be that the task score is more up to date than the list of submission.

I don't think it's a big deal.

Author: stefano-maggiolo

cms/server/contest/handlers/tasksubmission.py

@@ -47,6 +47,7 @@
 from cms import config, FEEDBACK_LEVEL_FULL
 from cms.db import Submission, SubmissionResult
 from cms.grading.languagemanager import get_language
+from cms.grading.scoring import task_score
 from cms.server import multi_contest
 from cms.server.contest.submission import get_submission_count, \
     UnacceptableSubmission, accept_submission
@@ -133,6 +134,13 @@ def get(self, task_name):
             .options(joinedload(Submission.results))\
             .all()
 
+        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)
+        # These two should be the same, anyway.
+        is_score_partial = is_public_score_partial or is_tokened_score_partial
+
         submissions_left_contest = None
         if self.contest.max_submission_number is not None:
             submissions_c = \
@@ -162,6 +170,9 @@ def get(self, task_name):
         download_allowed = self.contest.submissions_download_allowed
         self.render("task_submissions.html",
                     task=task, submissions=submissions,
+                    public_score=public_score,
+                    tokened_score=tokened_score,
+                    is_score_partial=is_score_partial,
                     tokens_task=task.token_mode,
                     tokens_info=tokens_info,
                     submissions_left=submissions_left,
@@ -173,6 +184,42 @@ class SubmissionStatusHandler(ContestHandler):
 
     refresh_cookie = False
 
+    def add_task_score(self, participation, task, data):
+        """Add the task score information to the dict to be returned.
+
+        participation (Participation): user for which we want the score.
+        task (Task): task for which we want the score.
+        data (dict): 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:
+            "score" and "score_message"; in addition we have
+            "task_is_score_partial" as partial info is the same for both.
+
+        """
+        # Just to preload all information required to compute the task score.
+        self.sql_session.query(Submission)\
+            .filter(Submission.participation == participation)\
+            .filter(Submission.task == task)\
+            .options(joinedload(Submission.token))\
+            .options(joinedload(Submission.results))\
+            .all()
+        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)
+        # These two should be the same, anyway.
+        data["task_score_is_partial"] = \
+            public_score_is_partial or tokened_score_is_partial
+
+        score_type = task.active_dataset.score_type_object
+        data["task_public_score_message"] = score_type.format_score(
+            data["task_public_score"], score_type.max_public_score, None,
+            task.score_precision, translation=self.translation)
+        data["task_tokened_score_message"] = score_type.format_score(
+            data["task_tokened_score"], score_type.max_score, None,
+            task.score_precision, translation=self.translation)
+
     @tornado.web.authenticated
     @actual_phase_required(0, 3)
     @multi_contest
@@ -186,7 +233,8 @@ def get(self, task_name, submission_num):
             raise tornado.web.HTTPError(404)
 
         sr = submission.get_result(task.active_dataset)
-        data = dict()
+
+        data = {}
 
         if sr is None:
             # implicit compiling state while result is not created
@@ -204,6 +252,7 @@ def get(self, task_name, submission_num):
             data["status_text"] = self._("Scoring...")
         elif data["status"] == SubmissionResult.SCORED:
             data["status_text"] = self._("Evaluated")
+            self.add_task_score(submission.participation, task, data)
 
             score_type = task.active_dataset.score_type_object
             if score_type.max_public_score > 0:

cms/server/contest/static/cws_style.css

@@ -411,6 +411,37 @@ td.token_rules p:last-child {
     clear: both;
 }
 
+/*** Task score */
+
+.task_score_container {
+    display: flex;
+    justify-content: space-evenly;
+    font-weight: bold;
+}
+
+.task_score {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    margin-bottom: 0;
+}
+
+.task_score .score img {
+    margin-left: 5px;
+}
+
+.task_score.score_0 {
+    background-color: hsla(0, 100%, 50%, 0.4);
+}
+
+.task_score.score_0_100 {
+    background-color: hsla(60, 100%, 50%, 0.4);
+}
+
+.task_score.score_100 {
+    background-color: hsla(120, 100%, 50%, 0.4);
+}
+
 /*** Submit a solution */
 
 #submit_solution {

cms/server/contest/templates/submission_row.html

@@ -96,7 +96,7 @@
         {% endif %}
     </td>
 {% endif %}
-{% if tokens_contest != TOKEN_MODE_DISABLED and tokens_task != TOKEN_MODE_DISABLED and actual_phase == 0 %}
+{% if can_use_tokens and actual_phase == 0 %}
     <td class="token">
         {% if s.token is not none %}
         <a class="btn disabled">{% trans %}Played{% endtrans %}</a>

cms/server/contest/templates/task_submissions.html

@@ -2,6 +2,10 @@
 
 {% set page = "task_submissions" %}
 
+{% set score_type = get_score_type(dataset=task.active_dataset) %}
+{% set can_use_tokens = tokens_contest != TOKEN_MODE_DISABLED
+       and tokens_task != TOKEN_MODE_DISABLED %}
+
 {% block additional_js %}
 
 $(document).on("click", "#submission_list tbody tr td.status .details", function (event) {
@@ -39,7 +43,45 @@
     }
 };
 
-update_submission_row = function (submission_id, data) {
+/**
+ * Update the score (public or tokened) in the UI (both in the task score and in
+ * the submission row) given the results of a newly scored submisson
+ *
+ * score_elem: table cell with the submission score to update.
+ * task_score_elem: container element of the task score to update.
+ * score (Number): the score of the submission.
+ * score_message (String): the score of the submission as a string.
+ * task_score (Number): the current score of the task.
+ * task_score_message (String): the current score of the task as a string.
+ * task_score_is_partial (Boolean): if some submission has yet to be scored.
+ * max_score (Number): maximum score of the task.
+ */
+update_score = function(score_elem, task_score_elem,
+        score, score_message,
+        task_score, task_score_message, task_score_is_partial,
+        max_score) {
+    // Submission row.
+    if (score !== undefined) {
+        score_elem.addClass(get_score_class(score, max_score));
+        score_elem.removeClass("undefined");
+        score_elem.text(score_message);
+    }
+
+    // Task score.
+    var task_score_span = task_score_elem.find(".score");
+    task_score_span.text(task_score_message);
+    if (task_score_is_partial) {
+        task_score_span.append(
+            $("<img class=\"details\" src=\"{{ url("static", "loading.gif") }}\"/>"));
+    }
+    task_score_elem.removeClass("undefined");
+    task_score_elem.removeClass("score_0");
+    task_score_elem.removeClass("score_0_100");
+    task_score_elem.removeClass("score_100");
+    task_score_elem.addClass(get_score_class(task_score, max_score));
+};
+
+update_scores = function (submission_id, data) {
     var row = $("#submission_list tbody tr[data-submission=\"" + submission_id + "\"]");
     row.attr("data-status", data["status"]);
     row.children("td.status").text(data["status_text"]);
@@ -52,47 +94,48 @@
             $("<a class=\"details\">{% trans %}details{% endtrans %}</a>"));
     }
     if (data["status"] == {{ SubmissionResult.SCORED }}) {
-        if (data["public_score"] != undefined) {
-            row.children("td.public_score").addClass(get_score_class(data["public_score"], data["max_public_score"]));
-            row.children("td.public_score").removeClass("undefined");
-            row.children("td.public_score").html(data["public_score_message"]);
-        }
-        if (data["score"] != undefined) {
-            // This element may not exist, if max_public_score == max_score.
-            row.children("td.total_score").addClass(get_score_class(data["score"], data["max_score"]));
-            row.children("td.total_score").removeClass("undefined");
-            row.children("td.total_score").html(data["score_message"]);
-        }
+        update_score(
+            row.children("td.public_score"), $("#task_score_public"),
+            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 can_use_tokens %}
+        update_score(
+            row.children("td.total_score"), $("#task_score_tokened"),
+            data["score"], data["score_message"],
+            data["task_tokened_score"], data["task_tokened_score_message"],
+            data["task_score_is_partial"], data["max_score"]);
+{% endif %}
     } else if (data["status"] != {{ SubmissionResult.COMPILATION_FAILED }}) {
-        schedule_update_submission_row(submission_id);
+        schedule_update_scores(submission_id);
     }
 };
 
-schedule_update_submission_row = function (submission_id) {
-    if (typeof(schedule_update_submission_row.delays) === "undefined") {
-        schedule_update_submission_row.delays = {};
+schedule_update_scores = function (submission_id) {
+    if (typeof(schedule_update_scores.delays) === "undefined") {
+        schedule_update_scores.delays = {};
     }
-    if (!schedule_update_submission_row.delays[submission_id]) {
-        schedule_update_submission_row.delays[submission_id] = 1000.0;
+    if (!schedule_update_scores.delays[submission_id]) {
+        schedule_update_scores.delays[submission_id] = 1000.0;
     } else {
         // We want exponential backoff, but slightly staggered across submissions to
         // avoid asking about all of them at the same time, so we use 1.4 plus a
         // value depending on the submission id.
         var hash = (37 * parseInt(submission_id)) % 100 / 100.0;
-        schedule_update_submission_row.delays[submission_id] =
-            schedule_update_submission_row.delays[submission_id]
+        schedule_update_scores.delays[submission_id] =
+            schedule_update_scores.delays[submission_id]
                 * (1.4 + hash * 0.2);
     }
     setTimeout(function () {
         $.get(utils.contest_url("tasks", "{{ task.name }}", "submissions", submission_id), function (data) {
-            update_submission_row(submission_id, data);
+            update_scores(submission_id, data);
         });
-    }, schedule_update_submission_row.delays[submission_id]);
+    }, schedule_update_scores.delays[submission_id]);
 };
 
 $(document).ready(function () {
     $('#submission_list tbody tr[data-status][data-status!="{{ SubmissionResult.COMPILATION_FAILED }}"][data-status!="{{ SubmissionResult.SCORED }}"]').each(function (idx, elem) {
-        schedule_update_submission_row($(this).attr("data-submission"));
+        schedule_update_scores($(this).attr("data-submission"));
     });
 });
 
@@ -106,6 +149,59 @@
     <h1>{% trans name=task.title, short_name=task.name %}{{ name }} ({{ short_name }}) <small>submissions</small>{% endtrans %}</h1>
 </div>
 
+{% if score_type is defined %}
+    {% set two_task_scores = score_type.max_public_score > 0
+        and score_type.max_public_score < score_type.max_score %}
+<div class="task_score_container row-fluid">
+
+    {% if score_type.max_public_score > 0 %}
+        {# Show the public score (alone, if everything is public or tokens are disabled, or together with the tokened score). #}
+    <div id="task_score_public"
+         class="{{ "span6" if two_task_scores else "span12" }} well well-small task_score {{ get_score_class(public_score, score_type.max_public_score) }}">
+        <span>
+        {% if score_type.max_public_score == score_type.max_score %}
+            {% trans %}Score:{% endtrans %}
+        {% else %}
+            {% trans %}Public score:{% endtrans %}
+        {% endif %}
+        </span>
+      <br/>
+        <span class="score">
+            {{ score_type.format_score(public_score, score_type.max_public_score, none, task.score_precision, translation=translation) }}
+        {% if is_score_partial %}
+            <img src="{{ url("static", "loading.gif") }}" />
+        {% endif %}
+        </span>
+    </div>
+    {% endif %}
+
+    {% if score_type.max_public_score < score_type.max_score %}
+        {# Show the tokened score (alone if everything is non-public, or together with the public score). #}
+    <div id="task_score_tokened"
+         class="{{ "span6" if two_task_scores else "span12" }}  well well-small task_score {{ get_score_class(tokened_score, score_type.max_score) if can_use_tokens else "undefined" }}">
+        <span>
+        {% if can_use_tokens %}
+            {% trans %}Score of tokened submissions:{% endtrans %}
+        {% else %}
+            {% trans %}Total score:{% endtrans %}
+        {% endif %}
+        </span>
+      <br/>
+        <span class="score">
+        {% if can_use_tokens %}
+            {{ score_type.format_score(tokened_score, score_type.max_score, none, task.score_precision, translation=translation) }}
+            {% if is_score_partial %}
+            <img src="{{ url("static", "loading.gif") }}" />
+            {% endif %}
+        {% else %}
+            {% trans %}N/A{% endtrans %}
+        {% endif %}
+        </span>
+    </div>
+    {% endif %}
+
+</div>
+{% endif %}
 
 <h2 style="margin-bottom: 10px">{% trans %}Submit a solution{% endtrans %}</h2>
 
@@ -229,8 +325,6 @@ <h2 style="margin: 40px 0 10px">{% trans %}Previous submissions{% endtrans %}</h
 {% endif %}
 
 
-{% set score_type = get_score_type(dataset=task.active_dataset) %}
-
 {% set show_date = not submissions|map(attribute="timestamp")|all("today") %}