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 and cr.role == :student)
+    |> 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 @@
           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 @@
     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,51 @@
   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
+    has_resume_code = params |> Map.has_key?(:resume_code)
+
+    resume_code_params =
+      params
+      |> Map.get(:resume_code, "")
+      |> String.trim()
+
+    resume_code =
+      changeset
+      |> get_field(: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, has_resume_code, resume_code_params} do
+      {_, _, true, ""} ->
+        add_error(
+          changeset,
+          :resume_code,
+          "Resume code must not be empty."
+        )
+
+      {true, false, _, _} ->
+        add_error(
+          changeset,
+          :enable_exam_mode,
+          "Exam mode is only available for official institution course."
+        )
+
+      _ ->
+        changeset
+    end
   end
 
   # Validates combination of Source chapter and variant

lib/cadet/courses/courses.ex

@@ -24,11 +24,12 @@ defmodule Cadet.Courses do
 
   @doc """
   Creates a new course configuration, course registration, and sets
-  the user's latest course id to the newly created course.
+  the user's latest course id to the newly created course. A 4-digit
+  course resume code will be randomly generated.
   """
   def create_course_config(params, user) do
     Multi.new()
-    |> Multi.insert(:course, Course.changeset(%Course{}, params))
+    |> Multi.insert(:course, Course.changeset(%Course{}, set_default_resume_code(params)))
     |> Multi.run(:course_reg, fn _repo, %{course: course} ->
       CourseRegistrations.enroll_course(%{
         course_id: course.id,
@@ -82,6 +83,11 @@ defmodule Cadet.Courses do
     end
   end
 
+  defp set_default_resume_code(params) do
+    params
+    |> Map.put(:resume_code, Integer.to_string(:rand.uniform(9000) + 999))
+  end
+
   def get_all_course_ids do
     Course
     |> select([c], c.id)

lib/cadet/focus_logs/focus_log.ex

@@ -0,0 +1,32 @@
+defmodule Cadet.FocusLogs.FocusLog do
+  @moduledoc """
+  The FocusLog entity represents a log of user's browser focus
+  while using Source Academy under exam mode.
+  """
+  use Cadet, :model
+
+  alias Cadet.Accounts.User
+  alias Cadet.Courses.Course
+
+  @type t :: %__MODULE__{
+          user: User.t(),
+          course: Course.t(),
+          focus_type: integer()
+        }
+
+  schema "user_browser_focus_log" do
+    belongs_to(:user, User)
+    belongs_to(:course, Course)
+    field(:time, :naive_datetime)
+    field(:focus_type, :integer)
+  end
+
+  @required_fields ~w(user_id course_id time focus_type)a
+
+  def changeset(focus_log, params) do
+    focus_log
+    |> cast(params, @required_fields)
+    |> add_belongs_to_id_from_model([:user, :course], params)
+    |> validate_required(@required_fields)
+  end
+end

lib/cadet/focus_logs/focus_logs.ex

@@ -0,0 +1,26 @@
+defmodule Cadet.FocusLogs do
+  @moduledoc """
+  Contains logic to manage user's browser focus log
+  such as insertion
+  """
+  alias Cadet.FocusLogs.FocusLog
+
+  use Cadet, [:context, :display]
+
+  def insert_log(user_id, course_id, focus_type) do
+    insert_result =
+      %FocusLog{}
+      |> FocusLog.changeset(%{
+        user_id: user_id,
+        course_id: course_id,
+        time: DateTime.utc_now(),
+        focus_type: focus_type
+      })
+      |> Repo.insert()
+
+    case insert_result do
+      {:ok, log} -> {:ok, log}
+      {:error, changeset} -> {:error, full_error_messages(changeset)}
+    end
+  end
+end

lib/cadet_web/admin_controllers/admin_courses_controller.ex

@@ -108,6 +108,14 @@ 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 that students that attempt to open developer tools will be prompted to enter"
+      )
+
       sublanguage(:body, Schema.ref(:AdminSublanguage), "sublanguage object")
       module_help_text(:body, :string, "Module help text")
     end
@@ -143,7 +151,11 @@ defmodule CadetWeb.AdminCoursesController do
           title("AdminSublanguage")
 
           properties do
-            chapter(:integer, "Chapter number from 1 to 4", required: true, minimum: 1, maximum: 4)
+            chapter(:integer, "Chapter number from 1 to 4",
+              required: true,
+              minimum: 1,
+              maximum: 4
+            )
 
             variant(Schema.ref(:SourceVariant), "Variant name", required: true)
           end

lib/cadet_web/controllers/courses_controller.ex

@@ -9,7 +9,11 @@ defmodule CadetWeb.CoursesController do
   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 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,36 @@ defmodule CadetWeb.CoursesController do
     end
   end
 
+  defp check_resume_code(course_id, resume_code) do
+    case Courses.get_course_config(course_id) do
+      {:ok, config} -> {:ok, config.resume_code == resume_code}
+      {:error, {status_code, message}} -> {:error, {status_code, message}}
+    end
+  end
+
+  defp unpause_user(conn, user) do
+    update_result =
+      user
+      |> Cadet.Accounts.User.changeset(%{is_paused: false})
+      |> Cadet.Repo.update()
+
+    case update_result do
+      {:ok, _} -> conn |> send_resp(:ok, "")
+      {:error, _} -> conn |> send_resp(500, "")
+    end
+  end
+
+  def try_unpause_user(conn, %{"course_id" => course_id}) when is_ecto_id(course_id) do
+    user = conn.assigns.current_user
+    resume_code = Map.get(conn.body_params, "resume_code", nil)
+
+    case check_resume_code(course_id, resume_code) do
+      {:ok, true} -> unpause_user(conn, user)
+      {:ok, false} -> conn |> send_resp(:forbidden, "")
+      {:error, {status_code, message}} -> conn |> send_resp(status_code, message)
+    end
+  end
+
   swagger_path :create do
     post("/config/create")
 
@@ -56,6 +90,7 @@ defmodule CadetWeb.CoursesController do
       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 +132,7 @@ defmodule CadetWeb.CoursesController do
             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)