Implement direct site ownership transfer without invite via CRM (#3416)

pull/3425/head
Adrian Gruntkowski 3 years ago committed by GitHub
parent 313bfa0558
commit f0c749ad70
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

@ -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

@ -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

@ -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

@ -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(),

@ -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: [])

@ -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)

Loading…
Cancel
Save