Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.
TypeScript analyticsanalytics-dashboardclickhouseelixirgoogle-analyticsmarketingopen-source-analyticsphoenixplausible-analyticspostgresqlprivacyprivacy-friendlyself-hostedsimple-analyticsstatisticstailwindcssweb-analyticswebsite-analyticswebsite-statswebsite-tracking
Fix and refactor invitation logic (#3376)
Adrian Gruntkowskie67850c11dc4
diff --git a/lib/plausible/billing/billing.ex b/lib/plausible/billing/billing.exindex 5581c088ec..932f55adb9 100644--- a/lib/plausible/billing/billing.ex+++ b/lib/plausible/billing/billing.ex@@ -73,17 +73,22 @@ defmodule Plausible.Billing doendend- 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) douser = 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_neededendend@@ -260,34 +265,14 @@ defmodule Plausible.Billing doendend- 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+ )enddefp after_subscription_update(subscription) do@@ -298,7 +283,23 @@ defmodule Plausible.Billing douser|> 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+ endenddiff --git a/lib/plausible/billing/site_locker.ex b/lib/plausible/billing/site_locker.exindex 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 douse 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)+ :unlockedendend+ @spec set_lock_status_for(Plausible.Auth.User.t(), boolean()) :: {:ok, non_neg_integer()}def set_lock_status_for(user, status) dosite_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 dowhere: 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.exindex c63ab30599..f7c6acb0cf 100644--- a/lib/plausible/mailer.ex+++ b/lib/plausible/mailer.ex@@ -2,7 +2,9 @@ defmodule Plausible.Mailer douse Bamboo.Mailer, otp_app: :plausiblerequire 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) docase deliver_now(email) do{:ok, _email} -> :okdiff --git a/lib/plausible/site/membership.ex b/lib/plausible/site/membership.exindex 52e7c94e83..6e663faf59 100644--- a/lib/plausible/site/membership.ex+++ b/lib/plausible/site/membership.ex@@ -2,6 +2,8 @@ defmodule Plausible.Site.Membership douse Ecto.Schemaimport Ecto.Changeset+ @type t() :: %__MODULE__{}+schema "site_memberships" dofield :role, Ecto.Enum, values: [:owner, :admin, :viewer]belongs_to :site, Plausible.Site@@ -10,9 +12,15 @@ defmodule Plausible.Site.Membership dotimestamps()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])endenddiff --git a/lib/plausible/site/memberships.ex b/lib/plausible/site/memberships.exnew file mode 100644index 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+enddiff --git a/lib/plausible/site/memberships/accept_invitation.ex b/lib/plausible/site/memberships/accept_invitation.exnew file mode 100644index 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+enddiff --git a/lib/plausible/site/memberships/invitations.ex b/lib/plausible/site/memberships/invitations.exnew file mode 100644index 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+enddiff --git a/lib/plausible/site/memberships/reject_invitation.ex b/lib/plausible/site/memberships/reject_invitation.exnew file mode 100644index 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+enddiff --git a/lib/plausible/site/memberships/remove_invitation.ex b/lib/plausible/site/memberships/remove_invitation.exnew file mode 100644index 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+enddiff --git a/lib/plausible/sites.ex b/lib/plausible/sites.exindex 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 doif 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 dowith :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 doPlausible.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:okenddiff --git a/lib/plausible_web/controllers/invitation_controller.ex b/lib/plausible_web/controllers/invitation_controller.exindex 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 douse PlausibleWeb, :controller- use Plausible.Repo- alias Ecto.Multi- alias Plausible.Auth.Invitation- alias Plausible.Site.Membershipplug 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")endenddef 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")+ endenddef 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))+ endendenddiff --git a/lib/plausible_web/controllers/site/membership_controller.ex b/lib/plausible_web/controllers/site/membership_controller.exindex 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 doif can_grant_role? domembership =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.exindex 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 dosites: 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))enddiff --git a/lib/plausible_web/templates/site/index.html.eex b/lib/plausible_web/templates/site/index.html.eexindex 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.exindex 69356d6cd7..e1007dcb39 100644--- a/lib/workers/lock_sites.ex+++ b/lib/workers/lock_sites.ex@@ -8,7 +8,7 @@ defmodule Plausible.Workers.LockSites dousers = 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:okdiff --git a/test/plausible/billing/billing_test.exs b/test/plausible/billing/billing_test.exsindex e924c7506a..d49b4997df 100644--- a/test/plausible/billing/billing_test.exs+++ b/test/plausible/billing/billing_test.exs@@ -125,30 +125,36 @@ defmodule Plausible.BillingTest doendend- describe "needs_to_upgrade?" do+ describe "check_needs_to_upgrade" dotest "is false for a trial user" douser = insert(:user)- refute Billing.needs_to_upgrade?(user)+ assert Billing.check_needs_to_upgrade(user) == :no_upgrade_neededendtest "is true for a user with an expired trial" douser = 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}endtest "is false for a user with an expired trial but an active subscription" douser = 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_neededendtest "is false for a user with a cancelled subscription IF the billing cycle isn't completed yet" douser = 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_neededendtest "is true for a user with a cancelled subscription IF the billing cycle is complete" do@@ -160,14 +166,23 @@ defmodule Plausible.BillingTest donext_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" douser = 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}endenddiff --git a/test/plausible/billing/site_locker_test.exs b/test/plausible/billing/site_locker_test.exsindex 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 douse Bamboo.Test, shared: truealias Plausible.Billing.SiteLocker- describe "check_sites_for/1" do+ describe "update_sites_for/1" dotest "does not lock sites if user is on trial" douser = 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) == :unlockedrefute Repo.reload!(site).lockedend@@ -17,9 +23,16 @@ defmodule Plausible.Billing.SiteLockerTest dotest "does not lock if user has an active subscription" douser = 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) == :unlockedrefute Repo.reload!(site).lockedend@@ -27,9 +40,15 @@ defmodule Plausible.Billing.SiteLockerTest dotest "does not lock user who is past due" douser = 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) == :unlockedrefute Repo.reload!(site).lockedend@@ -37,9 +56,15 @@ defmodule Plausible.Billing.SiteLockerTest dotest "does not lock user who cancelled subscription but it hasn't expired yet" douser = 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) == :unlockedrefute Repo.reload!(site).lockedend@@ -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) == :unlockedrefute Repo.reload!(site).lockedendtest "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 douser: 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).lockedendtest "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).lockedend@@ -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 dotest "locks all sites if user has no trial or active subscription" douser = 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).lockedend@@ -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.exsnew file mode 100644index 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+enddiff --git a/test/plausible/site/memberships/reject_invitation_test.exs b/test/plausible/site/memberships/reject_invitation_test.exsnew file mode 100644index 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+enddiff --git a/test/plausible/site/memberships/remove_invitation_test.exs b/test/plausible/site/memberships/remove_invitation_test.exsnew file mode 100644index 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+enddiff --git a/test/plausible/site/sites_test.exs b/test/plausible/site/sites_test.exsindex 41d9e2ad0f..34385bc99a 100644--- a/test/plausible/site/sites_test.exs+++ b/test/plausible/site/sites_test.exs@@ -142,7 +142,7 @@ defmodule Plausible.SitesTest doassert {: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" doinviter = insert(:user)site = insert(:site, memberships: [build(:site_membership, user: inviter, role: :owner)])@@ -169,6 +169,36 @@ defmodule Plausible.SitesTest doassert {: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" doinviter = 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.exsindex 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 dotest "locked site - returns 402", %{conn: conn, api_key: api_key, user: user} dosite = 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 douser: user} dosite = 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.exsindex 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: trueuse Plausible.Repouse Bamboo.Test@@ -53,43 +53,9 @@ defmodule PlausibleWeb.Site.InvitationControllerTest doassert 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}"- )- endenddescribe "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} doold_owner = insert(:user)site = insert(:site, members: [old_owner])@@ -111,116 +77,10 @@ defmodule PlausibleWeb.Site.InvitationControllerTest doassert new_owner_membership.role == :ownerend-- 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- endenddescribe "POST /sites/invitations/:invitation_id/reject" do- test "deletes the invitation", %{conn: conn, user: user} do+ test "rejects the invitation", %{conn: conn, user: user} dosite = insert(:site)invitation =@@ -231,24 +91,20 @@ defmodule PlausibleWeb.Site.InvitationControllerTest dorole: :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"endend@@ -272,9 +128,7 @@ defmodule PlausibleWeb.Site.InvitationControllerTest doassert 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)endtest "fails to remove an invitation with insufficient permission", %{conn: conn, user: user} do@@ -293,9 +147,7 @@ defmodule PlausibleWeb.Site.InvitationControllerTest doRoutes.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)endtest "fails to remove an invitation from the outside", %{conn: my_conn, user: me} do@@ -324,9 +176,26 @@ defmodule PlausibleWeb.Site.InvitationControllerTest dodelete(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"endendend