Merge branch 'fix/update-favorites-category' into dev

Author: mydearxym

lib/mastani_server/accounts/accounts.ex

@@ -23,8 +23,8 @@ defmodule MastaniServer.Accounts do
   defdelegate create_favorite_category(user, attrs), to: FavoriteCategory
   defdelegate update_favorite_category(user, attrs), to: FavoriteCategory
   defdelegate delete_favorite_category(user, id), to: FavoriteCategory
-  defdelegate set_favorites(user, thread, content_id, category_title), to: FavoriteCategory
-  defdelegate unset_favorites(user, thread, content_id, category_title), to: FavoriteCategory
+  defdelegate set_favorites(user, thread, content_id, category_id), to: FavoriteCategory
+  defdelegate unset_favorites(user, thread, content_id, category_id), to: FavoriteCategory
 
   # achievement
   defdelegate achieve(user, operation, key), to: Achievements

lib/mastani_server/accounts/delegates/favorite_category.ex

@@ -41,7 +41,7 @@ defmodule MastaniServer.Accounts.Delegate.FavoriteCategory do
           from(
             pf in CMS.PostFavorite,
             where: pf.user_id == ^user_id,
-            where: pf.category_title == ^category.title
+            where: pf.category_id == ^category.id
           )
 
         query |> Repo.delete_all() |> done()
@@ -89,8 +89,8 @@ defmodule MastaniServer.Accounts.Delegate.FavoriteCategory do
 
   alias CMS.PostFavorite
 
-  defp check_dup_category(content, category_title) do
-    case content.category_title !== category_title do
+  defp check_dup_category(content, category) do
+    case content.category_id !== category.id do
       true -> {:ok, ""}
       false -> {:error, [message: "viewer has already categoried", code: ecode(:already_did)]}
     end
@@ -100,20 +100,20 @@ defmodule MastaniServer.Accounts.Delegate.FavoriteCategory do
     PostFavorite |> ORM.find_by(%{post_id: content_id, user_id: user_id})
   end
 
-  def set_favorites(%User{} = user, thread, content_id, title) do
+  def set_favorites(%User{} = user, thread, content_id, category_id) do
     with {:ok, favorite_category} <-
-           FavoriteCategory |> ORM.find_by(%{user_id: user.id, title: title}) do
+           FavoriteCategory |> ORM.find_by(%{user_id: user.id, id: category_id}) do
       Multi.new()
       |> Multi.run(:favorite_content, fn _ ->
         case content_favorite_result(thread, content_id, user.id) do
-          {:ok, content_favorite} -> check_dup_category(content_favorite, title)
+          {:ok, content_favorite} -> check_dup_category(content_favorite, favorite_category)
           {:error, _} -> CMS.reaction(thread, :favorite, content_id, user)
         end
       end)
