Add Publish Grading Feature

lib/cadet/accounts/notification_type.ex

@@ -3,12 +3,12 @@ import EctoEnum
 defenum(Cadet.Accounts.NotificationType, :notification_type, [
   # Notifications for new assessments
   :new,
-  # Notifications for autograded assessments
-  :autograded,
-  # Notifications for manually graded assessments
-  :graded,
   # Notifications for unsubmitted submissions
   :unsubmitted,
   # Notifications for submitted assessments
-  :submitted
+  :submitted,
+  # Notifications for published grades
+  :published_grading,
+  # Notifications for unpublished grades
+  :unpublished_grading
 ])

lib/cadet/accounts/notifications.ex

@@ -145,18 +145,41 @@ defmodule Cadet.Accounts.Notifications do
           {:ok, Ecto.Schema.t()} | {:error, Ecto.Changeset.t()}
   def handle_unsubmit_notifications(assessment_id, student = %CourseRegistration{})
       when is_ecto_id(assessment_id) do
-    # Fetch and delete all notifications of :autograded and :graded
+    # Fetch and delete all notifications of :unpublished_grading
     # Add new notification :unsubmitted
 
     Notification
     |> where(course_reg_id: ^student.id)
     |> where(assessment_id: ^assessment_id)
-    |> where([n], n.type in ^[:autograded, :graded])
+    |> where([n], n.type in ^[:unpublished_grading])
     |> Repo.delete_all()
 
     write(%{
       type: :unsubmitted,
-      role: student.role,
+      role: :student,
+      course_reg_id: student.id,
+      assessment_id: assessment_id
+    })
+  end
+
+  @doc """
+  Function that handles notifications when a submission grade is unpublished.
+  Deletes all :published notifications and adds a new :unpublished_grading notification.
+  """
+  @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
+    Notification
+    |> where(course_reg_id: ^student.id)
+    |> where(assessment_id: ^assessment_id)
+    |> where([n], n.type in ^[:published_grading])
+    |> Repo.delete_all()
+
+    write(%{
+      type: :unpublished_grading,
+      read: false,
+      role: :student,
       course_reg_id: student.id,
       assessment_id: assessment_id
     })
@@ -166,9 +189,9 @@ defmodule Cadet.Accounts.Notifications do
   Writes a notification that a student's submission has been
   graded successfully. (for the student)
   """
-  @spec write_notification_when_graded(integer(), any()) ::
+  @spec write_notification_when_published(integer(), any()) ::
           {:ok, Ecto.Schema.t()} | {:error, Ecto.Changeset.t()}
-  def write_notification_when_graded(submission_id, type) when type in [:graded, :autograded] do
+  def write_notification_when_published(submission_id, type) when type in [:published_grading] do
     case Repo.get(Submission, submission_id) do
       nil ->
         {:error, %Ecto.Changeset{}}

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)