refactor(article-comments): add list_article_comments_participators

Author: mydearxym

lib/groupher_server/cms/cms.ex

@@ -121,9 +121,7 @@ defmodule GroupherServer.CMS do
 
   defdelegate list_comment_replies(comment_id, filters), to: ArticleComment
   defdelegate list_comment_replies(comment_id, filters, user), to: ArticleComment
-
-  defdelegate list_comments(thread, content_id, filters), to: CommentCURD
-  defdelegate list_comments_participators(thread, content_id, filters), to: CommentCURD
+  defdelegate list_article_comments_participators(thread, content_id, filters), to: ArticleComment
 
   defdelegate create_article_comment(thread, article_id, args, user), to: ArticleComment
   defdelegate upvote_article_comment(comment_id, user), to: ArticleComment
@@ -146,6 +144,9 @@ defmodule GroupherServer.CMS do
   defdelegate list_replies(thread, comment, user), to: CommentCURD
   defdelegate reply_comment(thread, comment, args, user), to: CommentCURD
 
+  defdelegate list_comments(thread, content_id, filters), to: CommentCURD
+  defdelegate list_comments_participators(thread, content_id, filters), to: CommentCURD
+
   # report
   defdelegate create_report(type, content_id, args, user), to: AbuseReport
 

lib/groupher_server/cms/delegates/article_comment.ex

@@ -88,73 +88,26 @@ defmodule GroupherServer.CMS.Delegate.ArticleComment do
     do_list_comment_replies(comment_id, filters, user)
   end
 
-  defp do_list_article_comment(thread, article_id, filters, where_query, user) do
+  @spec list_article_comments_participators(T.comment_thread(), Integer.t(), T.paged_filter()) ::
+          {:ok, T.paged_users()}
+  def list_article_comments_participators(thread, article_id, filters) do
     %{page: page, size: size} = filters
 
     with {:ok, thread_query} <- match(thread, :query, article_id) do
-      query = from(c in ArticleComment, preload: [reply_to: :author])
-
-      query
+      ArticleComment
       |> where(^thread_query)
-      |> where(^where_query)
-      |> QueryBuilder.filter_pack(Map.merge(filters, %{sort: :asc_inserted}))
+      |> QueryBuilder.filter_pack(Map.merge(filters, %{sort: :desc_inserted}))
+      |> join(:inner, [c], a in assoc(c, :author))
+      |> distinct([c, a], a.id)
+      |> group_by([c, a], a.id)
+      |> group_by([c, a], c.inserted_at)
+      |> select([c, a], a)
       |> ORM.paginater(~m(page size)a)
-      |> set_viewer_emotion_ifneed(user)
-      |> add_pined_comments_ifneed(thread, article_id, filters)
       |> done()
     end
   end
 
-  defp do_list_comment_replies(comment_id, filters, user) do
-    %{page: page, size: size} = filters
-    query = from(c in ArticleComment, preload: [reply_to: :author])
-
-    where_query =
-      dynamic([c], not c.is_reported and not c.is_folded and c.reply_to_id == ^comment_id)
-
-    query
-    |> where(^where_query)
-    |> QueryBuilder.filter_pack(filters)
-    |> ORM.paginater(~m(page size)a)
-    |> set_viewer_emotion_ifneed(user)
-    |> done()
-  end
-
-  defp add_pined_comments_ifneed(%{entries: entries} = paged_comments, thread, article_id, %{
-         page: 1
-       }) do
-    with {:ok, info} <- match(thread),
-         query <-
-           from(p in ArticlePinedComment,
-             join: c in ArticleComment,
-             on: p.article_comment_id == c.id,
-             where: field(p, ^info.foreign_key) == ^article_id,
-             select: c
-           ),
-         {:ok, pined_comments} <- Repo.all(query) |> done() do
-      case pined_comments do
-        [] ->
-          paged_comments
-
-        _ ->
-          preloaded_pined_comments =
-            Enum.slice(pined_comments, 0, @pined_comment_limit)
-            |> Repo.preload(reply_to: :author)
-
-          updated_entries = Enum.concat(preloaded_pined_comments, entries)
-
-          pined_comment_count = length(pined_comments)
-
-          Map.merge(paged_comments, %{
-            entries: updated_entries,
-            total_count: paged_comments.total_count + pined_comment_count
-          })
-      end
-    end
-  end
-
-  defp add_pined_comments_ifneed(paged_comments, _thread, _article_id, _), do: paged_comments
-
+  @spec pin_article_comment(Integer.t()) :: {:ok, ArticleComment.t()}
   @doc "pin a comment"
   def pin_article_comment(comment_id) do
     with {:ok, comment} <- ORM.find(ArticleComment, comment_id),
