refactor(abuse-report): wip

Author: mydearxym

lib/groupher_server/cms/cms.ex

@@ -162,6 +162,7 @@ defmodule GroupherServer.CMS do
   # TODO: move report to abuse report module
   defdelegate create_report(type, content_id, args, user), to: AbuseReport
   defdelegate report_article(thread, article_id, reason, attr, user), to: AbuseReport
+  defdelegate undo_report_article(thread, article_id, user), to: AbuseReport
   defdelegate list_reports(type, content_id, filter), to: AbuseReport
   defdelegate report_article_comment(comment_id, user), to: ArticleCommentAction
   defdelegate unreport_article_comment(comment_id, user), to: ArticleCommentAction

lib/groupher_server/cms/delegates/abuse_report.ex

@@ -36,33 +36,76 @@ defmodule GroupherServer.CMS.Delegate.AbuseReport do
         create_report(thread, article_id, reason, attr, user)
       end)
       |> Multi.run(:update_report_flag, fn _, _ ->
-        count_query = from(c in AbuseReport, where: field(c, ^info.foreign_key) == ^article.id)
-        reported_count = Repo.aggregate(count_query, :count)
-        meta = article.meta |> Map.merge(%{reported_count: reported_count}) |> strip_struct
+        update_report_meta(info, article, true)
+      end)
+      |> Repo.transaction()
+      |> result()
+    end
+  end
 
-        article
-        |> Ecto.Changeset.change(%{is_reported: true})
-        |> Ecto.Changeset.put_embed(:meta, meta)
-        |> Repo.update()
+  @doc "unreport an article"
+  def undo_report_article(thread, article_id, %User{} = user) do
+    with {:ok, info} <- match(thread),
+         {:ok, article} <- ORM.find(info.model, article_id) do
+      Multi.new()
+      |> Multi.run(:delete_abuse_report, fn _, _ ->
+        delete_report(thread, article_id, user)
+      end)
+      |> Multi.run(:update_report_flag, fn _, _ ->
+        update_report_meta(info, article, false)
       end)
       |> Repo.transaction()
       |> result()
     end
   end
 
-  @doc "unreport a comment"
-  # def unreport_article(thread, article_id, %User{} = _user) do
-  #   with {:ok, comment} <- ORM.find(ArticleComment, comment_id) do
-  #     comment |> ORM.update(%{is_reported: false})
-  #   end
-  # end
+  defp delete_report(thread, content_id, %User{} = user) do
+    with {:ok, info} <- match(thread),
+         {:error, _} <- not_reported_before(info, content_id, user),
+         {:ok, report} = ORM.find_by(AbuseReport, Map.put(%{}, info.foreign_key, content_id)) do
+      case length(report.report_cases) do
+        1 ->
+          ORM.delete(report)
+
+        _ ->
+          report_cases = report.report_cases |> Enum.reject(&(&1.user.login == user.login))
+
+          report
+          |> Ecto.Changeset.change(%{report_cases_count: length(report_cases)})
+          |> Ecto.Changeset.put_embed(:report_cases, report_cases)
+          |> Repo.update()
+      end
+    end
+  end
+
+  # update is_reported flag and reported_count in mete for article or comment
+  defp update_report_meta(info, content, is_reported) do
+    case ORM.find_by(AbuseReport, Map.put(%{}, info.foreign_key, content.id)) do
+      {:ok, record} ->
+        reported_count = record.report_cases |> length
+        meta = content.meta |> Map.merge(%{reported_count: reported_count}) |> strip_struct
+
+        content
+        |> Ecto.Changeset.change(%{is_reported: is_reported})
+        |> Ecto.Changeset.put_embed(:meta, meta)
+        |> Repo.update()
+
+      {:error, _} ->
+        meta = content.meta |> Map.merge(%{reported_count: 0}) |> strip_struct
+
+        content
+        |> Ecto.Changeset.change(%{is_reported: false})
+        |> Ecto.Changeset.put_embed(:meta, meta)
+        |> Repo.update()
+    end
+  end
 
   def create_report(type, content_id, reason, attr, %User{} = user) do
     with {:ok, info} <- match(type),
          {:ok, report} <- not_reported_before(info, content_id, user) do
       case report do
         nil ->
