Remove JaReource from ProjectCategoryController (#1062)

Author: landongrindheim

lib/code_corps/policy/policy.ex

@@ -49,6 +49,8 @@ defmodule CodeCorps.Policy do
     %OrganizationGithubAppInstallation{} = organization_github_app_installation, %{}),
       do: Policy.OrganizationGithubAppInstallation.delete?(user, organization_github_app_installation)
   defp can?(%User{} = user, :create, %OrganizationGithubAppInstallation{}, %{} = params), do: Policy.OrganizationGithubAppInstallation.create?(user, params)
+  defp can?(%User{} = current_user, :create, %ProjectCategory{}, %{} = params), do: Policy.ProjectCategory.create?(current_user, params)
+  defp can?(%User{} = current_user, :delete, %ProjectCategory{} = project_category, %{}), do: Policy.ProjectCategory.delete?(current_user, project_category)
   defp can?(%User{} = current_user, :create, %ProjectGithubRepo{}, %{} = params), do: Policy.ProjectGithubRepo.create?(current_user, params)
   defp can?(%User{} = current_user, :delete, %ProjectGithubRepo{} = project_github_repo, %{}),
     do: Policy.ProjectGithubRepo.delete?(current_user, project_github_repo)
@@ -105,9 +107,6 @@ defmodule CodeCorps.Policy do
 
     def can?(%User{} = user, :create, %Changeset{data: %Preview{}} = changeset), do: Policy.Preview.create?(user, changeset)
 
-    def can?(%User{} = user, :create, %Changeset{data: %ProjectCategory{}} = changeset), do: Policy.ProjectCategory.create?(user, changeset)
-    def can?(%User{} = user, :delete, %ProjectCategory{} = project_category), do: Policy.ProjectCategory.delete?(user, project_category)
-
     def can?(%User{} = user, :create, Role), do: Policy.Role.create?(user)
   end
 end

lib/code_corps/policy/project_category.ex

@@ -2,12 +2,13 @@ defmodule CodeCorps.Policy.ProjectCategory do
   import CodeCorps.Policy.Helpers, only: [get_project: 1, administered_by?: 2]
 
   alias CodeCorps.{ProjectCategory, User}
-  alias Ecto.Changeset
 
-  def create?(%User{} = user, %Changeset{} = changeset) do
-    changeset |> get_project |> administered_by?(user)
+  @spec create?(User.t, map) :: boolean
+  def create?(%User{} = user, %{} = params) do
+    params |> get_project |> administered_by?(user)
   end
 
+  @spec delete?(User.t, ProjectCategory.t) :: boolean
   def delete?(%User{} = user, %ProjectCategory{} = project_category) do
     project_category |> get_project |> administered_by?(user)
   end

lib/code_corps_web/controllers/project_category_controller.ex

@@ -1,24 +1,43 @@
 defmodule CodeCorpsWeb.ProjectCategoryController do
   use CodeCorpsWeb, :controller
-  use JaResource
 
-  alias CodeCorps.ProjectCategory
+  alias CodeCorps.{ProjectCategory, User, Helpers.Query}
 
-  import CodeCorps.Helpers.Query, only: [id_filter: 2]
+  action_fallback CodeCorpsWeb.FallbackController
+  plug CodeCorpsWeb.Plug.DataToAttributes
+  plug CodeCorpsWeb.Plug.IdsToIntegers
 
-  plug :load_resource, model: ProjectCategory, only: [:show], preload: [:project, :category]
-  plug :load_and_authorize_changeset, model: ProjectCategory, only: [:create]
-  plug :load_and_authorize_resource, model: ProjectCategory, only: [:delete]
-  plug JaResource
+  @spec index(Conn.t, map) :: Conn.t
+  def index(%Conn{} = conn, %{} = params) do
+    with project_categories <- ProjectCategory |> Query.id_filter(params) |> Repo.all do
+      conn |> render("index.json-api", data: project_categories)
+    end
+  end
 
