feat(post-qa): pin solution logic

Author: mydearxym

lib/groupher_server/cms/delegates/article_comment.ex

@@ -107,9 +107,7 @@ defmodule GroupherServer.CMS.Delegate.ArticleComment do
       |> Multi.run(:set_question_flag_ifneed, fn _, %{create_article_comment: comment} ->
         set_question_flag_ifneed(article, comment)
       end)
-      |> Multi.run(:add_participator, fn _, _ ->
-        add_participator_to_article(article, user)
-      end)
+      |> Multi.run(:add_participator, fn _, _ -> add_participator_to_article(article, user) end)
       |> Multi.run(:update_article_active_timestamp, fn _, %{create_article_comment: comment} ->
         case comment.author_id == article.author.user.id do
           true -> {:ok, :pass}
@@ -144,6 +142,7 @@ defmodule GroupherServer.CMS.Delegate.ArticleComment do
          {:ok, post} <- ORM.find(CMS.Post, article_comment.post_id, preload: [author: :user]) do
       # 确保只有一个最佳答案
       batch_update_solution_flag(post, false)
+      CMS.pin_article_comment(article_comment.id)
       do_mark_comment_solution(post, article_comment, user, true)
     end
   end
@@ -209,7 +208,9 @@ defmodule GroupherServer.CMS.Delegate.ArticleComment do
         %{article_comments_participators: article_comments_participators} = article,
         %User{} = user
       ) do
-    total_participators = article_comments_participators |> List.insert_at(0, user) |> Enum.uniq()
+    total_participators =
+      article_comments_participators |> List.insert_at(0, user) |> Enum.uniq_by(& &1.id)
+
     new_comment_participators = total_participators |> Enum.slice(0, @max_participator_count)
     total_participators_count = length(total_participators)
 
@@ -312,6 +313,7 @@ defmodule GroupherServer.CMS.Delegate.ArticleComment do
              join: c in ArticleComment,
              on: p.article_comment_id == c.id,
              where: field(p, ^info.foreign_key) == ^article_id,
+             order_by: [desc: p.inserted_at],
              select: c
            ),
          {:ok, pined_comments} <- Repo.all(query) |> done() do
@@ -323,6 +325,7 @@ defmodule GroupherServer.CMS.Delegate.ArticleComment do
           preloaded_pined_comments =
             Enum.slice(pined_comments, 0, @pinned_comment_limit)
             |> Repo.preload(reply_to: :author)
+            |> sort_solution_to_front
 
           entries = Enum.concat(preloaded_pined_comments, entries)
           pined_comment_count = length(pined_comments)
@@ -335,6 +338,19 @@ defmodule GroupherServer.CMS.Delegate.ArticleComment do
 
   defp add_pined_comments_ifneed(paged_comments, _thread, _article_id, _), do: paged_comments
 
+  defp sort_solution_to_front(pined_comments) do
+    solution_index = Enum.find_index(pined_comments, & &1.is_solution)
+
+    case is_nil(solution_index) do
+      true ->
+        pined_comments
+
+      false ->
+        {solution_comment, rest_comments} = List.pop_at(pined_comments, solution_index)
+        [solution_comment] ++ rest_comments
+    end
+  end
+
   defp mark_viewer_has_upvoted(paged_comments, nil), do: paged_comments
 
   defp mark_viewer_has_upvoted(%{entries: entries} = paged_comments, %User{} = user) do

test/groupher_server/cms/comments/post_comment_test.exs

@@ -714,7 +714,7 @@ defmodule GroupherServer.Test.CMS.Comments.PostComment do
       assert not comment3.is_for_question
     end
 
-    @tag :wip
+    @tag :wip2
     test "can mark a comment as solution", ~m(user community)a do
       post_attrs = mock_attrs(:post, %{community_id: community.id, is_question: true})
       {:ok, post} = CMS.create_article(community, :post, post_attrs, user)
@@ -732,7 +732,7 @@ defmodule GroupherServer.Test.CMS.Comments.PostComment do
       assert post.solution_digest == comment.body_html
     end
 
-    @tag :wip
+    @tag :wip2
     test "non-post-author can not mark a comment as solution", ~m(user community)a do
       post_attrs = mock_attrs(:post, %{community_id: community.id, is_question: true})
       {:ok, post} = CMS.create_article(community, :post, post_attrs, user)
