refactor(account): published artiments (#411)

* refactor(renaming): publishd_article_comments -> published_comments

* refactor(cms): reuse paged_articles logic

* refactor(account): move published logic to CMS

Author: mydearxym

lib/groupher_server/accounts/accounts.ex

@@ -47,8 +47,8 @@ defmodule GroupherServer.Accounts do
 
   # publish
   defdelegate paged_published_articles(user, thread, filter), to: Publish
-  defdelegate paged_published_article_comments(user, thread, filter), to: Publish
-  defdelegate paged_published_article_comments(user, thread), to: Publish
+  defdelegate paged_published_comments(user, thread, filter), to: Publish
+  defdelegate paged_published_comments(user, thread), to: Publish
   defdelegate update_published_states(user, thread), to: Publish
 
   # fans

lib/groupher_server/accounts/delegates/publish.ex

@@ -3,27 +3,20 @@ defmodule GroupherServer.Accounts.Delegate.Publish do
   user followers / following related
   """
   import Ecto.Query, warn: false
-  import Helper.Utils, only: [done: 1, ensure: 2]
-  # import Helper.ErrorCode
-  import ShortMaps
+  import Helper.Utils, only: [ensure: 2]
 
-  import GroupherServer.CMS.Helper.Matcher
+  alias GroupherServer.{Accounts, CMS}
+  alias Accounts.Model.{Embeds, User}
 
-  alias GroupherServer.Accounts.Model.{Embeds, User}
-  alias GroupherServer.CMS.Model.Comment
-
-  alias Helper.{ORM, QueryBuilder}
+  alias Helper.ORM
 
   @default_meta Embeds.UserMeta.default_meta()
 
   @doc """
   get paged published contets of a user
   """
   def paged_published_articles(%User{id: user_id}, thread, filter) do
-    with {:ok, info} <- match(thread),
-         {:ok, user} <- ORM.find(User, user_id) do
-      do_paged_published_articles(info.model, user, filter)
-    end
+    CMS.paged_published_articles(thread, filter, user_id)
   end
 
   @doc """
@@ -32,60 +25,21 @@ defmodule GroupherServer.Accounts.Delegate.Publish do
   def update_published_states(user_id, thread) do
     filter = %{page: 1, size: 1}
 
-    with {:ok, info} <- match(thread),
-         {:ok, user} <- ORM.find(User, user_id),
-         {:ok, paged_published_articles} <- do_paged_published_articles(info.model, user, filter) do
-      articles_count = paged_published_articles.total_count
-
-      meta =
-        ensure(user.meta, @default_meta) |> Map.put(:"published_#{thread}s_count", articles_count)
+    with {:ok, user} <- ORM.find(User, user_id),
+         {:ok, paged_articles} <- CMS.paged_published_articles(thread, filter, user_id) do
+      #
+      user_meta = ensure(user.meta, @default_meta)
+      meta = Map.put(user_meta, :"published_#{thread}s_count", paged_articles.total_count)
 
       ORM.update_meta(user, meta)
     end
   end
 
-  defp do_paged_published_articles(queryable, %User{} = user, %{page: page, size: size} = filter) do
-    queryable
-    |> join(:inner, [article], author in assoc(article, :author))
-    |> where([article, author], author.user_id == ^user.id)
-    |> select([article, author], article)
-    |> QueryBuilder.filter_pack(filter)
-    |> ORM.paginater(~m(page size)a)
-    |> done()
+  def paged_published_comments(user, filter) do
+    CMS.paged_published_comments(user, filter)
   end
 
-  def paged_published_article_comments(%User{id: user_id}, %{page: page, size: size} = filter) do
-    with {:ok, user} <- ORM.find(User, user_id) do
-      Comment
-      |> join(:inner, [comment], author in assoc(comment, :author))
-      |> where([comment, author], author.id == ^user.id)
-      |> QueryBuilder.filter_pack(filter)
-      |> ORM.paginater(~m(page size)a)
-      |> ORM.extract_and_assign_article()
-      |> done()
-    end
-  end
-
-  def paged_published_article_comments(
-        %User{id: user_id},
-        thread,
-        %{page: page, size: size} = filter
-      ) do
-    with {:ok, user} <- ORM.find(User, user_id) do
-      thread = thread |> to_string |> String.upcase()
-      thread_atom = thread |> String.downcase() |> String.to_atom()
-
-      article_preload = Keyword.new([{thread_atom, [author: :user]}])
-      query = from(comment in Comment, preload: ^article_preload)
-
-      query
-      |> join(:inner, [comment], author in assoc(comment, :author))
-      |> where([comment, author], author.id == ^user.id)
-      |> where([comment, author], comment.thread == ^thread)
-      |> QueryBuilder.filter_pack(filter)
-      |> ORM.paginater(~m(page size)a)
-      |> ORM.extract_and_assign_article()
-      |> done()
-    end
+  def paged_published_comments(user, thread, filter) do
+    CMS.paged_published_comments(user, thread, filter)
   end
 end

lib/groupher_server/cms/cms.ex

@@ -86,6 +86,7 @@ defmodule GroupherServer.CMS do
 
   defdelegate paged_articles(queryable, filter), to: ArticleCURD
   defdelegate paged_articles(queryable, filter, user), to: ArticleCURD
+  defdelegate paged_published_articles(queryable, filter, user), to: ArticleCURD
 
   defdelegate create_article(community, thread, attrs, user), to: ArticleCURD
   defdelegate update_article(article, attrs), to: ArticleCURD
@@ -133,6 +134,9 @@ defmodule GroupherServer.CMS do
   defdelegate paged_comments(thread, article_id, filters, mode), to: CommentCurd
   defdelegate paged_comments(thread, article_id, filters, mode, user), to: CommentCurd
 
+  defdelegate paged_published_comments(user, thread, filters), to: CommentCurd
+  defdelegate paged_published_comments(user, filters), to: CommentCurd
+
   defdelegate paged_folded_article_comments(thread, article_id, filters), to: CommentCurd
   defdelegate paged_folded_article_comments(thread, article_id, filters, user), to: CommentCurd
 

lib/groupher_server/cms/delegates/article_curd.ex

@@ -91,6 +91,9 @@ defmodule GroupherServer.CMS.Delegate.ArticleCURD do
     end
   end
 
+  @doc """
+  get paged articles
+  """
   def paged_articles(thread, filter) do
     %{page: page, size: size} = filter
 
@@ -105,14 +108,26 @@ defmodule GroupherServer.CMS.Delegate.ArticleCURD do
   end
 
   def paged_articles(thread, filter, %User{} = user) do
+    with {:ok, stateless_paged_articles} <- paged_articles(thread, filter) do
+      stateless_paged_articles
+      |> mark_viewer_emotion_states(user)
+      |> mark_viewer_has_states(user)
+      |> done()
+    end
+  end
+
+  @doc "paged published articles for accounts"
+  def paged_published_articles(thread, filter, user_id) do
     %{page: page, size: size} = filter
 
-    with {:ok, info} <- match(thread) do
+    with {:ok, info} <- match(thread),
+         {:ok, user} <- ORM.find(User, user_id) do
       info.model
-      |> QueryBuilder.domain_query(filter)
-      |> QueryBuilder.filter_pack(Map.merge(filter, %{mark_delete: false}))
+      |> join(:inner, [article], author in assoc(article, :author))
+      |> where([article, author], author.user_id == ^user.id)
+      |> select([article, author], article)
+      |> QueryBuilder.filter_pack(filter)
       |> ORM.paginater(~m(page size)a)
-      |> add_pin_articles_ifneed(info.model, filter)
       |> mark_viewer_emotion_states(user)
       |> mark_viewer_has_states(user)
       |> done()

lib/groupher_server/cms/delegates/comment_curd.ex

@@ -52,6 +52,37 @@ defmodule GroupherServer.CMS.Delegate.CommentCurd do
     do_paged_comment(thread, article_id, filters, where_query, user)
   end
 
+  def paged_published_comments(%User{id: user_id}, filter) do
+    %{page: page, size: size} = filter
+
+    Comment
+    |> join(:inner, [comment], author in assoc(comment, :author))
+    |> where([comment, author], author.id == ^user_id)
+    |> QueryBuilder.filter_pack(filter)
+    |> ORM.paginater(~m(page size)a)
+    |> ORM.extract_and_assign_article()
+    |> done()
+  end
+
+  def paged_published_comments(%User{id: user_id}, thread, filter) do
+    %{page: page, size: size} = filter
+
+    thread = thread |> to_string |> String.upcase()
+    thread_atom = thread |> String.downcase() |> String.to_atom()
+
+    article_preload = Keyword.new([{thread_atom, [author: :user]}])
+    query = from(comment in Comment, preload: ^article_preload)
+
+    query
+    |> join(:inner, [comment], author in assoc(comment, :author))
+    |> where([comment, author], comment.thread == ^thread)
+    |> where([comment, author], author.id == ^user_id)
+    |> QueryBuilder.filter_pack(filter)
+    |> ORM.paginater(~m(page size)a)
+    |> ORM.extract_and_assign_article()
+    |> done()
+  end
+
   def paged_folded_article_comments(thread, article_id, filters) do
     where_query = dynamic([c], c.is_folded and not c.is_pinned)
     do_paged_comment(thread, article_id, filters, where_query, nil)

lib/groupher_server/cms/delegates/helper.ex

@@ -56,15 +56,15 @@ defmodule GroupherServer.CMS.Delegate.Helper do
   defp get_supported_mentions(:comment), do: @supported_comment_emotions
   defp get_supported_mentions(_), do: @supported_emotions
 
-  def mark_viewer_emotion_states(paged_contents, nil), do: paged_contents
-  def mark_viewer_emotion_states(%{entries: []} = paged_contents, _), do: paged_contents
-  def mark_viewer_emotion_states(paged_contents, nil, :comment), do: paged_contents
+  def mark_viewer_emotion_states(paged_artiments, nil), do: paged_artiments
+  def mark_viewer_emotion_states(%{entries: []} = paged_artiments, _), do: paged_artiments
+  def mark_viewer_emotion_states(paged_artiments, nil, :comment), do: paged_artiments
 
   @doc """
   mark viewer emotions status for article or comment
   """
   def mark_viewer_emotion_states(
-        %{entries: entries} = paged_contents,
+        %{entries: entries} = paged_artiments,
         %User{} = user,
         type \\ :article
       ) do
@@ -84,7 +84,7 @@ defmodule GroupherServer.CMS.Delegate.Helper do
         Map.put(article, :emotions, updated_emotions)
       end)
 
