restructure claim schema

Author: zcesur

lib/algora/bounties/bounties.ex

@@ -121,28 +121,31 @@ defmodule Algora.Bounties do
     |> Oban.insert()
   end
 
-  @spec do_claim_bounty(%{user: User.t(), ticket: Ticket.t(), pull_request: map()}) ::
+  @spec do_claim_bounty(%{
+          user: User.t(),
+          target: Ticket.t(),
+          source: Ticket.t(),
+          status: :pending | :approved | :rejected | :paid,
+          type: :pull_request | :review | :video | :design | :article
+        }) ::
           {:ok, Claim.t()} | {:error, atom()}
-  defp do_claim_bounty(%{user: user, ticket: ticket, pull_request: pull_request}) do
+  defp do_claim_bounty(%{user: user, target: target, source: source, status: status, type: type}) do
     # TODO: ensure user is pull request author
     changeset =
       Claim.changeset(%Claim{}, %{
-        ticket_id: ticket.id,
+        target_id: target.id,
+        source_id: source.id,
         user_id: user.id,
-        provider: "github",
-        provider_id: to_string(pull_request["id"]),
-        provider_meta: Util.normalize_struct(pull_request),
-        type: :pull_request,
-        title: pull_request["title"],
-        url: pull_request["html_url"],
-        merged_at: Util.to_date(pull_request["merged_at"])
+        type: type,
+        status: status,
+        url: source.url
       })
 
     case Repo.insert(changeset) do
       {:ok, claim} ->
         {:ok, claim}
 
-      {:error, %{errors: [ticket_id: {_, [constraint: :unique, constraint_name: _]}]}} ->
+      {:error, %{errors: [target_id: {_, [constraint: :unique, constraint_name: _]}]}} ->
         {:error, :already_exists}
 
       {:error, _changeset} = error ->
@@ -153,17 +156,21 @@ defmodule Algora.Bounties do
   @spec claim_bounty(
           %{
             user: User.t(),
-            ticket_ref: %{owner: String.t(), repo: String.t(), number: integer()},
-            pull_request: map()
+            target_ticket_ref: %{owner: String.t(), repo: String.t(), number: integer()},
+            source_ticket_ref: %{owner: String.t(), repo: String.t(), number: integer()},
+            status: :pending | :approved | :rejected | :paid,
+            type: :pull_request | :review | :video | :design | :article
           },
           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
+          target_ticket_ref: %{owner: target_repo_owner, repo: target_repo_name, number: target_number},
+          source_ticket_ref: %{owner: source_repo_owner, repo: source_repo_name, number: source_number},
+          status: status,
+          type: type
         },
         opts \\ []
       ) do
@@ -176,8 +183,9 @@ defmodule Algora.Bounties do
 
     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, target} <- Workspace.ensure_ticket(token, target_repo_owner, target_repo_name, target_number),
+           {:ok, source} <- Workspace.ensure_ticket(token, source_repo_owner, source_repo_name, source_number),
+           {:ok, claim} <- do_claim_bounty(%{user: user, target: target, source: source, status: status, type: type}),
            {:ok, _job} <- notify_claim(%{claim: claim}, installation_id: installation_id) do
         broadcast()
         {:ok, claim}

lib/algora/bounties/jobs/notify_claim.ex

@@ -17,7 +17,7 @@ defmodule Algora.Bounties.Jobs.NotifyClaim do
   def perform(%Oban.Job{args: %{"claim_id" => claim_id, "installation_id" => installation_id}}) do
     with {:ok, token} <- Github.get_installation_token(installation_id),
          {:ok, claim} <- Repo.fetch(Claim, claim_id),
-         claim = Repo.preload(claim, ticket: [repository: [:user]], user: []),
+         claim = Repo.preload(claim, source: [repository: [:user]], target: [repository: [:user]], user: []),
          {:ok, _} <- maybe_add_labels(token, claim),
          {:ok, _} <- add_comment(token, claim) do
       :ok
