add stripe connect flow

Author: zcesur

lib/algora/accounts/schemas/user.ex

@@ -236,6 +236,7 @@ defmodule Algora.Accounts.User do
       :need_avatar,
       :website_url,
       :bio,
+      :country,
       :location,
       :timezone
     ])

lib/algora/integrations/stripe/connect_countries.ex

@@ -125,4 +125,6 @@ defmodule Algora.Stripe.ConnectCountries do
       {"Uzbekistan", "UZ"},
       {"Vietnam", "VN"}
     ]
+
+  def list_codes, do: Enum.map(list(), &elem(&1, 1))
 end

lib/algora/payments/payments.ex

@@ -2,10 +2,14 @@ defmodule Algora.Payments do
   @moduledoc false
   import Ecto.Query
 
+  alias Algora.Accounts
+  alias Algora.Accounts.User
+  alias Algora.Payments.Account
   alias Algora.Payments.Customer
   alias Algora.Payments.PaymentMethod
   alias Algora.Payments.Transaction
   alias Algora.Repo
+  alias Algora.Util
 
   require Logger
 
@@ -128,4 +132,95 @@ defmodule Algora.Payments do
     |> order_by([t], desc: t.inserted_at)
     |> Repo.all()
   end
+
+  def get_account(user_id, region) do
+    Account
+    |> where([a], a.user_id == ^user_id and a.region == ^region)
+    |> Repo.one()
+  end
+
+  @spec create_account(user :: User.t(), attrs :: %{optional(atom()) => any()}) ::
+          {:ok, Account.t()} | {:error, any()}
+  def create_account(user, attrs) do
+    with {:ok, stripe_account} <- create_stripe_account(attrs) do
+      attrs = %{
+        provider: "stripe",
+        provider_id: stripe_account.id,
+        provider_meta: Util.normalize_struct(stripe_account),
+        type: attrs.type,
+        region: :US,
+        user_id: user.id,
+        country: attrs.country
+      }
+
+      %Account{}
+      |> Account.changeset(attrs)
+      |> Repo.insert()
+    end
+  end
+
+  @spec create_stripe_account(attrs :: %{optional(atom()) => any()}) ::
+          {:ok, Stripe.Account.t()} | {:error, Stripe.Error.t()}
+  defp create_stripe_account(%{country: country, type: type}) do
+    case Stripe.Account.create(%{country: country, type: type}) do
+      {:ok, account} -> {:ok, account}
+      {:error, _reason} -> Stripe.Account.create(%{type: type})
+    end
+  end
+
+  @spec create_account_link(account :: Account.t(), base_url :: String.t()) ::
+          {:ok, Stripe.AccountLink.t()} | {:error, Stripe.Error.t()}
+  def create_account_link(account, base_url) do
+    Stripe.AccountLink.create(%{
+      account: account.provider_id,
+      refresh_url: "#{base_url}/callbacks/stripe/refresh",
+      return_url: "#{base_url}/callbacks/stripe/return",
+      type: "account_onboarding"
+    })
+  end
+
+  @spec create_login_link(account :: Account.t()) ::
+          {:ok, Stripe.Account.t()} | {:error, Stripe.Error.t()}
+  def create_login_link(account) do
+    Stripe.Account.create_login_link(account.provider_id, %{})
+  end
+
+  @spec refresh_stripe_account(user_id :: binary()) ::
+          {:ok, Account.t()} | {:error, :account_not_found} | {:error, any()}
+  def refresh_stripe_account(user_id) do
+    case get_account(user_id, :US) do
+      nil ->
+        {:error, :account_not_found}
+
+      account ->
+        with {:ok, stripe_account} <- Stripe.Account.retrieve(account.provider_id) do
+          attrs = %{
+            charges_enabled: stripe_account.charges_enabled,
+            details_submitted: stripe_account.details_submitted,
+            country: stripe_account.country,
+            service_agreement: stripe_account.tos_acceptance.service_agreement,
+            provider_meta: Util.normalize_struct(stripe_account)
+          }
+
+          account
+          |> Account.changeset(attrs)
+          |> Repo.update()
+          |> case do
+            {:ok, updated_account} ->
+              if stripe_account.charges_enabled do
+                account.user_id
+                |> Accounts.get_user!()
+                |> Accounts.update_settings(%{country: stripe_account.country})
+              end
+
+              # TODO: enqueue pending transfers
+
+              {:ok, updated_account}
+
+            error ->
+              error
+          end
+        end
+    end
+  end
 end

lib/algora/payments/schemas/account.ex

@@ -2,22 +2,24 @@ defmodule Algora.Payments.Account do
   @moduledoc false
   use Algora.Schema
 
+  alias Algora.Stripe
+
   @derive {Inspect, except: [:provider_meta]}
   typed_schema "accounts" do
-    field :provider, :string
-    field :provider_id, :string
-    field :provider_meta, :map
+    field :provider, :string, null: false
+    field :provider_id, :string, null: false
+    field :provider_meta, :map, null: false
 
     field :name, :string
-    field :details_submitted, :boolean, default: false
-    field :charges_enabled, :boolean, default: false
+    field :details_submitted, :boolean, default: false, null: false
+    field :charges_enabled, :boolean, default: false, null: false
     field :service_agreement, :string
-    field :country, :string
-    field :type, Ecto.Enum, values: [:standard, :express]
-    field :region, Ecto.Enum, values: [:US, :EU]
-    field :stale, :boolean, default: false
+    field :country, :string, null: false
+    field :type, Ecto.Enum, values: [:standard, :express], null: false
+    field :region, Ecto.Enum, values: [:US, :EU], null: false
+    field :stale, :boolean, default: false, null: false
 
