Added Exam mode

lib/cadet/accounts/course_registrations.ex

@@ -47,6 +47,20 @@ defmodule Cadet.Accounts.CourseRegistrations do
     |> Repo.all()
   end
 
+  def get_exam_mode_course(%User{id: id}) do
+    CourseRegistration
+    |> where([cr], cr.user_id == ^id)
+    |> join(:inner, [cr], c in assoc(cr, :course),
+      on: c.enable_exam_mode == true and c.is_official_course == true
+    )
+    |> join(:left, [cr, c], ac in assoc(c, :assessment_config))
+    |> preload([cr, c, ac],
+      course: {c, assessment_config: ^from(ac in AssessmentConfig, order_by: [asc: ac.order])}
+    )
+    |> preload(:group)
+    |> Repo.one()
+  end
+
   def get_admin_courses_count(%User{id: id}) do
     CourseRegistration
     |> where(user_id: ^id)

lib/cadet/accounts/user.ex

@@ -21,6 +21,7 @@ defmodule Cadet.Accounts.User do
     field(:provider, :string)
     field(:super_admin, :boolean)
     field(:email, :string)
+    field(:is_paused, :boolean)
 
     belongs_to(:latest_viewed_course, Course)
     has_many(:courses, CourseRegistration)
@@ -29,7 +30,7 @@ defmodule Cadet.Accounts.User do
   end
 
   @required_fields ~w(username provider)a
-  @optional_fields ~w(name latest_viewed_course_id super_admin)a
+  @optional_fields ~w(name latest_viewed_course_id super_admin is_paused)a
 
   def changeset(user, params \\ %{}) do
     user

lib/cadet/courses/course.ex

@@ -14,6 +14,9 @@ defmodule Cadet.Courses.Course do
           enable_achievements: boolean(),
           enable_sourcecast: boolean(),
           enable_stories: boolean(),
+          enable_exam_mode: boolean(),
+          resume_code: string(),
+          is_official_course: boolean(),
           source_chapter: integer(),
           source_variant: String.t(),
           module_help_text: String.t(),
@@ -28,6 +31,9 @@ defmodule Cadet.Courses.Course do
     field(:enable_achievements, :boolean, default: true)
     field(:enable_sourcecast, :boolean, default: true)
     field(:enable_stories, :boolean, default: false)
+    field(:enable_exam_mode, :boolean, default: false)
+    field(:resume_code, :string)
+    field(:is_official_course, :boolean, default: false)
     field(:source_chapter, :integer)
     field(:source_variant, :string)
     field(:module_help_text, :string)
@@ -41,14 +47,44 @@ 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
-  @optional_fields ~w(course_short_name module_help_text)a
+    enable_exam_mode enable_achievements enable_sourcecast enable_stories source_chapter source_variant)a
+  @optional_fields ~w(course_short_name module_help_text resume_code)a
 
   def changeset(course, params) do
     course
     |> cast(params, @required_fields ++ @optional_fields)
     |> validate_required(@required_fields)
     |> validate_sublanguage_combination(params)
+    |> validate_exam_mode(params)
+  end
+
+  # Validates combination of exam mode, resume code, and official course state
+  defp validate_exam_mode(changeset, params) do
+    resume_code = Map.get(params, :resume_code, "")
+    enable_exam_mode = Map.get(params, :enable_exam_mode, false)
+    is_official_course = get_field(changeset, :is_official_course, false)
+
+    case {enable_exam_mode, is_official_course, resume_code} do
+      {false, _, _} ->
+        changeset
+
+      {true, false, _} ->
+        add_error(
+          changeset,
+          :enable_exam_mode,
+          "Exam mode is only available for official institution course."
+        )
+
+      {true, true, ""} ->
+        add_error(
+          changeset,
+          :resume_code,
+          "Resume code must be set to non-empty value upon enabling of exam mode."
+        )
+
+      {_, _, _} ->
+        changeset
+    end
   end
 
   # Validates combination of Source chapter and variant

lib/cadet/courses/courses.ex

