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
+  :unpublishedGrading
 ])

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, :unpublishedGrading])
     |> 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: :unpublishedGrading,
+      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, default: false)
     field(:title, :string)
     field(:is_published, :boolean, default: false)
     field(:summary_short, :string)

lib/cadet/assessments/assessments.ex

@@ -91,6 +91,7 @@ defmodule Cadet.Assessments do
     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], %{
@@ -248,6 +249,14 @@ defmodule Cadet.Assessments do
         Answer
         |> join(:inner, [a], s in assoc(a, :submission))
         |> where([_, s], s.student_id == ^course_reg.id)
+        # change a.xp and a.xp_adjustment to 0
+        # if a.is_grading_published is false and return all answers
+        |> select([a, s], %{
+          a
+          | xp: fragment("CASE WHEN ? THEN ? ELSE 0 END", s.is_grading_published, a.xp),
+            xp_adjustment:
+              fragment("CASE WHEN ? THEN ? ELSE 0 END", s.is_grading_published, a.xp_adjustment)
+        })
 
       questions =
         Question
@@ -298,6 +307,11 @@ defmodule Cadet.Assessments do
       |> where([s], s.student_id == ^cr.id)
       |> select([s], [:assessment_id, :status])
 
+    grading_published_status =
+      Submission
+      |> where([s], s.student_id == ^cr.id)
+      |> select([s], [:assessment_id, :is_grading_published])
+
     assessments =
       cr.course_id
       |> Query.all_assessments_with_aggregates()
@@ -309,11 +323,15 @@ defmodule Cadet.Assessments do
         on: a.id == sa.assessment_id
       )
       |> join(:left, [a, _], s in subquery(submission_status), on: a.id == s.assessment_id)
-      |> select([a, sa, s], %{
+      |> join(:left, [a, _, _], gp in subquery(grading_published_status),
+        on: a.id == gp.assessment_id
+      )
+      |> select([a, sa, s, gp], %{
         a
-        | xp: sa.xp,
+        | xp: fragment("CASE WHEN ? THEN ? ELSE 0 END", gp.is_grading_published, sa.xp),
           graded_count: sa.graded_count,
-          user_status: s.status
+          user_status: s.status,
+          is_grading_published: gp.is_grading_published
       })
       |> filter_published_assessments(cr)
       |> order_by(:open_at)
@@ -817,7 +835,7 @@ defmodule Cadet.Assessments do
       end)
       |> Repo.transaction()
 
-      Cadet.Accounts.Notifications.handle_unsubmit_notifications(
+      Notifications.handle_unsubmit_notifications(
         submission.assessment.id,
         Repo.get(CourseRegistration, submission.student_id)
       )
@@ -844,6 +862,114 @@ defmodule Cadet.Assessments do
     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
+      Multi.new()
+      |> Multi.run(
+        :unpublish_grading,
+        fn _repo, _ ->
+          submission
+          |> Submission.changeset(%{is_grading_published: false})
+          |> Repo.update()
+        end
+      )
+      |> Repo.transaction()
+
+      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"}}
+
+      {:is_open?, false} ->
+        {:error, {:forbidden, "Assessment not open"}}
+
+      {:allowed_to_unpublish?, false} ->
+        {:error, {:forbidden, "Only Avenger of student 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
+      Multi.new()
+      |> Multi.run(
+        :publish_grading,
+        fn _repo, _ ->
+          submission
+          |> Submission.changeset(%{is_grading_published: true})
+          |> Repo.update()
+        end
+      )
+      |> Repo.transaction()
+
+      Notifications.write_notification_when_graded(
+        submission.id,
+        :graded
+      )
+
+      {:ok, nil}
+    else
+      {:submission_found?, false} ->
+        {:error, {:not_found, "Submission not found"}}
+
+      {:is_open?, false} ->
+        {:error, {:forbidden, "Assessment not open"}}
+
+      {: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 is permitted to publish grading"}}
+
+      _ ->
+        {:error, {:internal_server_error, "Please try again later."}}
+    end
+  end
+
   @spec update_submission_status_and_xp_bonus(Submission.t()) ::
           {:ok, Submission.t()} | {:error, Ecto.Changeset.t()}
   defp update_submission_status_and_xp_bonus(submission = %Submission{}) do
@@ -1197,6 +1323,7 @@ defmodule Cadet.Assessments do
                s."xpAdjustment",
                s."xpBonus",
                s."gradedCount",
+               s."isGradingPublished",
                assts.jsn as assessment,
                students.jsn as student,
                unsubmitters.jsn as "unsubmittedBy"
@@ -1211,7 +1338,8 @@ defmodule Cadet.Assessments do
                  sum(ans.xp) as xp,
                  sum(ans.xp_adjustment) as "xpAdjustment",
                  s.xp_bonus as "xpBonus",
-                 count(ans.id) filter (where ans.grader_id is not null) as "gradedCount"
+                 count(ans.id) filter (where ans.grader_id is not null) as "gradedCount",
+                 s.is_grading_published as "isGradingPublished"
                from submissions s
                  left join
                  answers ans on s.id = ans.submission_id
@@ -1367,12 +1495,7 @@ defmodule Cadet.Assessments do
          {: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

@@ -142,7 +142,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

@@ -82,6 +82,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]
 
@@ -277,6 +305,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:

lib/cadet_web/admin_controllers/admin_stories_controller.ex

@@ -12,7 +12,7 @@ defmodule CadetWeb.AdminStoriesController do
 
     case result do
       {:ok, _story} ->
-        conn |> put_status(200) |> text('')
+        conn |> put_status(200) |> text(~c"")
 
       {:error, {status, message}} ->
         conn
@@ -29,7 +29,7 @@ defmodule CadetWeb.AdminStoriesController do
 
     case result do
       {:ok, _story} ->
-        conn |> put_status(200) |> text('')
+        conn |> put_status(200) |> text(~c"")
 
       {:error, {status, message}} ->
         conn
@@ -43,7 +43,7 @@ defmodule CadetWeb.AdminStoriesController do
 
     case result do
       {:ok, _nil} ->
-        conn |> put_status(204) |> text('')
+        conn |> put_status(204) |> text(~c"")
 
       {:error, {status, message}} ->
         conn