handle various claim lifecycle scenarios

Author: zcesur

lib/algora/bounties/bounties.ex

@@ -229,26 +229,41 @@ defmodule Algora.Bounties do
          status: status,
          type: type
        }) do
-    with {:ok, user} <- Workspace.ensure_user(token, provider_login),
-         activity_attrs = %{type: :claim_submitted, notify_users: [user.id]},
-         {:ok, claim} <-
-           Repo.insert_with_activity(
-             Claim.changeset(%Claim{}, %{
-               target_id: target.id,
-               source_id: source.id,
-               user_id: user.id,
-               type: type,
-               status: status,
-               url: source.url,
-               group_id: group_id,
-               group_share: group_share
-             }),
-             activity_attrs
-           ) do
-      {:ok, claim}
-    else
-      {:error, %{errors: [target_id: {_, [constraint: :unique, constraint_name: _]}]}} ->
-        {:error, :already_exists}
+    case Workspace.ensure_user(token, provider_login) do
+      {:ok, user} ->
+        activity_attrs = %{type: :claim_submitted, notify_users: [user.id]}
+
+        claim_attrs = %{
+          target_id: target.id,
+          source_id: source.id,
+          user_id: user.id,
+          type: type,
+          status: status,
+          url: source.url,
+          group_id: group_id,
+          group_share: group_share
+        }
+
+        # Try to find existing claim
+        existing_claim =
+          Repo.get_by(Claim,
+            target_id: target.id,
+            source_id: source.id,
+            user_id: user.id
+          )
+
+        case existing_claim do
+          nil ->
+            # Create new claim
+            %Claim{}
+            |> Claim.changeset(claim_attrs)
+            |> Repo.insert_with_activity(activity_attrs)
+
+          claim ->
+            claim
+            |> Claim.changeset(claim_attrs)
+            |> Repo.update_with_activity(activity_attrs)
+        end
 
       {:error, _reason} = error ->
         error
@@ -306,7 +321,7 @@ defmodule Algora.Bounties do
           },
           opts :: [installation_id: integer()]
         ) ::
