Skip to content

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

Fix and refactor invitation logic (#3376)

Adrian Gruntkowskie67850c11dc4
diff --git a/lib/plausible/billing/billing.ex b/lib/plausible/billing/billing.ex
index 5581c088ec..932f55adb9 100644
--- a/lib/plausible/billing/billing.ex
+++ b/lib/plausible/billing/billing.ex
@@ -73,17 +73,22 @@ defmodule Plausible.Billing do
end
end
- def needs_to_upgrade?(%Plausible.Auth.User{trial_expiry_date: nil}), do: {true, :no_trial}
+ @spec check_needs_to_upgrade(Plausible.Auth.User.t()) ::
+ {:needs_to_upgrade, :no_trial | :no_active_subscription | :grace_period_ended}
+ | :no_upgrade_needed
+ def check_needs_to_upgrade(%Plausible.Auth.User{trial_expiry_date: nil}) do
+ {:needs_to_upgrade, :no_trial}
+ end
- def needs_to_upgrade?(user) do
+ def check_needs_to_upgrade(user) do
user = Plausible.Users.with_subscription(user)
trial_is_over = Timex.before?(user.trial_expiry_date, Timex.today())
subscription_active = subscription_is_active?(user.subscription)
cond do
- trial_is_over && !subscription_active -> {true, :no_active_subscription}
- Plausible.Auth.GracePeriod.expired?(user) -> {true, :grace_period_ended}
- true -> false
+ trial_is_over && !subscription_active -> {:needs_to_upgrade, :no_active_subscription}
+ Plausible.Auth.GracePeriod.expired?(user) -> {:needs_to_upgrade, :grace_period_ended}
+ true -> :no_upgrade_needed
end
end
@@ -260,34 +265,14 @@ defmodule Plausible.Billing do
end
end
- defp check_lock_status(user) do
- Plausible.Billing.SiteLocker.check_sites_for(user)
- user
- end
-
- defp maybe_adjust_api_key_limits(user) do
- plan =
- Repo.get_by(Plausible.Billing.EnterprisePlan,
- user_id: user.id,
- paddle_plan_id: user.subscription.paddle_plan_id
- )
-
- if plan do
- user_id = user.id
- api_keys = from(key in Plausible.Auth.ApiKey, where: key.user_id == ^user_id)
- Repo.update_all(api_keys, set: [hourly_request_limit: plan.hourly_api_request_limit])
- end
-
- user
- end
-
def paddle_api(), do: Application.fetch_env!(:plausible, :paddle_api)
defp active_subscription_query(user_id) do
- from s in Subscription,
+ from(s in Subscription,
where: s.user_id == ^user_id and s.status == "active",
order_by: [desc: s.inserted_at],
limit: 1
+ )
end
defp after_subscription_update(subscription) do
@@ -298,7 +283,23 @@ defmodule Plausible.Billing do
user
|> maybe_remove_grace_period()
- |> check_lock_status()
+ |> tap(&Plausible.Billing.SiteLocker.update_sites_for/1)
|> maybe_adjust_api_key_limits()
end
+
+ defp maybe_adjust_api_key_limits(user) do
+ plan =
+ Repo.get_by(Plausible.Billing.EnterprisePlan,
+ user_id: user.id,
+ paddle_plan_id: user.subscription.paddle_plan_id
+ )
+
+ if plan do
+ user_id = user.id
+ api_keys = from(key in Plausible.Auth.ApiKey, where: key.user_id == ^user_id)
+ Repo.update_all(api_keys, set: [hourly_request_limit: plan.hourly_api_request_limit])
+ end
+
+ user
+ end
end
diff --git a/lib/plausible/billing/site_locker.ex b/lib/plausible/billing/site_locker.ex
index 1cec2e8361..cb4802287c 100644
--- a/lib/plausible/billing/site_locker.ex
+++ b/lib/plausible/billing/site_locker.ex
@@ -1,33 +1,58 @@
defmodule Plausible.Billing.SiteLocker do
use Plausible.Repo
- def check_sites_for(user) do
+ @type update_opt() :: {:send_email?, boolean()}
+
+ @type lock_reason() ::
+ :grace_period_ended_now
+ | :grace_period_ended_already
+ | :no_trial
+ | :no_active_subscription
+
+ @spec update_sites_for(Plausible.Auth.User.t(), [update_opt()]) ::
+ {:locked, lock_reason()} | :unlocked
+ def update_sites_for(user, opts \\ []) do
+ send_email? = Keyword.get(opts, :send_email?, true)
+
user = Plausible.Users.with_subscription(user)
- case Plausible.Billing.needs_to_upgrade?(user) do
- {true, :grace_period_ended} ->
+ case Plausible.Billing.check_needs_to_upgrade(user) do
+ {:needs_to_upgrade, :grace_period_ended} ->
set_lock_status_for(user, true)
- if !user.grace_period.is_over do
- send_grace_period_end_email(user)
- Plausible.Auth.GracePeriod.end_changeset(user) |> Repo.update()
+ if user.grace_period.is_over != true do
+ user
+ |> Plausible.Auth.GracePeriod.end_changeset()
+ |> Repo.update!()
+
+ if send_email? do
+ send_grace_period_end_email(user)
+ end
+
+ {:locked, :grace_period_ended_now}
+ else
+ {:locked, :grace_period_ended_already}
end
- {true, _} ->
+ {:needs_to_upgrade, reason} ->
set_lock_status_for(user, true)
+ {:locked, reason}
- _ ->
+ :no_upgrade_needed ->
set_lock_status_for(user, false)
+ :unlocked
end
end
+ @spec set_lock_status_for(Plausible.Auth.User.t(), boolean()) :: {:ok, non_neg_integer()}
def set_lock_status_for(user, status) do
site_ids =
Repo.all(
- from s in Plausible.Site.Membership,
+ from(s in Plausible.Site.Membership,
where: s.user_id == ^user.id,
where: s.role == :owner,
select: s.site_id
+ )
)
site_q =
@@ -36,10 +61,14 @@ defmodule Plausible.Billing.SiteLocker do
where: s.id in ^site_ids
)
- Repo.update_all(site_q, set: [locked: status])
+ {num_updated, _} = Repo.update_all(site_q, set: [locked: status])
+
+ {:ok, num_updated}
end
- defp send_grace_period_end_email(user) do
+ @spec send_grace_period_end_email(Plausible.Auth.User.t()) :: Plausible.Mailer.result()
+ def send_grace_period_end_email(user) do
+ user = Repo.preload(user, :subscription)
{_, last_cycle} = Plausible.Billing.last_two_billing_cycles(user)
{_, last_cycle_usage} = Plausible.Billing.last_two_billing_months_usage(user)
suggested_plan = Plausible.Billing.Plans.suggest(user, last_cycle_usage)
diff --git a/lib/plausible/mailer.ex b/lib/plausible/mailer.ex
index c63ab30599..f7c6acb0cf 100644
--- a/lib/plausible/mailer.ex
+++ b/lib/plausible/mailer.ex
@@ -2,7 +2,9 @@ defmodule Plausible.Mailer do
use Bamboo.Mailer, otp_app: :plausible
require Logger
- @spec send(Bamboo.Email.t()) :: :ok | {:error, :hard_bounce} | {:error, :unknown_error}
+ @type result() :: :ok | {:error, :hard_bounce} | {:error, :unknown_error}
+
+ @spec send(Bamboo.Email.t()) :: result()
def send(email) do
case deliver_now(email) do
{:ok, _email} -> :ok
diff --git a/lib/plausible/site/membership.ex b/lib/plausible/site/membership.ex
index 52e7c94e83..6e663faf59 100644
--- a/lib/plausible/site/membership.ex
+++ b/lib/plausible/site/membership.ex
@@ -2,6 +2,8 @@ defmodule Plausible.Site.Membership do
use Ecto.Schema
import Ecto.Changeset
+ @type t() :: %__MODULE__{}
+
schema "site_memberships" do
field :role, Ecto.Enum, values: [:owner, :admin, :viewer]
belongs_to :site, Plausible.Site
@@ -10,9 +12,15 @@ defmodule Plausible.Site.Membership do
timestamps()
end
- def changeset(schema, attrs) do
- schema
- |> cast(attrs, [:user_id, :site_id, :role])
- |> validate_required([:user_id, :site_id])
+ def new(site, user) do
+ %__MODULE__{}
+ |> change()
+ |> put_assoc(:site, site)
+ |> put_assoc(:user, user)
+ end
+
+ def set_role(changeset, role) do
+ changeset
+ |> cast(%{role: role}, [:role])
end
end
diff --git a/lib/plausible/site/memberships.ex b/lib/plausible/site/memberships.ex
new file mode 100644
index 0000000000..71dc272d16
--- /dev/null
+++ b/lib/plausible/site/memberships.ex
@@ -0,0 +1,11 @@
+defmodule Plausible.Site.Memberships do
+ @moduledoc """
+ API for site memberships and invitations
+ """
+
+ alias Plausible.Site.Memberships
+
+ defdelegate accept_invitation(invitation_id, user), to: Memberships.AcceptInvitation
+ defdelegate reject_invitation(invitation_id, user), to: Memberships.RejectInvitation
+ defdelegate remove_invitation(invitation_id, site), to: Memberships.RemoveInvitation
+end
diff --git a/lib/plausible/site/memberships/accept_invitation.ex b/lib/plausible/site/memberships/accept_invitation.ex
new file mode 100644
index 0000000000..95043cd8f1
--- /dev/null
+++ b/lib/plausible/site/memberships/accept_invitation.ex
@@ -0,0 +1,163 @@
+defmodule Plausible.Site.Memberships.AcceptInvitation do
+ @moduledoc """
+ Service for accepting invitations, including ownership transfers.
+
+ Accepting invitation accounts for the fact that it's possible
+ that accepting user has an existing membership for the site and
+ acts permissively to not unnecessarily disrupt the flow while
+ also maintaining integrity of site memberships. This also applies
+ to cases where users update their email address between issuing
+ the invitation and accepting it.
+ """
+
+ import Ecto.Query, only: [from: 2]
+
+ alias Ecto.Multi
+ alias Plausible.Auth
+ alias Plausible.Billing
+ alias Plausible.Memberships.Invitations
+ alias Plausible.Repo
+ alias Plausible.Site
+ alias Plausible.Site.Memberships.Invitations
+
+ require Logger
+
+ @spec accept_invitation(String.t(), Auth.User.t(), Keyword.t()) ::
+ {:ok, Site.Membership.t()} | {:error, :invitation_not_found | Ecto.Changeset.t()}
+ def accept_invitation(invitation_id, user, opts \\ []) do
+ selfhost? = Keyword.get(opts, :selfhost?, Plausible.Release.selfhost?())
+
+ with {:ok, invitation} <- Invitations.find_for_user(invitation_id, user) do
+ membership = get_or_create_membership(invitation, user)
+
+ multi =
+ if invitation.role == :owner do
+ add_and_transfer_ownership(invitation, membership, user, selfhost?)
+ else
+ add(invitation, membership, user)
+ end
+
+ case Repo.transaction(multi) do
+ {:ok, changes} ->
+ if changes[:site_locker] == {:locked, :grace_period_ended_now} do
+ Billing.SiteLocker.send_grace_period_end_email(changes.user)
+ end
+
+ notify_invitation_accepted(invitation)
+
+ membership = Repo.preload(changes.membership, [:site, :user])
+
+ {:ok, membership}
+
+ {:error, _operation, error, _changes} ->
+ {:error, error}
+ end
+ end
+ end
+
+ defp add_and_transfer_ownership(invitation, membership, user, selfhost?) do
+ multi =
+ Multi.new()
+ |> downgrade_previous_owner(invitation.site, user)
+ |> maybe_end_trial_of_new_owner(user, selfhost?)
+ |> Multi.insert_or_update(:membership, membership)
+ |> Multi.delete(:invitation, invitation)
+
+ if selfhost? do
+ multi
+ else
+ Multi.run(multi, :site_locker, fn _, %{user: updated_user} ->
+ {:ok, Billing.SiteLocker.update_sites_for(updated_user, send_email?: false)}
+ end)
+ end
+ end
+
+ # If there's an existing membership, we DO NOT change the role
+ # to avoid accidental role downgrade.
+ defp add(invitation, membership, _user) do
+ if membership.data.id do
+ Multi.new()
+ |> Multi.put(:membership, membership.data)
+ |> Multi.delete(:invitation, invitation)
+ else
+ Multi.new()
+ |> Multi.insert(:membership, membership)
+ |> Multi.delete(:invitation, invitation)
+ end
+ end
+
+ defp get_or_create_membership(invitation, user) do
+ case Repo.get_by(Site.Membership, user_id: user.id, site_id: invitation.site.id) do
+ nil -> Site.Membership.new(invitation.site, user)
+ membership -> membership
+ end
+ |> Site.Membership.set_role(invitation.role)
+ end
+
+ # If the new owner is the same as old owner, we do not downgrade them
+ # to avoid leaving site without an owner!
+ defp downgrade_previous_owner(multi, site, new_owner) do
+ new_owner_id = new_owner.id
+
+ previous_owner =
+ Repo.one(
+ from(
+ sm in Site.Membership,
+ where: sm.site_id == ^site.id,
+ where: sm.role == :owner
+ )
+ )
+
+ case previous_owner do
+ %{user_id: ^new_owner_id} ->
+ Multi.put(multi, :previous_owner_membership, previous_owner)
+
+ nil ->
+ Logger.warn(
+ "Transferring ownership from a site with no owner: #{site.domain} " <>
+ ", new owner ID: #{new_owner_id}"
+ )
+
+ Multi.put(multi, :previous_owner_membership, nil)
+
+ previous_owner ->
+ Multi.update(
+ multi,
+ :previous_owner_membership,
+ Site.Membership.set_role(previous_owner, :admin)
+ )
+ end
+ end
+
+ # If the new owner is the same as the old owner, it's a no-op
+ defp maybe_end_trial_of_new_owner(multi, new_owner, selfhost?) do
+ new_owner_id = new_owner.id
+
+ cond do
+ selfhost? ->
+ Multi.put(multi, :user, new_owner)
+
+ Billing.on_trial?(new_owner) or is_nil(new_owner.trial_expiry_date) ->
+ Multi.update(multi, :user, fn
+ %{previous_owner_membership: %{user_id: ^new_owner_id}} ->
+ Ecto.Changeset.change(new_owner)
+
+ _ ->
+ Auth.User.end_trial(new_owner)
+ end)
+
+ true ->
+ Multi.put(multi, :user, new_owner)
+ end
+ end
+
+ defp notify_invitation_accepted(%Auth.Invitation{role: :owner} = invitation) do
+ PlausibleWeb.Email.ownership_transfer_accepted(invitation)
+ |> Plausible.Mailer.send()
+ end
+
+ defp notify_invitation_accepted(invitation) do
+ PlausibleWeb.Email.invitation_accepted(invitation)
+ |> Plausible.Mailer.send()
+ end
+end
diff --git a/lib/plausible/site/memberships/invitations.ex b/lib/plausible/site/memberships/invitations.ex
new file mode 100644
index 0000000000..f51e5beb9e
--- /dev/null
+++ b/lib/plausible/site/memberships/invitations.ex
@@ -0,0 +1,45 @@
+defmodule Plausible.Site.Memberships.Invitations do
+ @moduledoc false
+
+ import Ecto.Query, only: [from: 2]
+
+ alias Plausible.Auth
+ alias Plausible.Repo
+
+ @spec find_for_user(String.t(), Auth.User.t()) ::
+ {:ok, Auth.Invitation.t()} | {:error, :invitation_not_found}
+ def find_for_user(invitation_id, user) do
+ invitation =
+ Auth.Invitation
+ |> Repo.get_by(invitation_id: invitation_id, email: user.email)
+ |> Repo.preload([:site, :inviter])
+
+ if invitation do
+ {:ok, invitation}
+ else
+ {:error, :invitation_not_found}
+ end
+ end
+
+ @spec find_for_site(String.t(), Plausible.Site.t()) ::
+ {:ok, Auth.Invitation.t()} | {:error, :invitation_not_found}
+ def find_for_site(invitation_id, site) do
+ invitation =
+ Auth.Invitation
+ |> Repo.get_by(invitation_id: invitation_id, site_id: site.id)
+ |> Repo.preload([:site, :inviter])
+
+ if invitation do
+ {:ok, invitation}
+ else
+ {:error, :invitation_not_found}
+ end
+ end
+
+ @spec delete_invitation(Auth.Invitation.t()) :: :ok
+ def delete_invitation(invitation) do
+ Repo.delete_all(from(i in Auth.Invitation, where: i.id == ^invitation.id))
+
+ :ok
+ end
+end
diff --git a/lib/plausible/site/memberships/reject_invitation.ex b/lib/plausible/site/memberships/reject_invitation.ex
new file mode 100644
index 0000000000..40b1a1e2b8
--- /dev/null
+++ b/lib/plausible/site/memberships/reject_invitation.ex
@@ -0,0 +1,29 @@
+defmodule Plausible.Site.Memberships.RejectInvitation do
+ @moduledoc """
+ Service for rejecting invitations.
+ """
+
+ alias Plausible.Auth
+ alias Plausible.Site.Memberships.Invitations
+
+ @spec reject_invitation(String.t(), Auth.User.t()) ::
+ {:ok, Auth.Invitation.t()} | {:error, :invitation_not_found}
+ def reject_invitation(invitation_id, user) do
+ with {:ok, invitation} <- Invitations.find_for_user(invitation_id, user) do
+ Invitations.delete_invitation(invitation)
+ notify_invitation_rejected(invitation)
+
+ {:ok, invitation}
+ end
+ end
+
+ defp notify_invitation_rejected(%Auth.Invitation{role: :owner} = invitation) do
+ PlausibleWeb.Email.ownership_transfer_rejected(invitation)
+ |> Plausible.Mailer.send()
+ end
+
+ defp notify_invitation_rejected(invitation) do
+ PlausibleWeb.Email.invitation_rejected(invitation)
+ |> Plausible.Mailer.send()
+ end
+end
diff --git a/lib/plausible/site/memberships/remove_invitation.ex b/lib/plausible/site/memberships/remove_invitation.ex
new file mode 100644
index 0000000000..abb650fe7d
--- /dev/null
+++ b/lib/plausible/site/memberships/remove_invitation.ex
@@ -0,0 +1,18 @@
+defmodule Plausible.Site.Memberships.RemoveInvitation do
+ @moduledoc """
+ Service for removing invitations.
+ """
+
+ alias Plausible.Auth
+ alias Plausible.Site.Memberships.Invitations
+
+ @spec remove_invitation(String.t(), Plausible.Site.t()) ::
+ {:ok, Auth.Invitation.t()} | {:error, :invitation_not_found}
+ def remove_invitation(invitation_id, site) do
+ with {:ok, invitation} <- Invitations.find_for_site(invitation_id, site) do
+ Invitations.delete_invitation(invitation)
+
+ {:ok, invitation}
+ end
+ end
+end
diff --git a/lib/plausible/sites.ex b/lib/plausible/sites.ex
index 1823df2bad..ee10cca768 100644
--- a/lib/plausible/sites.ex
+++ b/lib/plausible/sites.ex
@@ -6,6 +6,7 @@ defmodule Plausible.Sites do
@type invite_error() ::
Ecto.Changeset.t()
| :already_a_member
+ | :transfer_to_self
| {:over_limit, non_neg_integer()}
| :forbidden
@@ -28,14 +29,8 @@ defmodule Plausible.Sites do
if Quota.within_limit?(usage, limit), do: {:ok, usage}, else: {:error, limit}
end)
|> Ecto.Multi.insert(:site, site_changeset)
- |> Ecto.Multi.run(:site_membership, fn repo, %{site: site} ->
- membership_changeset =
- Site.Membership.changeset(%Site.Membership{}, %{
- site_id: site.id,
- user_id: user.id
- })
-
- repo.insert(membership_changeset)
+ |> Ecto.Multi.insert(:site_membership, fn %{site: site} ->
+ Site.Membership.new(site, user)
end)
|> maybe_start_trial(user)
|> Repo.transaction()
@@ -91,6 +86,7 @@ defmodule Plausible.Sites do
with :ok <- check_invitation_permissions(site, inviter, role, opts),
:ok <- check_team_member_limit(site, role),
invitee <- Plausible.Auth.find_user_by(email: invitee_email),
+ :ok <- ensure_transfer_valid(site, invitee, role),
:ok <- ensure_new_membership(site, invitee, role),
%Ecto.Changeset{} = changeset <- Plausible.Auth.Invitation.new(attrs),
{:ok, invitation} <- Repo.insert(changeset) do
@@ -131,6 +127,18 @@ defmodule Plausible.Sites do
Plausible.Mailer.send(email)
end
+ defp ensure_transfer_valid(site, invitee, :owner) do
+ if invitee && role(invitee.id, site) == :owner do
+ {:error, :transfer_to_self}
+ else
+ :ok
+ end
+ end
+
+ defp ensure_transfer_valid(_site, _invitee, _role) do
+ :ok
+ end
+
defp ensure_new_membership(_site, _invitee, :owner) do
:ok
end
diff --git a/lib/plausible_web/controllers/invitation_controller.ex b/lib/plausible_web/controllers/invitation_controller.ex
index 26435f0ffe..b8a1934a96 100644
--- a/lib/plausible_web/controllers/invitation_controller.ex
+++ b/lib/plausible_web/controllers/invitation_controller.ex
@@ -1,136 +1,54 @@
defmodule PlausibleWeb.InvitationController do
use PlausibleWeb, :controller
- use Plausible.Repo
- alias Ecto.Multi
- alias Plausible.Auth.Invitation
- alias Plausible.Site.Membership
plug PlausibleWeb.RequireAccountPlug
- @require_owner [:remove_invitation]
-
- plug PlausibleWeb.AuthorizeSiteAccess,
- [:owner, :admin] when action in @require_owner
+ plug PlausibleWeb.AuthorizeSiteAccess, [:owner, :admin] when action in [:remove_invitation]
def accept_invitation(conn, %{"invitation_id" => invitation_id}) do
- invitation =
- Repo.get_by(Invitation, invitation_id: invitation_id)
- |> Repo.preload([:site, :inviter])
-
- if invitation do
- user = conn.assigns[:current_user]
- existing_membership = Repo.get_by(Membership, user_id: user.id, site_id: invitation.site.id)
-
- multi =
- if invitation.role == :owner do
- Multi.new()
- |> downgrade_previous_owner(invitation.site)
- |> maybe_end_trial_of_new_owner(user)
- else
- Multi.new()
- end
-
- membership_changeset =
- (existing_membership ||
- %Membership{user_id: user.id, site_id: invitation.site.id})
- |> Membership.changeset(%{role: invitation.role})
-
- multi =
- multi
- |> Multi.insert_or_update(:membership, membership_changeset)
- |> Multi.delete(:invitation, invitation)
-
- case Repo.transaction(multi) do
- {:ok, changes} ->
- updated_user = Map.get(changes, :user, user)
- notify_invitation_accepted(invitation)
- Plausible.Billing.SiteLocker.check_sites_for(updated_user)
-
- conn
- |> put_flash(:success, "You now have access to #{invitation.site.domain}")
- |> redirect(to: "/#{URI.encode_www_form(invitation.site.domain)}")
-
- {:error, _operation, _value, _changes} ->
- conn
- |> put_flash(:error, "Something went wrong, please try again")
- |> redirect(to: "/sites")
- end
- else
- conn
- |> put_flash(:error, "Invitation missing or already accepted")
- |> redirect(to: "/sites")
- end
- end
-
- defp downgrade_previous_owner(multi, site) do
- prev_owner =
- from(
- sm in Plausible.Site.Membership,
- where: sm.site_id == ^site.id,
- where: sm.role == :owner
- )
-
- Multi.update_all(multi, :prev_owner, prev_owner, set: [role: :admin])
- end
-
- defp maybe_end_trial_of_new_owner(multi, new_owner) do
- if Application.get_env(:plausible, :is_selfhost) do
- multi
- else
- end_trial_of_new_owner(multi, new_owner)
- end
- end
-
- defp end_trial_of_new_owner(multi, new_owner) do
- if Plausible.Billing.on_trial?(new_owner) || is_nil(new_owner.trial_expiry_date) do
- Ecto.Multi.update(multi, :user, Plausible.Auth.User.end_trial(new_owner))
- else
- multi
+ case Plausible.Site.Memberships.accept_invitation(invitation_id, conn.assigns.current_user) do
+ {:ok, membership} ->
+ conn
+ |> put_flash(:success, "You now have access to #{membership.site.domain}")
+ |> redirect(to: "/#{URI.encode_www_form(membership.site.domain)}")
+
+ {:error, :invitation_not_found} ->
+ conn
+ |> put_flash(:error, "Invitation missing or already accepted")
+ |> redirect(to: "/sites")
+
+ {:error, _} ->
+ conn
+ |> put_flash(:error, "Something went wrong, please try again")
+ |> redirect(to: "/sites")
end
end
def reject_invitation(conn, %{"invitation_id" => invitation_id}) do
- invitation =
- Repo.get_by!(Invitation, invitation_id: invitation_id)
- |> Repo.preload([:site, :inviter])
-
- Repo.delete!(invitation)
- notify_invitation_rejected(invitation)
-
- conn
- |> put_flash(:success, "You have rejected the invitation to #{invitation.site.domain}")
- |> redirect(to: "/sites")
- end
-
- defp notify_invitation_accepted(%Invitation{role: :owner} = invitation) do
- PlausibleWeb.Email.ownership_transfer_accepted(invitation)
- |> Plausible.Mailer.send()
- end
-
- defp notify_invitation_accepted(invitation) do
- PlausibleWeb.Email.invitation_accepted(invitation)
- |> Plausible.Mailer.send()
- end
-
- defp notify_invitation_rejected(%Invitation{role: :owner} = invitation) do
- PlausibleWeb.Email.ownership_transfer_rejected(invitation)
- |> Plausible.Mailer.send()
- end
-
- defp notify_invitation_rejected(invitation) do
- PlausibleWeb.Email.invitation_rejected(invitation)
- |> Plausible.Mailer.send()
+ case Plausible.Site.Memberships.reject_invitation(invitation_id, conn.assigns.current_user) do
+ {:ok, invitation} ->
+ conn
+ |> put_flash(:success, "You have rejected the invitation to #{invitation.site.domain}")
+ |> redirect(to: "/sites")
+
+ {:error, :invitation_not_found} ->
+ conn
+ |> put_flash(:error, "Invitation missing or already accepted")
+ |> redirect(to: "/sites")
+ end
end
def remove_invitation(conn, %{"invitation_id" => invitation_id}) do
- invitation =
- Repo.get_by!(Invitation, invitation_id: invitation_id, site_id: conn.assigns[:site].id)
- |> Repo.preload(:site)
-
- Repo.delete!(invitation)
-
- conn
- |> put_flash(:success, "You have removed the invitation for #{invitation.email}")
- |> redirect(to: Routes.site_path(conn, :settings_people, invitation.site.domain))
+ case Plausible.Site.Memberships.remove_invitation(invitation_id, conn.assigns.site) do
+ {:ok, invitation} ->
+ conn
+ |> put_flash(:success, "You have removed the invitation for #{invitation.email}")
+ |> redirect(to: Routes.site_path(conn, :settings_people, invitation.site.domain))
+
+ {:error, :invitation_not_found} ->
+ conn
+ |> put_flash(:error, "Invitation missing or already removed")
+ |> redirect(to: Routes.site_path(conn, :settings_people, conn.assigns.site.domain))
+ end
end
end
diff --git a/lib/plausible_web/controllers/site/membership_controller.ex b/lib/plausible_web/controllers/site/membership_controller.ex
index b907859421..c6004cbf1b 100644
--- a/lib/plausible_web/controllers/site/membership_controller.ex
+++ b/lib/plausible_web/controllers/site/membership_controller.ex
@@ -104,6 +104,13 @@ defmodule PlausibleWeb.Site.MembershipController do
|> put_flash(:success, "Site transfer request has been sent to #{email}")
|> redirect(to: Routes.site_path(conn, :settings_people, site.domain))
+ {:error, :transfer_to_self} ->
+ conn
+ |> put_flash(:ttl, :timer.seconds(5))
+ |> put_flash(:error_title, "Transfer error")
+ |> put_flash(:error, "Can't transfer ownership to existing owner")
+ |> redirect(to: Routes.site_path(conn, :settings_people, site.domain))
+
{:error, changeset} ->
errors = Plausible.ChangesetHelpers.traverse_errors(changeset)
@@ -149,7 +156,8 @@ defmodule PlausibleWeb.Site.MembershipController do
if can_grant_role? do
membership =
membership
- |> Membership.changeset(%{role: new_role})
+ |> Ecto.Changeset.change()
+ |> Membership.set_role(new_role)
|> Repo.update!()
redirect_target =
diff --git a/lib/plausible_web/controllers/site_controller.ex b/lib/plausible_web/controllers/site_controller.ex
index ac994ab0c0..db6c18a037 100644
--- a/lib/plausible_web/controllers/site_controller.ex
+++ b/lib/plausible_web/controllers/site_controller.ex
@@ -45,7 +45,7 @@ defmodule PlausibleWeb.SiteController do
sites: sites,
visitors: visitors,
pagination: pagination,
- needs_to_upgrade: user_owns_sites && Plausible.Billing.needs_to_upgrade?(user)
+ needs_to_upgrade: user_owns_sites && Plausible.Billing.check_needs_to_upgrade(user)
)
end
diff --git a/lib/plausible_web/templates/site/index.html.eex b/lib/plausible_web/templates/site/index.html.eex
index b1c4ac81b4..4d50c10c66 100644
--- a/lib/plausible_web/templates/site/index.html.eex
+++ b/lib/plausible_web/templates/site/index.html.eex
@@ -1,6 +1,6 @@
<div x-data="{selectedInvitation: null, invitationOpen: false, invitations: <%= Enum.map(@invitations, &({&1.invitation_id, &1})) |> Enum.into(%{}) |> Jason.encode! %>}" @keydown.escape.window="invitationOpen = false" class="container pt-6">
- <%= if @needs_to_upgrade == {true, :no_active_subscription} do %>
+ <%= if @needs_to_upgrade == {:needs_to_upgrade, :no_active_subscription} do %>
<div class="rounded-md bg-yellow-100 p-4">
<div class="flex">
<div class="flex-shrink-0">
diff --git a/lib/workers/lock_sites.ex b/lib/workers/lock_sites.ex
index 69356d6cd7..e1007dcb39 100644
--- a/lib/workers/lock_sites.ex
+++ b/lib/workers/lock_sites.ex
@@ -8,7 +8,7 @@ defmodule Plausible.Workers.LockSites do
users = Repo.all(from u in Plausible.Auth.User, preload: [subscription: ^subscription_q])
for user <- users do
- Plausible.Billing.SiteLocker.check_sites_for(user)
+ Plausible.Billing.SiteLocker.update_sites_for(user)
end
:ok
diff --git a/test/plausible/billing/billing_test.exs b/test/plausible/billing/billing_test.exs
index e924c7506a..d49b4997df 100644
--- a/test/plausible/billing/billing_test.exs
+++ b/test/plausible/billing/billing_test.exs
@@ -125,30 +125,36 @@ defmodule Plausible.BillingTest do
end
end
- describe "needs_to_upgrade?" do
+ describe "check_needs_to_upgrade" do
test "is false for a trial user" do
user = insert(:user)
- refute Billing.needs_to_upgrade?(user)
+ assert Billing.check_needs_to_upgrade(user) == :no_upgrade_needed
end
test "is true for a user with an expired trial" do
user = insert(:user, trial_expiry_date: Timex.shift(Timex.today(), days: -1))
- assert Billing.needs_to_upgrade?(user)
+ assert Billing.check_needs_to_upgrade(user) == {:needs_to_upgrade, :no_active_subscription}
+ end
+
+ test "is true for a user with empty trial expiry date" do
+ user = insert(:user, trial_expiry_date: nil)
+
+ assert Billing.check_needs_to_upgrade(user) == {:needs_to_upgrade, :no_trial}
end
test "is false for a user with an expired trial but an active subscription" do
user = insert(:user, trial_expiry_date: Timex.shift(Timex.today(), days: -1))
insert(:subscription, user: user)
- refute Billing.needs_to_upgrade?(user)
+ assert Billing.check_needs_to_upgrade(user) == :no_upgrade_needed
end
test "is false for a user with a cancelled subscription IF the billing cycle isn't completed yet" do
user = insert(:user, trial_expiry_date: Timex.shift(Timex.today(), days: -1))
insert(:subscription, user: user, status: "deleted", next_bill_date: Timex.today())
- refute Billing.needs_to_upgrade?(user)
+ assert Billing.check_needs_to_upgrade(user) == :no_upgrade_needed
end
test "is true for a user with a cancelled subscription IF the billing cycle is complete" do
@@ -160,14 +166,23 @@ defmodule Plausible.BillingTest do
next_bill_date: Timex.shift(Timex.today(), days: -1)
)
- assert Billing.needs_to_upgrade?(user)
+ assert Billing.check_needs_to_upgrade(user) == {:needs_to_upgrade, :no_active_subscription}
end
- test "is false for a deleted subscription if not next_bill_date specified" do
+ test "is true for a deleted subscription if no next_bill_date specified" do
user = insert(:user, trial_expiry_date: Timex.shift(Timex.today(), days: -1))
insert(:subscription, user: user, status: "deleted", next_bill_date: nil)
- assert Billing.needs_to_upgrade?(user)
+ assert Billing.check_needs_to_upgrade(user) == {:needs_to_upgrade, :no_active_subscription}
+ end
+
+ test "is true for a user past their grace period" do
+ user = insert(:user, trial_expiry_date: Timex.shift(Timex.today(), days: -1))
+ insert(:subscription, user: user, next_bill_date: Timex.today())
+
+ user = user |> Plausible.Auth.GracePeriod.end_changeset() |> Repo.update!()
+
+ assert Billing.check_needs_to_upgrade(user) == {:needs_to_upgrade, :grace_period_ended}
end
end
diff --git a/test/plausible/billing/site_locker_test.exs b/test/plausible/billing/site_locker_test.exs
index 52b6859f8e..58292fc189 100644
--- a/test/plausible/billing/site_locker_test.exs
+++ b/test/plausible/billing/site_locker_test.exs
@@ -3,13 +3,19 @@ defmodule Plausible.Billing.SiteLockerTest do
use Bamboo.Test, shared: true
alias Plausible.Billing.SiteLocker
- describe "check_sites_for/1" do
+ describe "update_sites_for/1" do
test "does not lock sites if user is on trial" do
user = insert(:user, trial_expiry_date: Timex.today())
- site = insert(:site, locked: true, members: [user])
+ site =
+ insert(:site,
+ locked: true,
+ memberships: [
+ build(:site_membership, user: user, role: :owner)
+ ]
+ )
- SiteLocker.check_sites_for(user)
+ assert SiteLocker.update_sites_for(user) == :unlocked
refute Repo.reload!(site).locked
end
@@ -17,9 +23,16 @@ defmodule Plausible.Billing.SiteLockerTest do
test "does not lock if user has an active subscription" do
user = insert(:user)
insert(:subscription, status: "active", user: user)
- site = insert(:site, locked: true, members: [user])
- SiteLocker.check_sites_for(user)
+ site =
+ insert(:site,
+ locked: true,
+ memberships: [
+ build(:site_membership, user: user, role: :owner)
+ ]
+ )
+
+ assert SiteLocker.update_sites_for(user) == :unlocked
refute Repo.reload!(site).locked
end
@@ -27,9 +40,15 @@ defmodule Plausible.Billing.SiteLockerTest do
test "does not lock user who is past due" do
user = insert(:user)
insert(:subscription, status: "past_due", user: user)
- site = insert(:site, members: [user])
- SiteLocker.check_sites_for(user)
+ site =
+ insert(:site,
+ memberships: [
+ build(:site_membership, user: user, role: :owner)
+ ]
+ )
+
+ assert SiteLocker.update_sites_for(user) == :unlocked
refute Repo.reload!(site).locked
end
@@ -37,9 +56,15 @@ defmodule Plausible.Billing.SiteLockerTest do
test "does not lock user who cancelled subscription but it hasn't expired yet" do
user = insert(:user)
insert(:subscription, status: "deleted", user: user)
- site = insert(:site, members: [user])
- SiteLocker.check_sites_for(user)
+ site =
+ insert(:site,
+ memberships: [
+ build(:site_membership, user: user, role: :owner)
+ ]
+ )
+
+ assert SiteLocker.update_sites_for(user) == :unlocked
refute Repo.reload!(site).locked
end
@@ -54,15 +79,21 @@ defmodule Plausible.Billing.SiteLockerTest do
)
insert(:subscription, status: "active", user: user)
- site = insert(:site, members: [user])
- SiteLocker.check_sites_for(user)
+ site =
+ insert(:site,
+ memberships: [
+ build(:site_membership, user: user, role: :owner)
+ ]
+ )
+
+ assert SiteLocker.update_sites_for(user) == :unlocked
refute Repo.reload!(site).locked
end
test "locks user who cancelled subscription and the cancelled subscription has expired" do
- user = insert(:user)
+ user = insert(:user, trial_expiry_date: Timex.shift(Timex.today(), days: -1))
insert(:subscription,
status: "deleted",
@@ -70,11 +101,16 @@ defmodule Plausible.Billing.SiteLockerTest do
user: user
)
- site = insert(:site, members: [user])
+ site =
+ insert(:site,
+ memberships: [
+ build(:site_membership, user: user, role: :owner)
+ ]
+ )
- SiteLocker.check_sites_for(user)
+ assert SiteLocker.update_sites_for(user) == {:locked, :no_active_subscription}
- refute Repo.reload!(site).locked
+ assert Repo.reload!(site).locked
end
test "locks all sites if user has active subscription but grace period has ended" do
@@ -87,9 +123,15 @@ defmodule Plausible.Billing.SiteLockerTest do
)
insert(:subscription, status: "active", user: user)
- site = insert(:site, members: [user])
- SiteLocker.check_sites_for(user)
+ site =
+ insert(:site,
+ memberships: [
+ build(:site_membership, user: user, role: :owner)
+ ]
+ )
+
+ assert SiteLocker.update_sites_for(user) == {:locked, :grace_period_ended_now}
assert Repo.reload!(site).locked
end
@@ -104,9 +146,14 @@ defmodule Plausible.Billing.SiteLockerTest do
)
insert(:subscription, status: "active", user: user)
- insert(:site, members: [user])
- SiteLocker.check_sites_for(user)
+ insert(:site,
+ memberships: [
+ build(:site_membership, user: user, role: :owner)
+ ]
+ )
+
+ assert SiteLocker.update_sites_for(user) == {:locked, :grace_period_ended_now}
assert_email_delivered_with(
to: [user],
@@ -125,9 +172,14 @@ defmodule Plausible.Billing.SiteLockerTest do
)
insert(:subscription, status: "active", user: user)
- insert(:site, members: [user])
- SiteLocker.check_sites_for(user)
+ insert(:site,
+ memberships: [
+ build(:site_membership, user: user, role: :owner)
+ ]
+ )
+
+ assert SiteLocker.update_sites_for(user) == {:locked, :grace_period_ended_now}
assert_email_delivered_with(
to: [user],
@@ -135,7 +187,7 @@ defmodule Plausible.Billing.SiteLockerTest do
)
user = Repo.reload!(user)
- SiteLocker.check_sites_for(user)
+ assert SiteLocker.update_sites_for(user) == {:locked, :grace_period_ended_already}
assert_no_emails_delivered()
end
@@ -143,9 +195,29 @@ defmodule Plausible.Billing.SiteLockerTest do
test "locks all sites if user has no trial or active subscription" do
user = insert(:user, trial_expiry_date: Timex.today() |> Timex.shift(days: -1))
- site = insert(:site, locked: true, members: [user])
+ site =
+ insert(:site,
+ memberships: [
+ build(:site_membership, user: user, role: :owner)
+ ]
+ )
+
+ assert SiteLocker.update_sites_for(user) == {:locked, :no_active_subscription}
+
+ assert Repo.reload!(site).locked
+ end
+
+ test "locks sites for user with empty trial - shouldn't happen under normal circumstances" do
+ user = insert(:user, trial_expiry_date: nil)
+
+ site =
+ insert(:site,
+ memberships: [
+ build(:site_membership, user: user, role: :owner)
+ ]
+ )
- SiteLocker.check_sites_for(user)
+ assert SiteLocker.update_sites_for(user) == {:locked, :no_trial}
assert Repo.reload!(site).locked
end
@@ -167,7 +239,7 @@ defmodule Plausible.Billing.SiteLockerTest do
]
)
- SiteLocker.check_sites_for(user)
+ assert SiteLocker.update_sites_for(user) == {:locked, :no_active_subscription}
owner_site = Repo.reload!(owner_site)
viewer_site = Repo.reload!(viewer_site)
diff --git a/test/plausible/site/memberships/accept_invitation_test.exs b/test/plausible/site/memberships/accept_invitation_test.exs
new file mode 100644
index 0000000000..b5c38e2ef7
--- /dev/null
+++ b/test/plausible/site/memberships/accept_invitation_test.exs
@@ -0,0 +1,323 @@
+defmodule Plausible.Site.Memberships.AcceptInvitationTest do
+ use Plausible.DataCase, async: true
+ use Bamboo.Test
+
+ alias Plausible.Site.Memberships.AcceptInvitation
+
+ describe "invitations" do
+ test "converts an invitation into a membership" do
+ inviter = insert(:user)
+ invitee = insert(:user)
+ site = insert(:site, members: [inviter])
+
+ invitation =
+ insert(:invitation,
+ site_id: site.id,
+ inviter: inviter,
+ email: invitee.email,
+ role: :admin
+ )
+
+ assert {:ok, membership} =
+ AcceptInvitation.accept_invitation(invitation.invitation_id, invitee)
+
+ assert membership.site_id == site.id
+ assert membership.user_id == invitee.id
+ assert membership.role == :admin
+ refute Repo.reload(invitation)
+
+ assert_email_delivered_with(
+ to: [nil: inviter.email],
+ subject:
+ "[Plausible Analytics] #{invitee.email} accepted your invitation to #{site.domain}"
+ )
+ end
+
+ test "does not degrade role when trying to invite self as an owner" do
+ site = insert(:site)
+ user = insert(:user)
+ membership = insert(:site_membership, user: user, site: site, role: :owner)
+
+ invitation =
+ insert(:invitation,
+ site_id: site.id,
+ inviter: user,
+ email: user.email,
+ role: :admin
+ )
+
+ assert {:ok, invited_membership} =
+ AcceptInvitation.accept_invitation(invitation.invitation_id, user)
+
+ assert invited_membership.id == membership.id
+ membership = Repo.reload!(membership)
+ assert membership.role == :owner
+ assert membership.site_id == site.id
+ assert membership.user_id == user.id
+ refute Repo.reload(invitation)
+ end
+
+ test "handles accepting invitation as already a member gracefully" do
+ inviter = insert(:user)
+ invitee = insert(:user)
+ site = insert(:site, members: [inviter])
+ existing_membership = insert(:site_membership, user: invitee, site: site, role: :admin)
+
+ invitation =
+ insert(:invitation,
+ site_id: site.id,
+ inviter: inviter,
+ email: invitee.email,
+ role: :viewer
+ )
+
+ assert {:ok, new_membership} =
+ AcceptInvitation.accept_invitation(invitation.invitation_id, invitee)
+
+ assert existing_membership.id == new_membership.id
+ assert existing_membership.user_id == new_membership.user_id
+ assert existing_membership.site_id == new_membership.site_id
+ assert existing_membership.role == new_membership.role
+ assert new_membership.role == :admin
+ refute Repo.reload(invitation)
+ end
+
+ test "returns an error on non-existent invitation" do
+ invitee = insert(:user)
+
+ assert {:error, :invitation_not_found} =
+ AcceptInvitation.accept_invitation("does_not_exist", invitee)
+ end
+ end
+
+ describe "ownership transfers" do
+ for {label, opts} <- [{"cloud", []}, {"selfhosted", [selfhost?: true]}] do
+ test "converts an ownership transfer into a membership on #{label} instance" do
+ site = insert(:site)
+ existing_owner = insert(:user)
+
+ existing_membership =
+ insert(:site_membership, user: existing_owner, site: site, role: :owner)
+
+ new_owner = insert(:user)
+
+ invitation =
+ insert(:invitation,
+ site_id: site.id,
+ inviter: existing_owner,
+ email: new_owner.email,
+ role: :owner
+ )
+
+ assert {:ok, new_membership} =
+ AcceptInvitation.accept_invitation(
+ invitation.invitation_id,
+ new_owner,
+ unquote(opts)
+ )
+
+ assert new_membership.site_id == site.id
+ assert new_membership.user_id == new_owner.id
+ assert new_membership.role == :owner
+ refute Repo.reload(invitation)
+
+ existing_membership = Repo.reload!(existing_membership)
+ assert existing_membership.user_id == existing_owner.id
+ assert existing_membership.site_id == site.id
+ assert existing_membership.role == :admin
+
+ assert_email_delivered_with(
+ to: [nil: existing_owner.email],
+ subject:
+ "[Plausible Analytics] #{new_owner.email} accepted the ownership transfer of #{site.domain}"
+ )
+ end
+ end
+
+ for role <- [:viewer, :admin] do
+ test "upgrades existing #{role} membership into an owner" do
+ site = insert(:site)
+ owner = insert(:user)
+ owner_membership = insert(:site_membership, user: owner, site: site, role: :owner)
+ new_owner = insert(:user)
+
+ new_owner_membership =
+ insert(:site_membership, user: new_owner, site: site, role: unquote(role))
+
+ invitation =
+ insert(:invitation,
+ site_id: site.id,
+ inviter: owner,
+ email: new_owner.email,
+ role: :owner
+ )
+
+ assert {:ok, membership} =
+ AcceptInvitation.accept_invitation(invitation.invitation_id, new_owner)
+
+ assert membership.id == new_owner_membership.id
+ assert membership.role == :owner
+
+ assert Repo.reload!(owner_membership).role == :admin
+ refute Repo.reload(invitation)
+ end
+ end
+
+ test "does note degrade or alter trial when accepting ownership transfer by self" do
+ site = insert(:site)
+ owner = insert(:user, trial_expiry_date: nil)
+ owner_membership = insert(:site_membership, user: owner, site: site, role: :owner)
+
+ invitation =
+ insert(:invitation,
+ site_id: site.id,
+ inviter: owner,
+ email: owner.email,
+ role: :owner
+ )
+
+ assert {:ok, membership} =
+ AcceptInvitation.accept_invitation(invitation.invitation_id, owner)
+
+ assert membership.id == owner_membership.id
+ assert membership.role == :owner
+ assert Repo.reload!(owner).trial_expiry_date == nil
+
+ refute Repo.reload(invitation)
+ end
+
+ test "locks the site if the new owner has no active subscription or trial" do
+ site = insert(:site, locked: false)
+
+ existing_owner = insert(:user)
+ insert(:site_membership, user: existing_owner, site: site, role: :owner)
+
+ new_owner = insert(:user, trial_expiry_date: Date.add(Date.utc_today(), -1))
+
+ invitation =
+ insert(:invitation,
+ site_id: site.id,
+ inviter: existing_owner,
+ email: new_owner.email,
+ role: :owner
+ )
+
+ assert {:ok, _membership} =
+ AcceptInvitation.accept_invitation(invitation.invitation_id, new_owner)
+
+ assert Repo.reload!(site).locked
+ end
+
+ test "does not lock the site or set trial expiry date if the instance is selfhosted" do
+ site = insert(:site, locked: false)
+
+ existing_owner = insert(:user)
+ insert(:site_membership, user: existing_owner, site: site, role: :owner)
+
+ new_owner = insert(:user, trial_expiry_date: nil)
+
+ invitation =
+ insert(:invitation,
+ site_id: site.id,
+ inviter: existing_owner,
+ email: new_owner.email,
+ role: :owner
+ )
+
+ assert {:ok, _membership} =
+ AcceptInvitation.accept_invitation(invitation.invitation_id, new_owner,
+ selfhost?: true
+ )
+
+ assert Repo.reload!(new_owner).trial_expiry_date == nil
+ refute Repo.reload!(site).locked
+ end
+
+ test "ends trial of the new owner immediately" do
+ site = insert(:site, locked: false)
+
+ existing_owner = insert(:user)
+ insert(:site_membership, user: existing_owner, site: site, role: :owner)
+
+ new_owner = insert(:user, trial_expiry_date: Date.add(Date.utc_today(), 7))
+
+ invitation =
+ insert(:invitation,
+ site_id: site.id,
+ inviter: existing_owner,
+ email: new_owner.email,
+ role: :owner
+ )
+
+ assert {:ok, _membership} =
+ AcceptInvitation.accept_invitation(invitation.invitation_id, new_owner)
+
+ assert Repo.reload!(new_owner).trial_expiry_date == Date.add(Date.utc_today(), -1)
+ assert Repo.reload!(site).locked
+ end
+
+ test "sets user's trial expiry date to yesterday if they don't have one" do
+ site = insert(:site, locked: false)
+
+ existing_owner = insert(:user)
+ insert(:site_membership, user: existing_owner, site: site, role: :owner)
+
+ new_owner = insert(:user, trial_expiry_date: nil)
+
+ invitation =
+ insert(:invitation,
+ site_id: site.id,
+ inviter: existing_owner,
+ email: new_owner.email,
+ role: :owner
+ )
+
+ assert {:ok, _membership} =
+ AcceptInvitation.accept_invitation(invitation.invitation_id, new_owner)
+
+ assert Repo.reload!(new_owner).trial_expiry_date == Date.add(Date.utc_today(), -1)
+ assert Repo.reload!(site).locked
+ end
+
+ test "ends grace period and sends an email about it if new owner is past grace period" do
+ site = insert(:site, locked: false)
+
+ existing_owner = insert(:user)
+ insert(:site_membership, user: existing_owner, site: site, role: :owner)
+ new_owner = insert(:user, trial_expiry_date: Date.add(Date.utc_today(), -1))
+ insert(:subscription, user: new_owner, next_bill_date: Timex.today())
+
+ new_owner =
+ new_owner
+ |> Plausible.Auth.GracePeriod.start_changeset(100)
+ |> then(fn changeset ->
+ grace_period =
+ changeset
+ |> get_field(:grace_period)
+ |> Map.put(:end_date, Date.add(Date.utc_today(), -1))
+
+ change(changeset, grace_period: grace_period)
+ end)
+ |> Repo.update!()
+
+ invitation =
+ insert(:invitation,
+ site_id: site.id,
+ inviter: existing_owner,
+ email: new_owner.email,
+ role: :owner
+ )
+
+ assert {:ok, _membership} =
+ AcceptInvitation.accept_invitation(invitation.invitation_id, new_owner)
+
+ assert Repo.reload!(new_owner).grace_period.is_over
+ assert Repo.reload!(site).locked
+
+ assert_email_delivered_with(
+ to: [{"Jane Smith", new_owner.email}],
+ subject: "[Action required] Your Plausible dashboard is now locked"
+ )
+ end
+ end
+end
diff --git a/test/plausible/site/memberships/reject_invitation_test.exs b/test/plausible/site/memberships/reject_invitation_test.exs
new file mode 100644
index 0000000000..f6149c00dd
--- /dev/null
+++ b/test/plausible/site/memberships/reject_invitation_test.exs
@@ -0,0 +1,58 @@
+defmodule Plausible.Site.Memberships.RejectInvitationTest do
+ use Plausible.DataCase, async: true
+ use Bamboo.Test
+
+ alias Plausible.Site.Memberships.RejectInvitation
+
+ test "rejects invitation and sends email to inviter" do
+ inviter = insert(:user)
+ invitee = insert(:user)
+ site = insert(:site, members: [inviter])
+
+ invitation =
+ insert(:invitation,
+ site_id: site.id,
+ inviter: inviter,
+ email: invitee.email,
+ role: :admin
+ )
+
+ assert {:ok, rejected_invitation} =
+ RejectInvitation.reject_invitation(invitation.invitation_id, invitee)
+
+ assert rejected_invitation.id == invitation.id
+ refute Repo.reload(rejected_invitation)
+
+ assert_email_delivered_with(
+ to: [nil: inviter.email],
+ subject: "[Plausible Analytics] #{invitee.email} rejected your invitation to #{site.domain}"
+ )
+ end
+
+ test "returns error for non-existent invitation" do
+ invitee = insert(:user)
+
+ assert {:error, :invitation_not_found} =
+ RejectInvitation.reject_invitation("does_not_exist", invitee)
+ end
+
+ test "does not allow rejecting invitation by anyone other than invitee" do
+ inviter = insert(:user)
+ invitee = insert(:user)
+ other_user = insert(:user)
+ site = insert(:site, members: [inviter])
+
+ invitation =
+ insert(:invitation,
+ site_id: site.id,
+ inviter: inviter,
+ email: invitee.email,
+ role: :admin
+ )
+
+ assert {:error, :invitation_not_found} =
+ RejectInvitation.reject_invitation(invitation.invitation_id, other_user)
+
+ assert Repo.reload(invitation)
+ end
+end
diff --git a/test/plausible/site/memberships/remove_invitation_test.exs b/test/plausible/site/memberships/remove_invitation_test.exs
new file mode 100644
index 0000000000..7df3ffe211
--- /dev/null
+++ b/test/plausible/site/memberships/remove_invitation_test.exs
@@ -0,0 +1,52 @@
+defmodule Plausible.Site.Memberships.RemoveInvitationTest do
+ use Plausible.DataCase, async: true
+
+ alias Plausible.Site.Memberships.RemoveInvitation
+
+ test "removes invitation" do
+ inviter = insert(:user)
+ invitee = insert(:user)
+ site = insert(:site, members: [inviter])
+
+ invitation =
+ insert(:invitation,
+ site_id: site.id,
+ inviter: inviter,
+ email: invitee.email,
+ role: :admin
+ )
+
+ assert {:ok, removed_invitation} =
+ RemoveInvitation.remove_invitation(invitation.invitation_id, site)
+
+ assert removed_invitation.id == invitation.id
+ refute Repo.reload(removed_invitation)
+ end
+
+ test "returns error for non-existent invitation" do
+ site = insert(:site)
+
+ assert {:error, :invitation_not_found} =
+ RemoveInvitation.remove_invitation("does_not_exist", site)
+ end
+
+ test "does not allow removing invitation from another site" do
+ inviter = insert(:user)
+ invitee = insert(:user)
+ site = insert(:site, members: [inviter])
+ other_site = insert(:site, members: [inviter])
+
+ invitation =
+ insert(:invitation,
+ site_id: site.id,
+ inviter: inviter,
+ email: invitee.email,
+ role: :admin
+ )
+
+ assert {:error, :invitation_not_found} =
+ RemoveInvitation.remove_invitation(invitation.invitation_id, other_site)
+
+ assert Repo.reload(invitation)
+ end
+end
diff --git a/test/plausible/site/sites_test.exs b/test/plausible/site/sites_test.exs
index 41d9e2ad0f..34385bc99a 100644
--- a/test/plausible/site/sites_test.exs
+++ b/test/plausible/site/sites_test.exs
@@ -142,7 +142,7 @@ defmodule Plausible.SitesTest do
assert {:error, {:over_limit, 5}} = Sites.invite(site, inviter, invitee.email, :viewer)
end
- test "sends ownership transfer email when invitee role is owner" do
+ test "sends ownership transfer email when inviter role is owner" do
inviter = insert(:user)
site = insert(:site, memberships: [build(:site_membership, user: inviter, role: :owner)])
@@ -169,6 +169,36 @@ defmodule Plausible.SitesTest do
assert {:error, :forbidden} = Sites.invite(site, inviter, "[email protected]", :owner)
end
+ test "allows ownership transfer to existing site members" do
+ inviter = insert(:user)
+ invitee = insert(:user)
+
+ site =
+ insert(:site,
+ memberships: [
+ build(:site_membership, user: inviter, role: :owner),
+ build(:site_membership, user: invitee, role: :viewer)
+ ]
+ )
+
+ assert {:ok, %Plausible.Auth.Invitation{}} =
+ Sites.invite(site, inviter, invitee.email, :owner)
+ end
+
+ test "does not allow transferring ownership to existing owner" do
+ inviter = insert(:user, email: "[email protected]")
+
+ site =
+ insert(:site,
+ memberships: [
+ build(:site_membership, user: inviter, role: :owner)
+ ]
+ )
+
+ assert {:error, :transfer_to_self} =
+ Sites.invite(site, inviter, "[email protected]", :owner)
+ end
+
test "does not check for limits when transferring ownership" do
inviter = insert(:user)
diff --git a/test/plausible_web/controllers/api/external_stats_controller/auth_test.exs b/test/plausible_web/controllers/api/external_stats_controller/auth_test.exs
index 1c6117aa7f..25016f6e07 100644
--- a/test/plausible_web/controllers/api/external_stats_controller/auth_test.exs
+++ b/test/plausible_web/controllers/api/external_stats_controller/auth_test.exs
@@ -47,7 +47,7 @@ defmodule PlausibleWeb.Api.ExternalStatsController.AuthTest do
test "locked site - returns 402", %{conn: conn, api_key: api_key, user: user} do
site = insert(:site, members: [user])
- {1, _} = Plausible.Billing.SiteLocker.set_lock_status_for(user, true)
+ {:ok, 1} = Plausible.Billing.SiteLocker.set_lock_status_for(user, true)
conn
|> with_api_key(api_key)
@@ -88,7 +88,7 @@ defmodule PlausibleWeb.Api.ExternalStatsController.AuthTest do
user: user
} do
site = insert(:site, members: [user])
- {1, _} = Plausible.Billing.SiteLocker.set_lock_status_for(user, true)
+ {:ok, 1} = Plausible.Billing.SiteLocker.set_lock_status_for(user, true)
conn
|> with_api_key(api_key)
diff --git a/test/plausible_web/controllers/invitation_controller_test.exs b/test/plausible_web/controllers/invitation_controller_test.exs
index 8121b44851..d68ab67338 100644
--- a/test/plausible_web/controllers/invitation_controller_test.exs
+++ b/test/plausible_web/controllers/invitation_controller_test.exs
@@ -1,5 +1,5 @@
defmodule PlausibleWeb.Site.InvitationControllerTest do
- use PlausibleWeb.ConnCase
+ use PlausibleWeb.ConnCase, async: true
use Plausible.Repo
use Bamboo.Test
@@ -53,43 +53,9 @@ defmodule PlausibleWeb.Site.InvitationControllerTest do
assert Phoenix.Flash.get(c2.assigns.flash, :error) ==
"Invitation missing or already accepted"
end
-
- test "notifies the original inviter", %{conn: conn, user: user} do
- inviter = insert(:user)
- site = insert(:site)
-
- invitation =
- insert(:invitation, site_id: site.id, inviter: inviter, email: user.email, role: :admin)
-
- post(conn, "/sites/invitations/#{invitation.invitation_id}/accept")
-
- assert_email_delivered_with(
- to: [nil: inviter.email],
- subject: "[Plausible Analytics] #{user.email} accepted your invitation to #{site.domain}"
- )
- end
end
describe "POST /sites/invitations/:invitation_id/accept - ownership transfer" do
- test "notifies the original inviter with a different email", %{
- conn: conn,
- user: user
- } do
- inviter = insert(:user)
- site = insert(:site)
-
- invitation =
- insert(:invitation, site_id: site.id, inviter: inviter, email: user.email, role: :owner)
-
- post(conn, "/sites/invitations/#{invitation.invitation_id}/accept")
-
- assert_email_delivered_with(
- to: [nil: inviter.email],
- subject:
- "[Plausible Analytics] #{user.email} accepted the ownership transfer of #{site.domain}"
- )
- end
-
test "downgrades previous owner to admin", %{conn: conn, user: user} do
old_owner = insert(:user)
site = insert(:site, members: [old_owner])
@@ -111,116 +77,10 @@ defmodule PlausibleWeb.Site.InvitationControllerTest do
assert new_owner_membership.role == :owner
end
-
- test "will lock the site if new owner does not have an active subscription or trial",
- %{
- conn: conn,
- user: user
- } do
- Repo.update_all(from(u in Plausible.Auth.User, where: u.id == ^user.id),
- set: [trial_expiry_date: Timex.today() |> Timex.shift(days: -1)]
- )
-
- inviter = insert(:user)
- site = insert(:site, locked: false)
-
- invitation =
- insert(:invitation, site_id: site.id, inviter: inviter, email: user.email, role: :owner)
-
- post(conn, "/sites/invitations/#{invitation.invitation_id}/accept")
-
- assert Repo.reload!(site).locked
- end
-
- test "will end the trial of the new owner immediately", %{
- conn: conn,
- user: user
- } do
- Repo.update_all(from(u in Plausible.Auth.User, where: u.id == ^user.id),
- set: [trial_expiry_date: Timex.today() |> Timex.shift(days: 7)]
- )
-
- inviter = insert(:user)
- site = insert(:site, locked: false)
-
- invitation =
- insert(:invitation, site_id: site.id, inviter: inviter, email: user.email, role: :owner)
-
- post(conn, "/sites/invitations/#{invitation.invitation_id}/accept")
-
- assert Timex.before?(Repo.reload!(user).trial_expiry_date, Timex.today())
- assert Repo.reload!(site).locked
- end
-
- test "if new owner does not have a trial - will set trial_expiry_date to yesterday",
- %{
- conn: conn,
- user: user
- } do
- Repo.update_all(from(u in Plausible.Auth.User, where: u.id == ^user.id),
- set: [trial_expiry_date: nil]
- )
-
- inviter = insert(:user)
- site = insert(:site, locked: false)
-
- invitation =
- insert(:invitation, site_id: site.id, inviter: inviter, email: user.email, role: :owner)
-
- post(conn, "/sites/invitations/#{invitation.invitation_id}/accept")
-
- assert Timex.before?(Repo.reload!(user).trial_expiry_date, Timex.today())
- assert Repo.reload!(site).locked
- end
-
- test "can upgrade admin to owner", %{conn: conn, user: user} do
- old_owner = insert(:user)
- site = insert(:site, members: [old_owner])
- insert(:site_membership, site: site, user: user, role: :admin)
-
- invitation =
- insert(:invitation, site_id: site.id, inviter: old_owner, email: user.email, role: :owner)
-
- post(conn, "/sites/invitations/#{invitation.invitation_id}/accept")
-
- refute Repo.exists?(from(i in Plausible.Auth.Invitation, where: i.email == ^user.email))
-
- new_owner_membership =
- Repo.get_by(Plausible.Site.Membership, user_id: user.id, site_id: site.id)
-
- assert new_owner_membership.role == :owner
- end
-
- test "works in self-hosted", %{conn: conn, user: user} do
- patch_env(:is_selfhost, true)
-
- old_owner = insert(:user)
- site = insert(:site, members: [old_owner])
-
- invitation =
- insert(:invitation,
- site_id: site.id,
- inviter: old_owner,
- email: user.email,
- role: :owner
- )
-
- post(conn, "/sites/invitations/#{invitation.invitation_id}/accept")
-
- old_owner_membership =
- Repo.get_by(Plausible.Site.Membership, user_id: old_owner.id, site_id: site.id)
-
- assert old_owner_membership.role == :admin
-
- new_owner_membership =
- Repo.get_by(Plausible.Site.Membership, user_id: user.id, site_id: site.id)
-
- assert new_owner_membership.role == :owner
- end
end
describe "POST /sites/invitations/:invitation_id/reject" do
- test "deletes the invitation", %{conn: conn, user: user} do
+ test "rejects the invitation", %{conn: conn, user: user} do
site = insert(:site)
invitation =
@@ -231,24 +91,20 @@ defmodule PlausibleWeb.Site.InvitationControllerTest do
role: :admin
)
- post(conn, "/sites/invitations/#{invitation.invitation_id}/reject")
+ conn = post(conn, "/sites/invitations/#{invitation.invitation_id}/reject")
- refute Repo.exists?(from(i in Plausible.Auth.Invitation, where: i.email == ^user.email))
- end
+ assert redirected_to(conn, 302) == "/sites"
- test "notifies the original inviter", %{conn: conn, user: user} do
- inviter = insert(:user)
- site = insert(:site)
+ refute Repo.reload(invitation)
+ end
- invitation =
- insert(:invitation, site_id: site.id, inviter: inviter, email: user.email, role: :admin)
+ test "renders error for non-existent invitation", %{conn: conn} do
+ conn = post(conn, "/sites/invitations/does-not-exist/reject")
- post(conn, "/sites/invitations/#{invitation.invitation_id}/reject")
+ assert redirected_to(conn, 302) == "/sites"
- assert_email_delivered_with(
- to: [nil: inviter.email],
- subject: "[Plausible Analytics] #{user.email} rejected your invitation to #{site.domain}"
- )
+ assert Phoenix.Flash.get(conn.assigns.flash, :error) ==
+ "Invitation missing or already accepted"
end
end
@@ -272,9 +128,7 @@ defmodule PlausibleWeb.Site.InvitationControllerTest do
assert redirected_to(conn, 302) == "/#{site.domain}/settings/people"
- refute Repo.exists?(
- from i in Plausible.Auth.Invitation, where: i.email == "[email protected]"
- )
+ refute Repo.reload(invitation)
end
test "fails to remove an invitation with insufficient permission", %{conn: conn, user: user} do
@@ -293,9 +147,7 @@ defmodule PlausibleWeb.Site.InvitationControllerTest do
Routes.invitation_path(conn, :remove_invitation, site.domain, invitation.invitation_id)
)
- assert Repo.exists?(
- from i in Plausible.Auth.Invitation, where: i.email == "[email protected]"
- )
+ assert Repo.reload(invitation)
end
test "fails to remove an invitation from the outside", %{conn: my_conn, user: me} do
@@ -324,9 +176,26 @@ defmodule PlausibleWeb.Site.InvitationControllerTest do
delete(my_conn, remove_invitation_path)
- assert Repo.exists?(
- from i in Plausible.Auth.Invitation, where: i.email == "[email protected]"
- )
+ assert Repo.reload(invitation)
+ end
+
+ test "renders error for non-existent invitation", %{conn: conn, user: user} do
+ site = insert(:site, memberships: [build(:site_membership, user: user, role: :admin)])
+
+ remove_invitation_path =
+ Routes.invitation_path(
+ conn,
+ :remove_invitation,
+ site.domain,
+ "does_not_exist"
+ )
+
+ conn = delete(conn, remove_invitation_path)
+
+ assert redirected_to(conn, 302) == "/#{site.domain}/settings/people"
+
+ assert Phoenix.Flash.get(conn.assigns.flash, :error) ==
+ "Invitation missing or already removed"
end
end
end