-          updated_report_cases = [
+          report_cases = [
             %{
               reason: reason,
               additional_reason: attr,
@@ -71,13 +114,13 @@ defmodule GroupherServer.CMS.Delegate.AbuseReport do
           ]
 
           args =
-            %{report_cases_count: 1, report_cases: updated_report_cases}
+            %{report_cases_count: 1, report_cases: report_cases}
             |> Map.put(info.foreign_key, content_id)
 
           AbuseReport |> ORM.create(args)
 
         _ ->
-          updated_report_cases =
+          report_cases =
             report.report_cases
             |> List.insert_at(
               length(report.report_cases),
@@ -89,13 +132,18 @@ defmodule GroupherServer.CMS.Delegate.AbuseReport do
             )
 
           report
-          |> Ecto.Changeset.change(%{report_cases_count: length(updated_report_cases)})
-          |> Ecto.Changeset.put_embed(:report_cases, updated_report_cases)
+          |> Ecto.Changeset.change(%{report_cases_count: length(report_cases)})
+          |> Ecto.Changeset.put_embed(:report_cases, report_cases)
           |> Repo.update()
       end
     end
   end
 
+  ##############
+  ##############
+  ##############
+  ##############
+
   @doc """
   create report record
   """
@@ -161,6 +209,7 @@ defmodule GroupherServer.CMS.Delegate.AbuseReport do
   end
 
   defp result({:ok, %{create_abuse_report: result}}), do: result |> done()
+  defp result({:ok, %{delete_abuse_report: result}}), do: result |> done()
 
   defp result({:error, _, result, _steps}) do
     {:error, result}

test/groupher_server/cms/abuse_reports/post_report_test.exs

@@ -5,13 +5,11 @@ defmodule GroupherServer.Test.CMS.AbuseReports.PostReport do
 
   alias Helper.ORM
   alias GroupherServer.CMS
-
-  alias CMS.AbuseReport
+  # alias CMS.AbuseReport
 
   setup do
     {:ok, user} = db_insert(:user)
     {:ok, user2} = db_insert(:user)
-    {:ok, post} = db_insert(:post)
 
     {:ok, community} = db_insert(:community)
     post_attrs = mock_attrs(:post, %{community_id: community.id})
@@ -23,7 +21,7 @@ defmodule GroupherServer.Test.CMS.AbuseReports.PostReport do
     @tag :wip2
     test "report a post should have a abuse report record", ~m(community user post_attrs)a do
       {:ok, post} = CMS.create_content(community, :post, post_attrs, user)
-      {:ok, report} = CMS.report_article(:post, post.id, "reason", "attr_info", user)
+      {:ok, _report} = CMS.report_article(:post, post.id, "reason", "attr_info", user)
 
       {:ok, all_reports} = CMS.list_reports(:post, post.id, %{page: 1, size: 20})
 
@@ -40,14 +38,50 @@ defmodule GroupherServer.Test.CMS.AbuseReports.PostReport do
       assert post.meta.reported_count == 1
     end
 
-    @tag :wip
+    @tag :wip2
+    test "can undo a report", ~m(community user post_attrs)a do
+      {:ok, post} = CMS.create_content(community, :post, post_attrs, user)
+      {:ok, _report} = CMS.report_article(:post, post.id, "reason", "attr_info", user)
+      {:ok, _report} = CMS.undo_report_article(:post, post.id, user)
+
+      {:ok, all_reports} = CMS.list_reports(:post, post.id, %{page: 1, size: 20})
+      assert all_reports.total_count == 0
+    end
+
+    @tag :wip2
+    test "can undo a report with other user report it too",
+         ~m(community user user2 post_attrs)a do
+      {:ok, post} = CMS.create_content(community, :post, post_attrs, user)
+      {:ok, _report} = CMS.report_article(:post, post.id, "reason", "attr_info", user)
+      {:ok, _report} = CMS.report_article(:post, post.id, "reason", "attr_info", user2)
+
+      {:ok, all_reports} = CMS.list_reports(:post, post.id, %{page: 1, size: 20})
+      assert all_reports.total_count == 1
+
+      report = all_reports.entries |> List.first()
+      assert report.report_cases |> length == 2
+      assert Enum.any?(report.report_cases, &(&1.user.login == user.login))
+      assert Enum.any?(report.report_cases, &(&1.user.login == user2.login))
+
+      {:ok, _report} = CMS.undo_report_article(:post, post.id, user)
+
+      {:ok, all_reports} = CMS.list_reports(:post, post.id, %{page: 1, size: 20})
+      assert all_reports.total_count == 1
+
+      report = all_reports.entries |> List.first()
+      assert report.report_cases |> length == 1
+      assert Enum.any?(report.report_cases, &(&1.user.login == user2.login))
+    end
+
+    @tag :wip2
     test "different user report a comment should have same report with different report cases",
-         ~m(user user2 post)a do
-      {:ok, comment} = CMS.create_article_comment(:post, post.id, "commment", user)
-      {:ok, _} = CMS.report_article_comment(comment.id, user)
-      {:ok, _} = CMS.report_article_comment(comment.id, user2)
+         ~m(community user user2 post_attrs)a do
+      {:ok, post} = CMS.create_content(community, :post, post_attrs, user)
+
+      {:ok, _report} = CMS.report_article(:post, post.id, "reason", "attr_info", user)
+      {:ok, _report} = CMS.report_article(:post, post.id, "reason2", "attr_info 2", user2)
 
-      {:ok, all_reports} = CMS.list_reports(:article_comment, comment.id, %{page: 1, size: 20})
+      {:ok, all_reports} = CMS.list_reports(:post, post.id, %{page: 1, size: 20})
 
       report = List.first(all_reports.entries)
       report_cases = report.report_cases
@@ -60,11 +94,12 @@ defmodule GroupherServer.Test.CMS.AbuseReports.PostReport do
       assert List.last(report_cases).user.login == user2.login
     end
 
-    @tag :wip
-    test "same user can not report a comment twice", ~m(user post)a do
-      {:ok, comment} = CMS.create_article_comment(:post, post.id, "commment", user)
-      {:ok, comment} = CMS.report_article_comment(comment.id, user)
-      assert {:error, _} = CMS.report_article_comment(comment.id, user)
+    @tag :wip2
+    test "same user can not report a comment twice", ~m(community post_attrs user)a do
+      {:ok, post} = CMS.create_content(community, :post, post_attrs, user)
+
+      {:ok, _report} = CMS.report_article(:post, post.id, "reason", "attr_info", user)
+      assert {:error, _report} = CMS.report_article(:post, post.id, "reason", "attr_info", user)
     end
   end
 end