Allow site transfer between different teams of the same user

lib/plausible/site/admin.ex

@@ -145,8 +145,8 @@ defmodule Plausible.SiteAdmin do
       {:error, :user_not_found} ->
         {:error, "User could not be found"}
 
-      {:error, :transfer_to_self} ->
-        {:error, "User is already an owner of one of the sites"}
+      {:error, %Ecto.Changeset{}} ->
+        {:error, "Site transfer request has failed for one of the sites"}
     end
   end
 
@@ -169,7 +169,7 @@ defmodule Plausible.SiteAdmin do
         {:error, "User could not be found"}
 
       {:error, :transfer_to_self} ->
-        {:error, "User is already an owner of one of the sites"}
+        {:error, "The site is already in the picked team"}
 
       {:error, :no_plan} ->
         {:error, "The new owner does not have a subscription"}

lib/plausible/site/memberships/accept_invitation.ex

@@ -33,6 +33,7 @@ defmodule Plausible.Site.Memberships.AcceptInvitation do
           | Billing.Quota.Limits.over_limits_error()
           | Ecto.Changeset.t()
           | :no_plan
+          | :transfer_to_self
           | :multiple_teams
           | :permission_denied
 
@@ -75,8 +76,8 @@ defmodule Plausible.Site.Memberships.AcceptInvitation do
   defp transfer_ownership(site, new_owner, team) do
     site = Repo.preload(site, :team)
 
-    with :ok <- Teams.Invitations.ensure_transfer_valid(site.team, new_owner, :owner),
-         {:ok, new_team} <- maybe_get_team(new_owner, team),
+    with {:ok, new_team} <- maybe_get_team(new_owner, team),
+         :ok <- Teams.Invitations.ensure_transfer_valid(site.team, new_team, :owner),
          :ok <- check_can_transfer_site(new_team, new_owner),
          :ok <- Teams.Invitations.ensure_can_take_ownership(site, new_team),
          :ok <- Teams.Invitations.transfer_site(site, new_team) do
@@ -89,8 +90,8 @@ defmodule Plausible.Site.Memberships.AcceptInvitation do
   defp do_accept_ownership_transfer(site_transfer, new_owner, team) do
     site = Repo.preload(site_transfer.site, :team)
 
-    with :ok <- Teams.Invitations.ensure_transfer_valid(site.team, new_owner, :owner),
-         {:ok, new_team} <- maybe_get_team(new_owner, team),
+    with {:ok, new_team} <- maybe_get_team(new_owner, team),
+         :ok <- Teams.Invitations.ensure_transfer_valid(site.team, new_team, :owner),
          :ok <- check_can_transfer_site(new_team, new_owner),
          :ok <- Teams.Invitations.ensure_can_take_ownership(site, new_team),
          :ok <- Teams.Invitations.accept_site_transfer(site_transfer, new_team) do

lib/plausible/site/memberships/create_invitation.ex

@@ -13,8 +13,6 @@ defmodule Plausible.Site.Memberships.CreateInvitation do
   @type invite_error() ::
           Ecto.Changeset.t()
           | :already_a_member
-          | :transfer_to_self
-          | :no_plan
           | {:over_limit, non_neg_integer()}
           | :forbidden
 
@@ -65,12 +63,6 @@ defmodule Plausible.Site.Memberships.CreateInvitation do
              invitee_email
            ),
          invitee = Plausible.Auth.find_user_by(email: invitee_email),
-         :ok <-
-           Teams.Invitations.ensure_transfer_valid(
-             site.team,
-             invitee,
-             role
-           ),
          :ok <-
            Teams.Invitations.ensure_new_membership(
              site,

lib/plausible/teams/invitations.ex

@@ -233,10 +233,11 @@ defmodule Plausible.Teams.Invitations do
   @doc false
   def ensure_transfer_valid(_team, nil, :owner), do: :ok
 
-  def ensure_transfer_valid(team, new_owner, :owner) do
-    case Teams.Memberships.team_role(team, new_owner) do
-      {:ok, :owner} -> {:error, :transfer_to_self}
-      _ -> :ok
+  def ensure_transfer_valid(team, new_team, :owner) do
+    if team.id == new_team.id do
+      {:error, :transfer_to_self}
+    else
+      :ok
     end
   end
 
@@ -493,11 +494,11 @@ defmodule Plausible.Teams.Invitations do
 
     if check_permissions? do
       case Teams.Memberships.site_role(site, inviter) do
-        {:ok, :owner} when invitation_role == :owner ->
+        {:ok, inviter_role} when inviter_role in [:owner, :admin] and invitation_role == :owner ->
           :ok
 
         {:ok, inviter_role}
-        when inviter_role in [:owner, :editor, :admin] and invitation_role != :owner ->
+        when inviter_role in [:owner, :admin, :editor] and invitation_role != :owner ->
           :ok
 
         _ ->