Remove JaResource from ProjectGithubRepoController

Author: landongrindheim

lib/code_corps/policy/policy.ex

@@ -47,6 +47,9 @@ 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, %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)
   defp can?(%User{} = current_user, :create, %Role{}, %{}), do: Policy.Role.create?(current_user)
   defp can?(%User{} = current_user, :create, %RoleSkill{}, %{}), do: Policy.RoleSkill.create?(current_user)
   defp can?(%User{} = current_user, :delete, %RoleSkill{}, %{}), do: Policy.RoleSkill.delete?(current_user)
@@ -106,9 +109,6 @@ defmodule CodeCorps.Policy do
     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, %Changeset{data: %ProjectGithubRepo{}} = changeset), do: Policy.ProjectGithubRepo.create?(user, changeset)
-    def can?(%User{} = user, :delete, %ProjectGithubRepo{} = project_github_repo), do: Policy.ProjectGithubRepo.delete?(user, project_github_repo)
-
     def can?(%User{} = user, :create, Role), do: Policy.Role.create?(user)
   end
 end

lib/code_corps/policy/project_github_repo.ex

@@ -2,12 +2,13 @@ defmodule CodeCorps.Policy.ProjectGithubRepo do
   import CodeCorps.Policy.Helpers, only: [get_project: 1, administered_by?: 2]
 
   alias CodeCorps.{ProjectGithubRepo, 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, ProjectGithubRepo.t) :: boolean
   def delete?(%User{} = user, %ProjectGithubRepo{} = project_github_repo) do
     project_github_repo |> get_project |> administered_by?(user)
   end

lib/code_corps_web/controllers/project_github_repo_controller.ex

@@ -1,24 +1,48 @@
 defmodule CodeCorpsWeb.ProjectGithubRepoController do
   use CodeCorpsWeb, :controller
-  use JaResource
 
-  import CodeCorps.Helpers.Query, only: [id_filter: 2]
+  alias CodeCorps.{ProjectGithubRepo, User, Helpers.Query}
 
-  alias CodeCorps.ProjectGithubRepo
+  action_fallback CodeCorpsWeb.FallbackController
+  plug CodeCorpsWeb.Plug.DataToAttributes
+  plug CodeCorpsWeb.Plug.IdsToIntegers
 
-  plug :load_resource, model: ProjectGithubRepo, only: [:show], preload: [:github_repo, :project]
-  plug :load_and_authorize_changeset, model: ProjectGithubRepo, only: [:create]
-  plug :load_and_authorize_resource, model: ProjectGithubRepo, only: [:delete]
-  plug JaResource
+  @spec index(Conn.t, map) :: Conn.t
+  def index(%Conn{} = conn, %{} = params) do
+    with organization_installations <- ProjectGithubRepo |> Query.id_filter(params) |> Repo.all do
+      conn |> render("index.json-api", data: organization_installations)
+    end
+  end
+
+  @spec show(Conn.t, map) :: Conn.t
+  def show(%Conn{} = conn, %{"id" => id}) do
+    with %ProjectGithubRepo{} = project_github_repo <- ProjectGithubRepo |> Repo.get(id) do
+      conn |> render("show.json-api", data: project_github_repo)
+    end
+  end
 
-  @spec model :: module
-  def model, do: CodeCorps.ProjectGithubRepo
+  @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, %ProjectGithubRepo{}, params),
+         {:ok, %ProjectGithubRepo{} = project_github_repo} <- create_project_repo_changeset(params) |> Repo.insert do
+      conn |> put_status(:created) |> render("show.json-api", data: project_github_repo)
+    end
+  end
 
-  def filter(_conn, query, "id", id_list) do
-    query |> id_filter(id_list)
+  @spec delete(Plug.Conn.t, map) :: Conn.t
+  def delete(%Conn{} = conn, %{"id" => id} = params) do
+    with %ProjectGithubRepo{} = project_github_repo <- ProjectGithubRepo |> Repo.get(id),
+         %User{} = current_user <- conn |> Guardian.Plug.current_resource,
+         {:ok, :authorized} <- current_user |> Policy.authorize(:delete, project_github_repo, params),
+         {:ok, _project_github_repo} <- project_github_repo |> Repo.delete do
+      conn |> send_resp(:no_content, "")
+    end
   end
 
-  def handle_create(_conn, attributes) do
-    %ProjectGithubRepo{} |> ProjectGithubRepo.create_changeset(attributes)
+  @spec create_project_repo_changeset(map) :: Ecto.Changeset.t
+  defp create_project_repo_changeset(params) do
+    %ProjectGithubRepo{}
+    |> ProjectGithubRepo.create_changeset(params)
   end
 end

test/lib/code_corps/policy/project_github_repo_test.exs

@@ -2,45 +2,42 @@ defmodule CodeCorps.Policy.ProjectGithubRepoTest do
   use CodeCorps.PolicyCase
 
   import CodeCorps.Policy.ProjectGithubRepo, only: [create?: 2, delete?: 2]
-  import CodeCorps.ProjectGithubRepo, only: [create_changeset: 2]
-
-  alias CodeCorps.ProjectGithubRepo
 
   describe "create?" do
     test "returns false when user is not a project member" do
       user = insert(:user)
       project = insert(:project)
 
-      changeset = %ProjectGithubRepo{} |> create_changeset(%{project_id: project.id})
-      refute create?(user, changeset)
+      params = %{"project_id" => project.id, "user_id" => user.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 = %ProjectGithubRepo{} |> create_changeset(%{project_id: project.id})
-      refute create?(user, changeset)
+      params = %{"project_id" => project.id, "user_id" => user.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 = %ProjectGithubRepo{} |> create_changeset(%{project_id: project.id})
-      refute create?(user, changeset)
+      params = %{"project_id" => project.id, "user_id" => user.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 = %ProjectGithubRepo{} |> create_changeset(%{project_id: project.id})
-      assert create?(user, changeset)
+      params = %{"project_id" => project.id, "user_id" => user.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 = %ProjectGithubRepo{} |> create_changeset(%{project_id: project.id})
-      assert create?(user, changeset)
+      params = %{"project_id" => project.id, "user_id" => user.id}
+      assert create?(user, params)
     end
   end