{render_slot(@inner_block)}
"""
diff --git a/lib/algora_web/components/ui/radio_group.ex b/lib/algora_web/components/ui/radio_group.ex
index 1d4b681ff..16fd33892 100644
--- a/lib/algora_web/components/ui/radio_group.ex
+++ b/lib/algora_web/components/ui/radio_group.ex
@@ -2,93 +2,53 @@ defmodule AlgoraWeb.Components.UI.RadioGroup do
@moduledoc false
use AlgoraWeb.Component
+ import AlgoraWeb.CoreComponents
+
@doc """
- Radio input group component
+ Radio input group component styled with a modern card-like appearance.
## Examples:
- <.radio_group name="question-1" value="option-2">
-
- <.radio_group_item builder={builder} value="option-one" id="option-one">
- <.label for="option-one">
- Option One
-
-
-
- <.radio_group_item builder={builder} value="option-two" id="option-two">
- <.label for="option-two">
- Option Two
-
-
-
+ <.radio_group
+ name="hiring"
+ options={[{"Yes", "true"}, {"No", "false"}]}
+ field={@form[:hiring]}
+ />
"""
attr :name, :string, default: nil
- attr :value, :any, default: nil
- attr :"default-value", :any
-
- attr :field, Phoenix.HTML.FormField, doc: "a form field struct retrieved from the form, for example: @form[:email]"
-
+ attr :options, :list, default: [], doc: "List of {label, value} tuples"
+ attr :field, Phoenix.HTML.FormField, doc: "a form field struct retrieved from the form"
attr :class, :string, default: nil
- slot :inner_block, required: true
def radio_group(assigns) do
- assigns = prepare_assign(assigns)
- assigns = assign(assigns, :builder, %{name: assigns.name, value: assigns.value})
-
~H"""
-
- {render_slot(@inner_block, @builder)}
+
+ <%= for {label, value} <- @options do %>
+
+ <% end %>
- """
- end
-
- attr :builder, :map, required: true
- attr :class, :string, default: nil
- attr :checked, :any, default: false
- attr :value, :string, default: nil
- attr :rest, :global
-
- def radio_group_item(assigns) do
- ~H"""
-
+ <.error :for={msg <- @field.errors}>{translate_error(msg)}
"""
end
end
diff --git a/lib/algora_web/components/ui/stat_card.ex b/lib/algora_web/components/ui/stat_card.ex
index 174c209ac..e071730cc 100644
--- a/lib/algora_web/components/ui/stat_card.ex
+++ b/lib/algora_web/components/ui/stat_card.ex
@@ -6,10 +6,12 @@ defmodule AlgoraWeb.Components.UI.StatCard do
attr :href, :string, default: nil
attr :title, :string
- attr :value, :string
+ attr :value, :string, default: nil
attr :subtext, :string, default: nil
attr :icon, :string, default: nil
+ slot :inner_block
+
def stat_card(assigns) do
~H"""
<%= if @href do %>
@@ -24,13 +26,24 @@ defmodule AlgoraWeb.Components.UI.StatCard do
defp stat_card_content(assigns) do
~H"""
-
+
diff --git a/lib/algora_web/controllers/webhooks/github_controller.ex b/lib/algora_web/controllers/webhooks/github_controller.ex
index 1963c7709..c58a63d82 100644
--- a/lib/algora_web/controllers/webhooks/github_controller.ex
+++ b/lib/algora_web/controllers/webhooks/github_controller.ex
@@ -13,24 +13,23 @@ defmodule AlgoraWeb.Webhooks.GithubController do
# TODO: auto-retry failed deliveries with exponential backoff
def new(conn, params) do
- case Webhook.new(conn) do
- {:ok, %Webhook{delivery: _delivery, event: event, installation_id: _installation_id}} ->
- author = get_author(event, params)
- body = get_body(event, params)
- process_commands(body, author, params)
-
- conn |> put_status(:accepted) |> json(%{status: "ok"})
-
+ with {:ok, webhook} <- Webhook.new(conn),
+ {:ok, _} <- process_commands(webhook, params) do
+ conn |> put_status(:accepted) |> json(%{status: "ok"})
+ else
{:error, :missing_header} ->
conn |> put_status(:bad_request) |> json(%{error: "Missing header"})
{:error, :signature_mismatch} ->
conn |> put_status(:unauthorized) |> json(%{error: "Signature mismatch"})
+
+ {:error, reason} ->
+ Logger.error("Error processing webhook: #{inspect(reason)}")
+ conn |> put_status(:internal_server_error) |> json(%{error: "Internal server error"})
end
rescue
e ->
Logger.error("Unexpected error: #{inspect(e)}")
-
conn |> put_status(:internal_server_error) |> json(%{error: "Internal server error"})
end
@@ -51,7 +50,8 @@ defmodule AlgoraWeb.Webhooks.GithubController do
defp get_permissions(_author, _params), do: {:error, :invalid_params}
- defp execute_command({:bounty, args}, author, params) do
+ defp execute_command(event_action, {:bounty, args}, author, params)
+ when event_action in ["issues.opened", "issues.edited", "issue_comment.created", "issue_comment.edited"] do
amount = args[:amount]
repo = params["repository"]
issue = params["issue"]
@@ -82,7 +82,8 @@ defmodule AlgoraWeb.Webhooks.GithubController do
end
end
- defp execute_command({:tip, args}, author, params) when not is_nil(args) do
+ defp execute_command(event_action, {:tip, args}, author, params)
+ when event_action in ["issue_comment.created", "issue_comment.edited"] do
amount = args[:amount]
recipient = args[:recipient]
repo = params["repository"]
@@ -113,27 +114,72 @@ 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(event_action, {:claim, args}, author, params)
+ when event_action in ["pull_request.opened", "pull_request.reopened", "pull_request.edited"] do
+ installation_id = params["installation"]["id"]
+ pull_request = params["pull_request"]
+ repo = params["repository"]
- Logger.info("Claim #{owner}/#{repo}##{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,
+ 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
+ )
+ end
+ end
+
+ defp execute_command(_event_action, _command, _author, _params) do
+ {:ok, nil}
end
- defp execute_command({command, _} = args, _author, _params),
- do: Logger.info("Unhandled command: #{command} #{inspect(args)}")
+ def process_commands(%Webhook{event: event, hook_id: hook_id}, params) do
+ author = get_author(event, params)
+ body = get_body(event, params)
+
+ event_action = event <> "." <> params["action"]
- def process_commands(body, author, params) when is_binary(body) do
case Github.Command.parse(body) do
- {:ok, commands} -> Enum.map(commands, &execute_command(&1, author, params))
- # TODO: handle errors
- {:error, error} -> Logger.error("Error parsing commands: #{inspect(error)}")
+ {:ok, commands} ->
+ Enum.reduce_while(commands, {:ok, []}, fn command, {:ok, results} ->
+ case execute_command(event_action, command, author, params) do
+ {:ok, result} ->
+ {:cont, {:ok, [result | results]}}
+
+ error ->
+ Logger.error(
+ "Command execution failed for #{event_action}(#{hook_id}): #{inspect(command)}: #{inspect(error)}"
+ )
+
+ {:halt, error}
+ end
+ end)
+
+ {:error, reason} = error ->
+ Logger.error("Error parsing commands: #{inspect(reason)}")
+ error
end
end
- def process_commands(_body, _author, _params), do: nil
-
defp get_author("issues", params), do: params["issue"]["user"]
defp get_author("issue_comment", params), do: params["comment"]["user"]
defp get_author("pull_request", params), do: params["pull_request"]["user"]
diff --git a/lib/algora_web/live/claim_live.ex b/lib/algora_web/live/claim_live.ex
new file mode 100644
index 000000000..77171a9e4
--- /dev/null
+++ b/lib/algora_web/live/claim_live.ex
@@ -0,0 +1,642 @@
+defmodule AlgoraWeb.ClaimLive do
+ @moduledoc false
+ use AlgoraWeb, :live_view
+
+ import Ecto.Changeset
+ import Ecto.Query
+
+ alias Algora.Bounties
+ alias Algora.Bounties.Claim
+ alias Algora.Bounties.LineItem
+ alias Algora.Github
+ alias Algora.Organizations
+ alias Algora.Repo
+ alias Algora.Util
+
+ require Logger
+
+ defp tip_options do
+ [
+ {"None", 0},
+ {"10%", 10},
+ {"20%", 20},
+ {"50%", 50}
+ ]
+ end
+
+ defmodule RewardBountyForm do
+ @moduledoc false
+ use Ecto.Schema
+
+ import Ecto.Changeset
+
+ @primary_key false
+ embedded_schema do
+ field :amount, :decimal
+ field :tip_percentage, :decimal
+ end
+
+ def changeset(form, attrs) do
+ form
+ |> cast(attrs, [:amount, :tip_percentage])
+ |> validate_required([:amount, :tip_percentage])
+ |> validate_number(:tip_percentage, greater_than_or_equal_to: 0)
+ |> validate_number(:amount, greater_than: 0)
+ end
+ end
+
+ @impl true
+ def mount(%{"group_id" => group_id}, _session, socket) do
+ claims =
+ from(c in Claim, where: c.group_id == ^group_id)
+ |> order_by(desc: :group_share)
+ |> Repo.all()
+ |> Repo.preload([
+ :user,
+ :transactions,
+ source: [repository: [:user]],
+ target: [repository: [:user], bounties: [:owner]]
+ ])
+
+ case claims do
+ [] ->
+ raise(AlgoraWeb.NotFoundError)
+
+ [primary_claim | _] ->
+ prize_pool =
+ primary_claim.target.bounties
+ |> Enum.map(& &1.amount)
+ |> Enum.reduce(Money.zero(:USD, no_fraction_if_integer: true), &Money.add!(&1, &2))
+
+ debits =
+ claims
+ |> Enum.flat_map(& &1.transactions)
+ |> Enum.filter(&(&1.type == :debit and &1.status == :succeeded))
+
+ total_paid =
+ debits
+ |> Enum.map(& &1.net_amount)
+ |> Enum.reduce(Money.zero(:USD, no_fraction_if_integer: true), &Money.add!(&1, &2))
+
+ context =
+ if repo = primary_claim.source.repository do
+ "#{repo.user.provider_login}/#{repo.name}"
+ end
+
+ source_body_html =
+ with token when is_binary(token) <- Github.TokenPool.get_token(),
+ {:ok, source_body_html} <-
+ Github.render_markdown(token, primary_claim.source.description, context: context) do
+ source_body_html
+ else
+ _ -> primary_claim.source.description
+ end
+
+ pledges =
+ primary_claim.target.bounties
+ |> Enum.group_by(& &1.owner.id)
+ |> Map.new(fn {owner_id, bounties} ->
+ {owner_id,
+ {hd(bounties).owner,
+ Enum.reduce(bounties, Money.zero(:USD, no_fraction_if_integer: true), &Money.add!(&1.amount, &2))}}
+ end)
+
+ payments =
+ debits
+ |> Enum.group_by(& &1.user_id)
+ |> Map.new(fn {user_id, debits} ->
+ {user_id, Enum.reduce(debits, Money.zero(:USD, no_fraction_if_integer: true), &Money.add!(&1.net_amount, &2))}
+ end)
+
+ sponsors =
+ pledges
+ |> Enum.map(fn {sponsor_id, {sponsor, pledged}} ->
+ paid = Map.get(payments, sponsor_id, Money.zero(:USD, no_fraction_if_integer: true))
+ tipped = Money.sub!(paid, pledged)
+
+ status =
+ cond do
+ Money.equal?(paid, pledged) -> :paid
+ Money.positive?(tipped) -> :overpaid
+ Money.positive?(paid) -> :partial
+ primary_claim.status == :approved -> :pending
+ true -> :none
+ end
+
+ %{
+ sponsor: sponsor,
+ status: status,
+ pledged: pledged,
+ paid: paid,
+ tipped: tipped
+ }
+ end)
+ |> Enum.sort_by(&{&1.pledged, &1.paid, &1.sponsor.name}, :desc)
+
+ source_or_target = primary_claim.source || primary_claim.target
+
+ contexts =
+ if socket.assigns.current_user do
+ Organizations.get_user_orgs(socket.assigns.current_user) ++ [socket.assigns.current_user]
+ else
+ []
+ end
+
+ context_ids = MapSet.new(contexts, & &1.id)
+ available_bounties = Enum.filter(primary_claim.target.bounties, &MapSet.member?(context_ids, &1.owner_id))
+
+ amount =
+ case available_bounties do
+ [] -> nil
+ [bounty | _] -> Money.to_decimal(bounty.amount)
+ end
+
+ changeset = RewardBountyForm.changeset(%RewardBountyForm{}, %{tip_percentage: 0, amount: amount})
+
+ {:ok,
+ socket
+ |> assign(:page_title, source_or_target.title)
+ |> assign(:claims, claims)
+ |> assign(:primary_claim, primary_claim)
+ |> assign(:target, primary_claim.target)
+ |> assign(:source, primary_claim.source)
+ |> assign(:source_or_target, source_or_target)
+ |> assign(:bounties, primary_claim.target.bounties)
+ |> assign(:prize_pool, prize_pool)
+ |> assign(:total_paid, total_paid)
+ |> assign(:source_body_html, source_body_html)
+ |> assign(:sponsors, sponsors)
+ |> assign(:contexts, contexts)
+ |> assign(:show_reward_bounty_modal, false)
+ |> assign(:available_bounties, available_bounties)
+ |> assign(:reward_bounty_form, to_form(changeset))}
+ end
+ end
+
+ @impl true
+ def handle_params(_params, _url, %{assigns: %{current_user: nil}} = socket) do
+ {:noreply, socket}
+ end
+
+ def handle_params(%{"context" => context_id}, _url, socket) do
+ {:noreply, socket |> assign_selected_context(context_id) |> assign_line_items()}
+ end
+
+ def handle_params(_params, _url, socket) do
+ {:noreply, socket |> assign_selected_context(default_context_id(socket)) |> assign_line_items()}
+ end
+
+ @impl true
+ def handle_event("reward_bounty", _params, %{assigns: %{current_user: nil}} = socket) do
+ {:noreply,
+ redirect(socket, to: ~p"/auth/login?#{%{return_to: ~p"/claims/#{socket.assigns.primary_claim.group_id}"}}")}
+ end
+
+ def handle_event("reward_bounty", _params, socket) do
+ {:noreply, assign(socket, :show_reward_bounty_modal, true)}
+ end
+
+ def handle_event("close_drawer", _params, socket) do
+ {:noreply, assign(socket, :show_reward_bounty_modal, false)}
+ end
+
+ def handle_event("validate_reward_bounty", %{"reward_bounty_form" => params}, socket) do
+ {:noreply,
+ socket
+ |> assign(:reward_bounty_form, to_form(RewardBountyForm.changeset(%RewardBountyForm{}, params)))
+ |> assign_line_items()}
+ end
+
+ def handle_event("split_bounty", _params, socket) do
+ # TODO: Implement split bounty
+ Logger.error(
+ "Attempt to split bounty #{socket.assigns.target.repository.user.provider_login}/#{socket.assigns.target.repository.name}#{socket.assigns.target.number}"
+ )
+
+ {:noreply, socket}
+ end
+
+ def handle_event("pay_with_stripe", %{"reward_bounty_form" => params}, socket) do
+ changeset = RewardBountyForm.changeset(%RewardBountyForm{}, params)
+
+ case apply_action(changeset, :save) do
+ {:ok, data} ->
+ with {:ok, bounty} <- get_or_create_bounty(socket, data),
+ {:ok, session_url} <- reward_bounty(socket, bounty, changeset) do
+ {:noreply, redirect(socket, external: session_url)}
+ else
+ {:error, reason} ->
+ Logger.error("Failed to create payment session: #{inspect(reason)}")
+ {:noreply, put_flash(socket, :error, "Something went wrong")}
+ end
+
+ {:error, changeset} ->
+ {:noreply, assign(socket, :reward_bounty_form, to_form(changeset))}
+ end
+ end
+
+ defp default_context_id(socket) do
+ case socket.assigns.available_bounties do
+ [] -> socket.assigns.current_user.id
+ [bounty | _] -> bounty.owner_id
+ end
+ end
+
+ defp assign_selected_context(socket, context_id) do
+ case Enum.find(socket.assigns.contexts, &(&1.id == context_id)) do
+ nil ->
+ push_patch(socket, to: "/claims/#{socket.assigns.primary_claim.group_id}?context=#{default_context_id(socket)}")
+
+ context ->
+ assign(socket, :selected_context, context)
+ end
+ end
+
+ defp assign_line_items(socket) do
+ line_items =
+ Bounties.generate_line_items(%{amount: calculate_final_amount(socket.assigns.reward_bounty_form.source)},
+ ticket_ref: %{
+ owner: socket.assigns.target.repository.user.provider_login,
+ repo: socket.assigns.target.repository.name,
+ number: socket.assigns.target.number
+ },
+ claims: socket.assigns.claims
+ )
+
+ assign(socket, :line_items, line_items)
+ end
+
+ defp ticket_ref(socket) do
+ %{
+ owner: socket.assigns.target.repository.user.provider_login,
+ repo: socket.assigns.target.repository.name,
+ number: socket.assigns.target.number
+ }
+ end
+
+ defp get_or_create_bounty(socket, data) do
+ case Enum.find(socket.assigns.available_bounties, &(&1.owner_id == socket.assigns.selected_context.id)) do
+ nil ->
+ Bounties.create_bounty(%{
+ creator: socket.assigns.current_user,
+ owner: socket.assigns.selected_context,
+ amount: Money.new!(:USD, data.amount),
+ ticket_ref: ticket_ref(socket)
+ })
+
+ bounty ->
+ {:ok, bounty}
+ end
+ end
+
+ defp reward_bounty(socket, bounty, changeset) do
+ final_amount = calculate_final_amount(changeset)
+
+ Bounties.reward_bounty(
+ %{
+ owner: socket.assigns.selected_context,
+ amount: final_amount,
+ bounty_id: bounty.id,
+ claims: socket.assigns.claims
+ },
+ ticket_ref: ticket_ref(socket)
+ )
+ end
+
+ defp calculate_final_amount(changeset) do
+ tip_percentage = get_field(changeset, :tip_percentage) || Decimal.new(0)
+ amount = get_field(changeset, :amount) || Decimal.new(0)
+
+ multiplier = tip_percentage |> Decimal.div(100) |> Decimal.add(1)
+ amount |> Money.new!(:USD) |> Money.mult!(multiplier)
+ end
+
+ @impl true
+ def render(assigns) do
+ ~H"""
+
{@title}
<.icon :if={@icon} name={@icon} class="h-6 w-6 text-muted-foreground" />
-
{@value}
+
+ <%= if @value do %>
+ {@value}
+ <% else %>
+ {render_slot(@inner_block)}
+ <% end %>
+
{@subtext}
+
+ <.drawer :if={@current_user} show={@show_reward_bounty_modal} on_cancel="close_drawer">
+ <.drawer_header>
+ <.drawer_title>Reward Bounty
+ <.drawer_description>
+ You can pay the full bounty now or start with a partial amount - it's up to you!
+
+
+ <.drawer_content class="mt-4">
+ <.form
+ for={@reward_bounty_form}
+ phx-change="validate_reward_bounty"
+ phx-submit="pay_with_stripe"
+ >
+
+
+
+ <.card>
+ <.card_header>
+
+
+
+ <.avatar class="h-12 w-12 rounded-full">
+ <.avatar_image src={@source_or_target.repository.user.avatar_url} />
+ <.avatar_fallback>
+ {String.first(@source_or_target.repository.user.provider_login)}
+
+
+
+
+ <.card_content>
+
+ <.link
+ href={@source_or_target.url}
+ class="text-xl font-semibold hover:underline"
+ target="_blank"
+ >
+ {@source_or_target.title}
+
+
+
+ {@source_or_target.repository.user.provider_login}/{@source_or_target.repository.name}#{@source_or_target.number}
+
+
+ {Phoenix.HTML.raw(@source_body_html)}
+
+
+
+
+ <.card>
+ <.card_header>
+
+
+ <.card_title>
+ Claim
+
+ <.button phx-click="reward_bounty">
+ Reward bounty
+
+
+
+ <.card_content>
+
+
+
+
+
+ <.card>
+ <.card_header>
+
+ Total prize pool
+
+ {Money.to_string!(@prize_pool)}
+
+
+
+ Total paid
+
+ {Money.to_string!(@total_paid)}
+
+
+
+ Status
+ {@primary_claim.status |> to_string() |> String.capitalize()}
+
+
+ Submitted
+ {Calendar.strftime(@primary_claim.inserted_at, "%B %d, %Y")}
+
+
+ Last updated
+ {Calendar.strftime(@primary_claim.updated_at, "%B %d, %Y")}
+
+
+ <.card_title>
+ Authors
+
+
+ <.button variant="secondary" phx-click="split_bounty">
+ Split bounty
+
+
+
+ <.card_content>
+
+ <%= for claim <- @claims do %>
+
+
+
+
+ <.card>
+ <.card_header>
+ <.card_title>
+ Sponsors
+
+
+ <.card_content>
+
+
+
+ <% end %>
+
+ <.avatar>
+ <.avatar_image src={claim.user.avatar_url} />
+ <.avatar_fallback>{String.first(claim.user.name)}
+
+
+
+
+
+ {Util.format_pct(claim.group_share)}
+
+
+
+
+ {claim.user.name}
+@{claim.user.handle}
+
+ <%= for sponsor <- @sponsors do %>
+
+
+
+
+
+ <% end %>
+
+ <.avatar>
+ <.avatar_image src={sponsor.sponsor.avatar_url} />
+ <.avatar_fallback>
+ {String.first(sponsor.sponsor.name)}
+
+
+
+
+
+ {sponsor.sponsor.name}
+@{sponsor.sponsor.handle}
+
+
+
+ <%= case sponsor.status do %>
+ <% :overpaid -> %>
+
+
+
+ {Money.to_string!(Money.sub!(sponsor.paid, sponsor.tipped))}
+
+ paid
+
+
+
+ +{Money.to_string!(sponsor.tipped)}
+
+ tip!
+
+ <% :paid -> %>
+
+
+ {Money.to_string!(sponsor.paid)}
+
+ paid
+
+ <% :partial -> %>
+
+
+ {Money.to_string!(sponsor.paid)}
+
+ paid
+
+
+
+ {Money.to_string!(Money.sub!(sponsor.pledged, sponsor.paid))}
+
+ pending
+
+ <% :pending -> %>
+
+
+ {Money.to_string!(sponsor.pledged)}
+
+ pending
+
+ <% :none -> %>
+
+
+ {Money.to_string!(sponsor.pledged)}
+
+
+ <% end %>
+
+
+
+
+
+ """
+ end
+end
diff --git a/lib/algora_web/live/org/bounty_hook.ex b/lib/algora_web/live/org/bounty_hook.ex
index 179db5d05..a9a9cedeb 100644
--- a/lib/algora_web/live/org/bounty_hook.ex
+++ b/lib/algora_web/live/org/bounty_hook.ex
@@ -27,9 +27,6 @@ defmodule AlgoraWeb.Org.BountyHook do
{:error, :already_exists} ->
{:halt, put_flash(socket, :warning, "You have already created a bounty for this ticket")}
- {:error, :internal_server_error} ->
- {:halt, put_flash(socket, :error, "Something went wrong")}
-
{:error, _reason} ->
changeset = add_error(socket.assigns.new_bounty_form.changeset, :github_issue_url, "Invalid URL")
{:halt, assign(socket, :new_bounty_form, to_form(changeset))}
diff --git a/lib/algora_web/live/org/create_bounty_live.ex b/lib/algora_web/live/org/create_bounty_live.ex
index 466d780f4..6a744503c 100644
--- a/lib/algora_web/live/org/create_bounty_live.ex
+++ b/lib/algora_web/live/org/create_bounty_live.ex
@@ -468,9 +468,6 @@ defmodule AlgoraWeb.Org.CreateBountyLive do
{:error, :already_exists} ->
{:noreply, put_flash(socket, :warning, "You have already created a bounty for this ticket")}
- {:error, :internal_server_error} ->
- {:noreply, put_flash(socket, :error, "Something went wrong")}
-
{:error, _reason} ->
changeset = add_error(socket.assigns.new_bounty_form.changeset, :github_issue_url, "Invalid URL")
{:noreply, assign(socket, :new_bounty_form, to_form(changeset))}
diff --git a/lib/algora_web/router.ex b/lib/algora_web/router.ex
index 7d7589567..81819494b 100644
--- a/lib/algora_web/router.ex
+++ b/lib/algora_web/router.ex
@@ -114,6 +114,7 @@ defmodule AlgoraWeb.Router do
live "/payment/success", Payment.SuccessLive, :index
live "/payment/canceled", Payment.CanceledLive, :index
live "/@/:handle", User.ProfileLive, :index
+ live "/claims/:group_id", ClaimLive
end
live "/orgs/new", Org.CreateLive
diff --git a/priv/repo/migrations/20250112164132_recreate_claims.exs b/priv/repo/migrations/20250112164132_recreate_claims.exs
new file mode 100644
index 000000000..acf28265e
--- /dev/null
+++ b/priv/repo/migrations/20250112164132_recreate_claims.exs
@@ -0,0 +1,73 @@
+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 :status, :string, null: false
+ add :type, :string, null: false
+ add :url, :string, null: false
+ add :group_id, :string, null: false
+ add :group_share, :decimal, null: false, default: 1.0
+
+ 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
+
+ alter table(:transactions) do
+ add :claim_id, references(:claims, on_delete: :nothing)
+ end
+
+ create unique_index(:claims, [:group_id, :user_id])
+ create index(:claims, [:source_id])
+ create index(:claims, [:target_id])
+ create index(:claims, [:user_id])
+ end
+
+ def down do
+ drop index(:claims, [:group_id, :user_id])
+ drop index(:claims, [:source_id])
+ drop index(:claims, [:target_id])
+ drop index(:claims, [:user_id])
+ drop table(:claims)
+
+ alter table(:transactions) do
+ remove :claim_id
+ end
+
+ 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
diff --git a/priv/repo/seeds.exs b/priv/repo/seeds.exs
index ff4c9a103..f3eb2d30a 100644
--- a/priv/repo/seeds.exs
+++ b/priv/repo/seeds.exs
@@ -77,6 +77,7 @@ richard =
email: "richard@example.com",
display_name: "Richard Hendricks",
handle: "richard",
+ provider_login: "richard",
bio: "CEO of Pied Piper. Creator of the middle-out compression algorithm.",
avatar_url: "https://algora.io/asset/storage/v1/object/public/mock/richard.jpg",
tech_stack: ["Python", "C++"],
@@ -94,6 +95,7 @@ dinesh =
email: "dinesh@example.com",
display_name: "Dinesh Chugtai",
handle: "dinesh",
+ provider_login: "dinesh",
bio: "Lead Frontend Engineer at Pied Piper. Java bad, Python good.",
avatar_url: "https://algora.io/asset/storage/v1/object/public/mock/dinesh.png",
tech_stack: ["Python", "JavaScript"],
@@ -111,6 +113,7 @@ gilfoyle =
email: "gilfoyle@example.com",
display_name: "Bertram Gilfoyle",
handle: "gilfoyle",
+ provider_login: "gilfoyle",
bio: "Systems Architect. Security. DevOps. Satanist.",
avatar_url: "https://algora.io/asset/storage/v1/object/public/mock/gilfoyle.jpg",
tech_stack: ["Python", "Rust", "Go", "Terraform"],
@@ -128,6 +131,7 @@ jared =
email: "jared@example.com",
display_name: "Jared Dunn",
handle: "jared",
+ provider_login: "jared",
bio: "COO of Pied Piper. Former Hooli executive. Excel wizard.",
avatar_url: "https://algora.io/asset/storage/v1/object/public/mock/jared.png",
tech_stack: ["Python", "SQL"],
@@ -145,6 +149,7 @@ carver =
email: "carver@example.com",
display_name: "Kevin 'The Carver'",
handle: "carver",
+ provider_login: "carver",
bio:
"Cloud architecture specialist. If your infrastructure needs a teardown, I'm your guy. Known for my 'insane' cloud architectures and occasional server incidents.",
avatar_url: "https://algora.io/asset/storage/v1/object/public/mock/carver.jpg",
@@ -313,133 +318,6 @@ end
Logger.info("Contract: #{AlgoraWeb.Endpoint.url()}/org/#{pied_piper.handle}/contracts/#{initial_contract.id}")
-repos = [
- {
- "middle-out",
- [
- "Optimize algorithm performance",
- "Add support for new file types",
- "Improve error handling",
- "Implement streaming compression",
- "Add compression statistics API"
- ]
- },
- {
- "pied-piper-web",
- [
- "Fix memory leak in upload handler",
- "Implement new dashboard UI",
- "Add real-time compression stats",
- "Integrate SSO authentication",
- "Build file comparison view"
- ]
- },
- {
- "infra",
- [
- "Scale kubernetes cluster",
- "Implement auto-scaling",
- "Optimize cloud costs",
- "Set up monitoring and alerts",
- "Configure disaster recovery"
- ]
- }
-]
-
-for {repo_name, issues} <- repos do
- repo =
- insert!(:repository, %{
- name: repo_name,
- url: "https://github.com/piedpiper/#{repo_name}",
- user_id: pied_piper.id
- })
-
- for {issue_title, index} <- Enum.with_index(issues, 1) do
- ticket =
- insert!(:ticket, %{
- repository_id: repo.id,
- title: issue_title,
- description: "We need help implementing this feature to improve our platform.",
- number: index,
- url: "https://github.com/piedpiper/#{repo_name}/issues/#{index}"
- })
-
- amount = Money.new!(Enum.random([500, 1000, 1500, 2000]), :USD)
-
- claimed = rem(index, 2) > 0
- paid = claimed and rem(index, 3) > 0
-
- bounty =
- insert!(:bounty, %{
- ticket_id: ticket.id,
- owner_id: pied_piper.id,
- creator_id: richard.id,
- amount: amount,
- status: if(paid, do: :paid, else: :open)
- })
-
- if not claimed do
- pied_piper_members
- |> Enum.take_random(Enum.random(0..(length(pied_piper_members) - 1)))
- |> Enum.each(fn member ->
- amount = Money.new!(Enum.random([500, 1000, 1500, 2000]), :USD)
-
- insert!(:bounty, %{
- ticket_id: ticket.id,
- owner_id: member.id,
- creator_id: member.id,
- amount: amount,
- status: :open
- })
- end)
- end
-
- if claimed do
- claim =
- 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}"
- })
-
- # Create transaction pairs for paid claims
- if paid do
- debit_id = Nanoid.generate()
- credit_id = Nanoid.generate()
-
- Repo.transact(fn ->
- insert!(:transaction, %{
- id: debit_id,
- linked_transaction_id: credit_id,
- bounty_id: bounty.id,
- type: :debit,
- status: :succeeded,
- net_amount: amount,
- user_id: pied_piper.id,
- succeeded_at: claim.inserted_at
- })
-
- insert!(:transaction, %{
- id: credit_id,
- linked_transaction_id: debit_id,
- bounty_id: bounty.id,
- type: :credit,
- status: :succeeded,
- net_amount: amount,
- user_id: carver.id,
- succeeded_at: claim.inserted_at
- })
-
- {:ok, :ok}
- end)
- end
- end
- end
-end
-
big_head =
upsert!(
:user,
@@ -448,6 +326,7 @@ big_head =
email: "bighead@example.com",
display_name: "Nelson Bighetti",
handle: "bighead",
+ provider_login: "bighead",
bio: "Former Hooli executive. Accidental tech success. Stanford President.",
avatar_url: "https://algora.io/asset/storage/v1/object/public/mock/bighead.jpg",
tech_stack: ["Python", "JavaScript"],
@@ -466,6 +345,7 @@ jian_yang =
email: "jianyang@example.com",
display_name: "Jian Yang",
handle: "jianyang",
+ provider_login: "jianyang",
bio: "App developer. Creator of SeeFood and Smokation.",
avatar_url: "https://algora.io/asset/storage/v1/object/public/mock/jianyang.jpg",
tech_stack: ["Swift", "Python", "TensorFlow"],
@@ -484,6 +364,7 @@ john =
email: "john@example.com",
display_name: "John Stafford",
handle: "john",
+ provider_login: "john",
bio: "Datacenter infrastructure expert. Rack space optimization specialist.",
avatar_url: "https://algora.io/asset/storage/v1/object/public/mock/john.png",
tech_stack: ["Perl", "Terraform", "C++", "C"],
@@ -502,6 +383,7 @@ aly =
email: "aly@example.com",
display_name: "Aly Dutta",
handle: "aly",
+ provider_login: "aly",
bio: "Former Hooli engineer. Expert in distributed systems and scalability.",
avatar_url: "https://algora.io/asset/storage/v1/object/public/mock/aly.png",
tech_stack: ["Java", "Kotlin", "Go"],
@@ -542,6 +424,180 @@ for user <- [aly, big_head, jian_yang, john] do
end)
end
+repos = [
+ {
+ "middle-out",
+ [
+ "Optimize algorithm performance",
+ "Add support for new file types",
+ "Improve error handling",
+ "Implement streaming compression",
+ "Add compression statistics API"
+ ]
+ },
+ {
+ "pied-piper-web",
+ [
+ "Fix memory leak in upload handler",
+ "Implement new dashboard UI",
+ "Add real-time compression stats",
+ "Integrate SSO authentication",
+ "Build file comparison view"
+ ]
+ },
+ {
+ "infra",
+ [
+ "Scale kubernetes cluster",
+ "Implement auto-scaling",
+ "Optimize cloud costs",
+ "Set up monitoring and alerts",
+ "Configure disaster recovery"
+ ]
+ }
+]
+
+for {repo_name, issues} <- repos do
+ repo =
+ insert!(:repository, %{
+ name: repo_name,
+ url: "https://github.com/piedpiper/#{repo_name}",
+ user_id: pied_piper.id
+ })
+
+ for {issue_title, index} <- Enum.with_index(issues, 1) do
+ issue =
+ insert!(:ticket, %{
+ type: :issue,
+ repository_id: repo.id,
+ title: issue_title,
+ description: "We need help implementing this feature to improve our platform.",
+ number: index,
+ url: "https://github.com/piedpiper/#{repo_name}/issues/#{index}"
+ })
+
+ claimed = rem(index, 2) > 0
+ paid = claimed and rem(index, 3) > 0
+
+ bounties =
+ [2000, 500, 400, 300, 200, 100]
+ |> Enum.map(&Money.new!(&1, :USD))
+ |> Enum.zip([pied_piper | pied_piper_members])
+ |> Enum.map(fn {amount, sponsor} ->
+ insert!(:bounty, %{
+ ticket_id: issue.id,
+ owner_id: sponsor.id,
+ creator_id: sponsor.id,
+ amount: amount,
+ status: if(paid, do: :paid, else: :open)
+ })
+ end)
+
+ if claimed do
+ pull_request =
+ insert!(:ticket, %{
+ type: :pull_request,
+ repository_id: repo.id,
+ title: "Fix memory leak in upload handler and optimize buffer allocation",
+ description: """
+ This PR addresses the memory leak in the file upload handler by:
+ - Implementing proper buffer cleanup in the streaming pipeline
+ - Adding automatic resource disposal using with-clauses
+ - Optimizing memory allocation for large file uploads
+ - Adding memory usage monitoring
+
+ Testing shows a 60% reduction in memory usage during sustained uploads.
+
+ Key changes:
+ ```python
+ def process_upload(file_stream):
+ try:
+ with MemoryManager.track() as memory:
+ for chunk in file_stream:
+ # Optimize buffer allocation
+ buffer = BytesIO(initial_size=chunk.size)
+ compressed = middle_out.compress(chunk, buffer)
+ yield compressed
+
+ memory.log_usage("Upload complete")
+ finally:
+ buffer.close()
+ gc.collect() # Force cleanup
+ ```
+
+ Closes ##{index}
+ """,
+ number: index + length(issues),
+ url: "https://github.com/piedpiper/#{repo_name}/pull/#{index}"
+ })
+
+ group_id = Nanoid.generate()
+
+ claimants =
+ [carver, aly, big_head]
+ |> Enum.zip(["0.5", "0.3", "0.2"])
+ |> Enum.map(fn {user, share} -> {user, Decimal.new(share)} end)
+
+ for {user, share} <- claimants do
+ claim =
+ insert!(:claim, %{
+ group_id: group_id,
+ group_share: share,
+ user_id: user.id,
+ target_id: issue.id,
+ source_id: pull_request.id,
+ type: :pull_request,
+ status: if(paid, do: :approved, else: :pending),
+ url: "https://github.com/piedpiper/#{repo_name}/pull/#{index}"
+ })
+
+ if paid do
+ for {pct_paid, bounty} <-
+ ["1.25", "1.0", "1.0", "0.5", "0.0", "0.0"]
+ |> Enum.map(&Decimal.new/1)
+ |> Enum.zip(bounties) do
+ debit_id = Nanoid.generate()
+ credit_id = Nanoid.generate()
+
+ net_paid = Money.mult!(bounty.amount, Decimal.mult(share, pct_paid))
+
+ # Create transaction pairs for paid claims
+ Repo.transact(fn ->
+ insert!(:transaction, %{
+ id: debit_id,
+ linked_transaction_id: credit_id,
+ bounty_id: bounty.id,
+ claim_id: claim.id,
+ type: :debit,
+ status: :succeeded,
+ net_amount: net_paid,
+ user_id: bounty.owner_id,
+ succeeded_at: claim.inserted_at
+ })
+
+ insert!(:transaction, %{
+ id: credit_id,
+ linked_transaction_id: debit_id,
+ bounty_id: bounty.id,
+ claim_id: claim.id,
+ type: :credit,
+ status: :succeeded,
+ net_amount: net_paid,
+ user_id: user.id,
+ succeeded_at: claim.inserted_at
+ })
+
+ {:ok, :ok}
+ end)
+ end
+ end
+
+ Logger.info("Claim [#{claim.status}]: #{AlgoraWeb.Endpoint.url()}/claims/#{claim.group_id}")
+ end
+ end
+ end
+end
+
reviews = [
{richard, carver, -1,
"His cloud architecture is... unconventional, but it works. Like, really works. Our servers haven't crashed in weeks. Just wish he'd document things better."},
diff --git a/test/algora_web/controllers/webhooks/github_controller_test.exs b/test/algora_web/controllers/webhooks/github_controller_test.exs
index 6b3070230..52cd98f7a 100644
--- a/test/algora_web/controllers/webhooks/github_controller_test.exs
+++ b/test/algora_web/controllers/webhooks/github_controller_test.exs
@@ -5,6 +5,7 @@ defmodule AlgoraWeb.Webhooks.GithubControllerTest do
import Money.Sigil
import Mox
+ alias Algora.Github.Webhook
alias AlgoraWeb.Webhooks.GithubController
setup :verify_on_exit!
@@ -15,7 +16,20 @@ defmodule AlgoraWeb.Webhooks.GithubControllerTest do
@repo_name "repo"
@installation_id 123
+ @webhook %Webhook{
+ event: "issue_comment",
+ hook_id: "123456789",
+ delivery: "00000000-0000-0000-0000-000000000000",
+ signature: "sha1=0000000000000000000000000000000000000000",
+ signature_256: "sha256=0000000000000000000000000000000000000000000000000000000000000000",
+ user_agent: "GitHub-Hookshot/0000000",
+ installation_type: "integration",
+ installation_id: "123456"
+ }
+
@params %{
+ "id" => 123,
+ "action" => "created",
"repository" => %{
"owner" => %{"login" => @repo_owner},
"name" => @repo_name
@@ -47,57 +61,66 @@ defmodule AlgoraWeb.Webhooks.GithubControllerTest do
@tag user: @unauthorized_user
test "handles bounty command with unauthorized user", %{user: user} do
- assert process_bounty_command("/bounty $100", user)[:ok] == nil
- assert process_bounty_command("/bounty $100", user)[:error] == :unauthorized
+ assert {:error, :unauthorized} = process_bounty_command("/bounty $100", user)
end
test "handles bounty command without amount" do
- assert process_bounty_command("/bounty")[:ok] == nil
- assert process_bounty_command("/bounty")[:error] == nil
+ assert {:ok, []} = process_bounty_command("/bounty")
end
test "handles valid bounty command with $ prefix" do
- assert process_bounty_command("/bounty $100")[:ok].amount == ~M[100]usd
+ assert {:ok, [bounty]} = process_bounty_command("/bounty $100")
+ assert bounty.amount == ~M[100]usd
end
test "handles invalid bounty command with $ suffix" do
- assert process_bounty_command("/bounty 100$")[:ok].amount == ~M[100]usd
+ assert {:ok, [bounty]} = process_bounty_command("/bounty 100$")
+ assert bounty.amount == ~M[100]usd
end
test "handles bounty command without $ symbol" do
- assert process_bounty_command("/bounty 100")[:ok].amount == ~M[100]usd
+ assert {:ok, [bounty]} = process_bounty_command("/bounty 100")
+ assert bounty.amount == ~M[100]usd
end
test "handles bounty command with decimal amount" do
- assert process_bounty_command("/bounty 100.50")[:ok].amount == ~M[100.50]usd
+ assert {:ok, [bounty]} = process_bounty_command("/bounty 100.50")
+ assert bounty.amount == ~M[100.50]usd
end
test "handles bounty command with partial decimal amount" do
- assert process_bounty_command("/bounty 100.5")[:ok].amount == ~M[100.5]usd
+ assert {:ok, [bounty]} = process_bounty_command("/bounty 100.5")
+ assert bounty.amount == ~M[100.5]usd
end
test "handles bounty command with decimal amount and $ prefix" do
- assert process_bounty_command("/bounty $100.50")[:ok].amount == ~M[100.50]usd
+ assert {:ok, [bounty]} = process_bounty_command("/bounty $100.50")
+ assert bounty.amount == ~M[100.50]usd
end
test "handles bounty command with partial decimal amount and $ prefix" do
- assert process_bounty_command("/bounty $100.5")[:ok].amount == ~M[100.5]usd
+ assert {:ok, [bounty]} = process_bounty_command("/bounty $100.5")
+ assert bounty.amount == ~M[100.5]usd
end
test "handles bounty command with decimal amount and $ suffix" do
- assert process_bounty_command("/bounty 100.50$")[:ok].amount == ~M[100.50]usd
+ assert {:ok, [bounty]} = process_bounty_command("/bounty 100.50$")
+ assert bounty.amount == ~M[100.50]usd
end
test "handles bounty command with partial decimal amount and $ suffix" do
- assert process_bounty_command("/bounty 100.5$")[:ok].amount == ~M[100.5]usd
+ assert {:ok, [bounty]} = process_bounty_command("/bounty 100.5$")
+ assert bounty.amount == ~M[100.5]usd
end
test "handles bounty command with comma separator" do
- assert process_bounty_command("/bounty 1,000")[:ok].amount == ~M[1000]usd
+ assert {:ok, [bounty]} = process_bounty_command("/bounty 1,000")
+ assert bounty.amount == ~M[1000]usd
end
test "handles bounty command with comma separator and decimal amount" do
- assert process_bounty_command("/bounty 1,000.50")[:ok].amount == ~M[1000.50]usd
+ assert {:ok, [bounty]} = process_bounty_command("/bounty 1,000.50")
+ assert bounty.amount == ~M[1000.50]usd
end
end
@@ -184,14 +207,17 @@ defmodule AlgoraWeb.Webhooks.GithubControllerTest do
end
# Helper function to process bounty commands
- defp process_bounty_command(body, author \\ @admin_user) do
- full_body = """
+ defp process_bounty_command(command, author \\ @admin_user) do
+ body = """
Lorem
- ipsum #{body} dolor
+ ipsum #{command} dolor
sit
amet
"""
- GithubController.process_commands(full_body, %{"login" => author}, @params)
+ GithubController.process_commands(
+ @webhook,
+ Map.put(@params, "comment", %{"user" => %{"login" => author}, "body" => body})
+ )
end
end
diff --git a/test/support/factory.ex b/test/support/factory.ex
index 0a8dda7f6..a7de935cd 100644
--- a/test/support/factory.ex
+++ b/test/support/factory.ex
@@ -66,7 +66,10 @@ defmodule Algora.Factory do
twitter_url: "https://twitter.com/piedpiper",
github_url: "https://github.com/piedpiper",
discord_url: "https://discord.gg/piedpiper",
- slack_url: "https://piedpiper.slack.com"
+ slack_url: "https://piedpiper.slack.com",
+ provider: "github",
+ provider_login: "piedpiper",
+ provider_id: sequence(:provider_id, &"#{&1}")
}
end
@@ -195,16 +198,13 @@ defmodule Algora.Factory do
end
def claim_factory do
+ id = Nanoid.generate()
+
%Algora.Bounties.Claim{
- id: Nanoid.generate(),
- provider: "github",
- provider_id: sequence(:provider_id, &"#{&1}"),
- type: :code,
- status: :pending,
- title: "Implemented compression optimization",
- description: "Added parallel processing for large files",
- url: "https://github.com/piedpiper/middle-out/pull/2",
- provider_meta: %{}
+ id: id,
+ group_id: id,
+ type: :pull_request,
+ status: :pending
}
end
+ <.card>
+ <.card_header>
+ <.card_title>Payment Details
+
+ <.card_content>
+
+
+ <%= if Enum.empty?(@available_bounties) do %>
+ <.alert variant="destructive">
+ <.alert_title>No bounties available
+ <.alert_description>
+ You didn't post a bounty for this issue. Would you like to create one now?
+
+
+ <% end %>
+ <.input
+ label="Amount"
+ icon="tabler-currency-dollar"
+ field={@reward_bounty_form[:amount]}
+ />
+
+
+
+
+ <.card>
+ <.card_header>
+ <.card_title>Payment Summary
+
+ <.card_content>
+
+ <.label>On behalf of
+ <.dropdown2 id="context-dropdown" class="mt-2">
+ <:img src={@selected_context.avatar_url} />
+ <:title>{@selected_context.name}
+ <:subtitle>@{@selected_context.handle}
+
+ <:link
+ :for={context <- @contexts |> Enum.reject(&(&1.id == @selected_context.id))}
+ patch={"?context=#{context.id}"}
+ >
+
+
+
+ 
+
+
+
+
+
+ {context.name}
+ @{context.handle}
+
+ <.label>Tip
+
+
+ <.radio_group
+ class="grid grid-cols-4 gap-4"
+ field={@reward_bounty_form[:tip_percentage]}
+ options={tip_options()}
+ />
+
+ -
+ <%= for line_item <- @line_items do %>
+
-
+ <%= if line_item.image do %>
+ <.avatar>
+ <.avatar_image src={line_item.image} />
+
+ <% else %>
+
+ <% end %>
+ ++{line_item.title}+{line_item.description}+
+
- + {Money.to_string!(line_item.amount)} + +
-
+
+ Total due+
+
- + {LineItem.gross_amount(@line_items)} + +
+
+ <% end %>
+
+
+
+
+ <.button variant="secondary" phx-click="close_drawer" type="button">
+ Cancel
+
+ <.button type="submit">
+ Pay with Stripe <.icon name="tabler-arrow-right" class="-mr-1 ml-2 h-4 w-4" />
+
+
+