refactor: pin & trash system for posts

Author: mydearxym

Makefile

@@ -40,22 +40,24 @@ launch.dev:
 launch.mock:
 	MIX_ENV=mock mix phx.server
 launch.prod:
-	mix phx.server
+	MIX_ENV=prod mix phx.server
 
 migrate:
 	mix ecto.migrate
 migrate.mock:
 	MIX_ENV=mock mix ecto.migrate
 rollback:
 	mix ecto.rollback
-migrate.mock:
-  MIX_ENV=mock mix ecto.migrate
 rollback.mock:
-  MIX_ENV=mock mix ecto.rollback
+	MIX_ENV=mock mix ecto.rollback
+rollback.test:
+	MIX_ENV=test mix ecto.rollback
 migrate.dev:
 	MIX_ENV=dev mix ecto.migrate
+migrate.test:
+	MIX_ENV=test mix ecto.migrate
 rollback.dev:
-  MIX_ENV=dev mix ecto.rollback
+	MIX_ENV=dev mix ecto.rollback
 
 gen.help:
 	$(call gen.help)

lib/helper/certification.ex

@@ -53,10 +53,23 @@ defmodule Helper.Certification do
         "post.community.unset",
         "job.community.set",
         "job.community.unset",
+        # flag on content
         "post.pin",
         "post.undo_pin",
         "post.trash",