@@ -452,6 +405,73 @@ defmodule GroupherServer.CMS.Delegate.ArticleComment do
     end
   end
 
+  defp do_list_article_comment(thread, article_id, filters, where_query, user) do
+    %{page: page, size: size} = filters
+
+    with {:ok, thread_query} <- match(thread, :query, article_id) do
+      query = from(c in ArticleComment, preload: [reply_to: :author])
+
+      query
+      |> where(^thread_query)
+      |> where(^where_query)
+      |> QueryBuilder.filter_pack(Map.merge(filters, %{sort: :asc_inserted}))
+      |> ORM.paginater(~m(page size)a)
+      |> set_viewer_emotion_ifneed(user)
+      |> add_pined_comments_ifneed(thread, article_id, filters)
+      |> done()
+    end
+  end
+
+  defp do_list_comment_replies(comment_id, filters, user) do
+    %{page: page, size: size} = filters
+    query = from(c in ArticleComment, preload: [reply_to: :author])
+
+    where_query =
+      dynamic([c], not c.is_reported and not c.is_folded and c.reply_to_id == ^comment_id)
+
+    query
+    |> where(^where_query)
+    |> QueryBuilder.filter_pack(filters)
+    |> ORM.paginater(~m(page size)a)
+    |> set_viewer_emotion_ifneed(user)
+    |> done()
+  end
+
+  defp add_pined_comments_ifneed(%{entries: entries} = paged_comments, thread, article_id, %{
+         page: 1
+       }) do
+    with {:ok, info} <- match(thread),
+         query <-
+           from(p in ArticlePinedComment,
+             join: c in ArticleComment,
+             on: p.article_comment_id == c.id,
+             where: field(p, ^info.foreign_key) == ^article_id,
+             select: c
+           ),
+         {:ok, pined_comments} <- Repo.all(query) |> done() do
+      case pined_comments do
+        [] ->
+          paged_comments
+
+        _ ->
+          preloaded_pined_comments =
+            Enum.slice(pined_comments, 0, @pined_comment_limit)
+            |> Repo.preload(reply_to: :author)
+
+          updated_entries = Enum.concat(preloaded_pined_comments, entries)
+
+          pined_comment_count = length(pined_comments)
+
+          Map.merge(paged_comments, %{
+            entries: updated_entries,
+            total_count: paged_comments.total_count + pined_comment_count
+          })
+      end
+    end
+  end
+
+  defp add_pined_comments_ifneed(paged_comments, _thread, _article_id, _), do: paged_comments
+
   defp update_article_author_upvoted_info(%ArticleComment{} = comment, user_id) do
     with {:ok, article} = get_full_comment(comment.id) do
       is_article_author_upvoted = article.author.id == user_id

lib/groupher_server_web/resolvers/cms_resolver.ex

@@ -361,6 +361,10 @@ defmodule GroupherServerWeb.Resolvers.CMS do
     end
   end
 
+  def paged_article_comments_participators(_root, ~m(id thread filter)a, _info) do
+    CMS.list_article_comments_participators(thread, id, filter)
+  end
+
   def paged_comment_replies(_root, ~m(id filter)a, %{context: %{cur_user: user}}) do
     CMS.list_comment_replies(id, filter, user)
   end

lib/groupher_server_web/schema/cms/cms_queries.ex

@@ -171,6 +171,16 @@ defmodule GroupherServerWeb.Schema.CMS.Queries do
       resolve(&R.CMS.paged_article_comments/3)
     end
 
+    @desc "get paged article comments participators"
+    field :paged_article_comments_participators, :paged_users do
+      arg(:id, non_null(:id))
+      arg(:thread, :cms_thread, default_value: :post)
+      arg(:filter, :paged_filter)
+
+      middleware(M.PageSizeProof)
+      resolve(&R.CMS.paged_article_comments_participators/3)
+    end
+
     @desc "get paged replies of a comment"
     field :paged_comment_replies, :paged_article_replies do
       arg(:id, non_null(:id))

lib/helper/types.ex