-      |> Multi.run(:update_title, fn _ ->
+      |> Multi.run(:update_category_id, fn _ ->
         {:ok, content_favorite} = content_favorite_result(thread, content_id, user.id)
 
-        content_favorite |> ORM.update(%{category_title: title})
+        content_favorite |> ORM.update(%{category_id: favorite_category.id})
       end)
       |> Multi.run(:inc_count, fn _ ->
         favorite_category |> ORM.update(%{total_count: favorite_category.total_count + 1})
@@ -130,17 +130,17 @@ defmodule MastaniServer.Accounts.Delegate.FavoriteCategory do
     {:error, result}
   end
 
-  defp set_favorites_result({:error, :update_title, _result, _steps}) do
-    {:error, [message: "update category title fails", code: ecode(:update_fails)]}
+  defp set_favorites_result({:error, :update_category_id, _result, _steps}) do
+    {:error, [message: "update category content fails", code: ecode(:update_fails)]}
   end
 
   defp set_favorites_result({:error, :update_count, _result, _steps}) do
     {:error, [message: "inc total count fails", code: ecode(:update_fails)]}
   end
 
-  def unset_favorites(%User{} = user, thread, content_id, title) do
+  def unset_favorites(%User{} = user, thread, content_id, category_id) do
     with {:ok, favorite_category} <-
-           FavoriteCategory |> ORM.find_by(%{user_id: user.id, title: title}) do
+           FavoriteCategory |> ORM.find_by(%{user_id: user.id, id: category_id}) do
       Multi.new()
       |> Multi.run(:remove_favorite_record, fn _ ->
         {:ok, content_favorite} = content_favorite_result(thread, content_id, user.id)

lib/mastani_server/cms/post_favorite.ex

@@ -8,14 +8,14 @@ defmodule MastaniServer.CMS.PostFavorite do
   alias MastaniServer.CMS.Post
 
   @required_fields ~w(user_id post_id)a
-  @optional_fields ~w(category_title)a
+  @optional_fields ~w(category_title category_id)a
 
   @type t :: %PostFavorite{}
   schema "posts_favorites" do
     belongs_to(:user, Accounts.User, foreign_key: :user_id)
     belongs_to(:post, Post, foreign_key: :post_id)
     # has_many(:category, UserFavoriteCategory)
-    # belongs_to(:category, FavoriteCategory)
+    belongs_to(:category, Accounts.FavoriteCategory)
     field(:category_title, :string, default: "all")
 
     timestamps(type: :utc_datetime)

lib/mastani_server_web/resolvers/accounts_resolver.ex

@@ -49,12 +49,12 @@ defmodule MastaniServerWeb.Resolvers.Accounts do
     Accounts.delete_favorite_category(cur_user, id)
   end
 
-  def set_favorites(_root, ~m(id thread category_title)a, %{context: %{cur_user: cur_user}}) do
-    Accounts.set_favorites(cur_user, thread, id, category_title)
+  def set_favorites(_root, ~m(id thread category_id)a, %{context: %{cur_user: cur_user}}) do
+    Accounts.set_favorites(cur_user, thread, id, category_id)
   end
 
-  def unset_favorites(_root, ~m(id thread category_title)a, %{context: %{cur_user: cur_user}}) do
-    Accounts.unset_favorites(cur_user, thread, id, category_title)
+  def unset_favorites(_root, ~m(id thread category_id)a, %{context: %{cur_user: cur_user}}) do
+    Accounts.unset_favorites(cur_user, thread, id, category_id)
   end
 
   def follow(_root, ~m(user_id)a, %{context: %{cur_user: cur_user}}) do

lib/mastani_server_web/schema/account/account_mutations.ex

@@ -79,7 +79,7 @@ defmodule MastaniServerWeb.Schema.Account.Mutations do
     @desc "put content to favorites with category"
     field :set_favorites, :favorites_category do
       arg(:id, non_null(:id))
-      arg(:category_title, non_null(:string))
+      arg(:category_id, non_null(:id))
       arg(:thread, :cms_thread, default_value: :post)
 
       middleware(M.Authorize, :login)
@@ -89,7 +89,7 @@ defmodule MastaniServerWeb.Schema.Account.Mutations do
     @desc "take out content from favorites category"
     field :unset_favorites, :favorites_category do
       arg(:id, non_null(:id))
-      arg(:category_title, non_null(:string))
+      arg(:category_id, non_null(:id))
       arg(:thread, :cms_thread, default_value: :post)
 
       middleware(M.Authorize, :login)

priv/repo/migrations/20180824235029_replace_category_id_to_posts_favorites.exs

@@ -0,0 +1,9 @@
+defmodule MastaniServer.Repo.Migrations.ReplaceCategoryIdToPostsFavorites do
+  use Ecto.Migration
+
+  def change do
+    alter table(:posts_favorites) do
+      add(:category_id, references(:favorite_categories, on_delete: :delete_all))
+    end
+  end
+end

test/mastani_server/accounts/favorite_category_test.exs

@@ -60,8 +60,8 @@ defmodule MastaniServer.Test.Accounts.FavoriteCategory do
       test_category = "test category"
       {:ok, category} = Accounts.create_favorite_category(user, %{title: test_category})
 
-      {:ok, _post_favorite} = Accounts.set_favorites(user, :post, post.id, category.title)
-      {:ok, _post_favorite} = Accounts.set_favorites(user, :post, post2.id, category.title)
+      {:ok, _post_favorite} = Accounts.set_favorites(user, :post, post.id, category.id)
+      {:ok, _post_favorite} = Accounts.set_favorites(user, :post, post2.id, category.id)
 
       assert {:ok, _} = Accounts.delete_favorite_category(user, category.id)
 
@@ -74,66 +74,66 @@ defmodule MastaniServer.Test.Accounts.FavoriteCategory do
   end
 
   describe "[favorite category set/unset]" do
+    @tag :wip
     test "user can set category to a favorited post", ~m(user post)a do
       test_category = "test category"
-      {:ok, _category} = Accounts.create_favorite_category(user, %{title: test_category})
-
-      {:ok, _favorites_category} = Accounts.set_favorites(user, :post, post.id, test_category)
+      {:ok, category} = Accounts.create_favorite_category(user, %{title: test_category})
+      {:ok, _favorites_category} = Accounts.set_favorites(user, :post, post.id, category.id)
 
       {:ok, post_favorite} =
         CMS.PostFavorite |> ORM.find_by(%{post_id: post.id, user_id: user.id})
 
-      assert post_favorite.category_title == test_category
+      assert post_favorite.category_id == category.id
     end
 
+    @tag :wip
     test "user can change category to a categoried favorited post", ~m(user post)a do
       test_category = "test category"
-      {:ok, _category} = Accounts.create_favorite_category(user, %{title: test_category})
+      {:ok, category} = Accounts.create_favorite_category(user, %{title: test_category})
 
       {:ok, _} = CMS.reaction(:post, :favorite, post.id, user)
-      {:ok, _favorite_category} = Accounts.set_favorites(user, :post, post.id, test_category)
+      {:ok, _favorite_category} = Accounts.set_favorites(user, :post, post.id, category.id)
 
       {:ok, post_favorite} =
         CMS.PostFavorite |> ORM.find_by(%{post_id: post.id, user_id: user.id})
 
-      assert post_favorite.category_title == test_category
+      assert post_favorite.category_id == category.id
 
       test_category2 = "test category2"
-      {:ok, _category} = Accounts.create_favorite_category(user, %{title: test_category2})
-      {:ok, _favorite_category} = Accounts.set_favorites(user, :post, post.id, test_category2)
+      {:ok, category} = Accounts.create_favorite_category(user, %{title: test_category2})
+      {:ok, _favorite_category} = Accounts.set_favorites(user, :post, post.id, category.id)
 
       {:ok, post_favorite} =
         CMS.PostFavorite |> ORM.find_by(%{post_id: post.id, user_id: user.id})
 
-      assert post_favorite.category_title == test_category2
+      assert post_favorite.category_id == category.id
     end
 
     test "user set a un-created user's category fails", ~m(user post)a do
+      {:ok, user2} = db_insert(:user)
       test_category = "test category"
+      {:ok, category} = Accounts.create_favorite_category(user2, %{title: test_category})
 
-      assert {:error, _} = Accounts.set_favorites(user, :post, post.id, test_category)
+      assert {:error, _} = Accounts.set_favorites(user, :post, post.id, category.id)
     end
 
+    @tag :wip
     test "user set to a already categoried post fails", ~m(user post)a do
       test_category = "test category"
-      {:ok, _category} = Accounts.create_favorite_category(user, %{title: test_category})
-      {:ok, _} = Accounts.set_favorites(user, :post, post.id, test_category)
+      {:ok, category} = Accounts.create_favorite_category(user, %{title: test_category})
+      {:ok, _} = Accounts.set_favorites(user, :post, post.id, category.id)
 
-      {:error, error} = Accounts.set_favorites(user, :post, post.id, test_category)
+      {:error, error} = Accounts.set_favorites(user, :post, post.id, category.id)
       assert error |> Keyword.get(:code) == ecode(:already_did)
     end
 
-    test "user can set category to a unfavorited post fails", ~m(user post)a do
-      {:error, _} = Accounts.set_favorites(user, :post, post.id, "test category")
-    end
-
     test "user can unset category to a favorited post", ~m(user post)a do
       test_category = "test category"
-      {:ok, _category} = Accounts.create_favorite_category(user, %{title: test_category})
-      {:ok, _post_favorite} = Accounts.set_favorites(user, :post, post.id, test_category)
+      {:ok, category} = Accounts.create_favorite_category(user, %{title: test_category})
+      {:ok, _post_favorite} = Accounts.set_favorites(user, :post, post.id, category.id)
       assert {:ok, _} = CMS.PostFavorite |> ORM.find_by(%{post_id: post.id, user_id: user.id})
 
-      {:ok, _category} = Accounts.unset_favorites(user, :post, post.id, test_category)
+      {:ok, _category} = Accounts.unset_favorites(user, :post, post.id, category.id)
 
       assert {:error, _} = CMS.PostFavorite |> ORM.find_by(%{post_id: post.id, user_id: user.id})
     end
@@ -145,23 +145,23 @@ defmodule MastaniServer.Test.Accounts.FavoriteCategory do
       {:ok, category} = Accounts.create_favorite_category(user, %{title: test_category})
       assert category.total_count == 0
 
-      {:ok, _post_favorite} = Accounts.set_favorites(user, :post, post.id, test_category)
+      {:ok, _post_favorite} = Accounts.set_favorites(user, :post, post.id, category.id)
 
       {:ok, category} = FavoriteCategory |> ORM.find(category.id)
       assert category.total_count == 1
 
-      {:ok, _post_favorite} = Accounts.set_favorites(user, :post, post2.id, test_category)
+      {:ok, _post_favorite} = Accounts.set_favorites(user, :post, post2.id, category.id)
       {:ok, category} = FavoriteCategory |> ORM.find(category.id)
 
       assert category.total_count == 2
     end
 
     test "total_count - 1 after unset category to a favorited post", ~m(user post)a do
       test_category = "test category"
-      {:ok, _category} = Accounts.create_favorite_category(user, %{title: test_category})
-      {:ok, _post_favorite} = Accounts.set_favorites(user, :post, post.id, test_category)
+      {:ok, category} = Accounts.create_favorite_category(user, %{title: test_category})
+      {:ok, _post_favorite} = Accounts.set_favorites(user, :post, post.id, category.id)
 
-      {:ok, category} = Accounts.unset_favorites(user, :post, post.id, test_category)
+      {:ok, category} = Accounts.unset_favorites(user, :post, post.id, category.id)
 
       assert category.total_count == 0
     end

test/mastani_server_web/mutation/accounts/favorite_category_test.exs

@@ -90,8 +90,8 @@ defmodule MastaniServer.Test.Mutation.Accounts.FavoriteCategory do
 
   describe "[Accounts FavoriteCategory set/unset]" do
     @query """
-    mutation($id: ID!, $thread: CmsThread, $categoryTitle: String!) {
-      setFavorites(id: $id, thread: $thread, categoryTitle: $categoryTitle){
+    mutation($id: ID!, $thread: CmsThread, $categoryId: ID!) {
+      setFavorites(id: $id, thread: $thread, categoryId: $categoryId){
         id
         title
         totalCount
@@ -100,21 +100,21 @@ defmodule MastaniServer.Test.Mutation.Accounts.FavoriteCategory do
     """
     test "user can put a post to favorites category", ~m(user user_conn post)a do
       test_category = "test category"
-      {:ok, _category} = Accounts.create_favorite_category(user, %{title: test_category})
+      {:ok, category} = Accounts.create_favorite_category(user, %{title: test_category})
 
-      variables = %{id: post.id, categoryTitle: test_category}
+      variables = %{id: post.id, categoryId: category.id}
       created = user_conn |> mutation_result(@query, variables, "setFavorites")
       {:ok, found} = CMS.PostFavorite |> ORM.find_by(%{post_id: post.id, user_id: user.id})
 
       assert created["totalCount"] == 1
-      assert found.category_title == test_category
+      assert found.category_id == category.id
       assert found.user_id == user.id
       assert found.post_id == post.id
     end
 
     @query """
-    mutation($id: ID!, $thread: CmsThread, $categoryTitle: String!) {
-      unsetFavorites(id: $id, thread: $thread, categoryTitle: $categoryTitle){
+    mutation($id: ID!, $thread: CmsThread, $categoryId: ID!) {
+      unsetFavorites(id: $id, thread: $thread, categoryId: $categoryId){
         id
         title
         totalCount
@@ -124,12 +124,12 @@ defmodule MastaniServer.Test.Mutation.Accounts.FavoriteCategory do
     test "user can unset favorites category", ~m(user user_conn post)a do
       test_category = "test category"
       {:ok, category} = Accounts.create_favorite_category(user, %{title: test_category})
-      {:ok, _favorite_category} = Accounts.set_favorites(user, :post, post.id, test_category)
+      {:ok, _favorite_category} = Accounts.set_favorites(user, :post, post.id, category.id)
 
       {:ok, category} = Accounts.FavoriteCategory |> ORM.find(category.id)
       assert category.total_count == 1
 
-      variables = %{id: post.id, categoryTitle: test_category}
+      variables = %{id: post.id, categoryId: category.id}
       user_conn |> mutation_result(@query, variables, "unsetFavorites")
 
       {:ok, category} = Accounts.FavoriteCategory |> ORM.find(category.id)