-  @spec model :: module
-  def model, do: CodeCorps.ProjectCategory
+  @spec show(Conn.t, map) :: Conn.t
+  def show(%Conn{} = conn, %{"id" => id}) do
+    with %ProjectCategory{} = project_category <- ProjectCategory |> Repo.get(id) do
+      conn |> render("show.json-api", data: project_category)
+    end
+  end
 
-  def filter(_conn, query, "id", id_list) do
-    query |> id_filter(id_list)
+  @spec create(Plug.Conn.t, map) :: Conn.t
+  def create(%Conn{} = conn, %{} = params) do
+    with %User{} = current_user <- conn |> Guardian.Plug.current_resource,
+         {:ok, :authorized} <- current_user |> Policy.authorize(:create, %ProjectCategory{}, params),
+         {:ok, %ProjectCategory{} = project_category} <- %ProjectCategory{} |> ProjectCategory.create_changeset(params) |> Repo.insert do
+      conn |> put_status(:created) |> render("show.json-api", data: project_category)
+    end
   end
 
-  def handle_create(_conn, attributes) do
-    %ProjectCategory{} |> ProjectCategory.create_changeset(attributes)
+  @spec delete(Conn.t, map) :: Conn.t
+  def delete(%Conn{} = conn, %{"id" => id} = _params) do
+    with %ProjectCategory{} = project_category <- ProjectCategory |> Repo.get(id),
+      %User{} = current_user <- conn |> Guardian.Plug.current_resource,
+      {:ok, :authorized} <- current_user |> Policy.authorize(:delete, project_category),
+      {:ok, %ProjectCategory{} = _project_category} <- project_category |> Repo.delete
+    do
+      conn |> Conn.assign(:project_category, project_category) |> send_resp(:no_content, "")
+    end
   end
 end

test/lib/code_corps/policy/project_category_test.exs

@@ -2,45 +2,42 @@ defmodule CodeCorps.Policy.ProjectCategoryTest do
   use CodeCorps.PolicyCase
 
   import CodeCorps.Policy.ProjectCategory, only: [create?: 2, delete?: 2]
-  import CodeCorps.ProjectCategory, only: [create_changeset: 2]
-
-  alias CodeCorps.ProjectCategory
 
   describe "create?" do
     test "returns false when user is not a project member" do
       user = insert(:user)
       project = insert(:project)
 
-      changeset = %ProjectCategory{} |> create_changeset(%{project_id: project.id})
-      refute create?(user, changeset)
+      params = %{"project_id" => project.id}
+      refute create?(user, params)
     end
 
     test "returns false when user is a pending project member" do
       %{project: project, user: user} = insert(:project_user, role: "pending")
 
-      changeset = %ProjectCategory{} |> create_changeset(%{project_id: project.id})
-      refute create?(user, changeset)
+      params = %{"project_id" =>  project.id}
+      refute create?(user, params)
     end
 
     test "returns false when user is a project contributor" do
       %{project: project, user: user} = insert(:project_user, role: "contributor")
 
-      changeset = %ProjectCategory{} |> create_changeset(%{project_id: project.id})
-      refute create?(user, changeset)
+      params = %{"project_id" => project.id}
+      refute create?(user, params)
     end
 
     test "returns true when user is a project admin" do
       %{project: project, user: user} = insert(:project_user, role: "admin")
 
-      changeset = %ProjectCategory{} |> create_changeset(%{project_id: project.id})
-      assert create?(user, changeset)
+      params = %{"project_id" => project.id}
+      assert create?(user, params)
     end
 
     test "returns true when user is project owner" do
       %{project: project, user: user} = insert(:project_user, role: "owner")
 
-      changeset = %ProjectCategory{} |> create_changeset(%{project_id: project.id})
-      assert create?(user, changeset)
+      params = %{"project_id" => project.id}
+      assert create?(user, params)
     end
   end