refactor(notify): mark read & re-org ORM functions

Author: mydearxym

lib/groupher_server/accounts/delegates/profile.ex

@@ -72,8 +72,7 @@ defmodule GroupherServer.Accounts.Delegate.Profile do
   """
   def update_subscribe_count(user_id) do
     with {:ok, user} <- ORM.find(User, user_id) do
-      count_query = from(s in CommunitySubscriber, where: s.user_id == ^user.id)
-      count = Repo.aggregate(count_query, :count)
+      {:ok, count} = from(s in CommunitySubscriber, where: s.user_id == ^user.id) |> ORM.count()
 
       user |> ORM.update(%{subscribed_communities_count: count})
     end

lib/groupher_server/cms/delegates/cited_artiment.ex

@@ -79,8 +79,8 @@ defmodule GroupherServer.CMS.Delegate.CitedArtiment do
   # update article/comment 's citting_count in meta
   defp update_artiment_citing_count(cited_artiments) do
     Enum.all?(cited_artiments, fn cited ->
-      count_query = from(c in CitedArtiment, where: c.cited_by_id == ^cited.cited_by_id)
-      count = Repo.aggregate(count_query, :count)
+      {:ok, count} =
+        from(c in CitedArtiment, where: c.cited_by_id == ^cited.cited_by_id) |> ORM.count()
 
       artiment = cited.artiment
       meta = Map.merge(artiment.meta, %{citing_count: count})

lib/groupher_server/cms/delegates/comment_action.ex

@@ -40,12 +40,11 @@ defmodule GroupherServer.CMS.Delegate.CommentAction do
          {:ok, info} <- match(full_comment.thread) do
       Multi.new()
       |> Multi.run(:checked_pined_comments_count, fn _, _ ->
-        count_query =
+        {:ok, pined_comments_count} =
           from(p in PinnedComment,
             where: field(p, ^info.foreign_key) == ^full_comment.article.id
           )
-
-        pined_comments_count = Repo.aggregate(count_query, :count)
+          |> ORM.count()
 
         case pined_comments_count >= @pinned_comment_limit do
           true -> {:error, "max #{@pinned_comment_limit} pinned comment for each article"}
@@ -163,8 +162,9 @@ defmodule GroupherServer.CMS.Delegate.CommentAction do
         update_upvoted_user_list(comment, user_id, :add)
       end)
       |> Multi.run(:inc_upvotes_count, fn _, %{add_upvoted_user: comment} ->
-        count_query = from(c in CommentUpvote, where: c.comment_id == ^comment.id)
-        upvotes_count = Repo.aggregate(count_query, :count)
+        {:ok, upvotes_count} =
+          from(c in CommentUpvote, where: c.comment_id == ^comment.id) |> ORM.count()
+
         ORM.update(comment, %{upvotes_count: upvotes_count})
       end)
       |> Multi.run(:check_article_author_upvoted, fn _, %{inc_upvotes_count: comment} ->
@@ -202,8 +202,8 @@ defmodule GroupherServer.CMS.Delegate.CommentAction do
         update_upvoted_user_list(comment, user_id, :remove)
       end)
       |> Multi.run(:desc_upvotes_count, fn _, %{remove_upvoted_user: comment} ->
-        count_query = from(c in CommentUpvote, where: c.comment_id == ^comment_id)
-        upvotes_count = Repo.aggregate(count_query, :count)
+        {:ok, upvotes_count} =
+          from(c in CommentUpvote, where: c.comment_id == ^comment_id) |> ORM.count()
 
         ORM.update(comment, %{upvotes_count: Enum.max([upvotes_count - 1, 0])})
       end)

lib/groupher_server/cms/delegates/comment_curd.ex

@@ -251,10 +251,9 @@ defmodule GroupherServer.CMS.Delegate.CommentCurd do
   def update_comments_count(%Comment{} = comment, opt) do
     with {:ok, article_info} <- match(:comment_article, comment),
          {:ok, article} <- ORM.find(article_info.model, article_info.id) do
-      count_query =
+      {:ok, cur_count} =
         from(c in Comment, where: field(c, ^article_info.foreign_key) == ^article_info.id)
-
-      cur_count = Repo.aggregate(count_query, :count)
+        |> ORM.count()
 
       # dec 是 comment 还没有删除的时候的操作，和 inc 不同
       # 因为 dec 操作如果放在 delete 后面，那么 update 会失败
@@ -405,8 +404,11 @@ defmodule GroupherServer.CMS.Delegate.CommentCurd do
 
   # get next floor under an article's comments list
   defp next_floor(article, foreign_key) do
-    count_query = from(c in Comment, where: field(c, ^foreign_key) == ^article.id)
-    Repo.aggregate(count_query, :count) + 1
+    {:ok, cur_count} =
+      from(c in Comment, where: field(c, ^foreign_key) == ^article.id)
+      |> ORM.count()
+
+    cur_count + 1
   end
 
   defp result({:ok, %{set_question_flag_ifneed: result}}), do: {:ok, result}

lib/groupher_server/cms/delegates/community_curd.ex

@@ -58,8 +58,10 @@ defmodule GroupherServer.CMS.Delegate.CommunityCURD do
   update editors_count of a community
   """
   def update_community_count_field(%Community{} = community, user_id, :editors_count, opt) do
