Merge pull request #1067 from code-corps/1063-create-github-issues

Create GithubIssue and modify Task

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/common/repo_finder.ex

@@ -14,13 +14,10 @@ defmodule CodeCorps.GitHub.Event.Common.RepoFinder do
   - `{:error, :unmatched_project}` if record was found, but has no associated
     `ProjectGithubRepo` children
   """
-  @spec find_repo(map) :: {:ok, GithubRepo.t} | {:error, :unmatched_repository} | {:error, :unmatched_project}
+  @spec find_repo(map) :: {:ok, GithubRepo.t} | {:error, :unmatched_repository}
   def find_repo(%{"repository" => %{"id" => github_id}}) do
-    case GithubRepo |> Repo.get_by(github_id: github_id) |> Repo.preload(:project_github_repos) do
-      # a GithubRepo with at least some ProjectGithubRepo children
-      %GithubRepo{project_github_repos: [_ | _]} = github_repo -> {:ok, github_repo}
-      # a GithubRepo with no ProjectGithubRepo children
-      %GithubRepo{project_github_repos: []} -> {:error, :unmatched_project}
+    case GithubRepo |> Repo.get_by(github_id: github_id) do
+      %GithubRepo{} = github_repo -> {:ok, github_repo}
       nil -> {:error, :unmatched_repository}
     end
   end

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, issue_user: user} -> github_issue |> TaskSyncer.sync_all(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, user: user} -> github_issue |> TaskSyncer.sync_all(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,
@@ -15,34 +16,41 @@ defmodule CodeCorps.GitHub.Event.Issues.TaskSyncer do
                    {:error, {list(Task.t), list(Changeset.t)}}
 
   @doc """
-  When provided a `GithubRepo`, a `User` and a GitHub API payload, for each
-  `Project` associated to that `GithubRepo` via a `ProjectGithubRepo`, it
-  creates or updates a `Task` associated to the specified `User`.
+  When provided a `CodeCorps.GithubIssue`, a `CodeCorps.User` and a GitHub API
+  payload, for each `CodeCorps.Project` associated to that
+  `CodeCorps.GithubRepo` via a `CodeCorps.ProjectGithubRepo`, it
+  creates or updates a `CodeCorps.Task`.
   """
-  @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, User.t, map) :: {:ok, list(Task.t)}
+  def sync_all(%GithubIssue{} = github_issue, %User{} = user, %{} = payload) do
+
+    %GithubIssue{
+      github_repo: %GithubRepo{project_github_repos: project_github_repos}
+    } = github_issue |> Repo.preload(github_repo: :project_github_repos)
+
     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