Merge pull request #1071 from code-corps/1070-github-comment

GithubComment model

Author: joshsmith

lib/code_corps/comment/service.ex

@@ -4,12 +4,20 @@ defmodule CodeCorps.Comment.Service do
   additional actions that need to be performed when such an operation happens.
   """
 
-  alias CodeCorps.{Comment, GitHub, GithubRepo, Task, Repo}
+  alias CodeCorps.{
+    Comment,
+    GitHub,
+    GitHub.Event.IssueComment.CommentLinker,
+    GithubComment,
+    GithubIssue,
+    Task,
+    Repo
+  }
   alias Ecto.{Changeset, Multi}
 
   require Logger
 
-  @preloads [:user, task: [:github_issue, github_repo: :github_app_installation]]
+  @preloads [:user, :github_comment, task: [:github_issue, github_repo: :github_app_installation]]
 
   @doc ~S"""
   Creates a `Comment` record using the provided parameters
@@ -21,7 +29,7 @@ defmodule CodeCorps.Comment.Service do
     Multi.new
     |> Multi.insert(:comment, %Comment{} |> Comment.create_changeset(attributes))
     |> Multi.run(:preload, fn %{comment: %Comment{} = comment} -> {:ok, comment |> Repo.preload(@preloads)} end)
-    |> Multi.run(:github, (fn %{preload: %Comment{} = comment} -> comment |> connect_to_github() end))
+    |> Multi.run(:github, (fn %{preload: %Comment{} = comment} -> comment |> create_on_github() end))
     |> Repo.transaction
     |> marshall_result
   end
@@ -33,7 +41,7 @@ defmodule CodeCorps.Comment.Service do
   def update(%Comment{} = comment, %{} = attributes) do
     Multi.new
     |> Multi.update(:comment, comment |> Comment.update_changeset(attributes))
-    |> Multi.run(:github, (fn %{comment: %Comment{} = comment} -> comment |> sync_to_github() end))
+    |> Multi.run(:github, (fn %{comment: %Comment{} = comment} -> comment |> update_on_github() end))
     |> Repo.transaction
     |> marshall_result()
   end
@@ -47,28 +55,31 @@ defmodule CodeCorps.Comment.Service do
     {:error, :github}
   end
 
-  @spec connect_to_github(Comment.t) :: {:ok, Comment.t} :: {:error, GitHub.api_error_struct}
-  defp connect_to_github(
-    %Comment{task: %Task{github_repo: nil}} = comment), do: {:ok, comment}
-  defp connect_to_github(
-    %Comment{task: %Task{github_repo: %GithubRepo{}}} = comment) do
+  @preloads [task: [:github_issue, github_repo: :github_app_installation]]
 
-    with {:ok, github_comment} <- comment |> GitHub.Comment.create do
+  @spec create_on_github(Comment.t) :: {:ok, Comment.t} :: {:error, GitHub.api_error_struct}
+  defp create_on_github(%Comment{task: %Task{github_issue_id: nil}} = comment), do: {:ok, comment}
+  defp create_on_github(%Comment{task: %Task{github_issue: github_issue}} = comment) do
+    with {:ok, payload} <- comment |> GitHub.Comment.create,
+         {:ok, %GithubComment{} = github_comment} <- CommentLinker.create_or_update_comment(github_issue, payload)do
       comment |> link_with_github_changeset(github_comment) |> Repo.update
     else
       {:error, github_error} -> {:error, github_error}
     end
   end
 
-  @spec link_with_github_changeset(Comment.t, map) :: Changeset.t
-  defp link_with_github_changeset(%Comment{} = comment, %{"id" => id}) do
-    comment |> Changeset.change(%{github_id: id})
+  @spec link_with_github_changeset(Comment.t, GithubComment.t) :: Changeset.t
+  defp link_with_github_changeset(%Comment{} = comment, %GithubComment{} = github_comment) do
+    comment |> Changeset.change(%{github_comment: github_comment})
   end
 