-    count_query = from(s in CommunityEditor, where: s.community_id == ^community.id)
-    editors_count = Repo.aggregate(count_query, :count)
+    {:ok, editors_count} =
+      from(s in CommunityEditor, where: s.community_id == ^community.id)
+      |> ORM.count()
+
     community_meta = if is_nil(community.meta), do: @default_meta, else: community.meta
 
     editors_ids =
@@ -80,8 +82,9 @@ defmodule GroupherServer.CMS.Delegate.CommunityCURD do
   update article_tags_count of a community
   """
   def update_community_count_field(%Community{} = community, :article_tags_count) do
-    count_query = from(t in ArticleTag, where: t.community_id == ^community.id)
-    article_tags_count = Repo.aggregate(count_query, :count)
+    {:ok, article_tags_count} =
+      from(t in ArticleTag, where: t.community_id == ^community.id)
+      |> ORM.count()
 
     community
     |> Ecto.Changeset.change(%{article_tags_count: article_tags_count})
@@ -92,8 +95,9 @@ defmodule GroupherServer.CMS.Delegate.CommunityCURD do
   update subscribers_count of a community
   """
   def update_community_count_field(%Community{} = community, user_id, :subscribers_count, opt) do
-    count_query = from(s in CommunitySubscriber, where: s.community_id == ^community.id)
-    subscribers_count = Repo.aggregate(count_query, :count)
+    {:ok, subscribers_count} =
+      from(s in CommunitySubscriber, where: s.community_id == ^community.id) |> ORM.count()
+
     community_meta = if is_nil(community.meta), do: @default_meta, else: community.meta
 
     subscribed_user_ids =
