Create GithubIssue and modify Task

Add IssueLinker, Issue adapter, incorporate other tweaks
Incorporate the GithubRepo into issue linking
Update TaskSyncer and ChangesetBuilder
Update TaskView and add GithubIssueView
Rewrite IssueLinker to take issue params and Task.Service to create issues

Author: joshsmith

lib/code_corps/comment/service.ex

@@ -9,7 +9,7 @@ defmodule CodeCorps.Comment.Service do
 
   require Logger
 
-  @preloads [:user, task: [github_repo: :github_app_installation]]
+  @preloads [:user, task: [:github_issue, github_repo: :github_app_installation]]
 
   @doc ~S"""
   Creates a `Comment` record using the provided parameters
@@ -49,9 +49,9 @@ defmodule CodeCorps.Comment.Service do
 
   @spec connect_to_github(Comment.t) :: {:ok, Comment.t} :: {:error, GitHub.api_error_struct}
   defp connect_to_github(
-    %Comment{task: %Task{github_repo: nil, github_issue_number: nil}} = comment), do: {:ok, comment}
+    %Comment{task: %Task{github_repo: nil}} = comment), do: {:ok, comment}
   defp connect_to_github(
-    %Comment{task: %Task{github_repo: %GithubRepo{} = _, github_issue_number: _}} = comment) do
+    %Comment{task: %Task{github_repo: %GithubRepo{}}} = comment) do
 
     with {:ok, github_comment} <- comment |> GitHub.Comment.create do
       comment |> link_with_github_changeset(github_comment) |> Repo.update

lib/code_corps/github/adapters/issue.ex

@@ -0,0 +1,51 @@
+defmodule CodeCorps.GitHub.Adapters.Issue do
+  @moduledoc """
+  Used to adapt a GitHub Issue payload into attributes for creating or updating
+  a `CodeCorps.GithubIssue` and vice-versa.
+  """
+
+  alias CodeCorps.{
+    Adapter.MapTransformer,
+    GithubIssue
+  }
+
+  @mapping [
+    {:body, ["body"]},
+    {:closed_at, ["closed_at"]},
+    {:comments_url, ["comments_url"]},
+    {:events_url, ["events_url"]},
+    {:github_created_at, ["created_at"]},
+    {:github_id, ["id"]},
+    {:github_updated_at, ["updated_at"]},
+    {:html_url, ["html_url"]},
+    {:labels_url, ["labels_url"]},
+    {:locked, ["locked"]},
+    {:number, ["number"]},
+    {:state, ["state"]},
+    {:title, ["title"]},
+    {:url, ["url"]}
+  ]
+
+  @doc ~S"""
+  Converts a GitHub Issue payload into a set of attributes used to update or
+  create a `GithubIssue` record.
+  """
+  @spec from_api(map) :: map
+  def from_api(%{} = payload) do
+    payload |> MapTransformer.transform(@mapping)
+  end
+
+  @autogenerated_github_keys ~w(closed_at comments_url created_at events_url html_url id labels_url number updated_at url)
+
+  @doc ~S"""
+  Converts a `GithubIssue` into a set of attributes used to update or create an
+  associated GitHub Issue.
+  """
+  @spec to_api(GithubIssue.t) :: map
+  def to_api(%GithubIssue{} = github_issue) do
+    github_issue
+    |> Map.from_struct
+    |> MapTransformer.transform_inverse(@mapping)
+    |> Map.drop(@autogenerated_github_keys)
+  end
+end

lib/code_corps/github/comment/comment.ex

@@ -3,7 +3,7 @@ defmodule CodeCorps.GitHub.Comment do
   Handles GitHub API requests for actions on Comments
   """
 
