feat: bounty claims

Author: zcesur

config/config.exs

@@ -32,7 +32,8 @@ config :algora, Oban,
     comment_consumers: 1,
     github_og_image: 5,
     notify_bounty: 1,
-    notify_tip_intent: 1
+    notify_tip_intent: 1,
+    notify_claim: 1
   ]
 
 # Configures the mailer

lib/algora/bounties/bounties.ex

@@ -121,6 +121,88 @@ defmodule Algora.Bounties do
     |> Oban.insert()
   end
 
+  @spec do_claim_bounty(%{user: User.t(), ticket: Ticket.t(), pull_request: map()}) ::
+          {:ok, Claim.t()} | {:error, atom()}
+  defp do_claim_bounty(%{user: user, ticket: ticket, pull_request: pull_request}) do
+    # TODO: ensure user is pull request author
+    id = Nanoid.generate()
+
+    changeset =
+      Claim.changeset(%Claim{}, %{
+        ticket_id: ticket.id,
+        user_id: user.id,
+        provider: "github",
+        provider_id: pull_request["id"],
+        provider_meta: pull_request,
+        title: pull_request["title"],
+        url: pull_request["html_url"],
+        group_id: id,
+        merged_at: Util.to_date(pull_request["merged_at"])
+      })
+
+    case Repo.insert(changeset) do
+      {:ok, claim} ->
+        {:ok, claim}
+
+      {:error, %{errors: [ticket_id: {_, [constraint: :unique, constraint_name: _]}]}} ->
+        {:error, :already_exists}
+
+      {:error, _changeset} ->
+        {:error, :internal_server_error}
+    end
+  end
+
+  @spec claim_bounty(
+          %{
+            user: User.t(),
+            ticket_ref: %{owner: String.t(), repo: String.t(), number: integer()},
+            pull_request: map()
+          },
+          opts :: [installation_id: integer()]
+        ) ::
+          {:ok, Bounty.t()} | {:error, atom()}
+  def claim_bounty(
+        %{
+          user: user,
+          ticket_ref: %{owner: repo_owner, repo: repo_name, number: number} = ticket_ref,
+          pull_request: pull_request
+        },
+        opts \\ []
+      ) do
+    installation_id = opts[:installation_id]
+
+    token_res =
+      if installation_id,
+        do: Github.get_installation_token(installation_id),
+        else: Accounts.get_access_token(user)
+
+    Repo.transact(fn ->
+      with {:ok, token} <- token_res,
+           {:ok, ticket} <- Workspace.ensure_ticket(token, repo_owner, repo_name, number),
+           {:ok, claim} <- do_claim_bounty(%{user: user, ticket: ticket, pull_request: pull_request}),
+           {:ok, _job} <- notify_claim(%{ticket_ref: ticket_ref}, installation_id: installation_id) do
+        broadcast()
+        {:ok, claim}
+      else
+        {:error, _reason} = error -> error
+      end
+    end)
+  end
+
+  @spec notify_claim(
+          %{ticket_ref: %{owner: String.t(), repo: String.t(), number: integer()}},
+          opts :: [installation_id: integer()]
+        ) ::
+          {:ok, Oban.Job.t()} | {:error, atom()}
+  def notify_claim(%{ticket_ref: ticket_ref}, opts \\ []) do
+    %{
+      ticket_ref: %{owner: ticket_ref.owner, repo: ticket_ref.repo, number: ticket_ref.number},
+      installation_id: opts[:installation_id]
+    }
+    |> Jobs.NotifyClaim.new()
+    |> Oban.insert()
+  end
+
   @spec create_tip_intent(
           %{
             recipient: String.t(),

lib/algora/bounties/jobs/notify_claim.ex

@@ -0,0 +1,28 @@
+defmodule Algora.Bounties.Jobs.NotifyClaim do
+  @moduledoc false
+  use Oban.Worker, queue: :notify_claim
+
+  alias Algora.Github
+
+  require Logger
+
+  @impl Oban.Worker
+  def perform(%Oban.Job{args: %{"ticket_ref" => _ticket_ref, "installation_id" => nil}}) do
+    :ok
+  end
+
+  @impl Oban.Worker
+  def perform(%Oban.Job{args: %{"ticket_ref" => ticket_ref, "installation_id" => installation_id}}) do
+    with {:ok, token} <- Github.get_installation_token(installation_id) do
+      body = "Claimed!"
+
+      Github.create_issue_comment(
+        token,
+        ticket_ref["owner"],
+        ticket_ref["repo"],
+        ticket_ref["number"],
+        body
+      )
+    end
+  end
+end

lib/algora/bounties/schemas/bounty.ex

@@ -14,7 +14,6 @@ defmodule Algora.Bounties.Bounty do
     belongs_to :owner, User
     belongs_to :creator, User
     has_many :attempts, Algora.Bounties.Attempt
-    has_many :claims, Algora.Bounties.Claim
     has_many :transactions, Algora.Payments.Transaction
 
     timestamps()

lib/algora/bounties/schemas/claim.ex

@@ -6,41 +6,64 @@ defmodule Algora.Bounties.Claim do
 
   @derive {Inspect, except: [:provider_meta]}
   typed_schema "claims" do
-    field :provider, :string
-    field :provider_id, :string
-    field :provider_meta, :map
-
-    field :type, Ecto.Enum, values: [:code, :video, :design, :article]
-
-    field :status, Ecto.Enum, values: [:pending, :merged, :approved, :rejected, :charged, :paid]
+    field :provider, :string, null: false
+    field :provider_id, :string, null: false
+    field :provider_meta, :map, null: false
 
     field :merged_at, :utc_datetime_usec
     field :approved_at, :utc_datetime_usec
     field :rejected_at, :utc_datetime_usec
     field :charged_at, :utc_datetime_usec
     field :paid_at, :utc_datetime_usec
 
-    field :title, :string
+    field :title, :string, null: false
     field :description, :string
-    field :url, :string
-    field :group_id, :string
+    field :url, :string, null: false
+    field :group_id, :string, null: false
 
-    belongs_to :bounty, Algora.Bounties.Bounty
-    belongs_to :user, Algora.Accounts.User
+    belongs_to :ticket, Algora.Workspace.Ticket, null: false
+    belongs_to :user, Algora.Accounts.User, null: false
     # has_one :transaction, Algora.Payments.Transaction
 
     timestamps()
   end
 
   def changeset(claim, attrs) do
     claim
-    |> cast(attrs, [:bounty_id, :user_id])
-    |> validate_required([:bounty_id, :user_id])
+    |> cast(attrs, [
+      :ticket_id,
+      :user_id,
+      :provider,
+      :provider_id,
+      :provider_meta,
+      :merged_at,
+      :approved_at,
+      :rejected_at,
+      :charged_at,
+      :paid_at,
+      :title,
+      :description,
+      :url,
+      :group_id
+    ])
+    |> validate_required([
+      :ticket_id,
+      :user_id,
+      :provider,
+      :provider_id,
+      :provider_meta,
+      :title,
+      :url,
+      :group_id
+    ])
+    |> foreign_key_constraint(:ticket_id)
+    |> foreign_key_constraint(:user_id)
+    |> unique_constraint([:ticket_id, :user_id])
   end
 
   def rewarded(query \\ Claim) do
     from c in query,
-      where: c.status == :approved and not is_nil(c.charged_at)
+      where: c.state == :approved and not is_nil(c.charged_at)
   end
 
   def filter_by_org_id(query, nil), do: query

lib/algora/shared/util.ex

@@ -45,6 +45,15 @@ defmodule Algora.Util do
     date |> DateTime.shift_zone!(timezone) |> Calendar.strftime("%Y-%m-%d %I:%M %p")
   end
 
+  def to_date(nil), do: nil
+
+  def to_date(date) do
+    case DateTime.from_iso8601(date) do
+      {:ok, datetime, _offset} -> datetime
+      {:error, _reason} = error -> error
+    end
+  end
+
   def format_pct(percentage) do
     percentage
     |> Decimal.mult(100)

lib/algora/workspace/schemas/ticket.ex

@@ -18,6 +18,7 @@ defmodule Algora.Workspace.Ticket do
 
     belongs_to :repository, Algora.Workspace.Repository
     has_many :bounties, Algora.Bounties.Bounty
+    has_many :claims, Algora.Bounties.Claim
 
     timestamps()
   end

lib/algora_web/controllers/webhooks/github_controller.ex

@@ -113,12 +113,21 @@ defmodule AlgoraWeb.Webhooks.GithubController do
     end
   end
 
-  defp execute_command({:claim, args}, _author, _params) when not is_nil(args) do
-    owner = Keyword.get(args, :owner)
-    repo = Keyword.get(args, :repo)
-    number = Keyword.get(args, :number)
+  defp execute_command({:claim, args}, author, params) when not is_nil(args) do
+    installation_id = params["installation"]["id"]
+    pull_request = params["pull_request"]
 
-    Logger.info("Claim #{owner}/#{repo}##{number}")
+    with {:ok, token} <- Github.get_installation_token(installation_id),
+         {:ok, user} <- Workspace.ensure_user(token, author["login"]) do
+      Bounties.claim_bounty(
+        %{
+          user: user,
+          ticket_ref: %{owner: args[:owner], repo: args[:repo], number: args[:number]},
+          pull_request: pull_request
+        },
+        installation_id: installation_id
+      )
+    end
   end
 
   defp execute_command({command, _} = args, _author, _params),

priv/repo/migrations/20250112164132_recreate_claims.exs

@@ -0,0 +1,72 @@
+defmodule Algora.Repo.Migrations.RecreateClaims do
+  use Ecto.Migration
+
+  def up do
+    drop index(:claims, [:bounty_id])
+    drop index(:claims, [:user_id])
+    drop table(:claims)
+
+    create table(:claims) do
+      add :provider, :string, null: false
+      add :provider_id, :string, null: false
+      add :provider_meta, :map, null: false
+
+      add :opened_at, :utc_datetime_usec
+      add :merged_at, :utc_datetime_usec
+      add :approved_at, :utc_datetime_usec
+      add :rejected_at, :utc_datetime_usec
+      add :charged_at, :utc_datetime_usec
+      add :paid_at, :utc_datetime_usec
+
+      add :title, :string, null: false
+      add :description, :string
+      add :url, :string, null: false
+      add :group_id, :string, null: false
+
+      add :ticket_id, references(:tickets, on_delete: :nothing), null: false
+      add :user_id, references(:users, on_delete: :nothing), null: false
+
+      timestamps()
+    end
+
+    create unique_index(:claims, [:ticket_id, :user_id])
+    create index(:claims, [:ticket_id])
+    create index(:claims, [:user_id])
+  end
+
+  def down do
+    drop unique_index(:claims, [:ticket_id, :user_id])
+    drop index(:claims, [:ticket_id])
+    drop index(:claims, [:user_id])
+    drop table(:claims)
+
+    create table(:claims) do
+      add :provider, :string
+      add :provider_id, :string
+      add :provider_meta, :map
+
+      add :type, :string
+
+      add :status, :string
+
+      add :merged_at, :utc_datetime_usec
+      add :approved_at, :utc_datetime_usec
+      add :rejected_at, :utc_datetime_usec
+      add :charged_at, :utc_datetime_usec
+      add :paid_at, :utc_datetime_usec
+
+      add :title, :string
+      add :description, :string
+      add :url, :string
+      add :group_id, :string
+
+      add :bounty_id, references(:bounties, on_delete: :nothing)
+      add :user_id, references(:users, on_delete: :nothing)
+
+      timestamps()
+    end
+
+    create index(:claims, [:bounty_id])
+    create index(:claims, [:user_id])
+  end
+end

priv/repo/seeds.exs

@@ -399,7 +399,6 @@ for {repo_name, issues} <- repos do
         insert!(:claim, %{
           bounty_id: bounty.id,
           user_id: carver.id,
-          status: if(paid, do: :paid, else: :pending),
           title: "Implementation for #{issue_title}",
           description: "Here's my solution to this issue.",
           url: "https://github.com/piedpiper/#{repo_name}/pull/#{index}"