@@ -27,21 +27,21 @@ defmodule Algora.Bounties.Jobs.NotifyClaim do
   defp add_comment(token, claim) do
     Github.create_issue_comment(
       token,
-      claim.ticket.repository.user.provider_login,
-      claim.ticket.repository.name,
-      claim.ticket.number,
+      claim.target.repository.user.provider_login,
+      claim.target.repository.name,
+      claim.target.number,
       "💡 @#{claim.user.provider_login} submitted [#{Claim.type_label(claim.type)}](#{claim.url}) that claims the bounty. You can visit [Algora](#{Claim.reward_url(claim)}) to reward."
     )
   end
 
-  defp maybe_add_labels(token, %Claim{type: :pull_request} = claim) do
+  defp maybe_add_labels(token, %Claim{source: source} = claim) when not is_nil(source) do
     Github.add_labels(
       token,
-      claim.provider_meta["base"]["repo"]["owner"]["login"],
-      claim.provider_meta["base"]["repo"]["name"],
-      claim.provider_meta["number"],
-      ["🙋 Bounty claim"])
-    
+      claim.source.repository.user.provider_login,
+      claim.source.repository.name,
+      claim.source.number,
+      ["🙋 Bounty claim"]
+    )
   end
 
   defp maybe_add_labels(_token, _claim), do: {:ok, nil}

lib/algora/bounties/schemas/claim.ex

@@ -3,27 +3,16 @@ defmodule Algora.Bounties.Claim do
   use Algora.Schema
 
   alias Algora.Bounties.Claim
+  alias Algora.Workspace.Ticket
 
-  @derive {Inspect, except: [:provider_meta]}
   typed_schema "claims" do
-    field :provider, :string, null: false
-    field :provider_id, :string, null: false
-    field :provider_meta, :map, null: false
-
+    field :status, Ecto.Enum, values: [:pending, :approved, :rejected, :paid], null: false
     field :type, Ecto.Enum, values: [:pull_request, :review, :video, :design, :article]
-
-    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, null: false
-    field :description, :string
     field :url, :string, null: false
     field :group_id, :string, null: false
 
-    belongs_to :ticket, Algora.Workspace.Ticket, null: false
+    belongs_to :source, Ticket
+    belongs_to :target, Ticket, null: false
     belongs_to :user, Algora.Accounts.User, null: false
     # has_one :transaction, Algora.Payments.Transaction
 
@@ -32,37 +21,14 @@ defmodule Algora.Bounties.Claim do
 
   def changeset(claim, attrs) do
     claim
-    |> cast(attrs, [
-      :ticket_id,
-      :user_id,
-      :provider,
-      :provider_id,
-      :provider_meta,
-      :merged_at,
-      :approved_at,
-      :rejected_at,
-      :charged_at,
-      :paid_at,
-      :type,
-      :title,
-      :description,
-      :url,
-      :group_id
-    ])
-    |> validate_required([
-      :ticket_id,
-      :user_id,
-      :provider,
-      :provider_id,
-      :provider_meta,
-      :title,
-      :url
-    ])
+    |> cast(attrs, [:source_id, :target_id, :user_id, :status, :type, :url, :group_id])
+    |> validate_required([:target_id, :user_id, :status, :type, :url])
     |> generate_id()
     |> put_group_id()
-    |> foreign_key_constraint(:ticket_id)
+    |> foreign_key_constraint(:source_id)
+    |> foreign_key_constraint(:target_id)
     |> foreign_key_constraint(:user_id)
-    |> unique_constraint([:ticket_id, :user_id])
+    |> unique_constraint([:target_id, :user_id])
   end
 
   def put_group_id(changeset) do

lib/algora/workspace/schemas/ticket.ex

@@ -18,7 +18,6 @@ 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

@@ -117,19 +117,28 @@ defmodule AlgoraWeb.Webhooks.GithubController do
     pull_request = params["pull_request"]
     repo = params["repository"]
 
