Leaderboard (#1238)

* added 'enable_leaderboard' columns in courses table

* Leaderboard create course config, leaderboard page routing, leaderboard sql query for all users in course

* added 'top_leaderboard_display' columns in courses table

* added 'all_user_total_xp' function for leaderboard display

* add top leaderboard display options to course settings (select how many to display in leaderboard)

* added contest scores fetching and contest score calculation

* Refactor query execution in assessments module for improved readability

* added functions to fetch contest scoring and voting

* changes to default values

* updated tests

* Fixed xp fetching for all users

* Add top contest leaderboard display configuration and update related tests.
Updated leaderboard fetching and exporting for assessment workspace leaderboard.
Added Leaderboard Dropdown contests fetching.

* Added automatic XP assignment for winning contest entries

* Implement XP assignment for winning contest entries based on contest voting XML and added dispatch endpoint for XP customisation

* Add default value for XP values and improve XP assignment logic for contest entries

* No tiebreak for contest scoring

* Refactor contest scoring endpoints for authentication errors

* Enhance leaderboard update logic and improve error handling for voting questions

* Refactor XP assignment logic for voting questions and set default XP values.
Refactor Score calculation logic to reset to 0 before calculating.

* Temporary Assessment Workspace leaderboard fix for testing

* Fixed tests for assessments (default XP to award for contests)

* Refactor contest fetching logic to filter by voting question contest numbers

* Refactor leaderboard query logic to use RANK() and improve code readability.
Uncommented leaderboard portions after finalising testing

* temporary fix for STePS

* Add ranking to assessment workspace leaderboard queries and update view helpers to include rank

* Post-STePS fixes

* Shifted schema updates to a new migration file

* Added support to retrieve only relevant rows for leaderboard pages

* Updated all_user_total_xp to include row count

* Combined aliases and removed unused ones

* Refactor leaderboard endpoints and update response structure for contest scores

* Refactor contest score retrieval to handle multiple questions and improve error responses

* Remove contest score retrieval endpoints from AdminAssessmentsController and router

* Removed unnecessary execute command in migration file

* Updated leaderboard display routes to use query parameters; Offset calculation shifted to frontend

* Added default values if query parameters for leaderboard display are missing

* Refactor leaderboard logic to reset scores conditionally and enhance test coverage for leaderboard endpoints

* Fix XP assignment logic for contest winners and added test coverage for automatic XP assignment for contest winners

* Add tests for all_user_total_xp pagination

* Change default offset to 0

* Format code

* Existing courses should have leaderboard disabled (and enabled only for new courses)

---------

Co-authored-by: Blerargh <[email protected]>
Co-authored-by: GabrielCWT <[email protected]>
Co-authored-by: Richard Dominick <[email protected]>
Co-authored-by: sayomaki <[email protected]>

Author: 5 people

lib/cadet/assessments/assessments.ex

@@ -12,10 +12,11 @@ defmodule Cadet.Assessments.QuestionTypes.VotingQuestion do
     field(:contest_number, :string)
     field(:reveal_hours, :integer)
     field(:token_divider, :integer)
+    field(:xp_values, {:array, :integer}, default: [500, 400, 300])
   end
 
   @required_fields ~w(content contest_number reveal_hours token_divider)a
-  @optional_fields ~w(prepend template)a
+  @optional_fields ~w(prepend template xp_values)a
 
   def changeset(question, params \\ %{}) do
     question

lib/cadet/assessments/question_types/voting_question.ex

@@ -12,6 +12,10 @@ defmodule Cadet.Courses.Course do
           viewable: boolean(),
           enable_game: boolean(),
           enable_achievements: boolean(),
+          enable_overall_leaderboard: boolean(),
+          enable_contest_leaderboard: boolean(),
+          top_leaderboard_display: integer(),
+          top_contest_leaderboard_display: integer(),
           enable_sourcecast: boolean(),
           enable_stories: boolean(),
           source_chapter: integer(),
@@ -26,6 +30,10 @@ defmodule Cadet.Courses.Course do
     field(:viewable, :boolean, default: true)
     field(:enable_game, :boolean, default: true)
     field(:enable_achievements, :boolean, default: true)
+    field(:enable_overall_leaderboard, :boolean, default: true)
+    field(:enable_contest_leaderboard, :boolean, default: true)
+    field(:top_leaderboard_display, :integer, default: 100)
+    field(:top_contest_leaderboard_display, :integer, default: 10)
     field(:enable_sourcecast, :boolean, default: true)
     field(:enable_stories, :boolean, default: false)
     field(:source_chapter, :integer)
@@ -41,7 +49,7 @@ defmodule Cadet.Courses.Course do
   end
 
   @required_fields ~w(course_name viewable enable_game
-    enable_achievements enable_sourcecast enable_stories source_chapter source_variant)a
+    enable_achievements enable_overall_leaderboard enable_contest_leaderboard top_leaderboard_display top_contest_leaderboard_display enable_sourcecast enable_stories source_chapter source_variant)a
   @optional_fields ~w(course_short_name module_help_text)a
 
   def changeset(course, params) do