-  @spec sync_to_github(Comment.t) :: {:ok, Comment.t} :: {:error, GitHub.api_error_struct}
-  defp sync_to_github(%Comment{github_id: nil} = comment), do: {:ok, comment}
-  defp sync_to_github(%Comment{github_id: _} = comment) do
-    with {:ok, _issue} <- comment |> Repo.preload(@preloads) |> GitHub.Comment.update do
+  @spec update_on_github(Comment.t) :: {:ok, Comment.t} :: {:error, GitHub.api_error_struct}
+  defp update_on_github(%Comment{github_comment_id: nil} = comment), do: {:ok, comment}
+  defp update_on_github(%Comment{} = comment) do
+    with %Comment{task: %Task{github_issue: %GithubIssue{} = github_issue}} = comment <- comment |> Repo.preload(@preloads),
+         {:ok, payload} <- comment |> GitHub.Comment.update,
+         {:ok, %GithubComment{}} <- CommentLinker.create_or_update_comment(github_issue, payload) do
+
       {:ok, comment}
     else
       {:error, github_error} -> {:error, github_error}

lib/code_corps/github/adapters/comment.ex

@@ -1,21 +1,23 @@
 defmodule CodeCorps.GitHub.Adapters.Comment do
   @moduledoc """
-  Used to adapt a GitHub payload into attributes for creating or updating
-  a `CodeCorps.Comment`.
+  Adapts a GitHub payload into attributes for creating or updating a
+  `CodeCorps.GithubComment` record.
   """
 
-  alias CodeCorps.Comment
+  alias CodeCorps.{
+    Adapter.MapTransformer,
+    Comment
+  }
 
   @mapping [
     {:created_at, ["created_at"]},
-    {:github_id, ["id"]},
     {:markdown, ["body"]},
     {:modified_at, ["updated_at"]}
   ]
 
   @spec from_api(map) :: map
   def from_api(%{} = payload) do
-    payload |> CodeCorps.Adapter.MapTransformer.transform(@mapping)
+    payload |> MapTransformer.transform(@mapping)
   end
 
   @autogenerated_github_keys ~w(created_at id updated_at)
@@ -24,7 +26,25 @@ defmodule CodeCorps.GitHub.Adapters.Comment do
   def to_api(%Comment{} = comment) do
     comment
     |> Map.from_struct
-    |> CodeCorps.Adapter.MapTransformer.transform_inverse(@mapping)
+    |> MapTransformer.transform_inverse(@mapping)
     |> Map.drop(@autogenerated_github_keys)
   end
+
+  @github_comment_mapping [
+    {:body, ["body"]},
+    {:github_created_at, ["created_at"]},
+    {:github_id, ["id"]},
+    {:github_updated_at, ["updated_at"]},
+    {:html_url, ["html_url"]},
+    {:url, ["url"]}
+  ]
+
+  @doc ~S"""
+  Adapts the GitHub payload into attributes for creating or updating a
+  `CodeCorps.GithubComment` record.
+  """
+  @spec to_github_comment(map) :: map
+  def to_github_comment(%{} = payload) do
+    payload |> MapTransformer.transform(@github_comment_mapping)
+  end
 end

lib/code_corps/github/comment/comment.ex