-        "post.undo_trash"
+        "post.undo_trash",
+        "job.pin",
+        "job.undo_pin",
+        "job.trash",
+        "job.undo_trash",
+        "video.pin",
+        "video.undo_pin",
+        "video.trash",
+        "video.undo_trash",
+        "repo.pin",
+        "repo.undo_pin",
+        "repo.trash",
+        "repo.undo_trash"
       ],
       community: [
         # thread

lib/helper/query_builder.ex

@@ -88,8 +88,6 @@ defmodule Helper.QueryBuilder do
     |> order_by([_, s], {^direction, fragment("count(?)", s.id)})
   end
 
-  def default_article_filters, do: %{pin: false, trash: false}
-
   def filter_pack(queryable, filter) when is_map(filter) do
     Enum.reduce(filter, queryable, fn
       {:sort, :desc_inserted}, queryable ->
@@ -186,13 +184,13 @@ defmodule Helper.QueryBuilder do
       {:first, first}, queryable ->
         queryable |> limit(^first)
 
-      {:pin, bool}, queryable ->
-        queryable
-        |> where([p], p.pin == ^bool)
+      # {:pin, bool}, queryable ->
+      #   queryable
+      #   |> where([p], p.pin == ^bool)
 
-      {:trash, bool}, queryable ->
-        queryable
-        |> where([p], p.trash == ^bool)
+      # {:trash, bool}, queryable ->
+      #   queryable
+      #   |> where([p], p.trash == ^bool)
 
       {_, _}, queryable ->
         queryable

lib/mastani_server/cms/cms.ex

@@ -59,7 +59,8 @@ defmodule MastaniServer.CMS do
 
   # ArticleOperation
   # >> set flag on article, like: pin / unpin article
-  defdelegate set_flag(queryable, id, attrs, user), to: ArticleOperation
+  defdelegate set_community_flags(queryable, community_id, attrs), to: ArticleOperation
+
   # >> tag: set / unset
   defdelegate set_tag(community, thread, tag, content_id), to: ArticleOperation
   defdelegate unset_tag(thread, tag, content_id), to: ArticleOperation

lib/mastani_server/cms/delegates/article_curd.ex

@@ -21,39 +21,70 @@ defmodule MastaniServer.CMS.Delegate.ArticleCURD do
   get paged post / job ...
   """
   def paged_contents(queryable, filter) do
-    normal_content_fr = filter |> Map.merge(QueryBuilder.default_article_filters())
-
     queryable
-    |> ORM.find_all(normal_content_fr)
+    |> flag_query(filter)
+    |> ORM.find_all(filter)
     |> add_pin_contents_ifneed(queryable, filter)
   end
 
+  defp flag_query(queryable, filter, flag \\ %{}) do
+    flag = %{pin: false, trash: false} |> Map.merge(flag)
+
+    # TODO: remove case judge ?
+    case filter |> Map.has_key?(:community) do
+      true ->
+        queryable
+        |> join(:inner, [q], f in assoc(q, :community_flags))
+        |> where([q, f], f.pin == ^flag.pin and f.trash == ^flag.trash)
+        |> join(:inner, [q, f], c in assoc(f, :community))
+        |> where([q, f, c], c.raw == ^filter.community)
+
+      false ->
+        # for runing tests usage, no flag when db_insert
+        queryable
+    end
+  end
+
   # only first page need pin contents
   defp add_pin_contents_ifneed(contents, queryable, filter) do
     with {:ok, normal_contents} <- contents,
+         true <- Map.has_key?(filter, :community),
          true <- 1 == Map.get(normal_contents, :page_number) do
-      pin_content_fr = filter |> Map.merge(%{pin: true})
-      {:ok, pined_content} = queryable |> ORM.find_all(pin_content_fr)
+      {:ok, pined_content} =
+        queryable
+        |> flag_query(filter, %{pin: true})
+        |> ORM.find_all(filter)
+
+      # TODO: add hot post pin/trash state ?
+      # don't by flag_changeset, dataloader make things complex
+      concat_contents(pined_content, normal_contents)
+    else
+      _error ->
+        contents
+    end
+  end
 
-      case pined_content |> Map.get(:total_count) do
-        0 ->
-          contents
+  defp concat_contents(pined_content, normal_contents) do
+    case pined_content |> Map.get(:total_count) do
+      0 ->
+        {:ok, normal_contents}
 
-        _ ->
-          pind_entries = pined_content |> Map.get(:entries)
-          normal_entries = normal_contents |> Map.get(:entries)
+      _ ->
+        # NOTE: this is tricy, should use dataloader refactor
+        pind_entries =
+          pined_content
+          |> Map.get(:entries)
+          |> Enum.map(&struct(&1, %{pin: true}))
 
-          normal_count = normal_contents |> Map.get(:total_count)
-          pind_count = pined_content |> Map.get(:total_count)
+        normal_entries = normal_contents |> Map.get(:entries)
 
-          normal_contents
-          |> Map.put(:entries, pind_entries ++ normal_entries)
-          |> Map.put(:total_count, pind_count + normal_count)
-          |> done
-      end
-    else
-      _error ->
-        contents
+        normal_count = normal_contents |> Map.get(:total_count)
+        pind_count = pined_content |> Map.get(:total_count)
+
+        normal_contents
+        |> Map.put(:entries, pind_entries ++ normal_entries)
+        |> Map.put(:total_count, pind_count + normal_count)
+        |> done
     end
   end
 
@@ -84,6 +115,21 @@ defmodule MastaniServer.CMS.Delegate.ArticleCURD do
       |> Multi.run(:set_community, fn %{add_content_author: content} ->
         ArticleOperation.set_community(community, thread, content.id)
       end)
+      |> Multi.run(:set_community_flag, fn %{add_content_author: content} ->
+        # TODO: remove this judge, as content should have a flag
+        case action |> Map.has_key?(:flag) do
+          true ->
+            ArticleOperation.set_community_flags(content, community.id, %{
+              pin: false,
+              trash: false
+            })
+
+          false ->
+            {:ok, "pass"}
+        end
+
+        # Repo.insert(%CMS.PostCommunityFlags{post_id: content.id, community_id: community.id, })
+      end)
       |> Multi.run(:set_tag, fn %{add_content_author: content} ->
         case attrs |> Map.has_key?(:tags) do
           true -> set_tags(community, thread, content.id, attrs.tags)
@@ -108,6 +154,10 @@ defmodule MastaniServer.CMS.Delegate.ArticleCURD do
     {:error, [message: "set community", code: ecode(:create_fails)]}
   end
 
+  defp create_content_result({:error, :set_community_flag, _result, _steps}) do
+    {:error, [message: "set community flag", code: ecode(:create_fails)]}
+  end
+
   defp create_content_result({:error, :set_tag, result, _steps}) do
     {:error, result}
   end

lib/mastani_server/cms/delegates/article_operation.ex

@@ -5,21 +5,33 @@ defmodule MastaniServer.CMS.Delegate.ArticleOperation do
   import MastaniServer.CMS.Utils.Matcher
   import Ecto.Query, warn: false
   import Helper.ErrorCode
+  # import ShortMaps
 
   alias Helper.ORM
   alias MastaniServer.Accounts.User
-  alias MastaniServer.CMS.{Community, Tag}
+  alias MastaniServer.CMS.{Community, PinState, Post, PostCommunityFlags, Tag}
   alias MastaniServer.Repo
 
   @doc """
   pin / unpin, trash / untrash articles
   """
-  def set_flag(queryable, id, %{pin: _} = attrs, %User{} = _user) do
-    queryable |> ORM.find_update(id, attrs)
+  def set_community_flags(%Post{id: post_id}, community_id, attrs) do
+    with {:ok, post} <- ORM.find(Post, post_id),
+         {:ok, community} <- ORM.find(Community, community_id),
+         {:ok, _} <- insert_flag_record(post, community_id, attrs) do
+      ORM.find(Post, post.id)
+    end
   end
 
-  def set_flag(queryable, id, %{trash: _} = attrs, %User{} = _user) do
-    queryable |> ORM.find_update(id, attrs)
+  defp insert_flag_record(%Post{id: id}, community_id, attrs) do
+    clauses = %{
+      post_id: id,
+      community_id: community_id
+    }
+
+    attrs = attrs |> Map.merge(clauses)
+
+    PostCommunityFlags |> ORM.upsert_by(clauses, attrs)
   end
 
   def set_community(%Community{id: community_id}, thread, content_id) when valid_thread(thread) do

lib/mastani_server/cms/post.ex

@@ -4,10 +4,19 @@ defmodule MastaniServer.CMS.Post do
 
   use Ecto.Schema
   import Ecto.Changeset
-  alias MastaniServer.CMS.{Author, Community, PostComment, PostFavorite, PostStar, Tag}
+
+  alias MastaniServer.CMS.{
+    Author,
+    Community,
+    PostComment,
+    PostCommunityFlags,
+    PostFavorite,
+    PostStar,
+    Tag
+  }
 
   @required_fields ~w(title body digest length)a
-  @optional_fields ~w(link_addr pin trash)
+  @optional_fields ~w(link_addr)a
 
   @type t :: %Post{}
   schema "cms_posts" do
@@ -18,14 +27,18 @@ defmodule MastaniServer.CMS.Post do
     field(:length, :integer)
     field(:views, :integer, default: 0)
 
-    field(:pin, :boolean, default_value: false)
-    field(:trash, :boolean, default_value: false)
+    # has_many(:pins, {"posts_pins", PostPin})
+    has_many(:community_flags, {"posts_communities_flags", PostCommunityFlags})
+
+    # NOTE: this one is tricky, pin is dynamic changed when return by func: add_pin_contents_ifneed
+    field(:pin, :boolean, default_value: false, virtual: true)
+    field(:trash, :boolean, default_value: false, virtual: true)
+
     belongs_to(:author, Author)
 
     # TODO
     # 相关文章
     # has_may(:related_post, ...)
-
     has_many(:comments, {"posts_comments", PostComment})
     has_many(:favorites, {"posts_favorites", PostFavorite})
     has_many(:stars, {"posts_stars", PostStar})
@@ -60,4 +73,12 @@ defmodule MastaniServer.CMS.Post do
     # |> foreign_key_constraint(:posts_tags, name: :posts_tags_tag_id_fkey)
     # |> foreign_key_constraint(name: :posts_tags_tag_id_fkey)
   end
+
+  @doc """
+  for update flag
+  """
+  # def flag_changeset(%Post{} = post, attrs) do
+  # post
+  # |> cast(attrs, ~w(pin trash)a)
+  # end
 end

lib/mastani_server/cms/post_community_flag.ex

@@ -0,0 +1,36 @@
+defmodule MastaniServer.CMS.PostCommunityFlags do
+  @moduledoc false
+  alias __MODULE__
+
+  use Ecto.Schema
+  import Ecto.Changeset
+  alias Helper.Certification
+  alias MastaniServer.Accounts
+  alias MastaniServer.CMS.{Community, Post}
+
+  @required_fields ~w(post_id community_id)a
+  @optional_fields ~w(pin trash refined)a
+
+  @type t :: %PostCommunityFlags{}
+
+  schema "posts_communities_flags" do
+    belongs_to(:post, Post, foreign_key: :post_id)
+    belongs_to(:community, Community, foreign_key: :community_id)
+
+    field(:pin, :boolean)
+    field(:refined, :boolean)
+    field(:trash, :boolean)
+
+    timestamps(type: :utc_datetime)
+  end
+
+  @doc false
+  def changeset(%PostCommunityFlags{} = post_community_flags, attrs) do
+    post_community_flags
+    |> cast(attrs, @optional_fields ++ @required_fields)
+    |> validate_required(@required_fields)
+    |> foreign_key_constraint(:post_id)
+    |> foreign_key_constraint(:community_id)
+    |> unique_constraint(:post_id, name: :posts_communities_flags_post_id_community_id_index)
+  end
+end

lib/mastani_server/cms/utils/matcher.ex

@@ -19,7 +19,8 @@ defmodule MastaniServer.CMS.Utils.Matcher do
     Tag,
     Community,
     PostCommentLike,
-    PostCommentDislike
+    PostCommentDislike,
+    PostCommunityFlags
   }
 
   @support_thread [:post, :video, :repo, :job]
@@ -44,7 +45,9 @@ defmodule MastaniServer.CMS.Utils.Matcher do
 
   def match_action(:post, :star), do: {:ok, %{target: Post, reactor: PostStar, preload: :user}}
   def match_action(:post, :tag), do: {:ok, %{target: Post, reactor: Tag}}
-  def match_action(:post, :community), do: {:ok, %{target: Post, reactor: Community}}
+
+  def match_action(:post, :community),
+    do: {:ok, %{target: Post, reactor: Community, flag: PostCommunityFlags}}
 
   def match_action(:post, :comment),
     do: {:ok, %{target: Post, reactor: PostComment, preload: :author}}