Skip to content

Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.

Remove team adapters (#4877)

Adrian Gruntkowski3afec60d98db
diff --git a/.github/workflows/elixir.yml b/.github/workflows/elixir.yml
index 1d30638f09..b33e83af73 100644
--- a/.github/workflows/elixir.yml
+++ b/.github/workflows/elixir.yml
@@ -16,22 +16,19 @@ env:
jobs:
build:
- name: "Build and test (${{ matrix.mix_env }}, ${{ matrix.postgres_image }}${{ matrix.test_read_team_schemas == '1' && ', read_team_schemas' || '' }})"
+ name: "Build and test (${{ matrix.mix_env }}, ${{ matrix.postgres_image }})"
runs-on: ubuntu-latest
strategy:
matrix:
- mix_env: ["test", "ce_test"]
- postgres_image: ["postgres:16"]
- test_read_team_schemas: ["0"]
+ mix_env: ["test"]
+ postgres_image: ["postgres:15"]
include:
- - mix_env: "test"
- postgres_image: "postgres:15"
- test_read_team_schemas: "1"
+ - mix_env: "ce_test"
+ postgres_image: "postgres:16"
env:
MIX_ENV: ${{ matrix.mix_env }}
- TEST_READ_TEAM_SCHEMAS: ${{ matrix.test_read_team_schemas }}
services:
postgres:
image: ${{ matrix.postgres_image }}
diff --git a/extra/lib/plausible_web/controllers/api/external_sites_controller.ex b/extra/lib/plausible_web/controllers/api/external_sites_controller.ex
index 4900d6c8b4..b6d8aa1c81 100644
--- a/extra/lib/plausible_web/controllers/api/external_sites_controller.ex
+++ b/extra/lib/plausible_web/controllers/api/external_sites_controller.ex
@@ -65,7 +65,7 @@ defmodule PlausibleWeb.Api.ExternalSitesController do
{:ok, %{site: site}} ->
json(conn, site)
- {:error, {:over_limit, limit}} ->
+ {:error, _, {:over_limit, limit}, _} ->
conn
|> put_status(402)
|> json(%{
@@ -206,7 +206,7 @@ defmodule PlausibleWeb.Api.ExternalSitesController do
end
defp get_site(user, site_id, roles) do
- case Plausible.Teams.Adapter.Read.Sites.get_for_user(user, site_id, roles) do
+ case Plausible.Sites.get_for_user(user, site_id, roles) do
nil -> {:error, :site_not_found}
site -> {:ok, site}
end
diff --git a/extra/lib/plausible_web/live/funnel_settings.ex b/extra/lib/plausible_web/live/funnel_settings.ex
index b6282abc92..d12bfb2a7e 100644
--- a/extra/lib/plausible_web/live/funnel_settings.ex
+++ b/extra/lib/plausible_web/live/funnel_settings.ex
@@ -16,7 +16,7 @@ defmodule PlausibleWeb.Live.FunnelSettings do
socket =
socket
|> assign_new(:site, fn %{current_user: current_user} ->
- Plausible.Teams.Adapter.Read.Sites.get_for_user!(current_user, domain, [
+ Plausible.Sites.get_for_user!(current_user, domain, [
:owner,
:admin,
:super_admin
@@ -106,7 +106,7 @@ defmodule PlausibleWeb.Live.FunnelSettings do
def handle_event("delete-funnel", %{"funnel-id" => id}, socket) do
site =
- Plausible.Teams.Adapter.Read.Sites.get_for_user!(
+ Plausible.Sites.get_for_user!(
socket.assigns.current_user,
socket.assigns.domain,
[:owner, :admin]
diff --git a/extra/lib/plausible_web/live/funnel_settings/form.ex b/extra/lib/plausible_web/live/funnel_settings/form.ex
index e0d24220d0..1fcd46f1fe 100644
--- a/extra/lib/plausible_web/live/funnel_settings/form.ex
+++ b/extra/lib/plausible_web/live/funnel_settings/form.ex
@@ -13,7 +13,7 @@ defmodule PlausibleWeb.Live.FunnelSettings.Form do
def mount(_params, %{"domain" => domain} = session, socket) do
site =
- Plausible.Teams.Adapter.Read.Sites.get_for_user!(socket.assigns.current_user, domain, [
+ Plausible.Sites.get_for_user!(socket.assigns.current_user, domain, [
:owner,
:admin,
:super_admin
diff --git a/lib/plausible/auth/auth.ex b/lib/plausible/auth/auth.ex
index 49e3ff97f8..69d767d595 100644
--- a/lib/plausible/auth/auth.ex
+++ b/lib/plausible/auth/auth.ex
@@ -117,17 +117,6 @@ defmodule Plausible.Auth do
end)
end
- def user_owns_sites?(user) do
- Repo.exists?(
- from(s in Plausible.Site,
- join: sm in Plausible.Site.Membership,
- on: sm.site_id == s.id,
- where: sm.user_id == ^user.id,
- where: sm.role == :owner
- )
- )
- end
-
on_ee do
def is_super_admin?(nil), do: false
def is_super_admin?(%Plausible.Auth.User{id: id}), do: is_super_admin?(id)
@@ -139,21 +128,19 @@ defmodule Plausible.Auth do
def is_super_admin?(_), do: false
end
- def enterprise_configured?(nil), do: false
-
- def enterprise_configured?(%Plausible.Auth.User{} = user) do
- user
- |> Ecto.assoc(:enterprise_plan)
- |> Repo.exists?()
- end
-
@spec create_api_key(Auth.User.t(), String.t(), String.t()) ::
{:ok, Auth.ApiKey.t()} | {:error, Ecto.Changeset.t() | :upgrade_required}
def create_api_key(user, name, key) do
+ team =
+ case Plausible.Teams.get_by_owner(user) do
+ {:ok, team} -> team
+ _ -> nil
+ end
+
params = %{name: name, user_id: user.id, key: key}
changeset = Auth.ApiKey.changeset(%Auth.ApiKey{}, params)
- with :ok <- Plausible.Billing.Feature.StatsAPI.check_availability(user),
+ with :ok <- Plausible.Billing.Feature.StatsAPI.check_availability(team),
do: Repo.insert(changeset)
end
diff --git a/lib/plausible/billing/billing.ex b/lib/plausible/billing/billing.ex
index f903a8ccca..a4fa1cf32f 100644
--- a/lib/plausible/billing/billing.ex
+++ b/lib/plausible/billing/billing.ex
@@ -2,20 +2,9 @@ defmodule Plausible.Billing do
use Plausible
use Plausible.Repo
require Plausible.Billing.Subscription.Status
- alias Plausible.Billing.Subscriptions
- alias Plausible.Billing.{Subscription, Plans, Quota}
+ alias Plausible.Billing.Subscription
alias Plausible.Auth.User
- @spec active_subscription_for(User.t()) :: Subscription.t() | nil
- def active_subscription_for(user) do
- user |> active_subscription_query() |> Repo.one()
- end
-
- @spec has_active_subscription?(User.t()) :: boolean()
- def has_active_subscription?(user) do
- user |> active_subscription_query() |> Repo.exists?()
- end
-
def subscription_created(params) do
Repo.transaction(fn ->
handle_subscription_created(params)
@@ -40,44 +29,6 @@ defmodule Plausible.Billing do
end)
end
- def change_plan(user, new_plan_id) do
- subscription = active_subscription_for(user)
- plan = Plans.find(new_plan_id)
-
- limit_checking_opts =
- if user.allow_next_upgrade_override do
- [ignore_pageview_limit: true]
- else
- []
- end
-
- with :ok <- Quota.ensure_within_plan_limits(user, plan, limit_checking_opts),
- do: do_change_plan(subscription, new_plan_id)
- end
-
- @doc false
- def do_change_plan(subscription, new_plan_id) do
- res =
- paddle_api().update_subscription(subscription.paddle_subscription_id, %{
- plan_id: new_plan_id
- })
-
- case res do
- {:ok, response} ->
- amount = :erlang.float_to_binary(response["next_payment"]["amount"] / 1, decimals: 2)
-
- Subscription.changeset(subscription, %{
- paddle_plan_id: Integer.to_string(response["plan_id"]),
- next_bill_amount: amount,
- next_bill_date: response["next_payment"]["date"]
- })
- |> Repo.update()
-
- e ->
- e
- end
- end
-
def change_plan_preview(subscription, new_plan_id) do
case paddle_api().update_subscription_preview(
subscription.paddle_subscription_id,
@@ -91,33 +42,6 @@ defmodule Plausible.Billing do
end
end
- @spec check_needs_to_upgrade(User.t()) ::
- {:needs_to_upgrade, :no_trial | :no_active_subscription | :grace_period_ended}
- | :no_upgrade_needed
- def check_needs_to_upgrade(user) do
- user = Plausible.Users.with_subscription(user)
-
- trial_over? =
- not is_nil(user.trial_expiry_date) and
- Date.before?(user.trial_expiry_date, Date.utc_today())
-
- subscription_active? = Subscriptions.active?(user.subscription)
-
- cond do
- is_nil(user.trial_expiry_date) and not subscription_active? ->
- {:needs_to_upgrade, :no_trial}
-
- trial_over? and not subscription_active? ->
- {:needs_to_upgrade, :no_active_subscription}
-
- Plausible.Auth.GracePeriod.expired?(user) ->
- {:needs_to_upgrade, :grace_period_ended}
-
- true ->
- :no_upgrade_needed
- end
- end
-
defp handle_subscription_created(params) do
params =
if present?(params["passthrough"]) do
@@ -284,14 +208,6 @@ defmodule Plausible.Billing do
"subscription_cancelled__#{id}"
end
- defp active_subscription_query(user) do
- from(s in Subscription,
- where: s.user_id == ^user.id and s.status == ^Subscription.Status.active(),
- order_by: [desc: s.inserted_at],
- limit: 1
- )
- end
-
defp after_subscription_update(subscription) do
user =
User
diff --git a/lib/plausible/billing/feature.ex b/lib/plausible/billing/feature.ex
index 78df7c23d4..a34926273e 100644
--- a/lib/plausible/billing/feature.ex
+++ b/lib/plausible/billing/feature.ex
@@ -65,9 +65,9 @@ defmodule Plausible.Billing.Feature do
@callback opted_out?(Plausible.Site.t()) :: boolean()
@doc """
- Checks whether the site owner or the user plan includes the given feature.
+ Checks whether the team or the team plan includes the given feature.
"""
- @callback check_availability(Plausible.Auth.User.t() | Plausible.Teams.Team.t() | nil) ::
+ @callback check_availability(Plausible.Teams.Team.t() | nil) ::
:ok | {:error, :upgrade_required} | {:error, :not_implemented}
@features [
@@ -120,8 +120,8 @@ defmodule Plausible.Billing.Feature do
@impl true
def enabled?(%Plausible.Site{} = site) do
- site = Plausible.Repo.preload(site, :owner)
- check_availability(site.owner) == :ok && !opted_out?(site)
+ site = Plausible.Repo.preload(site, :team)
+ check_availability(site.team) == :ok && !opted_out?(site)
end
@impl true
@@ -130,8 +130,12 @@ defmodule Plausible.Billing.Feature do
end
@impl true
- def check_availability(%Plausible.Auth.User{} = user) do
- Plausible.Teams.Adapter.Read.Billing.check_feature_availability(__MODULE__, user)
+ def check_availability(team_or_nil) do
+ cond do
+ free?() -> :ok
+ __MODULE__ in Plausible.Teams.Billing.allowed_features_for(team_or_nil) -> :ok
+ true -> {:error, :upgrade_required}
+ end
end
@impl true
@@ -140,11 +144,9 @@ defmodule Plausible.Billing.Feature do
end
defp do_toggle(%Plausible.Site{} = site, user, opts) do
- owner = Plausible.Teams.Adapter.Read.Ownership.get_owner(site, user)
-
override = Keyword.get(opts, :override)
toggle = if is_boolean(override), do: override, else: !Map.fetch!(site, toggle_field())
- availability = if toggle, do: check_availability(owner), else: :ok
+ availability = if toggle, do: check_availability(site.team), else: :ok
case availability do
:ok ->
@@ -195,22 +197,10 @@ defmodule Plausible.Billing.Feature.Props do
end
defmodule Plausible.Billing.Feature.StatsAPI do
+ use Plausible
+
@moduledoc false
use Plausible.Billing.Feature,
name: :stats_api,
display_name: "Stats API"
-
- @impl true
- @doc """
- Checks whether the user has access to Stats API or not.
-
- Before the business tier, users who had not yet started their trial had
- access to Stats API. With the business tier work, access is blocked and they
- must either start their trial or subscribe to a plan. This is common when a
- site owner invites a new user. In such cases, using the owner's API key is
- recommended.
- """
- def check_availability(%Plausible.Auth.User{} = user) do
- Plausible.Teams.Adapter.Read.Billing.check_feature_availability_for_stats_api(user)
- end
end
diff --git a/lib/plausible/billing/plans.ex b/lib/plausible/billing/plans.ex
index b4e970d849..5b17aba608 100644
--- a/lib/plausible/billing/plans.ex
+++ b/lib/plausible/billing/plans.ex
@@ -2,7 +2,7 @@ defmodule Plausible.Billing.Plans do
alias Plausible.Billing.Subscriptions
use Plausible.Repo
alias Plausible.Billing.{Subscription, Plan, EnterprisePlan}
- alias Plausible.Auth.User
+ alias Plausible.Teams
for f <- [
:legacy_plans,
@@ -25,9 +25,6 @@ defmodule Plausible.Billing.Plans do
Module.put_attribute(__MODULE__, :external_resource, path)
end
- @business_tier_launch ~N[2023-11-08 12:00:00]
- def business_tier_launch, do: @business_tier_launch
-
@spec growth_plans_for(Subscription.t()) :: [Plan.t()]
@doc """
Returns a list of growth plans available for the subscription to choose.
@@ -115,19 +112,6 @@ defmodule Plausible.Billing.Plans do
end
end
- def latest_enterprise_plan_with_price(user, customer_ip) do
- enterprise_plan =
- Repo.one!(
- from(e in EnterprisePlan,
- where: e.user_id == ^user.id,
- order_by: [desc: e.inserted_at],
- limit: 1
- )
- )
-
- {enterprise_plan, get_price_for(enterprise_plan, customer_ip)}
- end
-
def subscription_interval(subscription) do
case get_subscription_plan(subscription) do
%EnterprisePlan{billing_interval: interval} ->
@@ -202,24 +186,30 @@ defmodule Plausible.Billing.Plans do
end
end
- @enterprise_level_usage 10_000_000
- @spec suggest(User.t(), non_neg_integer()) :: Plan.t()
@doc """
- Returns the most appropriate plan for a user based on their usage during a
+ Returns the most appropriate plan for a team based on its usage during a
given cycle.
If the usage during the cycle exceeds the enterprise-level threshold, or if
- the user already belongs to an enterprise plan, it suggests the :enterprise
+ the team already has an enterprise plan, it suggests the :enterprise
plan.
Otherwise, it recommends the plan where the cycle usage falls just under the
- plan's limit from the available options for the user.
+ plan's limit from the available options for the team.
"""
- def suggest(user, usage_during_cycle) do
+ @enterprise_level_usage 10_000_000
+ @spec suggest(Teams.Team.t(), non_neg_integer()) :: Plan.t()
+ def suggest(team, usage_during_cycle) do
cond do
- usage_during_cycle > @enterprise_level_usage -> :enterprise
- Plausible.Teams.Adapter.Read.Billing.enterprise_configured?(user) -> :enterprise
- true -> Plausible.Teams.Adapter.Read.Billing.suggest_by_usage(user, usage_during_cycle)
+ usage_during_cycle > @enterprise_level_usage ->
+ :enterprise
+
+ Teams.Billing.enterprise_configured?(team) ->
+ :enterprise
+
+ true ->
+ subscription = Teams.Billing.get_subscription(team)
+ suggest_by_usage(subscription, usage_during_cycle)
end
end
diff --git a/lib/plausible/billing/qouta/limits.ex b/lib/plausible/billing/qouta/limits.ex
index 93918cb720..6d8018852c 100644
--- a/lib/plausible/billing/qouta/limits.ex
+++ b/lib/plausible/billing/qouta/limits.ex
@@ -1,120 +1,13 @@
defmodule Plausible.Billing.Quota.Limits do
@moduledoc false
- use Plausible
- alias Plausible.Users
- alias Plausible.Auth.User
- alias Plausible.Billing.{Plan, Plans, Subscription, EnterprisePlan, Feature}
- alias Plausible.Billing.Feature.{Goals, Props, StatsAPI}
-
@type over_limits_error() :: {:over_plan_limits, [limit()]}
@typep limit() :: :site_limit | :pageview_limit | :team_member_limit
- @pageview_allowance_margin 0.1
-
- on_ee do
- @limit_sites_since ~D[2021-05-05]
- @site_limit_for_trials 10
- @team_member_limit_for_trials 3
-
- @spec site_limit(User.t()) :: non_neg_integer() | :unlimited
- def site_limit(user) do
- if Date.before?(user.inserted_at, @limit_sites_since) do
- :unlimited
- else
- get_site_limit_from_plan(user)
- end
- end
-
- defp get_site_limit_from_plan(user) do
- user = Users.with_subscription(user)
-
- case Plans.get_subscription_plan(user.subscription) do
- %{site_limit: site_limit} -> site_limit
- :free_10k -> 50
- nil -> @site_limit_for_trials
- end
- end
-
- @spec team_member_limit(User.t()) :: non_neg_integer()
- def team_member_limit(user) do
- user = Users.with_subscription(user)
-
- case Plans.get_subscription_plan(user.subscription) do
- %{team_member_limit: limit} -> limit
- :free_10k -> :unlimited
- nil -> @team_member_limit_for_trials
- end
- end
- else
- def site_limit(_) do
- :unlimited
- end
-
- def team_member_limit(_) do
- :unlimited
- end
- end
-
- @monthly_pageview_limit_for_free_10k 10_000
- @monthly_pageview_limit_for_trials :unlimited
-
- @spec monthly_pageview_limit(User.t() | Subscription.t() | nil) ::
- non_neg_integer() | :unlimited
- def monthly_pageview_limit(%User{} = user) do
- user = Users.with_subscription(user)
- monthly_pageview_limit(user.subscription)
- end
- def monthly_pageview_limit(subscription) do
- case Plans.get_subscription_plan(subscription) do
- %EnterprisePlan{monthly_pageview_limit: limit} ->
- limit
-
- %Plan{monthly_pageview_limit: limit} ->
- limit
-
- :free_10k ->
- @monthly_pageview_limit_for_free_10k
-
- _any ->
- if subscription do
- Sentry.capture_message("Unknown monthly pageview limit for plan",
- extra: %{paddle_plan_id: subscription.paddle_plan_id}
- )
- end
-
- @monthly_pageview_limit_for_trials
- end
- end
+ @pageview_allowance_margin 0.1
def pageview_limit_with_margin(limit, margin \\ nil) do
margin = if margin, do: margin, else: @pageview_allowance_margin
ceil(limit * (1 + margin))
end
-
- @doc """
- Returns a list of features the user can use. Trial users have the
- ability to use all features during their trial.
- """
- def allowed_features_for(user) do
- user = Users.with_subscription(user)
-
- case Plans.get_subscription_plan(user.subscription) do
- %EnterprisePlan{features: features} ->
- features
-
- %Plan{features: features} ->
- features
-
- :free_10k ->
- [Goals, Props, StatsAPI]
-
- nil ->
- if Users.on_trial?(user) do
- Feature.list()
- else
- [Goals]
- end
- end
- end
end
diff --git a/lib/plausible/billing/qouta/quota.ex b/lib/plausible/billing/qouta/quota.ex
index 8d2ae5f4f2..54b12010be 100644
--- a/lib/plausible/billing/qouta/quota.ex
+++ b/lib/plausible/billing/qouta/quota.ex
@@ -4,47 +4,21 @@ defmodule Plausible.Billing.Quota do
"""
use Plausible
- alias Plausible.Users
- alias Plausible.Auth.User
- alias Plausible.Billing.{Plan, Plans, EnterprisePlan}
- alias Plausible.Billing.Quota.{Usage, Limits}
+ alias Plausible.Billing.{Plan, EnterprisePlan}
+ alias Plausible.Billing.Quota.Limits
@doc """
- Enterprise plans are always allowed to add more sites (even when
- over limit) to avoid service disruption. Their usage is checked
- in a background job instead (see `check_usage.ex`).
- """
- def ensure_can_add_new_site(user) do
- user = Users.with_subscription(user)
-
- case Plans.get_subscription_plan(user.subscription) do
- %EnterprisePlan{} ->
- :ok
-
- _ ->
- usage = Usage.site_usage(user)
- limit = Limits.site_limit(user)
-
- if below_limit?(usage, limit), do: :ok, else: {:error, {:over_limit, limit}}
- end
- end
-
- @doc """
- Ensures that the given user (or the usage map) is within the limits
+ Ensures that the given usage map is within the limits
of the given plan.
An `opts` argument can be passed with `ignore_pageview_limit: true`
which bypasses the pageview limit check and returns `:ok` as long as
the other limits are not exceeded.
"""
- @spec ensure_within_plan_limits(User.t() | map(), struct() | atom() | nil, Keyword.t()) ::
+ @spec ensure_within_plan_limits(map(), struct() | atom() | nil, Keyword.t()) ::
:ok | {:error, Limits.over_limits_error()}
- def ensure_within_plan_limits(user_or_usage, plan, opts \\ [])
- def ensure_within_plan_limits(%User{} = user, %plan_mod{} = plan, opts)
- when plan_mod in [Plan, EnterprisePlan] do
- ensure_within_plan_limits(Usage.usage(user), plan, opts)
- end
+ def ensure_within_plan_limits(usage, plan_mod, opts \\ [])
def ensure_within_plan_limits(usage, %plan_mod{} = plan, opts)
when plan_mod in [Plan, EnterprisePlan] do
@@ -121,13 +95,14 @@ defmodule Plausible.Billing.Quota do
end
end
- @spec exceeds_last_two_usage_cycles?(Usage.cycles_usage(), non_neg_integer()) :: boolean()
+ @spec exceeds_last_two_usage_cycles?(Plausible.Teams.Billing.cycles_usage(), non_neg_integer()) ::
+ boolean()
def exceeds_last_two_usage_cycles?(cycles_usage, allowed_volume) do
exceeded = exceeded_cycles(cycles_usage, allowed_volume)
:penultimate_cycle in exceeded && :last_cycle in exceeded
end
- @spec exceeded_cycles(Usage.cycles_usage(), non_neg_integer()) :: list()
+ @spec exceeded_cycles(Plausible.Teams.Billing.cycles_usage(), non_neg_integer()) :: list()
def exceeded_cycles(cycles_usage, allowed_volume) do
limit = Limits.pageview_limit_with_margin(allowed_volume)
diff --git a/lib/plausible/billing/qouta/usage.ex b/lib/plausible/billing/qouta/usage.ex
deleted file mode 100644
index c2f6942212..0000000000
--- a/lib/plausible/billing/qouta/usage.ex
+++ /dev/null
@@ -1,294 +0,0 @@
-defmodule Plausible.Billing.Quota.Usage do
- @moduledoc false
-
- use Plausible
- import Ecto.Query
- alias Plausible.Users
- alias Plausible.Auth.User
- alias Plausible.Site
- alias Plausible.Billing.{Subscriptions, Feature}
-
- @type cycles_usage() :: %{cycle() => usage_cycle()}
-
- @typep cycle :: :current_cycle | :last_cycle | :penultimate_cycle
- @typep last_30_days_usage() :: %{:last_30_days => usage_cycle()}
- @typep monthly_pageview_usage() :: cycles_usage() | last_30_days_usage()
-
- @typep usage_cycle :: %{
- date_range: Date.Range.t(),
- pageviews: non_neg_integer(),
- custom_events: non_neg_integer(),
- total: non_neg_integer()
- }
-
- @doc """
- Returns a full usage report for the user.
-
- ### Options
-
- * `pending_ownership_site_ids` - a list of site IDs from which to count
- additional usage. This allows us to look at the total usage from pending
- ownerships and owned sites at the same time, which is useful, for example,
- when deciding whether to let the user upgrade to a plan, or accept a site
- ownership.
-
- * `with_features` - when `true`, the returned map will contain features
- usage. Also counts usage from `pending_ownership_site_ids` if that option
- is given.
- """
- def usage(user, opts \\ []) do
- owned_site_ids = Plausible.Sites.owned_site_ids(user)
- pending_ownership_site_ids = Keyword.get(opts, :pending_ownership_site_ids, [])
- all_site_ids = Enum.uniq(owned_site_ids ++ pending_ownership_site_ids)
-
- basic_usage = %{
- monthly_pageviews: monthly_pageview_usage(user, all_site_ids),
- team_members:
- team_member_usage(user, pending_ownership_site_ids: pending_ownership_site_ids),
- sites: length(all_site_ids)
- }
-
- if Keyword.get(opts, :with_features) == true do
- basic_usage
- |> Map.put(:features, features_usage(user, all_site_ids))
- else
- basic_usage
- end
- end
-
- @spec site_usage(User.t()) :: non_neg_integer()
- @doc """
- Returns the number of sites the given user owns.
- """
- def site_usage(user) do
- Plausible.Sites.owned_sites_count(user)
- end
-
- @doc """
- Queries the ClickHouse database for the monthly pageview usage. If the given user's
- subscription is `active`, `past_due`, or a `deleted` (but not yet expired), a map
- with the following structure is returned:
-
- ```elixir
- %{
- current_cycle: usage_cycle(),
- last_cycle: usage_cycle(),
- penultimate_cycle: usage_cycle()
- }
- ```
-
- In all other cases of the subscription status (or a `free_10k` subscription which
- does not have a `last_bill_date` defined) - the following structure is returned:
-
- ```elixir
- %{last_30_days: usage_cycle()}
- ```
-
- Given only a user as input, the usage is queried from across all the sites that the
- user owns. Alternatively, given an optional argument of `site_ids`, the usage from
- across all those sites is queried instead.
- """
- @spec monthly_pageview_usage(User.t(), list() | nil) :: monthly_pageview_usage()
- def monthly_pageview_usage(user, site_ids \\ nil)
-
- def monthly_pageview_usage(user, nil) do
- monthly_pageview_usage(user, Plausible.Sites.owned_site_ids(user))
- end
-
- def monthly_pageview_usage(user, site_ids) do
- active_subscription? = Subscriptions.active?(user.subscription)
-
- if active_subscription? && user.subscription.last_bill_date do
- [:current_cycle, :last_cycle, :penultimate_cycle]
- |> Task.async_stream(fn cycle ->
- %{cycle => usage_cycle(user, cycle, site_ids)}
- end)
- |> Enum.map(fn {:ok, cycle_usage} -> cycle_usage end)
- |> Enum.reduce(%{}, &Map.merge/2)
- else
- %{last_30_days: usage_cycle(user, :last_30_days, site_ids)}
- end
- end
-
- @spec usage_cycle(User.t(), :last_30_days | cycle(), list() | nil, Date.t()) :: usage_cycle()
- def usage_cycle(user, cycle, owned_site_ids \\ nil, today \\ Date.utc_today())
-
- def usage_cycle(user, cycle, nil, today) do
- usage_cycle(user, cycle, Plausible.Sites.owned_site_ids(user), today)
- end
-
- def usage_cycle(_user, :last_30_days, owned_site_ids, today) do
- date_range = Date.range(Date.shift(today, day: -30), today)
-
- {pageviews, custom_events} =
- Plausible.Stats.Clickhouse.usage_breakdown(owned_site_ids, date_range)
-
- %{
- date_range: date_range,
- pageviews: pageviews,
- custom_events: custom_events,
- total: pageviews + custom_events
- }
- end
-
- def usage_cycle(user, cycle, owned_site_ids, today) do
- user = Users.with_subscription(user)
- last_bill_date = user.subscription.last_bill_date
-
- normalized_last_bill_date =
- Date.shift(last_bill_date, month: Timex.diff(today, last_bill_date, :months))
-
- date_range =
- case cycle do
- :current_cycle ->
- Date.range(
- normalized_last_bill_date,
- Date.shift(normalized_last_bill_date, month: 1, day: -1)
- )
-
- :last_cycle ->
- Date.range(
- Date.shift(normalized_last_bill_date, month: -1),
- Date.shift(normalized_last_bill_date, day: -1)
- )
-
- :penultimate_cycle ->
- Date.range(
- Date.shift(normalized_last_bill_date, month: -2),
- Date.shift(normalized_last_bill_date, day: -1, month: -1)
- )
- end
-
- {pageviews, custom_events} =
- Plausible.Stats.Clickhouse.usage_breakdown(owned_site_ids, date_range)
-
- %{
- date_range: date_range,
- pageviews: pageviews,
- custom_events: custom_events,
- total: pageviews + custom_events
- }
- end
-
- @spec team_member_usage(User.t(), Keyword.t()) :: non_neg_integer()
- @doc """
- Returns the total count of team members associated with the user's sites.
-
- * The given user (i.e. the owner) is not counted as a team member.
-
- * Pending invitations (but not ownership transfers) are counted as team
- members even before accepted.
-
- * Users are counted uniquely - i.e. even if an account is associated with
- many sites owned by the given user, they still count as one team member.
-
- ### Options
-
- * `exclude_emails` - a list of emails to not count towards the usage. This
- allows us to exclude a user from being counted as a team member when
- checking whether a site invitation can be created for that same user.
-
- * `pending_ownership_site_ids` - a list of site IDs from which to count
- additional team member usage. Without this option, usage is queried only
- across sites owned by the given user.
- """
- def team_member_usage(user, opts \\ [])
-
- def team_member_usage(%User{} = user, opts) do
- exclude_emails = Keyword.get(opts, :exclude_emails, []) ++ [user.email]
-
- q =
- user
- |> Plausible.Sites.owned_site_ids()
- |> query_team_member_emails()
-
- q =
- case Keyword.get(opts, :pending_ownership_site_ids) do
- [_ | _] = site_ids -> union(q, ^query_team_member_emails(site_ids))
- _ -> q
- end
-
- from(u in subquery(q),
- where: u.email not in ^exclude_emails,
- distinct: u.email
- )
- |> Plausible.Repo.aggregate(:count)
- end
-
- def query_team_member_emails(site_ids) do
- memberships_q =
- from sm in Site.Membership,
- where: sm.site_id in ^site_ids,
- inner_join: u in assoc(sm, :user),
- select: %{email: u.email}
-
- invitations_q =
- from i in Plausible.Auth.Invitation,
- where: i.site_id in ^site_ids and i.role != :owner,
- select: %{email: i.email}
-
- union(memberships_q, ^invitations_q)
- end
-
- @spec features_usage(User.t() | nil, list() | nil) :: [atom()]
- @doc """
- Given only a user, this function returns the features used across all the
- sites this user owns + StatsAPI if the user has a configured Stats API key.
-
- Given a user, and a list of site_ids, returns the features used by those
- sites instead + StatsAPI if the user has a configured Stats API key.
-
- The user can also be passed as `nil`, in which case we will never return
- Stats API as a used feature.
- """
- def features_usage(user, site_ids \\ nil)
-
- def features_usage(%User{} = user, nil) do
- site_ids = Plausible.Sites.owned_site_ids(user)
- features_usage(user, site_ids)
- end
-
- def features_usage(%User{} = user, site_ids) when is_list(site_ids) do
- site_scoped_feature_usage = features_usage(nil, site_ids)
-
- stats_api_used? =
- from(a in Plausible.Auth.ApiKey, where: a.user_id == ^user.id)
- |> Plausible.Repo.exists?()
-
- if stats_api_used? do
- site_scoped_feature_usage ++ [Feature.StatsAPI]
- else
- site_scoped_feature_usage
- end
- end
-
- def features_usage(nil, site_ids) when is_list(site_ids) do
- props_usage_q =
- from s in Site,
- where: s.id in ^site_ids and fragment("cardinality(?) > 0", s.allowed_event_props)
-
- revenue_goals_usage_q =
- from g in Plausible.Goal,
- where: g.site_id in ^site_ids and not is_nil(g.currency)
-
- queries =
- on_ee do
- funnels_usage_q = from f in "funnels", where: f.site_id in ^site_ids
-
- [
- {Feature.Props, props_usage_q},
- {Feature.Funnels, funnels_usage_q},
- {Feature.RevenueGoals, revenue_goals_usage_q}
- ]
- else
- [
- {Feature.Props, props_usage_q},
- {Feature.RevenueGoals, revenue_goals_usage_q}
- ]
- end
-
- Enum.reduce(queries, [], fn {feature, query}, acc ->
- if Plausible.Repo.exists?(query), do: acc ++ [feature], else: acc
- end)
- end
-end
diff --git a/lib/plausible/billing/site_locker.ex b/lib/plausible/billing/site_locker.ex
index 3db1640505..f3f82e5c8e 100644
--- a/lib/plausible/billing/site_locker.ex
+++ b/lib/plausible/billing/site_locker.ex
@@ -16,8 +16,13 @@ defmodule Plausible.Billing.SiteLocker do
user = Plausible.Users.with_subscription(user)
- # TODO: Use team version once we start switching writes.
- case Plausible.Billing.check_needs_to_upgrade(user) do
+ team =
+ case Plausible.Teams.get_by_owner(user) do
+ {:ok, team} -> team
+ _ -> nil
+ end
+
+ case Plausible.Teams.Billing.check_needs_to_upgrade(team) do
{:needs_to_upgrade, :grace_period_ended} ->
set_lock_status_for(user, true)
@@ -67,8 +72,14 @@ defmodule Plausible.Billing.SiteLocker do
@spec send_grace_period_end_email(Plausible.Auth.User.t()) :: Plausible.Mailer.result()
def send_grace_period_end_email(user) do
- usage = Plausible.Teams.Adapter.Read.Billing.monthly_pageview_usage(user)
- suggested_plan = Plausible.Billing.Plans.suggest(user, usage.last_cycle.total)
+ team =
+ case Plausible.Teams.get_by_owner(user) do
+ {:ok, team} -> team
+ _ -> nil
+ end
+
+ usage = Plausible.Teams.Billing.monthly_pageview_usage(team)
+ suggested_plan = Plausible.Billing.Plans.suggest(team, usage.last_cycle.total)
user
|> PlausibleWeb.Email.dashboard_locked(usage, suggested_plan)
diff --git a/lib/plausible/plugins/api/capabilities.ex b/lib/plausible/plugins/api/capabilities.ex
index d6d65a7db9..3ac6f240bb 100644
--- a/lib/plausible/plugins/api/capabilities.ex
+++ b/lib/plausible/plugins/api/capabilities.ex
@@ -13,11 +13,11 @@ defmodule Plausible.Plugins.API.Capabilities do
features =
if site do
- site = Plausible.Repo.preload(site, :owner)
+ site = Plausible.Repo.preload(site, :team)
Feature.list()
|> Enum.map(fn mod ->
- result = mod.check_availability(site.owner)
+ result = mod.check_availability(site.team)
feature = mod |> Module.split() |> List.last()
{feature, result == :ok}
end)
diff --git a/lib/plausible/site/admin.ex b/lib/plausible/site/admin.ex
index 09881e600a..1422a62e7f 100644
--- a/lib/plausible/site/admin.ex
+++ b/lib/plausible/site/admin.ex
@@ -131,13 +131,10 @@ defmodule Plausible.SiteAdmin do
{:error, "Please select at least one site from the list"}
end
- defp transfer_ownership_direct(conn, sites, %{"email" => email}) do
- current_user = conn.assigns.current_user
-
+ defp transfer_ownership_direct(_conn, sites, %{"email" => email}) do
with {:ok, new_owner} <- Plausible.Auth.get_user_by(email: email),
{:ok, _} <-
Plausible.Site.Memberships.bulk_transfer_ownership_direct(
- current_user,
sites,
new_owner
) do
diff --git a/lib/plausible/site/memberships.ex b/lib/plausible/site/memberships.ex
index 73a8be7d7d..9f381ed6ef 100644
--- a/lib/plausible/site/memberships.ex
+++ b/lib/plausible/site/memberships.ex
@@ -19,7 +19,7 @@ defmodule Plausible.Site.Memberships do
defdelegate bulk_create_invitation(sites, inviter, invitee_email, role, opts),
to: Memberships.CreateInvitation
- defdelegate bulk_transfer_ownership_direct(current_user, sites, new_owner),
+ defdelegate bulk_transfer_ownership_direct(sites, new_owner),
to: Memberships.AcceptInvitation
@spec any?(Auth.User.t()) :: boolean()
@@ -37,37 +37,4 @@ defmodule Plausible.Site.Memberships do
)
)
end
-
- @spec all_pending_ownerships(String.t()) :: list()
- def all_pending_ownerships(email) do
- pending_ownership_invitation_q(email)
- |> Repo.all()
- end
-
- @spec pending_ownerships?(String.t()) :: boolean()
- def pending_ownerships?(email) do
- pending_ownership_invitation_q(email)
- |> Repo.exists?()
- end
-
- @spec any_or_pending?(Plausible.Auth.User.t()) :: boolean()
- def any_or_pending?(user) do
- invitation_query =
- from(i in Plausible.Auth.Invitation,
- where: i.email == ^user.email,
- select: 1
- )
-
- from(sm in Plausible.Site.Membership,
- where: sm.user_id == ^user.id or exists(invitation_query),
- select: 1
- )
- |> Repo.exists?()
- end
-
- defp pending_ownership_invitation_q(email) do
- from(i in Plausible.Auth.Invitation,
- where: i.email == ^email and i.role == ^:owner
- )
- end
end
diff --git a/lib/plausible/site/memberships/accept_invitation.ex b/lib/plausible/site/memberships/accept_invitation.ex
index 90d265a3aa..4677cbb374 100644
--- a/lib/plausible/site/memberships/accept_invitation.ex
+++ b/lib/plausible/site/memberships/accept_invitation.ex
@@ -35,12 +35,12 @@ defmodule Plausible.Site.Memberships.AcceptInvitation do
| Ecto.Changeset.t()
| :no_plan
- @spec bulk_transfer_ownership_direct(Auth.User.t(), [Site.t()], Auth.User.t()) ::
+ @spec bulk_transfer_ownership_direct([Site.t()], Auth.User.t()) ::
{:ok, [Site.Membership.t()]} | {:error, transfer_error()}
- def bulk_transfer_ownership_direct(current_user, sites, new_owner) do
+ def bulk_transfer_ownership_direct(sites, new_owner) do
Repo.transaction(fn ->
for site <- sites do
- case transfer_ownership(current_user, site, new_owner) do
+ case transfer_ownership(site, new_owner) do
{:ok, membership} ->
membership
@@ -63,15 +63,17 @@ defmodule Plausible.Site.Memberships.AcceptInvitation do
end
end
- defp transfer_ownership(current_user, site, new_owner) do
+ defp transfer_ownership(site, new_owner) do
+ site = Repo.preload(site, :team)
+
with :ok <-
- Plausible.Teams.Adapter.Read.Invitations.ensure_transfer_valid(
- current_user,
- site,
+ Plausible.Teams.Invitations.ensure_transfer_valid(
+ site.team,
new_owner,
:owner
),
- :ok <- Plausible.Teams.Adapter.Read.Ownership.ensure_can_take_ownership(site, new_owner) do
+ {:ok, new_team} = Plausible.Teams.get_or_create(new_owner),
+ :ok <- Plausible.Teams.Invitations.ensure_can_take_ownership(site, new_team) do
membership = get_or_create_owner_membership(site, new_owner)
multi = add_and_transfer_ownership(site, membership, new_owner)
@@ -92,16 +94,16 @@ defmodule Plausible.Site.Memberships.AcceptInvitation do
defp do_accept_ownership_transfer(invitation, user) do
membership = get_or_create_membership(invitation, user)
- site = invitation.site
+ site = Repo.preload(invitation.site, :team)
with :ok <-
- Plausible.Teams.Adapter.Read.Invitations.ensure_transfer_valid(
- user,
- site,
+ Plausible.Teams.Invitations.ensure_transfer_valid(
+ site.team,
user,
:owner
),
- :ok <- Plausible.Teams.Adapter.Read.Ownership.ensure_can_take_ownership(site, user) do
+ {:ok, team} = Plausible.Teams.get_or_create(user),
+ :ok <- Plausible.Teams.Invitations.ensure_can_take_ownership(site, team) do
site
|> add_and_transfer_ownership(membership, user)
|> Multi.delete(:invitation, invitation)
diff --git a/lib/plausible/site/memberships/create_invitation.ex b/lib/plausible/site/memberships/create_invitation.ex
index c084c25101..45e903e01a 100644
--- a/lib/plausible/site/memberships/create_invitation.ex
+++ b/lib/plausible/site/memberships/create_invitation.ex
@@ -5,9 +5,9 @@ defmodule Plausible.Site.Memberships.CreateInvitation do
"""
alias Plausible.Auth.{User, Invitation}
- alias Plausible.{Site, Sites, Site.Membership}
- alias Plausible.Billing.Quota
- import Ecto.Query
+ alias Plausible.Site
+ alias Plausible.Repo
+ alias Plausible.Teams
use Plausible
@type invite_error() ::
@@ -32,7 +32,7 @@ defmodule Plausible.Site.Memberships.CreateInvitation do
as an ownership transfer and requires the inviter to be the owner of the site.
"""
def create_invitation(site, inviter, invitee_email, role) do
- Plausible.Repo.transaction(fn ->
+ Repo.transaction(fn ->
do_invite(site, inviter, invitee_email, role)
end)
end
@@ -40,7 +40,7 @@ defmodule Plausible.Site.Memberships.CreateInvitation do
@spec bulk_create_invitation([Site.t()], User.t(), String.t(), atom(), Keyword.t()) ::
{:ok, [Invitation.t()]} | {:error, invite_error()}
def bulk_create_invitation(sites, inviter, invitee_email, role, opts \\ []) do
- Plausible.Repo.transaction(fn ->
+ Repo.transaction(fn ->
for site <- sites do
do_invite(site, inviter, invitee_email, role, opts)
end
@@ -50,125 +50,56 @@ defmodule Plausible.Site.Memberships.CreateInvitation do
defp do_invite(site, inviter, invitee_email, role, opts \\ []) do
attrs = %{email: invitee_email, role: role, site_id: site.id, inviter_id: inviter.id}
- with site <- Plausible.Repo.preload(site, :owner),
+ with site <- Repo.preload(site, [:owner, :team]),
:ok <-
- Plausible.Teams.Adapter.Read.Invitations.check_invitation_permissions(
+ Teams.Invitations.check_invitation_permissions(
site,
inviter,
role,
opts
),
:ok <-
- Plausible.Teams.Adapter.Read.Invitations.check_team_member_limit(
- inviter,
- site,
+ Teams.Invitations.check_team_member_limit(
+ site.team,
role,
invitee_email
),
invitee = Plausible.Auth.find_user_by(email: invitee_email),
:ok <-
- Plausible.Teams.Adapter.Read.Invitations.ensure_transfer_valid(
- inviter,
- site,
+ Teams.Invitations.ensure_transfer_valid(
+ site.team,
invitee,
role
),
:ok <-
- Plausible.Teams.Adapter.Read.Invitations.ensure_new_membership(
- inviter,
+ Teams.Invitations.ensure_new_membership(
site,
invitee,
role
),
%Ecto.Changeset{} = changeset <- Invitation.new(attrs),
- {:ok, invitation} <- Plausible.Repo.insert(changeset) do
- Plausible.Teams.Invitations.invite_sync(site, invitation)
+ {:ok, invitation} <- Repo.insert(changeset) do
+ Teams.Invitations.invite_sync(site, invitation)
- Plausible.Teams.Adapter.Read.Invitations.send_invitation_email(inviter, invitation, invitee)
+ send_invitation_email(inviter, invitation, invitee)
invitation
else
- {:error, cause} -> Plausible.Repo.rollback(cause)
+ {:error, cause} -> Repo.rollback(cause)
end
end
- @doc false
- def check_invitation_permissions(site, inviter, requested_role, opts) do
- check_permissions? = Keyword.get(opts, :check_permissions, true)
-
- if check_permissions? do
- required_roles = if requested_role == :owner, do: [:owner], else: [:admin, :owner]
-
- membership_query =
- from(m in Membership,
- where: m.user_id == ^inviter.id and m.site_id == ^site.id and m.role in ^required_roles
- )
-
- if Plausible.Repo.exists?(membership_query), do: :ok, else: {:error, :forbidden}
- else
- :ok
- end
- end
-
- @doc false
- def send_invitation_email(invitation, invitee) do
- invitation = Plausible.Repo.preload(invitation, [:site, :inviter])
-
- email =
- case {invitee, invitation.role} do
- {invitee, :owner} ->
- PlausibleWeb.Email.ownership_transfer_request(
- invitation.email,
- invitation.invitation_id,
- invitation.site,
- invitation.inviter,
- invitee
- )
-
- {nil, _role} ->
- PlausibleWeb.Email.new_user_invitation(
- invitation.email,
- invitation.invitation_id,
- invitation.site,
- invitation.inviter
- )
-
- {%User{}, _role} ->
- PlausibleWeb.Email.existing_user_invitation(
- invitation.email,
- invitation.site,
- invitation.inviter
- )
- end
-
- Plausible.Mailer.send(email)
- end
-
- @doc false
- def ensure_new_membership(_site, _invitee, :owner) do
- :ok
- end
-
- def ensure_new_membership(site, invitee, _role) do
- if invitee && Sites.is_member?(invitee.id, site) do
- {:error, :already_a_member}
+ defp send_invitation_email(inviter, invitation, invitee) do
+ if invitation.role == :owner do
+ Teams.SiteTransfer
+ |> Repo.get_by!(transfer_id: invitation.invitation_id, initiator_id: inviter.id)
+ |> Repo.preload([:site, :initiator])
+ |> Teams.Invitations.send_invitation_email(invitee)
else
- :ok
+ Teams.GuestInvitation
+ |> Repo.get_by!(invitation_id: invitation.invitation_id)
+ |> Repo.preload([:site, team_invitation: :inviter])
+ |> Teams.Invitations.send_invitation_email(invitee)
end
end
-
- @doc false
- def check_team_member_limit(_site, :owner, _invitee_email) do
- :ok
- end
-
- def check_team_member_limit(site, _role, invitee_email) do
- site = Plausible.Repo.preload(site, :owner)
- limit = Quota.Limits.team_member_limit(site.owner)
- usage = Quota.Usage.team_member_usage(site.owner, exclude_emails: [invitee_email])
-
- if Quota.below_limit?(usage, limit),
- do: :ok,
- else: {:error, {:over_limit, limit}}
- end
end
diff --git a/lib/plausible/site/memberships/invitations.ex b/lib/plausible/site/memberships/invitations.ex
index ac11ecd5c1..dd2b55af33 100644
--- a/lib/plausible/site/memberships/invitations.ex
+++ b/lib/plausible/site/memberships/invitations.ex
@@ -5,7 +5,6 @@ defmodule Plausible.Site.Memberships.Invitations do
import Ecto.Query, only: [from: 2]
- alias Plausible.Site
alias Plausible.Auth
alias Plausible.Repo
alias Plausible.Billing.Feature
@@ -48,45 +47,4 @@ defmodule Plausible.Site.Memberships.Invitations do
:ok
end
-
- @spec ensure_transfer_valid(Site.t(), Auth.User.t() | nil, Site.Membership.role()) ::
- :ok | {:error, :transfer_to_self}
- def ensure_transfer_valid(%Site{} = site, %Auth.User{} = new_owner, :owner) do
- if Plausible.Sites.role(new_owner.id, site) == :owner do
- {:error, :transfer_to_self}
- else
- :ok
- end
- end
-
- def ensure_transfer_valid(_site, _invitee, _role) do
- :ok
- end
-
- on_ee do
- alias Plausible.Billing.Quota
-
- @spec ensure_can_take_ownership(Site.t(), Auth.User.t()) ::
- :ok | {:error, Quota.Limits.over_limits_error() | :no_plan}
- def ensure_can_take_ownership(site, new_owner) do
- site = Repo.preload(site, :owner)
- new_owner = Plausible.Users.with_subscription(new_owner)
- plan = Plausible.Billing.Plans.get_subscription_plan(new_owner.subscription)
-
- active_subscription? = Plausible.Billing.Subscriptions.active?(new_owner.subscription)
-
- if active_subscription? && plan != :free_10k do
- new_owner
- |> Quota.Usage.usage(pending_ownership_site_ids: [site.id])
- |> Quota.ensure_within_plan_limits(plan)
- else
- {:error, :no_plan}
- end
- end
- else
- @spec ensure_can_take_ownership(Site.t(), Auth.User.t()) :: :ok
- def ensure_can_take_ownership(_site, _new_owner) do
- :ok
- end
- end
end
diff --git a/lib/plausible/sites.ex b/lib/plausible/sites.ex
index f79b8687b1..cd99d77f71 100644
--- a/lib/plausible/sites.ex
+++ b/lib/plausible/sites.ex
@@ -8,6 +8,7 @@ defmodule Plausible.Sites do
alias Plausible.Auth
alias Plausible.Repo
alias Plausible.Site
+ alias Plausible.Teams
alias Plausible.Site.SharedLink
require Plausible.Site.UserPreference
@@ -55,7 +56,7 @@ defmodule Plausible.Sites do
@spec set_option(Auth.User.t(), Site.t(), atom(), any()) :: Site.UserPreference.t()
def set_option(user, site, option, value) when option in Site.UserPreference.options() do
- Plausible.Teams.Adapter.Read.Sites.get_for_user!(user, site.domain)
+ Plausible.Sites.get_for_user!(user, site.domain)
user
|> Site.UserPreference.changeset(site, %{option => value})
@@ -68,10 +69,85 @@ defmodule Plausible.Sites do
)
end
- defdelegate list(user, pagination_params, opts \\ []), to: Plausible.Teams.Adapter.Read.Sites
+ defdelegate list(user, pagination_params, opts \\ []), to: Plausible.Teams.Sites
defdelegate list_with_invitations(user, pagination_params, opts \\ []),
- to: Plausible.Teams.Adapter.Read.Sites
+ to: Plausible.Teams.Sites
+
+ def list_people(site) do
+ owner_membership =
+ from(
+ tm in Teams.Membership,
+ where: tm.team_id == ^site.team_id,
+ where: tm.role == :owner,
+ select: %Plausible.Site.Membership{
+ user_id: tm.user_id,
+ role: tm.role
+ }
+ )
+ |> Repo.one!()
+
+ memberships =
+ from(
+ gm in Teams.GuestMembership,
+ inner_join: tm in assoc(gm, :team_membership),
+ where: gm.site_id == ^site.id,
+ select: %Plausible.Site.Membership{
+ user_id: tm.user_id,
+ role:
+ fragment(
+ """
+ CASE
+ WHEN ? = 'editor' THEN 'admin'
+ ELSE ?
+ END
+ """,
+ gm.role,
+ gm.role
+ )
+ }
+ )
+ |> Repo.all()
+
+ memberships = Repo.preload([owner_membership | memberships], :user)
+
+ invitations =
+ from(
+ gi in Teams.GuestInvitation,
+ inner_join: ti in assoc(gi, :team_invitation),
+ where: gi.site_id == ^site.id,
+ select: %Plausible.Auth.Invitation{
+ invitation_id: gi.invitation_id,
+ email: ti.email,
+ role:
+ fragment(
+ """
+ CASE
+ WHEN ? = 'editor' THEN 'admin'
+ ELSE ?
+ END
+ """,
+ gi.role,
+ gi.role
+ )
+ }
+ )
+ |> Repo.all()
+
+ site_transfers =
+ from(
+ st in Teams.SiteTransfer,
+ where: st.site_id == ^site.id,
+ select: %Plausible.Auth.Invitation{
+ invitation_id: st.transfer_id,
+ email: st.email,
+ role: :owner
+ }
+ )
+ |> Repo.all()
+
+ %{memberships: memberships, invitations: site_transfers ++ invitations}
+ end
@spec for_user_query(Auth.User.t()) :: Ecto.Query.t()
def for_user_query(user) do
@@ -83,42 +159,46 @@ defmodule Plausible.Sites do
end
def create(user, params) do
- with :ok <- Plausible.Teams.Adapter.Read.Billing.ensure_can_add_new_site(user) do
- Ecto.Multi.new()
- |> Ecto.Multi.put(:site_changeset, Site.new(params))
- |> Ecto.Multi.run(:create_team, fn _repo, _context ->
- Plausible.Teams.get_or_create(user)
- end)
- |> Ecto.Multi.run(:clear_changed_from, fn
- _repo, %{site_changeset: %{changes: %{domain: domain}}} ->
- case Plausible.Teams.Adapter.Read.Sites.get_for_user(user, domain, [:owner]) do
- %Site{domain_changed_from: ^domain} = site ->
- site
- |> Ecto.Changeset.change()
- |> Ecto.Changeset.put_change(:domain_changed_from, nil)
- |> Ecto.Changeset.put_change(:domain_changed_at, nil)
- |> Repo.update()
-
- _ ->
- {:ok, :ignore}
- end
-
- _repo, _context ->
- {:ok, :ignore}
- end)
- |> Ecto.Multi.insert(:site, fn %{site_changeset: site, create_team: team} ->
- Ecto.Changeset.put_assoc(site, :team, team)
- end)
- |> Ecto.Multi.insert(:site_membership, fn %{site: site} ->
- Site.Membership.new(site, user)
- end)
- |> maybe_start_trial(user)
- |> Ecto.Multi.run(:sync_team, fn _repo, %{user: user} ->
- Plausible.Teams.sync_team(user)
- {:ok, nil}
- end)
- |> Repo.transaction()
- end
+ Ecto.Multi.new()
+ |> Ecto.Multi.put(:site_changeset, Site.new(params))
+ |> Ecto.Multi.run(:create_team, fn _repo, _context ->
+ Plausible.Teams.get_or_create(user)
+ end)
+ |> Ecto.Multi.run(:ensure_can_add_new_site, fn _repo, %{create_team: team} ->
+ case Plausible.Teams.Billing.ensure_can_add_new_site(team) do
+ :ok -> {:ok, :proceed}
+ error -> error
+ end
+ end)
+ |> Ecto.Multi.run(:clear_changed_from, fn
+ _repo, %{site_changeset: %{changes: %{domain: domain}}} ->
+ case Plausible.Sites.get_for_user(user, domain, [:owner]) do
+ %Site{domain_changed_from: ^domain} = site ->
+ site
+ |> Ecto.Changeset.change()
+ |> Ecto.Changeset.put_change(:domain_changed_from, nil)
+ |> Ecto.Changeset.put_change(:domain_changed_at, nil)
+ |> Repo.update()
+
+ _ ->
+ {:ok, :ignore}
+ end
+
+ _repo, _context ->
+ {:ok, :ignore}
+ end)
+ |> Ecto.Multi.insert(:site, fn %{site_changeset: site, create_team: team} ->
+ Ecto.Changeset.put_assoc(site, :team, team)
+ end)
+ |> Ecto.Multi.insert(:site_membership, fn %{site: site} ->
+ Site.Membership.new(site, user)
+ end)
+ |> maybe_start_trial(user)
+ |> Ecto.Multi.run(:sync_team, fn _repo, %{user: user} ->
+ Plausible.Teams.sync_team(user)
+ {:ok, nil}
+ end)
+ |> Repo.transaction()
end
defp maybe_start_trial(multi, user) do
@@ -231,6 +311,55 @@ defmodule Plausible.Sites do
locked
end
+ def get_for_user!(user, domain, roles \\ [:owner, :admin, :viewer]) do
+ roles = translate_roles(roles)
+
+ site =
+ if :super_admin in roles and Plausible.Auth.is_super_admin?(user.id) do
+ get_by_domain!(domain)
+ else
+ user.id
+ |> get_for_user_query(domain, List.delete(roles, :super_admin))
+ |> Repo.one!()
+ end
+
+ Repo.preload(site, :team)
+ end
+
+ def get_for_user(user, domain, roles \\ [:owner, :admin, :viewer]) do
+ roles = translate_roles(roles)
+
+ if :super_admin in roles and Plausible.Auth.is_super_admin?(user.id) do
+ get_by_domain(domain)
+ else
+ user.id
+ |> get_for_user_query(domain, List.delete(roles, :super_admin))
+ |> Repo.one()
+ end
+ end
+
+ defp translate_roles(roles) do
+ Enum.map(roles, fn
+ :admin -> :editor
+ role -> role
+ end)
+ end
+
+ defp get_for_user_query(user_id, domain, roles) do
+ roles = Enum.map(roles, &to_string/1)
+
+ from(s in Plausible.Site,
+ join: t in assoc(s, :team),
+ join: tm in assoc(t, :team_memberships),
+ left_join: gm in assoc(tm, :guest_memberships),
+ where: tm.user_id == ^user_id,
+ where: coalesce(gm.role, tm.role) in ^roles,
+ where: s.domain == ^domain or s.domain_changed_from == ^domain,
+ where: is_nil(gm.id) or gm.site_id == s.id,
+ select: s
+ )
+ end
+
def role(user_id, site) do
Repo.one(
from(sm in Site.Membership,
diff --git a/lib/plausible/teams.ex b/lib/plausible/teams.ex
index 3c981d55fb..32c9154aa1 100644
--- a/lib/plausible/teams.ex
+++ b/lib/plausible/teams.ex
@@ -9,6 +9,15 @@ defmodule Plausible.Teams do
alias Plausible.Repo
use Plausible
+ @spec get_owner(Teams.Team.t()) ::
+ {:ok, Plausible.Auth.User.t()} | {:error, :no_owner | :multiple_owners}
+ def get_owner(team) do
+ case Repo.preload(team, :owner).owner do
+ nil -> {:error, :no_owner}
+ owner_user -> {:ok, owner_user}
+ end
+ end
+
@spec on_trial?(Teams.Team.t() | nil) :: boolean()
on_ee do
def on_trial?(nil), do: false
@@ -29,10 +38,6 @@ defmodule Plausible.Teams do
Date.diff(team.trial_expiry_date, Date.utc_today())
end
- def read_team_schemas?(user) do
- FunWithFlags.enabled?(:read_team_schemas, for: user)
- end
-
def with_subscription(team) do
Repo.preload(team, subscription: last_subscription_query())
end
@@ -77,6 +82,12 @@ defmodule Plausible.Teams do
)
end
+ def has_active_sites?(team) do
+ team
+ |> owned_sites()
+ |> Enum.any?(&Plausible.Sites.has_stats?/1)
+ end
+
@doc """
Create (when necessary) and load team relation for provided site.
diff --git a/lib/plausible/teams/adapter.ex b/lib/plausible/teams/adapter.ex
deleted file mode 100644
index 25eebecfa2..0000000000
--- a/lib/plausible/teams/adapter.ex
+++ /dev/null
@@ -1,48 +0,0 @@
-defmodule Plausible.Teams.Adapter do
- @moduledoc """
- Commonly used teams-transition functions
- """
- alias Plausible.Teams
-
- defmacro __using__(_) do
- quote do
- alias Plausible.Teams
- import Teams.Adapter
- end
- end
-
- def user_or_team(user) do
- switch(user,
- team_fn: &Function.identity/1,
- user_fn: &Function.identity/1
- )
- end
-
- def switch(switch_on, opts \\ [])
-
- def switch(%Plausible.Auth.User{} = user, opts) do
- team_fn = Keyword.fetch!(opts, :team_fn)
- user_fn = Keyword.fetch!(opts, :user_fn)
-
- if Teams.read_team_schemas?(user) do
- team =
- case Teams.get_by_owner(user) do
- {:ok, team} -> team
- {:error, _} -> nil
- end
-
- team = Plausible.Teams.with_subscription(team)
-
- team_fn.(team)
- else
- user = Plausible.Users.with_subscription(user)
- user_fn.(user)
- end
- end
-
- def switch(team_or_nil, opts) do
- team_fn = Keyword.fetch!(opts, :team_fn)
- team = Plausible.Teams.with_subscription(team_or_nil)
- team_fn.(team)
- end
-end
diff --git a/lib/plausible/teams/adapter/read/billing.ex b/lib/plausible/teams/adapter/read/billing.ex
deleted file mode 100644
index e93974a3c8..0000000000
--- a/lib/plausible/teams/adapter/read/billing.ex
+++ /dev/null
@@ -1,190 +0,0 @@
-defmodule Plausible.Teams.Adapter.Read.Billing do
- @moduledoc """
- Transition adapter for new schema reads
- """
- use Plausible.Teams.Adapter
-
- def quota_usage(user, opts \\ []) do
- switch(user,
- team_fn: &Plausible.Teams.Billing.quota_usage(&1, opts),
- user_fn: &Plausible.Billing.Quota.Usage.usage(&1, opts)
- )
- end
-
- def allow_next_upgrade_override?(user) do
- switch(user,
- team_fn: &(&1 && &1.allow_next_upgrade_override),
- user_fn: & &1.allow_next_upgrade_override
- )
- end
-
- def change_plan(user, new_plan_id) do
- switch(user,
- team_fn: &Plausible.Teams.Billing.change_plan(&1, new_plan_id),
- user_fn: &Plausible.Billing.change_plan(&1, new_plan_id)
- )
- end
-
- def enterprise_configured?(nil), do: false
-
- def enterprise_configured?(user) do
- switch(user,
- team_fn: &Plausible.Teams.Billing.enterprise_configured?/1,
- user_fn: &Plausible.Auth.enterprise_configured?/1
- )
- end
-
- def latest_enterprise_plan_with_prices(user, customer_ip) do
- switch(user,
- team_fn: &Plausible.Teams.Billing.latest_enterprise_plan_with_price(&1, customer_ip),
- user_fn: &Plausible.Billing.Plans.latest_enterprise_plan_with_price(&1, customer_ip)
- )
- end
-
- def has_active_subscription?(user) do
- switch(user,
- team_fn: &Plausible.Teams.Billing.has_active_subscription?/1,
- user_fn: &Plausible.Billing.has_active_subscription?/1
- )
- end
-
- def active_subscription_for(user) do
- switch(user,
- team_fn: &Plausible.Teams.Billing.active_subscription_for/1,
- user_fn: &Plausible.Billing.active_subscription_for/1
- )
- end
-
- def get_subscription(user) do
- case user_or_team(user) do
- %{subscription: subscription} -> subscription
- _ -> nil
- end
- end
-
- def team_member_limit(user) do
- switch(user,
- team_fn: &Teams.Billing.team_member_limit/1,
- user_fn: &Plausible.Billing.Quota.Limits.team_member_limit/1
- )
- end
-
- def team_member_usage(user, opts \\ []) do
- switch(user,
- team_fn: &Teams.Billing.team_member_usage(&1, opts),
- user_fn: &Plausible.Billing.Quota.Usage.team_member_usage(&1, opts)
- )
- end
-
- def monthly_pageview_limit(user) do
- switch(user,
- team_fn: &Teams.Billing.monthly_pageview_limit/1,
- user_fn: &Plausible.Billing.Quota.Limits.monthly_pageview_limit/1
- )
- end
-
- def monthly_pageview_usage(user, site_ids \\ nil) do
- switch(
- user,
- team_fn: &Teams.Billing.monthly_pageview_usage(&1, site_ids),
- user_fn: &Plausible.Billing.Quota.Usage.monthly_pageview_usage(&1, site_ids)
- )
- end
-
- def check_needs_to_upgrade(user) do
- switch(
- user,
- team_fn: &Teams.Billing.check_needs_to_upgrade/1,
- user_fn: &Plausible.Billing.check_needs_to_upgrade/1
- )
- end
-
- def site_limit(user) do
- switch(
- user,
- team_fn: &Teams.Billing.site_limit/1,
- user_fn: &Plausible.Billing.Quota.Limits.site_limit/1
- )
- end
-
- def ensure_can_add_new_site(user) do
- switch(
- user,
- team_fn: &Teams.Billing.ensure_can_add_new_site/1,
- user_fn: &Plausible.Billing.Quota.ensure_can_add_new_site/1
- )
- end
-
- def site_usage(user) do
- switch(user,
- team_fn: &Teams.Billing.site_usage/1,
- user_fn: &Plausible.Billing.Quota.Usage.site_usage/1
- )
- end
-
- use Plausible
-
- on_ee do
- def check_feature_availability_for_stats_api(user) do
- {unlimited_trial?, subscription?} =
- switch(user,
- team_fn: fn team ->
- team = Plausible.Teams.with_subscription(team)
- unlimited_trial? = is_nil(team) or is_nil(team.trial_expiry_date)
-
- subscription? =
- not is_nil(team) and Plausible.Billing.Subscriptions.active?(team.subscription)
-
- {unlimited_trial?, subscription?}
- end,
- user_fn: fn user ->
- user = Plausible.Users.with_subscription(user)
- unlimited_trial? = is_nil(user.trial_expiry_date)
- subscription? = Plausible.Billing.Subscriptions.active?(user.subscription)
-
- {unlimited_trial?, subscription?}
- end
- )
-
- pre_business_tier_account? =
- NaiveDateTime.before?(user.inserted_at, Plausible.Billing.Plans.business_tier_launch())
-
- cond do
- !subscription? && unlimited_trial? && pre_business_tier_account? ->
- :ok
-
- !subscription? && unlimited_trial? && !pre_business_tier_account? ->
- {:error, :upgrade_required}
-
- true ->
- check_feature_availability(Plausible.Billing.Feature.StatsAPI, user)
- end
- end
- else
- def check_feature_availability_for_stats_api(_user), do: :ok
- end
-
- def check_feature_availability(feature, user) do
- switch(user,
- team_fn: fn team_or_nil ->
- cond do
- feature.free?() -> :ok
- feature in Teams.Billing.allowed_features_for(team_or_nil) -> :ok
- true -> {:error, :upgrade_required}
- end
- end,
- user_fn: fn user ->
- cond do
- feature.free?() -> :ok
- feature in Plausible.Billing.Quota.Limits.allowed_features_for(user) -> :ok
- true -> {:error, :upgrade_required}
- end
- end
- )
- end
-
- def suggest_by_usage(user, usage_during_cycle) do
- subscription = get_subscription(user)
- Plausible.Billing.Plans.suggest_by_usage(subscription, usage_during_cycle)
- end
-end
diff --git a/lib/plausible/teams/adapter/read/invitations.ex b/lib/plausible/teams/adapter/read/invitations.ex
deleted file mode 100644
index 9170df3829..0000000000
--- a/lib/plausible/teams/adapter/read/invitations.ex
+++ /dev/null
@@ -1,120 +0,0 @@
-defmodule Plausible.Teams.Adapter.Read.Invitations do
- @moduledoc """
- Transition adapter for new schema reads
- """
- use Plausible
- use Plausible.Teams.Adapter
-
- alias Plausible.Repo
-
- def check_invitation_permissions(site, inviter, role, opts) do
- switch(
- inviter,
- team_fn: fn _ ->
- Plausible.Teams.Invitations.check_invitation_permissions(
- site,
- inviter,
- role,
- opts
- )
- end,
- user_fn: fn _ ->
- Plausible.Site.Memberships.CreateInvitation.check_invitation_permissions(
- site,
- inviter,
- role,
- opts
- )
- end
- )
- end
-
- def check_team_member_limit(inviter, site, role, invitee_email) do
- switch(
- inviter,
- team_fn: fn _ ->
- site_team = Repo.preload(site, :team).team
-
- Plausible.Teams.Invitations.check_team_member_limit(
- site_team,
- role,
- invitee_email
- )
- end,
- user_fn: fn _ ->
- Plausible.Site.Memberships.CreateInvitation.check_team_member_limit(
- site,
- role,
- invitee_email
- )
- end
- )
- end
-
- def ensure_transfer_valid(current_user, site, invitee, role) do
- switch(
- current_user,
- team_fn: fn _ ->
- site_team = Repo.preload(site, :team).team
-
- Plausible.Teams.Invitations.ensure_transfer_valid(
- site_team,
- invitee,
- role
- )
- end,
- user_fn: fn _ ->
- Plausible.Site.Memberships.Invitations.ensure_transfer_valid(
- site,
- invitee,
- role
- )
- end
- )
- end
-
- def ensure_new_membership(inviter, site, invitee, role) do
- switch(
- inviter,
- team_fn: fn _ ->
- Plausible.Teams.Invitations.ensure_new_membership(
- site,
- invitee,
- role
- )
- end,
- user_fn: fn _ ->
- Plausible.Site.Memberships.CreateInvitation.ensure_new_membership(
- site,
- invitee,
- role
- )
- end
- )
- end
-
- def send_invitation_email(inviter, invitation, invitee) do
- switch(
- inviter,
- team_fn: fn _ ->
- if invitation.role == :owner do
- Teams.SiteTransfer
- |> Repo.get_by!(transfer_id: invitation.invitation_id, initiator_id: inviter.id)
- |> Repo.preload([:site, :initiator])
- |> Plausible.Teams.Invitations.send_invitation_email(invitee)
- else
- Teams.GuestInvitation
- |> Repo.get_by!(invitation_id: invitation.invitation_id)
- |> Repo.preload([:site, team_invitation: :inviter])
- |> Plausible.Teams.Invitations.send_invitation_email(invitee)
- end
- end,
- user_fn: fn _ ->
- Plausible.Site.Memberships.CreateInvitation.send_invitation_email(
- invitation,
- invitee
- )
- end
- )
- end
-end
diff --git a/lib/plausible/teams/adapter/read/ownership.ex b/lib/plausible/teams/adapter/read/ownership.ex
deleted file mode 100644
index 9801d326fb..0000000000
--- a/lib/plausible/teams/adapter/read/ownership.ex
+++ /dev/null
@@ -1,78 +0,0 @@
-defmodule Plausible.Teams.Adapter.Read.Ownership do
- @moduledoc """
- Transition adapter for new schema reads
- """
- use Plausible
- use Plausible.Teams.Adapter
- alias Plausible.Site
- alias Plausible.Auth
- alias Plausible.Site.Memberships.Invitations
-
- def all_pending_site_transfers(email, user) do
- switch(user,
- team_fn: fn _ -> Plausible.Teams.Memberships.all_pending_site_transfers(email) end,
- user_fn: fn _ -> Plausible.Site.Memberships.all_pending_ownerships(email) end
- )
- end
-
- def get_owner(site, user) do
- switch(user,
- team_fn: fn team ->
- case Teams.Sites.get_owner(team) do
- {:ok, user} -> user
- _ -> nil
- end
- end,
- user_fn: fn _ ->
- Plausible.Repo.preload(site, :owner).owner
- end
- )
- end
-
- def ensure_can_take_ownership(site, user) do
- switch(
- user,
- team_fn: &Teams.Invitations.ensure_can_take_ownership(site, &1),
- user_fn: &Invitations.ensure_can_take_ownership(site, &1)
- )
- end
-
- def has_sites?(user) do
- switch(
- user,
- team_fn: fn _ -> Teams.Users.has_sites?(user, include_pending?: true) end,
- user_fn: &Site.Memberships.any_or_pending?/1
- )
- end
-
- def owns_sites?(user, sites) do
- switch(
- user,
- team_fn: fn _ -> Teams.Users.owns_sites?(user, include_pending?: true) end,
- user_fn: fn user ->
- Enum.any?(sites.entries, fn site ->
- length(site.invitations) > 0 && List.first(site.invitations).role == :owner
- end) ||
- Auth.user_owns_sites?(user)
- end
- )
- end
-
- on_ee do
- def check_feature_access(site, new_owner) do
- missing_features =
- Plausible.Billing.Quota.Usage.features_usage(nil, [site.id])
- |> Enum.filter(&(&1.check_availability(new_owner) != :ok))
-
- if missing_features == [] do
- :ok
- else
- {:error, {:missing_features, missing_features}}
- end
- end
- else
- def check_feature_access(_site, _new_owner) do
- :ok
- end
- end
-end
diff --git a/lib/plausible/teams/adapter/read/sites.ex b/lib/plausible/teams/adapter/read/sites.ex
deleted file mode 100644
index 8d7ffc1a65..0000000000
--- a/lib/plausible/teams/adapter/read/sites.ex
+++ /dev/null
@@ -1,276 +0,0 @@
-defmodule Plausible.Teams.Adapter.Read.Sites do
- @moduledoc """
- Transition adapter for new schema reads
- """
-
- use Plausible.Teams.Adapter
-
- import Ecto.Query
-
- alias Plausible.Repo
- alias Plausible.Site
- alias Plausible.Teams
-
- def list(user, pagination_params, opts \\ []) do
- switch(
- user,
- team_fn: fn _ -> Plausible.Teams.Sites.list(user, pagination_params, opts) end,
- user_fn: fn _ -> old_list(user, pagination_params, opts) end
- )
- end
-
- def list_with_invitations(user, pagination_params, opts \\ []) do
- switch(
- user,
- team_fn: fn _ ->
- Plausible.Teams.Sites.list_with_invitations(user, pagination_params, opts)
- end,
- user_fn: fn _ -> old_list_with_invitations(user, pagination_params, opts) end
- )
- end
-
- defp old_list(user, pagination_params, opts) do
- domain_filter = Keyword.get(opts, :filter_by_domain)
-
- from(s in Site,
- left_join: up in Site.UserPreference,
- on: up.site_id == s.id and up.user_id == ^user.id,
- inner_join: sm in assoc(s, :memberships),
- on: sm.user_id == ^user.id,
- select: %{
- s
- | pinned_at: selected_as(up.pinned_at, :pinned_at),
- entry_type:
- selected_as(
- fragment(
- """
- CASE
- WHEN ? IS NOT NULL THEN 'pinned_site'
- ELSE 'site'
- END
- """,
- up.pinned_at
- ),
- :entry_type
- )
- },
- order_by: [asc: selected_as(:entry_type), desc: selected_as(:pinned_at), asc: s.domain],
- preload: [memberships: sm]
- )
- |> maybe_filter_by_domain(domain_filter)
- |> Repo.paginate(pagination_params)
- end
-
- defp old_list_with_invitations(user, pagination_params, opts) do
- domain_filter = Keyword.get(opts, :filter_by_domain)
-
- result =
- from(s in Site,
- left_join: up in Site.UserPreference,
- on: up.site_id == s.id and up.user_id == ^user.id,
- left_join: i in assoc(s, :invitations),
- on: i.email == ^user.email,
- left_join: sm in assoc(s, :memberships),
- on: sm.user_id == ^user.id,
- where: not is_nil(sm.id) or not is_nil(i.id),
- select: %{
- s
- | pinned_at: selected_as(up.pinned_at, :pinned_at),
- entry_type:
- selected_as(
- fragment(
- """
- CASE
- WHEN ? IS NOT NULL THEN 'invitation'
- WHEN ? IS NOT NULL THEN 'pinned_site'
- ELSE 'site'
- END
- """,
- i.id,
- up.pinned_at
- ),
- :entry_type
- )
- },
- order_by: [asc: selected_as(:entry_type), desc: selected_as(:pinned_at), asc: s.domain],
- preload: [memberships: sm, invitations: i]
- )
- |> maybe_filter_by_domain(domain_filter)
- |> Repo.paginate(pagination_params)
-
- # Populating `site` preload on `invitation`
- # without requesting it from database.
- # Necessary for invitation modals logic.
- entries =
- Enum.map(result.entries, fn
- %{invitations: [invitation]} = site ->
- site = %{site | invitations: [], memberships: []}
- invitation = %{invitation | site: site}
- %{site | invitations: [invitation]}
-
- site ->
- site
- end)
-
- %{result | entries: entries}
- end
-
- def list_people(site, user) do
- if Plausible.Teams.read_team_schemas?(user) do
- owner_membership =
- from(
- tm in Teams.Membership,
- where: tm.team_id == ^site.team_id,
- where: tm.role == :owner,
- select: %Plausible.Site.Membership{
- user_id: tm.user_id,
- role: tm.role
- }
- )
- |> Repo.one!()
-
- memberships =
- from(
- gm in Teams.GuestMembership,
- inner_join: tm in assoc(gm, :team_membership),
- where: gm.site_id == ^site.id,
- select: %Plausible.Site.Membership{
- user_id: tm.user_id,
- role:
- fragment(
- """
- CASE
- WHEN ? = 'editor' THEN 'admin'
- ELSE ?
- END
- """,
- gm.role,
- gm.role
- )
- }
- )
- |> Repo.all()
-
- memberships = Repo.preload([owner_membership | memberships], :user)
-
- invitations =
- from(
- gi in Teams.GuestInvitation,
- inner_join: ti in assoc(gi, :team_invitation),
- where: gi.site_id == ^site.id,
- select: %Plausible.Auth.Invitation{
- invitation_id: gi.invitation_id,
- email: ti.email,
- role:
- fragment(
- """
- CASE
- WHEN ? = 'editor' THEN 'admin'
- ELSE ?
- END
- """,
- gi.role,
- gi.role
- )
- }
- )
- |> Repo.all()
-
- site_transfers =
- from(
- st in Teams.SiteTransfer,
- where: st.site_id == ^site.id,
- select: %Plausible.Auth.Invitation{
- invitation_id: st.transfer_id,
- email: st.email,
- role: :owner
- }
- )
- |> Repo.all()
-
- %{memberships: memberships, invitations: site_transfers ++ invitations}
- else
- site
- |> Repo.preload([:invitations, memberships: :user])
- |> Map.take([:memberships, :invitations])
- end
- end
-
- def get_for_user!(user, domain, roles \\ [:owner, :admin, :viewer]) do
- {query_fn, roles} = for_user_query_and_roles(user, roles)
-
- site =
- if :super_admin in roles and Plausible.Auth.is_super_admin?(user.id) do
- Plausible.Sites.get_by_domain!(domain)
- else
- user.id
- |> query_fn.(domain, List.delete(roles, :super_admin))
- |> Repo.one!()
- end
-
- Repo.preload(site, :team)
- end
-
- def get_for_user(user, domain, roles \\ [:owner, :admin, :viewer]) do
- {query_fn, roles} = for_user_query_and_roles(user, roles)
-
- if :super_admin in roles and Plausible.Auth.is_super_admin?(user.id) do
- Plausible.Sites.get_by_domain(domain)
- else
- user.id
- |> query_fn.(domain, List.delete(roles, :super_admin))
- |> Repo.one()
- end
- end
-
- defp for_user_query_and_roles(user, roles) do
- switch(
- user,
- team_fn: fn _ ->
- translated_roles =
- Enum.map(roles, fn
- :admin -> :editor
- other -> other
- end)
-
- {&new_get_for_user_query/3, translated_roles}
- end,
- user_fn: fn _ ->
- {&old_get_for_user_query/3, roles}
- end
- )
- end
-
- defp old_get_for_user_query(user_id, domain, roles) do
- from(s in Plausible.Site,
- join: sm in Plausible.Site.Membership,
- on: sm.site_id == s.id,
- where: sm.user_id == ^user_id,
- where: sm.role in ^roles,
- where: s.domain == ^domain or s.domain_changed_from == ^domain,
- select: s
- )
- end
-
- defp new_get_for_user_query(user_id, domain, roles) do
- roles = Enum.map(roles, &to_string/1)
-
- from(s in Plausible.Site,
- join: t in assoc(s, :team),
- join: tm in assoc(t, :team_memberships),
- left_join: gm in assoc(tm, :guest_memberships),
- where: tm.user_id == ^user_id,
- where: coalesce(gm.role, tm.role) in ^roles,
- where: s.domain == ^domain or s.domain_changed_from == ^domain,
- where: is_nil(gm.id) or gm.site_id == s.id,
- select: s
- )
- end
-
- defp maybe_filter_by_domain(query, domain)
- when byte_size(domain) >= 1 and byte_size(domain) <= 64 do
- where(query, [s], ilike(s.domain, ^"%#{domain}%"))
- end
-
- defp maybe_filter_by_domain(query, _), do: query
-end
diff --git a/lib/plausible/teams/adapter/read/teams.ex b/lib/plausible/teams/adapter/read/teams.ex
deleted file mode 100644
index bd92db4f0c..0000000000
--- a/lib/plausible/teams/adapter/read/teams.ex
+++ /dev/null
@@ -1,27 +0,0 @@
-defmodule Plausible.Teams.Adapter.Read.Teams do
- @moduledoc """
- Transition adapter for new schema reads
- """
- use Plausible.Teams.Adapter
-
- def trial_expiry_date(user) do
- switch(user,
- team_fn: &(&1 && &1.trial_expiry_date),
- user_fn: & &1.trial_expiry_date
- )
- end
-
- def on_trial?(user) do
- switch(user,
- team_fn: &Plausible.Teams.on_trial?/1,
- user_fn: &Plausible.Users.on_trial?/1
- )
- end
-
- def trial_days_left(user) do
- switch(user,
- team_fn: &Plausible.Teams.trial_days_left/1,
- user_fn: &Plausible.Users.trial_days_left/1
- )
- end
-end
diff --git a/lib/plausible/teams/billing.ex b/lib/plausible/teams/billing.ex
index c0672eb352..d1e219878c 100644
--- a/lib/plausible/teams/billing.ex
+++ b/lib/plausible/teams/billing.ex
@@ -1,10 +1,13 @@
defmodule Plausible.Teams.Billing do
@moduledoc false
+ use Plausible
+
import Ecto.Query
alias Plausible.Billing.EnterprisePlan
alias Plausible.Billing.Plans
+ alias Plausible.Billing.Subscription
alias Plausible.Billing.Subscriptions
alias Plausible.Repo
alias Plausible.Teams
@@ -18,6 +21,29 @@ defmodule Plausible.Teams.Billing do
@limit_sites_since ~D[2021-05-05]
@site_limit_for_trials 10
+ @type cycles_usage() :: %{cycle() => usage_cycle()}
+
+ @typep cycle :: :current_cycle | :last_cycle | :penultimate_cycle
+
+ @typep usage_cycle :: %{
+ date_range: Date.Range.t(),
+ pageviews: non_neg_integer(),
+ custom_events: non_neg_integer(),
+ total: non_neg_integer()
+ }
+
+ @typep last_30_days_usage() :: %{:last_30_days => usage_cycle()}
+ @typep monthly_pageview_usage() :: cycles_usage() | last_30_days_usage()
+
+ def get_subscription(nil), do: nil
+
+ def get_subscription(%Teams.Team{subscription: %Subscription{} = subscription}),
+ do: subscription
+
+ def get_subscription(%Teams.Team{} = team) do
+ Teams.with_subscription(team).subscription
+ end
+
def change_plan(team, new_plan_id) do
subscription = active_subscription_for(team)
plan = Plausible.Billing.Plans.find(new_plan_id)
@@ -33,7 +59,29 @@ defmodule Plausible.Teams.Billing do
with :ok <-
Plausible.Billing.Quota.ensure_within_plan_limits(usage, plan, limit_checking_opts),
- do: Plausible.Billing.do_change_plan(subscription, new_plan_id)
+ do: do_change_plan(subscription, new_plan_id)
+ end
+
+ defp do_change_plan(subscription, new_plan_id) do
+ res =
+ Plausible.Billing.paddle_api().update_subscription(subscription.paddle_subscription_id, %{
+ plan_id: new_plan_id
+ })
+
+ case res do
+ {:ok, response} ->
+ amount = :erlang.float_to_binary(response["next_payment"]["amount"] / 1, decimals: 2)
+
+ Subscription.changeset(subscription, %{
+ paddle_plan_id: Integer.to_string(response["plan_id"]),
+ next_bill_amount: amount,
+ next_bill_date: response["next_payment"]["date"]
+ })
+ |> Repo.update()
+
+ e ->
+ e
+ end
end
def enterprise_configured?(nil), do: false
@@ -65,12 +113,17 @@ defmodule Plausible.Teams.Billing do
|> Repo.exists?()
end
+ def active_subscription_for(nil), do: nil
+
def active_subscription_for(team) do
team
|> active_subscription_query()
|> Repo.one()
end
+ @spec check_needs_to_upgrade(Teams.Team.t() | nil) ::
+ {:needs_to_upgrade, :no_trial | :no_active_subscription | :grace_period_ended}
+ | :no_upgrade_needed
def check_needs_to_upgrade(nil), do: {:needs_to_upgrade, :no_trial}
def check_needs_to_upgrade(team) do
@@ -97,6 +150,11 @@ defmodule Plausible.Teams.Billing do
end
end
+ @doc """
+ Enterprise plans are always allowed to add more sites (even when
+ over limit) to avoid service disruption. Their usage is checked
+ in a background job instead (see `check_usage.ex`).
+ """
def ensure_can_add_new_site(nil) do
:ok
end
@@ -132,6 +190,10 @@ defmodule Plausible.Teams.Billing do
end
end
+ @doc """
+ Returns the number of sites the given team owns.
+ """
+ @spec site_usage(Teams.Team.t()) :: non_neg_integer()
def site_usage(nil), do: 0
def site_usage(team) do
@@ -169,6 +231,21 @@ defmodule Plausible.Teams.Billing do
end
end
+ @doc """
+ Returns a full usage report for the team.
+
+ ### Options
+
+ * `pending_ownership_site_ids` - a list of site IDs from which to count
+ additional usage. This allows us to look at the total usage from pending
+ ownerships and owned sites at the same time, which is useful, for example,
+ when deciding whether to let the team owner upgrade to a plan, or accept a
+ site ownership.
+
+ * `with_features` - when `true`, the returned map will contain features
+ usage. Also counts usage from `pending_ownership_site_ids` if that option
+ is given.
+ """
def quota_usage(team, opts \\ []) do
team = Teams.with_subscription(team)
with_features? = Keyword.get(opts, :with_features, false)
@@ -226,6 +303,31 @@ defmodule Plausible.Teams.Billing do
end
end
+ @doc """
+ Queries the ClickHouse database for the monthly pageview usage. If the given team's
+ subscription is `active`, `past_due`, or a `deleted` (but not yet expired), a map
+ with the following structure is returned:
+
+ ```elixir
+ %{
+ current_cycle: usage_cycle(),
+ last_cycle: usage_cycle(),
+ penultimate_cycle: usage_cycle()
+ }
+ ```
+
+ In all other cases of the subscription status (or a `free_10k` subscription which
+ does not have a `last_bill_date` defined) - the following structure is returned:
+
+ ```elixir
+ %{last_30_days: usage_cycle()}
+ ```
+
+ Given only a team as input, the usage is queried from across all the sites that the
+ team owns. Alternatively, given an optional argument of `site_ids`, the usage from
+ across all those sites is queried instead.
+ """
+ @spec monthly_pageview_usage(Teams.Team.t(), list() | nil) :: monthly_pageview_usage()
def monthly_pageview_usage(team, site_ids \\ nil)
def monthly_pageview_usage(team, nil) do
@@ -251,10 +353,33 @@ defmodule Plausible.Teams.Billing do
end
end
+ @spec team_member_usage(Teams.Team.t(), Keyword.t()) :: non_neg_integer()
+ @doc """
+ Returns the total count of team members associated with the team's sites.
+
+ * The given team's owner is not counted as a team member.
+
+ * Pending invitations (but not ownership transfers) are counted as team
+ members even before accepted.
+
+ * Users are counted uniquely - i.e. even if an account is associated with
+ many sites owned by the given user, they still count as one team member.
+
+ ### Options
+
+ * `exclude_emails` - a list of emails to not count towards the usage. This
+ allows us to exclude a user from being counted as a team member when
+ checking whether a site invitation can be created for that same user.
+
+ * `pending_ownership_site_ids` - a list of site IDs from which to count
+ additional team member usage. Without this option, usage is queried only
+ across sites owned by the given user.
+ """
+ def team_member_usage(team, opts \\ [])
def team_member_usage(nil, _), do: 0
def team_member_usage(team, opts) do
- {:ok, owner} = Teams.Sites.get_owner(team)
+ {:ok, owner} = Teams.get_owner(team)
exclude_emails = Keyword.get(opts, :exclude_emails, []) ++ [owner.email]
pending_site_ids = Keyword.get(opts, :pending_ownership_site_ids, [])
@@ -324,6 +449,17 @@ defmodule Plausible.Teams.Billing do
}
end
+ @spec features_usage(Teams.Team.t() | nil, list() | nil) :: [atom()]
+ @doc """
+ Given only a team, this function returns the features used across all the
+ sites this team owns + StatsAPI if any team user has a configured Stats API key.
+
+ Given a team, and a list of site_ids, returns the features used by those
+ sites instead + StatsAPI if any user in the team has a configured Stats API key.
+
+ The team can also be passed as `nil`, in which case we will never return
+ Stats API as a used feature.
+ """
def features_usage(team, site_ids \\ nil)
def features_usage(nil, nil), do: []
@@ -337,7 +473,7 @@ defmodule Plausible.Teams.Billing do
site_scoped_feature_usage = features_usage(nil, owned_site_ids)
stats_api_used? =
- Plausible.Repo.exists?(
+ Repo.exists?(
from tm in Plausible.Teams.Membership,
as: :team_membership,
where: tm.team_id == ^team.id,
@@ -355,8 +491,34 @@ defmodule Plausible.Teams.Billing do
end
end
- def features_usage(nil, owned_site_ids) when is_list(owned_site_ids) do
- Plausible.Billing.Quota.Usage.features_usage(nil, owned_site_ids)
+ def features_usage(nil, site_ids) when is_list(site_ids) do
+ props_usage_q =
+ from s in Plausible.Site,
+ where: s.id in ^site_ids and fragment("cardinality(?) > 0", s.allowed_event_props)
+
+ revenue_goals_usage_q =
+ from g in Plausible.Goal,
+ where: g.site_id in ^site_ids and not is_nil(g.currency)
+
+ queries =
+ on_ee do
+ funnels_usage_q = from f in "funnels", where: f.site_id in ^site_ids
+
+ [
+ {Feature.Props, props_usage_q},
+ {Feature.Funnels, funnels_usage_q},
+ {Feature.RevenueGoals, revenue_goals_usage_q}
+ ]
+ else
+ [
+ {Feature.Props, props_usage_q},
+ {Feature.RevenueGoals, revenue_goals_usage_q}
+ ]
+ end
+
+ Enum.reduce(queries, [], fn {feature, query}, acc ->
+ if Repo.exists?(query), do: acc ++ [feature], else: acc
+ end)
end
defp query_team_member_emails(team, pending_ownership_site_ids, exclude_emails) do
diff --git a/lib/plausible/teams/invitations.ex b/lib/plausible/teams/invitations.ex
index 2b4bdf859d..161d9f8cf1 100644
--- a/lib/plausible/teams/invitations.ex
+++ b/lib/plausible/teams/invitations.ex
@@ -1,6 +1,8 @@
defmodule Plausible.Teams.Invitations do
@moduledoc false
+ use Plausible
+
import Ecto.Query
alias Plausible.Billing
@@ -274,7 +276,7 @@ defmodule Plausible.Teams.Invitations do
Repo.delete_all(from gm in Teams.GuestMembership, where: gm.id in ^old_guest_ids)
:ok = Teams.Memberships.prune_guests(prior_team)
- {:ok, prior_owner} = Teams.Sites.get_owner(prior_team)
+ {:ok, prior_owner} = Teams.get_owner(prior_team)
{:ok, prior_owner_team_membership} = create_team_membership(team, :guest, prior_owner, now)
@@ -312,19 +314,25 @@ defmodule Plausible.Teams.Invitations do
:ok
end
- def ensure_can_take_ownership(_site, nil), do: {:error, :no_plan}
+ on_ee do
+ def ensure_can_take_ownership(_site, nil), do: {:error, :no_plan}
- def ensure_can_take_ownership(site, team) do
- team = Teams.with_subscription(team)
- plan = Billing.Plans.get_subscription_plan(team.subscription)
- active_subscription? = Billing.Subscriptions.active?(team.subscription)
+ def ensure_can_take_ownership(site, team) do
+ team = Teams.with_subscription(team)
+ plan = Billing.Plans.get_subscription_plan(team.subscription)
+ active_subscription? = Billing.Subscriptions.active?(team.subscription)
- if active_subscription? and plan != :free_10k do
- team
- |> Teams.Billing.quota_usage(pending_ownership_site_ids: [site.id])
- |> Billing.Quota.ensure_within_plan_limits(plan)
- else
- {:error, :no_plan}
+ if active_subscription? and plan != :free_10k do
+ team
+ |> Teams.Billing.quota_usage(pending_ownership_site_ids: [site.id])
+ |> Billing.Quota.ensure_within_plan_limits(plan)
+ else
+ {:error, :no_plan}
+ end
+ end
+ else
+ def ensure_can_take_ownership(_site, _team) do
+ :ok
end
end
diff --git a/lib/plausible/teams/sites.ex b/lib/plausible/teams/sites.ex
index 3e08a8fd07..62e01d9ada 100644
--- a/lib/plausible/teams/sites.ex
+++ b/lib/plausible/teams/sites.ex
@@ -47,23 +47,6 @@ defmodule Plausible.Teams.Sites do
end
end
- @spec get_owner(Teams.Team.t()) :: {:ok, Auth.User.t()} | {:error, :no_owner | :multiple_owners}
- def get_owner(team) do
- owner_query =
- from(
- tm in Teams.Membership,
- inner_join: u in assoc(tm, :user),
- where: tm.team_id == ^team.id and tm.role == :owner,
- select: u
- )
-
- case Repo.all(owner_query) do
- [owner_user] -> {:ok, owner_user}
- [] -> {:error, :no_owner}
- _ -> {:error, :multiple_owners}
- end
- end
-
@spec list(Auth.User.t(), map(), [list_opt()]) :: Scrivener.Page.t()
def list(user, pagination_params, opts \\ []) do
domain_filter = Keyword.get(opts, :filter_by_domain)
diff --git a/lib/plausible_web/components/billing/billing.ex b/lib/plausible_web/components/billing/billing.ex
index 01b2b0a97f..d975a8ba14 100644
--- a/lib/plausible_web/components/billing/billing.ex
+++ b/lib/plausible_web/components/billing/billing.ex
@@ -189,7 +189,7 @@ defmodule PlausibleWeb.Components.Billing do
</div>
<.styled_link
:if={
- not (Plausible.Teams.Adapter.Read.Billing.enterprise_configured?(@user) &&
+ not (Plausible.Teams.Billing.enterprise_configured?(@team) &&
Subscriptions.halted?(@subscription))
}
id="#upgrade-or-change-plan-link"
diff --git a/lib/plausible_web/components/billing/notice.ex b/lib/plausible_web/components/billing/notice.ex
index ab8aae0296..34909cfe54 100644
--- a/lib/plausible_web/components/billing/notice.ex
+++ b/lib/plausible_web/components/billing/notice.ex
@@ -71,7 +71,7 @@ defmodule PlausibleWeb.Components.Billing.Notice do
def premium_feature(assigns) do
~H"""
<.notice
- :if={@feature_mod.check_availability(@billable_user) !== :ok}
+ :if={@feature_mod.check_availability(@current_team) !== :ok}
class="rounded-t-md rounded-b-none"
title="Notice"
{@rest}
diff --git a/lib/plausible_web/components/billing/plan_box.ex b/lib/plausible_web/components/billing/plan_box.ex
index 55bbee0e95..3ffae1f139 100644
--- a/lib/plausible_web/components/billing/plan_box.ex
+++ b/lib/plausible_web/components/billing/plan_box.ex
@@ -175,7 +175,7 @@ defmodule PlausibleWeb.Components.Billing.PlanBox do
change_plan_link_text = change_plan_link_text(assigns)
subscription =
- Plausible.Teams.Adapter.Read.Billing.get_subscription(assigns.current_user)
+ Plausible.Teams.Billing.get_subscription(assigns.current_team)
billing_details_expired =
Subscription.Status.in?(subscription, [
@@ -264,22 +264,18 @@ defmodule PlausibleWeb.Components.Billing.PlanBox do
defp check_usage_within_plan_limits(%{
available: true,
usage: usage,
- current_user: current_user,
+ current_team: current_team,
plan_to_render: plan
}) do
- # At this point, the user is *not guaranteed* to have a `trial_expiry_date`,
- # because in the past we've let users upgrade without that constraint, as
- # well as transfer sites to those accounts. to these accounts we won't be
- # offering an extra pageview limit allowance margin though.
- invited_user? = is_nil(Plausible.Teams.Adapter.Read.Teams.trial_expiry_date(current_user))
-
+ # At this point, the user is *not guaranteed* to have a team,
+ # with ongoing trial.
trial_active_or_ended_recently? =
- not invited_user? &&
- Plausible.Teams.Adapter.Read.Teams.trial_days_left(current_user) >= -10
+ not is_nil(current_team) and not is_nil(current_team.trial_expiry_date) and
+ Plausible.Teams.trial_days_left(current_team) >= -10
limit_checking_opts =
cond do
- Plausible.Teams.Adapter.Read.Billing.allow_next_upgrade_override?(current_user) ->
+ current_team && current_team.allow_next_upgrade_override ->
[ignore_pageview_limit: true]
trial_active_or_ended_recently? && plan.volume == "10k" ->
diff --git a/lib/plausible_web/controllers/billing_controller.ex b/lib/plausible_web/controllers/billing_controller.ex
index d6a7916936..9c05d8f08b 100644
--- a/lib/plausible_web/controllers/billing_controller.ex
+++ b/lib/plausible_web/controllers/billing_controller.ex
@@ -9,16 +9,15 @@ defmodule PlausibleWeb.BillingController do
plug PlausibleWeb.RequireAccountPlug
def ping_subscription(%Plug.Conn{} = conn, _params) do
- subscribed? =
- Plausible.Teams.Adapter.Read.Billing.has_active_subscription?(conn.assigns.current_user)
+ subscribed? = Plausible.Teams.Billing.has_active_subscription?(conn.assigns.current_team)
json(conn, %{is_subscribed: subscribed?})
end
def choose_plan(conn, _params) do
- current_user = conn.assigns.current_user
+ current_team = conn.assigns.current_team
- if Plausible.Teams.Adapter.Read.Billing.enterprise_configured?(current_user) do
+ if Plausible.Teams.Billing.enterprise_configured?(current_team) do
redirect(conn, to: Routes.billing_path(conn, :upgrade_to_enterprise_plan))
else
render(conn, "choose_plan.html",
@@ -29,9 +28,8 @@ defmodule PlausibleWeb.BillingController do
end
def upgrade_to_enterprise_plan(conn, _params) do
- current_user = conn.assigns.current_user
current_team = conn.assigns.current_team
- subscription = Plausible.Teams.Adapter.Read.Billing.get_subscription(current_user)
+ subscription = Plausible.Teams.Billing.get_subscription(current_team)
{latest_enterprise_plan, price} =
Plausible.Teams.Billing.latest_enterprise_plan_with_price(
@@ -72,8 +70,9 @@ defmodule PlausibleWeb.BillingController do
end
def change_plan_preview(conn, %{"plan_id" => new_plan_id}) do
+ current_team = conn.assigns.current_team
current_user = conn.assigns.current_user
- subscription = Plausible.Teams.Adapter.Read.Billing.active_subscription_for(current_user)
+ subscription = Plausible.Teams.Billing.active_subscription_for(current_team)
case preview_subscription(subscription, new_plan_id) do
{:ok, {subscription, preview_info}} ->
@@ -92,6 +91,7 @@ defmodule PlausibleWeb.BillingController do
extra: %{
message: msg,
new_plan_id: new_plan_id,
+ current_team: current_team.id,
user_id: current_user.id
}
)
@@ -103,9 +103,9 @@ defmodule PlausibleWeb.BillingController do
end
def change_plan(conn, %{"new_plan_id" => new_plan_id}) do
- current_user = conn.assigns.current_user
+ current_team = conn.assigns.current_team
- case Plausible.Teams.Adapter.Read.Billing.change_plan(current_user, new_plan_id) do
+ case Plausible.Teams.Billing.change_plan(current_team, new_plan_id) do
{:ok, _subscription} ->
conn
|> put_flash(:success, "Plan changed successfully")
@@ -133,7 +133,8 @@ defmodule PlausibleWeb.BillingController do
errors: inspect(e),
message: msg,
new_plan_id: new_plan_id,
- user_id: current_user.id
+ current_team: current_team.id,
+ user_id: conn.assigns.current_user.id
}
)
diff --git a/lib/plausible_web/controllers/settings_controller.ex b/lib/plausible_web/controllers/settings_controller.ex
index 015696fbce..2795db50de 100644
--- a/lib/plausible_web/controllers/settings_controller.ex
+++ b/lib/plausible_web/controllers/settings_controller.ex
@@ -4,6 +4,7 @@ defmodule PlausibleWeb.SettingsController do
alias Plausible.Auth
alias PlausibleWeb.UserAuth
+ alias Plausible.Teams
require Logger
@@ -20,24 +21,23 @@ defmodule PlausibleWeb.SettingsController do
end
def subscription(conn, _params) do
- current_user = conn.assigns.current_user
- subscription = Plausible.Teams.Adapter.Read.Billing.get_subscription(current_user)
+ current_team = conn.assigns.current_team
+ subscription = Teams.Billing.get_subscription(current_team)
render(conn, :subscription,
layout: {PlausibleWeb.LayoutView, :settings},
subscription: subscription,
- pageview_limit: Plausible.Teams.Adapter.Read.Billing.monthly_pageview_limit(current_user),
- pageview_usage: Plausible.Teams.Adapter.Read.Billing.monthly_pageview_usage(current_user),
- site_usage: Plausible.Teams.Adapter.Read.Billing.site_usage(current_user),
- site_limit: Plausible.Teams.Adapter.Read.Billing.site_limit(current_user),
- team_member_limit: Plausible.Teams.Adapter.Read.Billing.team_member_limit(current_user),
- team_member_usage: Plausible.Teams.Adapter.Read.Billing.team_member_usage(current_user)
+ pageview_limit: Teams.Billing.monthly_pageview_limit(subscription),
+ pageview_usage: Teams.Billing.monthly_pageview_usage(current_team),
+ site_usage: Teams.Billing.site_usage(current_team),
+ site_limit: Teams.Billing.site_limit(current_team),
+ team_member_limit: Teams.Billing.team_member_limit(current_team),
+ team_member_usage: Teams.Billing.team_member_usage(current_team)
)
end
def invoices(conn, _params) do
- subscription =
- Plausible.Teams.Adapter.Read.Billing.get_subscription(conn.assigns.current_user)
+ subscription = Teams.Billing.get_subscription(conn.assigns.current_team)
invoices = Plausible.Billing.paddle_api().get_invoices(subscription)
render(conn, :invoices, layout: {PlausibleWeb.LayoutView, :settings}, invoices: invoices)
diff --git a/lib/plausible_web/controllers/site/membership_controller.ex b/lib/plausible_web/controllers/site/membership_controller.ex
index d74e93b188..c95c8e282b 100644
--- a/lib/plausible_web/controllers/site/membership_controller.ex
+++ b/lib/plausible_web/controllers/site/membership_controller.ex
@@ -26,11 +26,11 @@ defmodule PlausibleWeb.Site.MembershipController do
def invite_member_form(conn, _params) do
site =
conn.assigns.current_user
- |> Plausible.Teams.Adapter.Read.Sites.get_for_user!(conn.assigns.site.domain)
+ |> Plausible.Sites.get_for_user!(conn.assigns.site.domain)
|> Plausible.Repo.preload(:owner)
- limit = Plausible.Teams.Adapter.Read.Billing.team_member_limit(site.owner)
- usage = Plausible.Teams.Adapter.Read.Billing.team_member_usage(site.owner)
+ limit = Plausible.Teams.Billing.team_member_limit(site.team)
+ usage = Plausible.Teams.Billing.team_member_usage(site.team)
below_limit? = Plausible.Billing.Quota.below_limit?(usage, limit)
render(
@@ -47,7 +47,7 @@ defmodule PlausibleWeb.Site.MembershipController do
site_domain = conn.assigns.site.domain
site =
- Plausible.Teams.Adapter.Read.Sites.get_for_user!(conn.assigns.current_user, site_domain)
+ Plausible.Sites.get_for_user!(conn.assigns.current_user, site_domain)
|> Plausible.Repo.preload(:owner)
case Memberships.create_invitation(site, conn.assigns.current_user, email, role) do
@@ -96,7 +96,7 @@ defmodule PlausibleWeb.Site.MembershipController do
site_domain = conn.assigns.site.domain
site =
- Plausible.Teams.Adapter.Read.Sites.get_for_user!(conn.assigns.current_user, site_domain)
+ Plausible.Sites.get_for_user!(conn.assigns.current_user, site_domain)
render(
conn,
@@ -110,7 +110,7 @@ defmodule PlausibleWeb.Site.MembershipController do
site_domain = conn.assigns.site.domain
site =
- Plausible.Teams.Adapter.Read.Sites.get_for_user!(conn.assigns.current_user, site_domain)
+ Plausible.Sites.get_for_user!(conn.assigns.current_user, site_domain)
case Memberships.create_invitation(site, conn.assigns.current_user, email, :owner) do
{:ok, _invitation} ->
diff --git a/lib/plausible_web/controllers/site_controller.ex b/lib/plausible_web/controllers/site_controller.ex
index 3cdf7583da..c45ffa7742 100644
--- a/lib/plausible_web/controllers/site_controller.ex
+++ b/lib/plausible_web/controllers/site_controller.ex
@@ -14,21 +14,21 @@ defmodule PlausibleWeb.SiteController do
def new(conn, params) do
flow = params["flow"] || PlausibleWeb.Flows.register()
- current_user = conn.assigns[:current_user]
+ current_team = conn.assigns.current_team
render(conn, "new.html",
changeset: Plausible.Site.changeset(%Plausible.Site{}),
- site_limit: Plausible.Teams.Adapter.Read.Billing.site_limit(current_user),
- site_limit_exceeded?:
- Plausible.Teams.Adapter.Read.Billing.ensure_can_add_new_site(current_user) != :ok,
+ site_limit: Plausible.Teams.Billing.site_limit(current_team),
+ site_limit_exceeded?: Plausible.Teams.Billing.ensure_can_add_new_site(current_team) != :ok,
form_submit_url: "/sites?flow=#{flow}",
flow: flow
)
end
def create_site(conn, %{"site" => site_params}) do
- user = conn.assigns[:current_user]
- first_site? = Plausible.Teams.Adapter.Read.Billing.site_usage(user) == 0
+ team = conn.assigns.current_team
+ user = conn.assigns.current_user
+ first_site? = Plausible.Teams.Billing.site_usage(team) == 0
flow = conn.params["flow"]
case Sites.create(user, site_params) do
@@ -46,7 +46,7 @@ defmodule PlausibleWeb.SiteController do
)
)
- {:error, {:over_limit, limit}} ->
+ {:error, _, {:over_limit, limit}, _} ->
render(conn, "new.html",
changeset: Plausible.Site.changeset(%Plausible.Site{}),
first_site?: first_site?,
@@ -60,7 +60,7 @@ defmodule PlausibleWeb.SiteController do
render(conn, "new.html",
changeset: changeset,
first_site?: first_site?,
- site_limit: Plausible.Teams.Adapter.Read.Billing.site_limit(user),
+ site_limit: Plausible.Teams.Billing.site_limit(team),
site_limit_exceeded?: false,
flow: flow,
form_submit_url: "/sites?flow=#{flow}"
@@ -122,11 +122,10 @@ defmodule PlausibleWeb.SiteController do
end
def settings_people(conn, _params) do
- current_user = conn.assigns.current_user
site = conn.assigns.site
%{memberships: memberships, invitations: invitations} =
- Plausible.Teams.Adapter.Read.Sites.list_people(site, current_user)
+ Sites.list_people(site)
conn
|> render("settings_people.html",
diff --git a/lib/plausible_web/email.ex b/lib/plausible_web/email.ex
index 0f414d5a7c..0d9383a5dd 100644
--- a/lib/plausible_web/email.ex
+++ b/lib/plausible_web/email.ex
@@ -94,7 +94,13 @@ defmodule PlausibleWeb.Email do
end
def trial_upgrade_email(user, day, usage) do
- suggested_plan = Plausible.Billing.Plans.suggest(user, usage.total)
+ team =
+ case Plausible.Teams.get_by_owner(user) do
+ {:ok, team} -> team
+ _ -> nil
+ end
+
+ suggested_plan = Plausible.Billing.Plans.suggest(team, usage.total)
base_email()
|> to(user)
diff --git a/lib/plausible_web/live/choose_plan.ex b/lib/plausible_web/live/choose_plan.ex
index d5b258a555..db48c399fd 100644
--- a/lib/plausible_web/live/choose_plan.ex
+++ b/lib/plausible_web/live/choose_plan.ex
@@ -18,20 +18,20 @@ defmodule PlausibleWeb.Live.ChoosePlan do
socket
|> assign_new(:pending_ownership_site_ids, fn %{current_user: current_user} ->
current_user.email
- |> Plausible.Teams.Adapter.Read.Ownership.all_pending_site_transfers(current_user)
+ |> Plausible.Teams.Memberships.all_pending_site_transfers()
|> Enum.map(& &1.site_id)
end)
|> assign_new(:usage, fn %{
- current_user: current_user,
+ current_team: current_team,
pending_ownership_site_ids: pending_ownership_site_ids
} ->
- Plausible.Teams.Adapter.Read.Billing.quota_usage(current_user,
+ Plausible.Teams.Billing.quota_usage(current_team,
with_features: true,
pending_ownership_site_ids: pending_ownership_site_ids
)
end)
- |> assign_new(:subscription, fn %{current_user: current_user} ->
- Plausible.Teams.Adapter.Read.Billing.get_subscription(current_user)
+ |> assign_new(:subscription, fn %{current_team: current_team} ->
+ Plausible.Teams.Billing.get_subscription(current_team)
end)
|> assign_new(:owned_plan, fn %{subscription: subscription} ->
Plans.get_regular_plan(subscription, only_non_expired: true)
diff --git a/lib/plausible_web/live/goal_settings.ex b/lib/plausible_web/live/goal_settings.ex
index cdad77967b..e62292e839 100644
--- a/lib/plausible_web/live/goal_settings.ex
+++ b/lib/plausible_web/live/goal_settings.ex
@@ -16,7 +16,7 @@ defmodule PlausibleWeb.Live.GoalSettings do
socket
|> assign_new(:site, fn %{current_user: current_user} ->
current_user
- |> Plausible.Teams.Adapter.Read.Sites.get_for_user!(domain, [:owner, :admin, :super_admin])
+ |> Plausible.Sites.get_for_user!(domain, [:owner, :admin, :super_admin])
|> Plausible.Imported.load_import_data()
end)
|> assign_new(:all_goals, fn %{site: site} ->
diff --git a/lib/plausible_web/live/imports_exports_settings.ex b/lib/plausible_web/live/imports_exports_settings.ex
index 94a19c5b67..bcfc4a63f6 100644
--- a/lib/plausible_web/live/imports_exports_settings.ex
+++ b/lib/plausible_web/live/imports_exports_settings.ex
@@ -15,7 +15,7 @@ defmodule PlausibleWeb.Live.ImportsExportsSettings do
socket =
socket
|> assign_new(:site, fn %{current_user: current_user} ->
- Plausible.Teams.Adapter.Read.Sites.get_for_user!(current_user, domain, [
+ Plausible.Sites.get_for_user!(current_user, domain, [
:owner,
:admin,
:super_admin
diff --git a/lib/plausible_web/live/installation.ex b/lib/plausible_web/live/installation.ex
index e05ee34ad4..64096ffe4a 100644
--- a/lib/plausible_web/live/installation.ex
+++ b/lib/plausible_web/live/installation.ex
@@ -32,7 +32,7 @@ defmodule PlausibleWeb.Live.Installation do
socket
) do
site =
- Plausible.Teams.Adapter.Read.Sites.get_for_user!(socket.assigns.current_user, domain, [
+ Plausible.Sites.get_for_user!(socket.assigns.current_user, domain, [
:owner,
:admin,
:super_admin,
diff --git a/lib/plausible_web/live/plugins/api/settings.ex b/lib/plausible_web/live/plugins/api/settings.ex
index 582ab3c270..a7963e8af9 100644
--- a/lib/plausible_web/live/plugins/api/settings.ex
+++ b/lib/plausible_web/live/plugins/api/settings.ex
@@ -11,7 +11,7 @@ defmodule PlausibleWeb.Live.Plugins.API.Settings do
socket =
socket
|> assign_new(:site, fn %{current_user: current_user} ->
- Plausible.Teams.Adapter.Read.Sites.get_for_user!(current_user, domain, [
+ Plausible.Sites.get_for_user!(current_user, domain, [
:owner,
:admin,
:super_admin
diff --git a/lib/plausible_web/live/plugins/api/token_form.ex b/lib/plausible_web/live/plugins/api/token_form.ex
index e2fed6458e..eb426b3cea 100644
--- a/lib/plausible_web/live/plugins/api/token_form.ex
+++ b/lib/plausible_web/live/plugins/api/token_form.ex
@@ -19,7 +19,7 @@ defmodule PlausibleWeb.Live.Plugins.API.TokenForm do
socket =
socket
|> assign_new(:site, fn %{current_user: current_user} ->
- Plausible.Teams.Adapter.Read.Sites.get_for_user!(current_user, domain, [
+ Plausible.Sites.get_for_user!(current_user, domain, [
:owner,
:admin,
:super_admin
diff --git a/lib/plausible_web/live/props_settings.ex b/lib/plausible_web/live/props_settings.ex
index 05cb1bc767..5188c62d92 100644
--- a/lib/plausible_web/live/props_settings.ex
+++ b/lib/plausible_web/live/props_settings.ex
@@ -11,7 +11,7 @@ defmodule PlausibleWeb.Live.PropsSettings do
socket =
socket
|> assign_new(:site, fn %{current_user: current_user} ->
- Plausible.Teams.Adapter.Read.Sites.get_for_user!(current_user, domain, [
+ Plausible.Sites.get_for_user!(current_user, domain, [
:owner,
:admin,
:super_admin
diff --git a/lib/plausible_web/live/props_settings/form.ex b/lib/plausible_web/live/props_settings/form.ex
index ada2451358..6a7d7b8243 100644
--- a/lib/plausible_web/live/props_settings/form.ex
+++ b/lib/plausible_web/live/props_settings/form.ex
@@ -18,7 +18,7 @@ defmodule PlausibleWeb.Live.PropsSettings.Form do
socket =
socket
|> assign_new(:site, fn %{current_user: current_user} ->
- Plausible.Teams.Adapter.Read.Sites.get_for_user!(current_user, domain, [
+ Plausible.Sites.get_for_user!(current_user, domain, [
:owner,
:admin,
:super_admin
diff --git a/lib/plausible_web/live/shields/countries.ex b/lib/plausible_web/live/shields/countries.ex
index 400496389d..74398b89ff 100644
--- a/lib/plausible_web/live/shields/countries.ex
+++ b/lib/plausible_web/live/shields/countries.ex
@@ -14,7 +14,7 @@ defmodule PlausibleWeb.Live.Shields.Countries do
socket =
socket
|> assign_new(:site, fn %{current_user: current_user} ->
- Plausible.Teams.Adapter.Read.Sites.get_for_user!(current_user, domain, [
+ Plausible.Sites.get_for_user!(current_user, domain, [
:owner,
:admin,
:super_admin
diff --git a/lib/plausible_web/live/shields/hostnames.ex b/lib/plausible_web/live/shields/hostnames.ex
index 8ec12623ff..d2d10eb402 100644
--- a/lib/plausible_web/live/shields/hostnames.ex
+++ b/lib/plausible_web/live/shields/hostnames.ex
@@ -10,7 +10,7 @@ defmodule PlausibleWeb.Live.Shields.Hostnames do
socket =
socket
|> assign_new(:site, fn %{current_user: current_user} ->
- Plausible.Teams.Adapter.Read.Sites.get_for_user!(current_user, domain, [
+ Plausible.Sites.get_for_user!(current_user, domain, [
:owner,
:admin,
:super_admin
diff --git a/lib/plausible_web/live/shields/ip_addresses.ex b/lib/plausible_web/live/shields/ip_addresses.ex
index f7cb9dfeed..91d71bb1f9 100644
--- a/lib/plausible_web/live/shields/ip_addresses.ex
+++ b/lib/plausible_web/live/shields/ip_addresses.ex
@@ -17,7 +17,7 @@ defmodule PlausibleWeb.Live.Shields.IPAddresses do
socket =
socket
|> assign_new(:site, fn %{current_user: current_user} ->
- Plausible.Teams.Adapter.Read.Sites.get_for_user!(current_user, domain, [
+ Plausible.Sites.get_for_user!(current_user, domain, [
:owner,
:admin,
:super_admin
diff --git a/lib/plausible_web/live/shields/pages.ex b/lib/plausible_web/live/shields/pages.ex
index ff368a2acd..ec86025a7e 100644
--- a/lib/plausible_web/live/shields/pages.ex
+++ b/lib/plausible_web/live/shields/pages.ex
@@ -10,7 +10,7 @@ defmodule PlausibleWeb.Live.Shields.Pages do
socket =
socket
|> assign_new(:site, fn %{current_user: current_user} ->
- Plausible.Teams.Adapter.Read.Sites.get_for_user!(current_user, domain, [
+ Plausible.Sites.get_for_user!(current_user, domain, [
:owner,
:admin,
:super_admin
diff --git a/lib/plausible_web/live/sites.ex b/lib/plausible_web/live/sites.ex
index 7588da5aed..00c57dfdaf 100644
--- a/lib/plausible_web/live/sites.ex
+++ b/lib/plausible_web/live/sites.ex
@@ -27,10 +27,14 @@ defmodule PlausibleWeb.Live.Sites do
|> assign(:params, params)
|> load_sites()
|> assign_new(:has_sites?, fn %{current_user: current_user} ->
- has_sites?(current_user)
+ Plausible.Teams.Users.has_sites?(current_user, include_pending?: true)
end)
- |> assign_new(:needs_to_upgrade, fn %{current_user: current_user, sites: sites} ->
- owns_sites?(current_user, sites) && check_needs_to_upgrade(current_user)
+ |> assign_new(:needs_to_upgrade, fn %{
+ current_user: current_user,
+ current_team: current_team
+ } ->
+ Plausible.Teams.Users.owns_sites?(current_user, include_pending?: true) &&
+ Plausible.Teams.Billing.check_needs_to_upgrade(current_team)
end)
{:noreply, socket}
@@ -640,12 +644,6 @@ defmodule PlausibleWeb.Live.Sites do
{:noreply, socket}
end
- defdelegate has_sites?(user), to: Plausible.Teams.Adapter.Read.Ownership
-
- defdelegate owns_sites?(user, sites), to: Plausible.Teams.Adapter.Read.Ownership
-
- defdelegate check_needs_to_upgrade(user), to: Plausible.Teams.Adapter.Read.Billing
-
defp load_sites(%{assigns: assigns} = socket) do
sites =
Sites.list_with_invitations(assigns.current_user, assigns.params,
@@ -680,7 +678,13 @@ defmodule PlausibleWeb.Live.Sites do
end
defp check_limits(%{role: :owner, site: site} = invitation, user) do
- case ensure_can_take_ownership(site, user) do
+ team =
+ case Plausible.Teams.get_by_owner(user) do
+ {:ok, team} -> team
+ _ -> nil
+ end
+
+ case ensure_can_take_ownership(site, team) do
:ok ->
check_features(invitation, user)
@@ -695,9 +699,7 @@ defmodule PlausibleWeb.Live.Sites do
defp check_limits(invitation, _), do: %{invitation: invitation}
- defdelegate ensure_can_take_ownership(site, user), to: Plausible.Teams.Adapter.Read.Ownership
-
- defdelegate check_feature_access(site, user), to: Plausible.Teams.Adapter.Read.Ownership
+ defdelegate ensure_can_take_ownership(site, team), to: Plausible.Teams.Invitations
def check_features(%{role: :owner, site: site} = invitation, user) do
case check_feature_access(site, user) do
@@ -714,6 +716,24 @@ defmodule PlausibleWeb.Live.Sites do
end
end
+ on_ee do
+ defp check_feature_access(site, new_owner) do
+ missing_features =
+ Plausible.Teams.Billing.features_usage(nil, [site.id])
+ |> Enum.filter(&(&1.check_availability(new_owner) != :ok))
+
+ if missing_features == [] do
+ :ok
+ else
+ {:error, {:missing_features, missing_features}}
+ end
+ end
+ else
+ defp check_feature_access(_site, _new_owner) do
+ :ok
+ end
+ end
+
defp set_filter_text(socket, filter_text) do
uri = socket.assigns.uri
diff --git a/lib/plausible_web/live/verification.ex b/lib/plausible_web/live/verification.ex
index 9308a98f06..44cbaad57a 100644
--- a/lib/plausible_web/live/verification.ex
+++ b/lib/plausible_web/live/verification.ex
@@ -18,7 +18,7 @@ defmodule PlausibleWeb.Live.Verification do
socket
) do
site =
- Plausible.Teams.Adapter.Read.Sites.get_for_user!(socket.assigns.current_user, domain, [
+ Plausible.Sites.get_for_user!(socket.assigns.current_user, domain, [
:owner,
:admin,
:super_admin,
diff --git a/lib/plausible_web/plugs/authorize_public_api.ex b/lib/plausible_web/plugs/authorize_public_api.ex
index 12fbf81bec..90f7acd00d 100644
--- a/lib/plausible_web/plugs/authorize_public_api.ex
+++ b/lib/plausible_web/plugs/authorize_public_api.ex
@@ -134,6 +134,12 @@ defmodule PlausibleWeb.Plugs.AuthorizePublicAPI do
end
defp verify_site_access(api_key, site) do
+ team =
+ case Plausible.Teams.get_by_owner(api_key.user) do
+ {:ok, team} -> team
+ _ -> nil
+ end
+
is_member? = Plausible.Teams.Memberships.site_member?(site, api_key.user)
is_super_admin? = Auth.is_super_admin?(api_key.user_id)
@@ -144,8 +150,7 @@ defmodule PlausibleWeb.Plugs.AuthorizePublicAPI do
Sites.locked?(site) ->
{:error, :site_locked}
- Plausible.Teams.Adapter.Read.Billing.check_feature_availability_for_stats_api(api_key.user) !==
- :ok ->
+ Plausible.Billing.Feature.StatsAPI.check_availability(team) !== :ok ->
{:error, :upgrade_required}
is_member? ->
diff --git a/lib/plausible_web/templates/layout/_notice.html.heex b/lib/plausible_web/templates/layout/_notice.html.heex
index 576939ad89..24e03f001d 100644
--- a/lib/plausible_web/templates/layout/_notice.html.heex
+++ b/lib/plausible_web/templates/layout/_notice.html.heex
@@ -2,28 +2,18 @@
<%= render("_flash.html", assigns) %>
<% end %>
-<%= if @conn.assigns[:current_team] do %>
- <div class="flex flex-col gap-y-2">
- <Notice.active_grace_period
- :if={Plausible.Auth.GracePeriod.active?(@conn.assigns.current_team)}
- enterprise?={
- Plausible.Teams.Adapter.Read.Billing.enterprise_configured?(@conn.assigns.current_team)
- }
- grace_period_end={grace_period_end(@conn.assigns.current_team)}
- />
+<div :if={assigns[:current_team]} class="flex flex-col gap-y-2">
+ <Notice.active_grace_period
+ :if={Plausible.Auth.GracePeriod.active?(@current_team)}
+ enterprise?={Plausible.Teams.Billing.enterprise_configured?(@current_team)}
+ grace_period_end={grace_period_end(@current_team)}
+ />
- <Notice.dashboard_locked :if={Plausible.Auth.GracePeriod.expired?(@conn.assigns.current_team)} />
+ <Notice.dashboard_locked :if={Plausible.Auth.GracePeriod.expired?(@current_team)} />
- <Notice.subscription_cancelled subscription={@conn.assigns.current_team.subscription} />
+ <Notice.subscription_cancelled subscription={@current_team.subscription} />
- <Notice.subscription_past_due
- subscription={@conn.assigns.current_team.subscription}
- class="container"
- />
+ <Notice.subscription_past_due subscription={@current_team.subscription} class="container" />
- <Notice.subscription_paused
- subscription={@conn.assigns.current_team.subscription}
- class="container"
- />
- </div>
-<% end %>
+ <Notice.subscription_paused subscription={@current_team.subscription} class="container" />
+</div>
diff --git a/lib/plausible_web/templates/settings/api_keys.html.heex b/lib/plausible_web/templates/settings/api_keys.html.heex
index d00a5863f5..2743f54378 100644
--- a/lib/plausible_web/templates/settings/api_keys.html.heex
+++ b/lib/plausible_web/templates/settings/api_keys.html.heex
@@ -16,7 +16,7 @@
<.filter_bar filtering_enabled?={false}>
<.button_link
- :if={Plausible.Billing.Feature.StatsAPI.check_availability(@current_user) == :ok}
+ :if={Plausible.Billing.Feature.StatsAPI.check_availability(@current_team) == :ok}
href={Routes.settings_path(@conn, :new_api_key)}
>
New API Key
diff --git a/lib/plausible_web/templates/settings/subscription.html.heex b/lib/plausible_web/templates/settings/subscription.html.heex
index de3b3c7e03..ac3483e6df 100644
--- a/lib/plausible_web/templates/settings/subscription.html.heex
+++ b/lib/plausible_web/templates/settings/subscription.html.heex
@@ -33,7 +33,7 @@
<div class="flex flex-col items-center justify-between sm:flex-row sm:items-start">
<PlausibleWeb.Components.Billing.monthly_quota_box
- user={@current_user}
+ team={@current_team}
subscription={@subscription}
/>
<div class="w-full md:w-1/3 h-32 px-2 py-4 my-4 text-center bg-gray-100 rounded dark:bg-gray-900">
diff --git a/lib/plausible_web/views/auth_view.ex b/lib/plausible_web/views/auth_view.ex
index 29b4613b1f..23bc2d2c0e 100644
--- a/lib/plausible_web/views/auth_view.ex
+++ b/lib/plausible_web/views/auth_view.ex
@@ -8,7 +8,7 @@ defmodule PlausibleWeb.AuthView do
def subscription_quota(nil, _options), do: "Free trial"
def subscription_quota(subscription, options) do
- pageview_limit = Plausible.Billing.Quota.Limits.monthly_pageview_limit(subscription)
+ pageview_limit = Plausible.Teams.Billing.monthly_pageview_limit(subscription)
quota =
if pageview_limit == :unlimited do
diff --git a/lib/workers/check_usage.ex b/lib/workers/check_usage.ex
index 007892eb49..d9149732ec 100644
--- a/lib/workers/check_usage.ex
+++ b/lib/workers/check_usage.ex
@@ -3,7 +3,7 @@ defmodule Plausible.Workers.CheckUsage do
use Oban.Worker, queue: :check_usage
require Plausible.Billing.Subscription.Status
alias Plausible.Billing.{Subscription, Quota}
- alias Plausible.Auth.User
+ alias Plausible.Teams
defmacro yesterday() do
quote do
@@ -33,26 +33,17 @@ defmodule Plausible.Workers.CheckUsage do
end
@impl Oban.Worker
- def perform(_job, usage_mod \\ Quota.Usage, today \\ Date.utc_today()) do
+ def perform(_job, usage_mod \\ Teams.Billing, today \\ Date.utc_today()) do
yesterday = today |> Date.shift(day: -1)
- last_subscription_query =
- from(s in Subscription,
- order_by: [desc: s.inserted_at],
- where: s.user_id == parent_as(:user).id,
- limit: 1
- )
-
active_subscribers =
Repo.all(
- from(u in User,
- as: :user,
- inner_join: s in Plausible.Billing.Subscription,
- on: s.user_id == u.id,
- inner_lateral_join: ls in subquery(last_subscription_query),
- on: ls.id == s.id,
- left_join: ep in Plausible.Billing.EnterprisePlan,
- on: ep.user_id == u.id,
+ from(t in Teams.Team,
+ as: :team,
+ inner_join: o in assoc(t, :owner),
+ inner_lateral_join: s in subquery(Teams.last_subscription_join_query()),
+ on: true,
+ left_join: ep in assoc(t, :enterprise_plan),
where:
s.status in [
^Subscription.Status.active(),
@@ -65,8 +56,8 @@ defmodule Plausible.Workers.CheckUsage do
where:
least(day_of_month(s.last_bill_date), day_of_month(last_day_of_month(^yesterday))) ==
day_of_month(^yesterday),
- order_by: u.id,
- preload: [subscription: s, enterprise_plan: ep]
+ order_by: t.id,
+ preload: [subscription: s, enterprise_plan: ep, owner: o]
)
)
@@ -91,7 +82,8 @@ defmodule Plausible.Workers.CheckUsage do
defp check_site_usage_for_enterprise(subscriber) do
limit = subscriber.enterprise_plan.site_limit
- usage = Quota.Usage.site_usage(subscriber)
+
+ usage = Teams.Billing.site_usage(subscriber)
if Quota.below_limit?(usage, limit) do
{:below_limit, {usage, limit}}
@@ -103,7 +95,7 @@ defmodule Plausible.Workers.CheckUsage do
def maybe_remove_grace_period(subscriber, usage_mod) do
case check_pageview_usage_last_cycle(subscriber, usage_mod) do
{:below_limit, _} ->
- Plausible.Users.remove_grace_period(subscriber)
+ Plausible.Users.remove_grace_period(subscriber.owner)
:ok
_ ->
@@ -117,10 +109,10 @@ defmodule Plausible.Workers.CheckUsage do
suggested_plan =
Plausible.Billing.Plans.suggest(subscriber, pageview_usage.last_cycle.total)
- PlausibleWeb.Email.over_limit_email(subscriber, pageview_usage, suggested_plan)
+ PlausibleWeb.Email.over_limit_email(subscriber.owner, pageview_usage, suggested_plan)
|> Plausible.Mailer.send()
- Plausible.Users.start_grace_period(subscriber)
+ Plausible.Users.start_grace_period(subscriber.owner)
_ ->
nil
@@ -137,20 +129,20 @@ defmodule Plausible.Workers.CheckUsage do
{{_, pageview_usage}, {_, {site_usage, site_allowance}}} ->
PlausibleWeb.Email.enterprise_over_limit_internal_email(
- subscriber,
+ subscriber.owner,
pageview_usage,
site_usage,
site_allowance
)
|> Plausible.Mailer.send()
- Plausible.Users.start_manual_lock_grace_period(subscriber)
+ Plausible.Users.start_manual_lock_grace_period(subscriber.owner)
end
end
defp check_pageview_usage_two_cycles(subscriber, usage_mod) do
usage = usage_mod.monthly_pageview_usage(subscriber)
- limit = Quota.Limits.monthly_pageview_limit(subscriber.subscription)
+ limit = Teams.Billing.monthly_pageview_limit(subscriber.subscription)
if Quota.exceeds_last_two_usage_cycles?(usage, limit) do
{:over_limit, usage}
@@ -161,7 +153,7 @@ defmodule Plausible.Workers.CheckUsage do
defp check_pageview_usage_last_cycle(subscriber, usage_mod) do
usage = usage_mod.monthly_pageview_usage(subscriber)
- limit = Quota.Limits.monthly_pageview_limit(subscriber.subscription)
+ limit = Teams.Billing.monthly_pageview_limit(subscriber.subscription)
if :last_cycle in Quota.exceeded_cycles(usage, limit) do
{:over_limit, usage}
diff --git a/lib/workers/send_trial_notifications.ex b/lib/workers/send_trial_notifications.ex
index a702c42313..bb082752c2 100644
--- a/lib/workers/send_trial_notifications.ex
+++ b/lib/workers/send_trial_notifications.ex
@@ -5,40 +5,43 @@ defmodule Plausible.Workers.SendTrialNotifications do
queue: :trial_notification_emails,
max_attempts: 1
+ alias Plausible.Teams
+
require Logger
@impl Oban.Worker
def perform(_job) do
- users =
+ teams =
Repo.all(
- from u in Plausible.Auth.User,
- left_join: s in Plausible.Billing.Subscription,
- on: s.user_id == u.id,
- where: not is_nil(u.trial_expiry_date),
+ from t in Teams.Team,
+ inner_join: o in assoc(t, :owner),
+ left_join: s in assoc(t, :subscription),
+ where: not is_nil(t.trial_expiry_date),
where: is_nil(s.id),
- order_by: u.inserted_at
+ order_by: t.inserted_at,
+ preload: [owner: o]
)
- for user <- users do
- case Date.diff(user.trial_expiry_date, Date.utc_today()) do
+ for team <- teams do
+ case Date.diff(team.trial_expiry_date, Date.utc_today()) do
7 ->
- if Plausible.Auth.has_active_sites?(user, [:owner]) do
- send_one_week_reminder(user)
+ if Teams.has_active_sites?(team) do
+ send_one_week_reminder(team.owner)
end
1 ->
- if Plausible.Auth.has_active_sites?(user, [:owner]) do
- send_tomorrow_reminder(user)
+ if Teams.has_active_sites?(team) do
+ send_tomorrow_reminder(team.owner, team)
end
0 ->
- if Plausible.Auth.has_active_sites?(user, [:owner]) do
- send_today_reminder(user)
+ if Teams.has_active_sites?(team) do
+ send_today_reminder(team.owner, team)
end
-1 ->
- if Plausible.Auth.has_active_sites?(user, [:owner]) do
- send_over_reminder(user)
+ if Teams.has_active_sites?(team) do
+ send_over_reminder(team.owner)
end
_ ->
@@ -54,15 +57,15 @@ defmodule Plausible.Workers.SendTrialNotifications do
|> Plausible.Mailer.send()
end
- defp send_tomorrow_reminder(user) do
- usage = Plausible.Billing.Quota.Usage.usage_cycle(user, :last_30_days)
+ defp send_tomorrow_reminder(user, team) do
+ usage = Plausible.Teams.Billing.usage_cycle(team, :last_30_days)
PlausibleWeb.Email.trial_upgrade_email(user, "tomorrow", usage)
|> Plausible.Mailer.send()
end
- defp send_today_reminder(user) do
- usage = Plausible.Billing.Quota.Usage.usage_cycle(user, :last_30_days)
+ defp send_today_reminder(user, team) do
+ usage = Plausible.Teams.Billing.usage_cycle(team, :last_30_days)
PlausibleWeb.Email.trial_upgrade_email(user, "today", usage)
|> Plausible.Mailer.send()
diff --git a/test/plausible/auth/auth_test.exs b/test/plausible/auth/auth_test.exs
index 68c7830737..67cbe29c5d 100644
--- a/test/plausible/auth/auth_test.exs
+++ b/test/plausible/auth/auth_test.exs
@@ -49,14 +49,12 @@ defmodule Plausible.AuthTest do
user_with_plan_no_subscription =
new_user() |> subscribe_to_enterprise_plan(subscription?: false)
- assert Plausible.Teams.Adapter.Read.Billing.enterprise_configured?(user_with_plan)
+ assert Plausible.Teams.Billing.enterprise_configured?(team_of(user_with_plan))
- assert Plausible.Teams.Adapter.Read.Billing.enterprise_configured?(
- user_with_plan_no_subscription
- )
+ assert Plausible.Teams.Billing.enterprise_configured?(team_of(user_with_plan_no_subscription))
- refute Plausible.Teams.Adapter.Read.Billing.enterprise_configured?(user_without_plan)
- refute Plausible.Teams.Adapter.Read.Billing.enterprise_configured?(nil)
+ refute Plausible.Teams.Billing.enterprise_configured?(team_of(user_without_plan))
+ refute Plausible.Teams.Billing.enterprise_configured?(nil)
end
describe "create_api_key/3" do
@@ -78,7 +76,7 @@ defmodule Plausible.AuthTest do
@tag :ce_build_only
test "defaults to 1000000 requests per hour limit in CE" do
- user = insert(:user)
+ user = new_user()
{:ok, %Auth.ApiKey{hourly_request_limit: hourly_request_limit}} =
Auth.create_api_key(user, "my new CE key", Ecto.UUID.generate())
diff --git a/test/plausible/billing/billing_test.exs b/test/plausible/billing/billing_test.exs
index a96c61fc38..4599643332 100644
--- a/test/plausible/billing/billing_test.exs
+++ b/test/plausible/billing/billing_test.exs
@@ -8,79 +8,94 @@ defmodule Plausible.BillingTest do
describe "check_needs_to_upgrade" do
test "is false for a trial user" do
- user = insert(:user)
- assert Billing.check_needs_to_upgrade(user) == :no_upgrade_needed
+ team = new_user() |> team_of()
+ assert Plausible.Teams.Billing.check_needs_to_upgrade(team) == :no_upgrade_needed
end
test "is true for a user with an expired trial" do
- user = insert(:user, trial_expiry_date: Timex.shift(Timex.today(), days: -1))
+ team = new_user(trial_expiry_date: Date.shift(Date.utc_today(), day: -1)) |> team_of()
- assert Billing.check_needs_to_upgrade(user) == {:needs_to_upgrade, :no_active_subscription}
+ assert Plausible.Teams.Billing.check_needs_to_upgrade(team) ==
+ {:needs_to_upgrade, :no_active_subscription}
end
test "is true for a user with empty trial expiry date" do
- user = insert(:user, trial_expiry_date: nil)
-
- assert Billing.check_needs_to_upgrade(user) == {:needs_to_upgrade, :no_trial}
+ assert Plausible.Teams.Billing.check_needs_to_upgrade(nil) ==
+ {:needs_to_upgrade, :no_trial}
end
test "is false for user with empty trial expiry date but with an active subscription" do
- user = insert(:user, trial_expiry_date: nil)
- insert(:subscription, user: user)
+ team =
+ new_user()
+ |> subscribe_to_growth_plan()
+ |> team_of()
+ |> Ecto.Changeset.change(trial_expiry_date: nil)
+ |> Repo.update!()
- assert Billing.check_needs_to_upgrade(user) == :no_upgrade_needed
+ assert Plausible.Teams.Billing.check_needs_to_upgrade(team) == :no_upgrade_needed
end
test "is false for a user with an expired trial but an active subscription" do
- user = insert(:user, trial_expiry_date: Timex.shift(Timex.today(), days: -1))
- insert(:subscription, user: user)
+ team =
+ new_user(trial_expiry_date: Date.shift(Date.utc_today(), day: -1))
+ |> subscribe_to_growth_plan()
+ |> team_of()
- assert Billing.check_needs_to_upgrade(user) == :no_upgrade_needed
+ assert Plausible.Teams.Billing.check_needs_to_upgrade(team) == :no_upgrade_needed
end
test "is false for a user with a cancelled subscription IF the billing cycle isn't completed yet" do
- user = insert(:user, trial_expiry_date: Timex.shift(Timex.today(), days: -1))
-
- insert(:subscription,
- user: user,
- status: Subscription.Status.deleted(),
- next_bill_date: Timex.today()
- )
+ team =
+ new_user(trial_expiry_date: Date.shift(Date.utc_today(), day: -1))
+ |> subscribe_to_growth_plan(
+ status: Subscription.Status.deleted(),
+ next_bill_date: Date.utc_today()
+ )
+ |> team_of()
- assert Billing.check_needs_to_upgrade(user) == :no_upgrade_needed
+ assert Plausible.Teams.Billing.check_needs_to_upgrade(team) == :no_upgrade_needed
end
test "is true for a user with a cancelled subscription IF the billing cycle is complete" do
- user = insert(:user, trial_expiry_date: Timex.shift(Timex.today(), days: -1))
-
- insert(:subscription,
- user: user,
- status: Subscription.Status.deleted(),
- next_bill_date: Timex.shift(Timex.today(), days: -1)
- )
+ team =
+ new_user(trial_expiry_date: Date.shift(Date.utc_today(), day: -1))
+ |> subscribe_to_growth_plan(
+ status: Subscription.Status.deleted(),
+ next_bill_date: Date.shift(Date.utc_today(), day: -1)
+ )
+ |> team_of()
- assert Billing.check_needs_to_upgrade(user) == {:needs_to_upgrade, :no_active_subscription}
+ assert Plausible.Teams.Billing.check_needs_to_upgrade(team) ==
+ {:needs_to_upgrade, :no_active_subscription}
end
test "is true for a deleted subscription if no next_bill_date specified" do
- user = insert(:user, trial_expiry_date: Timex.shift(Timex.today(), days: -1))
-
- insert(:subscription,
- user: user,
- status: Subscription.Status.deleted(),
- next_bill_date: nil
- )
+ team =
+ new_user(trial_expiry_date: Date.shift(Date.utc_today(), day: -1))
+ |> subscribe_to_growth_plan(
+ status: Subscription.Status.deleted(),
+ next_bill_date: nil
+ )
+ |> team_of()
- assert Billing.check_needs_to_upgrade(user) == {:needs_to_upgrade, :no_active_subscription}
+ assert Plausible.Teams.Billing.check_needs_to_upgrade(team) ==
+ {:needs_to_upgrade, :no_active_subscription}
end
test "is true for a user past their grace period" do
- user = insert(:user, trial_expiry_date: Timex.shift(Timex.today(), days: -1))
- insert(:subscription, user: user, next_bill_date: Timex.today())
+ user =
+ new_user(trial_expiry_date: Date.shift(Date.utc_today(), day: -1))
+ |> subscribe_to_growth_plan(
+ status: Subscription.Status.deleted(),
+ next_bill_date: Date.utc_today()
+ )
user = Plausible.Users.end_grace_period(user)
- assert Billing.check_needs_to_upgrade(user) == {:needs_to_upgrade, :grace_period_ended}
+ team = user |> Repo.reload!() |> team_of()
+
+ assert Plausible.Teams.Billing.check_needs_to_upgrade(team) ==
+ {:needs_to_upgrade, :grace_period_ended}
end
end
@@ -514,12 +529,11 @@ defmodule Plausible.BillingTest do
describe "change_plan" do
test "sets the next bill amount and date" do
- user = insert(:user)
- insert(:subscription, user: user)
+ team = new_user() |> subscribe_to_growth_plan() |> team_of()
- Billing.change_plan(user, "123123")
+ Plausible.Teams.Billing.change_plan(team, "123123")
- subscription = Repo.get_by(Plausible.Billing.Subscription, user_id: user.id)
+ subscription = Repo.get_by(Plausible.Billing.Subscription, team_id: team.id)
assert subscription.paddle_plan_id == "123123"
assert subscription.next_bill_date == ~D[2019-07-10]
assert subscription.next_bill_amount == "6.00"
@@ -527,22 +541,33 @@ defmodule Plausible.BillingTest do
end
test "active_subscription_for/1 returns active subscription" do
- active = insert(:subscription, user: insert(:user), status: Subscription.Status.active())
- paused = insert(:subscription, user: insert(:user), status: Subscription.Status.paused())
- user_without_subscription = insert(:user)
-
- assert Billing.active_subscription_for(active.user).id == active.id
- assert Billing.active_subscription_for(paused.user) == nil
- assert Billing.active_subscription_for(user_without_subscription) == nil
+ active_team =
+ new_user()
+ |> subscribe_to_growth_plan(status: Subscription.Status.active())
+ |> team_of()
+ |> Plausible.Teams.with_subscription()
+
+ paused_team =
+ new_user()
+ |> subscribe_to_growth_plan(status: Subscription.Status.paused())
+ |> team_of()
+
+ assert Plausible.Teams.Billing.active_subscription_for(active_team).id ==
+ active_team.subscription.id
+
+ assert Plausible.Teams.Billing.active_subscription_for(paused_team) == nil
+ assert Plausible.Teams.Billing.active_subscription_for(nil) == nil
end
test "has_active_subscription?/1 returns whether the user has an active subscription" do
- active = insert(:subscription, user: insert(:user), status: Subscription.Status.active())
- paused = insert(:subscription, user: insert(:user), status: Subscription.Status.paused())
- user_without_subscription = insert(:user)
+ active_team =
+ new_user() |> subscribe_to_growth_plan(status: Subscription.Status.active()) |> team_of()
+
+ paused_team =
+ new_user() |> subscribe_to_growth_plan(status: Subscription.Status.paused()) |> team_of()
- assert Billing.has_active_subscription?(active.user)
- refute Billing.has_active_subscription?(paused.user)
- refute Billing.has_active_subscription?(user_without_subscription)
+ assert Plausible.Teams.Billing.has_active_subscription?(active_team)
+ refute Plausible.Teams.Billing.has_active_subscription?(paused_team)
+ refute Plausible.Teams.Billing.has_active_subscription?(nil)
end
end
diff --git a/test/plausible/billing/feature_test.exs b/test/plausible/billing/feature_test.exs
index 9c0af28454..7a9c4213b7 100644
--- a/test/plausible/billing/feature_test.exs
+++ b/test/plausible/billing/feature_test.exs
@@ -6,96 +6,88 @@ defmodule Plausible.Billing.FeatureTest do
for mod <- [Plausible.Billing.Feature.Funnels, Plausible.Billing.Feature.RevenueGoals] do
test "#{mod}.check_availability/1 returns :ok when site owner is on a enterprise plan" do
- user =
+ team =
new_user()
|> subscribe_to_enterprise_plan(paddle_plan_id: "123321", features: [unquote(mod)])
+ |> team_of()
- assert :ok == unquote(mod).check_availability(user)
+ assert :ok == unquote(mod).check_availability(team)
end
test "#{mod}.check_availability/1 returns :ok when site owner is on a business plan" do
- user = new_user() |> subscribe_to_business_plan()
- assert :ok == unquote(mod).check_availability(user)
+ team = new_user() |> subscribe_to_business_plan() |> team_of()
+ assert :ok == unquote(mod).check_availability(team)
end
test "#{mod}.check_availability/1 returns error when site owner is on a growth plan" do
- user = new_user() |> subscribe_to_growth_plan()
- assert {:error, :upgrade_required} == unquote(mod).check_availability(user)
+ team = new_user() |> subscribe_to_growth_plan() |> team_of()
+ assert {:error, :upgrade_required} == unquote(mod).check_availability(team)
end
test "#{mod}.check_availability/1 returns error when site owner is on an old plan" do
- user = new_user() |> subscribe_to_plan(@v1_plan_id)
- assert {:error, :upgrade_required} == unquote(mod).check_availability(user)
+ team = new_user() |> subscribe_to_plan(@v1_plan_id) |> team_of()
+ assert {:error, :upgrade_required} == unquote(mod).check_availability(team)
end
end
test "Plausible.Billing.Feature.StatsAPI.check_availability/2 returns :ok when user is on a business plan" do
- user = new_user() |> subscribe_to_business_plan()
- assert :ok == Plausible.Billing.Feature.StatsAPI.check_availability(user)
+ team = new_user() |> subscribe_to_business_plan() |> team_of()
+ assert :ok == Plausible.Billing.Feature.StatsAPI.check_availability(team)
end
test "Plausible.Billing.Feature.StatsAPI.check_availability/2 returns :ok when user is on an old plan" do
- user = new_user() |> subscribe_to_plan(@v1_plan_id)
- assert :ok == Plausible.Billing.Feature.StatsAPI.check_availability(user)
+ team = new_user() |> subscribe_to_plan(@v1_plan_id) |> team_of()
+ assert :ok == Plausible.Billing.Feature.StatsAPI.check_availability(team)
end
test "Plausible.Billing.Feature.StatsAPI.check_availability/2 returns :ok when user is on trial" do
- user = new_user()
- assert :ok == Plausible.Billing.Feature.StatsAPI.check_availability(user)
+ team = new_user() |> team_of()
+ assert :ok == Plausible.Billing.Feature.StatsAPI.check_availability(team)
end
test "Plausible.Billing.Feature.StatsAPI.check_availability/2 returns :ok when user is on an enterprise plan" do
- user =
+ team =
new_user()
|> subscribe_to_enterprise_plan(
paddle_plan_id: "123321",
features: [Plausible.Billing.Feature.StatsAPI]
)
+ |> team_of()
- assert :ok == Plausible.Billing.Feature.StatsAPI.check_availability(user)
+ assert :ok == Plausible.Billing.Feature.StatsAPI.check_availability(team)
end
@tag :ee_only
test "Plausible.Billing.Feature.StatsAPI.check_availability/2 returns error when user is on a growth plan" do
- user = new_user() |> subscribe_to_growth_plan()
+ team = new_user() |> subscribe_to_growth_plan() |> team_of()
assert {:error, :upgrade_required} ==
- Plausible.Billing.Feature.StatsAPI.check_availability(user)
- end
-
- test "Plausible.Billing.Feature.StatsAPI.check_availability/2 returns :ok when user trial hasn't started and was created before the business tier launch" do
- user = new_user(inserted_at: ~N[2020-01-01T00:00:00], trial_expiry_date: nil)
- assert :ok == Plausible.Billing.Feature.StatsAPI.check_availability(user)
- end
-
- test "Plausible.Billing.Feature.StatsAPI.check_availability/2 returns :ok if user is subscribed and account was created after business tier launch" do
- user = new_user(trial_expiry_date: nil) |> subscribe_to_business_plan()
- assert :ok == Plausible.Billing.Feature.StatsAPI.check_availability(user)
+ Plausible.Billing.Feature.StatsAPI.check_availability(team)
end
@tag :ee_only
test "Plausible.Billing.Feature.StatsAPI.check_availability/2 returns error when user trial hasn't started and was created after the business tier launch" do
- user = new_user(trial_expiry_date: nil)
+ _user = new_user(trial_expiry_date: nil)
assert {:error, :upgrade_required} ==
- Plausible.Billing.Feature.StatsAPI.check_availability(user)
+ Plausible.Billing.Feature.StatsAPI.check_availability(nil)
end
test "Plausible.Billing.Feature.Props.check_availability/1 applies grandfathering to old plans" do
- user = new_user() |> subscribe_to_plan(@v1_plan_id)
- assert :ok == Plausible.Billing.Feature.Props.check_availability(user)
+ team = new_user() |> subscribe_to_plan(@v1_plan_id) |> team_of()
+ assert :ok == Plausible.Billing.Feature.Props.check_availability(team)
end
test "Plausible.Billing.Feature.Goals.check_availability/2 always returns :ok" do
- u1 = new_user() |> subscribe_to_plan(@v1_plan_id)
- u2 = new_user() |> subscribe_to_growth_plan()
- u3 = new_user() |> subscribe_to_business_plan()
- u4 = new_user() |> subscribe_to_enterprise_plan(paddle_plan_id: "123321")
-
- assert :ok == Plausible.Billing.Feature.Goals.check_availability(u1)
- assert :ok == Plausible.Billing.Feature.Goals.check_availability(u2)
- assert :ok == Plausible.Billing.Feature.Goals.check_availability(u3)
- assert :ok == Plausible.Billing.Feature.Goals.check_availability(u4)
+ t1 = new_user() |> subscribe_to_plan(@v1_plan_id) |> team_of()
+ t2 = new_user() |> subscribe_to_growth_plan() |> team_of()
+ t3 = new_user() |> subscribe_to_business_plan() |> team_of()
+ t4 = new_user() |> subscribe_to_enterprise_plan(paddle_plan_id: "123321") |> team_of()
+
+ assert :ok == Plausible.Billing.Feature.Goals.check_availability(t1)
+ assert :ok == Plausible.Billing.Feature.Goals.check_availability(t2)
+ assert :ok == Plausible.Billing.Feature.Goals.check_availability(t3)
+ assert :ok == Plausible.Billing.Feature.Goals.check_availability(t4)
end
for {mod, property} <- [
diff --git a/test/plausible/billing/plans_test.exs b/test/plausible/billing/plans_test.exs
index ee48076578..a7a665a226 100644
--- a/test/plausible/billing/plans_test.exs
+++ b/test/plausible/billing/plans_test.exs
@@ -155,22 +155,30 @@ defmodule Plausible.Billing.PlansTest do
end
test "latest_enterprise_plan_with_price/1" do
- user = insert(:user)
- insert(:enterprise_plan, user: user, paddle_plan_id: "123", inserted_at: Timex.now())
+ now = NaiveDateTime.utc_now()
+ user = new_user()
+ team = team_of(user)
+
+ subscribe_to_enterprise_plan(user,
+ paddle_plan_id: "123",
+ inserted_at: now,
+ subscription?: false
+ )
- insert(:enterprise_plan,
- user: user,
+ subscribe_to_enterprise_plan(user,
paddle_plan_id: "456",
- inserted_at: Timex.shift(Timex.now(), hours: -10)
+ inserted_at: NaiveDateTime.shift(now, hour: -10),
+ subscription?: false
)
- insert(:enterprise_plan,
- user: user,
+ subscribe_to_enterprise_plan(user,
paddle_plan_id: "789",
- inserted_at: Timex.shift(Timex.now(), minutes: -2)
+ inserted_at: NaiveDateTime.shift(now, minute: -2),
+ subscription?: false
)
- {enterprise_plan, price} = Plans.latest_enterprise_plan_with_price(user, "127.0.0.1")
+ {enterprise_plan, price} =
+ Plausible.Teams.Billing.latest_enterprise_plan_with_price(team, "127.0.0.1")
assert enterprise_plan.paddle_plan_id == "123"
assert price == Money.new(:EUR, "10.0")
@@ -210,7 +218,7 @@ defmodule Plausible.Billing.PlansTest do
describe "suggested_plan/2" do
test "returns suggested plan based on usage" do
- user = new_user() |> subscribe_to_plan(@v1_plan_id)
+ team = new_user() |> subscribe_to_plan(@v1_plan_id) |> team_of()
assert %Plausible.Billing.Plan{
monthly_pageview_limit: 100_000,
@@ -219,7 +227,7 @@ defmodule Plausible.Billing.PlansTest do
volume: "100k",
yearly_cost: nil,
yearly_product_id: "590752"
- } = Plans.suggest(user, 10_000)
+ } = Plans.suggest(team, 10_000)
assert %Plausible.Billing.Plan{
monthly_pageview_limit: 200_000,
@@ -228,21 +236,22 @@ defmodule Plausible.Billing.PlansTest do
volume: "200k",
yearly_cost: nil,
yearly_product_id: "597486"
- } = Plans.suggest(user, 100_000)
+ } = Plans.suggest(team, 100_000)
end
test "returns nil when user has enterprise-level usage" do
- user = new_user() |> subscribe_to_plan(@v1_plan_id)
- assert :enterprise == Plans.suggest(user, 100_000_000)
+ team = new_user() |> subscribe_to_plan(@v1_plan_id) |> team_of()
+ assert :enterprise == Plans.suggest(team, 100_000_000)
end
test "returns nil when user is on an enterprise plan" do
- user =
+ team =
new_user()
|> subscribe_to_plan(@v1_plan_id)
|> subscribe_to_enterprise_plan(billing_interval: :yearly, subscription?: false)
+ |> team_of()
- assert :enterprise == Plans.suggest(user, 10_000)
+ assert :enterprise == Plans.suggest(team, 10_000)
end
end
diff --git a/test/plausible/billing/quota_test.exs b/test/plausible/billing/quota_test.exs
index 60f3fd336a..5e963706f2 100644
--- a/test/plausible/billing/quota_test.exs
+++ b/test/plausible/billing/quota_test.exs
@@ -24,54 +24,58 @@ defmodule Plausible.Billing.QuotaTest do
@describetag :ee_only
test "returns 50 when user is on an old plan" do
- user_on_v1 = new_user() |> subscribe_to_plan(@v1_plan_id)
- user_on_v2 = new_user() |> subscribe_to_plan(@v2_plan_id)
- user_on_v3 = new_user() |> subscribe_to_plan(@v3_plan_id)
+ team_on_v1 = new_user() |> subscribe_to_plan(@v1_plan_id) |> team_of()
+ team_on_v2 = new_user() |> subscribe_to_plan(@v2_plan_id) |> team_of()
+ team_on_v3 = new_user() |> subscribe_to_plan(@v3_plan_id) |> team_of()
- assert 50 == Plausible.Teams.Adapter.Read.Billing.site_limit(user_on_v1)
- assert 50 == Plausible.Teams.Adapter.Read.Billing.site_limit(user_on_v2)
- assert 50 == Plausible.Teams.Adapter.Read.Billing.site_limit(user_on_v3)
+ assert 50 == Plausible.Teams.Billing.site_limit(team_on_v1)
+ assert 50 == Plausible.Teams.Billing.site_limit(team_on_v2)
+ assert 50 == Plausible.Teams.Billing.site_limit(team_on_v3)
end
test "returns 50 when user is on free_10k plan" do
- user = new_user() |> subscribe_to_plan("free_10k")
- assert 50 == Plausible.Teams.Adapter.Read.Billing.site_limit(user)
+ team = new_user() |> subscribe_to_plan("free_10k") |> team_of()
+ assert 50 == Plausible.Teams.Billing.site_limit(team)
end
test "returns the configured site limit for enterprise plan" do
- user = new_user() |> subscribe_to_enterprise_plan(site_limit: 500)
- assert Plausible.Teams.Adapter.Read.Billing.site_limit(user) == 500
+ team = new_user() |> subscribe_to_enterprise_plan(site_limit: 500) |> team_of()
+ assert Plausible.Teams.Billing.site_limit(team) == 500
end
test "returns 10 when user in on trial" do
- user = new_user(trial_expiry_date: Date.shift(Date.utc_today(), day: 7))
- assert Plausible.Teams.Adapter.Read.Billing.site_limit(user) == 10
+ team = new_user(trial_expiry_date: Date.shift(Date.utc_today(), day: 7)) |> team_of()
+ assert Plausible.Teams.Billing.site_limit(team) == 10
end
test "returns the subscription limit for enterprise users who have not paid yet" do
- user =
+ team =
new_user()
|> subscribe_to_plan(@v1_plan_id)
|> subscribe_to_enterprise_plan(paddle_plan_id: "123321", subscription?: false)
+ |> team_of()
- assert Plausible.Teams.Adapter.Read.Billing.site_limit(user) == 50
+ assert Plausible.Teams.Billing.site_limit(team) == 50
end
test "returns 10 for enterprise users who have not upgraded yet and are on trial" do
- user =
- new_user() |> subscribe_to_enterprise_plan(paddle_plan_id: "123321", subscription?: false)
+ team =
+ new_user()
+ |> subscribe_to_enterprise_plan(paddle_plan_id: "123321", subscription?: false)
+ |> team_of()
- assert Plausible.Teams.Adapter.Read.Billing.site_limit(user) == 10
+ assert Plausible.Teams.Billing.site_limit(team) == 10
end
end
test "site_usage/1 returns the amount of sites the user owns" do
- user = insert(:user)
- insert_list(3, :site, memberships: [build(:site_membership, user: user, role: :owner)])
- insert(:site, memberships: [build(:site_membership, user: user, role: :admin)])
- insert(:site, memberships: [build(:site_membership, user: user, role: :viewer)])
+ user = new_user()
+ for _ <- 1..3, do: new_site(owner: user)
+ add_guest(new_site(), user: user, role: :editor)
+ add_guest(new_site(), user: user, role: :viewer)
+ team = team_of(user)
- assert Quota.Usage.site_usage(user) == 3
+ assert Plausible.Teams.Billing.site_usage(team) == 3
end
describe "below_limit?/2" do
@@ -199,21 +203,33 @@ defmodule Plausible.Billing.QuotaTest do
describe "monthly_pageview_limit/1" do
test "is based on the plan if user is on a legacy plan" do
- user = insert(:user, subscription: build(:subscription, paddle_plan_id: @legacy_plan_id))
+ team =
+ new_user()
+ |> subscribe_to_plan(@legacy_plan_id)
+ |> team_of()
+ |> Plausible.Teams.with_subscription()
- assert Quota.Limits.monthly_pageview_limit(user.subscription) == 1_000_000
+ assert Plausible.Teams.Billing.monthly_pageview_limit(team.subscription) == 1_000_000
end
test "is based on the plan if user is on a standard plan" do
- user = insert(:user, subscription: build(:subscription, paddle_plan_id: @v1_plan_id))
+ team =
+ new_user()
+ |> subscribe_to_plan(@v1_plan_id)
+ |> team_of()
+ |> Plausible.Teams.with_subscription()
- assert Quota.Limits.monthly_pageview_limit(user.subscription) == 10_000
+ assert Plausible.Teams.Billing.monthly_pageview_limit(team.subscription) == 10_000
end
test "free_10k has 10k monthly_pageview_limit" do
- user = insert(:user, subscription: build(:subscription, paddle_plan_id: "free_10k"))
+ team =
+ new_user()
+ |> subscribe_to_plan("free_10k")
+ |> team_of()
+ |> Plausible.Teams.with_subscription()
- assert Quota.Limits.monthly_pageview_limit(user.subscription) == 10_000
+ assert Plausible.Teams.Billing.monthly_pageview_limit(team.subscription) == 10_000
end
test "is based on the enterprise plan if user is on an enterprise plan" do
@@ -226,7 +242,7 @@ defmodule Plausible.Billing.QuotaTest do
|> Repo.preload(:subscription)
|> Map.fetch!(:subscription)
- assert Quota.Limits.monthly_pageview_limit(subscription) == 100_000
+ assert Plausible.Teams.Billing.monthly_pageview_limit(subscription) == 100_000
end
test "does not limit pageviews when user has a pending enterprise plan" do
@@ -239,233 +255,169 @@ defmodule Plausible.Billing.QuotaTest do
|> Repo.preload(:subscription)
|> Map.fetch!(:subscription)
- assert Quota.Limits.monthly_pageview_limit(subscription) == :unlimited
+ assert Plausible.Teams.Billing.monthly_pageview_limit(subscription) == :unlimited
end
end
describe "team_member_usage/2" do
test "returns the number of members in all of the sites the user owns" do
- me = insert(:user)
-
- _site_i_own_1 =
- insert(:site,
- memberships: [
- build(:site_membership, user: me, role: :owner),
- build(:site_membership, user: build(:user), role: :viewer)
- ]
- )
-
- _site_i_own_2 =
- insert(:site,
- memberships: [
- build(:site_membership, user: me, role: :owner),
- build(:site_membership, user: build(:user), role: :admin),
- build(:site_membership, user: build(:user), role: :viewer)
- ]
- )
-
- _site_i_own_3 =
- insert(:site,
- memberships: [
- build(:site_membership, user: me, role: :owner)
- ]
- )
-
- _site_i_have_access =
- insert(:site,
- memberships: [
- build(:site_membership, user: me, role: :viewer),
- build(:site_membership, user: build(:user), role: :viewer),
- build(:site_membership, user: build(:user), role: :viewer),
- build(:site_membership, user: build(:user), role: :viewer)
- ]
- )
-
- assert Quota.Usage.team_member_usage(me) == 3
+ me = new_user()
+ site_i_own_1 = new_site(owner: me)
+ add_guest(site_i_own_1, role: :viewer)
+ site_i_own_2 = new_site(owner: me)
+ add_guest(site_i_own_2, role: :editor)
+ add_guest(site_i_own_2, role: :viewer)
+ _site_i_own_3 = new_site(owner: me)
+ site_i_have_access = new_site()
+ add_guest(site_i_have_access, user: me, role: :viewer)
+ add_guest(site_i_have_access, role: :viewer)
+ add_guest(site_i_have_access, role: :viewer)
+ add_guest(site_i_have_access, role: :viewer)
+ team = team_of(me)
+
+ assert Plausible.Teams.Billing.team_member_usage(team) == 3
end
test "counts the same email address as one team member" do
- me = insert(:user)
- joe = insert(:user, email: "[email protected]")
-
- _site_i_own_1 =
- insert(:site,
- memberships: [
- build(:site_membership, user: me, role: :owner),
- build(:site_membership, user: joe, role: :viewer)
- ]
- )
-
- _site_i_own_2 =
- insert(:site,
- memberships: [
- build(:site_membership, user: me, role: :owner),
- build(:site_membership, user: build(:user), role: :admin),
- build(:site_membership, user: joe, role: :viewer)
- ]
- )
-
- site_i_own_3 = insert(:site, memberships: [build(:site_membership, user: me, role: :owner)])
-
- insert(:invitation, site: site_i_own_3, inviter: me, email: "[email protected]")
+ me = new_user()
+ joe = new_user(email: "[email protected]")
+ site_i_own_1 = new_site(owner: me)
+ add_guest(site_i_own_1, user: joe, role: :viewer)
+ site_i_own_2 = new_site(owner: me)
+ add_guest(site_i_own_2, user: new_user(), role: :editor)
+ add_guest(site_i_own_2, user: joe, role: :viewer)
+ site_i_own_3 = new_site(owner: me)
+ invite_guest(site_i_own_3, joe, role: :viewer, inviter: me)
+ team = team_of(me)
- assert Quota.Usage.team_member_usage(me) == 2
+ assert Plausible.Teams.Billing.team_member_usage(team) == 2
end
test "counts pending invitations as team members" do
- me = insert(:user)
- member = insert(:user)
-
- site_i_own =
- insert(:site,
- memberships: [
- build(:site_membership, user: me, role: :owner),
- build(:site_membership, user: member, role: :admin)
- ]
- )
-
- site_i_have_access =
- insert(:site, memberships: [build(:site_membership, user: me, role: :admin)])
+ me = new_user()
+ member = new_user()
+ site_i_own = new_site(owner: me)
+ add_guest(site_i_own, user: member, role: :editor)
+ site_i_have_access = new_site()
+ add_guest(site_i_have_access, user: me, role: :editor)
+ team = team_of(me)
- insert(:invitation, site: site_i_own, inviter: me)
- insert(:invitation, site: site_i_own, inviter: member)
- insert(:invitation, site: site_i_have_access, inviter: me)
+ invite_guest(site_i_own, new_user(), role: :viewer, inviter: me)
+ invite_guest(site_i_own, new_user(), role: :viewer, inviter: member)
+ invite_guest(site_i_have_access, new_user(), role: :viewer, inviter: me)
- assert Quota.Usage.team_member_usage(me) == 3
+ assert Plausible.Teams.Billing.team_member_usage(team) == 3
end
test "does not count ownership transfer as a team member by default" do
- me = insert(:user)
- site_i_own = insert(:site, memberships: [build(:site_membership, user: me, role: :owner)])
+ me = new_user()
+ site_i_own = new_site(owner: me)
+ invite_transfer(site_i_own, new_user(), inviter: me)
+ team = team_of(me)
- insert(:invitation, site: site_i_own, inviter: me, role: :owner)
-
- assert Quota.Usage.team_member_usage(me) == 0
+ assert Plausible.Teams.Billing.team_member_usage(team) == 0
end
test "counts team members from pending ownerships when specified" do
- me = insert(:user)
+ me = new_user()
+ my_team = team_of(me)
- user_1 = insert(:user)
- user_2 = insert(:user)
+ user_1 = new_user()
+ user_2 = new_user()
- pending_ownership_site =
- insert(:site,
- memberships: [
- build(:site_membership, user: user_1, role: :owner),
- build(:site_membership, user: user_2, role: :admin)
- ]
- )
+ pending_ownership_site = new_site(owner: user_1)
+ add_guest(pending_ownership_site, user: user_2, role: :editor)
- insert(:invitation,
- site: pending_ownership_site,
- inviter: user_1,
- email: me.email,
- role: :owner
- )
+ invite_transfer(pending_ownership_site, me, inviter: user_1)
- assert Quota.Usage.team_member_usage(me,
+ assert Plausible.Teams.Billing.team_member_usage(my_team,
pending_ownership_site_ids: [pending_ownership_site.id]
) == 2
end
test "counts invitations towards team members from pending ownership sites" do
- me = insert(:user)
-
- user_1 = insert(:user)
- user_2 = insert(:user)
-
- pending_ownership_site =
- insert(:site,
- memberships: [build(:site_membership, user: user_1, role: :owner)]
- )
-
- insert(:invitation,
- site: pending_ownership_site,
- inviter: user_1,
- email: me.email,
- role: :owner
- )
-
- insert(:invitation,
- site: pending_ownership_site,
- inviter: user_1,
- email: user_2.email,
- role: :admin
- )
-
- assert Quota.Usage.team_member_usage(me,
+ me = new_user()
+ user_1 = new_user()
+ user_2 = new_user()
+ pending_ownership_site = new_site(owner: user_1)
+ invite_transfer(pending_ownership_site, me, inviter: user_1)
+ invite_guest(pending_ownership_site, user_2, role: :editor, inviter: user_1)
+ team = team_of(me)
+
+ assert Plausible.Teams.Billing.team_member_usage(team,
pending_ownership_site_ids: [pending_ownership_site.id]
) == 2
end
test "returns zero when user does not have any site" do
- me = insert(:user)
- assert Quota.Usage.team_member_usage(me) == 0
+ team = new_user() |> team_of()
+ assert Plausible.Teams.Billing.team_member_usage(team) == 0
end
test "does not count email report recipients as team members" do
- me = insert(:user)
- site = insert(:site, memberships: [build(:site_membership, user: me, role: :owner)])
+ me = new_user()
+ site = new_site(owner: me)
+ team = team_of(me)
insert(:weekly_report,
site: site,
)
- assert Quota.Usage.team_member_usage(me) == 0
+ assert Plausible.Teams.Billing.team_member_usage(team) == 0
end
test "excludes specific emails from limit calculation" do
- me = insert(:user)
- member = insert(:user)
-
- site_i_own =
- insert(:site,
- memberships: [
- build(:site_membership, user: me, role: :owner),
- build(:site_membership, user: member, role: :admin)
- ]
- )
+ me = new_user()
+ member = new_user()
+ site_i_own = new_site(owner: me)
+ add_guest(site_i_own, user: member, role: :editor)
+ team = team_of(me)
+
+ invite_guest(site_i_own, new_user(), role: :viewer, inviter: me)
+ invite_guest(site_i_own, new_user(), role: :viewer, inviter: member)
+ invitation = invite_guest(site_i_own, "[email protected]", role: :viewer, inviter: me)
+
+ assert Plausible.Teams.Billing.team_member_usage(team) == 4
- insert(:invitation, site: site_i_own, inviter: me)
- insert(:invitation, site: site_i_own, inviter: member)
- invitation = insert(:invitation, site: site_i_own, inviter: me, email: "[email protected]")
+ assert Plausible.Teams.Billing.team_member_usage(team,
+ exclude_emails: ["[email protected]"]
+ ) == 4
- assert Quota.Usage.team_member_usage(me) == 4
- assert Quota.Usage.team_member_usage(me, exclude_emails: ["[email protected]"]) == 4
- assert Quota.Usage.team_member_usage(me, exclude_emails: [member.email]) == 3
- assert Quota.Usage.team_member_usage(me, exclude_emails: [invitation.email]) == 3
+ assert Plausible.Teams.Billing.team_member_usage(team, exclude_emails: [member.email]) == 3
- assert Quota.Usage.team_member_usage(me, exclude_emails: [member.email, invitation.email]) ==
- 2
+ assert Plausible.Teams.Billing.team_member_usage(team, exclude_emails: [invitation.email]) ==
+ 3
+
+ assert Plausible.Teams.Billing.team_member_usage(team,
+ exclude_emails: [member.email, invitation.email]
+ ) == 2
end
end
describe "team_member_limit/1" do
@describetag :ee_only
test "returns unlimited when user is on an old plan" do
- user_on_v1 = insert(:user, subscription: build(:subscription, paddle_plan_id: @v1_plan_id))
- user_on_v2 = insert(:user, subscription: build(:subscription, paddle_plan_id: @v2_plan_id))
- user_on_v3 = insert(:user, subscription: build(:subscription, paddle_plan_id: @v3_plan_id))
+ team_on_v1 = new_user() |> subscribe_to_plan(@v1_plan_id)
+ team_on_v2 = new_user() |> subscribe_to_plan(@v2_plan_id)
+ team_on_v3 = new_user() |> subscribe_to_plan(@v3_plan_id)
- assert :unlimited == Quota.Limits.team_member_limit(user_on_v1)
- assert :unlimited == Quota.Limits.team_member_limit(user_on_v2)
- assert :unlimited == Quota.Limits.team_member_limit(user_on_v3)
+ assert :unlimited == Plausible.Teams.Billing.team_member_limit(team_on_v1)
+ assert :unlimited == Plausible.Teams.Billing.team_member_limit(team_on_v2)
+ assert :unlimited == Plausible.Teams.Billing.team_member_limit(team_on_v3)
end
test "returns unlimited when user is on free_10k plan" do
- user = insert(:user, subscription: build(:subscription, paddle_plan_id: "free_10k"))
- assert :unlimited == Quota.Limits.team_member_limit(user)
+ user = new_user()
+ subscribe_to_plan(user, "free_10k")
+ team = team_of(user)
+ assert :unlimited == Plausible.Teams.Billing.team_member_limit(team)
end
test "returns 5 when user in on trial" do
- user =
- insert(:user,
- trial_expiry_date: Timex.shift(Timex.now(), days: 7)
- )
+ team = new_user(trial_expiry_date: Date.shift(Date.utc_today(), day: 7)) |> team_of()
- assert 3 == Quota.Limits.team_member_limit(user)
+ assert 3 == Plausible.Teams.Billing.team_member_limit(team)
end
test "returns the enterprise plan limit" do
@@ -477,39 +429,33 @@ defmodule Plausible.Billing.QuotaTest do
end
test "reads from json file when the user is on a v4 plan" do
- user_on_growth = insert(:user, subscription: build(:growth_subscription))
+ team_on_growth = new_user() |> subscribe_to_growth_plan() |> team_of()
+ team_on_business = new_user() |> subscribe_to_business_plan() |> team_of()
- user_on_business = insert(:user, subscription: build(:business_subscription))
-
- assert 3 == Quota.Limits.team_member_limit(user_on_growth)
- assert 10 == Quota.Limits.team_member_limit(user_on_business)
+ assert 3 == Plausible.Teams.Billing.team_member_limit(team_on_growth)
+ assert 10 == Plausible.Teams.Billing.team_member_limit(team_on_business)
end
test "returns unlimited when user is on a v3 business plan" do
- user =
- insert(:user, subscription: build(:subscription, paddle_plan_id: @v3_business_plan_id))
+ team = new_user() |> subscribe_to_plan(@v3_business_plan_id) |> team_of()
- assert :unlimited == Quota.Limits.team_member_limit(user)
+ assert :unlimited == Plausible.Teams.Billing.team_member_limit(team)
end
end
describe "features_usage/2" do
test "returns an empty list for a user/site who does not use any feature" do
- assert [] == Quota.Usage.features_usage(insert(:user))
- assert [] == Quota.Usage.features_usage(nil, [insert(:site).id])
+ assert [] == Plausible.Teams.Billing.features_usage(team_of(new_user()))
+ assert [] == Plausible.Teams.Billing.features_usage(nil, [new_site().id])
end
test "returns [Props] when user/site uses custom props" do
- user = insert(:user)
-
- site =
- insert(:site,
- allowed_event_props: ["dummy"],
- memberships: [build(:site_membership, user: user, role: :owner)]
- )
+ user = new_user()
+ site = new_site(owner: user, allowed_event_props: ["dummy"])
+ team = team_of(user)
- assert [Props] == Quota.Usage.features_usage(nil, [site.id])
- assert [Props] == Quota.Usage.features_usage(user)
+ assert [Props] == Plausible.Teams.Billing.features_usage(nil, [site.id])
+ assert [Props] == Plausible.Teams.Billing.features_usage(team)
end
on_ee do
@@ -527,30 +473,32 @@ defmodule Plausible.Billing.QuotaTest do
end
test "returns [RevenueGoals] when user/site uses revenue goals" do
- user = insert(:user)
- site = insert(:site, memberships: [build(:site_membership, user: user, role: :owner)])
+ user = new_user()
+ team = team_of(user)
+ site = new_site(owner: user)
insert(:goal, currency: :USD, site: site, event_name: "Purchase")
- assert [RevenueGoals] == Quota.Usage.features_usage(nil, [site.id])
- assert [RevenueGoals] == Quota.Usage.features_usage(user)
+ assert [RevenueGoals] == Plausible.Teams.Billing.features_usage(nil, [site.id])
+ assert [RevenueGoals] == Plausible.Teams.Billing.features_usage(team)
end
end
test "returns [StatsAPI] when user has a stats api key" do
- user = insert(:user)
+ user = new_user()
+ team = team_of(user)
insert(:api_key, user: user)
- assert [StatsAPI] == Quota.Usage.features_usage(user)
+ assert [StatsAPI] == Plausible.Teams.Billing.features_usage(team)
end
test "returns feature usage based on a user and a custom list of site_ids" do
- user = insert(:user)
+ user = new_user()
+ team = team_of(user)
insert(:api_key, user: user)
-
- site_using_props = insert(:site, allowed_event_props: ["dummy"])
+ site_using_props = new_site(allowed_event_props: ["dummy"])
site_ids = [site_using_props.id]
- assert [Props, StatsAPI] == Quota.Usage.features_usage(user, site_ids)
+ assert [Props, StatsAPI] == Plausible.Teams.Billing.features_usage(team, site_ids)
end
on_ee do
@@ -585,24 +533,26 @@ defmodule Plausible.Billing.QuotaTest do
describe "allowed_features_for/1" do
on_ee do
test "users with expired trials have no access to subscription features" do
- user = insert(:user, trial_expiry_date: ~D[2023-01-01])
- assert [Goals] == Quota.Limits.allowed_features_for(user)
+ team = new_user(trial_expiry_date: ~D[2023-01-01]) |> team_of()
+ assert [Goals] == Plausible.Teams.Billing.allowed_features_for(team)
end
end
test "returns all grandfathered features when user is on an old plan" do
- user_on_v1 = insert(:user, subscription: build(:subscription, paddle_plan_id: @v1_plan_id))
- user_on_v2 = insert(:user, subscription: build(:subscription, paddle_plan_id: @v2_plan_id))
- user_on_v3 = insert(:user, subscription: build(:subscription, paddle_plan_id: @v3_plan_id))
+ team_on_v1 = new_user() |> subscribe_to_plan(@v1_plan_id) |> team_of()
+ team_on_v2 = new_user() |> subscribe_to_plan(@v2_plan_id) |> team_of()
+ team_on_v3 = new_user() |> subscribe_to_plan(@v3_plan_id) |> team_of()
- assert [Goals, Props, StatsAPI] == Quota.Limits.allowed_features_for(user_on_v1)
- assert [Goals, Props, StatsAPI] == Quota.Limits.allowed_features_for(user_on_v2)
- assert [Goals, Props, StatsAPI] == Quota.Limits.allowed_features_for(user_on_v3)
+ assert [Goals, Props, StatsAPI] == Plausible.Teams.Billing.allowed_features_for(team_on_v1)
+ assert [Goals, Props, StatsAPI] == Plausible.Teams.Billing.allowed_features_for(team_on_v2)
+ assert [Goals, Props, StatsAPI] == Plausible.Teams.Billing.allowed_features_for(team_on_v3)
end
test "returns [Goals, Props, StatsAPI] when user is on free_10k plan" do
- user = insert(:user, subscription: build(:subscription, paddle_plan_id: "free_10k"))
- assert [Goals, Props, StatsAPI] == Quota.Limits.allowed_features_for(user)
+ user = new_user()
+ subscribe_to_plan(user, "free_10k")
+ team = team_of(user)
+ assert [Goals, Props, StatsAPI] == Plausible.Teams.Billing.allowed_features_for(team)
end
on_ee do
@@ -623,29 +573,28 @@ defmodule Plausible.Billing.QuotaTest do
end
test "returns all features when user in on trial" do
- user = insert(:user, trial_expiry_date: Timex.shift(Timex.now(), days: 7))
+ team = new_user(trial_expiry_date: Date.shift(Date.utc_today(), day: 7))
- assert Plausible.Billing.Feature.list() == Quota.Limits.allowed_features_for(user)
+ assert Plausible.Billing.Feature.list() ==
+ Plausible.Teams.Billing.allowed_features_for(team)
end
test "returns previous plan limits for enterprise users who have not paid yet" do
user =
- insert(:user,
- enterprise_plan: build(:enterprise_plan, paddle_plan_id: "123321"),
- subscription: build(:subscription, paddle_plan_id: @v1_plan_id)
- )
+ new_user()
+ |> subscribe_to_plan(@v1_plan_id)
+ |> subscribe_to_enterprise_plan(subscription?: false)
+
+ team = team_of(user)
- assert [Goals, Props, StatsAPI] == Quota.Limits.allowed_features_for(user)
+ assert [Goals, Props, StatsAPI] == Plausible.Teams.Billing.allowed_features_for(team)
end
test "returns all features for enterprise users who have not upgraded yet and are on trial" do
- user =
- insert(:user,
- enterprise_plan: build(:enterprise_plan, paddle_plan_id: "123321"),
- subscription: nil
- )
+ team = new_user() |> subscribe_to_enterprise_plan(subscription?: false) |> team_of()
- assert Plausible.Billing.Feature.list() == Quota.Limits.allowed_features_for(user)
+ assert Plausible.Billing.Feature.list() ==
+ Plausible.Teams.Billing.allowed_features_for(team)
end
test "returns old plan features for enterprise customers who are due to change a plan" do
@@ -670,9 +619,7 @@ defmodule Plausible.Billing.QuotaTest do
describe "monthly_pageview_usage/2" do
test "returns empty usage for user without subscription and without any sites" do
- user =
- insert(:user)
- |> Plausible.Users.with_subscription()
+ team = new_user() |> team_of()
assert %{
last_30_days: %{
@@ -681,18 +628,16 @@ defmodule Plausible.Billing.QuotaTest do
pageviews: 0,
date_range: date_range
}
- } = Quota.Usage.monthly_pageview_usage(user)
+ } = Plausible.Teams.Billing.monthly_pageview_usage(team)
assert date_range.last == Date.utc_today()
assert Date.compare(date_range.first, date_range.last) == :lt
end
test "returns usage for user without subscription with a site" do
- user =
- insert(:user)
- |> Plausible.Users.with_subscription()
-
- site = insert(:site, members: [user])
+ user = new_user()
+ site = new_site(owner: user)
+ team = team_of(user)
now = NaiveDateTime.utc_now()
@@ -712,12 +657,13 @@ defmodule Plausible.Billing.QuotaTest do
pageviews: 3,
date_range: %{}
}
- } = Quota.Usage.monthly_pageview_usage(user)
+ } = Plausible.Teams.Billing.monthly_pageview_usage(team)
end
test "pageleave events are not counted towards monthly pageview usage" do
- user = insert(:user) |> Plausible.Users.with_subscription()
- site = insert(:site, members: [user])
+ user = new_user()
+ site = new_site(owner: user)
+ team = team_of(user)
now = NaiveDateTime.utc_now()
populate_stats(site, [
@@ -733,18 +679,16 @@ defmodule Plausible.Billing.QuotaTest do
pageviews: 1,
date_range: %{}
}
- } = Quota.Usage.monthly_pageview_usage(user)
+ } = Plausible.Teams.Billing.monthly_pageview_usage(team)
end
test "returns usage for user with subscription and a site" do
today = Date.utc_today()
+ user = new_user()
+ subscribe_to_growth_plan(user, last_bill_date: Date.shift(today, day: -8))
+ team = team_of(user)
- user =
- insert(:user,
- subscription: build(:subscription, last_bill_date: Timex.shift(today, days: -8))
- )
-
- site = insert(:site, members: [user])
+ site = new_site(owner: user)
now = NaiveDateTime.utc_now()
@@ -776,20 +720,19 @@ defmodule Plausible.Billing.QuotaTest do
pageviews: 0,
date_range: %{}
}
- } = Quota.Usage.monthly_pageview_usage(user)
+ } = Plausible.Teams.Billing.monthly_pageview_usage(team)
end
test "returns usage for only a subset of site IDs" do
today = Date.utc_today()
- user =
- insert(:user,
- subscription: build(:subscription, last_bill_date: Timex.shift(today, days: -8))
- )
+ user = new_user()
+ subscribe_to_growth_plan(user, last_bill_date: Date.shift(today, day: -8))
+ team = team_of(user)
- site1 = insert(:site, members: [user])
- site2 = insert(:site, members: [user])
- site3 = insert(:site, members: [user])
+ site1 = new_site(owner: user)
+ site2 = new_site(owner: user)
+ site3 = new_site(owner: user)
now = NaiveDateTime.utc_now()
@@ -823,14 +766,15 @@ defmodule Plausible.Billing.QuotaTest do
pageviews: 0,
date_range: %{}
}
- } = Quota.Usage.monthly_pageview_usage(user, [site1.id, site3.id])
+ } = Plausible.Teams.Billing.monthly_pageview_usage(team, [site1.id, site3.id])
end
end
describe "usage_cycle/1" do
setup do
- user = insert(:user)
- site = insert(:site, members: [user])
+ user = new_user()
+ site = new_site(owner: user)
+ team = team_of(user)
populate_stats(site, [
build(:event, timestamp: ~N[2023-04-01 00:00:00], name: "custom"),
@@ -850,45 +794,41 @@ defmodule Plausible.Billing.QuotaTest do
build(:event, timestamp: ~N[2023-06-05 00:00:00], name: "custom")
])
- {:ok, %{user: user}}
+ {:ok, %{user: user, team: team}}
end
- test "returns usage and date_range for the given billing month", %{user: user} do
+ test "returns usage and date_range for the given billing month", %{user: user, team: team} do
last_bill_date = ~D[2023-06-03]
today = ~D[2023-06-05]
- insert(:subscription, user_id: user.id, last_bill_date: last_bill_date)
+ subscribe_to_growth_plan(user, last_bill_date: last_bill_date)
assert %{date_range: penultimate_cycle, pageviews: 2, custom_events: 3, total: 5} =
- Quota.Usage.usage_cycle(user, :penultimate_cycle, nil, today)
+ Plausible.Teams.Billing.usage_cycle(team, :penultimate_cycle, nil, today)
assert %{date_range: last_cycle, pageviews: 3, custom_events: 2, total: 5} =
- Quota.Usage.usage_cycle(user, :last_cycle, nil, today)
+ Plausible.Teams.Billing.usage_cycle(team, :last_cycle, nil, today)
assert %{date_range: current_cycle, pageviews: 0, custom_events: 3, total: 3} =
- Quota.Usage.usage_cycle(user, :current_cycle, nil, today)
+ Plausible.Teams.Billing.usage_cycle(team, :current_cycle, nil, today)
assert penultimate_cycle == Date.range(~D[2023-04-03], ~D[2023-05-02])
assert last_cycle == Date.range(~D[2023-05-03], ~D[2023-06-02])
assert current_cycle == Date.range(~D[2023-06-03], ~D[2023-07-02])
end
- test "returns usage and date_range for the last 30 days", %{user: user} do
+ test "returns usage and date_range for the last 30 days", %{team: team} do
today = ~D[2023-06-01]
assert %{date_range: last_30_days, pageviews: 4, custom_events: 1, total: 5} =
- Quota.Usage.usage_cycle(user, :last_30_days, nil, today)
+ Plausible.Teams.Billing.usage_cycle(team, :last_30_days, nil, today)
assert last_30_days == Date.range(~D[2023-05-02], ~D[2023-06-01])
end
- test "only considers sites that the user owns", %{user: user} do
- different_site =
- insert(:site,
- memberships: [
- build(:site_membership, user: user, role: :admin)
- ]
- )
+ test "only considers sites that the user owns", %{user: user, team: team} do
+ different_site = new_site()
+ add_guest(different_site, user: user, role: :editor)
populate_stats(different_site, [
build(:event, timestamp: ~N[2023-05-05 00:00:00], name: "custom")
@@ -897,10 +837,10 @@ defmodule Plausible.Billing.QuotaTest do
last_bill_date = ~D[2023-06-03]
today = ~D[2023-06-05]
- insert(:subscription, user_id: user.id, last_bill_date: last_bill_date)
+ subscribe_to_growth_plan(user, last_bill_date: last_bill_date)
assert %{date_range: last_cycle, pageviews: 3, custom_events: 2, total: 5} =
- Quota.Usage.usage_cycle(user, :last_cycle, nil, today)
+ Plausible.Teams.Billing.usage_cycle(team, :last_cycle, nil, today)
assert last_cycle == Date.range(~D[2023-05-03], ~D[2023-06-02])
end
@@ -909,16 +849,18 @@ defmodule Plausible.Billing.QuotaTest do
last_bill_date = ~D[2020-09-01]
today = ~D[2021-02-02]
- user = insert(:user, subscription: build(:subscription, last_bill_date: last_bill_date))
+ user = new_user()
+ subscribe_to_growth_plan(user, last_bill_date: last_bill_date)
+ team = team_of(user)
assert %{date_range: penultimate_cycle} =
- Quota.Usage.usage_cycle(user, :penultimate_cycle, nil, today)
+ Plausible.Teams.Billing.usage_cycle(team, :penultimate_cycle, nil, today)
assert %{date_range: last_cycle} =
- Quota.Usage.usage_cycle(user, :last_cycle, nil, today)
+ Plausible.Teams.Billing.usage_cycle(team, :last_cycle, nil, today)
assert %{date_range: current_cycle} =
- Quota.Usage.usage_cycle(user, :current_cycle, nil, today)
+ Plausible.Teams.Billing.usage_cycle(team, :current_cycle, nil, today)
assert penultimate_cycle == Date.range(~D[2020-12-01], ~D[2020-12-31])
assert last_cycle == Date.range(~D[2021-01-01], ~D[2021-01-31])
@@ -929,16 +871,18 @@ defmodule Plausible.Billing.QuotaTest do
last_bill_date = ~D[2021-01-01]
today = ~D[2021-01-02]
- user = insert(:user, subscription: build(:subscription, last_bill_date: last_bill_date))
+ user = new_user()
+ subscribe_to_growth_plan(user, last_bill_date: last_bill_date)
+ team = team_of(user)
assert %{date_range: penultimate_cycle, total: 0} =
- Quota.Usage.usage_cycle(user, :penultimate_cycle, nil, today)
+ Plausible.Teams.Billing.usage_cycle(team, :penultimate_cycle, nil, today)
assert %{date_range: last_cycle, total: 0} =
- Quota.Usage.usage_cycle(user, :last_cycle, nil, today)
+ Plausible.Teams.Billing.usage_cycle(team, :last_cycle, nil, today)
assert %{date_range: current_cycle, total: 0} =
- Quota.Usage.usage_cycle(user, :current_cycle, nil, today)
+ Plausible.Teams.Billing.usage_cycle(team, :current_cycle, nil, today)
assert penultimate_cycle == Date.range(~D[2020-11-01], ~D[2020-11-30])
assert last_cycle == Date.range(~D[2020-12-01], ~D[2020-12-31])
@@ -948,16 +892,19 @@ defmodule Plausible.Billing.QuotaTest do
describe "suggest_tier/2" do
setup do
- %{user: insert(:user) |> Plausible.Users.with_subscription()}
+ user = new_user()
+ team = user |> team_of() |> Plausible.Teams.with_subscription()
+ %{user: user, team: team}
end
test "returns nil if the monthly pageview limit exceeds regular plans",
- %{user: user} do
+ %{team: team} do
highest_growth_plan = Plausible.Billing.Plans.find(@v4_10m_growth_plan_id)
highest_business_plan = Plausible.Billing.Plans.find(@v4_10m_business_plan_id)
usage =
- Quota.Usage.usage(user)
+ team
+ |> Plausible.Teams.Billing.quota_usage()
|> Map.replace!(:monthly_pageviews, %{last_30_days: %{total: 12_000_000}})
suggested_tier =
diff --git a/test/plausible/billing/site_locker_test.exs b/test/plausible/billing/site_locker_test.exs
index 677fe38560..2b0b5cfdd4 100644
--- a/test/plausible/billing/site_locker_test.exs
+++ b/test/plausible/billing/site_locker_test.exs
@@ -7,15 +7,8 @@ defmodule Plausible.Billing.SiteLockerTest do
describe "update_sites_for/1" do
test "does not lock sites if user is on trial" do
- user = insert(:user, trial_expiry_date: Timex.today())
-
- site =
- insert(:site,
- locked: true,
- memberships: [
- build(:site_membership, user: user, role: :owner)
- ]
- )
+ user = new_user(trial_expiry_date: Date.utc_today())
+ site = new_site(owner: user, locked: true)
assert SiteLocker.update_sites_for(user) == :unlocked
@@ -23,16 +16,8 @@ defmodule Plausible.Billing.SiteLockerTest do
end
test "does not lock if user has an active subscription" do
- user = insert(:user)
- insert(:subscription, status: Subscription.Status.active(), user: user)
-
- site =
- insert(:site,
- locked: true,
- memberships: [
- build(:site_membership, user: user, role: :owner)
- ]
- )
+ user = new_user() |> subscribe_to_growth_plan()
+ site = new_site(owner: user)
assert SiteLocker.update_sites_for(user) == :unlocked
@@ -40,15 +25,8 @@ defmodule Plausible.Billing.SiteLockerTest do
end
test "does not lock user who is past due" do
- user = insert(:user)
- insert(:subscription, status: Subscription.Status.past_due(), user: user)
-
- site =
- insert(:site,
- memberships: [
- build(:site_membership, user: user, role: :owner)
- ]
- )
+ user = new_user() |> subscribe_to_growth_plan(status: Subscription.Status.past_due())
+ site = new_site(owner: user)
assert SiteLocker.update_sites_for(user) == :unlocked
@@ -56,15 +34,8 @@ defmodule Plausible.Billing.SiteLockerTest do
end
test "does not lock user who cancelled subscription but it hasn't expired yet" do
- user = insert(:user)
- insert(:subscription, status: Subscription.Status.deleted(), user: user)
-
- site =
- insert(:site,
- memberships: [
- build(:site_membership, user: user, role: :owner)
- ]
- )
+ user = new_user() |> subscribe_to_growth_plan(status: Subscription.Status.deleted())
+ site = new_site(owner: user)
assert SiteLocker.update_sites_for(user) == :unlocked
@@ -73,16 +44,12 @@ defmodule Plausible.Billing.SiteLockerTest do
test "does not lock user who has an active subscription and is on grace period" do
grace_period = %Plausible.Auth.GracePeriod{end_date: Timex.shift(Timex.today(), days: 1)}
- user = insert(:user, grace_period: grace_period)
- insert(:subscription, status: Subscription.Status.active(), user: user)
+ user =
+ new_user(grace_period: grace_period, team: [grace_period: grace_period])
+ |> subscribe_to_growth_plan()
- site =
- insert(:site,
- memberships: [
- build(:site_membership, user: user, role: :owner)
- ]
- )
+ site = new_site(owner: user)
assert SiteLocker.update_sites_for(user) == :unlocked
@@ -90,21 +57,15 @@ defmodule Plausible.Billing.SiteLockerTest do
end
test "locks user who cancelled subscription and the cancelled subscription has expired" do
- user = insert(:user, trial_expiry_date: Timex.shift(Timex.today(), days: -1))
-
- insert(:subscription,
- status: Subscription.Status.deleted(),
- next_bill_date: Timex.today() |> Timex.shift(days: -1),
- user: user
- )
-
- site =
- insert(:site,
- memberships: [
- build(:site_membership, user: user, role: :owner)
- ]
+ user =
+ new_user(trial_expiry_date: Date.shift(Date.utc_today(), day: -1))
+ |> subscribe_to_growth_plan(
+ next_bill_date: Date.utc_today() |> Date.shift(day: -1),
+ status: Subscription.Status.deleted()
)
+ site = new_site(owner: user)
+
assert SiteLocker.update_sites_for(user) == {:locked, :no_active_subscription}
assert Repo.reload!(site).locked
@@ -112,7 +73,7 @@ defmodule Plausible.Billing.SiteLockerTest do
test "locks all sites if user has active subscription but grace period has ended" do
grace_period = %Plausible.Auth.GracePeriod{end_date: Timex.shift(Timex.today(), days: -1)}
- user = new_user(grace_period: grace_period)
+ user = new_user(grace_period: grace_period, team: [grace_period: grace_period])
subscribe_to_plan(user, "123")
site = new_site(owner: user)
@@ -124,7 +85,7 @@ defmodule Plausible.Billing.SiteLockerTest do
@tag :teams
test "syncs grace period end with teams" do
grace_period = %Plausible.Auth.GracePeriod{end_date: Timex.shift(Timex.today(), days: -1)}
- user = new_user(grace_period: grace_period)
+ user = new_user(grace_period: grace_period, team: [grace_period: grace_period])
subscribe_to_plan(user, "123")
new_site(owner: user)
@@ -138,7 +99,7 @@ defmodule Plausible.Billing.SiteLockerTest do
test "sends email if grace period has ended" do
grace_period = %Plausible.Auth.GracePeriod{end_date: Timex.shift(Timex.today(), days: -1)}
- user = new_user(grace_period: grace_period)
+ user = new_user(grace_period: grace_period, team: [grace_period: grace_period])
subscribe_to_plan(user, "123")
new_site(owner: user)
@@ -156,7 +117,8 @@ defmodule Plausible.Billing.SiteLockerTest do
is_over: false
}
- user = new_user(grace_period: grace_period)
+ user = new_user(grace_period: grace_period, team: [grace_period: grace_period])
+
subscribe_to_plan(user, "123")
new_site(owner: user)
@@ -174,14 +136,8 @@ defmodule Plausible.Billing.SiteLockerTest do
end
test "locks all sites if user has no trial or active subscription" do
- user = insert(:user, trial_expiry_date: Timex.today() |> Timex.shift(days: -1))
-
- site =
- insert(:site,
- memberships: [
- build(:site_membership, user: user, role: :owner)
- ]
- )
+ user = new_user(trial_expiry_date: Date.utc_today() |> Date.shift(day: -1))
+ site = new_site(owner: user)
assert SiteLocker.update_sites_for(user) == {:locked, :no_active_subscription}
@@ -204,21 +160,11 @@ defmodule Plausible.Billing.SiteLockerTest do
end
test "only locks sites that the user owns" do
- user = insert(:user, trial_expiry_date: Timex.today() |> Timex.shift(days: -1))
-
- owner_site =
- insert(:site,
- memberships: [
- build(:site_membership, user: user, role: :owner)
- ]
- )
+ user = new_user(trial_expiry_date: Date.utc_today() |> Date.shift(day: -1))
- viewer_site =
- insert(:site,
- memberships: [
- build(:site_membership, user: user, role: :viewer)
- ]
- )
+ owner_site = new_site(owner: user)
+ viewer_site = new_site()
+ add_guest(viewer_site, user: user, role: :viewer)
assert SiteLocker.update_sites_for(user) == {:locked, :no_active_subscription}
diff --git a/test/plausible/site/memberships/accept_invitation_test.exs b/test/plausible/site/memberships/accept_invitation_test.exs
index cc3f6be461..289fdc06de 100644
--- a/test/plausible/site/memberships/accept_invitation_test.exs
+++ b/test/plausible/site/memberships/accept_invitation_test.exs
@@ -18,7 +18,6 @@ defmodule Plausible.Site.Memberships.AcceptInvitationTest do
assert {:ok, _} =
AcceptInvitation.bulk_transfer_ownership_direct(
- current_owner,
[site1, site2],
new_owner
)
@@ -39,7 +38,6 @@ defmodule Plausible.Site.Memberships.AcceptInvitationTest do
assert {:error, :transfer_to_self} =
AcceptInvitation.bulk_transfer_ownership_direct(
- current_owner,
[site1, site2],
new_owner
)
@@ -56,7 +54,7 @@ defmodule Plausible.Site.Memberships.AcceptInvitationTest do
for _ <- 1..3, do: add_guest(site, role: :editor)
assert {:error, {:over_plan_limits, [:team_member_limit]}} =
- AcceptInvitation.bulk_transfer_ownership_direct(old_owner, [site], new_owner)
+ AcceptInvitation.bulk_transfer_ownership_direct([site], new_owner)
end
@tag :ee_only
@@ -68,7 +66,7 @@ defmodule Plausible.Site.Memberships.AcceptInvitationTest do
for _ <- 1..2, do: add_guest(site, role: :editor)
assert {:ok, _} =
- AcceptInvitation.bulk_transfer_ownership_direct(old_owner, [site], new_owner)
+ AcceptInvitation.bulk_transfer_ownership_direct([site], new_owner)
end
@tag :ee_only
@@ -81,7 +79,7 @@ defmodule Plausible.Site.Memberships.AcceptInvitationTest do
site = new_site(owner: old_owner)
assert {:error, {:over_plan_limits, [:site_limit]}} =
- AcceptInvitation.bulk_transfer_ownership_direct(old_owner, [site], new_owner)
+ AcceptInvitation.bulk_transfer_ownership_direct([site], new_owner)
end
@tag :ee_only
@@ -102,7 +100,7 @@ defmodule Plausible.Site.Memberships.AcceptInvitationTest do
for _ <- 1..3, do: add_guest(site, role: :editor)
assert {:error, {:over_plan_limits, [:team_member_limit, :site_limit]}} =
- AcceptInvitation.bulk_transfer_ownership_direct(old_owner, [site], new_owner)
+ AcceptInvitation.bulk_transfer_ownership_direct([site], new_owner)
end
end
diff --git a/test/plausible/site/sites_test.exs b/test/plausible/site/sites_test.exs
index eb1b38bd6b..7c6494939f 100644
--- a/test/plausible/site/sites_test.exs
+++ b/test/plausible/site/sites_test.exs
@@ -162,15 +162,15 @@ defmodule Plausible.SitesTest do
patch_env(:super_admin_user_ids, [user2.id])
%{id: site_id, domain: domain} = new_site(owner: user1)
- assert %{id: ^site_id} = Plausible.Teams.Adapter.Read.Sites.get_for_user(user1, domain)
+ assert %{id: ^site_id} = Plausible.Sites.get_for_user(user1, domain)
assert %{id: ^site_id} =
- Plausible.Teams.Adapter.Read.Sites.get_for_user(user1, domain, [:owner])
+ Plausible.Sites.get_for_user(user1, domain, [:owner])
- assert is_nil(Plausible.Teams.Adapter.Read.Sites.get_for_user(user2, domain))
+ assert is_nil(Plausible.Sites.get_for_user(user2, domain))
assert %{id: ^site_id} =
- Plausible.Teams.Adapter.Read.Sites.get_for_user(user2, domain, [:super_admin])
+ Plausible.Sites.get_for_user(user2, domain, [:super_admin])
end
end
diff --git a/test/plausible_web/controllers/settings_controller_test.exs b/test/plausible_web/controllers/settings_controller_test.exs
index 8d9c2fea2c..17a8b12e33 100644
--- a/test/plausible_web/controllers/settings_controller_test.exs
+++ b/test/plausible_web/controllers/settings_controller_test.exs
@@ -1063,12 +1063,9 @@ defmodule PlausibleWeb.SettingsControllerTest do
end
test "can't create api key into another site", %{conn: conn, user: me} do
- _my_site = insert(:site, memberships: [build(:site_membership, user: me, role: "owner")])
-
- other_user = insert(:user)
-
- _other_site =
- insert(:site, memberships: [build(:site_membership, user: other_user, role: "owner")])
+ _my_site = new_site(owner: me)
+ other_user = new_user()
+ _other_site = new_site(owner: other_user)
conn =
post(conn, Routes.settings_path(conn, :api_keys), %{
diff --git a/test/plausible_web/controllers/site_controller_test.exs b/test/plausible_web/controllers/site_controller_test.exs
index 35ad8e229e..a878949f1d 100644
--- a/test/plausible_web/controllers/site_controller_test.exs
+++ b/test/plausible_web/controllers/site_controller_test.exs
@@ -342,6 +342,7 @@ defmodule PlausibleWeb.SiteControllerTest do
user: user
} do
subscribe_to_enterprise_plan(user, site_limit: 1)
+ team = team_of(user)
new_site(owner: user)
new_site(owner: user)
@@ -354,7 +355,7 @@ defmodule PlausibleWeb.SiteControllerTest do
})
assert redirected_to(conn) == "/example.com/installation?site_created=true&flow="
- assert Plausible.Billing.Quota.Usage.site_usage(user) == 3
+ assert Plausible.Teams.Billing.site_usage(team) == 3
end
for url <- ["https://Example.com/", "HTTPS://EXAMPLE.COM/", "/Example.com/", "//Example.com/"] do
diff --git a/test/plausible_web/controllers/unsubscribe_controller_test.exs b/test/plausible_web/controllers/unsubscribe_controller_test.exs
index 17cf229e66..4abb3acca1 100644
--- a/test/plausible_web/controllers/unsubscribe_controller_test.exs
+++ b/test/plausible_web/controllers/unsubscribe_controller_test.exs
@@ -1,12 +1,13 @@
defmodule PlausibleWeb.UnsubscribeControllerTest do
use PlausibleWeb.ConnCase, async: true
use Plausible.Repo
+ use Plausible.Teams.Test
setup {PlausibleWeb.FirstLaunchPlug.Test, :skip}
describe "GET /sites/:domain/weekly-report/unsubscribe" do
test "removes a recipient from the weekly report without them having to log in", %{conn: conn} do
- site = insert(:site)
+ site = new_site()
insert(:weekly_report, site: site, recipients: ["[email protected]"])
conn =
@@ -35,7 +36,7 @@ defmodule PlausibleWeb.UnsubscribeControllerTest do
describe "GET /sites/:domain/monthly-report/unsubscribe" do
test "removes a recipient from the weekly report without them having to log in", %{conn: conn} do
- site = insert(:site)
+ site = new_site()
insert(:monthly_report, site: site, recipients: ["[email protected]"])
conn =
diff --git a/test/plausible_web/live/choose_plan_test.exs b/test/plausible_web/live/choose_plan_test.exs
index 4c90226ca4..523f2a0828 100644
--- a/test/plausible_web/live/choose_plan_test.exs
+++ b/test/plausible_web/live/choose_plan_test.exs
@@ -281,7 +281,7 @@ defmodule PlausibleWeb.Live.ChoosePlanTest do
user: user
} do
for _ <- 1..9, do: new_site(owner: user)
- assert 10 = Plausible.Teams.Adapter.Read.Billing.site_usage(user)
+ assert user |> team_of() |> Plausible.Teams.Billing.site_usage() == 10
another_user = new_user()
pending_ownership_site = new_site(owner: another_user)
@@ -611,11 +611,13 @@ defmodule PlausibleWeb.Live.ChoosePlanTest do
conn: conn,
user: user
} do
+ team = team_of(user)
+
for _ <- 1..49 do
new_site(owner: user)
end
- assert 50 = Plausible.Teams.Adapter.Read.Billing.quota_usage(user).sites
+ assert 50 = Plausible.Teams.Billing.quota_usage(team).sites
another_user = new_user()
pending_ownership_site = new_site(owner: another_user)
diff --git a/test/test_helper.exs b/test/test_helper.exs
index 87d50bcf40..3870088140 100644
--- a/test/test_helper.exs
+++ b/test/test_helper.exs
@@ -8,13 +8,6 @@ Application.ensure_all_started(:double)
FunWithFlags.enable(:channels)
FunWithFlags.enable(:scroll_depth)
-# Temporary flag to test `read_team_schemas` flag on all tests.
-if System.get_env("TEST_READ_TEAM_SCHEMAS") == "1" do
- IO.puts("READS TEAM SCHEMAS")
- FunWithFlags.enable(:read_team_schemas)
-else
- FunWithFlags.disable(:read_team_schemas)
-end
Ecto.Adapters.SQL.Sandbox.mode(Plausible.Repo, :manual)
diff --git a/test/workers/check_usage_test.exs b/test/workers/check_usage_test.exs
index 7706f924f7..aa36164adb 100644
--- a/test/workers/check_usage_test.exs
+++ b/test/workers/check_usage_test.exs
@@ -29,7 +29,7 @@ defmodule Plausible.Workers.CheckUsageTest do
user: user
} do
usage_stub =
- Plausible.Billing.Quota.Usage
+ Plausible.Teams.Billing
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
@@ -37,17 +37,17 @@ defmodule Plausible.Workers.CheckUsageTest do
}
end)
- insert(:subscription,
- user: user,
- paddle_plan_id: @paddle_id_10k,
- last_bill_date: Timex.shift(Timex.today(), days: -1),
+ subscribe_to_plan(
+ user,
+ @paddle_id_10k,
+ last_bill_date: Date.shift(Date.utc_today(), day: -1),
status: :active
)
- insert(:subscription,
- user: user,
- paddle_plan_id: "wont-exist-should-crash",
- last_bill_date: Timex.shift(Timex.today(), days: -1),
+ subscribe_to_plan(
+ user,
+ "wont-exist-should-crash",
+ last_bill_date: Date.shift(Date.utc_today(), day: -1),
inserted_at: DateTime.shift(DateTime.utc_now(), day: -2),
status: :deleted
)
@@ -62,7 +62,7 @@ defmodule Plausible.Workers.CheckUsageTest do
test "sends more than one email", %{user: user} do
usage_stub =
- Plausible.Billing.Quota.Usage
+ Plausible.Teams.Billing
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
@@ -74,11 +74,11 @@ defmodule Plausible.Workers.CheckUsageTest do
insert(:site, members: [user2])
for u <- [user, user2] do
- insert(:subscription,
- user: u,
- paddle_plan_id: @paddle_id_10k,
- last_bill_date: Timex.shift(Timex.today(), days: -1),
- next_bill_date: Timex.shift(Timex.today(), days: +5),
+ subscribe_to_plan(
+ u,
+ @paddle_id_10k,
+ last_bill_date: Date.shift(Date.utc_today(), day: -1),
+ next_bill_date: Date.shift(Date.utc_today(), day: +5),
status: :active
)
end
@@ -129,7 +129,7 @@ defmodule Plausible.Workers.CheckUsageTest do
user: user
} do
usage_stub =
- Plausible.Billing.Quota.Usage
+ Plausible.Teams.Billing
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 9_000},
@@ -154,7 +154,7 @@ defmodule Plausible.Workers.CheckUsageTest do
user: user
} do
usage_stub =
- Plausible.Billing.Quota.Usage
+ Plausible.Teams.Billing
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 10_999},
@@ -180,7 +180,7 @@ defmodule Plausible.Workers.CheckUsageTest do
user: user
} do
usage_stub =
- Plausible.Billing.Quota.Usage
+ Plausible.Teams.Billing
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
@@ -188,10 +188,10 @@ defmodule Plausible.Workers.CheckUsageTest do
}
end)
- insert(:subscription,
- user: user,
- paddle_plan_id: @paddle_id_10k,
- last_bill_date: Timex.shift(Timex.today(), days: -1),
+ subscribe_to_plan(
+ user,
+ @paddle_id_10k,
+ last_bill_date: Date.shift(Date.utc_today(), day: -1),
status: unquote(status)
)
@@ -211,7 +211,7 @@ defmodule Plausible.Workers.CheckUsageTest do
user: user
} do
usage_stub =
- Plausible.Billing.Quota.Usage
+ Plausible.Teams.Billing
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
@@ -219,10 +219,10 @@ defmodule Plausible.Workers.CheckUsageTest do
}
end)
- insert(:subscription,
- user: user,
- paddle_plan_id: @paddle_id_10k,
- last_bill_date: Timex.shift(Timex.today(), days: -1),
+ subscribe_to_plan(
+ user,
+ @paddle_id_10k,
+ last_bill_date: Date.shift(Date.utc_today(), day: -1),
status: unquote(status)
)
@@ -240,7 +240,7 @@ defmodule Plausible.Workers.CheckUsageTest do
user: user
} do
usage_stub =
- Plausible.Billing.Quota.Usage
+ Plausible.Teams.Billing
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000_000},
@@ -248,9 +248,9 @@ defmodule Plausible.Workers.CheckUsageTest do
}
end)
- insert(:subscription,
- user: user,
- paddle_plan_id: @paddle_id_10k,
+ subscribe_to_plan(
+ user,
+ @paddle_id_10k,
last_bill_date: Timex.shift(Timex.today(), days: -1),
status: unquote(status)
)
@@ -267,7 +267,7 @@ defmodule Plausible.Workers.CheckUsageTest do
%{grace_period: existing_grace_period} = Plausible.Users.start_grace_period(user)
usage_stub =
- Plausible.Billing.Quota.Usage
+ Plausible.Teams.Billing
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
@@ -292,7 +292,7 @@ defmodule Plausible.Workers.CheckUsageTest do
user: user
} do
usage_stub =
- Plausible.Billing.Quota.Usage
+ Plausible.Teams.Billing
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
@@ -300,9 +300,9 @@ defmodule Plausible.Workers.CheckUsageTest do
}
end)
- insert(:subscription,
- user: user,
- paddle_plan_id: @paddle_id_10k,
+ subscribe_to_plan(
+ user,
+ @paddle_id_10k,
last_bill_date: Timex.shift(Timex.today(), days: -1),
status: unquote(status)
)
@@ -318,7 +318,7 @@ defmodule Plausible.Workers.CheckUsageTest do
test "clears grace period when plan is applicable again", %{user: user} do
usage_stub =
- Plausible.Billing.Quota.Usage
+ Plausible.Teams.Billing
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
@@ -326,10 +326,10 @@ defmodule Plausible.Workers.CheckUsageTest do
}
end)
- insert(:subscription,
- user: user,
- paddle_plan_id: @paddle_id_10k,
- last_bill_date: Timex.shift(Timex.today(), days: -1),
+ subscribe_to_plan(
+ user,
+ @paddle_id_10k,
+ last_bill_date: Date.shift(Date.utc_today(), day: -1),
status: unquote(status)
)
@@ -337,7 +337,7 @@ defmodule Plausible.Workers.CheckUsageTest do
assert user |> Repo.reload() |> Plausible.Auth.GracePeriod.active?()
usage_stub =
- Plausible.Billing.Quota.Usage
+ Plausible.Teams.Billing
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
@@ -352,7 +352,7 @@ defmodule Plausible.Workers.CheckUsageTest do
@tag :teams
test "syncs clearing grace period with teams", %{user: user} do
usage_stub =
- Plausible.Billing.Quota.Usage
+ Plausible.Teams.Billing
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
@@ -360,9 +360,7 @@ defmodule Plausible.Workers.CheckUsageTest do
}
end)
- insert(:subscription,
- user: user,
- paddle_plan_id: @paddle_id_10k,
+ subscribe_to_plan(user, @paddle_id_10k,
last_bill_date: Timex.shift(Timex.today(), days: -1),
status: unquote(status)
)
@@ -374,7 +372,7 @@ defmodule Plausible.Workers.CheckUsageTest do
assert Plausible.Auth.GracePeriod.active?(team)
usage_stub =
- Plausible.Billing.Quota.Usage
+ Plausible.Teams.Billing
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
@@ -395,7 +393,7 @@ defmodule Plausible.Workers.CheckUsageTest do
Plausible.Users.start_manual_lock_grace_period(user)
usage_stub =
- Plausible.Billing.Quota.Usage
+ Plausible.Teams.Billing
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 1_100_000},
@@ -423,7 +421,7 @@ defmodule Plausible.Workers.CheckUsageTest do
user: user
} do
usage_stub =
- Plausible.Billing.Quota.Usage
+ Plausible.Teams.Billing
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 1_100_000},
@@ -453,7 +451,7 @@ defmodule Plausible.Workers.CheckUsageTest do
user: user
} do
usage_stub =
- Plausible.Billing.Quota.Usage
+ Plausible.Teams.Billing
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 1},
@@ -483,7 +481,7 @@ defmodule Plausible.Workers.CheckUsageTest do
test "manual lock grace period is synced with teams", %{user: user} do
usage_stub =
- Plausible.Billing.Quota.Usage
+ Plausible.Teams.Billing
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 1_100_000},
@@ -510,7 +508,7 @@ defmodule Plausible.Workers.CheckUsageTest do
test "starts grace period when plan is outgrown", %{user: user} do
usage_stub =
- Plausible.Billing.Quota.Usage
+ Plausible.Teams.Billing
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 1_100_000},
@@ -538,7 +536,7 @@ defmodule Plausible.Workers.CheckUsageTest do
user: user
} do
usage_stub =
- Plausible.Billing.Quota.Usage
+ Plausible.Teams.Billing
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
@@ -546,10 +544,10 @@ defmodule Plausible.Workers.CheckUsageTest do
}
end)
- insert(:subscription,
- user: user,
- paddle_plan_id: @paddle_id_10k,
- last_bill_date: Timex.shift(Timex.today(), days: -1)
+ subscribe_to_plan(
+ user,
+ @paddle_id_10k,
+ last_bill_date: Date.shift(Date.utc_today(), day: -1)
)
CheckUsage.perform(nil, usage_stub)
@@ -564,7 +562,7 @@ defmodule Plausible.Workers.CheckUsageTest do
user: user
} do
usage_stub =
- Plausible.Billing.Quota.Usage
+ Plausible.Teams.Billing
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
@@ -588,7 +586,7 @@ defmodule Plausible.Workers.CheckUsageTest do
user: user
} do
usage_stub =
- Plausible.Billing.Quota.Usage
+ Plausible.Teams.Billing
|> stub(:monthly_pageview_usage, fn _user ->
%{
penultimate_cycle: %{date_range: @date_range, total: 11_000},
@@ -596,9 +594,9 @@ defmodule Plausible.Workers.CheckUsageTest do
}
end)
- insert(:subscription,
- user: user,
- paddle_plan_id: @paddle_id_10k,
+ subscribe_to_plan(
+ user,
+ @paddle_id_10k,
last_bill_date: ~D[2021-06-29]
)
diff --git a/test/workers/lock_sites_test.exs b/test/workers/lock_sites_test.exs
index b8c27b4c97..041a919fda 100644
--- a/test/workers/lock_sites_test.exs
+++ b/test/workers/lock_sites_test.exs
@@ -1,17 +1,16 @@
defmodule Plausible.Workers.LockSitesTest do
use Plausible.DataCase, async: true
+ use Plausible.Teams.Test
require Plausible.Billing.Subscription.Status
alias Plausible.Workers.LockSites
alias Plausible.Billing.Subscription
test "does not lock enterprise site on grace period" do
user =
- :user
- |> build()
- |> Plausible.Auth.GracePeriod.start_manual_lock_changeset()
- |> Plausible.Repo.insert!()
+ new_user()
+ |> Plausible.Users.start_manual_lock_grace_period()
- site = insert(:site, members: [user])
+ site = new_site(owner: user)
LockSites.perform(nil)
@@ -19,8 +18,8 @@ defmodule Plausible.Workers.LockSitesTest do
end
test "does not lock trial user's site" do
- user = insert(:user, trial_expiry_date: Timex.today() |> Timex.shift(days: 1))
- site = insert(:site, members: [user])
+ user = new_user(trial_expiry_date: Date.utc_today() |> Date.shift(day: 1))
+ site = new_site(owner: user)
LockSites.perform(nil)
@@ -28,8 +27,8 @@ defmodule Plausible.Workers.LockSitesTest do
end
test "locks site for user whose trial has expired" do
- user = insert(:user, trial_expiry_date: Timex.today() |> Timex.shift(days: -1))
- site = insert(:site, members: [user])
+ user = new_user(trial_expiry_date: Date.utc_today() |> Date.shift(day: -1))
+ site = new_site(owner: user)
LockSites.perform(nil)
@@ -37,9 +36,8 @@ defmodule Plausible.Workers.LockSitesTest do
end
test "does not lock active subsriber's sites" do
- user = insert(:user)
- insert(:subscription, status: Subscription.Status.active(), user: user)
- site = insert(:site, members: [user])
+ user = new_user() |> subscribe_to_growth_plan(status: Subscription.Status.active())
+ site = new_site(owner: user)
LockSites.perform(nil)
@@ -47,9 +45,8 @@ defmodule Plausible.Workers.LockSitesTest do
end
test "does not lock user who is past due" do
- user = insert(:user)
- insert(:subscription, status: Subscription.Status.past_due(), user: user)
- site = insert(:site, members: [user])
+ user = new_user() |> subscribe_to_growth_plan(status: Subscription.Status.past_due())
+ site = new_site(owner: user)
LockSites.perform(nil)
@@ -57,9 +54,8 @@ defmodule Plausible.Workers.LockSitesTest do
end
test "does not lock user who cancelled subscription but it hasn't expired yet" do
- user = insert(:user)
- insert(:subscription, status: Subscription.Status.deleted(), user: user)
- site = insert(:site, members: [user])
+ user = new_user() |> subscribe_to_growth_plan(status: Subscription.Status.deleted())
+ site = new_site(owner: user)
LockSites.perform(nil)
@@ -67,15 +63,14 @@ defmodule Plausible.Workers.LockSitesTest do
end
test "locks user who cancelled subscription and the cancelled subscription has expired" do
- user = insert(:user, trial_expiry_date: Timex.today() |> Timex.shift(days: -1))
-
- insert(:subscription,
- status: Subscription.Status.deleted(),
- next_bill_date: Timex.today() |> Timex.shift(days: -1),
- user: user
- )
+ user =
+ new_user(trial_expiry_date: Date.utc_today() |> Date.shift(day: -1))
+ |> subscribe_to_growth_plan(
+ status: Subscription.Status.deleted(),
+ next_bill_date: Date.utc_today() |> Date.shift(day: -1)
+ )
- site = insert(:site, members: [user])
+ site = new_site(owner: user)
LockSites.perform(nil)
@@ -83,18 +78,16 @@ defmodule Plausible.Workers.LockSitesTest do
end
test "does not lock if user has an old cancelled subscription and a new active subscription" do
- user = insert(:user, trial_expiry_date: Timex.today() |> Timex.shift(days: -1))
-
- insert(:subscription,
- status: Subscription.Status.deleted(),
- next_bill_date: Timex.today() |> Timex.shift(days: -1),
- user: user,
- inserted_at: Timex.now() |> Timex.shift(days: -1)
- )
-
- insert(:subscription, status: Subscription.Status.active(), user: user)
-
- site = insert(:site, members: [user])
+ user =
+ new_user(trial_expiry_date: Date.utc_today() |> Date.shift(day: -1))
+ |> subscribe_to_growth_plan(
+ status: Subscription.Status.deleted(),
+ next_bill_date: Date.utc_today() |> Date.shift(day: -1),
+ inserted_at: NaiveDateTime.utc_now() |> NaiveDateTime.shift(day: -1)
+ )
+ |> subscribe_to_growth_plan(status: Subscription.Status.deleted())
+
+ site = new_site(owner: user)
LockSites.perform(nil)
diff --git a/test/workers/send_trial_notifications_test.exs b/test/workers/send_trial_notifications_test.exs
index bf111f9b5c..69eccdc029 100644
--- a/test/workers/send_trial_notifications_test.exs
+++ b/test/workers/send_trial_notifications_test.exs
@@ -6,10 +6,10 @@ defmodule Plausible.Workers.SendTrialNotificationsTest do
alias Plausible.Workers.SendTrialNotifications
test "does not send a notification if user didn't create a site" do
- insert(:user, trial_expiry_date: Timex.now() |> Timex.shift(days: 7))
- insert(:user, trial_expiry_date: Timex.now() |> Timex.shift(days: 1))
- insert(:user, trial_expiry_date: Timex.now() |> Timex.shift(days: 0))
- insert(:user, trial_expiry_date: Timex.now() |> Timex.shift(days: -1))
+ new_user(trial_expiry_date: Date.utc_today() |> Date.shift(day: 7))
+ new_user(trial_expiry_date: Date.utc_today() |> Date.shift(day: 1))
+ new_user(trial_expiry_date: Date.utc_today() |> Date.shift(day: 0))
+ new_user(trial_expiry_date: Date.utc_today() |> Date.shift(day: -1))
perform_job(SendTrialNotifications, %{})
@@ -17,8 +17,8 @@ defmodule Plausible.Workers.SendTrialNotificationsTest do
end
test "does not send a notification if user does not have a trial" do
- user = insert(:user, trial_expiry_date: nil)
- insert(:site, members: [user])
+ user = new_user(trial_expiry_date: nil)
+ new_site(members: user)
perform_job(SendTrialNotifications, %{})
@@ -26,8 +26,8 @@ defmodule Plausible.Workers.SendTrialNotificationsTest do
end
test "does not send a notification if user created a site but there are no pageviews" do
- user = insert(:user, trial_expiry_date: Timex.now() |> Timex.shift(days: 7))
- insert(:site, members: [user])
+ user = new_user(trial_expiry_date: Date.utc_today() |> Date.shift(day: 7))
+ new_site(owner: user)
perform_job(SendTrialNotifications, %{})
@@ -35,14 +35,9 @@ defmodule Plausible.Workers.SendTrialNotificationsTest do
end
test "does not send a notification if user is a collaborator on sites but not an owner" do
- user = insert(:user, trial_expiry_date: Timex.now())
-
- site =
- insert(:site,
- memberships: [
- build(:site_membership, user: user, role: :admin)
- ]
- )
+ user = new_user(trial_expiry_date: Date.utc_today())
+ site = new_site()
+ add_guest(site, user: user, role: :editor)
populate_stats(site, [build(:pageview)])
@@ -53,8 +48,8 @@ defmodule Plausible.Workers.SendTrialNotificationsTest do
describe "with site and pageviews" do
test "sends a reminder 7 days before trial ends (16 days after user signed up)" do
- user = insert(:user, trial_expiry_date: Timex.now() |> Timex.shift(days: 7))
- site = insert(:site, members: [user])
+ user = new_user(trial_expiry_date: Date.utc_today() |> Date.shift(day: 7))
+ site = new_site(owner: user)
populate_stats(site, [build(:pageview)])
perform_job(SendTrialNotifications, %{})
@@ -63,8 +58,8 @@ defmodule Plausible.Workers.SendTrialNotificationsTest do
end
test "sends an upgrade email the day before the trial ends" do
- user = insert(:user, trial_expiry_date: Timex.now() |> Timex.shift(days: 1))
- site = insert(:site, members: [user])
+ user = new_user(trial_expiry_date: Date.utc_today() |> Date.shift(day: 1))
+ site = new_site(owner: user)
usage = %{total: 3, custom_events: 0}
populate_stats(site, [
@@ -79,8 +74,8 @@ defmodule Plausible.Workers.SendTrialNotificationsTest do
end
test "sends an upgrade email the day the trial ends" do
- user = insert(:user, trial_expiry_date: Timex.today())
- site = insert(:site, members: [user])
+ user = new_user(trial_expiry_date: Date.utc_today())
+ site = new_site(owner: user)
usage = %{total: 3, custom_events: 0}
populate_stats(site, [
@@ -95,7 +90,7 @@ defmodule Plausible.Workers.SendTrialNotificationsTest do
end
test "does not include custom event note if user has not used custom events" do
- user = insert(:user, trial_expiry_date: Timex.today())
+ user = new_user(trial_expiry_date: Date.utc_today())
usage = %{total: 9_000, custom_events: 0}
email = PlausibleWeb.Email.trial_upgrade_email(user, "today", usage)
@@ -105,7 +100,7 @@ defmodule Plausible.Workers.SendTrialNotificationsTest do
end
test "includes custom event note if user has used custom events" do
- user = insert(:user, trial_expiry_date: Timex.today())
+ user = new_user(trial_expiry_date: Date.utc_today())
usage = %{total: 9_100, custom_events: 100}
email = PlausibleWeb.Email.trial_upgrade_email(user, "today", usage)
@@ -115,8 +110,8 @@ defmodule Plausible.Workers.SendTrialNotificationsTest do
end
test "sends a trial over email the day after the trial ends" do
- user = insert(:user, trial_expiry_date: Timex.today() |> Timex.shift(days: -1))
- site = insert(:site, members: [user])
+ user = new_user(trial_expiry_date: Date.utc_today() |> Date.shift(day: -1))
+ site = new_site(owner: user)
populate_stats(site, [
build(:pageview),
@@ -130,8 +125,8 @@ defmodule Plausible.Workers.SendTrialNotificationsTest do
end
test "does not send a notification if user has a subscription" do
- user = insert(:user, trial_expiry_date: Timex.now() |> Timex.shift(days: 7))
- site = insert(:site, members: [user])
+ user = new_user(trial_expiry_date: Date.utc_today() |> Date.shift(day: 7))
+ site = new_site(owner: user)
populate_stats(site, [
build(:pageview),
@@ -139,7 +134,7 @@ defmodule Plausible.Workers.SendTrialNotificationsTest do
build(:pageview)
])
- insert(:subscription, user: user)
+ subscribe_to_growth_plan(user)
perform_job(SendTrialNotifications, %{})
@@ -149,7 +144,7 @@ defmodule Plausible.Workers.SendTrialNotificationsTest do
describe "Suggested plans" do
test "suggests 10k/mo plan" do
- user = insert(:user)
+ user = new_user()
usage = %{total: 9_000, custom_events: 0}
email = PlausibleWeb.Email.trial_upgrade_email(user, "today", usage)
@@ -157,7 +152,7 @@ defmodule Plausible.Workers.SendTrialNotificationsTest do
end
test "suggests 100k/mo plan" do
- user = insert(:user)
+ user = new_user()
usage = %{total: 90_000, custom_events: 0}
email = PlausibleWeb.Email.trial_upgrade_email(user, "today", usage)
@@ -165,7 +160,7 @@ defmodule Plausible.Workers.SendTrialNotificationsTest do
end
test "suggests 200k/mo plan" do
- user = insert(:user)
+ user = new_user()
usage = %{total: 180_000, custom_events: 0}
email = PlausibleWeb.Email.trial_upgrade_email(user, "today", usage)
@@ -173,7 +168,7 @@ defmodule Plausible.Workers.SendTrialNotificationsTest do
end
test "suggests 500k/mo plan" do
- user = insert(:user)
+ user = new_user()
usage = %{total: 450_000, custom_events: 0}
email = PlausibleWeb.Email.trial_upgrade_email(user, "today", usage)
@@ -181,7 +176,7 @@ defmodule Plausible.Workers.SendTrialNotificationsTest do
end
test "suggests 1m/mo plan" do
- user = insert(:user)
+ user = new_user()
usage = %{total: 900_000, custom_events: 0}
email = PlausibleWeb.Email.trial_upgrade_email(user, "today", usage)
@@ -189,7 +184,7 @@ defmodule Plausible.Workers.SendTrialNotificationsTest do
end
test "suggests 2m/mo plan" do
- user = insert(:user)
+ user = new_user()
usage = %{total: 1_800_000, custom_events: 0}
email = PlausibleWeb.Email.trial_upgrade_email(user, "today", usage)
@@ -197,7 +192,7 @@ defmodule Plausible.Workers.SendTrialNotificationsTest do
end
test "suggests 5m/mo plan" do
- user = insert(:user)
+ user = new_user()
usage = %{total: 4_500_000, custom_events: 0}
email = PlausibleWeb.Email.trial_upgrade_email(user, "today", usage)
@@ -205,7 +200,7 @@ defmodule Plausible.Workers.SendTrialNotificationsTest do
end
test "suggests 10m/mo plan" do
- user = insert(:user)
+ user = new_user()
usage = %{total: 9_000_000, custom_events: 0}
email = PlausibleWeb.Email.trial_upgrade_email(user, "today", usage)
@@ -213,7 +208,7 @@ defmodule Plausible.Workers.SendTrialNotificationsTest do
end
test "does not suggest a plan above that" do
- user = insert(:user)
+ user = new_user()
usage = %{total: 20_000_000, custom_events: 0}
email = PlausibleWeb.Email.trial_upgrade_email(user, "today", usage)