refactor(pinned-article): max_pinned_article_count_per_thread

Author: mydearxym

lib/groupher_server/cms/community.ex

@@ -19,10 +19,14 @@ defmodule GroupherServer.CMS.Community do
     CommunityCheatsheet
   }
 
+  @max_pinned_article_count_per_thread 2
+
   @required_fields ~w(title desc user_id logo raw)a
   # @required_fields ~w(title desc user_id)a
   @optional_fields ~w(label geo_info index aka)a
 
+  def max_pinned_article_count_per_thread, do: @max_pinned_article_count_per_thread
+
   schema "communities" do
     field(:title, :string)
     field(:aka, :string)

lib/groupher_server/cms/delegates/article_operation.ex

@@ -4,7 +4,8 @@ defmodule GroupherServer.CMS.Delegate.ArticleOperation do
   """
   import GroupherServer.CMS.Utils.Matcher
   import Ecto.Query, warn: false
-  # import Helper.ErrorCode
+
+  import Helper.ErrorCode
   import ShortMaps
   import GroupherServer.CMS.Utils.Matcher2
 
@@ -20,7 +21,7 @@ defmodule GroupherServer.CMS.Delegate.ArticleOperation do
     JobCommunityFlag,
     RepoCommunityFlag,
     Tag,
-    PinedArticle,
+    PinnedArticle,
     PinedPost,
     PinedJob,
     PinedRepo
@@ -29,12 +30,34 @@ defmodule GroupherServer.CMS.Delegate.ArticleOperation do
   alias GroupherServer.CMS.Repo, as: CMSRepo
   alias GroupherServer.Repo
 
-  @spec pin_article(T.article_thread(), Integer.t(), Integer.t()) :: {:ok, PinedArticle.t()}
+  alias Ecto.Multi
+
+  @max_pinned_article_count_per_thread Community.max_pinned_article_count_per_thread()
+
+  @spec pin_article(T.article_thread(), Integer.t(), Integer.t()) :: {:ok, PinnedArticle.t()}
   def pin_article(thread, article_id, community_id) do
     with {:ok, info} <- match(thread),
-         {:ok, community} <- ORM.find(Community, community_id) do
-      args = Map.put(%{community_id: community.id}, info.foreign_key, article_id)
-      PinedArticle |> ORM.create(args)
+         {:ok, community} <- ORM.find(Community, community_id),
+         {:ok, _} <- check_pinned_article_count(community_id, thread) do
+      Multi.new()
+      |> Multi.run(:update_article_pinned_flag, fn _, _ ->
+        # ORM.update(comment, %{is_pined: true})
+        {:ok, :pass}
+      end)
+      |> Multi.run(:create_pinned_article, fn _, _ ->
+        thread_upcase = thread |> to_string |> String.upcase()
+
+        args =
+          Map.put(
+            %{community_id: community.id, thread: thread_upcase},
+            info.foreign_key,
+            article_id
+          )
+
+        PinnedArticle |> ORM.create(args)
+      end)
+      |> Repo.transaction()
+      |> create_pinned_article_result()
     end
   end
 
@@ -267,18 +290,26 @@ defmodule GroupherServer.CMS.Delegate.ArticleOperation do
     |> Repo.update()
   end
 
-  # make sure the reuest tag is in the current community thread
-  # example: you can't set a other thread tag to this thread's article
+  # check if the thread has aready enough pined articles
+  defp check_pinned_article_count(community_id, thread) do
+    thread_upcase = thread |> to_string |> String.upcase()
+
+    query =
+      from(p in PinnedArticle,
+        where: p.community_id == ^community_id and p.thread == ^thread_upcase
+      )
 
-  # defp tag_in_community_thread?(%Community{id: communityId}, thread, tag) do
-  # with {:ok, community} <- ORM.find(Community, communityId) do
-  # matched_tags =
-  # Tag
-  # |> where([t], t.community_id == ^community.id)
-  # |> where([t], t.thread == ^to_string(thread))
-  # |> Repo.all()
+    pinned_articles = query |> Repo.all()
 
-  # tag in matched_tags
-  # end
-  # end
+    case length(pinned_articles) >= @max_pinned_article_count_per_thread do
+      true -> raise_error(:too_much_pinned_article, "too much pinned article")
+      _ -> {:ok, :pass}
+    end
+  end
+
+  defp create_pinned_article_result({:ok, %{create_pinned_article: result}}), do: {:ok, result}
+
+  defp create_pinned_article_result({:error, _, result, _steps}) do
+    {:error, result}
+  end
 end

lib/groupher_server/cms/pined_article.ex renamed to lib/groupher_server/cms/pinned_article.ex

@@ -1,4 +1,4 @@
-defmodule GroupherServer.CMS.PinedArticle do
+defmodule GroupherServer.CMS.PinnedArticle do
   @moduledoc false
   alias __MODULE__
 
@@ -8,21 +8,23 @@ defmodule GroupherServer.CMS.PinedArticle do
   alias GroupherServer.CMS
   alias CMS.{Community, Post, Job}
 
-  @required_fields ~w(community_id)a
+  @required_fields ~w(community_id thread)a
   @optional_fields ~w(post_id job_id)a
 
-  @type t :: %PinedArticle{}
-  schema "pined_articles" do
+  @type t :: %PinnedArticle{}
+  schema "pinned_articles" do
     belongs_to(:post, Post, foreign_key: :post_id)
     belongs_to(:job, Job, foreign_key: :job_id)
     belongs_to(:community, Community, foreign_key: :community_id)
 
+    field(:thread, :string)
+
     timestamps(type: :utc_datetime)
   end
 
   @doc false
-  def changeset(%PinedArticle{} = pined_article, attrs) do
-    pined_article
+  def changeset(%PinnedArticle{} = pinned_article, attrs) do
+    pinned_article
     |> cast(attrs, @optional_fields ++ @required_fields)
     |> validate_required(@required_fields)
     |> foreign_key_constraint(:post_id)

lib/helper/error_code.ex

@@ -7,6 +7,7 @@ defmodule Helper.ErrorCode do
   @throttle_base 4200
   @account_base 4300
   @comment_base 4400
+  @article_base 4500
 
   @spec raise_error(Atom.t(), String.t()) :: {:error, [message: String.t(), code: Integer.t()]}
   def raise_error(code_atom, msg) do
@@ -38,8 +39,10 @@ defmodule Helper.ErrorCode do
   def ecode(:throttle_inverval), do: @throttle_base + 1
   def ecode(:throttle_hour), do: @throttle_base + 2
   def ecode(:throttle_day), do: @throttle_base + 3
-  #
+  # comment
   def ecode(:create_comment), do: @comment_base + 1
+  # article
+  def ecode(:too_much_pinned_article), do: @article_base + 1
 
   def ecode, do: @default_base
   # def ecode(_), do: @default_base

priv/repo/migrations/20210429014800_create_pined_article.exs

@@ -2,17 +2,18 @@ defmodule GroupherServer.Repo.Migrations.CreatePinedArticle do
   use Ecto.Migration
 
   def change do
-    create table(:pined_articles) do
+    create table(:pinned_articles) do
       add(:post_id, references(:cms_posts, on_delete: :delete_all))
       add(:job_id, references(:cms_jobs, on_delete: :delete_all))
       add(:community_id, references(:communities, on_delete: :delete_all), null: false)
+      add(:thread, :string)
 
       timestamps()
     end
 
-    create(index(:pined_articles, [:post_id]))
-    create(index(:pined_articles, [:job_id]))
-    create(index(:pined_articles, [:community_id]))
-    create(unique_index(:pined_articles, [:post_id, :job_id, :community_id]))
+    create(index(:pinned_articles, [:post_id]))
+    create(index(:pinned_articles, [:job_id]))
+    create(index(:pinned_articles, [:community_id]))
+    create(unique_index(:pinned_articles, [:post_id, :job_id, :community_id]))
   end
 end

test/groupher_server/cms/article_pin_test.exs

@@ -5,11 +5,14 @@ defmodule GroupherServer.Test.CMS.ArticlePin do
   alias GroupherServer.CMS
 
   alias CMS.{
-    PinedArticle,
+    Community,
+    PinnedArticle,
     Post,
     Job
   }
 
+  @max_pinned_article_count_per_thread Community.max_pinned_article_count_per_thread()
+
   setup do
     {:ok, user} = db_insert(:user)
     {:ok, community} = db_insert(:community)
@@ -22,15 +25,29 @@ defmodule GroupherServer.Test.CMS.ArticlePin do
   end
 
   describe "[cms post pin]" do
-    @tag :wip2
+    @tag :wip
     test "can pin a post", ~m(community post)a do
       {:ok, _} = CMS.pin_article(:post, post.id, community.id)
-      {:ok, pind_article} = ORM.find_by(PinedArticle, %{post_id: post.id})
+      {:ok, pind_article} = ORM.find_by(PinnedArticle, %{post_id: post.id})
 
       assert pind_article.post_id == post.id
     end
 
     @tag :wip2
+    test "one community & thread can only pin certern count of post", ~m(community post user)a do
+      {:ok, post2} = CMS.create_content(community, :post, mock_attrs(:post), user)
+      {:ok, post3} = CMS.create_content(community, :post, mock_attrs(:post), user)
+
+      Enum.reduce(1..@max_pinned_article_count_per_thread, [], fn _, acc ->
+        {:ok, _} = CMS.pin_article(:post, post.id, community.id)
+        acc
+      end)
+
+      {:error, reason} = CMS.pin_article(:post, post3.id, community.id)
+      assert reason |> Keyword.get(:code) == ecode(:too_much_pinned_article)
+    end
+
+    @tag :wip
     test "can not pin a non-exsit post", ~m(community post)a do
       assert {:error, _} = CMS.pin_article(:post, 8848, community.id)
     end