@@ -747,7 +747,7 @@ defmodule GroupherServer.Test.CMS.Comments.PostComment do
       reason |> is_error?(:require_questioner)
     end
 
-    @tag :wip
+    @tag :wip2
     test "can undo mark a comment as solution", ~m(user community)a do
       post_attrs = mock_attrs(:post, %{community_id: community.id, is_question: true})
       {:ok, post} = CMS.create_article(community, :post, post_attrs, user)
@@ -765,7 +765,7 @@ defmodule GroupherServer.Test.CMS.Comments.PostComment do
       assert not post.is_solved
     end
 
-    @tag :wip
+    @tag :wip2
     test "non-post-author can not undo mark a comment as solution", ~m(user community)a do
       post_attrs = mock_attrs(:post, %{community_id: community.id, is_question: true})
       {:ok, post} = CMS.create_article(community, :post, post_attrs, user)
@@ -780,7 +780,7 @@ defmodule GroupherServer.Test.CMS.Comments.PostComment do
       reason |> is_error?(:require_questioner)
     end
 
-    @tag :wip
+    @tag :wip2
     test "can only mark one best comment as solution", ~m(user community)a do
       post_attrs = mock_attrs(:post, %{community_id: community.id, is_question: true})
       {:ok, post} = CMS.create_article(community, :post, post_attrs, user)

test/groupher_server_web/query/cms/comments/job_comment_test.exs

@@ -240,6 +240,7 @@ defmodule GroupherServer.Test.Query.Comments.JobComment do
       assert results["totalCount"] == total_count
     end
 
+    @tag :wip
     test "guest user can get paged comment with pinned comment in it",
          ~m(guest_conn job user)a do
       total_count = 20
@@ -254,14 +255,16 @@ defmodule GroupherServer.Test.Query.Comments.JobComment do
       {:ok, comment} = CMS.create_article_comment(thread, job.id, "pinned comment", user)
       {:ok, pinned_comment} = CMS.pin_article_comment(comment.id)
 
+      Process.sleep(1000)
+
       {:ok, comment} = CMS.create_article_comment(thread, job.id, "pinned comment 2", user)
       {:ok, pinned_comment2} = CMS.pin_article_comment(comment.id)
 
       variables = %{id: job.id, thread: "JOB", filter: %{page: 1, size: 10}}
       results = guest_conn |> query_result(@query, variables, "pagedArticleComments")
 
-      assert results["entries"] |> List.first() |> Map.get("id") == to_string(pinned_comment.id)
-      assert results["entries"] |> Enum.at(1) |> Map.get("id") == to_string(pinned_comment2.id)
+      assert results["entries"] |> List.first() |> Map.get("id") == to_string(pinned_comment2.id)
+      assert results["entries"] |> Enum.at(1) |> Map.get("id") == to_string(pinned_comment.id)
 
       assert results["totalCount"] == total_count + 2
     end

test/groupher_server_web/query/cms/comments/post_comment_test.exs

@@ -4,16 +4,18 @@ defmodule GroupherServer.Test.Query.Comments.PostComment do
   use GroupherServer.TestTools
 
   alias GroupherServer.CMS
+  alias Helper.ORM
 
   setup do
     {:ok, post} = db_insert(:post)
     {:ok, user} = db_insert(:user)
     {:ok, user2} = db_insert(:user)
+    {:ok, community} = db_insert(:community)
 
     guest_conn = simu_conn(:guest)
     user_conn = simu_conn(:user, user)
 
-    {:ok, ~m(user_conn guest_conn post user user2)a}
+    {:ok, ~m(user_conn guest_conn community post user user2)a}
   end
 
   describe "[baisc article post comment]" do
@@ -240,6 +242,7 @@ defmodule GroupherServer.Test.Query.Comments.PostComment do
       assert results["totalCount"] == total_count
     end
 
+    @tag :wip
     test "guest user can get paged comment with pinned comment in it",
          ~m(guest_conn post user)a do
       total_count = 20
@@ -254,18 +257,58 @@ defmodule GroupherServer.Test.Query.Comments.PostComment do
       {:ok, comment} = CMS.create_article_comment(thread, post.id, "pinned comment", user)
       {:ok, pinned_comment} = CMS.pin_article_comment(comment.id)
 
