feat: auto-pay on merge (#51)

Author: zcesur

lib/algora/bounties/bounties.ex

@@ -462,7 +462,7 @@ defmodule Algora.Bounties do
     recipient = opts[:recipient]
     claims = opts[:claims] || []
 
-    description = if(ticket_ref, do: "#{ticket_ref[:owner]}/#{ticket_ref[:repo]}##{ticket_ref[:number]}")
+    description = if(ticket_ref, do: "#{ticket_ref[:repo]}##{ticket_ref[:number]}")
 
     platform_fee_pct = FeeTier.calculate_fee_percentage(Money.zero(:USD))
     transaction_fee_pct = Payments.get_transaction_fee_pct()
@@ -563,6 +563,73 @@ defmodule Algora.Bounties do
     end)
   end
 
+  @spec create_invoice(
+          %{owner: User.t(), amount: Money.t()},
+          opts :: [
+            ticket_ref: %{owner: String.t(), repo: String.t(), number: integer()},
+            tip_id: String.t(),
+            bounty_id: String.t(),
+            claims: [Claim.t()],
+            recipient: User.t()
+          ]
+        ) ::
+          {:ok, Stripe.Invoice.t()} | {:error, atom()}
+  def create_invoice(%{owner: owner, amount: amount}, opts \\ []) do
+    tx_group_id = Nanoid.generate()
+
+    line_items =
+      generate_line_items(%{amount: amount},
+        ticket_ref: opts[:ticket_ref],
+        recipient: opts[:recipient],
+        claims: opts[:claims]
+      )
+
+    gross_amount = LineItem.gross_amount(line_items)
+
+    Repo.transact(fn ->
+      with {:ok, _charge} <-
+             initialize_charge(%{
+               id: Nanoid.generate(),
+               tip_id: opts[:tip_id],
+               bounty_id: opts[:bounty_id],
+               claim_id: nil,
+               user_id: owner.id,
+               gross_amount: gross_amount,
+               net_amount: amount,
+               total_fee: Money.sub!(gross_amount, amount),
+               line_items: line_items,
+               group_id: tx_group_id
+             }),
+           {:ok, _transactions} <-
+             create_transaction_pairs(%{
+               claims: opts[:claims] || [],
+               tip_id: opts[:tip_id],
+               bounty_id: opts[:bounty_id],
+               claim_id: nil,
+               amount: amount,
+               creator_id: owner.id,
+               group_id: tx_group_id
+             }),
+           {:ok, customer} <- Payments.fetch_or_create_customer(owner),
+           {:ok, invoice} <-
+             Algora.Stripe.create_invoice(%{
+               auto_advance: false,
+               customer: customer.provider_id
+             }),
+           {:ok, _line_items} <-
+             line_items
+             |> Enum.map(&LineItem.to_invoice_item(&1, invoice, customer))
+             |> Enum.reduce_while({:ok, []}, fn params, {:ok, acc} ->
+               case Algora.Stripe.create_invoice_item(params) do
+                 {:ok, item} -> {:cont, {:ok, [item | acc]}}
+                 {:error, error} -> {:halt, {:error, error}}
+               end
+             end) do
+        {:ok, invoice}
+      end
+    end)
+  end
+
   defp initialize_charge(%{
          id: id,
          tip_id: tip_id,

lib/algora/bounties/schemas/line_item.ex

@@ -32,6 +32,16 @@ defmodule Algora.Bounties.LineItem do
     }
   end
 
+  def to_invoice_item(line_item, invoice, customer) do
+    %{
+      invoice: invoice.id,
+      customer: customer.provider_id,
+      amount: MoneyUtils.to_minor_units(line_item.amount),
+      currency: to_string(line_item.amount.currency),
+      description: if(line_item.description, do: line_item.title <> " - " <> line_item.description, else: line_item.title)
+    }
+  end
+
   def gross_amount(line_items) do
     Enum.reduce(line_items, Money.zero(:USD), fn item, acc -> Money.add!(acc, item.amount) end)
   end

lib/algora/shared/util.ex

@@ -80,6 +80,13 @@ defmodule Algora.Util do
     |> Kernel.<>("%")
   end
 
+  def normalize_struct(%Money{} = money) do
+    %{
+      amount: Decimal.to_string(money.amount),
+      currency: money.currency
+    }
+  end
+
   def normalize_struct(struct) when is_struct(struct) do
     struct
     |> Map.from_struct()

lib/algora_web/controllers/webhooks/github_controller.ex

@@ -1,23 +1,32 @@
 defmodule AlgoraWeb.Webhooks.GithubController do
   use AlgoraWeb, :controller
 
+  import Ecto.Query
+
   alias Algora.Accounts
   alias Algora.Bounties
+  alias Algora.Bounties.Bounty
+  alias Algora.Bounties.Claim
   alias Algora.Github
   alias Algora.Github.Webhook
   alias Algora.Repo
   alias Algora.Workspace
   alias Algora.Workspace.CommandResponse
+  alias Algora.Workspace.Installation
 
   require Logger
 
   # TODO: persist & alert about failed deliveries
   # TODO: auto-retry failed deliveries with exponential backoff
 
   def new(conn, params) do
-    with {:ok, webhook} <- Webhook.new(conn),
+    with {:ok, %{event: event} = webhook} <- Webhook.new(conn),
          :ok <- ensure_human_author(webhook, params),
-         {:ok, _} <- process_commands(webhook, params) do
+         author = get_author(event, params),
+         body = get_body(event, params),
+         event_action = join_event_action(event, params),
+         {:ok, _} <- process_commands(webhook, event_action, author, body, params),
+         :ok <- process_event(event_action, params) do
       conn |> put_status(:accepted) |> json(%{status: "ok"})
     else
       {:error, :bot_event} ->
@@ -32,10 +41,14 @@ defmodule AlgoraWeb.Webhooks.GithubController do
       {:error, reason} ->
         Logger.error("Error processing webhook: #{inspect(reason)}")
         conn |> put_status(:internal_server_error) |> json(%{error: "Internal server error"})
+
+      error ->
+        Logger.error("Error processing webhook: #{inspect(error)}")
+        conn |> put_status(:internal_server_error) |> json(%{error: "Internal server error"})
     end
   rescue
     e ->
-      Logger.error("Unexpected error: #{inspect(e)}")
+      Logger.error(Exception.format(:error, e, __STACKTRACE__))
       conn |> put_status(:internal_server_error) |> json(%{error: "Internal server error"})
   end
 
@@ -63,6 +76,161 @@ defmodule AlgoraWeb.Webhooks.GithubController do
 
   defp get_permissions(_author, _params), do: {:error, :invalid_params}
 
+  def process_event(event_action, %{"pull_request" => %{"merged_at" => nil}})
+      when event_action in ["pull_request.closed"] do
+    :ok
+  end
+
+  def process_event(event_action, %{
+        "repository" => repository,
+        "pull_request" => pull_request,
+        "installation" => installation
+      })
+      when event_action in ["pull_request.closed"] do
+    with {:ok, token} <- Github.get_installation_token(installation["id"]),
+         {:ok, source} <-
+           Workspace.ensure_ticket(token, repository["owner"]["login"], repository["name"], pull_request["number"]) do
+      claims =
+        case Repo.one(
+               from c in Claim,
+                 join: s in assoc(c, :source),
+                 join: u in assoc(c, :user),
+                 where: s.id == ^source.id,
+                 where: u.provider == "github",
+                 where: u.provider_id == ^to_string(pull_request["user"]["id"]),
+                 order_by: [asc: c.inserted_at],
+                 limit: 1
+             ) do
+          nil ->
+            []
+
+          %Claim{group_id: group_id} ->
+            Repo.update_all(
+              from(c in Claim, where: c.group_id == ^group_id),
+              set: [status: :approved]
+            )
+
+            Repo.all(
+              from c in Claim,
+                join: t in assoc(c, :target),
+                join: tr in assoc(t, :repository),
+                join: tru in assoc(tr, :user),
+                join: u in assoc(c, :user),
+                where: c.group_id == ^group_id,
+                order_by: [desc: c.group_share, asc: c.inserted_at],
+                select_merge: %{
+                  target: %{t | repository: %{tr | user: tru}},
+                  user: u
+                }
+            )
+        end
+
+      if claims == [] do
+        :ok
+      else
+        primary_claim = List.first(claims)
+
+        installation =
+          Repo.one(
+            from i in Installation,
+              where: i.provider == "github",
+              where: i.provider_id == ^to_string(installation["id"])
+          )
+
+        bounties =
+          Repo.all(
+            from(b in Bounty,
+              join: t in assoc(b, :ticket),
+              join: o in assoc(b, :owner),
+              left_join: u in assoc(b, :creator),
+              left_join: c in assoc(o, :customer),
+              left_join: p in assoc(c, :default_payment_method),
+              where: t.id == ^primary_claim.target_id,
+              select_merge: %{owner: %{o | customer: %{default_payment_method: p}}, creator: u}
+            )
+          )
+
+        autopayable_bounty =
+          Enum.find(
+            bounties,
+            &(not is_nil(installation) and
+                &1.owner.id == installation.connected_user_id and
+                not is_nil(&1.owner.customer) and
+                not is_nil(&1.owner.customer.default_payment_method))
+          )
+
+        autopay_result =
+          if autopayable_bounty do
+            with {:ok, invoice} <-
+                   Bounties.create_invoice(
+                     %{
+                       owner: autopayable_bounty.owner,
+                       amount: autopayable_bounty.amount
+                     },
+                     ticket_ref: %{
+                       owner: repository["owner"]["login"],
+                       repo: repository["name"],
+                       number: pull_request["number"]
+                     },
+                     bounty_id: autopayable_bounty.id,
+                     claims: claims
+                   ),
+                 {:ok, _invoice} <-
+                   Algora.Stripe.pay_invoice(invoice, %{
+                     payment_method: autopayable_bounty.owner.customer.default_payment_method.provider_id,
+                     off_session: true
+                   }) do
+              Logger.info("Autopay successful (#{autopayable_bounty.owner.name} - #{autopayable_bounty.amount}).")
+              :ok
+            else
+              {:error, reason} ->
+                Logger.error(
+                  "Autopay failed (#{autopayable_bounty.owner.name} - #{autopayable_bounty.amount}): #{inspect(reason)}"
+                )
+
+                :error
+            end
+          end
+
+        unpaid_bounties =
+          Enum.filter(
+            bounties,
+            &case autopay_result do
+              :ok -> &1.id != autopayable_bounty.id
+              _ -> true
+            end
+          )
+
+        sponsors_to_notify =
+          unpaid_bounties
+          |> Enum.map(&(&1.creator || &1.owner))
+          |> Enum.map_join(", ", &"@#{&1.provider_login}")
+
+        if unpaid_bounties != [] do
+          names =
+            claims
+            |> Enum.map(fn c -> "@#{c.user.provider_login}" end)
+            |> Algora.Util.format_name_list()
+
+          Github.create_issue_comment(
+            token,
+            primary_claim.target.repository.user.provider_login,
+            primary_claim.target.repository.name,
+            primary_claim.target.number,
+            "🎉 The pull request of #{names} has been merged. You can visit [Algora](#{Claim.reward_url(primary_claim)}) to award the bounty." <>
+              if(sponsors_to_notify == "", do: "", else: "\n\ncc #{sponsors_to_notify}")
+          )
+        end
+
+        :ok
+      end
+    end
+  end
+
+  def process_event(_event_action, _params) do
+    :ok
+  end
+
   defp execute_command(event_action, {:bounty, args}, author, params)
        when event_action in ["issues.opened", "issues.edited", "issue_comment.created", "issue_comment.edited"] do
     [event, _action] = String.split(event_action, ".")
@@ -242,12 +410,7 @@ defmodule AlgoraWeb.Webhooks.GithubController do
     end
   end
 
-  def process_commands(%Webhook{event: event, hook_id: hook_id}, params) do
-    author = get_author(event, params)
-    body = get_body(event, params)
-
-    event_action = event <> "." <> params["action"]
-
+  def process_commands(%Webhook{hook_id: hook_id}, event_action, author, body, params) do
     case build_commands(body) do
       {:ok, commands} ->
         Enum.reduce_while(commands, {:ok, []}, fn command, {:ok, results} ->
@@ -270,17 +433,20 @@ defmodule AlgoraWeb.Webhooks.GithubController do
     end
   end
 
-  defp get_author("issues", params), do: params["issue"]["user"]
-  defp get_author("issue_comment", params), do: params["comment"]["user"]
-  defp get_author("pull_request", params), do: params["pull_request"]["user"]
-  defp get_author("pull_request_review", params), do: params["review"]["user"]
-  defp get_author("pull_request_review_comment", params), do: params["comment"]["user"]
-  defp get_author(_event, _params), do: nil
-
-  defp get_body("issues", params), do: params["issue"]["body"]
-  defp get_body("issue_comment", params), do: params["comment"]["body"]
-  defp get_body("pull_request", params), do: params["pull_request"]["body"]
-  defp get_body("pull_request_review", params), do: params["review"]["body"]
-  defp get_body("pull_request_review_comment", params), do: params["comment"]["body"]
-  defp get_body(_event, _params), do: nil
+  def join_event_action(event, params), do: event <> "." <> params["action"]
+
+  def split_event_action(event_action) do
+    [event, action] = String.split(event_action, ".")
+    {event, action}
+  end
+
+  def get_entity_key("issues"), do: "issue"
+  def get_entity_key("issue_comment"), do: "comment"
+  def get_entity_key("pull_request"), do: "pull_request"
+  def get_entity_key("pull_request_review"), do: "review"
+  def get_entity_key("pull_request_review_comment"), do: "comment"
+  def get_entity_key(_event), do: nil
+
+  def get_author(event, params), do: get_in(params, ["#{get_entity_key(event)}", "user"])
+  def get_body(event, params), do: get_in(params, ["#{get_entity_key(event)}", "body"])
 end