-    %{paged_contents | entries: new_entries}
+    %{paged_artiments | entries: new_entries}
   end
 
   @doc """

lib/groupher_server_web/resolvers/accounts_resolver.ex

@@ -191,17 +191,17 @@ defmodule GroupherServerWeb.Resolvers.Accounts do
     Accounts.paged_published_articles(cur_user, thread, filter)
   end
 
-  def paged_published_article_comments(_root, ~m(login filter thread)a, _info) do
+  def paged_published_comments(_root, ~m(login filter thread)a, _info) do
     with {:ok, user_id} <- Accounts.get_userid_and_cache(login) do
-      Accounts.paged_published_article_comments(%User{id: user_id}, thread, filter)
+      Accounts.paged_published_comments(%User{id: user_id}, thread, filter)
     else
       _ -> raise_error(:not_exsit, "#{login} not found")
     end
   end
 
-  def paged_published_article_comments(_root, ~m(login filter)a, _info) do
+  def paged_published_comments(_root, ~m(login filter)a, _info) do
     with {:ok, user_id} <- Accounts.get_userid_and_cache(login) do
-      Accounts.paged_published_article_comments(%User{id: user_id}, filter)
+      Accounts.paged_published_comments(%User{id: user_id}, filter)
     else
       _ -> raise_error(:not_exsit, "#{login} not found")
     end

lib/groupher_server_web/schema/account/account_queries.ex

@@ -121,13 +121,13 @@ defmodule GroupherServerWeb.Schema.Account.Queries do
     end
 
     @desc "get paged published article comments"
-    field :paged_published_article_comments, :paged_comments do
+    field :paged_published_comments, :paged_comments do
       arg(:login, non_null(:string))
       arg(:filter, non_null(:paged_filter))
       arg(:thread, :thread, default_value: :post)
 
       middleware(M.PageSizeProof)
-      resolve(&R.Accounts.paged_published_article_comments/3)
+      resolve(&R.Accounts.paged_published_comments/3)
     end
 
     published_article_queries()

test/groupher_server/accounts/published/published_blogs_test.exs

@@ -81,7 +81,7 @@ defmodule GroupherServer.Test.Accounts.Published.Blog do
       end)
 
       filter = %{page: 1, size: 20}
-      {:ok, articles} = Accounts.paged_published_article_comments(user, :blog, filter)
+      {:ok, articles} = Accounts.paged_published_comments(user, :blog, filter)
 
       entries = articles.entries
       article = entries |> List.first()

test/groupher_server/accounts/published/published_jobs_test.exs

@@ -81,7 +81,7 @@ defmodule GroupherServer.Test.Accounts.Published.Job do
       end)
 
       filter = %{page: 1, size: 20}
-      {:ok, articles} = Accounts.paged_published_article_comments(user, :job, filter)
+      {:ok, articles} = Accounts.paged_published_comments(user, :job, filter)
 
       entries = articles.entries
       article = entries |> List.first()