+      Process.sleep(1000)
+
       {:ok, comment} = CMS.create_article_comment(thread, post.id, "pinned comment 2", user)
       {:ok, pinned_comment2} = CMS.pin_article_comment(comment.id)
 
       variables = %{id: post.id, thread: "POST", filter: %{page: 1, size: 10}}
       results = guest_conn |> query_result(@query, variables, "pagedArticleComments")
 
-      assert results["entries"] |> List.first() |> Map.get("id") == to_string(pinned_comment.id)
-      assert results["entries"] |> Enum.at(1) |> Map.get("id") == to_string(pinned_comment2.id)
+      assert results["entries"] |> List.first() |> Map.get("id") == to_string(pinned_comment2.id)
+      assert results["entries"] |> Enum.at(1) |> Map.get("id") == to_string(pinned_comment.id)
 
       assert results["totalCount"] == total_count + 2
     end
 
+    # post only
+    @tag :wip
+    test "if solution in pinned comments, solution should always on top",
+         ~m(guest_conn community user)a do
+      post_attrs = mock_attrs(:post, %{community_id: community.id, is_question: true})
+      {:ok, post} = CMS.create_article(community, :post, post_attrs, user)
+
+      total_count = 20
+      thread = :post
+
+      Enum.reduce(1..total_count, [], fn _, acc ->
+        {:ok, comment} = CMS.create_article_comment(thread, post.id, "test comment", user)
+
+        acc ++ [comment]
+      end)
+
+      {:ok, post} = ORM.find(CMS.Post, post.id, preload: [author: :user])
+      post_author = post.author.user
+
+      {:ok, comment} = CMS.create_article_comment(thread, post.id, "pinned comment", user)
+      {:ok, pinned_comment} = CMS.pin_article_comment(comment.id)
+
+      Process.sleep(1000)
+
+      {:ok, comment} = CMS.create_article_comment(thread, post.id, "solution", post_author)
+      {:ok, solution_comment} = CMS.mark_comment_solution(comment.id, post_author)
+
+      Process.sleep(1000)
+      {:ok, comment} = CMS.create_article_comment(thread, post.id, "pinned comment 2", user)
+      {:ok, pinned_comment2} = CMS.pin_article_comment(comment.id)
+
+      variables = %{id: post.id, thread: "POST", filter: %{page: 1, size: 10}}
+      results = guest_conn |> query_result(@query, variables, "pagedArticleComments")
+
+      assert results["entries"] |> List.first() |> Map.get("id") == to_string(solution_comment.id)
+      assert results["totalCount"] == total_count + 3
+    end
+
     test "guest user can get paged comment with floor it", ~m(guest_conn post user)a do
       total_count = 5
       thread = :post

test/groupher_server_web/query/cms/comments/repo_comment_test.exs

@@ -238,6 +238,7 @@ defmodule GroupherServer.Test.Query.Comments.RepoComment do
       assert results["totalCount"] == total_count
     end
 
+    @tag :wip
     test "guest user can get paged comment with pinned comment in it",
          ~m(guest_conn repo user)a do
       total_count = 20
@@ -252,14 +253,16 @@ defmodule GroupherServer.Test.Query.Comments.RepoComment do
       {:ok, comment} = CMS.create_article_comment(thread, repo.id, "pinned comment", user)
       {:ok, pinned_comment} = CMS.pin_article_comment(comment.id)
 
+      Process.sleep(1000)
+
       {:ok, comment} = CMS.create_article_comment(thread, repo.id, "pinned comment 2", user)
       {:ok, pinned_comment2} = CMS.pin_article_comment(comment.id)
 
       variables = %{id: repo.id, thread: "REPO", filter: %{page: 1, size: 10}}
       results = guest_conn |> query_result(@query, variables, "pagedArticleComments")
 
-      assert results["entries"] |> List.first() |> Map.get("id") == to_string(pinned_comment.id)
-      assert results["entries"] |> Enum.at(1) |> Map.get("id") == to_string(pinned_comment2.id)
+      assert results["entries"] |> List.first() |> Map.get("id") == to_string(pinned_comment2.id)
+      assert results["entries"] |> Enum.at(1) |> Map.get("id") == to_string(pinned_comment.id)
 
       assert results["totalCount"] == total_count + 2
     end