Skip to content

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

Implement basics of Teams (#4658)

Adrian Gruntkowski17b12ddaeba2
diff --git a/.credo.exs b/.credo.exs
index 882e3a7c2d..f0f0f39804 100644
--- a/.credo.exs
+++ b/.credo.exs
@@ -83,7 +83,7 @@
# If you don't want TODO comments to cause `mix credo` to fail, just
# set this value to 0 (zero).
#
- {Credo.Check.Design.TagTODO, [exit_status: 2]},
+ {Credo.Check.Design.TagTODO, [exit_status: 0]},
{Credo.Check.Design.TagFIXME, []},
#
diff --git a/lib/mix/tasks/create_free_subscription.ex b/lib/mix/tasks/create_free_subscription.ex
index be0c7a993b..846e7ce0c8 100644
--- a/lib/mix/tasks/create_free_subscription.ex
+++ b/lib/mix/tasks/create_free_subscription.ex
@@ -15,10 +15,13 @@ defmodule Mix.Tasks.CreateFreeSubscription do
def execute(user_id) do
user = Repo.get(Plausible.Auth.User, user_id)
+ {:ok, team} = Plausible.Teams.get_or_create(user)
- Subscription.free(%{user_id: user_id})
+ Subscription.free(%{user_id: user_id, team_id: team.id})
|> Repo.insert!()
+ Plausible.Teams.sync_team(user)
+
IO.puts("Created a free subscription for user: #{user.name}")
end
end
diff --git a/lib/mix/tasks/pull_sandbox_subscription.ex b/lib/mix/tasks/pull_sandbox_subscription.ex
index 438b369516..7aad712547 100644
--- a/lib/mix/tasks/pull_sandbox_subscription.ex
+++ b/lib/mix/tasks/pull_sandbox_subscription.ex
@@ -40,6 +40,8 @@ defmodule Mix.Tasks.PullSandboxSubscription do
if body["success"] do
res = body["response"] |> List.first()
user = Repo.get_by!(User, email: res["user_email"])
+ {:ok, team} = Plausible.Teams.get_or_create(user)
+ Plausible.Teams.sync_team(user)
subscription = %{
paddle_subscription_id: res["subscription_id"] |> to_string(),
@@ -47,6 +49,7 @@ defmodule Mix.Tasks.PullSandboxSubscription do
cancel_url: res["cancel_url"],
update_url: res["update_url"],
user_id: user.id,
+ team_id: team.id,
status: res["state"],
last_bill_date: res["last_payment"]["date"],
next_bill_date: res["next_payment"]["date"],
diff --git a/lib/plausible.ex b/lib/plausible.ex
index b4c9226188..671892a203 100644
--- a/lib/plausible.ex
+++ b/lib/plausible.ex
@@ -4,6 +4,7 @@ defmodule Plausible do
"""
@ce_builds [:ce, :ce_test, :ce_dev]
+ @public_builds [:ce, :prod]
defmacro __using__(_) do
quote do
@@ -58,4 +59,12 @@ defmodule Plausible do
"Plausible Analytics"
end
end
+
+ defmacro with_teams(do: do_block) do
+ if Mix.env() in @public_builds do
+ quote do
+ unquote(do_block)
+ end
+ end
+ end
end
diff --git a/lib/plausible/auth/user.ex b/lib/plausible/auth/user.ex
index 116c1437f4..00aaed6390 100644
--- a/lib/plausible/auth/user.ex
+++ b/lib/plausible/auth/user.ex
@@ -53,6 +53,7 @@ defmodule Plausible.Auth.User do
has_many :sessions, Plausible.Auth.UserSession
has_many :site_memberships, Plausible.Site.Membership
+ has_many :team_memberships, Plausible.Teams.Membership
has_many :sites, through: [:site_memberships, :site]
has_many :api_keys, Plausible.Auth.ApiKey
has_one :google_auth, Plausible.Site.GoogleAuth
diff --git a/lib/plausible/auth/user_admin.ex b/lib/plausible/auth/user_admin.ex
index 4ebafa13ba..5be0fa09e0 100644
--- a/lib/plausible/auth/user_admin.ex
+++ b/lib/plausible/auth/user_admin.ex
@@ -62,10 +62,18 @@ defmodule Plausible.Auth.UserAdmin do
]
end
+ with_teams do
+ def after_update(_conn, user) do
+ Plausible.Teams.sync_team(user)
+
+ {:ok, user}
+ end
+ end
+
defp lock(user) do
if user.grace_period do
Plausible.Billing.SiteLocker.set_lock_status_for(user, true)
- user |> Plausible.Auth.GracePeriod.end_changeset() |> Repo.update()
+ {:ok, Plausible.Users.end_grace_period(user)}
else
{:error, user, "No active grace period on this user"}
end
@@ -73,7 +81,7 @@ defmodule Plausible.Auth.UserAdmin do
defp unlock(user) do
if user.grace_period do
- Plausible.Auth.GracePeriod.remove_changeset(user) |> Repo.update()
+ Plausible.Users.remove_grace_period(user)
Plausible.Billing.SiteLocker.set_lock_status_for(user, false)
{:ok, user}
else
diff --git a/lib/plausible/billing/billing.ex b/lib/plausible/billing/billing.ex
index 1278a07cfe..c8a3b4c5f0 100644
--- a/lib/plausible/billing/billing.ex
+++ b/lib/plausible/billing/billing.ex
@@ -120,10 +120,32 @@ defmodule Plausible.Billing do
defp handle_subscription_created(params) do
params =
if present?(params["passthrough"]) do
- params
+ case String.split(to_string(params["passthrough"]), ";") do
+ [user_id] ->
+ user = Repo.get!(User, user_id)
+ {:ok, team} = Plausible.Teams.get_or_create(user)
+ Map.put(params, "team_id", team.id)
+
+ [user_id, ""] ->
+ user = Repo.get!(User, user_id)
+ {:ok, team} = Plausible.Teams.get_or_create(user)
+
+ params
+ |> Map.put("passthrough", user_id)
+ |> Map.put("team_id", team.id)
+
+ [user_id, team_id] ->
+ params
+ |> Map.put("passthrough", user_id)
+ |> Map.put("team_id", team_id)
+ end
else
- user = Repo.get_by(User, email: params["email"])
- Map.put(params, "passthrough", user && user.id)
+ user = Repo.get_by!(User, email: params["email"])
+ {:ok, team} = Plausible.Teams.get_or_create(user)
+
+ params
+ |> Map.put("passthrough", user.id)
+ |> Map.put("team_id", team.id)
end
subscription_params = format_subscription(params) |> add_last_bill_date(params)
@@ -209,7 +231,7 @@ defmodule Plausible.Billing do
end
defp format_subscription(params) do
- %{
+ params = %{
paddle_subscription_id: params["subscription_id"],
paddle_plan_id: params["subscription_plan_id"],
cancel_url: params["cancel_url"],
@@ -220,6 +242,12 @@ defmodule Plausible.Billing do
next_bill_amount: params["unit_price"] || params["new_unit_price"],
currency_code: params["currency"]
}
+
+ if team_id = params["team_id"] do
+ Map.put(params, :team_id, team_id)
+ else
+ params
+ end
end
defp add_last_bill_date(subscription_params, paddle_params) do
@@ -236,12 +264,6 @@ defmodule Plausible.Billing do
defp present?(nil), do: false
defp present?(_), do: true
- defp remove_grace_period(%User{} = user) do
- user
- |> Plausible.Auth.GracePeriod.remove_changeset()
- |> Repo.update!()
- end
-
@spec format_price(Money.t()) :: String.t()
def format_price(money) do
Money.to_string!(money, fractional_digits: 2, no_fraction_if_integer: true)
@@ -275,7 +297,7 @@ defmodule Plausible.Billing do
user
|> Plausible.Users.update_accept_traffic_until()
- |> remove_grace_period()
+ |> Plausible.Users.remove_grace_period()
|> Plausible.Users.maybe_reset_next_upgrade_override()
|> tap(&Plausible.Billing.SiteLocker.update_sites_for/1)
|> maybe_adjust_api_key_limits()
diff --git a/lib/plausible/billing/enterprise_plan.ex b/lib/plausible/billing/enterprise_plan.ex
index 54fa7be425..2a224cce2d 100644
--- a/lib/plausible/billing/enterprise_plan.ex
+++ b/lib/plausible/billing/enterprise_plan.ex
@@ -13,6 +13,10 @@ defmodule Plausible.Billing.EnterprisePlan do
:team_member_limit
]
+ @optional_fields [
+ :team_id
+ ]
+
schema "enterprise_plans" do
field :paddle_plan_id, :string
field :billing_interval, Ecto.Enum, values: [:monthly, :yearly]
@@ -23,13 +27,14 @@ defmodule Plausible.Billing.EnterprisePlan do
field :hourly_api_request_limit, :integer
belongs_to :user, Plausible.Auth.User
+ belongs_to :team, Plausible.Teams.Team
timestamps()
end
def changeset(model, attrs \\ %{}) do
model
- |> cast(attrs, @required_fields)
+ |> cast(attrs, @required_fields ++ @optional_fields)
|> validate_required(@required_fields)
|> unique_constraint(:user_id)
end
diff --git a/lib/plausible/billing/enterprise_plan_admin.ex b/lib/plausible/billing/enterprise_plan_admin.ex
index b88b1944b2..027fdbe706 100644
--- a/lib/plausible/billing/enterprise_plan_admin.ex
+++ b/lib/plausible/billing/enterprise_plan_admin.ex
@@ -51,6 +51,16 @@ defmodule Plausible.Billing.EnterprisePlanAdmin do
def create_changeset(schema, attrs) do
attrs = sanitize_attrs(attrs)
+
+ team_id =
+ if user_id = attrs["user_id"] do
+ user = Repo.get!(Plausible.Auth.User, user_id)
+ {:ok, team} = Plausible.Teams.get_or_create(user)
+ team.id
+ end
+
+ attrs = Map.put(attrs, "team_id", team_id)
+
Plausible.Billing.EnterprisePlan.changeset(schema, attrs)
end
diff --git a/lib/plausible/billing/site_locker.ex b/lib/plausible/billing/site_locker.ex
index 11b2c42280..de47bdefa0 100644
--- a/lib/plausible/billing/site_locker.ex
+++ b/lib/plausible/billing/site_locker.ex
@@ -21,9 +21,7 @@ defmodule Plausible.Billing.SiteLocker do
set_lock_status_for(user, true)
if user.grace_period.is_over != true do
- user
- |> Plausible.Auth.GracePeriod.end_changeset()
- |> Repo.update!()
+ Plausible.Users.end_grace_period(user)
if send_email? do
send_grace_period_end_email(user)
diff --git a/lib/plausible/billing/subscription.ex b/lib/plausible/billing/subscription.ex
index e5c72af0fd..f328a30dc0 100644
--- a/lib/plausible/billing/subscription.ex
+++ b/lib/plausible/billing/subscription.ex
@@ -20,7 +20,7 @@ defmodule Plausible.Billing.Subscription do
:currency_code
]
- @optional_fields [:last_bill_date]
+ @optional_fields [:last_bill_date, :team_id]
schema "subscriptions" do
field :paddle_subscription_id, :string
@@ -34,6 +34,7 @@ defmodule Plausible.Billing.Subscription do
field :currency_code, :string
belongs_to :user, Plausible.Auth.User
+ belongs_to :team, Plausible.Teams.Team
timestamps()
end
@@ -52,7 +53,7 @@ defmodule Plausible.Billing.Subscription do
next_bill_amount: "0",
currency_code: "EUR"
}
- |> cast(attrs, @required_fields)
+ |> cast(attrs, @required_fields ++ @optional_fields)
|> validate_required([:user_id])
|> unique_constraint(:paddle_subscription_id)
end
diff --git a/lib/plausible/data_migration.ex b/lib/plausible/data_migration.ex
index 838b101ad5..e33d553706 100644
--- a/lib/plausible/data_migration.ex
+++ b/lib/plausible/data_migration.ex
@@ -6,7 +6,7 @@ defmodule Plausible.DataMigration do
defmacro __using__(opts) do
dir = Keyword.fetch!(opts, :dir)
- repo = Keyword.get(opts, :repo, Plausible.DataMigration.Repo)
+ repo = Keyword.get(opts, :repo, Plausible.DataMigration.ClickhouseRepo)
quote bind_quoted: [dir: dir, repo: repo] do
@dir dir
diff --git a/lib/plausible/data_migration/backfill_teams.ex b/lib/plausible/data_migration/backfill_teams.ex
new file mode 100644
index 0000000000..9e544f1017
--- /dev/null
+++ b/lib/plausible/data_migration/backfill_teams.ex
@@ -0,0 +1,724 @@
+defmodule Plausible.DataMigration.BackfillTeams do
+ @moduledoc """
+ Backfill and sync all teams related entities.
+ """
+
+ import Ecto.Query
+
+ alias Plausible.Auth
+ alias Plausible.Teams
+
+ @repo Plausible.DataMigration.PostgresRepo
+
+ defmacrop is_distinct(f1, f2) do
+ quote do
+ fragment("? IS DISTINCT FROM ?", unquote(f1), unquote(f2))
+ end
+ end
+
+ def run() do
+ # Teams backfill
+ db_url =
+ System.get_env(
+ "TEAMS_MIGRATION_DB_URL",
+ Application.get_env(:plausible, Plausible.Repo)[:url]
+ )
+
+ @repo.start(db_url, pool_size: System.schedulers_online() * 2)
+
+ backfill()
+ end
+
+ defp backfill() do
+ sites_without_teams =
+ from(
+ s in Plausible.Site,
+ inner_join: m in assoc(s, :memberships),
+ inner_join: o in assoc(m, :user),
+ where: m.role == :owner,
+ where: is_nil(s.team_id),
+ preload: [memberships: {m, user: o}]
+ )
+ |> @repo.all(timeout: :infinity)
+
+ log("Found #{length(sites_without_teams)} sites without teams...")
+
+ teams_count = backfill_teams(sites_without_teams)
+
+ log("Backfilled #{teams_count} teams.")
+
+ owner_site_memberships_query =
+ from(
+ tm in Plausible.Site.Membership,
+ where: tm.user_id == parent_as(:user).id,
+ where: tm.role == :owner,
+ select: 1
+ )
+
+ users_with_subscriptions_without_sites =
+ from(
+ s in Plausible.Billing.Subscription,
+ inner_join: u in assoc(s, :user),
+ as: :user,
+ where: not exists(owner_site_memberships_query),
+ where: is_nil(s.team_id),
+ select: u,
+ distinct: true
+ )
+ |> @repo.all(timeout: :infinity)
+
+ log(
+ "Found #{length(users_with_subscriptions_without_sites)} users with subscriptions without sites..."
+ )
+
+ teams_count = backfill_teams_for_users(users_with_subscriptions_without_sites)
+
+ log("Backfilled #{teams_count} teams from users with subscriptions without sites.")
+
+ # Stale teams sync
+
+ stale_teams =
+ from(
+ t in Teams.Team,
+ inner_join: tm in assoc(t, :team_memberships),
+ inner_join: o in assoc(tm, :user),
+ where: tm.role == :owner,
+ where:
+ is_distinct(o.trial_expiry_date, t.trial_expiry_date) or
+ is_distinct(o.accept_traffic_until, t.accept_traffic_until) or
+ is_distinct(o.allow_next_upgrade_override, t.allow_next_upgrade_override) or
+ is_distinct(o.grace_period["id"], t.grace_period["id"]) or
+ is_distinct(o.grace_period["is_over"], t.grace_period["is_over"]) or
+ is_distinct(o.grace_period["end_date"], t.grace_period["end_date"]) or
+ is_distinct(o.grace_period["manual_lock"], t.grace_period["manual_lock"]),
+ preload: [team_memberships: {tm, user: o}]
+ )
+ |> @repo.all(timeout: :infinity)
+
+ log("Found #{length(stale_teams)} teams which have fields out of sync...")
+
+ sync_teams(stale_teams)
+
+ # Subsciprtions backfill
+
+ log("Brought out of sync teams up to date.")
+
+ subscriptions_without_teams =
+ from(
+ s in Plausible.Billing.Subscription,
+ inner_join: u in assoc(s, :user),
+ inner_join: tm in assoc(u, :team_memberships),
+ inner_join: t in assoc(tm, :team),
+ where: tm.role == :owner,
+ where: is_nil(s.team_id),
+ preload: [user: {u, team_memberships: {tm, team: t}}]
+ )
+ |> @repo.all(timeout: :infinity)
+
+ log("Found #{length(subscriptions_without_teams)} subscriptions without team...")
+
+ backfill_subscriptions(subscriptions_without_teams)
+
+ log("All subscriptions are linked to a team now.")
+
+ # Enterprise plans backfill
+
+ enterprise_plans_without_teams =
+ from(
+ ep in Plausible.Billing.EnterprisePlan,
+ inner_join: u in assoc(ep, :user),
+ inner_join: tm in assoc(u, :team_memberships),
+ inner_join: t in assoc(tm, :team),
+ where: tm.role == :owner,
+ where: is_nil(ep.team_id),
+ preload: [user: {u, team_memberships: {tm, team: t}}]
+ )
+ |> @repo.all(timeout: :infinity)
+
+ log("Found #{length(enterprise_plans_without_teams)} enterprise plans without team...")
+
+ backfill_enterprise_plans(enterprise_plans_without_teams)
+
+ log("All enterprise plans are linked to a team now.")
+
+ # Guest Memberships cleanup
+
+ site_memberships_query =
+ from(
+ sm in Plausible.Site.Membership,
+ where: sm.site_id == parent_as(:guest_membership).site_id,
+ where: sm.user_id == parent_as(:team_membership).user_id,
+ where: sm.role != :owner,
+ select: 1
+ )
+
+ guest_memberships_to_remove =
+ from(
+ gm in Teams.GuestMembership,
+ as: :guest_membership,
+ inner_join: tm in assoc(gm, :team_membership),
+ as: :team_membership,
+ where: not exists(site_memberships_query)
+ )
+ |> @repo.all(timeout: :infinity)
+
+ log("Found #{length(guest_memberships_to_remove)} guest memberships to remove...")
+
+ team_ids_to_prune = remove_guest_memberships(guest_memberships_to_remove)
+
+ log("Pruning guest team memberships for #{length(team_ids_to_prune)} teams...")
+
+ from(t in Teams.Team, where: t.id in ^team_ids_to_prune)
+ |> @repo.all(timeout: :infinity)
+ |> Enum.each(fn team ->
+ Plausible.Teams.Memberships.prune_guests(team)
+ end)
+
+ log("Guest memberships cleared.")
+
+ # Guest Memberships backfill
+
+ guest_memberships_query =
+ from(
+ gm in Teams.GuestMembership,
+ inner_join: tm in assoc(gm, :team_membership),
+ where: gm.site_id == parent_as(:site_membership).site_id,
+ where: tm.user_id == parent_as(:site_membership).user_id,
+ select: 1
+ )
+
+ site_memberships_to_backfill =
+ from(
+ sm in Plausible.Site.Membership,
+ as: :site_membership,
+ inner_join: s in assoc(sm, :site),
+ inner_join: t in assoc(s, :team),
+ inner_join: u in assoc(sm, :user),
+ where: sm.role != :owner,
+ where: not exists(guest_memberships_query),
+ preload: [user: u, site: {s, team: t}]
+ )
+ |> @repo.all(timeout: :infinity)
+
+ log(
+ "Found #{length(site_memberships_to_backfill)} site memberships without guest membership..."
+ )
+
+ backfill_guest_memberships(site_memberships_to_backfill)
+
+ log("Backfilled missing guest memberships.")
+
+ # Stale guest memberships sync
+
+ stale_guest_memberships =
+ from(
+ sm in Plausible.Site.Membership,
+ inner_join: tm in Teams.Membership,
+ on: tm.user_id == sm.user_id,
+ inner_join: gm in assoc(tm, :guest_memberships),
+ on: gm.site_id == sm.site_id,
+ where: tm.role == :guest,
+ where:
+ (gm.role == :viewer and sm.role == :admin) or
+ (gm.role == :editor and sm.role == :viewer),
+ select: {gm, sm.role}
+ )
+ |> @repo.all(timeout: :infinity)
+
+ log("Found #{length(stale_guest_memberships)} guest memberships with role out of sync...")
+
+ sync_guest_memberships(stale_guest_memberships)
+
+ log("All guest memberships are up to date now.")
+
+ # Guest invitations cleanup
+
+ site_invitations_query =
+ from(
+ i in Auth.Invitation,
+ where: i.site_id == parent_as(:guest_invitation).site_id,
+ where: i.email == parent_as(:team_invitation).email,
+ where:
+ (i.role == :viewer and parent_as(:guest_invitation).role == :viewer) or
+ (i.role == :admin and parent_as(:guest_invitation).role == :editor)
+ )
+
+ guest_invitations_to_remove =
+ from(
+ gi in Teams.GuestInvitation,
+ as: :guest_invitation,
+ inner_join: ti in assoc(gi, :team_invitation),
+ as: :team_invitation,
+ where: not exists(site_invitations_query)
+ )
+ |> @repo.all(timeout: :infinity)
+
+ log("Found #{length(guest_invitations_to_remove)} guest invitations to remove...")
+
+ team_ids_to_prune = remove_guest_invitations(guest_invitations_to_remove)
+
+ log("Pruning guest team invitations for #{length(team_ids_to_prune)} teams...")
+
+ from(t in Teams.Team, where: t.id in ^team_ids_to_prune)
+ |> @repo.all(timeout: :infinity)
+ |> Enum.each(fn team ->
+ Plausible.Teams.Invitations.prune_guest_invitations(team)
+ end)
+
+ log("Guest invitations cleared.")
+
+ # Guest invitations backfill
+
+ guest_invitations_query =
+ from(
+ gi in Teams.GuestInvitation,
+ inner_join: ti in assoc(gi, :team_invitation),
+ where: gi.site_id == parent_as(:site_invitation).site_id,
+ where: ti.email == parent_as(:site_invitation).email,
+ select: 1
+ )
+
+ site_invitations_to_backfill =
+ from(
+ si in Auth.Invitation,
+ as: :site_invitation,
+ inner_join: s in assoc(si, :site),
+ inner_join: t in assoc(s, :team),
+ inner_join: inv in assoc(si, :inviter),
+ where: si.role != :owner,
+ where: not exists(guest_invitations_query),
+ preload: [site: {s, team: t}, inviter: inv]
+ )
+ |> @repo.all(timeout: :infinity)
+
+ log(
+ "Found #{length(site_invitations_to_backfill)} site invitations without guest invitation..."
+ )
+
+ backfill_guest_invitations(site_invitations_to_backfill)
+
+ log("Backfilled missing guest invitations.")
+
+ # Stale guest invitations sync
+
+ stale_guest_invitations =
+ from(
+ si in Auth.Invitation,
+ inner_join: ti in Teams.Invitation,
+ on: ti.email == si.email,
+ inner_join: gi in assoc(ti, :guest_invitations),
+ on: gi.site_id == si.site_id,
+ where: ti.role == :guest,
+ where:
+ (gi.role == :viewer and si.role == :admin) or
+ (gi.role == :editor and si.role == :viewer),
+ select: {gi, si.role}
+ )
+ |> @repo.all(timeout: :infinity)
+
+ log("Found #{length(stale_guest_invitations)} guest invitations with role out of sync...")
+
+ sync_guest_invitations(stale_guest_invitations)
+
+ log("All guest invitations are up to date now.")
+
+ # Site transfers cleanup
+
+ site_invitations_query =
+ from(
+ i in Auth.Invitation,
+ where: i.site_id == parent_as(:site_transfer).site_id,
+ where: i.email == parent_as(:site_transfer).email,
+ where: i.role == :owner
+ )
+
+ site_transfers_to_remove =
+ from(
+ st in Teams.SiteTransfer,
+ as: :site_transfer,
+ where: not exists(site_invitations_query)
+ )
+ |> @repo.all(timeout: :infinity)
+
+ log("Found #{length(site_transfers_to_remove)} site transfers to remove...")
+
+ remove_site_transfers(site_transfers_to_remove)
+
+ log("Site transfers cleared.")
+
+ # Site transfers backfill
+
+ site_transfers_query =
+ from(
+ st in Teams.SiteTransfer,
+ where: st.site_id == parent_as(:site_invitation).site_id,
+ where: st.email == parent_as(:site_invitation).email,
+ select: 1
+ )
+
+ site_invitations_to_backfill =
+ from(
+ si in Auth.Invitation,
+ as: :site_invitation,
+ inner_join: s in assoc(si, :site),
+ inner_join: inv in assoc(si, :inviter),
+ where: si.role == :owner,
+ where: not exists(site_transfers_query),
+ preload: [inviter: inv, site: s]
+ )
+ |> @repo.all(timeout: :infinity)
+
+ log(
+ "Found #{length(site_invitations_to_backfill)} ownership transfers without site transfer..."
+ )
+
+ backfill_site_transfers(site_invitations_to_backfill)
+
+ log("Backfilled missing site transfers.")
+
+ log("All data are up to date now!")
+ end
+
+ defp backfill_teams(sites) do
+ sites
+ |> Enum.map(fn %{id: site_id, memberships: [%{user: owner, role: :owner}]} ->
+ {owner, site_id}
+ end)
+ |> Enum.group_by(&elem(&1, 0), &elem(&1, 1))
+ |> tap(fn
+ grouped when grouped != %{} ->
+ log("Teams about to be created: #{map_size(grouped)}")
+
+ log(
+ "Max sites: #{Enum.max_by(grouped, fn {_, sites} -> length(sites) end) |> elem(1) |> length()}"
+ )
+
+ _ ->
+ :pass
+ end)
+ |> Enum.with_index()
+ |> Task.async_stream(
+ fn {{owner, site_ids}, idx} ->
+ @repo.transaction(
+ fn ->
+ team =
+ "My Team"
+ |> Teams.Team.changeset()
+ |> Ecto.Changeset.put_change(:trial_expiry_date, owner.trial_expiry_date)
+ |> Ecto.Changeset.put_change(:accept_traffic_until, owner.accept_traffic_until)
+ |> Ecto.Changeset.put_change(
+ :allow_next_upgrade_override,
+ owner.allow_next_upgrade_override
+ )
+ |> Ecto.Changeset.put_embed(:grace_period, owner.grace_period)
+ |> Ecto.Changeset.put_change(:inserted_at, owner.inserted_at)
+ |> Ecto.Changeset.put_change(:updated_at, owner.updated_at)
+ |> @repo.insert!()
+
+ team
+ |> Teams.Membership.changeset(owner, :owner)
+ |> Ecto.Changeset.put_change(:inserted_at, owner.inserted_at)
+ |> Ecto.Changeset.put_change(:updated_at, owner.updated_at)
+ |> @repo.insert!()
+
+ @repo.update_all(from(s in Plausible.Site, where: s.id in ^site_ids),
+ set: [team_id: team.id]
+ )
+ end,
+ timeout: :infinity
+ )
+
+ if rem(idx, 10) == 0 do
+ IO.write(".")
+ end
+ end,
+ timeout: :infinity
+ )
+ |> Enum.to_list()
+ |> length()
+ end
+
+ defp backfill_teams_for_users(users) do
+ users
+ |> Enum.with_index()
+ |> Task.async_stream(
+ fn {owner, idx} ->
+ @repo.transaction(
+ fn ->
+ team =
+ "My Team"
+ |> Teams.Team.changeset()
+ |> Ecto.Changeset.put_change(:trial_expiry_date, owner.trial_expiry_date)
+ |> Ecto.Changeset.put_change(:accept_traffic_until, owner.accept_traffic_until)
+ |> Ecto.Changeset.put_change(
+ :allow_next_upgrade_override,
+ owner.allow_next_upgrade_override
+ )
+ |> Ecto.Changeset.put_embed(:grace_period, owner.grace_period)
+ |> Ecto.Changeset.put_change(:inserted_at, owner.inserted_at)
+ |> Ecto.Changeset.put_change(:updated_at, owner.updated_at)
+ |> @repo.insert!()
+
+ team
+ |> Teams.Membership.changeset(owner, :owner)
+ |> Ecto.Changeset.put_change(:inserted_at, owner.inserted_at)
+ |> Ecto.Changeset.put_change(:updated_at, owner.updated_at)
+ |> @repo.insert!()
+ end,
+ timeout: :infinity
+ )
+
+ if rem(idx, 10) == 0 do
+ IO.write(".")
+ end
+ end,
+ timeout: :infinity
+ )
+ |> Enum.to_list()
+ |> length()
+ end
+
+ defp sync_teams(stale_teams) do
+ Enum.each(stale_teams, fn team ->
+ [%{user: owner}] = team.team_memberships
+
+ team
+ |> Ecto.Changeset.change()
+ |> Ecto.Changeset.put_change(:trial_expiry_date, owner.trial_expiry_date)
+ |> Ecto.Changeset.put_change(:accept_traffic_until, owner.accept_traffic_until)
+ |> Ecto.Changeset.put_change(
+ :allow_next_upgrade_override,
+ owner.allow_next_upgrade_override
+ )
+ |> Ecto.Changeset.put_embed(:grace_period, owner.grace_period)
+ |> @repo.update!()
+ end)
+ end
+
+ defp backfill_subscriptions(subscriptions) do
+ subscriptions
+ |> Enum.with_index()
+ |> Task.async_stream(
+ fn {subscription, idx} ->
+ [%{team: team, role: :owner}] = subscription.user.team_memberships
+
+ subscription
+ |> Ecto.Changeset.change(team_id: team.id)
+ |> Ecto.Changeset.put_change(:updated_at, subscription.updated_at)
+ |> @repo.update!()
+
+ if rem(idx, 1000) == 0 do
+ IO.write(".")
+ end
+ end,
+ timeout: :infinity
+ )
+ |> Stream.run()
+ end
+
+ defp backfill_enterprise_plans(enterprise_plans) do
+ enterprise_plans
+ |> Enum.with_index()
+ |> Task.async_stream(
+ fn {enterprise_plan, idx} ->
+ [%{team: team, role: :owner}] = enterprise_plan.user.team_memberships
+
+ enterprise_plan
+ |> Ecto.Changeset.change(team_id: team.id)
+ |> Ecto.Changeset.put_change(:updated_at, enterprise_plan.updated_at)
+ |> @repo.update!()
+
+ if rem(idx, 1000) == 0 do
+ IO.write(".")
+ end
+ end,
+ timeout: :infinity
+ )
+ |> Stream.run()
+ end
+
+ defp remove_guest_memberships(guest_memberships) do
+ ids = Enum.map(guest_memberships, & &1.id)
+
+ {_, team_ids} =
+ @repo.delete_all(
+ from(
+ gm in Teams.GuestMembership,
+ inner_join: tm in assoc(gm, :team_membership),
+ where: gm.id in ^ids,
+ select: tm.team_id
+ )
+ )
+
+ Enum.uniq(team_ids)
+ end
+
+ defp backfill_guest_memberships(site_memberships) do
+ site_memberships
+ |> Enum.group_by(&{&1.site.team, &1.user}, & &1)
+ |> tap(fn
+ grouped when grouped != %{} ->
+ log("Team memberships to be created: #{map_size(grouped)}")
+
+ log(
+ "Max guest memberships: #{Enum.max_by(grouped, fn {_, gms} -> length(gms) end) |> elem(1) |> length()}"
+ )
+
+ _ ->
+ :pass
+ end)
+ |> Enum.with_index()
+ |> Task.async_stream(
+ fn {{{team, user}, site_memberships}, idx} ->
+ first_site_membership =
+ Enum.min_by(site_memberships, & &1.inserted_at)
+
+ team_membership =
+ team
+ |> Teams.Membership.changeset(user, :guest)
+ |> Ecto.Changeset.put_change(:inserted_at, first_site_membership.inserted_at)
+ |> Ecto.Changeset.put_change(:updated_at, first_site_membership.updated_at)
+ |> @repo.insert!(
+ on_conflict: [set: [updated_at: first_site_membership.updated_at]],
+ conflict_target: [:team_id, :user_id]
+ )
+
+ Enum.each(site_memberships, fn site_membership ->
+ team_membership
+ |> Teams.GuestMembership.changeset(
+ site_membership.site,
+ translate_role(site_membership.role)
+ )
+ |> Ecto.Changeset.put_change(:inserted_at, site_membership.inserted_at)
+ |> Ecto.Changeset.put_change(:updated_at, site_membership.updated_at)
+ |> @repo.insert!()
+ end)
+
+ if rem(idx, 1000) == 0 do
+ IO.write(".")
+ end
+ end,
+ timeout: :infinity
+ )
+ |> Stream.run()
+ end
+
+ defp sync_guest_memberships(guest_memberships_and_roles) do
+ guest_memberships_and_roles
+ |> Enum.with_index()
+ |> Enum.each(fn {{guest_membership, role}, idx} ->
+ guest_membership
+ |> Ecto.Changeset.change(role: translate_role(role))
+ |> Ecto.Changeset.put_change(:updated_at, guest_membership.updated_at)
+ |> @repo.update!()
+
+ if rem(idx, 1000) == 0 do
+ IO.write(".")
+ end
+ end)
+ end
+
+ defp remove_guest_invitations(guest_invitations) do
+ ids = Enum.map(guest_invitations, & &1.id)
+
+ {_, team_ids} =
+ @repo.delete_all(
+ from(
+ gi in Teams.GuestInvitation,
+ inner_join: ti in assoc(gi, :team_invitation),
+ where: gi.id in ^ids,
+ select: ti.team_id
+ )
+ )
+
+ Enum.uniq(team_ids)
+ end
+
+ defp backfill_guest_invitations(site_invitations) do
+ site_invitations
+ |> Enum.group_by(&{&1.site.team, &1.email}, & &1)
+ |> Enum.with_index()
+ |> Enum.each(fn {{{team, email}, site_invitations}, idx} ->
+ first_site_invitation = List.first(site_invitations)
+
+ team_invitation =
+ team
+ # NOTE: we put first inviter and invitation ID matching team/email combination
+ |> Teams.Invitation.changeset(
+ email: email,
+ role: :guest,
+ inviter: first_site_invitation.inviter
+ )
+ |> Ecto.Changeset.put_change(:invitation_id, first_site_invitation.invitation_id)
+ |> Ecto.Changeset.put_change(:inserted_at, first_site_invitation.inserted_at)
+ |> Ecto.Changeset.put_change(:updated_at, first_site_invitation.updated_at)
+ |> @repo.insert!(
+ on_conflict: [set: [updated_at: first_site_invitation.updated_at]],
+ conflict_target: [:team_id, :email]
+ )
+
+ Enum.each(site_invitations, fn site_invitation ->
+ team_invitation
+ |> Teams.GuestInvitation.changeset(
+ site_invitation.site,
+ translate_role(site_invitation.role)
+ )
+ |> Ecto.Changeset.put_change(:inserted_at, site_invitation.inserted_at)
+ |> Ecto.Changeset.put_change(:updated_at, site_invitation.updated_at)
+ |> @repo.insert!()
+ end)
+
+ if rem(idx, 1000) == 0 do
+ IO.write(".")
+ end
+ end)
+ end
+
+ defp sync_guest_invitations(guest_invitations_and_roles) do
+ guest_invitations_and_roles
+ |> Enum.with_index()
+ |> Enum.each(fn {{guest_invitation, role}, idx} ->
+ guest_invitation
+ |> Ecto.Changeset.change(role: translate_role(role))
+ |> Ecto.Changeset.put_change(:updated_at, guest_invitation.updated_at)
+ |> @repo.update!()
+
+ if rem(idx, 1000) == 0 do
+ IO.write(".")
+ end
+ end)
+ end
+
+ defp remove_site_transfers(site_transfers) do
+ ids = Enum.map(site_transfers, & &1.id)
+
+ @repo.delete_all(from(st in Teams.SiteTransfer, where: st.id in ^ids))
+ end
+
+ defp backfill_site_transfers(site_invitations) do
+ site_invitations
+ |> Enum.with_index()
+ |> Enum.each(fn {site_invitation, idx} ->
+ site_invitation.site
+ |> Teams.SiteTransfer.changeset(
+ initiator: site_invitation.inviter,
+ email: site_invitation.email
+ )
+ |> Ecto.Changeset.put_change(:transfer_id, site_invitation.invitation_id)
+ |> Ecto.Changeset.put_change(:inserted_at, site_invitation.inserted_at)
+ |> Ecto.Changeset.put_change(:updated_at, site_invitation.updated_at)
+ |> @repo.insert!()
+
+ if rem(idx, 1000) == 0 do
+ IO.write(".")
+ end
+ end)
+ end
+
+ defp translate_role(:admin), do: :editor
+ defp translate_role(:viewer), do: :viewer
+
+ defp log(msg) do
+ IO.puts("[#{NaiveDateTime.utc_now(:second)}] #{msg}")
+ end
+end
diff --git a/lib/plausible/data_migration/repo.ex b/lib/plausible/data_migration/clickhouse_repo.ex
similarity index 92%
rename from lib/plausible/data_migration/repo.ex
rename to lib/plausible/data_migration/clickhouse_repo.ex
index 4215d45b8a..522fa34f89 100644
--- a/lib/plausible/data_migration/repo.ex
+++ b/lib/plausible/data_migration/clickhouse_repo.ex
@@ -1,4 +1,4 @@
-defmodule Plausible.DataMigration.Repo do
+defmodule Plausible.DataMigration.ClickhouseRepo do
@moduledoc """
Ecto.Repo for Clickhouse data migrations, to be started manually,
outside of the main application supervision tree.
diff --git a/lib/plausible/data_migration/postgres_repo.ex b/lib/plausible/data_migration/postgres_repo.ex
new file mode 100644
index 0000000000..3518500798
--- /dev/null
+++ b/lib/plausible/data_migration/postgres_repo.ex
@@ -0,0 +1,22 @@
+defmodule Plausible.DataMigration.PostgresRepo do
+ @moduledoc """
+ Ecto.Repo for Posrtgres data migrations, to be started manually,
+ outside of the main application supervision tree.
+ """
+ use Ecto.Repo,
+ otp_app: :plausible,
+ adapter: Ecto.Adapters.Postgres
+
+ def start(url, opts \\ []) when is_binary(url) do
+ default_config = Plausible.Repo.config()
+
+ start_link(
+ url: url,
+ queue_target: 500,
+ queue_interval: 2000,
+ pool_size: opts[:pool_size] || 1,
+ ssl: opts[:ssl] || default_config[:ssl],
+ ssl_opts: opts[:ssl_opts] || default_config[:ssl_opts]
+ )
+ end
+end
diff --git a/lib/plausible/site.ex b/lib/plausible/site.ex
index 5d0ab13916..63cdefa488 100644
--- a/lib/plausible/site.ex
+++ b/lib/plausible/site.ex
@@ -32,6 +32,11 @@ defmodule Plausible.Site do
# NOTE: needed by `SiteImports` data migration script
embeds_one :imported_data, Plausible.Site.ImportedData, on_replace: :update
+ # NOTE: new teams relations
+ belongs_to :team, Plausible.Teams.Team
+ has_many :guest_memberships, Plausible.Teams.GuestMembership
+ has_many :guest_invitations, Plausible.Teams.GuestInvitation
+
embeds_one :installation_meta, Plausible.Site.InstallationMeta,
on_replace: :update,
defaults_to_struct: true
@@ -69,6 +74,12 @@ defmodule Plausible.Site do
timestamps()
end
+ def new_for_team(team, params) do
+ params
+ |> new()
+ |> put_assoc(:team, team)
+ end
+
def new(params), do: changeset(%__MODULE__{}, params)
@domain_unique_error """
diff --git a/lib/plausible/site/memberships/accept_invitation.ex b/lib/plausible/site/memberships/accept_invitation.ex
index 98f82d3ddf..b1cc23031e 100644
--- a/lib/plausible/site/memberships/accept_invitation.ex
+++ b/lib/plausible/site/memberships/accept_invitation.ex
@@ -36,10 +36,20 @@ defmodule Plausible.Site.Memberships.AcceptInvitation do
with :ok <- Invitations.ensure_transfer_valid(site, user, :owner),
:ok <- Invitations.ensure_can_take_ownership(site, user) do
membership = get_or_create_owner_membership(site, user)
+
multi = add_and_transfer_ownership(site, membership, user)
case Repo.transaction(multi) do
{:ok, changes} ->
+ with_teams do
+ sync_job =
+ Task.async(fn ->
+ Plausible.Teams.Invitations.transfer_site_sync(site, user)
+ end)
+
+ Task.await(sync_job)
+ end
+
membership = Repo.preload(changes.membership, [:site, :user])
{:ok, membership}
@@ -72,6 +82,10 @@ defmodule Plausible.Site.Memberships.AcceptInvitation do
site = Repo.preload(invitation.site, :owner)
with :ok <- Invitations.ensure_can_take_ownership(site, user) do
+ with_teams do
+ Plausible.Teams.Invitations.accept_transfer_sync(invitation, user)
+ end
+
site
|> add_and_transfer_ownership(membership, user)
|> Multi.delete(:invitation, invitation)
@@ -80,6 +94,10 @@ defmodule Plausible.Site.Memberships.AcceptInvitation do
end
defp do_accept_invitation(invitation, user) do
+ with_teams do
+ Plausible.Teams.Invitations.accept_invitation_sync(invitation, user)
+ end
+
membership = get_or_create_membership(invitation, user)
invitation
@@ -182,12 +200,17 @@ defmodule Plausible.Site.Memberships.AcceptInvitation do
end
defp notify_invitation_accepted(%Auth.Invitation{role: :owner} = invitation) do
- PlausibleWeb.Email.ownership_transfer_accepted(invitation)
+ PlausibleWeb.Email.ownership_transfer_accepted(
+ invitation.email,
+ invitation.inviter.email,
+ invitation.site
+ )
|> Plausible.Mailer.send()
end
defp notify_invitation_accepted(invitation) do
- PlausibleWeb.Email.invitation_accepted(invitation)
+ invitation.inviter.email
+ |> PlausibleWeb.Email.invitation_accepted(invitation.email, invitation.site)
|> Plausible.Mailer.send()
end
end
diff --git a/lib/plausible/site/memberships/create_invitation.ex b/lib/plausible/site/memberships/create_invitation.ex
index 615fd3b8f1..ab52322c52 100644
--- a/lib/plausible/site/memberships/create_invitation.ex
+++ b/lib/plausible/site/memberships/create_invitation.ex
@@ -9,6 +9,7 @@ defmodule Plausible.Site.Memberships.CreateInvitation do
alias Plausible.Site.Memberships.Invitations
alias Plausible.Billing.Quota
import Ecto.Query
+ use Plausible
@type invite_error() ::
Ecto.Changeset.t()
@@ -80,6 +81,11 @@ defmodule Plausible.Site.Memberships.CreateInvitation do
%Ecto.Changeset{} = changeset <- Invitation.new(attrs),
{:ok, invitation} <- Plausible.Repo.insert(changeset) do
send_invitation_email(invitation, invitee)
+
+ with_teams do
+ Plausible.Teams.Invitations.invite_sync(site, invitation)
+ end
+
invitation
else
{:error, cause} -> Plausible.Repo.rollback(cause)
@@ -108,9 +114,29 @@ defmodule Plausible.Site.Memberships.CreateInvitation do
email =
case {invitee, invitation.role} do
- {invitee, :owner} -> PlausibleWeb.Email.ownership_transfer_request(invitation, invitee)
- {nil, _role} -> PlausibleWeb.Email.new_user_invitation(invitation)
- {%User{}, _role} -> PlausibleWeb.Email.existing_user_invitation(invitation)
+ {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)
diff --git a/lib/plausible/sites.ex b/lib/plausible/sites.ex
index 97d6feaffa..a492ec0933 100644
--- a/lib/plausible/sites.ex
+++ b/lib/plausible/sites.ex
@@ -208,8 +208,9 @@ defmodule Plausible.Sites do
defp maybe_start_trial(multi, user) do
case user.trial_expiry_date do
nil ->
- changeset = Auth.User.start_trial(user)
- Ecto.Multi.update(multi, :user, changeset)
+ Ecto.Multi.run(multi, :user, fn _, _ ->
+ {:ok, Plausible.Users.start_trial(user)}
+ end)
_ ->
multi
diff --git a/lib/plausible/teams.ex b/lib/plausible/teams.ex
new file mode 100644
index 0000000000..b953de26ed
--- /dev/null
+++ b/lib/plausible/teams.ex
@@ -0,0 +1,102 @@
+defmodule Plausible.Teams do
+ @moduledoc """
+ Core context of teams.
+ """
+
+ import Ecto.Query
+
+ alias __MODULE__
+ alias Plausible.Repo
+
+ def with_subscription(team) do
+ Repo.preload(team, subscription: last_subscription_query())
+ end
+
+ def owned_sites(team) do
+ Repo.preload(team, :sites).sites
+ end
+
+ @doc """
+ Get or create user's team.
+
+ If the user has no non-guest membership yet, an implicit "My Team" team is
+ created with them as an owner.
+
+ If the user already has an owner membership in an existing team,
+ that team is returned.
+
+ If the user has a non-guest membership other than owner, `:no_team` error
+ is returned.
+ """
+ def get_or_create(user) do
+ with {:error, :no_team} <- get_owned_by_user(user) do
+ case create_my_team(user) do
+ {:ok, team} -> {:ok, team}
+ {:error, :exists_already} -> get_owned_by_user(user)
+ end
+ end
+ end
+
+ def sync_team(user) do
+ case get_owned_by_user(user) do
+ {:ok, team} ->
+ team
+ |> Teams.Team.sync_changeset(user)
+ |> Repo.update!()
+
+ _ ->
+ :skip
+ end
+
+ :ok
+ end
+
+ defp create_my_team(user) do
+ team =
+ "My Team"
+ |> Teams.Team.changeset()
+ |> Ecto.Changeset.put_change(:inserted_at, user.inserted_at)
+ |> Ecto.Changeset.put_change(:updated_at, user.updated_at)
+ |> Repo.insert!()
+
+ team_membership =
+ team
+ |> Teams.Membership.changeset(user, :owner)
+ |> Ecto.Changeset.put_change(:inserted_at, user.inserted_at)
+ |> Ecto.Changeset.put_change(:updated_at, user.updated_at)
+ |> Repo.insert!(
+ on_conflict: :nothing,
+ conflict_target: {:unsafe_fragment, "(user_id) WHERE role != 'guest'"}
+ )
+
+ if team_membership.id do
+ {:ok, team}
+ else
+ Repo.delete!(team)
+ {:error, :exists_already}
+ end
+ end
+
+ defp get_owned_by_user(user) do
+ result =
+ from(tm in Teams.Membership,
+ inner_join: t in assoc(tm, :team),
+ where: tm.user_id == ^user.id and tm.role == :owner,
+ select: t,
+ order_by: t.id
+ )
+ |> Repo.one()
+
+ case result do
+ nil -> {:error, :no_team}
+ team -> {:ok, team}
+ end
+ end
+
+ defp last_subscription_query() do
+ from(subscription in Plausible.Billing.Subscription,
+ order_by: [desc: subscription.inserted_at],
+ limit: 1
+ )
+ end
+end
diff --git a/lib/plausible/teams/billing.ex b/lib/plausible/teams/billing.ex
new file mode 100644
index 0000000000..2cd5aec8a0
--- /dev/null
+++ b/lib/plausible/teams/billing.ex
@@ -0,0 +1,235 @@
+defmodule Plausible.Teams.Billing do
+ @moduledoc false
+
+ import Ecto.Query
+
+ alias Plausible.Billing.EnterprisePlan
+ alias Plausible.Billing.Plans
+ alias Plausible.Billing.Subscriptions
+ alias Plausible.Repo
+ alias Plausible.Teams
+
+ @team_member_limit_for_trials 3
+ @limit_sites_since ~D[2021-05-05]
+ @site_limit_for_trials 10
+
+ def ensure_can_add_new_site(team) do
+ team = Teams.with_subscription(team)
+
+ case Plans.get_subscription_plan(team.subscription) do
+ %EnterprisePlan{} ->
+ :ok
+
+ _ ->
+ usage = site_usage(team)
+ limit = site_limit(team)
+
+ if Plausible.Billing.Quota.below_limit?(usage, limit) do
+ :ok
+ else
+ {:error, {:over_limit, limit}}
+ end
+ end
+ end
+
+ def site_limit(team) do
+ if Timex.before?(team.inserted_at, @limit_sites_since) do
+ :unlimited
+ else
+ get_site_limit_from_plan(team)
+ end
+ end
+
+ def site_usage(team) do
+ team
+ |> Teams.owned_sites()
+ |> length()
+ end
+
+ defp get_site_limit_from_plan(team) do
+ team = Teams.with_subscription(team)
+
+ case Plans.get_subscription_plan(team.subscription) do
+ %{site_limit: site_limit} -> site_limit
+ :free_10k -> 50
+ nil -> @site_limit_for_trials
+ end
+ end
+
+ def team_member_limit(team) do
+ team = Teams.with_subscription(team)
+
+ case Plans.get_subscription_plan(team.subscription) do
+ %{team_member_limit: limit} -> limit
+ :free_10k -> :unlimited
+ nil -> @team_member_limit_for_trials
+ end
+ end
+
+ def quota_usage(team, opts) do
+ team = Teams.with_subscription(team)
+ with_features? = Keyword.get(opts, :with_features, false)
+ pending_site_ids = Keyword.get(opts, :pending_ownership_site_ids, [])
+ team_site_ids = team |> Teams.owned_sites() |> Enum.map(& &1.id)
+ all_site_ids = pending_site_ids ++ team_site_ids
+
+ monthly_pageviews = monthly_pageview_usage(team, all_site_ids)
+ team_member_usage = team_member_usage(team, pending_ownership_site_ids: pending_site_ids)
+
+ basic_usage = %{
+ monthly_pageviews: monthly_pageviews,
+ team_members: team_member_usage,
+ sites: length(all_site_ids)
+ }
+
+ if with_features? do
+ Map.put(basic_usage, :features, features_usage(team, all_site_ids))
+ else
+ basic_usage
+ end
+ end
+
+ def monthly_pageview_usage(team, site_ids) do
+ team = Teams.with_subscription(team)
+ active_subscription? = Subscriptions.active?(team.subscription)
+
+ if active_subscription? and team.subscription.last_bill_date != nil do
+ [:current_cycle, :last_cycle, :penultimate_cycle]
+ |> Task.async_stream(fn cycle ->
+ {cycle, usage_cycle(team, cycle, site_ids)}
+ end)
+ |> Enum.into(%{}, fn {:ok, cycle_usage} -> cycle_usage end)
+ else
+ %{last_30_days: usage_cycle(team, :last_30_days, site_ids)}
+ end
+ end
+
+ def team_member_usage(team, opts) do
+ exclude_emails = Keyword.get(opts, :exclude_emails, [])
+ pending_site_ids = Keyword.get(opts, :pending_ownership_site_ids, [])
+
+ team
+ |> query_team_member_emails(pending_site_ids, exclude_emails)
+ |> Repo.aggregate(:count)
+ end
+
+ def usage_cycle(team, cycle, owned_site_ids \\ nil, today \\ Date.utc_today())
+
+ def usage_cycle(team, cycle, nil, today) do
+ owned_site_ids = team |> Teams.owned_sites() |> Enum.map(& &1.id)
+ usage_cycle(team, cycle, owned_site_ids, today)
+ end
+
+ def usage_cycle(_team, :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(team, cycle, owned_site_ids, today) do
+ team = Teams.with_subscription(team)
+ last_bill_date = team.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
+
+ def features_usage(user, site_ids \\ nil)
+
+ def features_usage(%Teams.Team{} = team, nil) do
+ owned_site_ids = team |> Teams.owned_sites() |> Enum.map(& &1.id)
+ features_usage(team, owned_site_ids)
+ end
+
+ def features_usage(%Teams.Team{} = team, owned_site_ids) when is_list(owned_site_ids) do
+ site_scoped_feature_usage = features_usage(nil, owned_site_ids)
+
+ stats_api_used? =
+ from(a in Plausible.Auth.ApiKey, where: a.team_id == ^team.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, owned_site_ids) when is_list(owned_site_ids) do
+ Plausible.Billing.Quota.Usage.features_usage(nil, owned_site_ids)
+ end
+
+ defp query_team_member_emails(team, site_ids, exclude_emails) do
+ pending_memberships_q =
+ from tm in Teams.Membership,
+ inner_join: u in assoc(tm, :user),
+ inner_join: gm in assoc(tm, :guest_memberships),
+ where: gm.site_id in ^site_ids and tm.role != :owner,
+ where: u.email not in ^exclude_emails,
+ select: %{email: u.email}
+
+ pending_invitations_q =
+ from ti in Teams.Invitation,
+ inner_join: gi in assoc(ti, :guest_invitations),
+ where: gi.site_id in ^site_ids and ti.role != :owner,
+ where: ti.email not in ^exclude_emails,
+ select: %{email: ti.email}
+
+ team_memberships_q =
+ from tm in Teams.Membership,
+ inner_join: u in assoc(tm, :user),
+ where: tm.team_id == ^team.id and tm.role != :owner,
+ where: u.email not in ^exclude_emails,
+ select: %{email: u.email}
+
+ team_invitations_q =
+ from ti in Teams.Invitation,
+ where: ti.team_id == ^team.id and ti.role != :owner,
+ where: ti.email not in ^exclude_emails,
+ select: %{email: ti.email}
+
+ pending_memberships_q
+ |> union(^pending_invitations_q)
+ |> union(^team_memberships_q)
+ |> union(^team_invitations_q)
+ end
+end
diff --git a/lib/plausible/teams/guest_invitation.ex b/lib/plausible/teams/guest_invitation.ex
new file mode 100644
index 0000000000..9f0e710025
--- /dev/null
+++ b/lib/plausible/teams/guest_invitation.ex
@@ -0,0 +1,26 @@
+defmodule Plausible.Teams.GuestInvitation do
+ @moduledoc """
+ Guest invitation schema
+ """
+
+ use Ecto.Schema
+
+ import Ecto.Changeset
+
+ schema "guest_invitations" do
+ field :role, Ecto.Enum, values: [:viewer, :editor]
+
+ belongs_to :site, Plausible.Site
+ belongs_to :team_invitation, Plausible.Teams.Invitation
+
+ timestamps()
+ end
+
+ def changeset(team_invitation, site, role) do
+ %__MODULE__{}
+ |> cast(%{role: role}, [:role])
+ |> validate_required(:role)
+ |> put_assoc(:team_invitation, team_invitation)
+ |> put_assoc(:site, site)
+ end
+end
diff --git a/lib/plausible/teams/guest_membership.ex b/lib/plausible/teams/guest_membership.ex
new file mode 100644
index 0000000000..3932685e10
--- /dev/null
+++ b/lib/plausible/teams/guest_membership.ex
@@ -0,0 +1,26 @@
+defmodule Plausible.Teams.GuestMembership do
+ @moduledoc """
+ Guest membership schema
+ """
+
+ use Ecto.Schema
+
+ import Ecto.Changeset
+
+ schema "guest_memberships" do
+ field :role, Ecto.Enum, values: [:viewer, :editor]
+
+ belongs_to :team_membership, Plausible.Teams.Membership
+ belongs_to :site, Plausible.Site
+
+ timestamps()
+ end
+
+ def changeset(team_membership, site, role) do
+ %__MODULE__{}
+ |> change()
+ |> put_change(:role, role)
+ |> put_assoc(:team_membership, team_membership)
+ |> put_assoc(:site, site)
+ end
+end
diff --git a/lib/plausible/teams/invitation.ex b/lib/plausible/teams/invitation.ex
new file mode 100644
index 0000000000..473dc7ea68
--- /dev/null
+++ b/lib/plausible/teams/invitation.ex
@@ -0,0 +1,34 @@
+defmodule Plausible.Teams.Invitation do
+ @moduledoc """
+ Team invitation schema
+ """
+
+ use Ecto.Schema
+
+ import Ecto.Changeset
+
+ schema "team_invitations" do
+ field :invitation_id, :string
+ field :email, :string
+ field :role, Ecto.Enum, values: [:guest, :viewer, :editor, :admin, :owner]
+
+ belongs_to :inviter, Plausible.Auth.User
+ belongs_to :team, Plausible.Teams.Team
+
+ has_many :guest_invitations, Plausible.Teams.GuestInvitation, foreign_key: :team_invitation_id
+
+ timestamps()
+ end
+
+ def changeset(team, opts) do
+ email = Keyword.fetch!(opts, :email)
+ role = Keyword.fetch!(opts, :role)
+ inviter = Keyword.fetch!(opts, :inviter)
+
+ %__MODULE__{invitation_id: Nanoid.generate()}
+ |> cast(%{email: email, role: role}, [:email, :role])
+ |> validate_required([:email, :role])
+ |> put_assoc(:team, team)
+ |> put_assoc(:inviter, inviter)
+ end
+end
diff --git a/lib/plausible/teams/invitations.ex b/lib/plausible/teams/invitations.ex
new file mode 100644
index 0000000000..e443901b2f
--- /dev/null
+++ b/lib/plausible/teams/invitations.ex
@@ -0,0 +1,560 @@
+defmodule Plausible.Teams.Invitations do
+ @moduledoc false
+
+ import Ecto.Query
+
+ alias Plausible.Auth
+ alias Plausible.Billing
+ alias Plausible.Repo
+ alias Plausible.Teams
+
+ def invite(site, inviter, invitee_email, role, opts \\ [])
+
+ def invite(site, initiator, invitee_email, :owner, opts) do
+ check_permissions? = opts[:check_permissions]
+ site = Repo.preload(site, :team)
+
+ with :ok <- check_transfer_permissions(site.team, initiator, check_permissions?),
+ new_owner = Plausible.Auth.find_user_by(email: invitee_email),
+ :ok <- ensure_transfer_valid(site.team, new_owner),
+ {:ok, site_transfer} <- create_site_transfer(site, initiator, invitee_email) do
+ send_transfer_init_email(site_transfer, new_owner)
+ {:ok, site_transfer}
+ end
+ end
+
+ def invite(site, inviter, invitee_email, role, opts) do
+ check_permissions? = opts[:check_permissions]
+ site = Repo.preload(site, :team)
+ role = translate_role(role)
+
+ with :ok <- check_invitation_permissions(site.team, inviter, check_permissions?),
+ :ok <- check_team_member_limit(site.team, role, invitee_email),
+ invitee = Auth.find_user_by(email: invitee_email),
+ :ok <- ensure_new_membership(site, invitee, role),
+ {:ok, guest_invitation} <- create_invitation(site, invitee_email, role, inviter) do
+ send_invitation_email(guest_invitation, invitee)
+ {:ok, guest_invitation}
+ end
+ end
+
+ def invite_sync(site, site_invitation) do
+ site = Repo.preload(site, :team)
+ site_invitation = Repo.preload(site_invitation, :inviter)
+ role = translate_role(site_invitation.role)
+
+ if site_invitation.role == :owner do
+ create_site_transfer(
+ site,
+ site_invitation.inviter,
+ site_invitation.email
+ )
+ else
+ create_invitation(
+ site,
+ site_invitation.email,
+ role,
+ site_invitation.inviter
+ )
+ end
+ catch
+ _, thrown ->
+ Sentry.capture_message(
+ "Failed to sync invitation for site ##{site.id} and email ##{site_invitation.email}",
+ extra: %{
+ error: inspect(thrown)
+ }
+ )
+ end
+
+ def transfer_site(site, new_owner, now \\ NaiveDateTime.utc_now(:second)) do
+ site = Repo.preload(site, :team)
+
+ with :ok <- ensure_transfer_valid(site.team, new_owner),
+ {:ok, team} <- Teams.get_or_create(new_owner),
+ :ok <- ensure_can_take_ownership(site, team) do
+ site =
+ Repo.preload(site, [
+ :owner,
+ guest_memberships: [team_membership: :user],
+ guest_invitations: [team_invitation: :user]
+ ])
+
+ {:ok, _} =
+ Repo.transaction(fn ->
+ :ok = transfer_site_ownership(site, team, now)
+ end)
+
+ {:ok, team_membership} = Teams.Memberships.get(team, new_owner)
+
+ {:ok, team_membership}
+ end
+ end
+
+ def transfer_site_sync(site, user) do
+ {:ok, team} = Plausible.Teams.get_or_create(user)
+
+ site =
+ Repo.preload(site, [
+ :owner,
+ guest_memberships: [team_membership: :user],
+ guest_invitations: [team_invitation: :user]
+ ])
+
+ {:ok, _} =
+ Repo.transaction(fn ->
+ :ok = transfer_site_ownership(site, team, NaiveDateTime.utc_now(:second))
+ end)
+ catch
+ _, thrown ->
+ Sentry.capture_message(
+ "Failed to sync transfer site for site ##{site.id} and user ##{user.id}",
+ extra: %{
+ error: inspect(thrown)
+ }
+ )
+ end
+
+ def accept(invitation_id, user, now \\ NaiveDateTime.utc_now(:second)) do
+ case find_for_user(invitation_id, user) do
+ {:ok, %Teams.Invitation{} = team_invitation} ->
+ do_accept(team_invitation, user, now)
+
+ {:ok, %Teams.SiteTransfer{} = site_transfer} ->
+ do_transfer(site_transfer, user, now)
+
+ {:error, _} = error ->
+ error
+ end
+ end
+
+ def accept_invitation_sync(site_invitation, user) do
+ site_invitation =
+ Repo.preload(
+ site_invitation,
+ site: :team
+ )
+
+ role =
+ case site_invitation.role do
+ :viewer -> :viewer
+ :admin -> :editor
+ end
+
+ guest_invitation =
+ create_invitation(
+ site_invitation.site,
+ site_invitation.invitee_email,
+ role,
+ site_invitation.inviter
+ )
+
+ {:ok, _} =
+ do_accept(guest_invitation.team_invitation, user, NaiveDateTime.utc_now(:second),
+ send_email?: false
+ )
+ catch
+ _, thrown ->
+ Sentry.capture_message(
+ "Failed to sync accept invitation for site ##{site_invitation.site_id} and user ##{user.id}",
+ extra: %{
+ error: inspect(thrown)
+ }
+ )
+ end
+
+ def accept_transfer_sync(site_invitation, user) do
+ {:ok, team} = Teams.get_or_create(user)
+
+ site =
+ Repo.preload(site_invitation.site, [:owner, guest_memberships: [team_membership: :user]])
+
+ site_transfer = create_site_transfer(site, site_invitation.inviter, site_invitation.email)
+
+ {:ok, _} =
+ Repo.transaction(fn ->
+ :ok = transfer_site_ownership(site, team, NaiveDateTime.utc_now(:second))
+ Repo.delete!(site_transfer)
+ end)
+ catch
+ _, thrown ->
+ Sentry.capture_message(
+ "Failed to sync accept transfer for site ##{site_invitation.site_id} and user ##{user.id}",
+ extra: %{
+ error: inspect(thrown)
+ }
+ )
+ end
+
+ defp check_transfer_permissions(_team, _initiator, false = _check_permissions?) do
+ :ok
+ end
+
+ defp check_transfer_permissions(team, initiator, _) do
+ case Teams.Memberships.team_role(team, initiator) do
+ {:ok, :owner} -> :ok
+ _ -> {:error, :forbidden}
+ end
+ end
+
+ defp ensure_transfer_valid(_team, nil), do: :ok
+
+ defp ensure_transfer_valid(team, new_owner) do
+ case Teams.Memberships.team_role(team, new_owner) do
+ {:ok, :owner} -> {:error, :transfer_to_self}
+ _ -> :ok
+ end
+ end
+
+ defp create_site_transfer(site, initiator, invitee_email, now \\ NaiveDateTime.utc_now(:second)) do
+ site
+ |> Teams.SiteTransfer.changeset(initiator: initiator, email: invitee_email)
+ |> Repo.insert(
+ on_conflict: [set: [updated_at: now]],
+ conflict_target: [:email, :site_id]
+ )
+ end
+
+ defp send_transfer_init_email(site_transfer, new_owner) do
+ email =
+ PlausibleWeb.Email.ownership_transfer_request(
+ site_transfer.email,
+ site_transfer.transfer_id,
+ site_transfer.site,
+ site_transfer.initiator,
+ new_owner
+ )
+
+ Plausible.Mailer.send(email)
+ end
+
+ defp do_accept(team_invitation, user, now, opts \\ []) do
+ send_email? = Keyword.get(opts, :send_email?, true)
+ guest_invitations = team_invitation.guest_invitations
+
+ Repo.transaction(fn ->
+ with {:ok, team_membership} <-
+ create_team_membership(team_invitation.team, team_invitation.role, user, now),
+ {:ok, _guest_memberships} <-
+ create_guest_memberships(team_membership, guest_invitations, now) do
+ Repo.delete!(team_invitation)
+
+ if send_email? do
+ send_invitation_accepted_email(team_invitation, guest_invitations)
+ end
+
+ team_membership
+ else
+ {:error, changeset} -> Repo.rollback(changeset)
+ end
+ end)
+ end
+
+ defp do_transfer(site_transfer, new_owner, now) do
+ # That's probably the most involved flow of all so far
+ # - if new owner does not have a team yet, create one
+ # - ensure the new team can take ownership of the site
+ # - move site to and create guest memberships in the new team
+ # - create editor guest membership for the old owner
+ # - remove old guest memberships
+ site_transfer = Repo.preload(site_transfer, [:initiator, site: :team])
+
+ with :ok <- ensure_transfer_valid(site_transfer.site.team, new_owner),
+ {:ok, team} <- Teams.get_or_create(new_owner),
+ :ok <- ensure_can_take_ownership(site_transfer.site, team) do
+ site = Repo.preload(site_transfer.site, guest_memberships: [team_membership: :user])
+
+ {:ok, _} =
+ Repo.transaction(fn ->
+ :ok = transfer_site_ownership(site, team, now)
+ Repo.delete!(site_transfer)
+ end)
+
+ send_transfer_accepted_email(site_transfer)
+
+ {:ok, team_membership} = Teams.Memberships.get(team, new_owner)
+
+ {:ok, team_membership}
+ end
+ end
+
+ defp transfer_site_ownership(site, team, now) do
+ prior_team = site.team
+
+ site
+ |> Ecto.Changeset.change(team_id: team.id)
+ |> Repo.update!()
+
+ {_old_team_invitations, old_guest_invitations} =
+ site.guest_invitations
+ |> Enum.map(fn old_guest_invitation ->
+ old_team_invitation = old_guest_invitation.team_invitation
+
+ {:ok, new_team_invitation} =
+ create_team_invitation(team, old_team_invitation.email, now)
+
+ {:ok, _new_guest_invitation} =
+ create_guest_invitation(new_team_invitation, site, old_guest_invitation.role)
+
+ {old_team_invitation, old_guest_invitation}
+ end)
+ |> Enum.unzip()
+
+ old_guest_ids = Enum.map(old_guest_invitations, & &1.id)
+ :ok = prune_guest_invitations(prior_team, ignore_guest_ids: old_guest_ids)
+
+ {_old_team_memberships, old_guest_memberships} =
+ site.guest_memberships
+ |> Enum.map(fn old_guest_membership ->
+ old_team_membership = old_guest_membership.team_membership
+
+ {:ok, new_team_membership} =
+ create_team_membership(team, :guest, old_team_membership.user, now)
+
+ if new_team_membership.role == :guest do
+ {:ok, _} =
+ new_team_membership
+ |> Teams.GuestMembership.changeset(site, old_guest_membership.role)
+ |> Repo.insert(
+ on_conflict: [set: [updated_at: now, role: old_guest_membership.role]],
+ conflict_target: [:team_membership_id, :site_id]
+ )
+ end
+
+ {old_team_membership, old_guest_membership}
+ end)
+ |> Enum.unzip()
+
+ old_guest_ids = Enum.map(old_guest_memberships, & &1.id)
+ :ok = Teams.Memberships.prune_guests(prior_team, ignore_guest_ids: old_guest_ids)
+
+ {:ok, prior_owner} = Teams.Sites.get_owner(prior_team)
+
+ {:ok, prior_owner_team_membership} = create_team_membership(team, :guest, prior_owner, now)
+
+ if prior_owner_team_membership.role == :guest do
+ {:ok, _} =
+ prior_owner_team_membership
+ |> Teams.GuestMembership.changeset(site, :editor)
+ |> Repo.insert(
+ on_conflict: [set: [updated_at: now, role: :editor]],
+ conflict_target: [:team_membership_id, :site_id]
+ )
+ end
+
+ # TODO: Update site lock status with SiteLocker
+
+ :ok
+ end
+
+ def prune_guest_invitations(team, opts \\ []) do
+ ignore_guest_ids = Keyword.get(opts, :ignore_guest_ids, [])
+
+ guest_query =
+ from(
+ gi in Teams.GuestInvitation,
+ where: gi.team_invitation_id == parent_as(:team_invitation).id,
+ where: gi.id not in ^ignore_guest_ids,
+ select: true
+ )
+
+ Repo.delete_all(
+ from(
+ ti in Teams.Invitation,
+ as: :team_invitation,
+ where: ti.team_id == ^team.id and ti.role == :guest,
+ where: not exists(guest_query)
+ )
+ )
+
+ :ok
+ end
+
+ defp send_transfer_accepted_email(site_transfer) do
+ PlausibleWeb.Email.ownership_transfer_accepted(
+ site_transfer.email,
+ site_transfer.initiator.email,
+ site_transfer.site
+ )
+ |> Plausible.Mailer.send()
+ end
+
+ defp 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}
+ end
+ end
+
+ defp find_for_user(invitation_id, user) do
+ with {:error, :invitation_not_found} <- find_invitation(invitation_id, user) do
+ find_site_transfer(invitation_id, user)
+ end
+ end
+
+ defp find_invitation(invitation_id, user) do
+ invitation =
+ Teams.Invitation
+ |> Repo.get_by(invitation_id: invitation_id, email: user.email)
+ |> Repo.preload([:team, :inviter, guest_invitations: :site])
+
+ if invitation do
+ {:ok, invitation}
+ else
+ {:error, :invitation_not_found}
+ end
+ end
+
+ defp find_site_transfer(transfer_id, user) do
+ site_transfer =
+ Teams.SiteTransfer
+ |> Repo.get_by(transfer_id: transfer_id, email: user.email)
+ |> Repo.preload([:initiator, site: :team])
+
+ if site_transfer do
+ {:ok, site_transfer}
+ else
+ {:error, :invitation_not_found}
+ end
+ end
+
+ defp check_invitation_permissions(_team, _inviter, false = _check_permission?) do
+ :ok
+ end
+
+ defp check_invitation_permissions(team, inviter, _) do
+ case Teams.Memberships.team_role(team, inviter) do
+ {:ok, role} when role in [:owner, :admin] -> :ok
+ _ -> {:error, :forbidden}
+ end
+ end
+
+ defp translate_role(:admin), do: :editor
+ defp translate_role(role), do: role
+
+ defp check_team_member_limit(team, _role, invitee_email) do
+ limit = Teams.Billing.team_member_limit(team)
+ usage = Teams.Billing.team_member_usage(team, exclude_emails: [invitee_email])
+
+ if Billing.Quota.below_limit?(usage, limit) do
+ :ok
+ else
+ {:error, {:over_limit, limit}}
+ end
+ end
+
+ defp ensure_new_membership(_site, nil, _role), do: :ok
+
+ defp ensure_new_membership(site, invitee, _role) do
+ if Teams.Memberships.site_role(site, invitee) == {:error, :not_a_member} do
+ :ok
+ else
+ {:error, :already_a_member}
+ end
+ end
+
+ defp create_invitation(site, invitee_email, role, inviter) do
+ Repo.transaction(fn ->
+ with {:ok, team_invitation} <- create_team_invitation(site.team, invitee_email, inviter),
+ {:ok, guest_invitation} <- create_guest_invitation(team_invitation, site, role) do
+ guest_invitation
+ else
+ {:error, changeset} -> Repo.rollback(changeset)
+ end
+ end)
+ end
+
+ defp create_team_invitation(team, invitee_email, inviter) do
+ now = NaiveDateTime.utc_now(:second)
+
+ team
+ |> Teams.Invitation.changeset(email: invitee_email, role: :guest, inviter: inviter)
+ |> Repo.insert(on_conflict: [set: [updated_at: now]], conflict_target: [:team_id, :email])
+ end
+
+ defp create_guest_invitation(team_invitation, site, role) do
+ now = NaiveDateTime.utc_now(:second)
+
+ team_invitation
+ |> Teams.GuestInvitation.changeset(site, role)
+ |> Repo.insert(
+ on_conflict: [set: [updated_at: now]],
+ conflict_target: [:team_invitation_id, :site_id]
+ )
+ end
+
+ defp send_invitation_email(guest_invitation, invitee) do
+ team_invitation = guest_invitation.team_invitation
+
+ email =
+ if invitee do
+ PlausibleWeb.Email.existing_user_invitation(
+ team_invitation.email,
+ guest_invitation.site,
+ team_invitation.inviter
+ )
+ else
+ PlausibleWeb.Email.new_user_invitation(
+ team_invitation.email,
+ team_invitation.invitation_id,
+ guest_invitation.site,
+ team_invitation.inviter
+ )
+ end
+
+ Plausible.Mailer.send(email)
+ end
+
+ defp create_team_membership(team, role, user, now) do
+ team
+ |> Teams.Membership.changeset(user, role)
+ |> Repo.insert(
+ on_conflict: [set: [updated_at: now]],
+ conflict_target: [:team_id, :user_id]
+ )
+ end
+
+ defp create_guest_memberships(_team_membership, [], _now) do
+ {:ok, []}
+ end
+
+ defp create_guest_memberships(%{role: role} = _team_membership, _, _) when role != :guest do
+ {:ok, []}
+ end
+
+ defp create_guest_memberships(team_membership, guest_invitations, now) do
+ Enum.reduce_while(guest_invitations, {:ok, []}, fn guest_invitation,
+ {:ok, guest_memberships} ->
+ result =
+ team_membership
+ |> Teams.GuestMembership.changeset(guest_invitation.site, guest_invitation.role)
+ |> Repo.insert(
+ on_conflict: [set: [updated_at: now, role: guest_invitation.role]],
+ conflict_target: [:team_membership_id, :site_id]
+ )
+
+ case result do
+ {:ok, guest_membership} -> {:cont, {:ok, [guest_membership | guest_memberships]}}
+ {:error, changeset} -> {:halt, {:error, changeset}}
+ end
+ end)
+ end
+
+ defp send_invitation_accepted_email(_team_invitation, []) do
+ # NOOP for now
+ :ok
+ end
+
+ defp send_invitation_accepted_email(team_invitation, [guest_invitation | _]) do
+ team_invitation.inviter.email
+ |> PlausibleWeb.Email.invitation_accepted(team_invitation.email, guest_invitation.site)
+ |> Plausible.Mailer.send()
+ end
+end
diff --git a/lib/plausible/teams/membership.ex b/lib/plausible/teams/membership.ex
new file mode 100644
index 0000000000..b446d995a3
--- /dev/null
+++ b/lib/plausible/teams/membership.ex
@@ -0,0 +1,29 @@
+defmodule Plausible.Teams.Membership do
+ @moduledoc """
+ Team membership schema
+ """
+
+ use Ecto.Schema
+
+ import Ecto.Changeset
+
+ schema "team_memberships" do
+ field :role, Ecto.Enum, values: [:guest, :viewer, :editor, :admin, :owner]
+
+ belongs_to :user, Plausible.Auth.User
+ belongs_to :team, Plausible.Teams.Team
+
+ has_many :guest_memberships, Plausible.Teams.GuestMembership, foreign_key: :team_membership_id
+
+ timestamps()
+ end
+
+ def changeset(team, user, role) do
+ %__MODULE__{}
+ |> change()
+ |> put_change(:role, role)
+ |> put_assoc(:team, team)
+ |> put_assoc(:user, user)
+ |> unique_constraint(:user_id, name: :one_team_per_user)
+ end
+end
diff --git a/lib/plausible/teams/memberships.ex b/lib/plausible/teams/memberships.ex
new file mode 100644
index 0000000000..15f9c9cf05
--- /dev/null
+++ b/lib/plausible/teams/memberships.ex
@@ -0,0 +1,133 @@
+defmodule Plausible.Teams.Memberships do
+ @moduledoc false
+
+ import Ecto.Query
+
+ alias Plausible.Auth
+ alias Plausible.Repo
+ alias Plausible.Teams
+
+ def get(team, user) do
+ result =
+ from(tm in Teams.Membership,
+ left_join: gm in assoc(tm, :guest_memberships),
+ where: tm.team_id == ^team.id and tm.user_id == ^user.id
+ )
+ |> Repo.one()
+
+ case result do
+ nil -> {:error, :not_a_member}
+ team_membership -> {:ok, team_membership}
+ end
+ end
+
+ def team_role(team, user) do
+ result =
+ from(u in Auth.User,
+ inner_join: tm in assoc(u, :team_memberships),
+ where: tm.team_id == ^team.id and tm.user_id == ^user.id,
+ select: tm.role
+ )
+ |> Repo.one()
+
+ case result do
+ nil -> {:error, :not_a_member}
+ role -> {:ok, role}
+ end
+ end
+
+ def site_role(site, user) do
+ result =
+ from(u in Auth.User,
+ inner_join: tm in assoc(u, :team_memberships),
+ left_join: gm in assoc(tm, :guest_memberships),
+ where: tm.team_id == ^site.team_id and tm.user_id == ^user.id,
+ where: tm.role != :guest or gm.site_id == ^site.id,
+ select: {tm.role, gm.role}
+ )
+ |> Repo.one()
+
+ case result do
+ {:guest, role} -> {:ok, role}
+ {role, _} -> {:ok, role}
+ _ -> {:error, :not_a_member}
+ end
+ end
+
+ def update_role_sync(site_membership) do
+ site_id = site_membership.site_id
+ user_id = site_membership.user_id
+ role = site_membership.role
+
+ new_role =
+ case role do
+ :viewer -> :viewer
+ _ -> :editor
+ end
+
+ case get_guest_membership(site_id, user_id) do
+ {:ok, guest_membership} ->
+ guest_membership
+ |> Ecto.Changeset.change(role: new_role)
+ |> Ecto.Changeset.put_change(:updated_at, site_membership.updated_at)
+ |> Repo.update!()
+
+ {:error, _} ->
+ :pass
+ end
+
+ :ok
+ end
+
+ def remove_sync(site_membership) do
+ site_id = site_membership.site_id
+ user_id = site_membership.user_id
+
+ case get_guest_membership(site_id, user_id) do
+ {:ok, guest_membership} ->
+ guest_membership = Repo.preload(guest_membership, team_membership: :team)
+ Repo.delete!(guest_membership)
+ prune_guests(guest_membership.team_membership.team)
+
+ {:error, _} ->
+ :pass
+ end
+ end
+
+ def prune_guests(team, opts \\ []) do
+ ignore_guest_ids = Keyword.get(opts, :ignore_guest_ids, [])
+
+ guest_query =
+ from(
+ gm in Teams.GuestMembership,
+ where: gm.team_membership_id == parent_as(:team_membership).id,
+ where: gm.id not in ^ignore_guest_ids,
+ select: true
+ )
+
+ Repo.delete_all(
+ from(
+ tm in Teams.Membership,
+ as: :team_membership,
+ where: tm.team_id == ^team.id and tm.role == :guest,
+ where: not exists(guest_query)
+ )
+ )
+
+ :ok
+ end
+
+ defp get_guest_membership(site_id, user_id) do
+ query =
+ from(
+ gm in Teams.GuestMembership,
+ inner_join: tm in assoc(gm, :team_membership),
+ where: gm.site_id == ^site_id and tm.user_id == ^user_id
+ )
+
+ case Repo.one(query) do
+ nil -> {:error, :no_guest}
+ membership -> {:ok, membership}
+ end
+ end
+end
diff --git a/lib/plausible/teams/site_transfer.ex b/lib/plausible/teams/site_transfer.ex
new file mode 100644
index 0000000000..d46dfaab0b
--- /dev/null
+++ b/lib/plausible/teams/site_transfer.ex
@@ -0,0 +1,35 @@
+defmodule Plausible.Teams.SiteTransfer do
+ @moduledoc """
+ Site transfer schema
+ """
+
+ use Ecto.Schema
+
+ import Ecto.Changeset
+
+ schema "team_site_transfers" do
+ field :transfer_id, :string
+ field :email, :string
+ field :transfer_guests, :boolean, default: true
+
+ belongs_to :site, Plausible.Site
+ belongs_to :initiator, Plausible.Auth.User
+ belongs_to :destination_team, Plausible.Teams.Team
+
+ timestamps()
+ end
+
+ def changeset(site, opts) do
+ initiator = Keyword.fetch!(opts, :initiator)
+ transfer_guests = Keyword.get(opts, :transfer_guests, true)
+ destination_team = Keyword.get(opts, :destination_team)
+ email = Keyword.get(opts, :email)
+
+ %__MODULE__{transfer_id: Nanoid.generate()}
+ |> cast(%{email: email}, [:email])
+ |> put_change(:transfer_guests, transfer_guests)
+ |> put_assoc(:site, site)
+ |> put_assoc(:destination_team, destination_team)
+ |> put_assoc(:initiator, initiator)
+ end
+end
diff --git a/lib/plausible/teams/sites.ex b/lib/plausible/teams/sites.ex
new file mode 100644
index 0000000000..173066ce01
--- /dev/null
+++ b/lib/plausible/teams/sites.ex
@@ -0,0 +1,206 @@
+defmodule Plausible.Teams.Sites do
+ @moduledoc false
+
+ import Ecto.Query
+
+ alias Plausible.Auth
+ alias Plausible.Repo
+ alias Plausible.Site
+ alias Plausible.Teams
+
+ @type list_opt() :: {:filter_by_domain, String.t()}
+
+ @spec create(Teams.Team.t(), map()) :: {:ok, map()}
+ def create(team, params) do
+ with :ok <- Teams.Billing.ensure_can_add_new_site(team) do
+ Ecto.Multi.new()
+ |> Ecto.Multi.put(:site_changeset, Site.new_for_team(team, params))
+ |> Ecto.Multi.run(:clear_changed_from, fn
+ _repo, %{site_changeset: %{changes: %{domain: domain}}} ->
+ if site_to_clear = Repo.get_by(Site, team_id: team.id, domain_changed_from: domain) do
+ site_to_clear
+ |> Ecto.Changeset.change()
+ |> Ecto.Changeset.put_change(:domain_changed_from, nil)
+ |> Ecto.Changeset.put_change(:domain_changed_at, nil)
+ |> Repo.update()
+ else
+ {:ok, :ignore}
+ end
+
+ _repo, _context ->
+ {:ok, :ignore}
+ end)
+ |> Ecto.Multi.insert(:site, fn %{site_changeset: site} -> site end)
+ |> maybe_start_trial(team)
+ |> Repo.transaction()
+ end
+ end
+
+ defp maybe_start_trial(multi, team) do
+ case team.trial_expiry_date do
+ nil ->
+ changeset = Teams.Team.start_trial(team)
+ Ecto.Multi.update(multi, :team, changeset)
+
+ _ ->
+ multi
+ 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)
+
+ team_membership_query =
+ from tm in Teams.Membership,
+ inner_join: t in assoc(tm, :team),
+ inner_join: s in assoc(t, :sites),
+ where: tm.user_id == ^user.id and tm.role != :guest,
+ select: %{site_id: s.id, entry_type: "site"}
+
+ guest_membership_query =
+ from tm in Teams.Membership,
+ inner_join: gm in assoc(tm, :guest_memberships),
+ inner_join: s in assoc(gm, :site),
+ where: tm.user_id == ^user.id and tm.role == :guest,
+ select: %{site_id: s.id, entry_type: "site"}
+
+ union_query =
+ from s in team_membership_query,
+ union_all: ^guest_membership_query
+
+ from(u in subquery(union_query),
+ inner_join: s in Plausible.Site,
+ on: u.site_id == s.id,
+ left_join: up in Site.UserPreference,
+ on: up.site_id == s.id,
+ select: %{
+ s
+ | entry_type:
+ selected_as(
+ fragment(
+ """
+ CASE
+ WHEN ? IS NOT NULL THEN 'pinned_site'
+ ELSE ?
+ END
+ """,
+ up.pinned_at,
+ u.entry_type
+ ),
+ :entry_type
+ ),
+ pinned_at: selected_as(up.pinned_at, :pinned_at)
+ },
+ order_by: [
+ asc: selected_as(:entry_type),
+ desc: selected_as(:pinned_at),
+ asc: s.domain
+ ]
+ )
+ |> maybe_filter_by_domain(domain_filter)
+ |> Repo.paginate(pagination_params)
+ end
+
+ @spec list_with_invitations(Auth.User.t(), map(), [list_opt()]) :: Scrivener.Page.t()
+ def list_with_invitations(user, pagination_params, opts \\ []) do
+ domain_filter = Keyword.get(opts, :filter_by_domain)
+
+ team_membership_query =
+ from tm in Teams.Membership,
+ inner_join: t in assoc(tm, :team),
+ inner_join: s in assoc(t, :sites),
+ where: tm.user_id == ^user.id and tm.role != :guest,
+ select: %{site_id: s.id, entry_type: "site", invitation_id: 0, invitation_role: ""}
+
+ guest_membership_query =
+ from(tm in Teams.Membership,
+ inner_join: gm in assoc(tm, :guest_memberships),
+ inner_join: s in assoc(gm, :site),
+ where: tm.user_id == ^user.id and tm.role == :guest,
+ select: %{site_id: s.id, entry_type: "site", invitation_id: 0, invitation_role: ""}
+ )
+
+ guest_invitation_query =
+ from ti in Teams.Invitation,
+ inner_join: gi in assoc(ti, :guest_invitations),
+ inner_join: s in assoc(gi, :site),
+ where: ti.email == ^user.email and ti.role == :guest,
+ select: %{
+ site_id: s.id,
+ entry_type: "invitation",
+ invitation_id: ti.id,
+ invitation_role: gi.role
+ }
+
+ union_query =
+ from s in team_membership_query,
+ union_all: ^guest_membership_query,
+ union_all: ^guest_invitation_query
+
+ from(u in subquery(union_query),
+ inner_join: s in Plausible.Site,
+ on: u.site_id == s.id,
+ left_join: up in Site.UserPreference,
+ on: up.site_id == s.id,
+ left_join: ti in Teams.Invitation,
+ on: ti.id == u.invitation_id,
+ select: %{
+ s
+ | entry_type:
+ selected_as(
+ fragment(
+ """
+ CASE
+ WHEN ? IS NOT NULL THEN 'pinned_site'
+ ELSE ?
+ END
+ """,
+ up.pinned_at,
+ u.entry_type
+ ),
+ :entry_type
+ ),
+ pinned_at: selected_as(up.pinned_at, :pinned_at),
+ invitations: [
+ %Plausible.Auth.Invitation{
+ invitation_id: ti.invitation_id,
+ email: ti.email,
+ role: u.invitation_role
+ }
+ ]
+ },
+ order_by: [
+ asc: selected_as(:entry_type),
+ desc: selected_as(:pinned_at),
+ asc: s.domain
+ ]
+ )
+ |> maybe_filter_by_domain(domain_filter)
+ |> Repo.paginate(pagination_params)
+ 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/team.ex b/lib/plausible/teams/team.ex
new file mode 100644
index 0000000000..e1fe3a056d
--- /dev/null
+++ b/lib/plausible/teams/team.ex
@@ -0,0 +1,73 @@
+defmodule Plausible.Teams.Team do
+ @moduledoc """
+ Team schema
+ """
+
+ use Ecto.Schema
+ use Plausible
+
+ import Ecto.Changeset
+
+ @type t() :: %__MODULE__{}
+
+ @trial_accept_traffic_until_offset_days 14
+
+ schema "teams" do
+ field :name, :string
+ field :trial_expiry_date, :date
+ field :accept_traffic_until, :date
+ field :allow_next_upgrade_override, :boolean
+
+ embeds_one :grace_period, Plausible.Auth.GracePeriod, on_replace: :update
+
+ has_many :sites, Plausible.Site
+ has_many :team_memberships, Plausible.Teams.Membership
+ has_many :team_invitations, Plausible.Teams.Invitation
+ has_one :subscription, Plausible.Billing.Subscription
+ has_one :enterprise_plan, Plausible.Billing.EnterprisePlan
+
+ timestamps()
+ end
+
+ def sync_changeset(team, user) do
+ team
+ |> change()
+ |> put_change(:trial_expiry_date, user.trial_expiry_date)
+ |> put_change(:accept_traffic_until, user.accept_traffic_until)
+ |> put_change(:allow_next_upgrade_override, user.allow_next_upgrade_override)
+ |> put_embed(:grace_period, user.grace_period)
+ |> put_change(:inserted_at, user.inserted_at)
+ |> put_change(:updated_at, user.updated_at)
+ end
+
+ def changeset(name, today \\ Date.utc_today()) do
+ trial_expiry_date =
+ if ee?() do
+ Date.shift(today, day: 30)
+ else
+ Date.shift(today, year: 100)
+ end
+
+ %__MODULE__{}
+ |> cast(%{name: name}, [:name])
+ |> validate_required(:name)
+ |> put_change(:trial_expiry_date, trial_expiry_date)
+ end
+
+ def start_trial(team) do
+ trial_expiry = trial_expiry()
+
+ change(team,
+ trial_expiry_date: trial_expiry,
+ accept_traffic_until: Date.add(trial_expiry, @trial_accept_traffic_until_offset_days)
+ )
+ end
+
+ defp trial_expiry() do
+ on_ee do
+ Date.utc_today() |> Date.shift(day: 30)
+ else
+ Date.utc_today() |> Date.shift(year: 100)
+ end
+ end
+end
diff --git a/lib/plausible/users.ex b/lib/plausible/users.ex
index 39a32d78d3..9604380054 100644
--- a/lib/plausible/users.ex
+++ b/lib/plausible/users.ex
@@ -8,6 +8,7 @@ defmodule Plausible.Users do
import Ecto.Query
alias Plausible.Auth
+ alias Plausible.Auth.GracePeriod
alias Plausible.Billing.Subscription
alias Plausible.Repo
@@ -30,9 +31,16 @@ defmodule Plausible.Users do
@spec update_accept_traffic_until(Auth.User.t()) :: Auth.User.t()
def update_accept_traffic_until(user) do
+ user =
+ user
+ |> Auth.User.changeset(%{accept_traffic_until: accept_traffic_until(user)})
+ |> Repo.update!()
+
+ with_teams do
+ Plausible.Teams.sync_team(user)
+ end
+
user
- |> Auth.User.changeset(%{accept_traffic_until: accept_traffic_until(user)})
- |> Repo.update!()
end
@spec bump_last_seen(Auth.User.t() | pos_integer(), NaiveDateTime.t()) :: :ok
@@ -98,17 +106,44 @@ defmodule Plausible.Users do
Auth.EmailVerification.any?(user)
end
+ def start_trial(%Auth.User{} = user) do
+ user =
+ user
+ |> Auth.User.start_trial()
+ |> Repo.update!()
+
+ with_teams do
+ Plausible.Teams.sync_team(user)
+ end
+
+ user
+ end
+
def allow_next_upgrade_override(%Auth.User{} = user) do
+ user =
+ user
+ |> Auth.User.changeset(%{allow_next_upgrade_override: true})
+ |> Repo.update!()
+
+ with_teams do
+ Plausible.Teams.sync_team(user)
+ end
+
user
- |> Auth.User.changeset(%{allow_next_upgrade_override: true})
- |> Repo.update!()
end
def maybe_reset_next_upgrade_override(%Auth.User{} = user) do
if user.allow_next_upgrade_override do
+ user =
+ user
+ |> Auth.User.changeset(%{allow_next_upgrade_override: false})
+ |> Repo.update!()
+
+ with_teams do
+ Plausible.Teams.sync_team(user)
+ end
+
user
- |> Auth.User.changeset(%{allow_next_upgrade_override: false})
- |> Repo.update!()
else
user
end
@@ -120,6 +155,58 @@ defmodule Plausible.Users do
)
end
+ def start_grace_period(user) do
+ user =
+ user
+ |> GracePeriod.start_changeset()
+ |> Repo.update!()
+
+ with_teams do
+ Plausible.Teams.sync_team(user)
+ end
+
+ user
+ end
+
+ def start_manual_lock_grace_period(user) do
+ user =
+ user
+ |> GracePeriod.start_manual_lock_changeset()
+ |> Repo.update!()
+
+ with_teams do
+ Plausible.Teams.sync_team(user)
+ end
+
+ user
+ end
+
+ def end_grace_period(user) do
+ user =
+ user
+ |> GracePeriod.end_changeset()
+ |> Repo.update!()
+
+ with_teams do
+ Plausible.Teams.sync_team(user)
+ end
+
+ user
+ end
+
+ def remove_grace_period(user) do
+ user =
+ user
+ |> GracePeriod.remove_changeset()
+ |> Repo.update!()
+
+ with_teams do
+ Plausible.Teams.sync_team(user)
+ end
+
+ user
+ end
+
defp last_subscription_query() do
from(subscription in Subscription,
order_by: [desc: subscription.inserted_at],
diff --git a/lib/plausible_web/components/billing/billing.ex b/lib/plausible_web/components/billing/billing.ex
index 74ce1544af..6f51713bd7 100644
--- a/lib/plausible_web/components/billing/billing.ex
+++ b/lib/plausible_web/components/billing/billing.ex
@@ -227,6 +227,7 @@ defmodule PlausibleWeb.Components.Billing do
attr :paddle_product_id, :string, required: true
attr :checkout_disabled, :boolean, default: false
attr :user, :map, required: true
+ attr :team, :map, default: nil
attr :confirm_message, :any, default: nil
slot :inner_block, required: true
@@ -234,12 +235,22 @@ defmodule PlausibleWeb.Components.Billing do
confirmed =
if assigns.confirm_message, do: "confirm(\"#{assigns.confirm_message}\")", else: "true"
- assigns = assign(assigns, :confirmed, confirmed)
+ passthrough =
+ if assigns.team do
+ "user:#{assigns.user.id};team:#{assigns.team.id}"
+ else
+ assigns.user.id
+ end
+
+ assigns =
+ assigns
+ |> assign(:confirmed, confirmed)
+ |> assign(:passthrough, passthrough)
~H"""
<button
id={@id}
- onclick={"if (#{@confirmed}) {Paddle.Checkout.open(#{Jason.encode!(%{product: @paddle_product_id, email: @user.email, disableLogout: true, passthrough: @user.id, success: Routes.billing_path(PlausibleWeb.Endpoint, :upgrade_success), theme: "none"})})}"}
+ onclick={"if (#{@confirmed}) {Paddle.Checkout.open(#{Jason.encode!(%{product: @paddle_product_id, email: @user.email, disableLogout: true, passthrough: @passthrough, success: Routes.billing_path(PlausibleWeb.Endpoint, :upgrade_success), theme: "none"})})}"}
class={[
"text-sm w-full mt-6 block rounded-md py-2 px-3 text-center font-semibold leading-6 text-white",
!@checkout_disabled && "bg-indigo-600 hover:bg-indigo-500",
diff --git a/lib/plausible_web/components/billing/plan_box.ex b/lib/plausible_web/components/billing/plan_box.ex
index 7b2e3ce2ad..d853e1e65a 100644
--- a/lib/plausible_web/components/billing/plan_box.ex
+++ b/lib/plausible_web/components/billing/plan_box.ex
@@ -227,7 +227,11 @@ defmodule PlausibleWeb.Components.Billing.PlanBox do
<%= if @owned_plan && Plausible.Billing.Subscriptions.resumable?(@current_user.subscription) do %>
<.change_plan_link {assigns} />
<% else %>
- <PlausibleWeb.Components.Billing.paddle_button user={@current_user} {assigns}>
+ <PlausibleWeb.Components.Billing.paddle_button
+ user={@current_user}
+ team={@current_team}
+ {assigns}
+ >
Upgrade
</PlausibleWeb.Components.Billing.paddle_button>
<% end %>
diff --git a/lib/plausible_web/controllers/site/membership_controller.ex b/lib/plausible_web/controllers/site/membership_controller.ex
index f06cfdae54..5eb60f280b 100644
--- a/lib/plausible_web/controllers/site/membership_controller.ex
+++ b/lib/plausible_web/controllers/site/membership_controller.ex
@@ -12,6 +12,7 @@ defmodule PlausibleWeb.Site.MembershipController do
use PlausibleWeb, :controller
use Plausible.Repo
+ use Plausible
alias Plausible.Sites
alias Plausible.Site.{Membership, Memberships}
@@ -170,6 +171,10 @@ defmodule PlausibleWeb.Site.MembershipController do
|> Membership.set_role(new_role)
|> Repo.update!()
+ with_teams do
+ Plausible.Teams.Memberships.update_role_sync(membership)
+ end
+
redirect_target =
if membership.user.id == current_user.id and new_role == :viewer do
"/#{URI.encode_www_form(site.domain)}"
@@ -216,6 +221,10 @@ defmodule PlausibleWeb.Site.MembershipController do
if membership do
Repo.delete!(membership)
+ with_teams do
+ Plausible.Teams.Memberships.remove_sync(membership)
+ end
+
membership
|> PlausibleWeb.Email.site_member_removed()
|> Plausible.Mailer.send()
diff --git a/lib/plausible_web/email.ex b/lib/plausible_web/email.ex
index 1ee0eeb1bc..0f414d5a7c 100644
--- a/lib/plausible_web/email.ex
+++ b/lib/plausible_web/email.ex
@@ -233,49 +233,52 @@ defmodule PlausibleWeb.Email do
|> render("cancellation_email.html", user: user)
end
- def new_user_invitation(invitation) do
+ def new_user_invitation(email, invitation_id, site, inviter) do
priority_email()
- |> to(invitation.email)
+ |> to(email)
|> tag("new-user-invitation")
- |> subject("[#{Plausible.product_name()}] You've been invited to #{invitation.site.domain}")
+ |> subject("[#{Plausible.product_name()}] You've been invited to #{site.domain}")
|> render("new_user_invitation.html",
- invitation: invitation
+ invitation_id: invitation_id,
+ site: site,
+ inviter: inviter
)
end
- def existing_user_invitation(invitation) do
+ def existing_user_invitation(email, site, inviter) do
priority_email()
- |> to(invitation.email)
+ |> to(email)
|> tag("existing-user-invitation")
- |> subject("[#{Plausible.product_name()}] You've been invited to #{invitation.site.domain}")
+ |> subject("[#{Plausible.product_name()}] You've been invited to #{site.domain}")
|> render("existing_user_invitation.html",
- invitation: invitation
+ site: site,
+ inviter: inviter
)
end
- def ownership_transfer_request(invitation, new_owner_account) do
+ def ownership_transfer_request(email, invitation_id, site, inviter, new_owner_account) do
priority_email()
- |> to(invitation.email)
+ |> to(email)
|> tag("ownership-transfer-request")
- |> subject(
- "[#{Plausible.product_name()}] Request to transfer ownership of #{invitation.site.domain}"
- )
+ |> subject("[#{Plausible.product_name()}] Request to transfer ownership of #{site.domain}")
|> render("ownership_transfer_request.html",
- invitation: invitation,
+ invitation_id: invitation_id,
+ inviter: inviter,
+ site: site,
new_owner_account: new_owner_account
)
end
- def invitation_accepted(invitation) do
+ def invitation_accepted(inviter_email, invitee_email, site) do
priority_email()
- |> to(invitation.inviter.email)
+ |> to(inviter_email)
|> tag("invitation-accepted")
|> subject(
- "[#{Plausible.product_name()}] #{invitation.email} accepted your invitation to #{invitation.site.domain}"
+ "[#{Plausible.product_name()}] #{invitee_email} accepted your invitation to #{site.domain}"
)
|> render("invitation_accepted.html",
- user: invitation.inviter,
- invitation: invitation
+ invitee_email: invitee_email,
+ site: site
)
end
@@ -292,16 +295,16 @@ defmodule PlausibleWeb.Email do
)
end
- def ownership_transfer_accepted(invitation) do
+ def ownership_transfer_accepted(new_owner_email, inviter_email, site) do
priority_email()
- |> to(invitation.inviter.email)
+ |> to(inviter_email)
|> tag("ownership-transfer-accepted")
|> subject(
- "[#{Plausible.product_name()}] #{invitation.email} accepted the ownership transfer of #{invitation.site.domain}"
+ "[#{Plausible.product_name()}] #{new_owner_email} accepted the ownership transfer of #{site.domain}"
)
|> render("ownership_transfer_accepted.html",
- user: invitation.inviter,
- invitation: invitation
+ new_owner_email: new_owner_email,
+ site: site
)
end
diff --git a/lib/plausible_web/live/auth_context.ex b/lib/plausible_web/live/auth_context.ex
index c58e1b612b..1258605d69 100644
--- a/lib/plausible_web/live/auth_context.ex
+++ b/lib/plausible_web/live/auth_context.ex
@@ -31,6 +31,13 @@ defmodule PlausibleWeb.Live.AuthContext do
_ -> nil
end
end)
+ |> assign_new(:current_team, fn context ->
+ case context.current_user do
+ nil -> nil
+ %{team_memberships: [%{team: team}]} -> team
+ %{team_memberships: []} -> nil
+ end
+ end)
{:cont, socket}
end
diff --git a/lib/plausible_web/plugs/auth_plug.ex b/lib/plausible_web/plugs/auth_plug.ex
index 7f2a0809bc..290a426bea 100644
--- a/lib/plausible_web/plugs/auth_plug.ex
+++ b/lib/plausible_web/plugs/auth_plug.ex
@@ -20,12 +20,22 @@ defmodule PlausibleWeb.AuthPlug do
{:ok, user_session} ->
user = user_session.user
+ team =
+ case user.team_memberships do
+ [%{team: team}] ->
+ team
+
+ [] ->
+ nil
+ end
+
Plausible.OpenTelemetry.add_user_attributes(user)
Sentry.Context.set_user_context(%{id: user.id, name: user.name, email: user.email})
conn
|> assign(:current_user, user)
|> assign(:current_user_session, user_session)
+ |> assign(:current_team, team)
_ ->
conn
diff --git a/lib/plausible_web/templates/billing/upgrade_to_enterprise_plan.html.heex b/lib/plausible_web/templates/billing/upgrade_to_enterprise_plan.html.heex
index 0a0555f320..2be8b52b70 100644
--- a/lib/plausible_web/templates/billing/upgrade_to_enterprise_plan.html.heex
+++ b/lib/plausible_web/templates/billing/upgrade_to_enterprise_plan.html.heex
@@ -67,6 +67,7 @@
id="paddle-button"
paddle_product_id={@latest_enterprise_plan.paddle_plan_id}
user={@current_user}
+ team={@current_team}
>
<svg fill="currentColor" viewBox="0 0 20 20" class="inline w-4 h-4 mr-2">
<path
diff --git a/lib/plausible_web/templates/email/existing_user_invitation.html.heex b/lib/plausible_web/templates/email/existing_user_invitation.html.heex
index 43b5fa903f..3e5dca4fe7 100644
--- a/lib/plausible_web/templates/email/existing_user_invitation.html.heex
+++ b/lib/plausible_web/templates/email/existing_user_invitation.html.heex
@@ -1,3 +1,3 @@
-<%= @invitation.inviter.email %> has invited you to the <%= @invitation.site.domain %> site on <%= Plausible.product_name() %>.
+<%= @inviter.email %> has invited you to the <%= @site.domain %> site on <%= Plausible.product_name() %>.
<a href={Routes.site_url(PlausibleWeb.Endpoint, :index)}>Click here</a> to view and respond to the invitation. The invitation
will expire 48 hours after this email is sent.
diff --git a/lib/plausible_web/templates/email/invitation_accepted.html.heex b/lib/plausible_web/templates/email/invitation_accepted.html.heex
index 0547b1b7e9..c68d3cb49e 100644
--- a/lib/plausible_web/templates/email/invitation_accepted.html.heex
+++ b/lib/plausible_web/templates/email/invitation_accepted.html.heex
@@ -1,2 +1,2 @@
-<%= @invitation.email %> has accepted your invitation to <%= @invitation.site.domain %>.
-<a href={Routes.site_url(PlausibleWeb.Endpoint, :settings_general, @invitation.site.domain)}>Click here</a> to view site settings.
+<%= @invitee_email %> has accepted your invitation to <%= @site.domain %>.
+<a href={Routes.site_url(PlausibleWeb.Endpoint, :settings_general, @site.domain)}>Click here</a> to view site settings.
diff --git a/lib/plausible_web/templates/email/new_user_invitation.html.heex b/lib/plausible_web/templates/email/new_user_invitation.html.heex
index 64c0c459d9..53f9affa30 100644
--- a/lib/plausible_web/templates/email/new_user_invitation.html.heex
+++ b/lib/plausible_web/templates/email/new_user_invitation.html.heex
@@ -1,9 +1,9 @@
-<%= @invitation.inviter.email %> has invited you to join the <%= @invitation.site.domain %> site on <%= Plausible.product_name() %>.
+<%= @inviter.email %> has invited you to join the <%= @site.domain %> site on <%= Plausible.product_name() %>.
<a href={
Routes.auth_url(
PlausibleWeb.Endpoint,
:register_from_invitation_form,
- @invitation.invitation_id
+ @invitation_id
)
}>Click here</a> to create your account. The link is valid for 48 hours after this email is sent.
<br /><br />
diff --git a/lib/plausible_web/templates/email/ownership_transfer_accepted.html.heex b/lib/plausible_web/templates/email/ownership_transfer_accepted.html.heex
index 3e0f39ac0d..a77705c1bf 100644
--- a/lib/plausible_web/templates/email/ownership_transfer_accepted.html.heex
+++ b/lib/plausible_web/templates/email/ownership_transfer_accepted.html.heex
@@ -1,3 +1,3 @@
-<%= @invitation.email %> has accepted the ownership transfer of <%= @invitation.site.domain %>. They will be responsible for billing of it going
+<%= @new_owner_email %> has accepted the ownership transfer of <%= @site.domain %>. They will be responsible for billing of it going
forward and your role has been changed to <b>admin</b>.
-<a href={Routes.site_url(PlausibleWeb.Endpoint, :settings_general, @invitation.site.domain)}>Click here</a> to view site settings.
+<a href={Routes.site_url(PlausibleWeb.Endpoint, :settings_general, @site.domain)}>Click here</a> to view site settings.
diff --git a/lib/plausible_web/templates/email/ownership_transfer_request.html.heex b/lib/plausible_web/templates/email/ownership_transfer_request.html.heex
index 36ac511a31..bbfab461ba 100644
--- a/lib/plausible_web/templates/email/ownership_transfer_request.html.heex
+++ b/lib/plausible_web/templates/email/ownership_transfer_request.html.heex
@@ -1,15 +1,11 @@
-<%= @invitation.inviter.email %> has requested to transfer the ownership of <%= @invitation.site.domain %> site on <%= Plausible.product_name() %> to you.
+<%= @inviter.email %> has requested to transfer the ownership of <%= @site.domain %> site on <%= Plausible.product_name() %> to you.
<%= if @new_owner_account do %>
<a href={Routes.site_url(PlausibleWeb.Endpoint, :index)}>Click here</a>
to view and respond to the invitation.
<% else %>
<a
phx-no-format
- href={
- Routes.auth_url(PlausibleWeb.Endpoint, :register_form,
- invitation: @invitation.invitation_id
- )
- }
+ href={Routes.auth_url(PlausibleWeb.Endpoint, :register_form, invitation: @invitation_id)}
>Click here</a> to create your account. <br /><br />
Plausible is a lightweight and open-source website analytics tool. We hope you like our simple and ethical approach to tracking website visitors.
<% end %>
diff --git a/lib/plausible_web/user_auth.ex b/lib/plausible_web/user_auth.ex
index 451ecce54b..58e3bf362d 100644
--- a/lib/plausible_web/user_auth.ex
+++ b/lib/plausible_web/user_auth.ex
@@ -129,10 +129,13 @@ defmodule PlausibleWeb.UserAuth do
from(us in Auth.UserSession,
inner_join: u in assoc(us, :user),
as: :user,
+ left_join: tm in assoc(u, :team_memberships),
+ on: tm.role != :guest,
+ left_join: t in assoc(tm, :team),
left_lateral_join: s in subquery(last_subscription_query),
on: true,
where: us.token == ^token and us.timeout_at > ^now,
- preload: [user: {u, subscription: s}]
+ preload: [user: {u, subscription: s, team_memberships: {tm, team: t}}]
)
case Repo.one(token_query) do
diff --git a/lib/workers/check_usage.ex b/lib/workers/check_usage.ex
index 1c7c5e011f..a66d6d670c 100644
--- a/lib/workers/check_usage.ex
+++ b/lib/workers/check_usage.ex
@@ -103,9 +103,8 @@ 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, _} ->
- subscriber
- |> Plausible.Auth.GracePeriod.remove_changeset()
- |> Repo.update()
+ Plausible.Users.remove_grace_period(subscriber)
+ :ok
_ ->
:skip
@@ -121,9 +120,7 @@ defmodule Plausible.Workers.CheckUsage do
PlausibleWeb.Email.over_limit_email(subscriber, pageview_usage, suggested_plan)
|> Plausible.Mailer.send()
- subscriber
- |> Plausible.Auth.GracePeriod.start_changeset()
- |> Repo.update()
+ Plausible.Users.start_grace_period(subscriber)
_ ->
nil
@@ -147,9 +144,7 @@ defmodule Plausible.Workers.CheckUsage do
)
|> Plausible.Mailer.send()
- subscriber
- |> Plausible.Auth.GracePeriod.start_manual_lock_changeset()
- |> Repo.update()
+ Plausible.Users.start_manual_lock_grace_period(subscriber)
end
end
diff --git a/lib/workers/clean_invitations.ex b/lib/workers/clean_invitations.ex
index 297d005a4b..c822e93a59 100644
--- a/lib/workers/clean_invitations.ex
+++ b/lib/workers/clean_invitations.ex
@@ -15,6 +15,11 @@ defmodule Plausible.Workers.CleanInvitations do
where: i.inserted_at < ^cutoff_time
)
+ Repo.delete_all(
+ from ti in Plausible.Teams.Invitation,
+ where: ti.inserted_at < ^cutoff_time
+ )
+
:ok
end
end
diff --git a/test/plausible/billing/billing_test.exs b/test/plausible/billing/billing_test.exs
index 082a1e4489..788c53bd23 100644
--- a/test/plausible/billing/billing_test.exs
+++ b/test/plausible/billing/billing_test.exs
@@ -77,7 +77,7 @@ defmodule Plausible.BillingTest do
user = insert(:user, trial_expiry_date: Timex.shift(Timex.today(), days: -1))
insert(:subscription, user: user, next_bill_date: Timex.today())
- user = user |> Plausible.Auth.GracePeriod.end_changeset() |> Repo.update!()
+ user = Plausible.Users.end_grace_period(user)
assert Billing.check_needs_to_upgrade(user) == {:needs_to_upgrade, :grace_period_ended}
end
diff --git a/test/plausible/site/memberships/accept_invitation_test.exs b/test/plausible/site/memberships/accept_invitation_test.exs
index a0123973d3..7b2aacc887 100644
--- a/test/plausible/site/memberships/accept_invitation_test.exs
+++ b/test/plausible/site/memberships/accept_invitation_test.exs
@@ -34,6 +34,68 @@ defmodule Plausible.Site.Memberships.AcceptInvitationTest do
assert_no_emails_delivered()
end
+ test "transfers ownership successfully (TEAM)" do
+ site = insert(:site, memberships: [])
+ existing_owner = insert(:user)
+
+ _existing_membership =
+ insert(:site_membership, user: existing_owner, site: site, role: :owner)
+
+ old_team = site.team
+
+ existing_team_membership =
+ insert(:team_membership, user: existing_owner, team: old_team, role: :owner)
+
+ another_user = insert(:user)
+
+ another_team_membership =
+ insert(:team_membership, user: another_user, team: old_team, role: :guest)
+
+ another_guest_membership =
+ insert(:guest_membership,
+ team_membership: another_team_membership,
+ site: site,
+ role: :viewer
+ )
+
+ new_owner = insert(:user)
+ new_team = insert(:team)
+ insert(:team_membership, user: new_owner, team: new_team, role: :owner)
+ insert(:growth_subscription, user: new_owner, team: new_team)
+
+ assert {:ok, new_team_membership} =
+ Plausible.Teams.Invitations.transfer_site(site, new_owner)
+
+ assert new_team_membership.team_id == new_team.id
+ assert new_team_membership.user_id == new_owner.id
+ assert new_team_membership.role == :owner
+
+ existing_team_membership = Repo.reload!(existing_team_membership)
+ assert existing_team_membership.user_id == existing_owner.id
+ assert existing_team_membership.team_id == old_team.id
+ assert existing_team_membership.role == :owner
+
+ refute Repo.reload(another_team_membership)
+ refute Repo.reload(another_guest_membership)
+
+ assert new_another_team_membership =
+ Plausible.Teams.Membership
+ |> Repo.get_by(
+ team_id: new_team.id,
+ user_id: another_user.id
+ )
+ |> Repo.preload(:guest_memberships)
+
+ assert another_team_membership.id != new_another_team_membership.id
+ assert [new_another_guest_membership] = new_another_team_membership.guest_memberships
+ assert new_another_guest_membership.site_id == site.id
+ assert new_another_guest_membership.role == another_guest_membership.role
+
+ assert new_another_team_membership.role == :guest
+
+ assert_no_emails_delivered()
+ end
+
@tag :ee_only
test "unlocks the site if it was previously locked" do
site = insert(:site, locked: true, memberships: [])
@@ -216,6 +278,51 @@ defmodule Plausible.Site.Memberships.AcceptInvitationTest do
)
end
+ test "converts an invitation into a membership (TEAMS)" do
+ inviter = insert(:user)
+ invitee = insert(:user)
+ team = insert(:team)
+ site = insert(:site, team: team, members: [inviter])
+ insert(:team_membership, team: team, user: inviter, role: :owner)
+
+ _invitation =
+ insert(:invitation,
+ site_id: site.id,
+ inviter: inviter,
+ email: invitee.email,
+ role: :admin
+ )
+
+ team_invitation =
+ insert(:team_invitation,
+ team: team,
+ inviter: inviter,
+ email: invitee.email,
+ role: :guest
+ )
+
+ insert(:guest_invitation, team_invitation: team_invitation, site: site, role: :editor)
+
+ assert {:ok, team_membership} =
+ Plausible.Teams.Invitations.accept(team_invitation.invitation_id, invitee)
+
+ assert [guest_membership] =
+ Repo.preload(team_membership, :guest_memberships).guest_memberships
+
+ assert guest_membership.site_id == site.id
+ assert team_membership.user_id == invitee.id
+ assert guest_membership.role == :editor
+ assert team_membership.role == :guest
+ assert team_membership.team_id == team.id
+
+ refute Repo.reload(team_invitation)
+
+ assert_email_delivered_with(
+ to: [nil: inviter.email],
+ subject: @subject_prefix <> "#{invitee.email} accepted your invitation to #{site.domain}"
+ )
+ end
+
test "does not degrade role when trying to invite self as an owner" do
user = insert(:user)
diff --git a/test/plausible/site/memberships/create_invitation_test.exs b/test/plausible/site/memberships/create_invitation_test.exs
index cb8490f555..21ab46ae32 100644
--- a/test/plausible/site/memberships/create_invitation_test.exs
+++ b/test/plausible/site/memberships/create_invitation_test.exs
@@ -10,37 +10,72 @@ defmodule Plausible.Site.Memberships.CreateInvitationTest do
test "creates an invitation" do
inviter = insert(:user)
invitee = insert(:user)
- site = insert(:site, memberships: [build(:site_membership, user: inviter, role: :owner)])
+ team = insert(:team)
+
+ site =
+ insert(:site,
+ team: team,
+ memberships: [build(:site_membership, user: inviter, role: :owner)]
+ )
+
+ insert(:team_membership, team: team, user: inviter, role: :owner)
assert {:ok, %Plausible.Auth.Invitation{}} =
CreateInvitation.create_invitation(site, inviter, invitee.email, :viewer)
+
+ assert {:ok, %Plausible.Teams.GuestInvitation{}} =
+ Plausible.Teams.Invitations.invite(site, inviter, invitee.email, :viewer)
end
test "returns validation errors" do
inviter = insert(:user)
- site = insert(:site, memberships: [build(:site_membership, user: inviter, role: :owner)])
+ team = insert(:team)
+
+ site =
+ insert(:site,
+ team: team,
+ memberships: [build(:site_membership, user: inviter, role: :owner)]
+ )
+
+ insert(:team_membership, team: team, user: inviter, role: :owner)
assert {:error, changeset} = CreateInvitation.create_invitation(site, inviter, "", :viewer)
assert {"can't be blank", _} = changeset.errors[:email]
+
+ assert {:error, changeset} = Plausible.Teams.Invitations.invite(site, inviter, "", :viewer)
+ assert {"can't be blank", _} = changeset.errors[:email]
end
test "returns error when user is already a member" do
inviter = insert(:user)
invitee = insert(:user)
+ team = insert(:team)
+
site =
insert(:site,
+ team: team,
memberships: [
build(:site_membership, user: inviter, role: :owner),
build(:site_membership, user: invitee, role: :viewer)
]
)
+ insert(:team_membership, team: team, user: inviter, role: :owner)
+ team_membership = insert(:team_membership, team: team, user: invitee, role: :guest)
+ insert(:guest_membership, team_membership: team_membership, site: site, role: :viewer)
+
assert {:error, :already_a_member} =
CreateInvitation.create_invitation(site, inviter, invitee.email, :viewer)
+ assert {:error, :already_a_member} =
+ Plausible.Teams.Invitations.invite(site, inviter, invitee.email, :viewer)
+
assert {:error, :already_a_member} =
CreateInvitation.create_invitation(site, inviter, inviter.email, :viewer)
+
+ assert {:error, :already_a_member} =
+ Plausible.Teams.Invitations.invite(site, inviter, inviter.email, :viewer)
end
test "sends invitation email for existing users" do
@@ -177,8 +212,14 @@ defmodule Plausible.Site.Memberships.CreateInvitationTest do
]
)
+ insert(:team_membership, team: site.team, user: inviter, role: :owner)
+ insert(:team_membership, team: site.team, user: invitee, role: :viewer)
+
assert {:ok, %Plausible.Auth.Invitation{}} =
CreateInvitation.create_invitation(site, inviter, invitee.email, :owner)
+
+ assert {:ok, %Plausible.Teams.SiteTransfer{}} =
+ Plausible.Teams.Invitations.invite(site, inviter, invitee.email, :owner)
end
test "does not allow transferring ownership to existing owner" do
@@ -191,8 +232,13 @@ defmodule Plausible.Site.Memberships.CreateInvitationTest do
]
)
+ insert(:team_membership, team: site.team, user: inviter, role: :owner)
+
assert {:error, :transfer_to_self} =
CreateInvitation.create_invitation(site, inviter, "[email protected]", :owner)
+
+ assert {:error, :transfer_to_self} =
+ Plausible.Teams.Invitations.invite(site, inviter, "[email protected]", :owner)
end
test "allows creating an ownership transfer even when at team member limit" do
@@ -214,17 +260,24 @@ defmodule Plausible.Site.Memberships.CreateInvitationTest do
test "does not allow viewers to invite users" do
inviter = insert(:user)
+ owner = insert(:user)
site =
insert(:site,
memberships: [
- build(:site_membership, user: build(:user), role: :owner),
+ build(:site_membership, user: owner, role: :owner),
build(:site_membership, user: inviter, role: :viewer)
]
)
+ insert(:team_membership, team: site.team, user: owner, role: :owner)
+ insert(:team_membership, team: site.team, user: inviter, role: :viewer)
+
assert {:error, :forbidden} =
CreateInvitation.create_invitation(site, inviter, "[email protected]", :viewer)
+
+ assert {:error, :forbidden} =
+ Plausible.Teams.Invitations.invite(site, inviter, "[email protected]", :viewer)
end
test "allows admins to invite other admins" do
diff --git a/test/plausible/site/sites_test.exs b/test/plausible/site/sites_test.exs
index df812b1c84..36cc24786b 100644
--- a/test/plausible/site/sites_test.exs
+++ b/test/plausible/site/sites_test.exs
@@ -13,6 +13,16 @@ defmodule Plausible.SitesTest do
Sites.create(user, params)
end
+ test "creates a site (TEAM)" do
+ user = insert(:user)
+ {:ok, team} = Plausible.Teams.get_or_create(user)
+
+ params = %{"domain" => "example.com", "timezone" => "Europe/London"}
+
+ assert {:ok, %{site: %{domain: "example.com", timezone: "Europe/London"}}} =
+ Plausible.Teams.Sites.create(team, params)
+ end
+
test "fails on invalid timezone" do
user = insert(:user)
@@ -21,6 +31,16 @@ defmodule Plausible.SitesTest do
assert {:error, :site, %{errors: [timezone: {"is invalid", []}]}, %{}} =
Sites.create(user, params)
end
+
+ test "fails on invalid timezone (TEAM)" do
+ user = insert(:user)
+ {:ok, team} = Plausible.Teams.get_or_create(user)
+
+ params = %{"domain" => "example.com", "timezone" => "blah"}
+
+ assert {:error, :site, %{errors: [timezone: {"is invalid", []}]}, %{}} =
+ Plausible.Teams.Sites.create(team, params)
+ end
end
describe "is_member?" do
@@ -142,6 +162,14 @@ defmodule Plausible.SitesTest do
total_pages: 1
} = Sites.list(user, %{})
+ assert %{
+ entries: [],
+ page_size: 24,
+ page_number: 1,
+ total_entries: 0,
+ total_pages: 1
+ } = Plausible.Teams.Sites.list(user, %{})
+
assert %{
entries: [],
page_size: 24,
@@ -149,82 +177,186 @@ defmodule Plausible.SitesTest do
total_entries: 0,
total_pages: 1
} = Sites.list_with_invitations(user, %{})
+
+ assert %{
+ entries: [],
+ page_size: 24,
+ page_number: 1,
+ total_entries: 0,
+ total_pages: 1
+ } = Plausible.Teams.Sites.list_with_invitations(user, %{})
end
test "pinned site doesn't matter with membership revoked (no active invitations)" do
user1 = insert(:user, email: "[email protected]")
user2 = insert(:user, email: "[email protected]")
- insert(:site, members: [user1], domain: "one.example.com")
+ team1 = insert(:team)
+ insert(:site, team: team1, members: [user1], domain: "one.example.com")
+ insert(:team_membership, team: team1, user: user1, role: :owner)
+
+ team2 = insert(:team)
site2 =
insert(:site,
+ team: team2,
members: [user2],
domain: "two.example.com"
)
+ insert(:team_membership, team: team2, user: user2, role: :owner)
+
membership = insert(:site_membership, user: user1, role: :viewer, site: site2)
+ team_membership = insert(:team_membership, team: team2, user: user1, role: :guest)
+ insert(:guest_membership, team_membership: team_membership, site: site2, role: :viewer)
{:ok, _} = Sites.toggle_pin(user1, site2)
Repo.delete!(membership)
+ Repo.delete!(team_membership)
assert %{entries: [%{domain: "one.example.com"}]} = Sites.list(user1, %{})
assert %{entries: [%{domain: "one.example.com"}]} = Sites.list_with_invitations(user1, %{})
+
+ assert %{entries: [%{domain: "one.example.com"}]} = Plausible.Teams.Sites.list(user1, %{})
+
+ assert %{entries: [%{domain: "one.example.com"}]} =
+ Plausible.Teams.Sites.list_with_invitations(user1, %{})
end
test "pinned site doesn't matter with membership revoked (with active invitation)" do
user1 = insert(:user, email: "[email protected]")
user2 = insert(:user, email: "[email protected]")
- insert(:site, members: [user1], domain: "one.example.com")
+ team1 = insert(:team)
+ insert(:site, team: team1, members: [user1], domain: "one.example.com")
+ insert(:team_membership, team: team1, user: user1, role: :owner)
+
+ team2 = insert(:team)
site2 =
insert(:site,
+ team: team2,
members: [user2],
domain: "two.example.com"
)
+ insert(:team_membership, team: team2, user: user2, role: :owner)
+
membership = insert(:site_membership, user: user1, role: :viewer, site: site2)
+ team_membership = insert(:team_membership, team: team2, user: user1, role: :guest)
+ insert(:guest_membership, team_membership: team_membership, site: site2, role: :viewer)
+
insert(:invitation, email: user1.email, inviter: user2, role: :owner, site: site2)
+ team_invitation =
+ insert(:team_invitation, team: team2, email: user1.email, inviter: user2, role: :guest)
+
+ insert(:guest_invitation, team_invitation: team_invitation, site: site2, role: :editor)
+
{:ok, _} = Sites.toggle_pin(user1, site2)
Repo.delete!(membership)
+ Repo.delete!(team_membership)
assert %{entries: [%{domain: "one.example.com"}]} = Sites.list(user1, %{})
assert %{entries: [%{domain: "two.example.com"}, %{domain: "one.example.com"}]} =
Sites.list_with_invitations(user1, %{})
+
+ assert %{entries: [%{domain: "one.example.com"}]} = Plausible.Teams.Sites.list(user1, %{})
+
+ assert %{entries: [%{domain: "two.example.com"}, %{domain: "one.example.com"}]} =
+ Plausible.Teams.Sites.list_with_invitations(user1, %{})
end
test "puts invitations first, pinned sites second, sites last" do
user = insert(:user, email: "[email protected]")
- site1 = %{id: site_id1} = insert(:site, members: [user], domain: "one.example.com")
- site2 = %{id: site_id2} = insert(:site, members: [user], domain: "two.example.com")
- %{id: site_id4} = insert(:site, members: [user], domain: "four.example.com")
+ team1 = insert(:team)
- _rogue_site = insert(:site, domain: "rogue.example.com")
+ site1 =
+ %{id: site_id1} = insert(:site, team: team1, members: [user], domain: "one.example.com")
- insert(:invitation, email: user.email, inviter: build(:user), role: :owner, site: site1)
+ insert(:team_membership, team: team1, user: user, role: :owner)
+ team2 = insert(:team)
- %{id: site_id3} =
- insert(:site,
- domain: "three.example.com",
- invitations: [
- build(:invitation, email: user.email, inviter: build(:user), role: :viewer)
- ]
+ site2 =
+ %{id: site_id2} = insert(:site, team: team2, members: [user], domain: "two.example.com")
+
+ insert(:team_membership, team: team2, user: build(:user), role: :owner)
+ team_membership2 = insert(:team_membership, team: team2, user: user, role: :guest)
+ insert(:guest_membership, team_membership: team_membership2, site: site2, role: :editor)
+
+ team4 = insert(:team)
+
+ site4 =
+ %{id: site_id4} = insert(:site, team: team4, members: [user], domain: "four.example.com")
+
+ insert(:team_membership, team: team4, user: build(:user), role: :owner)
+ team_membership4 = insert(:team_membership, team: team4, user: user, role: :guest)
+ insert(:guest_membership, team_membership: team_membership4, site: site4, role: :viewer)
+
+ _rogue_site = insert(:site, team: build(:team), domain: "rogue.example.com")
+
+ ## Having owner invite on owned site does not make much sense?
+ ## Maybe that was a repro of real-life example?
+ # insert(:invitation, email: user.email, inviter: build(:user), role: :owner, site: site1)
+
+ # team_invitation1 =
+ # insert(:team_invitation,
+ # team: team1,
+ # email: user.email,
+ # inviter: build(:user),
+ # role: :guest
+ # )
+
+ # insert(:guest_invitation, team_invitation: team_invitation1, site: site1, role: :editor)
+
+ team3 = insert(:team)
+
+ site3 = %{id: site_id3} = insert(:site, team: team3, domain: "three.example.com")
+
+ insert(:invitation, email: user.email, inviter: build(:user), role: :viewer, site: site3)
+
+ team_invitation2 =
+ insert(:team_invitation,
+ team: team3,
+ email: user.email,
+ inviter: build(:user),
+ role: :guest
)
+ insert(:guest_invitation, team_invitation: team_invitation2, site: site3, role: :viewer)
+
insert(:invitation, email: "[email protected]", inviter: user, role: :viewer, site: site1)
+ team_invitation3 =
+ insert(:team_invitation,
+ team: team1,
+ email: "[email protected]",
+ inviter: user,
+ role: :guest
+ )
+
+ insert(:guest_invitation, team_invitation: team_invitation3, site: site1, role: :viewer)
+
insert(:invitation,
site: site1,
inviter: user,
)
+ team_invitation4 =
+ insert(:team_invitation,
+ team: team1,
+ email: "[email protected]",
+ inviter: user,
+ role: :guest
+ )
+
+ insert(:guest_invitation, team_invitation: team_invitation4, site: site1, role: :editor)
+
{:ok, _} = Sites.toggle_pin(user, site2)
assert %{
@@ -237,12 +369,29 @@ defmodule Plausible.SitesTest do
assert %{
entries: [
- %{id: ^site_id1, entry_type: "invitation"},
%{id: ^site_id3, entry_type: "invitation"},
%{id: ^site_id2, entry_type: "pinned_site"},
- %{id: ^site_id4, entry_type: "site"}
+ %{id: ^site_id4, entry_type: "site"},
+ %{id: ^site_id1, entry_type: "site"}
]
} = Sites.list_with_invitations(user, %{})
+
+ assert %{
+ entries: [
+ %{id: ^site_id2, entry_type: "pinned_site"},
+ %{id: ^site_id4, entry_type: "site"},
+ %{id: ^site_id1, entry_type: "site"}
+ ]
+ } = Plausible.Teams.Sites.list(user, %{})
+
+ assert %{
+ entries: [
+ %{id: ^site_id3, entry_type: "invitation"},
+ %{id: ^site_id2, entry_type: "pinned_site"},
+ %{id: ^site_id4, entry_type: "site"},
+ %{id: ^site_id1, entry_type: "site"}
+ ]
+ } = Plausible.Teams.Sites.list_with_invitations(user, %{})
end
test "pinned sites are ordered according to the time they were pinned at" do
diff --git a/test/support/factory.ex b/test/support/factory.ex
index 1be7055a27..c6c6b6843e 100644
--- a/test/support/factory.ex
+++ b/test/support/factory.ex
@@ -3,6 +3,41 @@ defmodule Plausible.Factory do
require Plausible.Billing.Subscription.Status
alias Plausible.Billing.Subscription
+ def team_factory do
+ %Plausible.Teams.Team{
+ name: "My Team",
+ trial_expiry_date: Timex.today() |> Timex.shift(days: 30)
+ }
+ end
+
+ def team_membership_factory do
+ %Plausible.Teams.Membership{
+ user: build(:user),
+ role: :viewer
+ }
+ end
+
+ def guest_membership_factory do
+ %Plausible.Teams.GuestMembership{
+ team_membership: build(:team_membership, role: :guest)
+ }
+ end
+
+ def team_invitation_factory do
+ %Plausible.Teams.Invitation{
+ invitation_id: Nanoid.generate(),
+ email: sequence(:email, &"email-#{&1}@example.com"),
+ role: :admin
+ }
+ end
+
+ def guest_invitation_factory do
+ %Plausible.Teams.GuestInvitation{
+ role: :editor,
+ team_invitation: build(:team_invitation, role: :guest)
+ }
+ end
+
def user_factory(attrs) do
pw = Map.get(attrs, :password, "password")
@@ -43,6 +78,7 @@ defmodule Plausible.Factory do
attrs = if defined_memberships?, do: attrs, else: Map.put_new(attrs, :members, [build(:user)])
site = %Plausible.Site{
+ team: build(:team),
native_stats_start_at: ~N[2000-01-01 00:00:00],
domain: domain,
timezone: "UTC"
diff --git a/test/workers/check_usage_test.exs b/test/workers/check_usage_test.exs
index ffdf7feb52..7779717a44 100644
--- a/test/workers/check_usage_test.exs
+++ b/test/workers/check_usage_test.exs
@@ -232,10 +232,7 @@ defmodule Plausible.Workers.CheckUsageTest do
end
test "skips checking users who already have a grace period", %{user: user} do
- %{grace_period: existing_grace_period} =
- user
- |> Plausible.Auth.GracePeriod.start_changeset()
- |> Repo.update!()
+ %{grace_period: existing_grace_period} = Plausible.Users.start_grace_period(user)
usage_stub =
Plausible.Billing.Quota.Usage
@@ -326,9 +323,7 @@ defmodule Plausible.Workers.CheckUsageTest do
describe "#{status} subscription, enterprise customers" do
test "skips checking enterprise users who already have a grace period", %{user: user} do
%{grace_period: existing_grace_period} =
- user
- |> Plausible.Auth.GracePeriod.start_manual_lock_changeset()
- |> Repo.update!()
+ Plausible.Users.start_manual_lock_grace_period(user)
usage_stub =
Plausible.Billing.Quota.Usage