@@ -3,7 +3,16 @@ defmodule CodeCorps.GitHub.Comment do
   Handles GitHub API requests for actions on Comments
   """
 
-  alias CodeCorps.{Comment, GitHub, GithubAppInstallation, GithubIssue, GithubRepo, Task, User}
+  alias CodeCorps.{
+    Comment,
+    GitHub,
+    GithubAppInstallation,
+    GithubComment,
+    GithubIssue,
+    GithubRepo,
+    Task,
+    User
+  }
 
   @spec create(Comment.t) :: GitHub.response
   def create(
@@ -50,7 +59,7 @@ defmodule CodeCorps.GitHub.Comment do
   @spec update_endpoint_for(Comment.t) :: String.t
   defp update_endpoint_for(
     %Comment{
-      github_id: id,
+      github_comment: %GithubComment{github_id: id},
       task: %Task{
         github_repo: %GithubRepo{
           github_account_login: owner, name: repo

lib/code_corps/github/event/issue_comment.ex

@@ -8,11 +8,14 @@ defmodule CodeCorps.GitHub.Event.IssueComment do
 
   alias CodeCorps.{
     Comment,
+    GithubComment,
     GithubRepo,
     GitHub.Event.Common.RepoFinder,
     GitHub.Event.Issues,
+    GitHub.Event.Issues.IssueLinker,
     GitHub.Event.Issues.TaskSyncer,
     GitHub.Event.IssueComment,
+    GitHub.Event.IssueComment.CommentLinker,
     GitHub.Event.IssueComment.CommentSyncer,
     GitHub.Event.IssueComment.CommentDeleter,
     Repo
@@ -24,6 +27,7 @@ defmodule CodeCorps.GitHub.Event.IssueComment do
                    {:error, :unexpected_payload} |
                    {:error, :repository_not_found} |
                    {:error, :validation_error_on_inserting_issue_for_task} |
+                   {:error, :validation_error_on_inserting_github_comment} |
                    {: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} |
@@ -62,28 +66,40 @@ defmodule CodeCorps.GitHub.Event.IssueComment do
   end
 
   @spec operational_multi(map) :: Multi.t
-  defp operational_multi(%{"action" => action, "issue" => issue_payload} = payload) when action in ~w(created edited) do
+  defp operational_multi(%{"action" => action, "issue" => issue_payload, "comment" => comment_payload} = payload) when action in ~w(created edited) do
     Multi.new
     |> Multi.run(:repo, fn _ -> RepoFinder.find_repo(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(:github_issue, fn %{repo: github_repo} -> github_repo |> link_issue(payload) end)
+    |> Multi.run(:github_comment, fn %{github_issue: github_issue} -> github_issue |> link_comment(payload) end)
+    |> Multi.run(:issue_user, fn %{github_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 %{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)
+    |> Multi.run(:tasks, fn %{github_issue: github_issue, issue_user: user} -> github_issue |> TaskSyncer.sync_all(user, payload) end)
+    |> Multi.run(:comments, fn %{github_comment: github_comment, tasks: tasks, comment_user: user} -> CommentSyncer.sync_all(tasks, github_comment, user, payload) end)
   end
   defp operational_multi(%{"action" => "deleted"} = payload) do
     Multi.new
     |> Multi.run(:comments, fn _ -> CommentDeleter.delete_all(payload) end)
   end
   defp operational_multi(%{}), do: Multi.new
 
+  @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 link_comment(GithubIssue.t, map) :: {:ok, GithubComment.t} | {:error, Ecto.Changeset.t}
+  defp link_comment(github_issue, %{"comment" => attrs}) do
+    CommentLinker.create_or_update_comment(github_issue, attrs)
+  end
+
   @spec marshall_result(tuple) :: tuple
   defp marshall_result({:ok, %{comments: comments}}), do: {:ok, comments}
   defp marshall_result({:error, :payload, :invalid, _steps}), do: {:error, :unexpected_payload}
   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, :github_issue, %Ecto.Changeset{}, _steps}), do: {:error, :validation_error_on_inserting_issue_for_task}
+  defp marshall_result({:error, :github_comment, %Ecto.Changeset{}, _steps}), do: {:error, :validation_error_on_inserting_github_comment}
   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/issue_comment/changeset_builder.ex

@@ -6,6 +6,7 @@ defmodule CodeCorps.GitHub.Event.IssueComment.ChangesetBuilder do
 
   alias CodeCorps.{
     Comment,
+    GithubComment,
     Services.MarkdownRendererService,
     Task,
     User,
@@ -18,28 +19,41 @@ defmodule CodeCorps.GitHub.Event.IssueComment.ChangesetBuilder do
   Constructs a changeset for syncing a task when processing an IssueComment
   webhook
   """
-  @spec build_changeset(Comment.t, map, Task.t, User.t) :: Changeset.t
-  def build_changeset(%Comment{id: nil} = comment, %{"comment" => attrs}, %Task{} = task, %User{} = user) do
-    comment |> create_changeset(attrs, task, user)
+  @spec build_changeset(Comment.t, map, GithubComment.t, Task.t, User.t) :: Changeset.t
+  def build_changeset(
+    %Comment{id: nil} = comment,
+    %{"comment" => attrs},
+    %GithubComment{} = github_comment,
+    %Task{} = task,
+    %User{} = user) do
+
+    comment |> create_changeset(attrs, github_comment, task, user)
   end
-  def build_changeset(%Comment{} = comment, %{"comment" => attrs}, %Task{}, %User{}) do
+  def build_changeset(%Comment{} = comment, %{"comment" => attrs}, %GithubComment{}, %Task{}, %User{}) do
     comment |> update_changeset(attrs)
   end
 
