refactor(naming): (#355)

* refactor: create_content -> create_article

* refactor: update_content -> update_article

* refactor: list_collect_folders -> paged_collect_folders

* refactor: list_article_comments -> paged_article_comments

* refactor: wip

Author: mydearxym

cover/excoveralls.json

@@ -22,10 +22,10 @@ defmodule GroupherServer.Accounts do
   defdelegate subscribed_communities(user, filter), to: Profile
 
   # collect folder
-  defdelegate list_collect_folders(user_id, filter), to: CollectFolder
-  defdelegate list_collect_folders(user_id, filter, owner), to: CollectFolder
-  defdelegate list_collect_folder_articles(folder_id, filter, user), to: CollectFolder
-  defdelegate list_collect_folder_articles(folder_id, filter), to: CollectFolder
+  defdelegate paged_collect_folders(user_id, filter), to: CollectFolder
+  defdelegate paged_collect_folders(user_id, filter, owner), to: CollectFolder
+  defdelegate paged_collect_folder_articles(folder_id, filter, user), to: CollectFolder
+  defdelegate paged_collect_folder_articles(folder_id, filter), to: CollectFolder
 
   defdelegate create_collect_folder(attrs, user), to: CollectFolder
   defdelegate update_collect_folder(id, attrs), to: CollectFolder
@@ -35,9 +35,9 @@ defmodule GroupherServer.Accounts do
 
   # achievement
   defdelegate achieve(user, operation, key), to: Achievements
-  defdelegate list_editable_communities(user, filter), to: Achievements
+  defdelegate paged_editable_communities(user, filter), to: Achievements
   defdelegate downgrade_achievement(user, action, count), to: Achievements
-  # defdelegate list_editable_communities(filter), to: Achievements
+  # defdelegate paged_editable_communities(filter), to: Achievements
 
   # publish
   defdelegate published_contents(user, thread, filter), to: Publish
@@ -50,7 +50,7 @@ defmodule GroupherServer.Accounts do
   defdelegate fetch_followings(user, filter), to: Fans
 
   # upvoted articles
-  defdelegate list_upvoted_articles(user_id, filter), to: UpvotedArticles
+  defdelegate paged_upvoted_articles(user_id, filter), to: UpvotedArticles
 
   # mentions
   defdelegate fetch_mentions(user, filter), to: Mails

lib/groupher_server/accounts/accounts.ex

@@ -127,7 +127,7 @@ defmodule GroupherServer.Accounts.Delegate.Achievements do
   """
   alias GroupherServer.CMS.CommunityEditor
 
-  def list_editable_communities(%User{id: user_id}, %{page: page, size: size}) do
+  def paged_editable_communities(%User{id: user_id}, %{page: page, size: size}) do
     with {:ok, user} <- ORM.find(User, user_id) do
       CommunityEditor
       |> where([e], e.user_id == ^user.id)

lib/groupher_server/accounts/delegates/achievements.ex

@@ -29,37 +29,37 @@ defmodule GroupherServer.Accounts.Delegate.CollectFolder do
   @doc """
   list a user's not-private collect folders
   """
-  def list_collect_folders(user_id, filter) do
+  def paged_collect_folders(user_id, filter) do
     query = CollectFolder |> where([c], c.user_id == ^user_id and not c.private)
 
-    do_list_collect_folders(filter, query)
+    do_paged_collect_folders(filter, query)
   end
 
   @doc """
   list a owner's collect folders
   """
-  def list_collect_folders(user_id, filter, %User{id: cur_user_id}) do
+  def paged_collect_folders(user_id, filter, %User{id: cur_user_id}) do
     query =
       if cur_user_id == user_id,
         do: CollectFolder |> where([c], c.user_id == ^user_id),
         else: CollectFolder |> where([c], c.user_id == ^user_id and not c.private)
 
-    do_list_collect_folders(filter, query)
+    do_paged_collect_folders(filter, query)
   end
 
   @doc """
   list article inside a collect folder
   """
-  def list_collect_folder_articles(folder_id, filter) do
+  def paged_collect_folder_articles(folder_id, filter) do
     with {:ok, folder} <- ORM.find(CollectFolder, folder_id) do
       case folder.private do
         true -> raise_error(:private_collect_folder, "#{folder.title} is private")
-        false -> do_list_collect_folder_articles(folder, filter)
+        false -> do_paged_collect_folder_articles(folder, filter)
       end
     end
   end
 
-  def list_collect_folder_articles(folder_id, filter, %User{id: cur_user_id}) do
+  def paged_collect_folder_articles(folder_id, filter, %User{id: cur_user_id}) do
     with {:ok, folder} <- ORM.find(CollectFolder, folder_id) do
       is_valid_request =
         case folder.private do
@@ -69,12 +69,12 @@ defmodule GroupherServer.Accounts.Delegate.CollectFolder do
 
       case is_valid_request do
         false -> raise_error(:private_collect_folder, "#{folder.title} is private")
-        true -> do_list_collect_folder_articles(folder, filter)
+        true -> do_paged_collect_folder_articles(folder, filter)
       end
     end
   end
 
-  defp do_list_collect_folder_articles(folder, filter) do
+  defp do_paged_collect_folder_articles(folder, filter) do
     Repo.preload(folder.collects, @supported_collect_threads)
     |> ORM.embeds_paginater(filter)
     |> ORM.extract_articles(@supported_collect_threads)
@@ -228,7 +228,7 @@ defmodule GroupherServer.Accounts.Delegate.CollectFolder do
     end
   end
 
-  defp do_list_collect_folders(filter, query) do
+  defp do_paged_collect_folders(filter, query) do
     %{page: page, size: size} = filter
 
     query

lib/groupher_server/accounts/delegates/collect_folder.ex

@@ -18,14 +18,14 @@ defmodule GroupherServer.Accounts.Delegate.UpvotedArticles do
   @doc """
   get paged upvoted articles
   """
-  def list_upvoted_articles(user_id, %{thread: thread} = filter) do
+  def paged_upvoted_articles(user_id, %{thread: thread} = filter) do
     thread_upcase = thread |> to_string |> String.upcase()
     where_query = dynamic([a], a.user_id == ^user_id and a.thread == ^thread_upcase)
 
     load_upvoted_articles(where_query, filter)
   end
 
-  def list_upvoted_articles(user_id, filter) do
+  def paged_upvoted_articles(user_id, filter) do
     where_query = dynamic([a], a.user_id == ^user_id)
 
     load_upvoted_articles(where_query, filter)

lib/groupher_server/accounts/delegates/upvoted_articles.ex

@@ -4,6 +4,6 @@ defmodule GroupherServer.Billing do
   alias GroupherServer.Billing.Delegate.CURD
 
   defdelegate create_record(user, attrs), to: CURD
-  defdelegate list_records(user, filter), to: CURD
+  defdelegate paged_records(user, filter), to: CURD
   defdelegate update_record_state(record_id, state), to: CURD
 end

lib/groupher_server/billing/billing.ex

@@ -19,7 +19,7 @@ defmodule GroupherServer.Billing.Delegate.CURD do
   @doc """
   list all the bill records
   """
-  def list_records(%User{id: user_id}, %{page: page, size: size} = _filter) do
+  def paged_records(%User{id: user_id}, %{page: page, size: size} = _filter) do
     with {:ok, user} <- ORM.find(User, user_id) do
       BillRecord
       |> where([r], r.user_id == ^user.id)

lib/groupher_server/billing/delegates/curd.ex

@@ -79,8 +79,8 @@ defmodule GroupherServer.CMS do
   defdelegate paged_articles(queryable, filter), to: ArticleCURD
   defdelegate paged_articles(queryable, filter, user), to: ArticleCURD
 
-  defdelegate create_content(community, thread, attrs, user), to: ArticleCURD
-  defdelegate update_content(content, attrs), to: ArticleCURD
+  defdelegate create_article(community, thread, attrs, user), to: ArticleCURD
+  defdelegate update_article(content, attrs), to: ArticleCURD
 
   defdelegate upvote_article(thread, article_id, user), to: ArticleUpvote
   defdelegate undo_upvote_article(thread, article_id, user), to: ArticleUpvote
@@ -116,15 +116,17 @@ defmodule GroupherServer.CMS do
   defdelegate undo_emotion_to_article(thread, article_id, args, user), to: ArticleEmotion
 
   # Comment CURD
-  defdelegate list_article_comments(thread, article_id, filters, mode), to: ArticleComment
-  defdelegate list_article_comments(thread, article_id, filters, mode, user), to: ArticleComment
+  defdelegate paged_article_comments(thread, article_id, filters, mode), to: ArticleComment
+  defdelegate paged_article_comments(thread, article_id, filters, mode, user), to: ArticleComment
 
-  defdelegate list_folded_article_comments(thread, article_id, filters), to: ArticleComment
-  defdelegate list_folded_article_comments(thread, article_id, filters, user), to: ArticleComment
+  defdelegate paged_folded_article_comments(thread, article_id, filters), to: ArticleComment
+  defdelegate paged_folded_article_comments(thread, article_id, filters, user), to: ArticleComment
 
-  defdelegate list_comment_replies(comment_id, filters), to: ArticleComment
-  defdelegate list_comment_replies(comment_id, filters, user), to: ArticleComment
-  defdelegate list_article_comments_participators(thread, content_id, filters), to: ArticleComment
+  defdelegate paged_comment_replies(comment_id, filters), to: ArticleComment
+  defdelegate paged_comment_replies(comment_id, filters, user), to: ArticleComment
+
+  defdelegate paged_article_comments_participators(thread, content_id, filters),
+    to: ArticleComment
 
   defdelegate create_article_comment(thread, article_id, args, user), to: ArticleComment
   defdelegate update_article_comment(comment, content), to: ArticleComment
@@ -149,26 +151,26 @@ defmodule GroupherServer.CMS do
   defdelegate create_comment(thread, content_id, args, user), to: CommentCURD
   defdelegate update_comment(thread, id, args, user), to: CommentCURD
   defdelegate delete_comment(thread, content_id), to: CommentCURD
-  defdelegate list_replies(thread, comment, user), to: CommentCURD
+  defdelegate paged_replies(thread, comment, user), to: CommentCURD
   defdelegate reply_comment(thread, comment, args, user), to: CommentCURD
 
-  defdelegate list_comments(thread, content_id, filters), to: CommentCURD
-  defdelegate list_comments_participators(thread, content_id, filters), to: CommentCURD
+  defdelegate paged_comments(thread, content_id, filters), to: CommentCURD
+  defdelegate paged_comments_participators(thread, content_id, filters), to: CommentCURD
 
   # TODO: move report to abuse report module
   defdelegate report_article(thread, article_id, reason, attr, user), to: AbuseReport
   defdelegate report_article_comment(comment_id, reason, attr, user), to: AbuseReport
   defdelegate report_account(account_id, reason, attr, user), to: AbuseReport
   defdelegate undo_report_account(account_id, user), to: AbuseReport
   defdelegate undo_report_article(thread, article_id, user), to: AbuseReport
-  defdelegate list_reports(filter), to: AbuseReport
+  defdelegate paged_reports(filter), to: AbuseReport
   defdelegate undo_report_article_comment(comment_id, user), to: AbuseReport
 
   # Passport CURD
   defdelegate stamp_passport(rules, user), to: PassportCURD
   defdelegate erase_passport(rules, user), to: PassportCURD
   defdelegate get_passport(user), to: PassportCURD
-  defdelegate list_passports(community, key), to: PassportCURD
+  defdelegate paged_passports(community, key), to: PassportCURD
   defdelegate delete_passport(user), to: PassportCURD
 
   # search

lib/groupher_server/cms/cms.ex

@@ -35,22 +35,22 @@ defmodule GroupherServer.CMS.Delegate.AbuseReport do
   @doc """
   list paged reports for article comemnts
   """
-  def list_reports(%{content_type: :account, content_id: content_id} = filter) do
+  def paged_reports(%{content_type: :account, content_id: content_id} = filter) do
     with {:ok, info} <- match(:account) do
       query =
         from(r in AbuseReport,
           where: field(r, ^info.foreign_key) == ^content_id,
           preload: :account
         )
 
-      do_list_reports(query, :account, filter)
+      do_paged_reports(query, :account, filter)
     end
   end
 
   @doc """
   list paged reports for article comemnts
   """
-  def list_reports(%{content_type: :article_comment, content_id: content_id} = filter) do
+  def paged_reports(%{content_type: :article_comment, content_id: content_id} = filter) do
     with {:ok, info} <- match(:article_comment) do
       query =
         from(r in AbuseReport,
@@ -59,14 +59,14 @@ defmodule GroupherServer.CMS.Delegate.AbuseReport do
           preload: [article_comment: :author]
         )
 
-      do_list_reports(query, :article_comment, filter)
+      do_paged_reports(query, :article_comment, filter)
     end
   end
 
   @doc """
   list paged reports for article
   """
-  def list_reports(%{content_type: thread, content_id: content_id} = filter)
+  def paged_reports(%{content_type: thread, content_id: content_id} = filter)
       when thread in @article_threads do
     with {:ok, info} <- match(thread) do
       query =
@@ -75,12 +75,12 @@ defmodule GroupherServer.CMS.Delegate.AbuseReport do
           preload: [^thread, :operate_user]
         )
 
-      do_list_reports(query, thread, filter)
+      do_paged_reports(query, thread, filter)
     end
   end
 
-  # def list_reports(%{content_type: thread} = filter) when thread in @article_threads do
-  def list_reports(%{content_type: thread} = filter) do
+  # def paged_reports(%{content_type: thread} = filter) when thread in @article_threads do
+  def paged_reports(%{content_type: thread} = filter) do
     with {:ok, info} <- match(thread) do
       query =
         from(r in AbuseReport,
@@ -89,14 +89,14 @@ defmodule GroupherServer.CMS.Delegate.AbuseReport do
           preload: [article_comment: :author]
         )
 
-      do_list_reports(query, thread, filter)
+      do_paged_reports(query, thread, filter)
     end
   end
 
-  def list_reports(filter) do
+  def paged_reports(filter) do
     query = from(r in AbuseReport, preload: [:operate_user])
 
-    do_list_reports(query, filter)
+    do_paged_reports(query, filter)
   end
 
   @doc """
@@ -196,7 +196,7 @@ defmodule GroupherServer.CMS.Delegate.AbuseReport do
     undo_report_article(:article_comment, comment_id, user)
   end
 
-  defp do_list_reports(query, thread, filter) do
+  defp do_paged_reports(query, thread, filter) do
     %{page: page, size: size} = filter
 
     query
@@ -206,7 +206,7 @@ defmodule GroupherServer.CMS.Delegate.AbuseReport do
     |> done()
   end
 
-  defp do_list_reports(query, %{page: page, size: size}) do
+  defp do_paged_reports(query, %{page: page, size: size}) do
     query |> ORM.paginater(~m(page size)a) |> done()
   end
 

lib/groupher_server/cms/delegates/abuse_report.ex

@@ -30,48 +30,48 @@ defmodule GroupherServer.CMS.Delegate.ArticleComment do
   [timeline-mode] list paged article comments
   """
 
-  def list_article_comments(thread, article_id, filters, mode, user \\ nil)
+  def paged_article_comments(thread, article_id, filters, mode, user \\ nil)
 
-  def list_article_comments(thread, article_id, filters, :timeline, user) do
+  def paged_article_comments(thread, article_id, filters, :timeline, user) do
     where_query = dynamic([c], not c.is_folded and not c.is_pinned)
-    do_list_article_comment(thread, article_id, filters, where_query, user)
+    do_paged_article_comment(thread, article_id, filters, where_query, user)
   end
 
   @doc """
   [replies-mode] list paged article comments
   """
-  def list_article_comments(thread, article_id, filters, :replies, user) do
+  def paged_article_comments(thread, article_id, filters, :replies, user) do
     where_query =
       dynamic(
         [c],
         is_nil(c.reply_to_id) and not c.is_folded and not c.is_pinned
       )
 
-    do_list_article_comment(thread, article_id, filters, where_query, user)
+    do_paged_article_comment(thread, article_id, filters, where_query, user)
   end
 
-  def list_folded_article_comments(thread, article_id, filters) do
+  def paged_folded_article_comments(thread, article_id, filters) do
     where_query = dynamic([c], c.is_folded and not c.is_pinned)
-    do_list_article_comment(thread, article_id, filters, where_query, nil)
+    do_paged_article_comment(thread, article_id, filters, where_query, nil)
   end
 
-  def list_folded_article_comments(thread, article_id, filters, user) do
+  def paged_folded_article_comments(thread, article_id, filters, user) do
     where_query = dynamic([c], c.is_folded and not c.is_pinned)
-    do_list_article_comment(thread, article_id, filters, where_query, user)
+    do_paged_article_comment(thread, article_id, filters, where_query, user)
   end
 
   @doc """
   list paged comment replies
   """
-  def list_comment_replies(comment_id, filters, user \\ nil)
+  def paged_comment_replies(comment_id, filters, user \\ nil)
 
-  def list_comment_replies(comment_id, filters, user) do
-    do_list_comment_replies(comment_id, filters, user)
+  def paged_comment_replies(comment_id, filters, user) do
+    do_paged_comment_replies(comment_id, filters, user)
   end
 
-  @spec list_article_comments_participators(T.comment_thread(), Integer.t(), T.paged_filter()) ::
+  @spec paged_article_comments_participators(T.comment_thread(), Integer.t(), T.paged_filter()) ::
           {:ok, T.paged_users()}
-  def list_article_comments_participators(thread, article_id, filters) do
+  def paged_article_comments_participators(thread, article_id, filters) do
     %{page: page, size: size} = filters
 
     with {:ok, thread_query} <- match(thread, :query, article_id) do
@@ -196,7 +196,7 @@ defmodule GroupherServer.CMS.Delegate.ArticleComment do
     )
   end
 
-  defp do_list_article_comment(thread, article_id, filters, where_query, user) do
+  defp do_paged_article_comment(thread, article_id, filters, where_query, user) do
     %{page: page, size: size} = filters
     sort = Map.get(filters, :sort, :asc_inserted)
 
@@ -216,7 +216,7 @@ defmodule GroupherServer.CMS.Delegate.ArticleComment do
     end
   end
 
-  defp do_list_comment_replies(comment_id, filters, user) do
+  defp do_paged_comment_replies(comment_id, filters, user) do
     %{page: page, size: size} = filters
     query = from(c in ArticleComment, preload: [reply_to: :author])