-    ticket_ref = %{
-      owner: args[:ticket_ref][:owner] || repo["owner"]["login"],
-      repo: args[:ticket_ref][:repo] || repo["name"],
-      number: args[:ticket_ref][:number]
+    source_ticket_ref = %{
+      owner: repo["owner"]["login"],
+      repo: repo["name"],
+      number: pull_request["number"]
     }
 
+    target_ticket_ref =
+      %{
+        owner: args[:ticket_ref][:owner] || source_ticket_ref.owner,
+        repo: args[:ticket_ref][:repo] || source_ticket_ref.repo,
+        number: args[:ticket_ref][: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: ticket_ref,
-          pull_request: pull_request
+          target_ticket_ref: target_ticket_ref,
+          source_ticket_ref: source_ticket_ref,
+          status: if(pull_request["merged_at"], do: :approved, else: :pending),
+          type: :pull_request
         },
         installation_id: installation_id
       )

priv/repo/migrations/20250112164132_recreate_claims.exs

@@ -7,37 +7,28 @@ defmodule Algora.Repo.Migrations.RecreateClaims do
     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 :status, :string, null: false
       add :type, :string, null: false
-      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 :source_id, references(:tickets, on_delete: :nothing), null: false
+      add :target_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 unique_index(:claims, [:target_id, :user_id])
+    create index(:claims, [:source_id])
+    create index(:claims, [:target_id])
     create index(:claims, [:user_id])
   end
 
   def down do
-    drop unique_index(:claims, [:ticket_id, :user_id])
-    drop index(:claims, [:ticket_id])
+    drop unique_index(:claims, [:target_id, :user_id])
+    drop index(:claims, [:source_id])
+    drop index(:claims, [:target_id])
     drop index(:claims, [:user_id])
     drop table(:claims)
 

priv/repo/seeds.exs

@@ -355,7 +355,7 @@ for {repo_name, issues} <- repos do
     })
 
   for {issue_title, index} <- Enum.with_index(issues, 1) do
-    ticket =
+    issue =
       insert!(:ticket, %{
         repository_id: repo.id,
         title: issue_title,
@@ -371,7 +371,7 @@ for {repo_name, issues} <- repos do
 
     bounty =
       insert!(:bounty, %{
-        ticket_id: ticket.id,
+        ticket_id: issue.id,
         owner_id: pied_piper.id,
         creator_id: richard.id,
         amount: amount,
@@ -385,7 +385,7 @@ for {repo_name, issues} <- repos do
         amount = Money.new!(Enum.random([500, 1000, 1500, 2000]), :USD)
 
         insert!(:bounty, %{
-          ticket_id: ticket.id,
+          ticket_id: issue.id,
           owner_id: member.id,
           creator_id: member.id,
           amount: amount,
@@ -395,15 +395,24 @@ for {repo_name, issues} <- repos do
     end
 
     if claimed do
-      claim =
-        insert!(:claim, %{
-          bounty_id: bounty.id,
+      pull_request =
+        insert!(:ticket, %{
           user_id: carver.id,
           title: "Implementation for #{issue_title}",
           description: "Here's my solution to this issue.",
           url: "https://github.com/piedpiper/#{repo_name}/pull/#{index}"
         })
 
+      claim =
+        insert!(:claim, %{
+          user_id: carver.id,
+          target_id: pull_request.id,
+          source_id: issue.id,
+          type: :pull_request,
+          status: if(paid, do: :paid, else: :pending),
+          url: "https://github.com/piedpiper/#{repo_name}/pull/#{index}"
+        })
+
       # Create transaction pairs for paid claims
       if paid do
         debit_id = Nanoid.generate()

test/support/factory.ex

@@ -197,12 +197,8 @@ defmodule Algora.Factory do
   def claim_factory do
     %Algora.Bounties.Claim{
       id: Nanoid.generate(),
-      provider: "github",
-      provider_id: sequence(:provider_id, &"#{&1}"),
-      title: "Implemented compression optimization",
-      description: "Added parallel processing for large files",
-      url: "https://github.com/piedpiper/middle-out/pull/2",
-      provider_meta: %{}
+      type: :pull_request,
+      status: :pending
     }
   end