implement 3 step flow

zcesur · zcesur · commit d2e03bd71800 · 2025-04-23T13:24:12.000+03:00
diff --git a/lib/algora/bounties/bounties.ex b/lib/algora/bounties/bounties.ex
@@ -805,7 +805,9 @@ defmodule Algora.Bounties do
       bounty: bounty,
       claims: claims,
       recipient: opts[:recipient],
-      capture_method: :manual
+      capture_method: :manual,
+      success_url: opts[:success_url],
+      cancel_url: opts[:cancel_url]
     )
   end
 
@@ -883,7 +885,9 @@ defmodule Algora.Bounties do
             bounty: Bounty.t(),
             claims: [Claim.t()],
             recipient: User.t(),
-            capture_method: :automatic | :automatic_async | :manual
+            capture_method: :automatic | :automatic_async | :manual,
+            success_url: String.t(),
+            cancel_url: String.t()
           ]
         ) ::
           {:ok, String.t()} | {:error, atom()}
@@ -903,11 +907,12 @@ defmodule Algora.Bounties do
       metadata: %{"version" => Payments.metadata_version(), "group_id" => tx_group_id}
     }
 
-    payment_intent_data =
+    {payment_intent_data, session_opts} =
       if capture_method = opts[:capture_method] do
-        Map.put(payment_intent_data, :capture_method, capture_method)
+        {Map.put(payment_intent_data, :capture_method, capture_method),
+         [success_url: opts[:success_url], cancel_url: opts[:cancel_url]]}
       else
-        payment_intent_data
+        {payment_intent_data, []}
       end
 
     gross_amount = LineItem.gross_amount(line_items)
@@ -939,7 +944,12 @@ defmodule Algora.Bounties do
                group_id: tx_group_id
              }),
            {:ok, session} <-
-             Payments.create_stripe_session(owner, Enum.map(line_items, &LineItem.to_stripe/1), payment_intent_data) do
+             Payments.create_stripe_session(
+               owner,
+               Enum.map(line_items, &LineItem.to_stripe/1),
+               payment_intent_data,
+               session_opts
+             ) do
         {:ok, session.url}
       end
     end)
diff --git a/lib/algora/payments/payments.ex b/lib/algora/payments/payments.ex
@@ -5,6 +5,11 @@ defmodule Algora.Payments do
 
   alias Algora.Accounts
   alias Algora.Accounts.User
+  alias Algora.Bounties
+  alias Algora.Bounties.Bounty
+  alias Algora.Bounties.Claim
+  alias Algora.Bounties.Tip
+  alias Algora.Contracts.Contract
   alias Algora.MoneyUtils
   alias Algora.Payments.Account
   alias Algora.Payments.Customer
@@ -31,18 +36,19 @@ defmodule Algora.Payments do
   @spec create_stripe_session(
           user :: User.t(),
           line_items :: [PSP.Session.line_item_data()],
-          payment_intent_data :: PSP.Session.payment_intent_data()
+          payment_intent_data :: PSP.Session.payment_intent_data(),
+          opts :: Keyword.t()
         ) ::
           {:ok, PSP.session()} | {:error, PSP.error()}
-  def create_stripe_session(user, line_items, payment_intent_data) do
+  def create_stripe_session(user, line_items, payment_intent_data, opts \\ []) do
     with {:ok, customer} <- fetch_or_create_customer(user) do
       opts = %{
         mode: "payment",
         customer: customer.provider_id,
         billing_address_collection: "required",
         line_items: line_items,
-        success_url: "#{AlgoraWeb.Endpoint.url()}/payment/success",
-        cancel_url: "#{AlgoraWeb.Endpoint.url()}/payment/canceled",
+        success_url: opts[:success_url] || "#{AlgoraWeb.Endpoint.url()}/payment/success",
+        cancel_url: opts[:cancel_url] || "#{AlgoraWeb.Endpoint.url()}/payment/canceled",
         payment_intent_data: payment_intent_data
       }
 
@@ -544,4 +550,140 @@ defmodule Algora.Payments do
         {:error, error}
     end
   end