lib/cadet/courses/course.ex

@@ -246,22 +246,30 @@ defmodule Cadet.Updater.XMLParser do
   end
 
   defp process_question_entity_by_type(entity, "voting") do
-    Map.merge(
-      entity
-      |> xpath(
-        ~x"."e,
-        content: ~x"./TEXT/text()" |> transform_by(&process_charlist/1),
-        prepend: ~x"./SNIPPET/PREPEND/text()" |> transform_by(&process_charlist/1),
-        template: ~x"./SNIPPET/TEMPLATE/text()" |> transform_by(&process_charlist/1)
-      ),
-      entity
-      |> xpath(
-        ~x"./VOTING"e,
-        contest_number: ~x"./@assessment_number"s,
-        reveal_hours: ~x"./@reveal_hours"i,
-        token_divider: ~x"./@token_divider"i
+    question_data =
+      Map.merge(
+        entity
+        |> xpath(
+          ~x"."e,
+          content: ~x"./TEXT/text()" |> transform_by(&process_charlist/1),
+          prepend: ~x"./SNIPPET/PREPEND/text()" |> transform_by(&process_charlist/1),
+          template: ~x"./SNIPPET/TEMPLATE/text()" |> transform_by(&process_charlist/1)
+        ),
+        entity
+        |> xpath(
+          ~x"./VOTING"e,
+          contest_number: ~x"./@assessment_number"s,
+          reveal_hours: ~x"./@reveal_hours"i,
+          token_divider: ~x"./@token_divider"i
+        )
       )
-    )
+
+    xp_values =
+      entity
+      |> xpath(~x"./VOTING/XP_ARRAY/XP"el, value: ~x"./@value"i)
+      |> Enum.map(& &1[:value])
+
+    if xp_values == [], do: question_data, else: Map.merge(question_data, %{xp_values: xp_values})
   end
 
   defp process_question_entity_by_type(_, _) do

lib/cadet/jobs/xml_parser.ex

@@ -135,42 +135,35 @@ defmodule CadetWeb.AdminAssessmentsController do
     end
   end
 
-  def get_score_leaderboard(conn, %{"assessmentid" => assessment_id, "course_id" => course_id}) do
+  def calculate_contest_score(conn, %{"assessmentid" => assessment_id, "course_id" => course_id}) do
     voting_questions =
       Question
       |> where(type: :voting)
       |> where(assessment_id: ^assessment_id)
       |> Repo.one()
 
-    contest_id = Assessments.fetch_associated_contest_question_id(course_id, voting_questions)
-
-    result =
-      contest_id
-      |> Assessments.fetch_top_relative_score_answers(10)
-      |> Enum.map(fn entry ->
-        AssessmentsHelpers.build_contest_leaderboard_entry(entry)
-      end)
-
-    render(conn, "leaderboard.json", leaderboard: result)
+    if voting_questions do
+      Assessments.compute_relative_score(voting_questions.id)
+      text(conn, "CONTEST SCORE CALCULATED")
+    else
+      text(conn, "No voting questions found for the given assessment")
+    end
   end
 
-  def get_popular_leaderboard(conn, %{"assessmentid" => assessment_id, "course_id" => course_id}) do
+  def dispatch_contest_xp(conn, %{"assessmentid" => assessment_id, "course_id" => course_id}) do
     voting_questions =
       Question
       |> where(type: :voting)
       |> where(assessment_id: ^assessment_id)
       |> Repo.one()
 
-    contest_id = Assessments.fetch_associated_contest_question_id(course_id, voting_questions)
+    if voting_questions do
+      Assessments.assign_winning_contest_entries_xp(voting_questions.id)
 
-    result =
-      contest_id
-      |> Assessments.fetch_top_popular_score_answers(10)
-      |> Enum.map(fn entry ->
-        AssessmentsHelpers.build_popular_leaderboard_entry(entry)
-      end)
-
-    render(conn, "leaderboard.json", leaderboard: result)
+      text(conn, "XP Dispatched")
+    else
+      text(conn, "No voting questions found for the given assessment")
+    end
   end
 
   defp check_dates(open_at, close_at, assessment) do
@@ -288,7 +281,7 @@ defmodule CadetWeb.AdminAssessmentsController do
   swagger_path :get_score_leaderboard do
     get("/courses/{course_id}/admin/assessments/:assessmentid/scoreLeaderboard")
 
-    summary("get the top 10 contest entries based on score")
+    summary("get the top X contest entries based on score")
 
     security([%{JWT: []}])
 

lib/cadet_web/admin_controllers/admin_assessments_controller.ex

@@ -106,6 +106,10 @@ defmodule CadetWeb.AdminCoursesController do
       viewable(:body, :boolean, "Course viewability")
       enable_game(:body, :boolean, "Enable game")
       enable_achievements(:body, :boolean, "Enable achievements")
+      enable_overall_leaderboard(:body, :boolean, "Enable overall leaderboard")
+      enable_contest_leaderboard(:body, :boolean, "Enable contest leaderboard")
+      top_leaderboard_display(:body, :integer, "Top Leaderboard Display")
+      top_contest_leaderboard_display(:body, :integer, "Top Contest Leaderboard Display")
       enable_sourcecast(:body, :boolean, "Enable sourcecast")
       enable_stories(:body, :boolean, "Enable stories")
       sublanguage(:body, Schema.ref(:AdminSublanguage), "sublanguage object")

lib/cadet_web/admin_controllers/admin_courses_controller.ex

@@ -3,7 +3,11 @@ defmodule CadetWeb.AssessmentsController do
 
   use PhoenixSwagger
 
-  alias Cadet.Assessments
+  import Ecto.Query, only: [where: 2]
+
+  alias Cadet.{Assessments, Repo}
+  alias Cadet.Assessments.Question
+  alias CadetWeb.AssessmentsHelpers
 
   # These roles can save and finalise answers for closed assessments and
   # submitted answers
@@ -67,6 +71,103 @@ defmodule CadetWeb.AssessmentsController do
     end
   end
 
+  def combined_total_xp_for_all_users(conn, %{"course_id" => course_id}) do
+    users_with_xp = Assessments.all_user_total_xp(course_id)
+    json(conn, %{users: users_with_xp.users})
+  end
+
+  def paginated_total_xp_for_leaderboard_display(conn, %{"course_id" => course_id}) do
+    offset = String.to_integer(conn.params["offset"] || "0")
+    page_size = String.to_integer(conn.params["page_size"] || "25")
+    paginated_display = Assessments.all_user_total_xp(course_id, offset, page_size)
+    json(conn, paginated_display)
+  end
+
+  def get_score_leaderboard(conn, %{
+        "assessmentid" => assessment_id,
+        "course_id" => course_id
+      }) do
+    visible_entries = String.to_integer(conn.params["visible_entries"] || "10")
+    voting_id = Assessments.fetch_contest_voting_assesment_id(assessment_id)
+
+    voting_questions =
+      Question
+      |> where(type: :voting)
+      |> where(assessment_id: ^assessment_id)
+      |> Repo.one()
+      |> case do
+        nil ->
+          Question
+          |> where(type: :voting)
+          |> where(assessment_id: ^voting_id)
+          |> Repo.one()
+
+        question ->
+          question
+      end
+
+    contest_id = Assessments.fetch_associated_contest_question_id(course_id, voting_questions)
+
+    result =
+      contest_id
+      |> Assessments.fetch_top_relative_score_answers(visible_entries)
+      |> Enum.map(fn entry ->
+        updated_entry = %{
+          entry
+          | answer: entry.answer["code"]
+        }
+
+        AssessmentsHelpers.build_contest_leaderboard_entry(updated_entry)
+      end)
+
+    json(conn, %{leaderboard: result, voting_id: voting_id})
+  end
+
+  def get_popular_leaderboard(conn, %{
+        "assessmentid" => assessment_id,
+        "course_id" => course_id
+      }) do
+    visible_entries = String.to_integer(conn.params["visible_entries"] || "10")
+    voting_id = Assessments.fetch_contest_voting_assesment_id(assessment_id)
+
+    voting_questions =
+      Question
+      |> where(type: :voting)
+      |> where(assessment_id: ^assessment_id)
+      |> Repo.one()
+      |> case do
+        nil ->
+          Question
+          |> where(type: :voting)
+          |> where(assessment_id: ^voting_id)
+          |> Repo.one()
+
+        question ->
+          question
+      end
+
+    contest_id = Assessments.fetch_associated_contest_question_id(course_id, voting_questions)
+
+    result =
+      contest_id
+      |> Assessments.fetch_top_popular_score_answers(visible_entries)
+      |> Enum.map(fn entry ->
+        updated_entry = %{
+          entry
+          | answer: entry.answer["code"]
+        }
+
+        AssessmentsHelpers.build_popular_leaderboard_entry(updated_entry)
+      end)
+
+    json(conn, %{leaderboard: result, voting_id: voting_id})
+  end
+
+  def get_all_contests(conn, %{"course_id" => course_id}) do
+    contests = Assessments.fetch_all_contests(course_id)
+    json(conn, contests)
+  end
+
   swagger_path :submit do
     post("/courses/{course_id}/assessments/{assessmentId}/submit")
     summary("Finalise submission for an assessment")

lib/cadet_web/controllers/assessments_controller.ex

@@ -54,6 +54,14 @@ defmodule CadetWeb.CoursesController do
       viewable(:body, :boolean, "Course viewability", required: true)
       enable_game(:body, :boolean, "Enable game", required: true)
       enable_achievements(:body, :boolean, "Enable achievements", required: true)
+      enable_overall_leaderboard(:body, :boolean, "Enable overall leaderboard", required: true)
+      enable_contest_leaderboard(:body, :boolean, "Enable contest leaderboard", required: true)
+      top_leaderboard_display(:body, :number, "Top leaderboard display", required: true)
+
+      top_contest_leaderboard_display(:body, :number, "Top contest leaderboard display",
+        required: true
+      )
+
       enable_sourcecast(:body, :boolean, "Enable sourcecast", required: true)
       enable_stories(:body, :boolean, "Enable stories", required: true)
       source_chapter(:body, :number, "Default source chapter", required: true)
@@ -95,6 +103,14 @@ defmodule CadetWeb.CoursesController do
             viewable(:boolean, "Course viewability", required: true)
             enable_game(:boolean, "Enable game", required: true)
             enable_achievements(:boolean, "Enable achievements", required: true)
+            enable_overall_leaderboard(:boolean, "Enable overall leaderboard", required: true)
+            enable_contest_leaderboard(:boolean, "Enable contest leaderboard", required: true)
+            top_leaderboard_display(:boolean, "Top leaderboard display", required: true)
+
+            top_contest_leaderboard_display(:boolean, "Top contest leaderboard display",
+              required: true
+            )
+
             enable_sourcecast(:boolean, "Enable sourcecast", required: true)
             enable_stories(:boolean, "Enable stories", required: true)
             source_chapter(:integer, "Source Chapter number from 1 to 4", required: true)
@@ -109,6 +125,10 @@ defmodule CadetWeb.CoursesController do
             viewable: true,
             enable_game: true,
             enable_achievements: true,
+            enable_overall_leaderboard: true,
+            enable_contest_leaderboard: true,
+            top_leaderboard_display: 100,
+            top_contest_leaderboard_display: 10,
             enable_sourcecast: true,
             enable_stories: false,
             source_chapter: 1,

lib/cadet_web/controllers/courses_controller.ex

@@ -315,6 +315,14 @@ defmodule CadetWeb.UserController do
             viewable(:boolean, "Course viewability", required: true)
             enable_game(:boolean, "Enable game", required: true)
             enable_achievements(:boolean, "Enable achievements", required: true)
+            enable_overall_leaderboard(:boolean, "Enable overall leaderboard", required: true)
+            enable_contest_leaderboard(:boolean, "Enable contest leadeboard", required: true)
+            top_leaderboard_display(:integer, "Top leaderboard display", required: true)
+
+            top_contest_leaderboard_display(:integer, "Top contest leaderboard display",
+              required: true
+            )
+
             enable_sourcecast(:boolean, "Enable sourcecast", required: true)
             enable_stories(:boolean, "Enable stories", required: true)
             source_chapter(:integer, "Source Chapter number from 1 to 4", required: true)
@@ -330,6 +338,10 @@ defmodule CadetWeb.UserController do
             viewable: true,
             enable_game: true,
             enable_achievements: true,
+            enable_overall_leaderboard: true,
+            enable_contest_leaderboard: true,
+            top_leaderboard_display: 100,
+            top_contest_leaderboard_display: 10,
             enable_sourcecast: true,
             enable_stories: false,
             source_chapter: 1,

lib/cadet_web/controllers/user_controller.ex

@@ -107,7 +107,9 @@ defmodule CadetWeb.AssessmentsHelpers do
       transform_map_for_view(leaderboard_ans, %{
         submission_id: :submission_id,
         answer: :answer,
-        student_name: :student_name
+        student_name: :student_name,
+        student_username: :student_username,
+        rank: :rank
       }),
       "final_score",
       Float.round(leaderboard_ans.relative_score, 2)
@@ -119,7 +121,9 @@ defmodule CadetWeb.AssessmentsHelpers do
       transform_map_for_view(leaderboard_ans, %{
         submission_id: :submission_id,
         answer: :answer,
-        student_name: :student_name
+        student_name: :student_name,
+        student_username: :student_username,
+        rank: :rank
       }),
       "final_score",
       Float.round(leaderboard_ans.popular_score, 2)