@@ -3,6 +3,9 @@ defmodule Helper.Types do
   custom @types
   """
 
+  alias GroupherServer.{Accounts}
+  alias Accounts.User
+
   @typedoc """
   Type GraphQL flavor the error format
   """
@@ -29,6 +32,22 @@ defmodule Helper.Types do
         }
 
   @type article_thread :: :post | :job
+  @type comment_thread :: :post | :job
+
+  @type paged_filter :: %{
+          page: Integer.t(),
+          size: Integer.t(),
+          sort: :desc_inserted | :asc_inserted
+        }
+
+  @type paged_users :: %{
+          entries: [User.t()],
+          page_number: Integer.t(),
+          page_size: Integer.t(),
+          total_count: Integer.t(),
+          total_pages: Integer.t()
+        }
+
   @type article_common :: %{
           title: String.t()
         }

test/groupher_server/cms/article_comment_replies_test.exs

@@ -65,7 +65,7 @@ defmodule GroupherServer.Test.CMS.ArticleCommentReplies do
       assert exist_in?(replyed_comment_2, parent_comment.replies)
     end
 
-    @tag :wip2
+    @tag :wip
     test "reply to reply inside a comment should belong same parent comment",
          ~m(post user user2)a do
       {:ok, parent_comment} = CMS.create_article_comment(:post, post.id, "parent comment", user)
@@ -91,7 +91,7 @@ defmodule GroupherServer.Test.CMS.ArticleCommentReplies do
       assert replyed_comment_3.reply_to_id == replyed_comment_2.id
     end
 
-    @tag :wip2
+    @tag :wip
     test "reply to reply inside a comment should have is_reply_to_others flag in meta",
          ~m(post user user2)a do
       {:ok, parent_comment} = CMS.create_article_comment(:post, post.id, "parent comment", user)

test/groupher_server/cms/article_comment_test.exs

@@ -318,6 +318,30 @@ defmodule GroupherServer.Test.CMS.ArticleComment do
   end
 
   describe "paged article comments" do
+    @tag :wip2
+    test "can load paged comments participators of a article", ~m(user post)a do
+      total_count = 30
+      page_number = 1
+      page_size = 10
+      thread = :post
+
+      Enum.reduce(1..total_count, [], fn _, acc ->
+        {:ok, new_user} = db_insert(:user)
+        {:ok, comment} = CMS.create_article_comment(:post, post.id, "commment", new_user)
+
+        acc ++ [comment]
+      end)
+
+      {:ok, comment} = CMS.create_article_comment(:post, post.id, "commment", user)
+      {:ok, comment} = CMS.create_article_comment(:post, post.id, "commment", user)
+
+      {:ok, results} =
+        CMS.list_article_comments_participators(thread, post.id, %{page: 1, size: page_size})
+
+      assert results |> is_valid_pagination?(:raw)
+      assert results.total_count == total_count + 1
+    end
+
     @tag :wip
     test "paged article comments folded flag should be false", ~m(user post)a do
       total_count = 30

test/groupher_server_web/query/cms/article_comment_test.exs

@@ -494,6 +494,46 @@ defmodule GroupherServer.Test.Query.ArticleComment do
     end
   end
 
+  describe "paged paticipators" do
+    @query """
+      query($id: ID!, $filter: PagedFilter!) {
+        pagedArticleCommentsParticipators(id: $id, filter: $filter) {
+          entries {
+            id
+            nickname
+          }
+          totalPages
+          totalCount
+          pageSize
+          pageNumber
+        }
+    }
+    """
+    @tag :wip2
+    test "guest user can get paged participators", ~m(guest_conn post user)a do
+      total_count = 30
+      page_size = 10
+      thread = "POST"
+
+      Enum.reduce(1..total_count, [], fn _, acc ->
+        {:ok, new_user} = db_insert(:user)
+        {:ok, comment} = CMS.create_article_comment(:post, post.id, "commment", new_user)
+
+        acc ++ [comment]
+      end)
+
+      {:ok, comment} = CMS.create_article_comment(:post, post.id, "commment", user)
+      {:ok, comment} = CMS.create_article_comment(:post, post.id, "commment", user)
+
+      variables = %{id: post.id, thread: thread, filter: %{page: 1, size: page_size}}
+
+      results = guest_conn |> query_result(@query, variables, "pagedArticleCommentsParticipators")
+
+      assert results |> is_valid_pagination?
+      assert results["totalCount"] == total_count + 1
+    end
+  end
+
   describe "paged replies" do
     @query """
       query($id: ID!, $filter: CommentsFilter!) {