+
+  def process_charge(%Stripe.Event{type: "charge.succeeded", data: %{object: %Stripe.Charge{}}}, group_id)
+      when not is_binary(group_id) do
+    {:error, :invalid_group_id}
+  end
+
+  def process_charge(
+        "charge.succeeded",
+        %Stripe.Charge{id: charge_id, captured: false, payment_intent: payment_intent_id},
+        group_id
+      ) do
+    Repo.transact(fn ->
+      Repo.update_all(from(t in Transaction, where: t.group_id == ^group_id, where: t.type == :charge),
+        set: [
+          status: :requires_capture,
+          provider: "stripe",
+          provider_id: charge_id,
+          provider_charge_id: charge_id,
+          provider_payment_intent_id: payment_intent_id
+        ]
+      )
+
+      broadcast()
+      {:ok, nil}
+    end)
+  end
+
+  def process_charge(
+        "charge.captured",
+        %Stripe.Charge{id: charge_id, captured: true, payment_intent: payment_intent_id},
+        group_id
+      ) do
+    Repo.transact(fn ->
+      Repo.update_all(from(t in Transaction, where: t.group_id == ^group_id, where: t.type == :charge),
+        set: [
+          status: :succeeded,
+          provider: "stripe",
+          provider_id: charge_id,
+          provider_charge_id: charge_id,
+          provider_payment_intent_id: payment_intent_id
+        ]
+      )
+
+      Repo.update_all(from(t in Transaction, where: t.group_id == ^group_id, where: t.type != :charge),
+        set: [
+          status: :requires_release,
+          provider: "stripe",
+          provider_id: charge_id,
+          provider_charge_id: charge_id,
+          provider_payment_intent_id: payment_intent_id
+        ]
+      )
+
+      broadcast()
+      {:ok, nil}
+    end)
+  end
+
+  def process_charge(
+        "charge.succeeded",
+        %Stripe.Charge{id: charge_id, captured: true, payment_intent: payment_intent_id},
+        group_id
+      ) do
+    Repo.transact(fn ->
+      {_, txs} =
+        Repo.update_all(from(t in Transaction, where: t.group_id == ^group_id, select: t),
+          set: [
+            status: :succeeded,
+            succeeded_at: DateTime.utc_now(),
+            provider: "stripe",
+            provider_id: charge_id,
+            provider_charge_id: charge_id,
+            provider_payment_intent_id: payment_intent_id
+          ]
+        )
+
+      bounty_ids = txs |> Enum.map(& &1.bounty_id) |> Enum.reject(&is_nil/1) |> Enum.uniq()
+      tip_ids = txs |> Enum.map(& &1.tip_id) |> Enum.reject(&is_nil/1) |> Enum.uniq()
+      contract_ids = txs |> Enum.map(& &1.contract_id) |> Enum.reject(&is_nil/1) |> Enum.uniq()
+      claim_ids = txs |> Enum.map(& &1.claim_id) |> Enum.reject(&is_nil/1) |> Enum.uniq()
+
+      Repo.update_all(from(b in Bounty, where: b.id in ^bounty_ids), set: [status: :paid])
+      Repo.update_all(from(t in Tip, where: t.id in ^tip_ids), set: [status: :paid])
+      Repo.update_all(from(c in Contract, where: c.id in ^contract_ids), set: [status: :paid])
+      # TODO: add and use a new "paid" status for claims
+      Repo.update_all(from(c in Claim, where: c.id in ^claim_ids), set: [status: :approved])
+
+      activities_result =
+        txs
+        |> Enum.filter(&(&1.type == :credit))
+        |> Enum.reduce_while(:ok, fn tx, :ok ->
+          case Repo.insert_activity(tx, %{type: :transaction_succeeded, notify_users: [tx.user_id]}) do
+            {:ok, _} -> {:cont, :ok}
+            error -> {:halt, error}
+          end
+        end)
+
+      jobs_result =
+        txs
+        |> Enum.filter(&(&1.type == :credit))
+        |> Enum.reduce_while(:ok, fn credit, :ok ->
+          case fetch_active_account(credit.user_id) do
+            {:ok, _account} ->
+              case %{credit_id: credit.id}
+                   |> Jobs.ExecutePendingTransfer.new()
+                   |> Oban.insert() do
+                {:ok, _job} -> {:cont, :ok}
+                error -> {:halt, error}
+              end
+
+            {:error, :no_active_account} ->
+              case %{credit_id: credit.id}
+                   |> Bounties.Jobs.PromptPayoutConnect.new()
+                   |> Oban.insert() do
+                {:ok, _job} -> {:cont, :ok}
+                error -> {:halt, error}
+              end
+          end
+        end)
+
+      with txs when txs != [] <- txs,
+           :ok <- activities_result,
+           :ok <- jobs_result do
+        broadcast()
+        {:ok, nil}
+      else
+        {:error, reason} ->
+          Logger.error("Failed to update transactions: #{inspect(reason)}")
+          {:error, :failed_to_update_transactions}
+
+        error ->
+          Logger.error("Failed to update transactions: #{inspect(error)}")
+          {:error, :failed_to_update_transactions}
+      end
+    end)
+  end
 end
