You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
179 lines
4.6 KiB
Elixir
179 lines
4.6 KiB
Elixir
defmodule Plausible.Billing.Plans do
|
|
use Plausible.Repo
|
|
|
|
@unlisted_plans_v1 [
|
|
%{limit: 150_000_000, yearly_product_id: "648089", yearly_cost: "$4800"}
|
|
]
|
|
|
|
@unlisted_plans_v2 [
|
|
%{limit: 10_000_000, monthly_product_id: "655350", monthly_cost: "$250"}
|
|
]
|
|
|
|
@sandbox_plans [
|
|
%{
|
|
limit: 10_000,
|
|
monthly_product_id: "19878",
|
|
yearly_product_id: "20127",
|
|
monthly_cost: "$6",
|
|
yearly_cost: "$60"
|
|
},
|
|
%{
|
|
limit: 100_000,
|
|
monthly_product_id: "20657",
|
|
yearly_product_id: "20658",
|
|
monthly_cost: "$12.34",
|
|
yearly_cost: "$120.34"
|
|
}
|
|
]
|
|
|
|
@type plan() ::
|
|
%{
|
|
limit: non_neg_integer(),
|
|
monthly_product_id: String.t(),
|
|
yearly_product_id: String.t(),
|
|
monthly_cost: String.t(),
|
|
yearly_cost: String.t()
|
|
}
|
|
| :enterprise
|
|
|
|
def plans_for(user) do
|
|
user = Repo.preload(user, :subscription)
|
|
sandbox_plans = plans_sandbox()
|
|
v1_plans = plans_v1()
|
|
v2_plans = plans_v2()
|
|
v3_plans = plans_v3()
|
|
|
|
raw_plans =
|
|
cond do
|
|
contains?(v1_plans, user.subscription) ->
|
|
v1_plans
|
|
|
|
contains?(v2_plans, user.subscription) ->
|
|
v2_plans
|
|
|
|
contains?(v3_plans, user.subscription) ->
|
|
v3_plans
|
|
|
|
contains?(sandbox_plans, user.subscription) ->
|
|
sandbox_plans
|
|
|
|
true ->
|
|
cond do
|
|
Application.get_env(:plausible, :environment) == "dev" -> sandbox_plans
|
|
Timex.before?(user.inserted_at, ~D[2022-01-01]) -> v2_plans
|
|
true -> v3_plans
|
|
end
|
|
end
|
|
|
|
Enum.map(raw_plans, fn plan -> Map.put(plan, :volume, number_format(plan[:limit])) end)
|
|
end
|
|
|
|
def all_yearly_plan_ids do
|
|
Enum.map(all_plans(), fn plan -> plan[:yearly_product_id] end)
|
|
end
|
|
|
|
def for_product_id(product_id) do
|
|
Enum.find(all_plans(), fn plan ->
|
|
product_id in [plan[:monthly_product_id], plan[:yearly_product_id]]
|
|
end)
|
|
end
|
|
|
|
def subscription_interval(%Plausible.Billing.Subscription{paddle_plan_id: "free_10k"}),
|
|
do: "N/A"
|
|
|
|
def subscription_interval(subscription) do
|
|
case for_product_id(subscription.paddle_plan_id) do
|
|
nil ->
|
|
enterprise_plan = get_enterprise_plan(subscription)
|
|
|
|
enterprise_plan && enterprise_plan.billing_interval
|
|
|
|
plan ->
|
|
if subscription.paddle_plan_id == plan[:monthly_product_id] do
|
|
"monthly"
|
|
else
|
|
"yearly"
|
|
end
|
|
end
|
|
end
|
|
|
|
def allowance(%Plausible.Billing.Subscription{paddle_plan_id: "free_10k"}), do: 10_000
|
|
|
|
def allowance(subscription) do
|
|
found = for_product_id(subscription.paddle_plan_id)
|
|
|
|
if found do
|
|
Map.fetch!(found, :limit)
|
|
else
|
|
enterprise_plan = get_enterprise_plan(subscription)
|
|
|
|
if enterprise_plan do
|
|
enterprise_plan.monthly_pageview_limit
|
|
else
|
|
Sentry.capture_message("Unknown allowance for plan",
|
|
extra: %{
|
|
paddle_plan_id: subscription.paddle_plan_id
|
|
}
|
|
)
|
|
end
|
|
end
|
|
end
|
|
|
|
defp get_enterprise_plan(%Plausible.Billing.Subscription{} = subscription) do
|
|
Repo.get_by(Plausible.Billing.EnterprisePlan,
|
|
user_id: subscription.user_id,
|
|
paddle_plan_id: subscription.paddle_plan_id
|
|
)
|
|
end
|
|
|
|
@enterprise_level_usage 10_000_000
|
|
@spec suggested_plan(Plausible.Auth.User.t(), non_neg_integer()) :: plan()
|
|
def suggested_plan(user, usage_during_cycle) do
|
|
cond do
|
|
usage_during_cycle > @enterprise_level_usage -> :enterprise
|
|
Plausible.Auth.enterprise?(user) -> :enterprise
|
|
true -> Enum.find(plans_for(user), fn plan -> usage_during_cycle < plan[:limit] end)
|
|
end
|
|
end
|
|
|
|
defp contains?(_plans, nil), do: false
|
|
|
|
defp contains?(plans, subscription) do
|
|
Enum.any?(plans, fn plan ->
|
|
plan[:monthly_product_id] == subscription.paddle_plan_id ||
|
|
plan[:yearly_product_id] == subscription.paddle_plan_id
|
|
end)
|
|
end
|
|
|
|
defp number_format(num) do
|
|
PlausibleWeb.StatsView.large_number_format(num)
|
|
end
|
|
|
|
defp all_plans() do
|
|
plans_v1() ++
|
|
@unlisted_plans_v1 ++ plans_v2() ++ @unlisted_plans_v2 ++ plans_v3() ++ plans_sandbox()
|
|
end
|
|
|
|
defp plans_v1() do
|
|
File.read!(Application.app_dir(:plausible) <> "/priv/plans_v1.json")
|
|
|> Jason.decode!(keys: :atoms)
|
|
end
|
|
|
|
defp plans_v2() do
|
|
File.read!(Application.app_dir(:plausible) <> "/priv/plans_v2.json")
|
|
|> Jason.decode!(keys: :atoms)
|
|
end
|
|
|
|
defp plans_v3() do
|
|
File.read!(Application.app_dir(:plausible) <> "/priv/plans_v3.json")
|
|
|> Jason.decode!(keys: :atoms)
|
|
end
|
|
|
|
defp plans_sandbox() do
|
|
case Application.get_env(:plausible, :environment) do
|
|
"dev" -> @sandbox_plans
|
|
_ -> []
|
|
end
|
|
end
|
|
end
|