-  @create_attrs ~w(created_at github_id markdown modified_at)a
-  @spec create_changeset(Comment.t, map, Task.t, User.t) :: Changeset.t
-  defp create_changeset(%Comment{} = comment, %{} = attrs, %Task{} = task, %User{} = user) do
+  @create_attrs ~w(created_at markdown modified_at)a
+  @spec create_changeset(Comment.t, map, GithubComment.t, Task.t, User.t) :: Changeset.t
+  defp create_changeset(
+    %Comment{} = comment,
+    %{} = attrs,
+    %GithubComment{} = github_comment,
+    %Task{} = task,
+    %User{} = user) do
+
     comment
     |> Changeset.cast(CommentAdapter.from_api(attrs), @create_attrs)
     |> MarkdownRendererService.render_markdown_to_html(:markdown, :body)
     |> Changeset.put_change(:created_from, "github")
     |> Changeset.put_change(:modified_from, "github")
     |> Changeset.put_assoc(:task, task)
+    |> Changeset.put_assoc(:github_comment, github_comment)
     |> Changeset.put_change(:user, user)
     |> Changeset.validate_required([:markdown, :body])
   end
 
-  @update_attrs ~w(github_id markdown modified_at)a
+  @update_attrs ~w(markdown modified_at)a
   @spec update_changeset(Comment.t, map) :: Changeset.t
   defp update_changeset(%Comment{} = comment, %{} = attrs) do
     comment

lib/code_corps/github/event/issue_comment/comment_deleter.ex

@@ -1,6 +1,7 @@
 defmodule CodeCorps.GitHub.Event.IssueComment.CommentDeleter do
   alias CodeCorps.{
     Comment,
+    GithubComment,
     Repo
   }
 
@@ -12,8 +13,11 @@ defmodule CodeCorps.GitHub.Event.IssueComment.CommentDeleter do
   """
   @spec delete_all(map) :: {:ok, list(Comment.t)}
   def delete_all(%{"comment" => %{"id" => github_id}}) do
-    Comment
-    |> where([c], c.github_id == ^github_id)
+    query =
+      from c in Comment,
+        join: gc in GithubComment, on: gc.id == c.github_comment_id, where: gc.github_id == ^github_id
+
+    query
     |> Repo.delete_all(returning: true)
     |> (fn {_count, comments} -> {:ok, comments} end).()
   end

lib/code_corps/github/event/issue_comment/comment_linker.ex

@@ -0,0 +1,54 @@
+defmodule CodeCorps.GitHub.Event.IssueComment.CommentLinker 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.{
+    GitHub.Adapters,
+    GithubComment,
+    GithubIssue,
+    Repo
+  }
+
+  @typep linking_result :: {:ok, GithubComment.t} | {:error, Ecto.Changeset.t}
+
+  @doc ~S"""
+  Finds or creates a `CodeCorps.GithubComment` using the data in a GitHub
+  IssueComment payload.
+
+  The process is as follows:
+
+  - Search for the issue in our database with the payload data.
+    - If found, update it with payload data
+    - If not found, create it from payload data
+
+  `CodeCorps.GitHub.Adapters.Comment.to_github_comment/1` is used to adapt the
+  payload data.
+  """
+  @spec create_or_update_comment(GithubIssue.t, map) :: linking_result
+  def create_or_update_comment(%GithubIssue{} = github_issue, %{"id" => github_comment_id} = attrs) do
+    params = Adapters.Comment.to_github_comment(attrs)
+
+    case Repo.get_by(GithubComment, github_id: github_comment_id) do
+      nil -> create_comment(github_issue, params)
+      %GithubComment{} = github_comment -> github_comment |> update_issue(params)
+    end
+  end
+
+  defp create_comment(%GithubIssue{id: github_issue_id}, params) do
+    params = Map.put(params, :github_issue_id, github_issue_id)
+
+    %GithubComment{}
+    |> GithubComment.create_changeset(params)
+    |> Repo.insert
+  end
+
+  defp update_issue(%GithubComment{} = github_comment, params) do
+    github_comment
+    |> GithubComment.update_changeset(params)
+    |> Repo.update
+  end
+end