diff --git a/lib/algora/payments/schemas/transaction.ex b/lib/algora/payments/schemas/transaction.ex
@@ -7,7 +7,7 @@ defmodule Algora.Payments.Transaction do
   alias Algora.Types.Money
 
   @transaction_types [:charge, :transfer, :reversal, :debit, :credit, :deposit, :withdrawal]
-  @transaction_statuses [:initialized, :processing, :requires_capture, :succeeded, :failed, :canceled]
+  @transaction_statuses [:initialized, :processing, :requires_capture, :requires_release, :succeeded, :failed, :canceled]
 
   @derive {Inspect, except: [:provider_meta]}
   typed_schema "transactions" do
diff --git a/lib/algora/psp/psp.ex b/lib/algora/psp/psp.ex
@@ -133,6 +133,14 @@ defmodule Algora.PSP do
     def capture(id, params \\ %{}), do: Algora.PSP.client(__MODULE__).capture(id, params)
   end
 
+  @type charge :: Algora.PSP.Charge.t()
+  defmodule Charge do
+    @moduledoc false
+
+    @type t :: Stripe.Charge.t()
+    def retrieve(id), do: Algora.PSP.client(__MODULE__).retrieve(id)
+  end
+
   @type setup_intent :: Algora.PSP.SetupIntent.t()
   defmodule SetupIntent do
     @moduledoc false
diff --git a/lib/algora_web/controllers/webhooks/stripe_controller.ex b/lib/algora_web/controllers/webhooks/stripe_controller.ex
@@ -2,13 +2,8 @@ defmodule AlgoraWeb.Webhooks.StripeController do
   @behaviour Stripe.WebhookHandler
 
   import Ecto.Changeset
-  import Ecto.Query
 
   alias Algora.Bounties
-  alias Algora.Bounties.Bounty
-  alias Algora.Bounties.Claim
-  alias Algora.Bounties.Tip
-  alias Algora.Contracts.Contract
   alias Algora.Payments
   alias Algora.Payments.Customer
   alias Algora.Payments.Transaction
@@ -47,21 +42,19 @@ defmodule AlgoraWeb.Webhooks.StripeController do
       {:error, error}
   end
 
-  defp process_event(
-         %Stripe.Event{
-           type: type,
-           data: %{object: %Stripe.Charge{metadata: %{"version" => @metadata_version, "group_id" => group_id}}}
-         } = event
-       )
+  defp process_event(%Stripe.Event{
+         type: type,
+         data: %{object: %Stripe.Charge{metadata: %{"version" => @metadata_version, "group_id" => group_id}} = charge}
+       })
        when type in ["charge.succeeded", "charge.captured"] and is_binary(group_id) do
-    process_charge_succeeded(event, group_id)
+    Payments.process_charge(type, charge, group_id)
   end
 
-  defp process_event(%Stripe.Event{type: type, data: %{object: %Stripe.Charge{invoice: invoice_id}}} = event)
+  defp process_event(%Stripe.Event{type: type, data: %{object: %Stripe.Charge{invoice: invoice_id} = charge}})
        when type in ["charge.succeeded", "charge.captured"] do
     with {:ok, invoice} <- Algora.PSP.Invoice.retrieve(invoice_id),
          %{"version" => @metadata_version, "group_id" => group_id} <- invoice.metadata do
-      process_charge_succeeded(event, group_id)
+      Payments.process_charge(type, charge, group_id)
     end
   end
 