@@ -44,7 +44,7 @@
   """
   @spec get_course_config(integer) ::
           {:ok, Course.t()} | {:error, {:bad_request, String.t()}}
-  def get_course_config(course_id) when is_ecto_id(course_id) do
+  def get_course_config(course_id, is_admin \\ false) when is_ecto_id(course_id) do
     case retrieve_course(course_id) do
       nil ->
         {:error, {:bad_request, "Invalid course id"}}

lib/cadet_web/admin_controllers/admin_courses_controller.ex

@@ -108,6 +108,8 @@ defmodule CadetWeb.AdminCoursesController do
       enable_achievements(:body, :boolean, "Enable achievements")
       enable_sourcecast(:body, :boolean, "Enable sourcecast")
       enable_stories(:body, :boolean, "Enable stories")
+      enable_exam_mode(:body, :boolean, "Enable exam mode")
+      resume_code(:body, :string, "Resume code when attempt to open DevTool is detected")
       sublanguage(:body, Schema.ref(:AdminSublanguage), "sublanguage object")
       module_help_text(:body, :string, "Module help text")
     end

lib/cadet_web/admin_controllers/admin_user_controller.ex

@@ -3,7 +3,6 @@ defmodule CadetWeb.AdminUserController do
   use PhoenixSwagger
 
   import Ecto.Query
-
   alias Cadet.Repo
   alias Cadet.{Accounts, Assessments, Courses}
   alias Cadet.Accounts.{CourseRegistrations, CourseRegistration, Role}
@@ -14,7 +13,7 @@ defmodule CadetWeb.AdminUserController do
     users =
       filter |> try_keywordise_string_keys() |> Accounts.get_users_by(conn.assigns.course_reg)
 
-    render(conn, "users.json", users: users)
+    render(conn, "users.json", users: users, is_admin: false)
   end
 
   def combined_total_xp(conn, %{"course_reg_id" => course_reg_id}) do

lib/cadet_web/controllers/courses_controller.ex

@@ -9,7 +9,11 @@
   def index(conn, %{"course_id" => course_id}) when is_ecto_id(course_id) do
     case Courses.get_course_config(course_id) do
       {:ok, config} ->
-        render(conn, "config.json", config: config)
+        if conn.assigns.course_reg.role == :admin || conn.assigns.course_reg.role == "admin" do
+          render(conn, "config_admin.json", config: config)
+        else
+          render(conn, "config.json", config: config)
+        end
 
       # coveralls-ignore-start
       # no course error will not happen here
@@ -40,6 +44,42 @@
     end
   end
 
+  def check_resume_code(conn, %{"course_id" => course_id}) when is_ecto_id(course_id) do
+    params = conn.body_params
+    user = conn.assigns.current_user
+    resume_code = Map.get(params, "resume_code", nil)
+
+    case Courses.get_course_config(course_id) do
+      {:ok, config} ->
+        if config.resume_code == resume_code do
+          user
+          |> Cadet.Accounts.User.changeset(%{is_paused: false})
+          |> Cadet.Repo.update()
+          |> case do
+            result = {:ok, _} ->
+              conn
+              |> put_status(:ok)
+              |> text("Resume code validated.")
+
+            {:error, _} ->
+              conn
+              |> put_status(500)
+              |> text(:error)
+          end
+        else
+          conn
+          |> put_status(403)
+          |> text("Resume code wrong.")
+        end
+
+      # coveralls-ignore-start
+      # no course error will not happen here
+      {:error, {status, message}} ->
+        send_resp(conn, status, message)
+        # coveralls-ignore-stop
+    end
+  end
+
   swagger_path :create do
     post("/config/create")
 
@@ -56,6 +96,7 @@
       enable_achievements(:body, :boolean, "Enable achievements", required: true)
       enable_sourcecast(:body, :boolean, "Enable sourcecast", required: true)
       enable_stories(:body, :boolean, "Enable stories", required: true)
+      enable_exam_mode(:body, :boolean, "Enable exam mode", required: true)
       source_chapter(:body, :number, "Default source chapter", required: true)
 
       source_variant(:body, Schema.ref(:SourceVariant), "Default source variant name",
@@ -97,6 +138,7 @@
             enable_achievements(:boolean, "Enable achievements", required: true)
             enable_sourcecast(:boolean, "Enable sourcecast", required: true)
             enable_stories(:boolean, "Enable stories", required: true)
+            enable_exam_mode(:boolean, "Enable exam mode", required: true)
             source_chapter(:integer, "Source Chapter number from 1 to 4", required: true)
             source_variant(Schema.ref(:SourceVariant), "Source Variant name", required: true)
             module_help_text(:string, "Module help text", required: true)

lib/cadet_web/controllers/user_controller.ex

@@ -12,42 +12,68 @@
   def index(conn, _) do
     user = conn.assigns.current_user
     courses = CourseRegistrations.get_courses(conn.assigns.current_user)
-
-    if user.latest_viewed_course_id do
-      latest = CourseRegistrations.get_user_course(user.id, user.latest_viewed_course_id)
-      xp = Assessments.assessments_total_xp(latest)
-      max_xp = Assessments.user_max_xp(latest)
-      story = Assessments.user_current_story(latest)
-
-      render(
-        conn,
-        "index.json",
-        user: user,
-        courses: courses,
-        latest: latest,
-        max_xp: max_xp,
-        story: story,
-        xp: xp
-      )
-    else
-      render(conn, "index.json",
-        user: user,
-        courses: courses,
-        latest: nil,
-        max_xp: nil,
-        story: nil,
-        xp: nil
-      )
+    exam_mode_course = CourseRegistrations.get_exam_mode_course(conn.assigns.current_user)
+
+    cond do
+      exam_mode_course ->
+        xp = Assessments.assessments_total_xp(exam_mode_course)
+        max_xp = Assessments.user_max_xp(exam_mode_course)
+        story = Assessments.user_current_story(exam_mode_course)
+
+        render(
+          conn,
+          "index.json",
+          user: user,
+          courses: courses |> Enum.filter(fn c -> c.course_id == exam_mode_course.course_id end),
+          latest: exam_mode_course,
+          max_xp: max_xp,
+          story: story,
+          xp: xp
+        )
+
+      user.latest_viewed_course_id ->
+        latest = CourseRegistrations.get_user_course(user.id, user.latest_viewed_course_id)
+        xp = Assessments.assessments_total_xp(latest)
+        max_xp = Assessments.user_max_xp(latest)
+        story = Assessments.user_current_story(latest)
+
+        render(
+          conn,
+          "index.json",
+          user: user,
+          courses: courses,
+          latest: latest,
+          max_xp: max_xp,
+          story: story,
+          xp: xp
+        )
+
+      true ->
+        render(conn, "index.json",
+          user: user,
+          courses: courses,
+          latest: nil,
+          max_xp: nil,
+          story: nil,
+          xp: nil
+        )
     end
   end
 
   def get_latest_viewed(conn, _) do
     user = conn.assigns.current_user
+    exam_mode_course = CourseRegistrations.get_exam_mode_course(conn.assigns.current_user)
 
     latest =
-      case user.latest_viewed_course_id do
-        nil -> nil
-        _ -> CourseRegistrations.get_user_course(user.id, user.latest_viewed_course_id)
+      cond do
+        exam_mode_course ->
+          CourseRegistrations.get_user_course(user.id, exam_mode_course.course_id)
+
+        user.latest_viewed_course_id ->
+          CourseRegistrations.get_user_course(user.id, user.latest_viewed_course_id)
+
+        true ->
+          nil
       end
 
     get_course_reg_config(conn, latest)
@@ -98,6 +124,25 @@
     end
   end
 
+  def pause_user(conn, params) do
+    user = conn.assigns.current_user
+
+    user
+    |> Cadet.Accounts.User.changeset(%{is_paused: true})
+    |> Cadet.Repo.update()
+    |> case do
+      result = {:ok, _} ->
+        conn
+        |> put_status(:ok)
+        |> text("User is paused.")
+
+      {:error, _} ->
+        conn
+        |> put_status(500)
+        |> text(:error)
+    end
+  end
+
   def update_research_agreement(conn, %{"agreedToResearch" => agreed_to_research}) do
     course_reg = conn.assigns[:course_reg]
 
@@ -317,6 +362,8 @@
             enable_achievements(:boolean, "Enable achievements", required: true)
             enable_sourcecast(:boolean, "Enable sourcecast", required: true)
             enable_stories(:boolean, "Enable stories", required: true)
+            enable_exam_mode(:boolean, "Enable exam mode", required: true)
+            is_official_course(:boolean, "Course status (official institution course)")
             source_chapter(:integer, "Source Chapter number from 1 to 4", required: true)
             source_variant(Schema.ref(:SourceVariant), "Source Variant name", required: true)
             module_help_text(:string, "Module help text", required: true)
@@ -332,6 +379,8 @@
             enable_achievements: true,
             enable_sourcecast: true,
             enable_stories: false,
+            enable_exam_mode: false,
+            is_official_course: true,
             source_chapter: 1,
             source_variant: "default",
             module_help_text: "Help text",

lib/cadet_web/router.ex

@@ -117,8 +117,10 @@ defmodule CadetWeb.Router do
     get("/user/total_xp", UserController, :combined_total_xp)
     put("/user/game_states", UserController, :update_game_states)
     put("/user/research_agreement", UserController, :update_research_agreement)
+    put("/user/pause", UserController, :pause_user)
 
     get("/config", CoursesController, :index)
+    post("/resume_code", CoursesController, :check_resume_code)
 
     get("/team/:assessmentid", TeamController, :index)
   end

lib/cadet_web/views/courses_view.ex

@@ -12,6 +12,31 @@ defmodule CadetWeb.CoursesView do
           enableAchievements: :enable_achievements,
           enableSourcecast: :enable_sourcecast,
           enableStories: :enable_stories,
+          enableExamMode: :enable_exam_mode,
+          isOfficialCourse: :is_official_course,
+          sourceChapter: :source_chapter,
+          sourceVariant: :source_variant,
+          moduleHelpText: :module_help_text,
+          assessmentTypes: :assessment_configs,
+          assetsPrefix: :assets_prefix
+        })
+    }
+  end
+
+  def render("config_admin.json", %{config: config}) do
+    %{
+      config:
+        transform_map_for_view(config, %{
+          courseName: :course_name,
+          courseShortName: :course_short_name,
+          viewable: :viewable,
+          enableGame: :enable_game,
+          enableAchievements: :enable_achievements,
+          enableSourcecast: :enable_sourcecast,
+          enableStories: :enable_stories,
+          enableExamMode: :enable_exam_mode,
+          isOfficialCourse: :is_official_course,
+          resumeCode: :resume_code,
           sourceChapter: :source_chapter,
           sourceVariant: :source_variant,
           moduleHelpText: :module_help_text,