-          {:ok, Bounty.t()} | {:error, atom()}
+          {:ok, [Claim.t()]} | {:error, atom()}
   def claim_bounty(
         %{
           user: user,
@@ -328,25 +343,89 @@ defmodule Algora.Bounties do
     Repo.transact(fn ->
       with {:ok, token} <- token_res,
            {: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_bounties(%{
-               provider_logins: [user.provider_login | coauthor_provider_logins],
-               token: token,
-               target: target,
-               source: source,
-               status: status,
-               type: type
-             }),
-           {:ok, _job} <- notify_claim(%{claim: claim}, installation_id: installation_id) do
-        broadcast()
-        {:ok, claim}
+           {:ok, source} <- Workspace.ensure_ticket(token, source_repo_owner, source_repo_name, source_number) do
+        # Get all active claims for this PR
+        active_claims = get_active_claims(source.id)
+        requested_participants = [user.provider_login | coauthor_provider_logins]
+
+        cond do
+          # Case 1: Target changed - cancel all claims and create new ones
+          target_changed?(active_claims, target.id) ->
+            with :ok <- cancel_all_claims(active_claims) do
+              create_new_claims(token, source, target, requested_participants, status, type, installation_id)
+            end
+
+          # Case 3: Participants changed - cancel old claims and create new ones
+          participants_changed?(active_claims, requested_participants) ->
+            with :ok <- cancel_all_claims(active_claims) do
+              create_new_claims(token, source, target, requested_participants, status, type, installation_id)
+            end
+
+          # Case 4: No existing claims - create new ones
+          Enum.empty?(active_claims) ->
+            create_new_claims(token, source, target, requested_participants, status, type, installation_id)
+
+          # Case 5: No changes needed
+          true ->
+            {:ok, active_claims}
+        end
       else
         {:error, _reason} = error -> error
       end
     end)
   end
 
+  def get_active_claims(source_id) do
+    Repo.all(
+      from c in Claim,
+        where: c.source_id == ^source_id,
+        where: c.status != :cancelled,
+        preload: [:user]
+    )
+  end
+
+  defp target_changed?(claims, target_id) do
+    Enum.any?(claims, fn claim -> claim.target_id != target_id end)
+  end
+
+  defp participants_changed?(claims, requested_participants) do
+    current_participants =
+      claims
+      |> Enum.map(& &1.user.provider_login)
+      |> Enum.sort()
+
+    requested_participants
+    |> Enum.sort()
+    |> Kernel.!=(current_participants)
+  end
+
+  def cancel_all_claims(claims) do
+    Enum.reduce_while(claims, :ok, fn claim, :ok ->
+      case claim
+           |> Claim.changeset(%{status: :cancelled})
+           |> Repo.update() do
+        {:ok, _} -> {:cont, :ok}
+        error -> error
+      end
+    end)
+  end
+
+  defp create_new_claims(token, source, target, participants, status, type, installation_id) do
+    with {:ok, [claim | _] = claims} <-
+           do_claim_bounties(%{
+             provider_logins: participants,
+             token: token,
+             target: target,
+             source: source,
+             status: status,
+             type: type
+           }),
+         {:ok, _job} <- notify_claim(%{claim: claim}, installation_id: installation_id) do
+      broadcast()
+      {:ok, claims}
+    end
+  end
+
   @spec notify_claim(
           %{claim: Claim.t()},
           opts :: [installation_id: integer()]

lib/algora/workspace/workspace.ex

@@ -19,7 +19,14 @@ defmodule Algora.Workspace do
   @type command_source :: :ticket | :comment
 
   def ensure_ticket(token, owner, repo, number) do
-    ticket_query =
+    case get_ticket(owner, repo, number) do
+      %Ticket{} = ticket -> {:ok, ticket}
+      nil -> create_ticket_from_github(token, owner, repo, number)
+    end
+  end
+
+  def get_ticket(owner, repo, number) do
+    Repo.one(
       from(t in Ticket,
         join: r in assoc(t, :repository),
         join: u in assoc(r, :user),
@@ -29,11 +36,7 @@ defmodule Algora.Workspace do
         where: u.provider_login == ^owner,
         preload: [repository: {r, user: u}]
       )
-
-    case Repo.one(ticket_query) do
-      %Ticket{} = ticket -> {:ok, ticket}
-      nil -> create_ticket_from_github(token, owner, repo, number)
-    end
+    )
   end
 
   def create_ticket_from_github(token, owner, repo, number) do

lib/algora_web/controllers/webhooks/github_controller.ex

@@ -49,8 +49,8 @@ defmodule AlgoraWeb.Webhooks.GithubController do
 
   def process_delivery(webhook) do
     with :ok <- ensure_human_author(webhook),
-         :ok <- process_commands(webhook),
-         :ok <- process_event(webhook) do
+         {:ok, commands} <- process_commands(webhook),
+         :ok <- process_event(webhook, commands) do
       Logger.debug("✅ #{inspect(webhook.event_action)}")
       :ok
     end
@@ -78,11 +78,14 @@ defmodule AlgoraWeb.Webhooks.GithubController do
     end
   end
 
-  defp process_event(%Webhook{event_action: "pull_request.closed", payload: %{"pull_request" => %{"merged_at" => nil}}}) do
+  defp process_event(
+         %Webhook{event_action: "pull_request.closed", payload: %{"pull_request" => %{"merged_at" => nil}}},
+         _commands
+       ) do
     :ok
   end
 
-  defp process_event(%Webhook{event_action: "pull_request.closed", payload: payload}) do
+  defp process_event(%Webhook{event_action: "pull_request.closed", payload: payload}, _commands) do
     with {:ok, token} <- Github.get_installation_token(payload["installation"]["id"]),
          {:ok, source} <-
            Workspace.ensure_ticket(
@@ -228,7 +231,31 @@ defmodule AlgoraWeb.Webhooks.GithubController do
     end
   end
 
-  defp process_event(_webhook), do: :ok
+  defp process_event(%Webhook{event_action: event_action, payload: payload}, commands)
+       when event_action in ["pull_request.opened", "pull_request.reopened", "pull_request.edited"] do
+    if Enum.any?(commands, &match?({:claim, _}, &1)) do
+      :ok
+    else
+      source =
+        Workspace.get_ticket(
+          payload["repository"]["owner"]["login"],
+          payload["repository"]["name"],
+          payload["pull_request"]["number"]
+        )
+
+      case source do
+        nil ->
+          :ok
+
+        source ->
+          source.id
+          |> Bounties.get_active_claims()
+          |> Bounties.cancel_all_claims()
+      end
+    end
+  end
+
+  defp process_event(_webhook, _commands), do: :ok
 
   defp execute_command(%Webhook{event_action: event_action, payload: payload} = webhook, {:bounty, args})
        when event_action in ["issues.opened", "issues.edited", "issue_comment.created", "issue_comment.edited"] do
@@ -397,34 +424,38 @@ defmodule AlgoraWeb.Webhooks.GithubController do
         {:ok,
          commands
          |> Enum.map(&build_command(&1, commands))
-         |> Enum.reject(&is_nil/1)}
+         |> Enum.reject(&is_nil/1)
+         # keep only the first claim command if multiple claims are present
+         |> Enum.reduce([], fn
+           {:claim, _} = claim, acc -> if Enum.any?(acc, &match?({:claim, _}, &1)), do: acc, else: [claim | acc]
+           command, acc -> [command | acc]
+         end)
+         |> Enum.reverse()}
 
       {:error, reason} = error ->
         Logger.error("Error parsing commands: #{inspect(reason)}")
         error
     end
   end
 
-  defp process_commands(%Webhook{event_action: event_action, body: body, hook_id: hook_id} = webhook) do
-    case build_commands(body) do
-      {:ok, commands} ->
-        Enum.reduce_while(commands, :ok, fn command, :ok ->
-          case execute_command(webhook, command) do
-            {:ok, _result} ->
-              {:cont, :ok}
-
-            error ->
-              Logger.error(
-                "Command execution failed for #{event_action}(#{hook_id}): #{inspect(command)}: #{inspect(error)}"
-              )
+  defp process_commands(%Webhook{body: body} = webhook) do
+    with {:ok, commands} <- build_commands(body),
+         :ok <- execute_commands(webhook, commands) do
+      {:ok, commands}
+    end
+  end
 
-              {:halt, error}
-          end
-        end)
+  defp execute_commands(%Webhook{event_action: event_action, hook_id: hook_id} = webhook, commands) do
+    Enum.reduce_while(commands, :ok, fn command, :ok ->
+      case execute_command(webhook, command) do
+        {:ok, _result} ->
+          Logger.debug("✅ #{inspect(command)}")
+          {:cont, :ok}
 
-      {:error, reason} = error ->
-        Logger.error("Error parsing commands: #{inspect(reason)}")
-        error
-    end
+        error ->
+          Logger.error("Command execution failed for #{event_action}(#{hook_id}): #{inspect(command)}: #{inspect(error)}")
+          {:halt, error}
+      end
+    end)
   end
 end

test/algora/bounties_test.exs

@@ -7,7 +7,6 @@ defmodule Algora.BountiesTest do
 
   alias Algora.Activities.Notifier
   alias Algora.Activities.SendEmail
-  alias Algora.Activities.Views
 
   def setup_github_mocks(_context) do
     import Algora.Mocks.GithubMock
@@ -59,7 +58,7 @@ defmodule Algora.BountiesTest do
 
       assert {:ok, bounty} = Algora.Bounties.create_bounty(bounty_params, [])
 
-      assert {:ok, claim} =
+      assert {:ok, claims} =
                Algora.Bounties.claim_bounty(
                  %{
                    user: recipient,
@@ -72,15 +71,15 @@ defmodule Algora.BountiesTest do
                  installation_id: installation.id
                )
 
-      claim = Algora.Repo.one(Algora.Bounties.Claim.preload(claim.id))
+      claims = Repo.preload(claims, :user)
 
       assert {:ok, _bounty} =
                Algora.Bounties.reward_bounty(
                  %{
                    owner: owner,
                    amount: ~M[4000]usd,
                    bounty_id: bounty.id,
-                   claims: [claim]
+                   claims: claims
                  },
                  installation_id: installation.id
                )
@@ -94,14 +93,14 @@ defmodule Algora.BountiesTest do
                    recipient: recipient
                  },
                  ticket_ref: ticket_ref,
-                 claims: [claim]
+                 claims: claims
                )
 
       assert_activity_names([:bounty_posted, :claim_submitted, :bounty_awarded, :tip_awarded])
       assert_activity_names_for_user(creator.id, [:bounty_posted, :bounty_awarded, :tip_awarded])
       assert_activity_names_for_user(recipient.id, [:claim_submitted, :tip_awarded])
 
-      assert [bounty, claim, awarded, tip] = Enum.reverse(Algora.Activities.all())
+      assert [bounty, _claim, _awarded, tip] = Enum.reverse(Algora.Activities.all())
       assert "tip_activities" == tip.assoc_name
       assert tip.notify_users == [recipient.id]
       assert activity = Algora.Activities.get_with_preloaded_assoc(tip.assoc_name, tip.id)