@@ -127,96 +120,6 @@ defmodule AlgoraWeb.Webhooks.StripeController do
     end
   end
 
-  defp process_charge_succeeded(
-         %Stripe.Event{
-           type: type,
-           data: %{object: %Stripe.Charge{id: charge_id, captured: captured, payment_intent: payment_intent_id}}
-         },
-         group_id
-       )
-       when type in ["charge.succeeded", "charge.captured"] and is_binary(group_id) do
-    Repo.transact(fn ->
-      status = if captured, do: :succeeded, else: :requires_capture
-      succeeded_at = if captured, do: DateTime.utc_now()
-
-      {_, txs} =
-        Repo.update_all(from(t in Transaction, where: t.group_id == ^group_id, select: t),
-          set: [
-            status: status,
-            succeeded_at: succeeded_at,
-            provider: "stripe",
-            provider_id: charge_id,
-            provider_charge_id: charge_id,
-            provider_payment_intent_id: payment_intent_id
-          ]
-        )
-
-      if status == :succeeded do
-        bounty_ids = txs |> Enum.map(& &1.bounty_id) |> Enum.reject(&is_nil/1) |> Enum.uniq()
-        tip_ids = txs |> Enum.map(& &1.tip_id) |> Enum.reject(&is_nil/1) |> Enum.uniq()
-        contract_ids = txs |> Enum.map(& &1.contract_id) |> Enum.reject(&is_nil/1) |> Enum.uniq()
-        claim_ids = txs |> Enum.map(& &1.claim_id) |> Enum.reject(&is_nil/1) |> Enum.uniq()
-
-        Repo.update_all(from(b in Bounty, where: b.id in ^bounty_ids), set: [status: :paid])
-        Repo.update_all(from(t in Tip, where: t.id in ^tip_ids), set: [status: :paid])
-        Repo.update_all(from(c in Contract, where: c.id in ^contract_ids), set: [status: :paid])
-        # TODO: add and use a new "paid" status for claims
-        Repo.update_all(from(c in Claim, where: c.id in ^claim_ids), set: [status: :approved])
-
-        activities_result =
-          txs
-          |> Enum.filter(&(&1.type == :credit))
-          |> Enum.reduce_while(:ok, fn tx, :ok ->
-            case Repo.insert_activity(tx, %{type: :transaction_succeeded, notify_users: [tx.user_id]}) do
-              {:ok, _} -> {:cont, :ok}
-              error -> {:halt, error}
-            end
-          end)
-
-        jobs_result =
-          txs
-          |> Enum.filter(&(&1.type == :credit))
-          |> Enum.reduce_while(:ok, fn credit, :ok ->
-            case Payments.fetch_active_account(credit.user_id) do
-              {:ok, _account} ->
-                case %{credit_id: credit.id}
-                     |> Payments.Jobs.ExecutePendingTransfer.new()
-                     |> Oban.insert() do
-                  {:ok, _job} -> {:cont, :ok}
-                  error -> {:halt, error}
-                end
-
-              {:error, :no_active_account} ->
-                case %{credit_id: credit.id}
-                     |> Bounties.Jobs.PromptPayoutConnect.new()
-                     |> Oban.insert() do
-                  {:ok, _job} -> {:cont, :ok}
-                  error -> {:halt, error}
-                end
-            end
-          end)
-
-        with txs when txs != [] <- txs,
-             :ok <- activities_result,
-             :ok <- jobs_result do
-          Payments.broadcast()
-          {:ok, nil}
-        else
-          {:error, reason} ->
-            Logger.error("Failed to update transactions: #{inspect(reason)}")
-            {:error, :failed_to_update_transactions}
-
-          _error ->
-            Logger.error("Failed to update transactions")
-            {:error, :failed_to_update_transactions}
-        end
-      else
-        Payments.broadcast()
-        {:ok, nil}
-      end
-    end)
-  end
-
   defp alert(%Stripe.Event{} = event, :ok) do
     Algora.Admin.alert("Stripe event: #{event.type} #{event.id} https://dashboard.stripe.com/logs?success=true", :info)
   end
diff --git a/lib/algora_web/live/contract_live.ex b/lib/algora_web/live/contract_live.ex
