refactor(delivery): rename type -> thread in notification

Author: mydearxym

config/config.exs

@@ -51,7 +51,7 @@ config :groupher_server, :general,
   # others
   # 在这个时间段内，多条提醒消息将被合并为一条
   notify_group_interval_hour: 1,
-  nofity_types: [:upvote, :comment, :reply, :collect, :follow]
+  nofity_actions: [:upvote, :comment, :reply, :collect, :follow]
 
 config :groupher_server, :customization,
   theme: "cyan",

lib/groupher_server/cms/delegates/comment_curd.ex

@@ -114,8 +114,9 @@ defmodule GroupherServer.CMS.Delegate.CommentCurd do
           false -> CMS.update_active_timestamp(thread, article)
         end
       end)
-      |> Multi.run(:after_hooks, fn _, %{create_comment: create_comment} ->
-        Later.run({Hooks.Cite, :handle, [create_comment]})
+      |> Multi.run(:after_hooks, fn _, %{create_comment: comment} ->
+        Later.run({Hooks.Cite, :handle, [comment]})
+        Later.run({Hooks.Notify, :handle, [:comment, comment, user]})
       end)
       |> Repo.transaction()
       |> result()

lib/groupher_server/cms/delegates/helper.ex

@@ -41,6 +41,15 @@ defmodule GroupherServer.CMS.Delegate.Helper do
     |> done
   end
 
+  @doc "get parent article of a comment"
+  def parent_article_of(%Comment{} = comment) do
+    article_thread = comment.thread |> String.downcase() |> String.to_atom()
+
+    comment |> Repo.preload(article_thread) |> Map.get(article_thread) |> done
+  end
+
+  def parent_article_of(_), do: {:error, "only support comment"}
+
   #######
   # emotion related
   #######

lib/groupher_server/cms/delegates/hooks/notify.ex

@@ -3,71 +3,90 @@ defmodule GroupherServer.CMS.Delegate.Hooks.Notify do
   notify hooks, for upvote, collect, comment, reply
   """
   import Helper.Utils, only: [thread_of_article: 1]
-  import GroupherServer.CMS.Delegate.Helper, only: [preload_author: 1]
+  import GroupherServer.CMS.Delegate.Helper, only: [preload_author: 1, parent_article_of: 1]
 
-  alias GroupherServer.{Accounts, CMS, Delivery, Repo}
+  alias GroupherServer.{Accounts, CMS, Delivery}
 
   alias Accounts.Model.User
   alias CMS.Model.Comment
 
-  def handle(:undo, action, %Comment{} = comment, %User{} = from_user) do
-    article_thread = comment.thread |> String.downcase() |> String.to_atom()
-    article = comment |> Repo.preload(article_thread) |> Map.get(article_thread)
+  # 发布评论是特殊情况，单独处理
+  def handle(:comment, %Comment{} = comment, %User{} = from_user) do
+    {:ok, article} = parent_article_of(comment)
+    {:ok, article} = preload_author(article)
+    {:ok, thread} = thread_of_article(article)
 
     notify_attrs = %{
-      action: action,
-      type: :comment,
+      action: :comment,
+      thread: thread,
       article_id: article.id,
       title: article.title,
       comment_id: comment.id,
-      user_id: comment.author_id
+      # NOTE: 这里是提醒该评论文章的作者，不是评论本身的作者
+      user_id: article.author.user.id
     }
 
-    Delivery.revoke(:notify, notify_attrs, from_user)
+    Delivery.send(:notify, notify_attrs, from_user)
   end
 
-  def handle(:undo, action, article, %User{} = from_user) do
+  def handle(action, %Comment{} = comment, %User{} = from_user) do
+    {:ok, article} = parent_article_of(comment)
+    {:ok, thread} = thread_of_article(article)
+
+    notify_attrs = %{
+      action: action,
+      thread: thread,
+      article_id: article.id,
+      title: article.title,
+      user_id: comment.author_id,
+      comment_id: comment.id
+    }
+
+    Delivery.send(:notify, notify_attrs, from_user)
+  end
+
+  def handle(action, article, %User{} = from_user) do
     {:ok, article} = preload_author(article)
     {:ok, thread} = thread_of_article(article)
 
     notify_attrs = %{
       action: action,
-      type: thread,
+      thread: thread,
       article_id: article.id,
+      title: article.title,
       user_id: article.author.user.id
     }
 
-    Delivery.revoke(:notify, notify_attrs, from_user)
+    Delivery.send(:notify, notify_attrs, from_user)
   end
 
-  def handle(action, %Comment{} = comment, %User{} = from_user) do
-    article_thread = comment.thread |> String.downcase() |> String.to_atom()
-    article = comment |> Repo.preload(article_thread) |> Map.get(article_thread)
+  def handle(:undo, action, %Comment{} = comment, %User{} = from_user) do
+    {:ok, article} = parent_article_of(comment)
+    {:ok, thread} = thread_of_article(article)
 
     notify_attrs = %{
       action: action,
-      type: :comment,
+      thread: thread,
       article_id: article.id,
       title: article.title,
       comment_id: comment.id,
       user_id: comment.author_id
     }
 
-    Delivery.send(:notify, notify_attrs, from_user)
+    Delivery.revoke(:notify, notify_attrs, from_user)
   end
 
-  def handle(action, article, %User{} = from_user) do
+  def handle(:undo, action, article, %User{} = from_user) do
     {:ok, article} = preload_author(article)
     {:ok, thread} = thread_of_article(article)
 
     notify_attrs = %{
       action: action,
-      type: thread,
+      thread: thread,
       article_id: article.id,
-      title: article.title,
       user_id: article.author.user.id
     }
 
-    Delivery.send(:notify, notify_attrs, from_user)
+    Delivery.revoke(:notify, notify_attrs, from_user)
   end
 end

lib/groupher_server/delivery/delegates/notification.ex

@@ -14,11 +14,11 @@ defmodule GroupherServer.Delivery.Delegate.Notification do
   alias Accounts.Model.User
   alias Helper.ORM
 
-  @supported_notify_type get_config(:general, :nofity_types)
+  @notify_actions get_config(:general, :nofity_actions)
   @notify_group_interval_hour get_config(:general, :notify_group_interval_hour)
 
   def handle(%{action: action, user_id: user_id} = attrs, %User{} = from_user) do
-    with true <- action in @supported_notify_type,
+    with true <- action in @notify_actions,
          true <- is_valid?(attrs),
          true <- user_id !== from_user.id do
       from_user = from_user |> Map.take([:login, :nickname]) |> Map.put(:user_id, from_user.id)
@@ -90,18 +90,21 @@ defmodule GroupherServer.Delivery.Delegate.Notification do
 
   defp find_exist_notify(%{comment_id: comment_id} = attrs, opt)
        when not is_nil(comment_id) do
-    ~m(type article_id comment_id)a = atom_values_to_upcase(attrs)
+    ~m(thread article_id comment_id)a = atom_values_to_upcase(attrs)
 
     Notification
-    |> where([n], n.type == ^type and n.article_id == ^article_id and n.comment_id == ^comment_id)
+    |> where(
+      [n],
+      n.thread == ^thread and n.article_id == ^article_id and n.comment_id == ^comment_id
+    )
     |> do_find_exist_notify(attrs, opt)
   end
 
   defp find_exist_notify(attrs, opt) do
-    ~m(type article_id)a = atom_values_to_upcase(attrs)
+    ~m(thread article_id)a = atom_values_to_upcase(attrs)
 
     Notification
-    |> where([n], n.type == ^type and n.article_id == ^article_id)
+    |> where([n], n.thread == ^thread and n.article_id == ^article_id)
     |> do_find_exist_notify(attrs, opt)
   end
 
@@ -139,29 +142,24 @@ defmodule GroupherServer.Delivery.Delegate.Notification do
     |> done
   end
 
-  # [:upvote, :comment, :reply, :collect, :follow]
-  defp is_valid?(%{action: :upvote, type: :comment} = attrs) do
-    attrs |> all_exist?([:article_id, :type, :title, :comment_id, :user_id])
-  end
+  defp is_valid?(%{action: :follow} = attrs), do: attrs |> all_exist?([:user_id])
 
   defp is_valid?(%{action: :upvote} = attrs) do
-    attrs |> all_exist?([:article_id, :type, :title, :user_id])
+    attrs |> all_exist?([:article_id, :thread, :title, :user_id])
   end
 
-  defp is_valid?(%{action: :comment} = attrs) do
-    attrs |> all_exist?([:article_id, :type, :title, :comment_id, :user_id])
+  defp is_valid?(%{action: :collect} = attrs) do
+    attrs |> all_exist?([:article_id, :thread, :title, :user_id])
   end
 
-  defp is_valid?(%{action: :reply} = attrs) do
-    attrs |> all_exist?([:article_id, :type, :title, :comment_id, :user_id])
+  defp is_valid?(%{action: :comment} = attrs) do
+    attrs |> all_exist?([:article_id, :thread, :title, :comment_id, :user_id])
   end
 
-  defp is_valid?(%{action: :collect} = attrs) do
-    attrs |> all_exist?([:article_id, :type, :title, :user_id])
+  defp is_valid?(%{action: :reply} = attrs) do
+    attrs |> all_exist?([:article_id, :thread, :title, :comment_id, :user_id])
   end
 
-  defp is_valid?(%{action: :follow} = attrs), do: attrs |> all_exist?([:user_id])
-
   defp is_valid?(_), do: false
 
   # 确保 key 存在，并且不为 nil

lib/groupher_server/delivery/models/notification.ex

@@ -10,13 +10,13 @@ defmodule GroupherServer.Delivery.Model.Notification do
   alias CMS.Model.Embeds
 
   @required_fields ~w(user_id action)a
-  @optional_fields ~w(type article_id comment_id title read)a
+  @optional_fields ~w(thread article_id comment_id title read)a
 
   @type t :: %Notification{}
   schema "notifications" do
     belongs_to(:user, User)
     # article or comment
-    field(:type, :string)
+    field(:thread, :string)
     field(:article_id, :id)
     field(:title, :string)
     # optional comment id

priv/repo/migrations/20210620091612_rename_notifications_type_to_thread.exs

@@ -0,0 +1,7 @@
+defmodule GroupherServer.Repo.Migrations.RenameNotificationsTypeToThread do
+  use Ecto.Migration
+
+  def change do
+    rename(table(:notifications), :type, to: :thread)
+  end
+end