From f0c749ad70b2664ec8e22ac0ef3e5b7cab5d10f7 Mon Sep 17 00:00:00 2001 From: Adrian Gruntkowski Date: Fri, 13 Oct 2023 18:37:58 +0200 Subject: [PATCH] Implement direct site ownership transfer without invite via CRM (#3416) --- lib/plausible/site/admin.ex | 24 +++ lib/plausible/site/memberships.ex | 1 + .../site/memberships/accept_invitation.ex | 40 +++- lib/plausible/sites.ex | 15 ++ .../memberships/accept_invitation_test.exs | 171 +++++++++++++++++- test/plausible/site/sites_test.exs | 64 +++++++ 6 files changed, 309 insertions(+), 6 deletions(-) diff --git a/lib/plausible/site/admin.ex b/lib/plausible/site/admin.ex index f97d2dc6b..3fac915a6 100644 --- a/lib/plausible/site/admin.ex +++ b/lib/plausible/site/admin.ex @@ -61,6 +61,13 @@ defmodule Plausible.SiteAdmin do %{name: "email", title: "New Owner Email", default: nil} ], action: fn conn, sites, params -> transfer_ownership(conn, sites, params) end + }, + transfer_ownership_direct: %{ + name: "Transfer ownership without invite", + inputs: [ + %{name: "email", title: "New Owner Email", default: nil} + ], + action: fn conn, sites, params -> transfer_ownership_direct(conn, sites, params) end } ] end @@ -85,6 +92,23 @@ defmodule Plausible.SiteAdmin do end end + defp transfer_ownership_direct(_conn, [], _params) do + {:error, "Please select at least one site from the list"} + end + + defp transfer_ownership_direct(_conn, sites, %{"email" => email}) do + new_owner = Plausible.Auth.find_user_by(email: email) + + if new_owner do + case Plausible.Sites.bulk_transfer_ownership_direct(sites, new_owner) do + {:ok, _} -> :ok + {:error, :transfer_to_self} -> {:error, "User is already an owner of one of the sites"} + end + else + {:error, "User could not be found"} + end + end + defp format_date(date) do Timex.format!(date, "{Mshort} {D}, {YYYY}") end diff --git a/lib/plausible/site/memberships.ex b/lib/plausible/site/memberships.ex index cb743e6ec..c0b858846 100644 --- a/lib/plausible/site/memberships.ex +++ b/lib/plausible/site/memberships.ex @@ -8,6 +8,7 @@ defmodule Plausible.Site.Memberships do alias Plausible.Repo alias Plausible.Site.Memberships + defdelegate transfer_ownership(site, user), to: Memberships.AcceptInvitation 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 diff --git a/lib/plausible/site/memberships/accept_invitation.ex b/lib/plausible/site/memberships/accept_invitation.ex index bf9f0346d..9af496526 100644 --- a/lib/plausible/site/memberships/accept_invitation.ex +++ b/lib/plausible/site/memberships/accept_invitation.ex @@ -22,6 +22,29 @@ defmodule Plausible.Site.Memberships.AcceptInvitation do require Logger + @spec transfer_ownership(Site.t(), Auth.User.t(), Keyword.t()) :: + {:ok, Site.Membership.t()} | {:error, Ecto.Changeset.t()} + def transfer_ownership(site, user, opts \\ []) do + selfhost? = Keyword.get(opts, :selfhost?, Plausible.Release.selfhost?()) + membership = get_or_create_owner_membership(site, user) + multi = add_and_transfer_ownership(site, membership, user, selfhost?) + + case Repo.transaction(multi) do + {:ok, changes} -> + if changes[:site_locker] == {:locked, :grace_period_ended_now} do + user = Plausible.Users.with_subscription(changes.user) + Billing.SiteLocker.send_grace_period_end_email(user) + end + + membership = Repo.preload(changes.membership, [:site, :user]) + + {:ok, membership} + + {:error, _operation, error, _changes} -> + {:error, error} + end + end + @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 @@ -32,7 +55,9 @@ defmodule Plausible.Site.Memberships.AcceptInvitation do multi = if invitation.role == :owner do - add_and_transfer_ownership(invitation, membership, user, selfhost?) + invitation.site + |> add_and_transfer_ownership(membership, user, selfhost?) + |> Multi.delete(:invitation, invitation) else add(invitation, membership, user) end @@ -56,13 +81,12 @@ defmodule Plausible.Site.Memberships.AcceptInvitation do end end - defp add_and_transfer_ownership(invitation, membership, user, selfhost?) do + defp add_and_transfer_ownership(site, membership, user, selfhost?) do multi = Multi.new() - |> downgrade_previous_owner(invitation.site, user) + |> downgrade_previous_owner(site, user) |> maybe_end_trial_of_new_owner(user, selfhost?) |> Multi.insert_or_update(:membership, membership) - |> Multi.delete(:invitation, invitation) if selfhost? do multi @@ -95,6 +119,14 @@ defmodule Plausible.Site.Memberships.AcceptInvitation do |> Site.Membership.set_role(invitation.role) end + defp get_or_create_owner_membership(site, user) do + case Repo.get_by(Site.Membership, user_id: user.id, site_id: site.id) do + nil -> Site.Membership.new(site, user) + membership -> membership + end + |> Site.Membership.set_role(:owner) + 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 diff --git a/lib/plausible/sites.ex b/lib/plausible/sites.ex index 0ee276757..0e9465f83 100644 --- a/lib/plausible/sites.ex +++ b/lib/plausible/sites.ex @@ -47,6 +47,21 @@ defmodule Plausible.Sites do end end + @spec bulk_transfer_ownership_direct([Site.t()], Plausible.Auth.User.t()) :: + {:ok, [Plausible.Site.Membership.t()]} | {:error, invite_error()} + def bulk_transfer_ownership_direct(sites, new_owner) do + Repo.transaction(fn -> + for site <- sites do + with :ok <- ensure_transfer_valid(site, new_owner, :owner), + {:ok, membership} <- Site.Memberships.transfer_ownership(site, new_owner) do + membership + else + {:error, error} -> Repo.rollback(error) + end + end + end) + end + @spec bulk_transfer_ownership( [Site.t()], Plausible.Auth.User.t(), diff --git a/test/plausible/site/memberships/accept_invitation_test.exs b/test/plausible/site/memberships/accept_invitation_test.exs index ea76a31bb..27425a296 100644 --- a/test/plausible/site/memberships/accept_invitation_test.exs +++ b/test/plausible/site/memberships/accept_invitation_test.exs @@ -4,7 +4,174 @@ defmodule Plausible.Site.Memberships.AcceptInvitationTest do alias Plausible.Site.Memberships.AcceptInvitation - describe "invitations" do + describe "transfer_ownership/3" do + for {label, opts} <- [{"cloud", []}, {"selfhosted", [selfhost?: true]}] do + test "transfers ownership on #{label} instance" do + site = insert(:site, memberships: []) + existing_owner = insert(:user) + + existing_membership = + insert(:site_membership, user: existing_owner, site: site, role: :owner) + + new_owner = insert(:user) + + assert {:ok, new_membership} = + AcceptInvitation.transfer_ownership(site, new_owner, unquote(opts)) + + assert new_membership.site_id == site.id + assert new_membership.user_id == new_owner.id + assert new_membership.role == :owner + + 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_no_emails_delivered() + end + end + + for role <- [:viewer, :admin] do + test "upgrades existing #{role} membership into an owner" do + existing_owner = insert(:user) + new_owner = insert(:user) + + site = + insert(:site, + memberships: [ + build(:site_membership, user: existing_owner, role: :owner), + build(:site_membership, user: new_owner, role: unquote(role)) + ] + ) + + assert {:ok, %{id: membership_id}} = AcceptInvitation.transfer_ownership(site, new_owner) + + assert %{role: :admin} = + Plausible.Repo.get_by(Plausible.Site.Membership, user_id: existing_owner.id) + + assert %{id: ^membership_id, role: :owner} = + Plausible.Repo.get_by(Plausible.Site.Membership, user_id: new_owner.id) + end + end + + test "does not degrade or alter trial when accepting ownership transfer by self" do + owner = insert(:user, trial_expiry_date: nil) + site = insert(:site, memberships: [build(:site_membership, user: owner, role: :owner)]) + + assert {:ok, %{id: membership_id}} = AcceptInvitation.transfer_ownership(site, owner) + + assert %{id: ^membership_id, role: :owner} = + Plausible.Repo.get_by(Plausible.Site.Membership, user_id: owner.id) + + assert Repo.reload!(owner).trial_expiry_date == nil + end + + test "locks the site if the new owner has no active subscription or trial" do + existing_owner = insert(:user) + + site = + insert(:site, + locked: false, + memberships: [build(:site_membership, user: existing_owner, role: :owner)] + ) + + new_owner = insert(:user, trial_expiry_date: Date.add(Date.utc_today(), -1)) + + assert {:ok, _membership} = AcceptInvitation.transfer_ownership(site, 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 + existing_owner = insert(:user) + + site = + insert(:site, + locked: false, + memberships: [build(:site_membership, user: existing_owner, role: :owner)] + ) + + new_owner = insert(:user, trial_expiry_date: nil) + + assert {:ok, _membership} = + AcceptInvitation.transfer_ownership(site, 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 + existing_owner = insert(:user) + + site = + insert(:site, + locked: false, + memberships: [build(:site_membership, user: existing_owner, role: :owner)] + ) + + new_owner = insert(:user, trial_expiry_date: Date.add(Date.utc_today(), 7)) + + assert {:ok, _membership} = AcceptInvitation.transfer_ownership(site, 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 + existing_owner = insert(:user) + + site = + insert(:site, + locked: false, + memberships: [build(:site_membership, user: existing_owner, role: :owner)] + ) + + new_owner = insert(:user, trial_expiry_date: nil) + + assert {:ok, _membership} = AcceptInvitation.transfer_ownership(site, 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 + existing_owner = insert(:user) + + site = + insert(:site, + locked: false, + memberships: [build(:site_membership, user: existing_owner, 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!() + + assert {:ok, _membership} = AcceptInvitation.transfer_ownership(site, 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 + + describe "accept_invitation/3 - invitations" do test "converts an invitation into a membership" do inviter = insert(:user) invitee = insert(:user) @@ -91,7 +258,7 @@ defmodule Plausible.Site.Memberships.AcceptInvitationTest do end end - describe "ownership transfers" do + describe "accept_invitation/3 - 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, memberships: []) diff --git a/test/plausible/site/sites_test.exs b/test/plausible/site/sites_test.exs index bd5f00f25..663859c4a 100644 --- a/test/plausible/site/sites_test.exs +++ b/test/plausible/site/sites_test.exs @@ -308,6 +308,70 @@ defmodule Plausible.SitesTest do end end + describe "bulk_transfer_ownership_direct/2" do + test "transfers ownership for multiple sites in one action" do + current_owner = insert(:user) + new_owner = insert(:user) + + site1 = + insert(:site, memberships: [build(:site_membership, user: current_owner, role: :owner)]) + + site2 = + insert(:site, memberships: [build(:site_membership, user: current_owner, role: :owner)]) + + assert {:ok, _} = Sites.bulk_transfer_ownership_direct([site1, site2], new_owner) + + assert Repo.get_by(Plausible.Site.Membership, + site_id: site1.id, + user_id: new_owner.id, + role: :owner + ) + + assert Repo.get_by(Plausible.Site.Membership, + site_id: site2.id, + user_id: new_owner.id, + role: :owner + ) + + assert Repo.get_by(Plausible.Site.Membership, + site_id: site1.id, + user_id: current_owner.id, + role: :admin + ) + + assert Repo.get_by(Plausible.Site.Membership, + site_id: site2.id, + user_id: current_owner.id, + role: :admin + ) + end + + test "returns error when user is already an owner for one of the sites" do + current_owner = insert(:user) + new_owner = insert(:user) + + site1 = + insert(:site, memberships: [build(:site_membership, user: current_owner, role: :owner)]) + + site2 = insert(:site, memberships: [build(:site_membership, user: new_owner, role: :owner)]) + + assert {:error, :transfer_to_self} = + Sites.bulk_transfer_ownership_direct([site1, site2], new_owner) + + assert Repo.get_by(Plausible.Site.Membership, + site_id: site1.id, + user_id: current_owner.id, + role: :owner + ) + + assert Repo.get_by(Plausible.Site.Membership, + site_id: site2.id, + user_id: new_owner.id, + role: :owner + ) + end + end + describe "get_for_user/2" do test "get site for super_admin" do user1 = insert(:user)