Add Endpoints for Notifications

lib/cadet/notifications.ex

@@ -62,7 +62,76 @@ defmodule Cadet.Notifications do
         where(query, [c], c.assessment_config_id == ^assconfig_id)
       end
 
-    Repo.one(query)
+    config = Repo.one(query)
+
+    if config != nil do
+      config
+    else
+      IO.puts(
+        "No NotificationConfig found for Course #{course_id} and NotificationType #{notification_type_id}"
+      )
+
+      nil
+    end
+  end
+
+  def get_notification_config!(id), do: Repo.get!(NotificationConfig, id)
+
+  @doc """
+  Gets all notification configs that belong to a course
+  """
+  def get_notification_configs(course_id) do
+    query =
+      from(n in Cadet.Notifications.NotificationConfig,
+        where: n.course_id == ^course_id
+      )
+
+    query
+    |> Repo.all()
+    |> Repo.preload([:notification_type, :course, :assessment_config, :time_options])
+  end
+
+  @doc """
+  Gets all notification configs with preferences that
+  1. belongs to the course of the course reg,
+  2. only notifications that it can configure based on course reg's role
+  """
+  def get_configurable_notification_configs(cr_id) do
+    cr = Repo.get(Cadet.Accounts.CourseRegistration, cr_id)
+
+    case cr do
+      nil ->
+        nil
+
+      _ ->
+        is_staff = cr.role == :staff
+
+        query =
+          from(n in Cadet.Notifications.NotificationConfig,
+            join: ntype in Cadet.Notifications.NotificationType,
+            on: n.notification_type_id == ntype.id,
+            join: c in Cadet.Courses.Course,
+            on: n.course_id == c.id,
+            left_join: ac in Cadet.Courses.AssessmentConfig,
+            on: n.assessment_config_id == ac.id,
+            left_join: p in Cadet.Notifications.NotificationPreference,
+            on: p.notification_config_id == n.id,
+            where:
+              ntype.for_staff == ^is_staff and
+                n.course_id == ^cr.course_id and
+                (p.course_reg_id == ^cr.id or is_nil(p.course_reg_id))
+          )
+
+        query
+        |> Repo.all()
+        |> Repo.preload([
+          :notification_type,
+          :course,
+          :assessment_config,
+          :time_options,
+          :notification_preferences
+        ])
+    end
   end
 
   @doc """
@@ -83,6 +152,17 @@ defmodule Cadet.Notifications do
     |> Repo.update()
   end
 
+  def update_many_noti_configs(noti_configs) when is_list(noti_configs) do
+    Repo.transaction(fn ->
+      for noti_config <- noti_configs do
+        case Repo.update(noti_config) do
+          {:ok, res} -> res
+          {:error, error} -> Repo.rollback(error)
+        end
+      end
+    end)
+  end
+
   @doc """
   Returns an `%Ecto.Changeset{}` for tracking notification_config changes.
 
@@ -112,6 +192,23 @@ defmodule Cadet.Notifications do
   """
   def get_time_option!(id), do: Repo.get!(TimeOption, id)
 
+  @doc """
+  Gets all time options for a notification config
+  """
+  def get_time_options_for_config(notification_config_id) do
+    query =
+      from(to in Cadet.Notifications.TimeOption,
+        join: nc in Cadet.Notifications.NotificationConfig,
+        on: to.notification_config_id == nc.id,
+        where: nc.id == ^notification_config_id
+      )
+
+    Repo.all(query)
+  end
+
+  @doc """
+  Gets all time options for an assessment config and notification type
+  """
   def get_time_options_for_assessment(assessment_config_id, notification_type_id) do
     query =
       from(ac in Cadet.Courses.AssessmentConfig,
@@ -126,6 +223,9 @@ defmodule Cadet.Notifications do
     Repo.all(query)
   end
 
+  @doc """
+  Gets the default time options for an assessment config and notification type
+  """
   def get_default_time_option_for_assessment!(assessment_config_id, notification_type_id) do
     query =
       from(ac in Cadet.Courses.AssessmentConfig,
@@ -160,6 +260,34 @@ defmodule Cadet.Notifications do
     |> Repo.insert()
   end
 
+  def upsert_many_time_options(time_options) when is_list(time_options) do
+    Repo.transaction(fn ->
+      for to <- time_options do
+        case Repo.insert(to,
+               on_conflict: {:replace, [:is_default]},
+               conflict_target: [:minutes, :notification_config_id]
+             ) do
+          {:ok, time_option} -> time_option
+          {:error, error} -> Repo.rollback(error)
+        end
+      end
+    end)
+  end
+
+  def upsert_many_noti_preferences(noti_prefs) when is_list(noti_prefs) do
+    Repo.transaction(fn ->
+      for np <- noti_prefs do
+        case Repo.insert(np,
+               on_conflict: {:replace, [:is_enabled, :time_option_id]},
+               conflict_target: [:course_reg_id, :notification_config_id]
+             ) do
+          {:ok, noti_pref} -> noti_pref
+          {:error, error} -> Repo.rollback(error)
+        end
+      end
+    end)
+  end
+
   @doc """
   Deletes a time_option.
 
@@ -176,6 +304,41 @@ defmodule Cadet.Notifications do
     Repo.delete(time_option)
   end
 
+  def delete_many_time_options(to_ids) when is_list(to_ids) do
+    Repo.transaction(fn ->
+      for to_id <- to_ids do
+        time_option = Repo.get(TimeOption, to_id)
+
+        if is_nil(time_option) do
+          Repo.rollback("Time option do not exist")
+        else
+          case Repo.delete(time_option) do
+            {:ok, time_option} -> time_option
+            {:delete_error, error} -> Repo.rollback(error)
+          end
+        end
+      end
+    end)
+  end
+
+  @doc """
+  Gets the notification preference based from its id
+  """
+  def get_notification_preference!(notification_preference_id) do
+    query =
+      from(np in NotificationPreference,
+        left_join: to in TimeOption,
+        on: to.id == np.time_option_id,
+        where: np.id == ^notification_preference_id,
+        preload: :time_option
+      )
+
+    Repo.one!(query)
+  end
+
+  @doc """
+  Gets the notification preference based from notification type and course reg
+  """
   def get_notification_preference(notification_type_id, course_reg_id) do
     query =
       from(np in NotificationPreference,

lib/cadet/notifications/notification_config.ex

@@ -5,7 +5,7 @@ defmodule Cadet.Notifications.NotificationConfig do
   use Ecto.Schema
   import Ecto.Changeset
   alias Cadet.Courses.{Course, AssessmentConfig}
-  alias Cadet.Notifications.NotificationType
+  alias Cadet.Notifications.{NotificationType, TimeOption, NotificationPreference}
 
   schema "notification_configs" do
     field(:is_enabled, :boolean, default: false)
@@ -14,6 +14,9 @@ defmodule Cadet.Notifications.NotificationConfig do
     belongs_to(:course, Course)
     belongs_to(:assessment_config, AssessmentConfig)
 
+    has_many(:time_options, TimeOption)
+    has_many(:notification_preferences, NotificationPreference)
+
     timestamps()
   end
 

lib/cadet/notifications/notification_preference.ex

@@ -20,8 +20,9 @@ defmodule Cadet.Notifications.NotificationPreference do
   @doc false
   def changeset(notification_preference, attrs) do
     notification_preference
-    |> cast(attrs, [:is_enabled, :notification_config_id, :course_reg_id])
+    |> cast(attrs, [:is_enabled, :notification_config_id, :course_reg_id, :time_option_id])
     |> validate_required([:notification_config_id, :course_reg_id])
+    |> unique_constraint(:unique_course_reg_and_config, name: :single_preference_per_config)
     |> prevent_nil_is_enabled()
   end
 

lib/cadet/notifications/notification_type.ex

@@ -12,15 +12,16 @@ defmodule Cadet.Notifications.NotificationType do
     field(:is_enabled, :boolean, default: false)
     field(:name, :string)
     field(:template_file_name, :string)
+    field(:for_staff, :boolean)
 
     timestamps()
   end
 
   @doc false
   def changeset(notification_type, attrs) do
     notification_type
-    |> cast(attrs, [:name, :template_file_name, :is_enabled, :is_autopopulated])
-    |> validate_required([:name, :template_file_name, :is_autopopulated])
+    |> cast(attrs, [:name, :template_file_name, :is_enabled, :is_autopopulated, :for_staff])
+    |> validate_required([:name, :template_file_name, :is_autopopulated, :for_staff])
     |> unique_constraint(:name)
     |> prevent_nil_is_enabled()
   end

lib/cadet/workers/NotificationWorker.ex

@@ -73,31 +73,35 @@ defmodule Cadet.Workers.NotificationWorker do
           for avenger_cr <- avengers_crs do
             avenger = Cadet.Accounts.get_user(avenger_cr.user_id)
 
-            ungraded_submissions =
-              Jason.decode!(
-                elem(
-                  Cadet.Assessments.all_submissions_by_grader_for_index(avenger_cr, true, true),
-                  1
+            if is_user_enabled(notification_type_id, avenger_cr.id) do
+              ungraded_submissions =
+                Jason.decode!(
+                  elem(
+                    Cadet.Assessments.all_submissions_by_grader_for_index(avenger_cr, true, true),
+                    1
+                  )
                 )
-              )
 
-            if length(ungraded_submissions) < ungraded_threshold do
-              IO.puts("[AVENGER_BACKLOG] below threshold!")
-            else
-              IO.puts("[AVENGER_BACKLOG] SENDING_OUT")
+              if length(ungraded_submissions) < ungraded_threshold do
+                IO.puts("[AVENGER_BACKLOG] below threshold!")
+              else
+                IO.puts("[AVENGER_BACKLOG] SENDING_OUT")
 
-              email =
-                Email.avenger_backlog_email(
-                  ntype.template_file_name,
-                  avenger,
-                  ungraded_submissions
-                )
+                email =
+                  Email.avenger_backlog_email(
+                    ntype.template_file_name,
+                    avenger,
+                    ungraded_submissions
+                  )
 
-              {status, email} = Mailer.deliver_now(email)
+                {status, email} = Mailer.deliver_now(email)
 
-              if status == :ok do
-                Notifications.create_sent_notification(avenger_cr.id, email.html_body)
+                if status == :ok do
+                  Notifications.create_sent_notification(avenger_cr.id, email.html_body)
+                end
               end
+            else
+              IO.puts("[ASSESSMENT_SUBMISSION] user-level disabled")
             end
           end
         else