-  alias CodeCorps.{Comment, GitHub, GithubAppInstallation, GithubRepo, Task, User}
+  alias CodeCorps.{Comment, GitHub, GithubAppInstallation, GithubIssue, GithubRepo, Task, User}
 
   @spec create(Comment.t) :: GitHub.response
   def create(
@@ -64,7 +64,9 @@ defmodule CodeCorps.GitHub.Comment do
   defp create_endpoint_for(
     %Comment{
       task: %Task{
-        github_issue_number: number,
+        github_issue: %GithubIssue{
+          number: number
+        },
         github_repo: %GithubRepo{
           github_account_login: owner, name: repo
         },

lib/code_corps/github/event/issue_comment.ex

@@ -8,6 +8,7 @@ defmodule CodeCorps.GitHub.Event.IssueComment do
 
   alias CodeCorps.{
     Comment,
+    GithubRepo,
     GitHub.Event.Common.RepoFinder,
     GitHub.Event.Issues,
     GitHub.Event.Issues.TaskSyncer,
@@ -22,6 +23,7 @@ defmodule CodeCorps.GitHub.Event.IssueComment do
                    {:error, :unexpected_action} |
                    {:error, :unexpected_payload} |
                    {:error, :repository_not_found} |
+                   {:error, :validation_error_on_inserting_issue_for_task} |
                    {:error, :validation_error_on_inserting_user_for_task} |
                    {:error, :multiple_github_users_matched_same_cc_user_for_task} |
                    {:error, :validation_error_on_inserting_user_for_comment} |
@@ -60,12 +62,13 @@ defmodule CodeCorps.GitHub.Event.IssueComment do
   end
 
   @spec operational_multi(map) :: Multi.t
-  defp operational_multi(%{"action" => action} = payload) when action in ~w(created edited) do
+  defp operational_multi(%{"action" => action, "issue" => issue_payload} = payload) when action in ~w(created edited) do
     Multi.new
     |> Multi.run(:repo, fn _ -> RepoFinder.find_repo(payload) end)
-    |> Multi.run(:issue_user, fn _ -> Issues.UserLinker.find_or_create_user(payload) end)
+    |> Multi.run(:issue, fn %{repo: %GithubRepo{} = github_repo} -> github_repo |> Issues.IssueLinker.create_or_update_issue(issue_payload) end)
+    |> Multi.run(:issue_user, fn %{issue: github_issue} -> github_issue |> Issues.UserLinker.find_or_create_user(payload) end)
     |> Multi.run(:comment_user, fn _ -> IssueComment.UserLinker.find_or_create_user(payload) end)
-    |> Multi.run(:tasks, fn %{repo: github_repo, issue_user: user} -> TaskSyncer.sync_all(github_repo, user, payload) end)
+    |> Multi.run(:tasks, fn %{issue: github_issue, repo: github_repo, issue_user: user} -> github_issue |> TaskSyncer.sync_all(github_repo, user, payload) end)
     |> Multi.run(:comments, fn %{tasks: tasks, comment_user: user} -> CommentSyncer.sync_all(tasks, user, payload) end)
   end
   defp operational_multi(%{"action" => "deleted"} = payload) do
@@ -80,6 +83,7 @@ defmodule CodeCorps.GitHub.Event.IssueComment do
   defp marshall_result({:error, :action, :unexpected_action, _steps}), do: {:error, :unexpected_action}
   defp marshall_result({:error, :repo, :unmatched_project, _steps}), do: {:ok, []}
   defp marshall_result({:error, :repo, :unmatched_repository, _steps}), do: {:error, :repository_not_found}
+  defp marshall_result({:error, :issue, %Ecto.Changeset{}, _steps}), do: {:error, :validation_error_on_inserting_issue_for_task}
   defp marshall_result({:error, :issue_user, %Ecto.Changeset{}, _steps}), do: {:error, :validation_error_on_inserting_user_for_task}
   defp marshall_result({:error, :issue_user, :multiple_users, _steps}), do: {:error, :multiple_github_users_matched_same_cc_user_for_task}
   defp marshall_result({:error, :comment_user, %Ecto.Changeset{}, _steps}), do: {:error, :validation_error_on_inserting_user_for_comment}

lib/code_corps/github/event/issues.ex

@@ -9,6 +9,7 @@ defmodule CodeCorps.GitHub.Event.Issues do
 
   alias CodeCorps.{
     GitHub.Event.Common.RepoFinder,
+    GitHub.Event.Issues.IssueLinker,
     GitHub.Event.Issues.TaskSyncer,
     GitHub.Event.Issues.UserLinker,
     GitHub.Event.Issues.Validator,
@@ -50,12 +51,18 @@ defmodule CodeCorps.GitHub.Event.Issues do
     |> Multi.run(:payload, fn _ -> payload |> validate_payload() end)
     |> Multi.run(:action, fn _ -> payload |> validate_action() end)
     |> Multi.run(:repo, fn _ -> RepoFinder.find_repo(payload) end)
-    |> Multi.run(:user, fn _ -> UserLinker.find_or_create_user(payload) end)
-    |> Multi.run(:tasks, fn %{repo: github_repo, user: user} -> TaskSyncer.sync_all(github_repo, user, payload) end)
+    |> Multi.run(:issue, fn %{repo: github_repo} -> link_issue(github_repo, payload) end)
+    |> Multi.run(:user, fn %{issue: github_issue} -> UserLinker.find_or_create_user(github_issue, payload) end)
+    |> Multi.run(:tasks, fn %{issue: github_issue, repo: github_repo, user: user} -> TaskSyncer.sync_all(github_issue, github_repo, user, payload) end)
     |> Repo.transaction
     |> marshall_result()
   end
 
+  @spec link_issue(GithubRepo.t, map) :: {:ok, GithubIssue.t} | {:error, Ecto.Changeset.t}
+  defp link_issue(github_repo, %{"issue" => attrs}) do
+    IssueLinker.create_or_update_issue(github_repo, attrs)
+  end
+
   @spec marshall_result(tuple) :: tuple
   defp marshall_result({:ok, %{tasks: tasks}}), do: {:ok, tasks}
   defp marshall_result({:error, :payload, :invalid, _steps}), do: {:error, :unexpected_payload}

lib/code_corps/github/event/issues/changeset_builder.ex

@@ -5,6 +5,7 @@ defmodule CodeCorps.GitHub.Event.Issues.ChangesetBuilder do
   """
 
   alias CodeCorps.{
+    GithubIssue,
     ProjectGithubRepo,
     Repo,
     Services.MarkdownRendererService,
@@ -22,24 +23,26 @@ defmodule CodeCorps.GitHub.Event.Issues.ChangesetBuilder do
 
   The changeset can be used to create or update a `Task`
   """
-  @spec build_changeset(Task.t, map, ProjectGithubRepo.t, User.t) :: Changeset.t
+  @spec build_changeset(Task.t, map, GithubIssue.t, ProjectGithubRepo.t, User.t) :: Changeset.t
   def build_changeset(
     %Task{id: task_id} = task,
     %{"issue" => issue_attrs},
+    %GithubIssue{} = github_issue,
     %ProjectGithubRepo{} = project_github_repo,
     %User{} = user) do
 
     case is_nil(task_id) do
-      true -> create_changeset(task, issue_attrs, project_github_repo, user)
+      true -> create_changeset(task, issue_attrs, github_issue, project_github_repo, user)
       false -> update_changeset(task, issue_attrs)
     end
   end
 
-  @create_attrs ~w(created_at github_issue_number markdown modified_at status title)a
-  @spec create_changeset(Task.t, map, ProjectGithubRepo.t, User.t) :: Changeset.t
+  @create_attrs ~w(created_at markdown modified_at status title)a
+  @spec create_changeset(Task.t, map, GithubIssue.t, ProjectGithubRepo.t, User.t) :: Changeset.t
   defp create_changeset(
     %Task{} = task,
     %{} = issue_attrs,
+    %GithubIssue{id: github_issue_id},
     %ProjectGithubRepo{project_id: project_id, github_repo_id: github_repo_id},
     %User{id: user_id}) do
 
@@ -51,18 +54,20 @@ defmodule CodeCorps.GitHub.Event.Issues.ChangesetBuilder do
     |> MarkdownRendererService.render_markdown_to_html(:markdown, :body)
     |> Changeset.put_change(:created_from, "github")
     |> Changeset.put_change(:modified_from, "github")
+    |> Changeset.put_change(:github_issue_id, github_issue_id)
     |> Changeset.put_change(:github_repo_id, github_repo_id)
     |> Changeset.put_change(:project_id, project_id)
     |> Changeset.put_change(:task_list_id, task_list_id)
     |> Changeset.put_change(:user_id, user_id)
     |> Changeset.validate_required([:project_id, :task_list_id, :title, :user_id])
+    |> Changeset.assoc_constraint(:github_issue)
     |> Changeset.assoc_constraint(:github_repo)
     |> Changeset.assoc_constraint(:project)
     |> Changeset.assoc_constraint(:task_list)
     |> Changeset.assoc_constraint(:user)
   end
 
-  @update_attrs ~w(github_issue_number markdown modified_at status title)a
+  @update_attrs ~w(markdown modified_at status title)a
   @spec update_changeset(Task.t, map) :: Changeset.t
   defp update_changeset(%Task{} = task, %{} = issue_attrs) do
     task

lib/code_corps/github/event/issues/issue_linker.ex

@@ -0,0 +1,54 @@
+defmodule CodeCorps.GitHub.Event.Issues.IssueLinker do
+  @moduledoc ~S"""
+  In charge of finding a issue to link with a Task when processing an Issues
+  webhook.
+
+  The only entry point is `create_or_update_issue/1`.
+  """
+
+  alias CodeCorps.{
+    GithubIssue,
+    GithubRepo,
+    Repo
+  }
+
+  alias CodeCorps.GitHub.Adapters.Issue, as: IssueAdapter
+
+  @typep linking_result :: {:ok, GithubIssue.t} |
+                           {:error, Ecto.Changeset.t}
+
+  @doc ~S"""
+  Finds or creates a `GithubIssue` using the data in a GitHub Issue payload.
+
+  The process is as follows:
+
+  - Search for the issue in our database with the payload data.
+    - If we return a single `GithubIssue`, then the `GithubIssue` should be
+      updated.
+    - If there are no matching `GithubIssue` records, then a `GithubIssue`
+      should be created.
+  """
+  @spec create_or_update_issue(GithubRepo.t, map) :: linking_result
+  def create_or_update_issue(%GithubRepo{} = github_repo, %{"id" => github_issue_id} = attrs) do
+    params = IssueAdapter.from_api(attrs)
+
+    case Repo.get_by(GithubIssue, github_id: github_issue_id) do
+      nil -> create_issue(github_repo, params)
+      %GithubIssue{} = issue -> update_issue(issue, params)
+    end
+  end
+
+  defp create_issue(%GithubRepo{id: github_repo_id}, params) do
+    params = Map.put(params, :github_repo_id, github_repo_id)
+
+    %GithubIssue{}
+    |> GithubIssue.create_changeset(params)
+    |> Repo.insert
+  end
+
+  defp update_issue(%GithubIssue{} = github_issue, params) do
+    github_issue
+    |> GithubIssue.update_changeset(params)
+    |> Repo.update
+  end
+end

lib/code_corps/github/event/issues/task_syncer.ex

@@ -1,5 +1,6 @@
 defmodule CodeCorps.GitHub.Event.Issues.TaskSyncer do
   alias CodeCorps.{
+    GithubIssue,
     GithubRepo,
     GitHub.Event.Common.ResultAggregator,
     GitHub.Event.Issues.ChangesetBuilder,
@@ -19,30 +20,31 @@ defmodule CodeCorps.GitHub.Event.Issues.TaskSyncer do
   `Project` associated to that `GithubRepo` via a `ProjectGithubRepo`, it
   creates or updates a `Task` associated to the specified `User`.
   """
-  @spec sync_all(GithubRepo.t, User.t, map) :: {:ok, list(Task.t)}
-  def sync_all(%GithubRepo{project_github_repos: project_github_repos}, %User{} = user, %{} = payload) do
+  @spec sync_all(GithubIssue.t, GithubRepo.t, User.t, map) :: {:ok, list(Task.t)}
+  def sync_all(%GithubIssue{} = github_issue, %GithubRepo{project_github_repos: project_github_repos}, %User{} = user, %{} = payload) do
     project_github_repos
-    |> Enum.map(&sync(&1, user, payload))
+    |> Enum.map(&sync(github_issue, &1, user, payload))
     |> ResultAggregator.aggregate
   end
 
-  @spec sync(ProjectGithubRepo.t, User.t, map) :: {:ok, ProjectGithubRepo.t} | {:error, Changeset.t}
-  defp sync(%ProjectGithubRepo{} = project_github_repo, %User{} = user, %{} = payload) do
+  @spec sync(GithubIssue.t, ProjectGithubRepo.t, User.t, map) :: {:ok, ProjectGithubRepo.t} | {:error, Changeset.t}
+  defp sync(%GithubIssue{} = github_issue, %ProjectGithubRepo{} = project_github_repo, %User{} = user, %{} = payload) do
     project_github_repo
-    |> find_or_init_task(payload)
-    |> ChangesetBuilder.build_changeset(payload, project_github_repo, user)
+    |> find_or_init_task(github_issue)
+    |> ChangesetBuilder.build_changeset(payload, github_issue, project_github_repo, user)
     |> commit()
   end
 
-  @spec find_or_init_task(ProjectGithubRepo.t, map) :: Task.t
+  @spec find_or_init_task(ProjectGithubRepo.t, GithubIssue.t) :: Task.t
   defp find_or_init_task(
     %ProjectGithubRepo{project_id: project_id, github_repo_id: github_repo_id},
-    %{"issue" => %{"number" => github_issue_number}}) do
+    %GithubIssue{id: github_issue_id}
+  ) do
 
     query_params = [
-      github_issue_number: github_issue_number,
-      project_id: project_id,
-      github_repo_id: github_repo_id
+      github_issue_id: github_issue_id,
+      github_repo_id: github_repo_id,
+      project_id: project_id
     ]
 
     case Task |> Repo.get_by(query_params) do

lib/code_corps/github/event/issues/user_linker.ex

@@ -10,7 +10,7 @@ defmodule CodeCorps.GitHub.Event.Issues.UserLinker do
 
   alias CodeCorps.{
     Accounts,
-    GithubRepo,
+    GithubIssue,
     Repo,
     Task,
     User
@@ -21,8 +21,8 @@ defmodule CodeCorps.GitHub.Event.Issues.UserLinker do
                            {:error, :multiple_users}
 
   @doc ~S"""
-  Finds or creates a user using information contained in a GitHub Issue
-  webhook payload.
+  Finds or creates a user using information in a `GithubIssue` record and a
+  Github Issue payload.
 
   The process is as follows:
   - Find all affected tasks and extract their user data.
@@ -32,28 +32,22 @@ defmodule CodeCorps.GitHub.Event.Issues.UserLinker do
       someone who does not have a matching GitHub-connected Code Corps account.
       We create a placeholder user account until that GitHub user is claimed by
       a Code Corps user.
-  created.
     - If there are multiple matching users, this is an unexpected scenario and
       should error out.
   """
-  @spec find_or_create_user(map) :: linking_result
-  def find_or_create_user(%{"issue" => %{"user" => user_attrs}} = attrs) do
-    attrs
+  @spec find_or_create_user(GithubIssue.t, map) :: linking_result
+  def find_or_create_user(%GithubIssue{} = issue, %{"issue" => %{"user" => user_attrs}}) do
+    issue
     |> match_users
     |> marshall_response(user_attrs)
   end
 
-  @spec match_users(map) :: list(User.t)
-  defp match_users(
-    %{
-      "issue" => %{"number" => github_issue_number},
-      "repository" =>%{"id" => github_repo_id}
-    }) do
+  @spec match_users(GithubIssue.t) :: list(User.t)
+  defp match_users(%GithubIssue{id: github_issue_id}) do
 
     query = from u in User,
       distinct: u.id,
-      join: t in Task, on: u.id == t.user_id, where: t.github_issue_number == ^github_issue_number,
-      join: r in GithubRepo, on: r.id == t.github_repo_id, where: r.github_id == ^github_repo_id
+      join: t in Task, on: u.id == t.user_id, where: t.github_issue_id == ^github_issue_id
 
     query |> Repo.all
   end