-    belongs_to :user, Algora.Accounts.User
+    belongs_to :user, Algora.Accounts.User, null: false
 
     timestamps()
   end
@@ -34,8 +36,25 @@ defmodule Algora.Payments.Account do
       :country,
       :type,
       :region,
-      :stale
+      :stale,
+      :user_id
+    ])
+    |> validate_required([
+      :provider,
+      :provider_id,
+      :provider_meta,
+      :details_submitted,
+      :charges_enabled,
+      :country,
+      :type,
+      :region,
+      :stale,
+      :user_id
     ])
-    |> validate_required([:provider, :provider_id, :provider_meta])
+    |> validate_inclusion(:type, [:standard, :express])
+    |> validate_inclusion(:region, [:US, :EU])
+    |> validate_inclusion(:country, Stripe.ConnectCountries.list_codes())
+    |> foreign_key_constraint(:user_id)
+    |> generate_id()
   end
 end

lib/algora_web/controllers/stripe_callback_controller.ex

@@ -0,0 +1,28 @@
+defmodule AlgoraWeb.StripeCallbackController do
+  use AlgoraWeb, :controller
+
+  alias Algora.Payments
+
+  def refresh(conn, params), do: refresh_stripe_account(conn, params)
+  def return(conn, params), do: refresh_stripe_account(conn, params)
+
+  defp refresh_stripe_account(conn, _params) do
+    case conn.assigns[:current_user] do
+      nil ->
+        conn
+        |> redirect(to: ~p"/auth/login")
+        |> halt()
+
+      current_user ->
+        case Payments.refresh_stripe_account(current_user.id) do
+          {:ok, _account} ->
+            redirect(conn, to: ~p"/user/transactions")
+
+          {:error, _reason} ->
+            conn
+            |> put_flash(:error, "Failed to refresh Stripe account")
+            |> redirect(to: ~p"/user/transactions")
+        end
+    end
+  end
+end

lib/algora_web/live/user/transactions_live.ex

@@ -63,13 +63,44 @@ defmodule AlgoraWeb.User.TransactionsLive do
 
     case changeset do
       %{valid?: true} = changeset ->
-        # TODO: Actually create the payout account
-        IO.inspect(changeset.changes, label: "Would create payout account with")
-
-        {:noreply,
-         socket
-         |> put_flash(:info, "Payout account created!")
-         |> assign(:show_payout_drawer, false)}
+        # Get or create Stripe account
+        account = Payments.get_account(socket.assigns.current_user.id, :US)
+
+        result =
+          if is_nil(account) do
+            Payments.create_account(socket.assigns.current_user, %{
+              country: changeset.changes.country,
+              type: "express"
+            })
+          else
+            {:ok, account}
+          end
+
+        case result do
+          {:ok, account} ->
+            if account.charges_enabled do
+              if account.type == :express do
+                {:ok, %{url: url}} = Payments.create_login_link(account)
+
+                {:noreply, redirect(socket, external: url)}
+              else
+                {:noreply,
+                 socket
+                 |> put_flash(:info, "Account already set up!")
+                 |> assign(:show_payout_drawer, false)}
+              end
+            else
+              {:ok, %{url: url}} = Payments.create_account_link(account, AlgoraWeb.Endpoint.url())
+
+              {:noreply, redirect(socket, external: url)}
+            end
+
+          {:error, _reason} ->
+            {:noreply,
+             socket
+             |> put_flash(:error, "Failed to create payout account")
+             |> assign(:show_payout_drawer, false)}
+        end
 
       %{valid?: false} = changeset ->
         {:noreply, assign(socket, :payout_account_form, to_form(changeset))}
@@ -224,7 +255,7 @@ defmodule AlgoraWeb.User.TransactionsLive do
     </div>
     <.drawer show={@show_payout_drawer} on_cancel="close_drawer" direction="right">
       <.drawer_header>
-        <.drawer_title>Create Payout Account</.drawer_title>
+        <.drawer_title>Payout Account</.drawer_title>
         <.drawer_description>Create a payout account to receive your earnings</.drawer_description>
       </.drawer_header>
       <.drawer_content class="mt-4">

lib/algora_web/router.ex

@@ -44,6 +44,8 @@ defmodule AlgoraWeb.Router do
 
     get "/set_context/:context", ContextController, :set
 
+    get "/callbacks/stripe/refresh", StripeCallbackController, :refresh
+    get "/callbacks/stripe/return", StripeCallbackController, :return
     get "/callbacks/:provider/oauth", OAuthCallbackController, :new
     get "/callbacks/:provider/installation", InstallationCallbackController, :new
     get "/auth/logout", OAuthCallbackController, :sign_out

priv/repo/migrations/20250104150728_update_accounts.exs

@@ -0,0 +1,21 @@
+defmodule Algora.Repo.Migrations.UpdateAccounts do
+  use Ecto.Migration
+
+  def up do
+    alter table(:accounts) do
+      modify :service_agreement, :string, null: true
+    end
+
+    drop index(:accounts, [:user_id])
+    create unique_index(:accounts, [:user_id, :region])
+  end
+
+  def down do
+    alter table(:accounts) do
+      modify :service_agreement, :string, null: false
+    end
+
+    create index(:accounts, [:user_id])
+    drop unique_index(:accounts, [:user_id, :region])
+  end
+end