Add Publish Grading Feature

lib/cadet/accounts/notification_type.ex

@@ -10,5 +10,7 @@ defenum(Cadet.Accounts.NotificationType, :notification_type, [
   # Notifications for unsubmitted submissions
   :unsubmitted,
   # Notifications for submitted assessments
-  :submitted
+  :submitted,
+  # Notifications for unpublished grades
+  :unpublished_grading
 ])

lib/cadet/accounts/notifications.ex

@@ -151,7 +151,7 @@ defmodule Cadet.Accounts.Notifications do
     Notification
     |> where(course_reg_id: ^student.id)
     |> where(assessment_id: ^assessment_id)
-    |> where([n], n.type in ^[:autograded, :graded])
+    |> where([n], n.type in ^[:autograded, :graded, :unpublished_grading])
     |> Repo.delete_all()
 
     write(%{
@@ -162,6 +162,30 @@ defmodule Cadet.Accounts.Notifications do
     })
   end
 
+  @doc """
+  Function that handles notifications when a submission grade is unpublished.
+  """
+  @spec handle_unpublish_grades_notifications(integer(), CourseRegistration.t()) ::
+          {:ok, Ecto.Schema.t()} | {:error, Ecto.Changeset.t()}
+  def handle_unpublish_grades_notifications(assessment_id, student = %CourseRegistration{})
+      when is_ecto_id(assessment_id) do
+    # Fetch and delete all notifications of :graded
+    # Add new notification :unpublished
+
+    Notification
+    |> where(course_reg_id: ^student.id)
+    |> where(assessment_id: ^assessment_id)
+    |> where([n], n.type in ^[:autograded, :graded, :unsubmitted])
+    |> Repo.delete_all()
+
+    write(%{
+      type: :unpublished_grading,
+      role: student.role,
+      course_reg_id: student.id,
+      assessment_id: assessment_id
+    })
+  end
+
   @doc """
   Writes a notification that a student's submission has been
   graded successfully. (for the student)

lib/cadet/assessments/assessment.ex

@@ -20,6 +20,7 @@ defmodule Cadet.Assessments.Assessment do
     field(:grading_status, :string, virtual: true)
     field(:question_count, :integer, virtual: true)
     field(:graded_count, :integer, virtual: true)
+    field(:is_grading_published, :boolean, virtual: true)
     field(:title, :string)
     field(:is_published, :boolean, default: false)
     field(:summary_short, :string)

lib/cadet/assessments/assessments.ex

@@ -107,6 +107,7 @@
     submission_xp =
       Submission
       |> where(student_id: ^cr_id)
+      |> where(is_grading_published: true)
       |> join(:inner, [s], a in Answer, on: s.id == a.submission_id)
       |> group_by([s], s.id)
       |> select([s, a], %{
@@ -281,7 +282,18 @@
         end)
         |> load_contest_voting_entries(course_reg, assessment)
 
-      assessment = assessment |> Map.put(:questions, questions)
+      is_grading_published =
+        Submission
+        |> where(assessment_id: ^id)
+        |> where(student_id: ^course_reg.id)
+        |> select([s], s.is_grading_published)
+        |> Repo.one()
+
+      assessment =
+        assessment
+        |> Map.put(:questions, questions)
+        |> Map.put(:is_grading_published, is_grading_published)
+
       {:ok, assessment}
     else
       {:error, {:forbidden, "Assessment not open"}}
@@ -312,7 +324,7 @@
     submission_status =
       Submission
       |> where([s], s.student_id == ^cr.id)
-      |> select([s], [:assessment_id, :status])
+      |> select([s], [:assessment_id, :status, :is_grading_published])
 
     assessments =
       cr.course_id
@@ -329,7 +341,8 @@
         a
         | xp: sa.xp,
           graded_count: sa.graded_count,
-          user_status: s.status
+          user_status: s.status,
+          is_grading_published: s.is_grading_published
       })
       |> filter_published_assessments(cr)
       |> order_by(:open_at)
@@ -339,6 +352,52 @@
     {:ok, assessments}
   end
 
+  @doc """
+  A helper function which removes grading information from all assessments
+  if it's grading is not published.
+  """
+  def format_all_assessments(assessments) do
+    Enum.map(assessments, fn a ->
+      if a.is_grading_published do
+        a
+      else
+        a
+        |> Map.put(:xp, 0)
+        |> Map.put(:graded_count, 0)
+      end
+    end)
+  end
+
+  @doc """
+  A helper function which removes grading information from the assessment
+  if it's grading is not published.
+  """
+  def format_assessment_with_questions_and_answers(assessment) do
+    if assessment.is_grading_published do
+      assessment
+    else
+      %{
+        assessment
+        | questions:
+            Enum.map(assessment.questions, fn q ->
+              %{
+                q
+                | answer: %{
+                    q.answer
+                    | xp: 0,
+                      xp_adjustment: 0,
+                      autograding_status: :none,
+                      autograding_results: [],
+                      grader: nil,
+                      grader_id: nil,
+                      comments: nil
+                  }
+              }
+            end)
+      }
+    end
+  end
+
   def filter_published_assessments(assessments, cr) do
     role = cr.role
 
@@ -851,7 +910,9 @@
          {:allowed_to_unsubmit?, true} <-
            {:allowed_to_unsubmit?,
             role == :admin or bypass or
-              Cadet.Accounts.Query.avenger_of?(cr, submission.student_id)} do
+              Cadet.Accounts.Query.avenger_of?(cr, submission.student_id)},
+         {:is_grading_published?, false} <-
+           {:is_grading_published?, submission.is_grading_published} do
       Multi.new()
       |> Multi.run(
         :rollback_submission,
@@ -893,7 +954,7 @@
       end)
       |> Repo.transaction()
 
-      Cadet.Accounts.Notifications.handle_unsubmit_notifications(
+      Notifications.handle_unsubmit_notifications(
         submission.assessment.id,
         Repo.get(CourseRegistration, submission.student_id)
       )
@@ -915,6 +976,98 @@
       {:allowed_to_unsubmit?, false} ->
         {:error, {:forbidden, "Only Avenger of student or Admin is permitted to unsubmit"}}
 
+      {:is_grading_published?, true} ->
+        {:error, {:forbidden, "Grading has not been unpublished"}}
+
+      _ ->
+        {:error, {:internal_server_error, "Please try again later."}}
+    end
+  end
+
+  # This function changes the is_grading_published field of the submission to false
+  # and sends a notification to the student
+  def unpublish_grading(submission_id, cr = %CourseRegistration{id: course_reg_id, role: role})
+      when is_ecto_id(submission_id) do
+    submission =
+      Submission
+      |> join(:inner, [s], a in assoc(s, :assessment))
+      |> preload([_, a], assessment: a)
+      |> Repo.get(submission_id)
+
+    # allows staff to unpublish own assessment
+    bypass = role in @bypass_closed_roles and submission.student_id == course_reg_id
+
+    with {:submission_found?, true} <- {:submission_found?, is_map(submission)},
+         {:allowed_to_unpublish?, true} <-
+           {:allowed_to_unpublish?,
+            role == :admin or bypass or
+              Cadet.Accounts.Query.avenger_of?(cr, submission.student_id)} do
+      submission
+      |> Submission.changeset(%{is_grading_published: false})
+      |> Repo.update()
+
+      Notifications.handle_unpublish_grades_notifications(
+        submission.assessment.id,
+        Repo.get(CourseRegistration, submission.student_id)
+      )
+
+      {:ok, nil}
+    else
+      {:submission_found?, false} ->
+        {:error, {:not_found, "Submission not found"}}
+
+      {:allowed_to_unpublish?, false} ->
+        {:error,
+         {:forbidden, "Only Avenger of student or Admin is permitted to unpublish grading"}}
+
+      _ ->
+        {:error, {:internal_server_error, "Please try again later."}}
+    end
+  end
+
+  # This function changes the is_grading_published field of the submission to true
+  # only if all the answers are graded
+  # and sends a notification to the student
+  def publish_grading(submission_id, cr = %CourseRegistration{id: course_reg_id, role: role})
+      when is_ecto_id(submission_id) do
+    submission =
+      Submission
+      |> join(:inner, [s], a in assoc(s, :assessment))
+      |> preload([_, a], assessment: a)
+      |> Repo.get(submission_id)
+
+    # allows staff to publish own assessment
+    bypass = role in @bypass_closed_roles and submission.student_id == course_reg_id
+
+    with {:submission_found?, true} <- {:submission_found?, is_map(submission)},
+         {:status, :submitted} <- {:status, submission.status},
+         {:allowed_to_publish?, true} <-
+           {:allowed_to_publish?,
+            role == :admin or bypass or
+              Cadet.Accounts.Query.avenger_of?(cr, submission.student_id)} do
+      submission
+      |> Submission.changeset(%{is_grading_published: true})
+      |> Repo.update()
+
+      Notifications.write_notification_when_graded(
+        submission.id,
+        :graded
+      )
+
+      {:ok, nil}
+    else
+      {:submission_found?, false} ->
+        {:error, {:not_found, "Submission not found"}}
+
+      {:status, :attempting} ->
+        {:error, {:bad_request, "Some questions have not been attempted"}}
+
+      {:status, :attempted} ->
+        {:error, {:bad_request, "Assessment has not been submitted"}}
+
+      {:allowed_to_publish?, false} ->
+        {:error, {:forbidden, "Only Avenger of student or Admin is permitted to publish grading"}}
+
       _ ->
         {:error, {:internal_server_error, "Please try again later."}}
     end
@@ -1401,6 +1554,7 @@
           unsubmitted_by_id: s.unsubmitted_by_id,
           student_id: s.student_id,
           assessment_id: s.assessment_id,
+          is_grading_published: s.is_grading_published,
           xp: ans.xp,
           xp_adjustment: ans.xp_adjustment,
           graded_count: ans.graded_count,
@@ -1456,6 +1610,9 @@
       {"notFullyGraded", "true"}, dynamic ->
         dynamic([ans: ans, asst: asst], ^dynamic and asst.question_count > ans.graded_count)
 
+      {"notPublished", "true"}, dynamic ->
+        dynamic([submission], ^dynamic and not submission.is_grading_published)
+
       {_, _}, dynamic ->
         dynamic
     end)
@@ -1625,7 +1782,7 @@
     end
   end
 
   defp is_fully_graded?(%Answer{submission_id: submission_id}) do
     submission =
       Submission
       |> Repo.get_by(id: submission_id)
@@ -1681,12 +1838,7 @@
          {:valid, changeset = %Ecto.Changeset{valid?: true}} <-
            {:valid, Answer.grading_changeset(answer, attrs)},
          {:ok, _} <- Repo.update(changeset) do
-      if is_fully_graded?(answer) and not is_own_submission do
-        # Every answer in this submission has been graded manually
-        Notifications.write_notification_when_graded(submission_id, :graded)
-      else
-        {:ok, nil}
-      end
+      {:ok, nil}
     else
       {:answer_found?, false} ->
         {:error, {:bad_request, "Answer not found or user not permitted to grade."}}

lib/cadet/assessments/submission.ex

@@ -17,6 +17,7 @@ defmodule Cadet.Assessments.Submission do
     field(:graded_count, :integer, virtual: true, default: 0)
     field(:grading_status, :string, virtual: true)
     field(:unsubmitted_at, :utc_datetime_usec)
+    field(:is_grading_published, :boolean, default: false)
 
     belongs_to(:assessment, Assessment)
     belongs_to(:student, CourseRegistration)
@@ -26,7 +27,7 @@ defmodule Cadet.Assessments.Submission do
     timestamps()
   end
 
-  @required_fields ~w(student_id assessment_id status)a
+  @required_fields ~w(student_id assessment_id status is_grading_published)a
   @optional_fields ~w(xp_bonus unsubmitted_by_id unsubmitted_at)a
 
   def changeset(submission, params) do

lib/cadet/devices/devices.ex

@@ -208,7 +208,7 @@ defmodule Cadet.Devices do
               },
               300,
               [],
-              ''
+              ~c""
             )
 
           # ExAws includes the session token in the signed payload and doesn't allow

lib/cadet_web/admin_controllers/admin_assets_controller.ex

@@ -22,7 +22,7 @@ defmodule CadetWeb.AdminAssetsController do
 
     case Assets.delete_object(Courses.assets_prefix(course_reg.course), foldername, filename) do
       {:error, {status, message}} -> conn |> put_status(status) |> text(message)
-      _ -> conn |> put_status(204) |> text('')
+      _ -> conn |> put_status(204) |> text(~c"")
     end
   end
 

lib/cadet_web/admin_controllers/admin_courses_controller.ex

@@ -143,7 +143,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/admin_controllers/admin_grading_controller.ex

@@ -81,6 +81,34 @@ defmodule CadetWeb.AdminGradingController do
     end
   end
 
+  def unpublish_grades(conn, %{"submissionid" => submission_id}) when is_ecto_id(submission_id) do
+    course_reg = conn.assigns[:course_reg]
+
+    case Assessments.unpublish_grading(submission_id, course_reg) do
+      {:ok, nil} ->
+        text(conn, "OK")
+
+      {:error, {status, message}} ->
+        conn
+        |> put_status(status)
+        |> text(message)
+    end
+  end
+
+  def publish_grades(conn, %{"submissionid" => submission_id}) when is_ecto_id(submission_id) do
+    course_reg = conn.assigns[:course_reg]
+
+    case Assessments.publish_grading(submission_id, course_reg) do
+      {:ok, nil} ->
+        text(conn, "OK")
+
+      {:error, {status, message}} ->
+        conn
+        |> put_status(status)
+        |> text(message)
+    end
+  end
+
   def autograde_submission(conn, %{"submissionid" => submission_id}) do
     course_reg = conn.assigns[:course_reg]
 
@@ -276,6 +304,8 @@ defmodule CadetWeb.AdminGradingController do
 
             unsubmittedBy(Schema.ref(:GraderInfo))
             unsubmittedAt(:string, "Last unsubmitted at", format: "date-time", required: false)
+
+            isGradingPublished(:boolean, "Whether the grading is published", required: true)
           end
         end,
       AssessmentInfo: