Notification System Version2（backend)

lib/cadet/notifications.ex

@@ -4,14 +4,16 @@ defmodule Cadet.Notifications do
   """
 
   import Ecto.Query, warn: false
+  require Logger
   alias Cadet.Repo
 
   alias Cadet.Notifications.{
     NotificationType,
     NotificationConfig,
     SentNotification,
     TimeOption,
-    NotificationPreference
+    NotificationPreference,
+    PreferableTime
   }
 
   @doc """
@@ -49,20 +51,94 @@ defmodule Cadet.Notifications do
 
   def get_notification_config!(notification_type_id, course_id, assconfig_id) do
     query =
-      from(n in Cadet.Notifications.NotificationConfig,
-        join: ntype in Cadet.Notifications.NotificationType,
-        on: n.notification_type_id == ntype.id,
-        where: n.notification_type_id == ^notification_type_id and n.course_id == ^course_id
+      Cadet.Notifications.NotificationConfig
+      |> join(:inner, [n], ntype in Cadet.Notifications.NotificationType,
+        on: n.notification_type_id == ntype.id
       )
+      |> where([n], n.notification_type_id == ^notification_type_id and n.course_id == ^course_id)
+      |> filter_assconfig_id(assconfig_id)
+      |> Repo.one()
 
+    case query do
+      nil ->
+        Logger.error(
+          "No NotificationConfig found for Course #{course_id} and NotificationType #{notification_type_id}"
+        )
+
+        nil
+
+      config ->
+        config
+    end
+  end
+
+  defp filter_assconfig_id(query, nil) do
+    query |> where([c], is_nil(c.assessment_config_id))
+  end
+
+  defp filter_assconfig_id(query, assconfig_id) do
+    query |> where([c], c.assessment_config_id == ^assconfig_id)
+  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 =
-      if is_nil(assconfig_id) do
-        where(query, [c], is_nil(c.assessment_config_id))
-      else
-        where(query, [c], c.assessment_config_id == ^assconfig_id)
-      end
+      Cadet.Notifications.NotificationConfig
+      |> where([n], n.course_id == ^course_id)
+      |> Repo.all()
 
-    Repo.one(query)
+    query
+    |> 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 =
+          Cadet.Notifications.NotificationConfig
+          |> join(:inner, [n], ntype in Cadet.Notifications.NotificationType,
+            on: n.notification_type_id == ntype.id
+          )
+          |> join(:inner, [n], c in Cadet.Courses.Course, on: n.course_id == c.id)
+          |> join(:left, [n], ac in Cadet.Courses.AssessmentConfig,
+            on: n.assessment_config_id == ac.id
+          )
+          |> join(:left, [n], p in Cadet.Notifications.NotificationPreference,
+            on: p.notification_config_id == n.id
+          )
+          |> where(
+            [n, ntype, c, ac, p],
+            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))
+          )
+          |> Repo.all()
+
+        query
+        |> Repo.preload([
+          :notification_type,
+          :course,
+          :assessment_config,
+          :time_options,
+          :notification_preferences
+        ])
+    end
   end
 
   @doc """
@@ -83,6 +159,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 +199,24 @@ 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 =
+      Cadet.Notifications.TimeOption
+      |> join(:inner, [to], nc in Cadet.Notifications.NotificationConfig,
+        on: to.notification_config_id == nc.id
+      )
+      |> where([to, nc], 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 +231,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 +268,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 +312,42 @@ 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)
+
+        case time_option do
+          nil ->
+            Repo.rollback("Time option does not exist")
+
+          _ ->
+            case Repo.delete(time_option) do
+              {:ok, deleted_time_option} -> deleted_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 =
+      NotificationPreference
+      |> join(:left, [np], to in TimeOption, on: to.id == np.time_option_id)
+      |> where([np, to], 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,
@@ -276,33 +448,84 @@ defmodule Cadet.Notifications do
     |> Repo.insert()
   end
 
+  # PreferableTime
   @doc """
-  Returns the list of sent_notifications.
-
-  ## Examples
-
-      iex> list_sent_notifications()
-      [%SentNotification{}, ...]
-
+  Gets the preferable times using id number.
   """
+  def get_preferable_time!(id), do: Repo.get!(PreferableTime, id)
 
-  # def list_sent_notifications do
-  #   Repo.all(SentNotification)
-  # end
-
-  # @doc """
-  # Gets a single sent_notification.
+  @spec get_preferable_times_for_preference(any) :: any
+  @doc """
+  Gets all preferable times for a notification preference
+  """
+  def get_preferable_times_for_preference(notification_preference_id) do
+    query =
+      from(pt in Cadet.Notifications.PreferableTime,
+        join: np in Cadet.Notifications.NotificationPreference,
+        on: pt.notification_preference_id == np.id,
+        where: np.id == ^notification_preference_id
+      )
 
-  # Raises `Ecto.NoResultsError` if the Sent notification does not exist.
+    Repo.all(query)
+  end
 
-  # ## Examples
+  @spec create_preferable_time(
+          :invalid
+          | %{optional(:__struct__) => none, optional(atom | binary) => any}
+        ) :: any
+  @doc """
+  Creates a preferable_time.
+  ## Examples
+      iex> create_preferable_time(%{field: value})
+      {:ok, %TimeOption{}}
+      iex> create_preferable_time(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+  """
+  def create_preferable_time(attrs \\ %{}) do
+    %PreferableTime{}
+    |> PreferableTime.changeset(attrs)
+    |> Repo.insert()
+  end
 
-  #     iex> get_sent_notification!(123)
-  #     %SentNotification{}
+  def upsert_many_preferable_times(preferable_times) when is_list(preferable_times) do
+    Repo.transaction(fn ->
+      for pt <- preferable_times do
+        case Repo.insert(pt,
+               conflict_target: [:minutes, :notification_config_id]
+             ) do
+          {:ok, preferable_time} -> preferable_time
+          {:error, error} -> Repo.rollback(error)
+        end
+      end
+    end)
+  end
 
-  #     iex> get_sent_notification!(456)
-  #     ** (Ecto.NoResultsError)
+  @doc """
+  Deletes a preferable_time.
+  ## Examples
+      iex> delete_preferable_time(preferable_time)
+      {:ok, %PreferableTime{}}
+      iex> delete_preferable_time(preferable_time)
+      {:error, %Ecto.Changeset{}}
+  """
+  def delete_preferable_time(preferable_time = %PreferableTime{}) do
+    Repo.delete(preferable_time)
+  end
 
-  # """
-  # # def get_sent_notification!(id), do: Repo.get!(SentNotification, id)
+  def delete_many_preferable_times(pt_ids) when is_list(pt_ids) do
+    Repo.transaction(fn ->
+      for pt_id <- pt_ids do
+        preferable_time = Repo.get(PreferableTime, pt_id)
+
+        if is_nil(preferable_time) do
+          Repo.rollback("Preferable Time do not exist")
+        else
+          case Repo.delete(preferable_time) do
+            {:ok, preferable_time} -> preferable_time
+            {:delete_error, error} -> Repo.rollback(error)
+          end
+        end
+      end
+    end)
+  end
 end

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