@@ -122,22 +126,18 @@ defmodule GroupherServer.CMS.Delegate.CommunityCURD do
   """
   def update_community_count_field(%Community{} = community, thread) do
     with {:ok, info} <- match(thread) do
-      count_query =
+      {:ok, thread_article_count} =
         from(a in info.model,
           join: c in assoc(a, :communities),
-          where: a.mark_delete == false,
-          where: c.id == ^community.id
+          where: a.mark_delete == false and c.id == ^community.id
         )
+        |> ORM.count()
 
-      thread_article_count = Repo.aggregate(count_query, :count)
       community_meta = if is_nil(community.meta), do: @default_meta, else: community.meta
-
-      meta = community_meta |> Map.put(:"#{thread}s_count", thread_article_count) |> strip_struct
+      meta = Map.put(community_meta, :"#{thread}s_count", thread_article_count)
 
       community
-      |> Ecto.Changeset.change(%{articles_count: recount_articles_count(meta)})
-      |> Ecto.Changeset.put_embed(:meta, meta)
-      |> Repo.update()
+      |> ORM.update_meta(meta, changes: %{articles_count: recount_articles_count(meta)})
     end
   end
 

lib/groupher_server/cms/delegates/helper.ex

@@ -157,8 +157,8 @@ defmodule GroupherServer.CMS.Delegate.Helper do
         :collects_count -> ArticleCollect
       end
 
-    count_query = from(u in schema, where: field(u, ^info.foreign_key) == ^article.id)
-    cur_count = Repo.aggregate(count_query, :count)
+    {:ok, cur_count} =
+      from(u in schema, where: field(u, ^info.foreign_key) == ^article.id) |> ORM.count()
 
     case opt do
       :inc ->

lib/groupher_server/delivery/delegates/mention.ex

@@ -67,8 +67,7 @@ defmodule GroupherServer.Delivery.Delegate.Mention do
     read = Map.get(filter, :read, false)
 
     Mention
-    |> where([m], m.to_user_id == ^user.id)
-    |> where([m], m.read == ^read)
+    |> where([m], m.to_user_id == ^user.id and m.read == ^read)
     |> ORM.paginater(~m(page size)a)
     |> extract_mentions
     |> done()
@@ -78,19 +77,21 @@ defmodule GroupherServer.Delivery.Delegate.Mention do
   def unread_count(user_id) do
     Mention
     |> where([m], m.to_user_id == ^user_id and m.read == false)
-    |> Repo.aggregate(:count)
-    |> done
+    |> ORM.count()
   end
 
+  @doc "mark mention in ids as readed"
   def mark_read(ids, %User{} = user) when is_list(ids) do
-    query = Mention |> where([m], m.id in ^ids and m.to_user_id == ^user.id and m.read == false)
-
-    result = Repo.update_all(query, set: [read: true])
+    Mention
+    |> where([m], m.id in ^ids and m.to_user_id == ^user.id and m.read == false)
+    |> ORM.mark_read_all()
+  end
 
-    case result do
-      {0, nil} -> {:error, "no such mentions found"}
-      _ -> {:ok, :done}
-    end
+  @doc "mark all related mentions as readed"
+  def mark_read_all(%User{} = user) do
+    Mention
+    |> where([m], m.to_user_id == ^user.id and m.read == false)
+    |> ORM.mark_read_all()
   end
 
   defp batch_delete_mentions(%Comment{} = comment, %User{} = from_user) do
@@ -138,8 +139,5 @@ defmodule GroupherServer.Delivery.Delegate.Mention do
   end
 
   defp result({:ok, %{batch_insert_mentions: result}}), do: {:ok, result}
-
-  defp result({:error, _, result, _steps}) do
-    {:error, result}
-  end
+  defp result({:error, _, result, _steps}), do: {:error, result}
 end

lib/groupher_server/delivery/delegates/notification.ex

@@ -61,8 +61,7 @@ defmodule GroupherServer.Delivery.Delegate.Notification do
     read = Map.get(filter, :read, false)
 
     Notification
-    |> where([n], n.user_id == ^user_id)
-    |> where([n], n.read == ^read)
+    |> where([n], n.user_id == ^user_id and n.read == ^read)
     |> ORM.paginater(~m(page size)a)
     |> done
   end
@@ -71,8 +70,21 @@ defmodule GroupherServer.Delivery.Delegate.Notification do
   def unread_count(user_id) do
     Notification
     |> where([n], n.user_id == ^user_id and n.read == false)
-    |> Repo.aggregate(:count)
-    |> done
+    |> ORM.count()
+  end
+
+  @doc "mark notification in ids as readed"
+  def mark_read(ids, %User{} = user) when is_list(ids) do
+    Notification
+    |> where([m], m.id in ^ids and m.user_id == ^user.id and m.read == false)
+    |> ORM.mark_read_all()
+  end
+
+  @doc "mark all related notifications as readed"
+  def mark_read_all(%User{} = user) do
+    Notification
+    |> where([m], m.user_id == ^user.id and m.read == false)
+    |> ORM.mark_read_all()
   end
 
   # 如果在临近时间段内有类似操作，直接将这次的操作人添加到 from_users 中即可
@@ -172,9 +184,7 @@ defmodule GroupherServer.Delivery.Delegate.Notification do
 
   # 确保 key 存在，并且不为 nil
   defp all_exist?(attrs, keys) when is_map(attrs) and is_list(keys) do
-    Enum.all?(keys, fn key ->
-      Map.has_key?(attrs, key) and not is_nil(attrs[key])
-    end)
+    Enum.all?(keys, &(Map.has_key?(attrs, &1) and not is_nil(attrs[&1])))
   end
 
   # 此时间段内的相似通知会被 merge

lib/groupher_server/delivery/delegates/postman.ex

@@ -11,15 +11,18 @@ defmodule GroupherServer.Delivery.Delegate.Postman do
 
   def send(:notify, attrs, from_user), do: Notification.handle(attrs, from_user)
   def revoke(:notify, attrs, from_user), do: Notification.revoke(attrs, from_user)
+
   def fetch(:mention, user, filter), do: Mention.paged_mentions(user, filter)
   def fetch(:notification, user, filter), do: Notification.paged_notifications(user, filter)
 
   def unread_count(:mention, user_id), do: Mention.unread_count(user_id)
   def unread_count(:notification, user_id), do: Notification.unread_count(user_id)
 
   def mark_read(:mention, ids, user), do: Mention.mark_read(ids, user)
-  # def mark_read(:mention, ids, user), do: false
-  # def mark_read_all(:mention, id, user), do: false
+  def mark_read(:notification, ids, user), do: Notification.mark_read(ids, user)
+
+  def mark_read_all(:mention, user), do: Mention.mark_read_all(user)
+  def mark_read_all(:notification, user), do: Notification.mark_read_all(user)
 
   # def send(_, _, _), do: {:error, "delivery, not such service"}
   # def send(_, _, _, _), do: {:error, "delivery, not such service"}

lib/groupher_server/delivery/delivery.ex

@@ -15,6 +15,7 @@ defmodule GroupherServer.Delivery do
   defdelegate unread_count(service, user), to: Postman
 
   defdelegate mark_read(service, ids, user), to: Postman
+  defdelegate mark_read_all(service, user), to: Postman
   # system_notifications
   defdelegate publish_system_notification(info), to: Notifications
   defdelegate fetch_sys_notifications(user, filter), to: Notifications