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
[Step 4]: Rework team layout persist (#6772)
RobertJoonas376e91e9ffc3
diff --git a/extra/lib/plausible_web/live/customer_support/team/components/members.ex b/extra/lib/plausible_web/live/customer_support/team/components/members.exindex a7179cbed7..af82606599 100644--- a/extra/lib/plausible_web/live/customer_support/team/components/members.ex+++ b/extra/lib/plausible_web/live/customer_support/team/components/members.ex@@ -6,6 +6,7 @@ defmodule PlausibleWeb.CustomerSupport.Team.Components.Members doimport PlausibleWeb.CustomerSupport.Liveimport PlausibleWeb.CustomerSupport.Components.SuppressionWarningalias Plausible.Teams+ alias Plausible.Teams.Management.Rosterdef update(%{team: team}, socket) do{:ok, refresh_members(socket, team)}@@ -14,7 +15,7 @@ defmodule PlausibleWeb.CustomerSupport.Team.Components.Members dodef render(assigns) do~H"""<div class="mt-2">- <.table rows={Teams.Management.Layout.sorted_for_display(@team_layout)}>+ <.table rows={Roster.sorted_for_display(@roster)}><:thead><.th>User</.th><.th>Sessions</.th>@@ -23,9 +24,9 @@ defmodule PlausibleWeb.CustomerSupport.Team.Components.Members do</:thead><:tbody :let={{_, member}}><.td truncate>- <div :if={member.id != 0} class="flex items-center">+ <div :if={not Roster.Entry.invitation?(member)} class="flex items-center"><.styled_link- patch={~p"/cs/users/user/#{member.id}"}+ patch={~p"/cs/users/user/#{member.source.user.id}"}class="cursor-pointer flex block items-center"><img@@ -36,7 +37,7 @@ defmodule PlausibleWeb.CustomerSupport.Team.Components.Members do</.styled_link><.suppression_warning email={member.email} /></div>- <div :if={member.id == 0} class="flex items-center">+ <div :if={Roster.Entry.invitation?(member)} class="flex items-center"><imgsrc={Plausible.Auth.User.profile_img_url(%Plausible.Auth.User{email: member.email})}class="mr-4 w-6 rounded-full bg-gray-300"@@ -45,21 +46,23 @@ defmodule PlausibleWeb.CustomerSupport.Team.Components.Members do</div></.td><.td>- {if member.type == :membership, do: @session_counts[member.meta.user.id] || 0, else: 0}+ {if Roster.Entry.invitation?(member),+ do: 0,+ else: @session_counts[member.source.user.id] || 0}</.td><.td><div class="flex items-center gap-x-1">- <span :if={member.type == :membership && member.meta.user.type == :sso}>SSO </span>{member.type}+ <span :if={sso_member?(member)}>SSO </span>{member_type(member)}<.button- :if={member.type == :membership && member.meta.user.type == :sso}- id={"deprovision-sso-user-#{member.id}"}+ :if={sso_member?(member)}+ id={"deprovision-sso-user-#{member.source.user.id}"}theme="ghost"size="sm"icon?={true}class="btn-text-danger"phx-click="deprovision-sso-user"- phx-value-identifier={member.id}+ phx-value-identifier={member.source.user.id}phx-target={@myself}data-confirm="Are you sure you want to deprovision SSO user and convert them to a standard user? This will sign them out and force to use regular e-mail/password combination to log in again.">@@ -86,15 +89,21 @@ defmodule PlausibleWeb.CustomerSupport.Team.Components.Members doenddefp refresh_members(socket, team) do- team_layout = Teams.Management.Layout.init(team)+ roster = Roster.init(team)session_counts =- team_layout- |> Enum.map(fn {_, entry} -> if entry.type == :membership, do: entry.meta.user end)- |> Enum.reject(&is_nil/1)+ roster+ |> Roster.users()|> Plausible.Auth.UserSessions.count_for_users()|> Enum.into(%{})- assign(socket, team: team, team_layout: team_layout, session_counts: session_counts)+ assign(socket, team: team, roster: roster, session_counts: session_counts)+ end++ defp sso_member?(%Roster.Entry{source: %Teams.Membership{user: %{type: :sso}}}), do: true+ defp sso_member?(_), do: false++ defp member_type(member) do+ if Roster.Entry.invitation?(member), do: "invitation", else: "membership"endenddiff --git a/lib/plausible/teams.ex b/lib/plausible/teams.exindex 58476f6990..6bd731c9cc 100644--- a/lib/plausible/teams.ex+++ b/lib/plausible/teams.ex@@ -204,7 +204,7 @@ defmodule Plausible.Teams do@doc """Sets up a team by renaming it and inviting the given members, all ina single transaction - so that e.g. a member limit error on one of the- invitations never leaves the team renamed or marked as set up.+ invitations never renames the team or marks it as set up.Invitation e-mails are only sent once the transaction has been committed."""diff --git a/lib/plausible/teams/invitations.ex b/lib/plausible/teams/invitations.exindex c715d11663..0da75cb9bf 100644--- a/lib/plausible/teams/invitations.ex+++ b/lib/plausible/teams/invitations.ex@@ -588,26 +588,6 @@ defmodule Plausible.Teams.Invitations doend@doc false- def check_invitation_permissions(%Teams.Team{} = team, inviter, invitation_role, opts) do- check_permissions? = Keyword.get(opts, :check_permissions, true)-- if check_permissions? do- case Teams.Memberships.team_role(team, inviter) do- {:ok, :owner} when invitation_role == :owner ->- :ok-- {:ok, inviter_role}- when inviter_role in [:owner, :admin] and invitation_role != :owner ->- :ok-- _ ->- {:error, :permission_denied}- end- else- :ok- end- end-def check_invitation_permissions(%Plausible.Site{} = site, inviter, _invitation_role, opts) docheck_permissions? = Keyword.get(opts, :check_permissions, true)@@ -660,7 +640,7 @@ defmodule Plausible.Teams.Invitations doendend- def ensure_not_already_invited(%Teams.Team{} = team, invitee_email) do+ def ensure_no_invitations(%Teams.Team{} = team, invitee_email) dopending_invitation_role =Repo.one(from ti in Teams.Invitation,@@ -671,8 +651,8 @@ defmodule Plausible.Teams.Invitations docase pending_invitation_role donil -> :ok- :guest -> {:error, :already_invited_guest}- _ -> {:error, :already_invited}+ :guest -> {:error, :invited_as_guest}+ _ -> {:error, :invited_as_member}endenddiff --git a/lib/plausible/teams/invitations/invite_to_team.ex b/lib/plausible/teams/invitations/invite_to_team.exindex 3492165c78..557b2c4faf 100644--- a/lib/plausible/teams/invitations/invite_to_team.ex+++ b/lib/plausible/teams/invitations/invite_to_team.ex@@ -6,36 +6,8 @@ defmodule Plausible.Teams.Invitations.InviteToTeam doalias Plausible.Repoalias Plausible.Teams- @valid_roles Plausible.Teams.Invitation.roles() -- [:guest]- @valid_roles @valid_roles ++ Enum.map(@valid_roles, &to_string/1)-@type invite_entry() :: %{email: String.t(), role: atom() | String.t()}- # DEPRECATED: to be removed together with `Teams.Management.Layout.persist/2`,- # its only caller outside tests. Use `invite_all/4` + `send_invitation_emails/1`- # instead. `invite_all/4` duplicates this function's body on purpose, so that- # this one can be deleted as-is once nothing calls it anymore.- def invite(team, inviter, invitee_email, role, opts \\ [])-- def invite(team, inviter, invitee_email, role, opts) when role in @valid_roles do- with team <- Repo.preload(team, [:owners]),- :ok <- Teams.Invitations.check_invitation_permissions(team, inviter, role, opts),- :ok <- Teams.Invitations.check_team_member_limit(team, role, invitee_email),- invitee = Plausible.Auth.find_user_by(email: invitee_email),- :ok <- Teams.Invitations.ensure_new_membership(team, invitee, role),- {:ok, invitation} <- Teams.Invitations.invite(team, invitee_email, role, inviter) do- if Keyword.get(opts, :send_email?, true) do- send_invitation_email(invitation, invitee)- end-- {:ok, invitation}- end- end-- def invite(_team, _inviter, _invitee_email, role, _opts) do- raise "Invalid role passed: #{inspect(role)}"- end-@doc """Creates team invitations for all given entries in a single transaction.Either all of them get created, or none. Does not send any emails yet.@@ -96,11 +68,11 @@ defmodule Plausible.Teams.Invitations.InviteToTeam dodefp do_invite(team, inviter, invitee_email, role) dowith :ok <-- Teams.TeamRolePermissions.ensure_can_grant_for_invitation(team, inviter, nil, role),+ Teams.TeamRolePermissions.ensure_can_invite(team, inviter, role),:ok <- Teams.Invitations.check_team_member_limit(team, role, invitee_email),invitee = Plausible.Auth.find_user_by(email: invitee_email),:ok <- Teams.Invitations.ensure_new_membership(team, invitee, role),- :ok <- Teams.Invitations.ensure_not_already_invited(team, invitee_email) do+ :ok <- Teams.Invitations.ensure_no_invitations(team, invitee_email) doTeams.Invitations.invite(team, invitee_email, role, inviter)endenddiff --git a/lib/plausible/teams/invitations/update_role.ex b/lib/plausible/teams/invitations/update_role.exindex 072626e39c..c01213ccd0 100644--- a/lib/plausible/teams/invitations/update_role.ex+++ b/lib/plausible/teams/invitations/update_role.ex@@ -21,7 +21,7 @@ defmodule Plausible.Teams.Invitations.UpdateRole dowith {:ok, invitation} <- Teams.Invitations.get_team_invitation(team, invitation_id),:ok <- ensure_team_invitation(invitation),:ok <-- Teams.TeamRolePermissions.ensure_can_grant_for_invitation(+ Teams.TeamRolePermissions.ensure_can_change_invitation_role(team,current_user,invitation,diff --git a/lib/plausible/teams/management/layout.ex b/lib/plausible/teams/management/layout.exdeleted file mode 100644index 15b113c422..0000000000--- a/lib/plausible/teams/management/layout.ex+++ /dev/null@@ -1,187 +0,0 @@-defmodule Plausible.Teams.Management.Layout do- @moduledoc """- Abstraction for team membership(s) layout - provides a high level CRUD for- setting up team memberships, including invitations. Persisting the layout,- effectively takes care of delegating the operations to specialized services- and sending out e-mail notifications on success, if need be.- To be used in UIs allowing team memberships adjustments.- """- alias Plausible.Teams- alias Plausible.Teams.Management.Layout.Entry- alias Plausible.Repo- alias Plausible.Auth.User-- @type t() :: %{String.t() => Entry.t()}-- @spec init(Teams.Team.t()) :: t()- def init(%Teams.Team{} = team) do- invitations_sent = Teams.Invitations.pending_team_invitations_for(team)- all_members = Teams.Memberships.all(team)- build_by_email(invitations_sent ++ all_members)- end-- @spec build_by_email([Teams.Invitation.t() | Teams.Membership.t()]) ::- t()- def build_by_email(entities) do- Enum.reduce(entities, %{}, fn- %Teams.Invitation{} = invitation, acc ->- Map.put(acc, invitation.email, Entry.new(invitation))-- %Teams.Membership{} = membership, acc ->- Map.put(- acc,- membership.user.email,- Entry.new(membership)- )- end)- end-- @spec active_count(t()) :: non_neg_integer()- def active_count(layout) do- Enum.count(layout, fn {_, entry} -> entry.queued_op != :delete end)- end-- @spec owners_count(t()) :: non_neg_integer()- def owners_count(layout) do- Enum.count(layout, fn {_, entry} -> entry.queued_op != :delete and entry.role == :owner end)- end-- @spec has_guests?(t()) :: boolean()- def has_guests?(layout) do- not is_nil(- Enum.find(- layout,- fn- {_, entry} -> entry.role == :guest and entry.queued_op != :delete- end- )- )- end-- @spec update_role(t(), String.t(), atom()) :: t()- def update_role(layout, email, role) do- entry = Map.fetch!(layout, email)- Map.put(layout, email, Entry.patch(entry, role: role, queued_op: :update))- end-- @spec schedule_send(t(), String.t(), atom(), Keyword.t()) :: t()- def schedule_send(layout, email, role, entry_attrs \\ []) do- invitation = %Teams.Invitation{email: email, role: role}- Map.put(layout, email, Entry.new(invitation, Keyword.merge(entry_attrs, queued_op: :send)))- end-- @spec schedule_delete(t(), String.t()) :: t()- def schedule_delete(layout, email) do- entry = Map.fetch!(layout, email)- Map.put(layout, email, Entry.patch(entry, queued_op: :delete))- end-- @spec verify_removable(t(), String.t()) :: :ok | {:error, String.t()}- def verify_removable(layout, email) do- ensure_at_least_one_owner(layout, email)- end-- @spec removable?(t(), String.t()) :: boolean()- def removable?(layout, email) do- verify_removable(layout, email) == :ok- end-- @spec sorted_for_display(t()) :: [{String.t(), Entry.t()}]- def sorted_for_display(layout) do- layout- |> Enum.reject(fn {_, entry} -> entry.queued_op == :delete end)- |> Enum.sort_by(fn {email, entry} ->- primary_criterion =- case entry do- %{role: :guest, type: :invitation_pending} -> 10- %{role: :guest, type: :invitation_sent} -> 11- %{role: :guest, type: :membership} -> 12- %{type: :invitation_pending} -> 0- %{type: :invitation_sent} -> 1- %{type: :membership} -> 2- end-- secondary_criterion = entry.name- tertiary_criterion = email- {primary_criterion, secondary_criterion, tertiary_criterion}- end)- end-- @spec persist(t(), %{- required(:current_user) => User.t(),- required(:current_team) => Teams.Team.t(),- optional(:name_changeset) => Ecto.Changeset.t()- }) :: {:ok, integer()} | {:error, any()}- def persist(layout, context) do- result =- Repo.transaction(fn ->- # An optional :name_changeset commits the team's own rename together- # with its membership/invitation changes, in the same transaction -- # so a name change can never persist on its own if anything below it- # fails (e.g. team_setup.ex renaming a team as part of its creation).- team =- case Map.get(context, :name_changeset) do- nil -> context.current_team- name_changeset -> Repo.update!(name_changeset)- end-- Teams.complete_setup(team)-- layout- |> sorted_for_persistence()- |> Enum.reduce([], fn {_, entry}, acc ->- persist_entry(entry, %{context | current_team: team}, acc)- end)- end)-- case result do- {:ok, persisted} ->- persisted- |> Enum.each(fn- {%Entry{type: :invitation_pending}, invitation} ->- invitee = Plausible.Auth.find_user_by(email: invitation.email)- Teams.Invitations.InviteToTeam.send_invitation_email(invitation, invitee)-- {%Entry{type: :membership, queued_op: :delete}, team_membership} ->- Teams.Memberships.Remove.send_team_member_removed_email(team_membership)-- _ ->- :noop- end)-- {:ok, length(persisted)}-- {:error, _} = error ->- error- end- end-- defp sorted_for_persistence(layout) do- # sort by deletions first, so team member limits are triggered accurately- Enum.sort_by(layout, fn {_email, entry} ->- case entry.queued_op do- :delete -> 0- _ -> 1- end- end)- end-- defp ensure_at_least_one_owner(layout, email) do- if Enum.find(layout, fn {_email, entry} ->- entry.email != email and- entry.role == :owner and- entry.type == :membership and- entry.queued_op != :delete- end),- do: :ok,- else: {:error, "The team has to have at least one owner"}- end-- def persist_entry(entry, context, acc) do- case Entry.persist(entry, context) do- {:ok, :ignore} -> acc- {:ok, persist_result} -> [{entry, persist_result} | acc]- {:error, error} -> Repo.rollback(error)- end- end-enddiff --git a/lib/plausible/teams/management/layout/entry.ex b/lib/plausible/teams/management/layout/entry.exdeleted file mode 100644index 30da6c735e..0000000000--- a/lib/plausible/teams/management/layout/entry.ex+++ /dev/null@@ -1,123 +0,0 @@-defmodule Plausible.Teams.Management.Layout.Entry do- @moduledoc """- Module representing a single Team Layout element and all its state- transitions, including persistence options.- """- alias Plausible.Teams-- defstruct [:email, :name, :role, :type, :meta, :queued_op, :id]-- @type t() :: %__MODULE__{}-- @spec new(Teams.Invitation.t() | Teams.Membership.t(), Keyword.t()) :: t()- def new(object, attrs \\ [])-- def new(- %Teams.Invitation{id: existing} = invitation,- attrs- )- when is_integer(existing) do- %__MODULE__{- name: "Invited User",- id: 0,- email: invitation.email,- role: invitation.role,- type: :invitation_sent,- meta: invitation- }- |> Map.merge(Enum.into(attrs, %{}))- end-- def new(%Teams.Invitation{id: nil} = pending, attrs) do- %__MODULE__{- name: "Invited User",- id: 0,- email: pending.email,- role: pending.role,- type: :invitation_pending,- meta: pending- }- |> Map.merge(Enum.into(attrs, %{}))- end-- def new(%Teams.Membership{} = membership, attrs) do- %__MODULE__{- name: membership.user.name,- role: membership.role,- id: membership.user.id,- email: membership.user.email,- type: :membership,- meta: membership- }- |> Map.merge(Enum.into(attrs, %{}))- end-- @spec patch(t(), Keyword.t()) :: t()- def patch(%__MODULE__{} = entry, attrs) do- struct!(entry, attrs)- end-- @spec persist(t(), map()) ::- {:ok, :ignore | Teams.Invitation.t() | Teams.Membership.t()} | {:error, any()}- def persist(%__MODULE__{queued_op: nil}, _context) do- {:ok, :ignore}- end-- def persist(%__MODULE__{type: :invitation_pending, queued_op: :delete}, _context) do- {:ok, :ignore}- end-- def persist(- %__MODULE__{email: email, role: role, type: :invitation_pending, queued_op: op},- context- )- when op in [:update, :send] do- Teams.Invitations.InviteToTeam.invite(context.current_team, context.current_user, email, role,- send_email?: false- )- end-- def persist(- %__MODULE__{type: :invitation_sent, email: email, role: role, queued_op: :update},- context- ) do- Teams.Invitations.InviteToTeam.invite(context.current_team, context.current_user, email, role,- send_email?: false- )- end-- def persist(- %__MODULE__{type: :invitation_sent, queued_op: :delete, meta: meta},- context- ) do- Plausible.Teams.Invitations.RemoveFromTeam.remove(- context.current_team,- meta.invitation_id,- context.current_user- )- end-- def persist(- %__MODULE__{type: :membership, queued_op: :delete, meta: meta},- context- ) do- Plausible.Teams.Memberships.Remove.remove(- context.current_team,- meta.user.id,- context.current_user,- send_email?: false- )- end-- def persist(- %__MODULE__{type: :membership, queued_op: :update, role: role, meta: meta},- context- ) do- Plausible.Teams.Memberships.UpdateRole.update(- context.current_team,- meta.user.id,- role,- context.current_user- )- end-enddiff --git a/lib/plausible/teams/management/roster.ex b/lib/plausible/teams/management/roster.exnew file mode 100644index 0000000000..57d982e9ca--- /dev/null+++ b/lib/plausible/teams/management/roster.ex@@ -0,0 +1,71 @@+defmodule Plausible.Teams.Management.Roster do+ @moduledoc """+ Read-only list of a team's members and pending invitations, keyed by e-mail,+ for rendering the team management screen.+ """++ alias Plausible.Teams+ alias Plausible.Teams.Management.Roster.Entry++ @type t() :: %{String.t() => Entry.t()}++ @spec init(Teams.Team.t()) :: t()+ def init(%Teams.Team{} = team) do+ invitations = Teams.Invitations.pending_team_invitations_for(team)+ memberships = Teams.Memberships.all(team)+ build_by_email(invitations ++ memberships)+ end++ @spec build_by_email([Teams.Invitation.t() | Teams.Membership.t()]) :: t()+ def build_by_email(entities) do+ Map.new(entities, fn entity ->+ entry = Entry.new(entity)+ {entry.email, entry}+ end)+ end++ @spec owners_count(t()) :: non_neg_integer()+ def owners_count(roster) do+ Enum.count(roster, fn {_, entry} -> entry.role == :owner end)+ end++ @doc """+ The users of the roster's memberships. Pending invitations have no user yet,+ so they're left out.+ """+ @spec users(t()) :: [Plausible.Auth.User.t()]+ def users(roster) do+ for {_, %Entry{source: %Teams.Membership{user: user}}} <- roster, do: user+ end++ @spec has_guests?(t()) :: boolean()+ def has_guests?(roster) do+ Enum.any?(roster, fn {_, entry} -> entry.role == :guest end)+ end++ @doc """+ Whether the entry can be removed without leaving the team without an owner.+ Only a hint for rendering: the services doing the removal check this again.+ """+ @spec removable?(t(), String.t()) :: boolean()+ def removable?(roster, email) do+ Enum.any?(roster, fn {_, entry} ->+ entry.email != email and entry.role == :owner and not Entry.invitation?(entry)+ end)+ end++ @spec sorted_for_display(t()) :: [{String.t(), Entry.t()}]+ def sorted_for_display(roster) do+ Enum.sort_by(roster, fn {email, entry} ->+ primary_criterion =+ case {entry.role, Entry.invitation?(entry)} do+ {:guest, true} -> 11+ {:guest, false} -> 12+ {_, true} -> 1+ {_, false} -> 2+ end++ {primary_criterion, entry.name, email}+ end)+ end+enddiff --git a/lib/plausible/teams/management/roster/entry.ex b/lib/plausible/teams/management/roster/entry.exnew file mode 100644index 0000000000..c1abee5c01--- /dev/null+++ b/lib/plausible/teams/management/roster/entry.ex@@ -0,0 +1,39 @@+defmodule Plausible.Teams.Management.Roster.Entry do+ @moduledoc """+ A single member or pending invitation in a `Plausible.Teams.Management.Roster`.+ `source` is the membership or invitation struct the entry was built from.+ """+ alias Plausible.Teams++ defstruct [:email, :name, :role, :source]++ @type t() :: %__MODULE__{+ email: String.t(),+ name: String.t(),+ role: Teams.Membership.role(),+ source: Teams.Membership.t() | Teams.Invitation.t()+ }++ @spec new(Teams.Invitation.t() | Teams.Membership.t()) :: t()+ def new(%Teams.Invitation{} = invitation) do+ %__MODULE__{+ name: "Invited User",+ email: invitation.email,+ role: invitation.role,+ source: invitation+ }+ end++ def new(%Teams.Membership{} = membership) do+ %__MODULE__{+ name: membership.user.name,+ role: membership.role,+ email: membership.user.email,+ source: membership+ }+ end++ @spec invitation?(t()) :: boolean()+ def invitation?(%__MODULE__{source: %Teams.Invitation{}}), do: true+ def invitation?(%__MODULE__{source: %Teams.Membership{}}), do: false+enddiff --git a/lib/plausible/teams/memberships/update_role.ex b/lib/plausible/teams/memberships/update_role.exindex 4ccbc4590f..0e1449bc40 100644--- a/lib/plausible/teams/memberships/update_role.ex+++ b/lib/plausible/teams/memberships/update_role.ex@@ -12,7 +12,7 @@ defmodule Plausible.Teams.Memberships.UpdateRole dodef update(%Teams.Team{} = team, user_id, new_role, current_user) dowith {:ok, team_membership} <- Memberships.get_team_membership(team, user_id),:ok <-- Teams.TeamRolePermissions.ensure_can_grant_for_member(+ Teams.TeamRolePermissions.ensure_can_change_member_role(team,current_user,team_membership,diff --git a/lib/plausible/teams/team_role_permissions.ex b/lib/plausible/teams/team_role_permissions.exindex a5d0129db2..b660afd60f 100644--- a/lib/plausible/teams/team_role_permissions.ex+++ b/lib/plausible/teams/team_role_permissions.ex@@ -1,10 +1,12 @@defmodule Plausible.Teams.TeamRolePermissions do@moduledoc """- Rules for who is allowed to give which team role to whom.+ Rules for who is allowed to change which team roles.- Split into two independent questions: whose role the granter may change- at all (`ensure_can_change_role/3`), and which roles they may give- (`ensure_can_grant_role/2`). A change is allowed when both pass.+ A role change is allowed when the actor may modify the member or invitation+ in its current role (`can_modify_member?/2`, `can_modify_invitation?/2`),+ and may assign the new role (`can_assign?/2`). The `ensure_*` functions+ combine both for the services that make the change, and deny anyone who+ isn't a member of the team.Rules that depend on the team's state rather than on who's asking (thelast owner can't be demoted, owners need 2FA when the team enforces it,@@ -19,8 +21,6 @@ defmodule Plausible.Teams.TeamRolePermissions do@assignable_roles List.delete(@roles, :guest)@assignable_by_admins List.delete(@assignable_roles, :owner)- @types [:membership, :invitation]-@type assignable_role() :: :owner | :admin | :editor | :viewer | :billing@doc """@@ -31,102 +31,107 @@ defmodule Plausible.Teams.TeamRolePermissions dodef can_manage_team?(role), do: role in [:owner, :admin]@doc """- Checks whether `granter` may change `membership`'s role to `to_role`.+ Checks whether `actor` may change `membership`'s role to `new_role`.Changing your own role follows the same rules as changing the role ofsomeone who has the same role as you."""- @spec ensure_can_grant_for_member(+ @spec ensure_can_change_member_role(Teams.Team.t(),Auth.User.t(),Membership.t(),assignable_role()) :: :ok | {:error, :permission_denied}- def ensure_can_grant_for_member(team, granter, %Membership{} = membership, to_role) do- with {:ok, granter_role} <- get_granter_role(team, granter),- :ok <- ensure_can_change_role(:membership, granter_role, membership.role) do- ensure_can_grant_role(granter_role, to_role)+ def ensure_can_change_member_role(team, actor, %Membership{role: current_role}, new_role) do+ with {:ok, actor_role} <- Teams.Memberships.team_role(team, actor),+ true <- can_modify_member?(actor_role, current_role),+ true <- can_assign?(actor_role, new_role) do+ :ok+ else+ _ -> {:error, :permission_denied}endend@doc """- Checks whether `granter` may give a team invitation the role `to_role`.- `invitation` is the pending invitation being changed, or `nil` when a new- invitation is being created.+ Checks whether `actor` may change a pending team invitation's role to+ `new_role`."""- @spec ensure_can_grant_for_invitation(+ @spec ensure_can_change_invitation_role(Teams.Team.t(),Auth.User.t(),- Teams.Invitation.t() | nil,+ Teams.Invitation.t(),assignable_role()) :: :ok | {:error, :permission_denied}- def ensure_can_grant_for_invitation(team, granter, invitation, to_role) do- with {:ok, granter_role} <- get_granter_role(team, granter),- :ok <- ensure_can_change_role(:invitation, granter_role, invitation_role(invitation)) do- ensure_can_grant_role(granter_role, to_role)+ def ensure_can_change_invitation_role(+ team,+ actor,+ %Teams.Invitation{role: current_role},+ new_role+ ) do+ with {:ok, actor_role} <- Teams.Memberships.team_role(team, actor),+ true <- can_modify_invitation?(actor_role, current_role),+ true <- can_assign?(actor_role, new_role) do+ :ok+ else+ _ -> {:error, :permission_denied}endend@doc """- Checks whether someone with `granter_role` may change the role of a membership- or an invitation. `current_role` is `nil` when a new invitation is being- created.+ Checks whether `actor` may invite someone to the team with `role`."""- @spec ensure_can_change_role(- :membership | :invitation,- Membership.role(),- Membership.role() | nil- ) ::+ @spec ensure_can_invite(Teams.Team.t(), Auth.User.t(), assignable_role()) :::ok | {:error, :permission_denied}- def ensure_can_change_role(type, granter_role, current_role)-- def ensure_can_change_role(type, _granter_role, _current_role) when type not in @types,- do: raise(ArgumentError, "unknown type: #{inspect(type)}")-- def ensure_can_change_role(_type, :owner, _current_role), do: :ok-- # Creating a new invitation: there's nobody whose role would change yet- def ensure_can_change_role(:invitation, :admin, nil), do: :ok+ def ensure_can_invite(team, actor, role) do+ with {:ok, actor_role} <- Teams.Memberships.team_role(team, actor),+ true <- can_assign?(actor_role, role) do+ :ok+ else+ _ -> {:error, :permission_denied}+ end+ end- def ensure_can_change_role(_type, :admin, current_role)- when current_role in [:admin, :editor, :viewer],- do: :ok+ @doc """+ Whether someone with `actor_role` may give anyone the role `new_role`.+ A role that can't be assigned (anything other than owner, admin, editor,+ viewer or billing) raises an `ArgumentError`, whoever is asking.+ """+ @spec can_assign?(Membership.role(), assignable_role()) :: boolean()+ def can_assign?(actor_role, new_role)- # Admins can't change a billing member's role: billing members have access to- # the subscription, which admins don't. A pending billing invitation doesn't- # give access to anything yet, so admins can change it like any other- # non-owner invitation.- def ensure_can_change_role(:invitation, :admin, :billing), do: :ok+ def can_assign?(_actor_role, new_role) when new_role not in @assignable_roles,+ do: raise(ArgumentError, "invalid role: #{inspect(new_role)}")- def ensure_can_change_role(_type, _granter_role, _current_role),- do: {:error, :permission_denied}+ def can_assign?(:owner, _new_role), do: true+ def can_assign?(:admin, new_role), do: new_role in @assignable_by_admins+ def can_assign?(_actor_role, _new_role), do: false@doc """- Checks whether someone with `granter_role` may give anyone the role `to_role`.- A role that can't be assigned (anything other than owner, admin, editor,- viewer or billing) raises an `ArgumentError`, whoever is asking.+ Whether someone with `actor_role` may change the role of a member whose+ role is currently `current_role`."""- @spec ensure_can_grant_role(Membership.role(), assignable_role()) ::- :ok | {:error, :permission_denied}- def ensure_can_grant_role(granter_role, to_role)+ @spec can_modify_member?(Membership.role(), Membership.role()) :: boolean()+ def can_modify_member?(actor_role, current_role)- def ensure_can_grant_role(_granter_role, to_role) when to_role not in @assignable_roles,- do: raise(ArgumentError, "invalid role: #{inspect(to_role)}")+ def can_modify_member?(:owner, _current_role), do: true+ def can_modify_member?(:admin, current_role), do: current_role in [:admin, :editor, :viewer]+ def can_modify_member?(_actor_role, _current_role), do: false- def ensure_can_grant_role(:owner, _to_role), do: :ok- def ensure_can_grant_role(:admin, to_role) when to_role in @assignable_by_admins, do: :ok+ @doc """+ Whether someone with `actor_role` may change the role of a pending+ invitation whose role is currently `current_role`.- def ensure_can_grant_role(_granter_role, _to_role),- do: {:error, :permission_denied}+ Unlike billing members, admins may change pending billing invitations:+ billing members have access to the subscription, which admins don't, but a+ pending billing invitation doesn't give access to anything yet.+ """+ @spec can_modify_invitation?(Membership.role(), Membership.role()) :: boolean()+ def can_modify_invitation?(actor_role, current_role)- defp invitation_role(nil), do: nil- defp invitation_role(%Teams.Invitation{role: role}), do: role+ def can_modify_invitation?(:owner, _current_role), do: true- # Not being a member of the team counts as not having permission- defp get_granter_role(team, granter) do- case Teams.Memberships.team_role(team, granter) do- {:ok, granter_role} -> {:ok, granter_role}- {:error, :not_a_member} -> {:error, :permission_denied}- end- end+ def can_modify_invitation?(:admin, current_role),+ do: current_role in [:admin, :editor, :viewer, :billing]++ def can_modify_invitation?(_actor_role, _current_role), do: falseenddiff --git a/lib/plausible_web/live/components/team.ex b/lib/plausible_web/live/components/team.exindex d34fac2d2b..442743da61 100644--- a/lib/plausible_web/live/components/team.ex+++ b/lib/plausible_web/live/components/team.ex@@ -205,7 +205,7 @@ defmodule PlausibleWeb.Live.Components.Team dodefp selectable_role_descriptions(my_role) doEnum.filter(@role_descriptions, fn {role, _description} ->- TeamRolePermissions.ensure_can_grant_role(my_role, role) == :ok+ TeamRolePermissions.can_assign?(my_role, role)end)enddiff --git a/lib/plausible_web/live/team_management.ex b/lib/plausible_web/live/team_management.exindex 22b66f985a..a8ce0f32b9 100644--- a/lib/plausible_web/live/team_management.ex+++ b/lib/plausible_web/live/team_management.ex@@ -9,7 +9,7 @@ defmodule PlausibleWeb.Live.TeamManagement doalias Plausible.Auth.Userimport PlausibleWeb.Live.Components.Team- alias Plausible.Teams.Management.Layout+ alias Plausible.Teams.Management.Rosterdef mount(_params, _session, socket) do{:ok, reset(socket)}@@ -18,12 +18,12 @@ defmodule PlausibleWeb.Live.TeamManagement dodefp reset(%{assigns: %{current_user: current_user, current_team: current_team}} = socket) do{:ok, my_role} = Teams.Memberships.team_role(current_team, current_user)- layout = Layout.init(current_team)+ roster = Roster.init(current_team)team_members_limit = Plausible.Teams.Billing.team_member_limit(current_team)assign(socket,team_members_limit: team_members_limit,- layout: layout,+ roster: roster,my_role: my_role,input_email: "")@@ -34,7 +34,7 @@ defmodule PlausibleWeb.Live.TeamManagement do<.flash_messages flash={@flash} /><PlausibleWeb.Components.Billing.Notice.limit_exceeded- :if={@team_members_limit != 0 and at_limit?(@layout, @team_members_limit)}+ :if={@team_members_limit != 0 and at_limit?(@roster, @team_members_limit)}current_user={@current_user}current_team={@current_team}limit={@team_members_limit}@@ -52,7 +52,7 @@ defmodule PlausibleWeb.Live.TeamManagement doplaceholder="Enter e-mail"phx-debounce={200}readonly={- at_limit?(@layout, @team_members_limit) or+ at_limit?(@roster, @team_members_limit) ornot TeamRolePermissions.can_manage_team?(@my_role)}/>@@ -69,7 +69,7 @@ defmodule PlausibleWeb.Live.TeamManagement doid="invite-member"type="submit"disabled={- at_limit?(@layout, @team_members_limit) or+ at_limit?(@roster, @team_members_limit) ornot TeamRolePermissions.can_manage_team?(@my_role)}>@@ -80,23 +80,23 @@ defmodule PlausibleWeb.Live.TeamManagement do<div id="member-list"><.member- :for={{email, entry} <- Layout.sorted_for_display(@layout)}+ :for={{email, entry} <- Roster.sorted_for_display(@roster)}:if={entry.role != :guest}user={%User{email: entry.email, name: entry.name}}role={entry.role}label={entry_label(entry, @current_user)}- me?={entry.id == @current_user.id}- pending?={entry.type in [:invitation_pending, :invitation_sent]}+ me?={me?(entry, @current_user)}+ pending?={Roster.Entry.invitation?(entry)}my_role={@my_role}- remove_disabled={not Layout.removable?(@layout, email)}+ remove_disabled={not Roster.removable?(@roster, email)}disabled={- (entry.role == :owner && Layout.owners_count(@layout) == 1) or+ (entry.role == :owner && Roster.owners_count(@roster) == 1) ornot TeamRolePermissions.can_manage_team?(@my_role)}/></div>- <div :if={Layout.has_guests?(@layout)} class="flex items-center mt-4 mb-4" id="guests-hr">+ <div :if={Roster.has_guests?(@roster)} class="flex items-center mt-4 mb-4" id="guests-hr"><hr class="grow border-t border-gray-200 dark:border-gray-700" /><span class="mx-4 text-gray-500 text-sm">Guests@@ -104,17 +104,17 @@ defmodule PlausibleWeb.Live.TeamManagement do<hr class="grow border-t border-gray-200 dark:border-gray-700" /></div>- <div :if={Layout.has_guests?(@layout)} id="guest-list">+ <div :if={Roster.has_guests?(@roster)} id="guest-list"><.member- :for={{email, entry} <- Layout.sorted_for_display(@layout)}+ :for={{email, entry} <- Roster.sorted_for_display(@roster)}:if={entry.role == :guest}user={%User{email: entry.email, name: entry.name}}role={entry.role}label={entry_label(entry, @current_user)}- pending?={entry.type in [:invitation_pending, :invitation_sent]}+ pending?={Roster.Entry.invitation?(entry)}my_role={@my_role}- remove_disabled={not Layout.removable?(@layout, email)}- role_change_disabled={entry.type in [:invitation_pending, :invitation_sent]}+ remove_disabled={not Roster.removable?(@roster, email)}+ role_change_disabled={Roster.Entry.invitation?(entry)}disabled={not TeamRolePermissions.can_manage_team?(@my_role)}/></div>@@ -122,10 +122,6 @@ defmodule PlausibleWeb.Live.TeamManagement do"""end- @permission_denied_message "Permission denied"- @not_found_message "This member or invitation doesn't exist anymore. Please reload the page"- @only_one_owner_message "The team has to have at least one owner"-def handle_event("form-changed", params, socket) do{:noreply, assign(socket, input_email: params["input-email"])}end@@ -140,65 +136,48 @@ defmodule PlausibleWeb.Live.TeamManagement dosocket = assign(socket, input_email: email)socket =- case Teams.Invitations.InviteToTeam.invite_all(reload(team), current_user, [+ case Teams.Invitations.InviteToTeam.invite_all(reload!(team), current_user, [%{email: email, role: role}]) do{:ok, invitations} ->Teams.Invitations.InviteToTeam.send_invitation_emails(invitations)socket |> reset() |> put_live_flash(:success, "#{email} has been invited")- {:error, reason} when reason in [:invalid_email, :already_a_member, :already_invited] ->- put_live_flash(- socket,- :error,- "Make sure the e-mail is valid and not already taken by an existing member or invitation"- )-- {:error, :already_a_guest} ->- put_live_flash(- socket,- :error,- "This e-mail belongs to a guest. Please change their role below, or delete and invite them again."- )-- {:error, :already_invited_guest} ->- put_live_flash(- socket,- :error,- "This e-mail is already invited as a guest. To invite them to the team, please delete the guest invitation first."- )-- {:error, :permission_denied} ->- put_live_flash(socket, :error, @permission_denied_message)-- {:error, {:over_limit, limit}} ->- put_live_flash(- socket,- :error,- "Your account is limited to #{limit} team members. You can upgrade your plan to increase this limit"- )+ {:error, reason}+ when reason in [+ :invalid_email,+ :already_a_member,+ :invited_as_member,+ :already_a_guest,+ :invited_as_guest,+ :permission_denied+ ] ->+ put_error_flash(socket, reason)++ {:error, {:over_limit, _limit} = reason} ->+ put_error_flash(socket, reason)end{:noreply, socket}end- def handle_event("remove-member", %{"email" => email}, %{assigns: %{layout: layout}} = socket) do- {:noreply, remove(socket, Map.fetch!(layout, email))}+ def handle_event("remove-member", %{"email" => email}, %{assigns: %{roster: roster}} = socket) do+ {:noreply, remove(socket, Map.fetch!(roster, email))}enddef handle_event("update-role",%{"email" => email, "role" => role},- %{assigns: %{layout: layout}} = socket+ %{assigns: %{roster: roster}} = socket) do- {:noreply, update_role(socket, Map.fetch!(layout, email), role_to_atom(role))}+ {:noreply, update_role(socket, Map.fetch!(roster, email), role_to_atom(role))}end- defp remove(socket, %Layout.Entry{type: :membership, meta: membership}) do+ defp remove(socket, %Roster.Entry{source: %Teams.Membership{} = membership}) do%{current_team: team, current_user: current_user} = socket.assignsmyself? = membership.user.id == current_user.id- case Teams.Memberships.Remove.remove(reload(team), membership.user.id, current_user) do+ case Teams.Memberships.Remove.remove(reload!(team), membership.user.id, current_user) do{:ok, _} when myself? ->socket|> put_flash(:success, "You have left the team")@@ -209,22 +188,17 @@ defmodule PlausibleWeb.Live.TeamManagement do|> reset()|> put_live_flash(:success, "#{membership.user.email} has been removed from the team")- {:error, :membership_not_found} ->- put_live_flash(socket, :error, @not_found_message)-- {:error, reason} when reason in [:permission_denied, :not_a_member] ->- put_live_flash(socket, :error, @permission_denied_message)-- {:error, :only_one_owner} ->- put_live_flash(socket, :error, @only_one_owner_message)+ {:error, reason}+ when reason in [:membership_not_found, :permission_denied, :not_a_member, :only_one_owner] ->+ put_error_flash(socket, reason)endend- defp remove(socket, %Layout.Entry{type: :invitation_sent, meta: invitation}) do+ defp remove(socket, %Roster.Entry{source: %Teams.Invitation{} = invitation}) do%{current_team: team, current_user: current_user} = socket.assignscase Teams.Invitations.RemoveFromTeam.remove(- reload(team),+ reload!(team),invitation.invitation_id,current_user) do@@ -233,15 +207,13 @@ defmodule PlausibleWeb.Live.TeamManagement do|> reset()|> put_live_flash(:success, "The invitation for #{invitation.email} has been removed")- {:error, :invitation_not_found} ->- put_live_flash(socket, :error, @not_found_message)-- {:error, reason} when reason in [:permission_denied, :not_a_member] ->- put_live_flash(socket, :error, @permission_denied_message)+ {:error, reason}+ when reason in [:invitation_not_found, :permission_denied, :not_a_member] ->+ put_error_flash(socket, reason)endend- defp update_role(socket, %Layout.Entry{type: :membership, meta: membership}, role) do+ defp update_role(socket, %Roster.Entry{source: %Teams.Membership{} = membership}, role) do%{current_team: team, current_user: current_user} = socket.assignsdemoting_myself? =@@ -249,7 +221,7 @@ defmodule PlausibleWeb.Live.TeamManagement donot TeamRolePermissions.can_manage_team?(role)case Teams.Memberships.UpdateRole.update(- reload(team),+ reload!(team),membership.user.id,role,current_user@@ -268,25 +240,17 @@ defmodule PlausibleWeb.Live.TeamManagement do)|> animate_role_change(membership.user.email)- {:error, :membership_not_found} ->- put_live_flash(socket, :error, @not_found_message)-- {:error, :permission_denied} ->- put_live_flash(socket, :error, @permission_denied_message)-- {:error, :only_one_owner} ->- put_live_flash(socket, :error, @only_one_owner_message)-- {:error, :disabled_2fa} ->- put_live_flash(socket, :error, "User must have 2FA enabled to become an owner")+ {:error, reason}+ when reason in [:membership_not_found, :permission_denied, :only_one_owner, :disabled_2fa] ->+ put_error_flash(socket, reason)endend- defp update_role(socket, %Layout.Entry{type: :invitation_sent, meta: invitation}, role) do+ defp update_role(socket, %Roster.Entry{source: %Teams.Invitation{} = invitation}, role) do%{current_team: team, current_user: current_user} = socket.assignscase Teams.Invitations.UpdateRole.update(- reload(team),+ reload!(team),invitation.invitation_id,role,current_user@@ -300,21 +264,47 @@ defmodule PlausibleWeb.Live.TeamManagement do)|> animate_role_change(invitation.email)- {:error, :invitation_not_found} ->- put_live_flash(socket, :error, @not_found_message)-- {:error, :guest_invitation} ->- put_live_flash(- socket,- :error,- "A guest invitation can't be changed into a team invitation. Remove it and send a team invitation instead"- )-- {:error, :permission_denied} ->- put_live_flash(socket, :error, @permission_denied_message)+ {:error, reason}+ when reason in [:invitation_not_found, :guest_invitation, :permission_denied] ->+ put_error_flash(socket, reason)endend+ defp put_error_flash(socket, reason) do+ put_live_flash(socket, :error, error_message(reason))+ end++ defp error_message(reason) when reason in [:membership_not_found, :invitation_not_found],+ do: "This member or invitation doesn't exist anymore. Please reload the page"++ defp error_message(reason) when reason in [:permission_denied, :not_a_member],+ do: "Permission denied"++ defp error_message(reason)+ when reason in [:invalid_email, :already_a_member, :invited_as_member],+ do:+ "Make sure the e-mail is valid and not already taken by an existing member or invitation"++ defp error_message(:already_a_guest),+ do:+ "This e-mail belongs to a guest. Please change their role below, or delete and invite them again."++ defp error_message(:invited_as_guest),+ do:+ "This e-mail is already invited as a guest. To invite them to the team, please delete the guest invitation first."++ defp error_message(:guest_invitation),+ do:+ "A guest invitation can't be changed into a team invitation. Remove it and send a team invitation instead"++ defp error_message(:only_one_owner), do: "The team has to have at least one owner"++ defp error_message(:disabled_2fa), do: "User must have 2FA enabled to become an owner"++ defp error_message({:over_limit, limit}),+ do:+ "Your account is limited to #{limit} team members. You can upgrade your plan to increase this limit"+defp animate_role_change(socket, email) dopush_event(socket, "js-exec", %{to: "#member-row-#{:erlang.phash2(email)}",@@ -322,24 +312,26 @@ defmodule PlausibleWeb.Live.TeamManagement do})end- defp reload(team), do: Plausible.Repo.reload!(team)+ defp reload!(team), do: Plausible.Repo.reload!(team)defp role_name(role), do: role |> to_string() |> String.capitalize()- defp entry_label(%Layout.Entry{role: :guest, type: :membership}, _), do: nil- defp entry_label(%Layout.Entry{type: :invitation_pending}, _), do: "Invitation pending"- defp entry_label(%Layout.Entry{type: :invitation_sent}, _), do: "Invitation sent"+ defp entry_label(%Roster.Entry{role: :guest, source: %Teams.Membership{}}, _), do: nil+ defp entry_label(%Roster.Entry{source: %Teams.Invitation{}}, _), do: "Invitation sent"- defp entry_label(%Layout.Entry{meta: %{user: %{id: id, type: :sso}}}, %{id: id}),+ defp entry_label(%Roster.Entry{source: %{user: %{id: id, type: :sso}}}, %{id: id}),do: "You (SSO)"- defp entry_label(%Layout.Entry{meta: %{user: %{id: id}}}, %{id: id}), do: "You"- defp entry_label(%Layout.Entry{meta: %{user: %{type: :sso}}}, _), do: "SSO"+ defp entry_label(%Roster.Entry{source: %{user: %{id: id}}}, %{id: id}), do: "You"+ defp entry_label(%Roster.Entry{source: %{user: %{type: :sso}}}, _), do: "SSO"defp entry_label(_, _), do: nil- def at_limit?(layout, limit) do+ defp me?(%Roster.Entry{source: %Teams.Membership{user: %{id: id}}}, %{id: id}), do: true+ defp me?(_, _), do: false++ def at_limit?(roster, limit) donot Plausible.Billing.Quota.below_limit?(- Layout.active_count(layout) - 1,+ map_size(roster) - 1,limit)enddiff --git a/lib/plausible_web/live/team_setup.ex b/lib/plausible_web/live/team_setup.exindex 3a8d4c1cfb..2b327c5ac7 100644--- a/lib/plausible_web/live/team_setup.ex+++ b/lib/plausible_web/live/team_setup.ex@@ -194,7 +194,7 @@ defmodule PlausibleWeb.Live.TeamSetup do{:error, :duplicate_emails} ->{:noreply, put_live_flash(socket, :error, "Make sure e-mails are unique")}- {:error, reason} when reason in [:already_a_guest, :already_invited_guest] ->+ {:error, reason} when reason in [:already_a_guest, :invited_as_guest] ->{:noreply,put_live_flash(socket,diff --git a/test/plausible/teams/invitations/invite_to_team_test.exs b/test/plausible/teams/invitations/invite_to_team_test.exsindex 2195dcc890..5d4253820b 100644--- a/test/plausible/teams/invitations/invite_to_team_test.exs+++ b/test/plausible/teams/invitations/invite_to_team_test.exs@@ -8,215 +8,6 @@ defmodule Plausible.Teams.Invitations.InviteToTeamTest do@subject_prefix if ee?(), do: "[Plausible Analytics] ", else: "[Plausible CE] "- describe "invite/4,5" do- for role <- Teams.Invitation.roles() -- [:guest] do- test "creates an invitation with role #{role} for existing user" do- inviter = new_user()- invitee = new_user()- _site = new_site(owner: inviter)- team = team_of(inviter)-- assert {:ok, %Plausible.Teams.Invitation{} = team_invitation} =- InviteToTeam.invite(team, inviter, invitee.email, unquote(role))-- assert team_invitation.team_id == team.id- assert team_invitation.role == unquote(role)- assert team_invitation.email == invitee.email- assert team_invitation.inviter_id == inviter.id- assert is_binary(team_invitation.invitation_id)- assert [] = Repo.preload(team_invitation, :guest_invitations).guest_invitations-- assert_email_delivered_with(- to: [nil: invitee.email],- subject: @subject_prefix <> "You've been invited to \"#{team.name}\" team"- )- end- end-- for role <- Teams.Invitation.roles() -- [:guest] do- test "creates an invitation with role #{role} for new user" do- inviter = new_user()- invitee = build(:user)- _site = new_site(owner: inviter)- team = team_of(inviter)-- assert {:ok, %Plausible.Teams.Invitation{} = team_invitation} =- InviteToTeam.invite(team, inviter, invitee.email, unquote(role))-- assert team_invitation.team_id == team.id- assert team_invitation.role == unquote(role)- assert team_invitation.email == invitee.email- assert team_invitation.inviter_id == inviter.id- assert is_binary(team_invitation.invitation_id)- assert [] = Repo.preload(team_invitation, :guest_invitations).guest_invitations-- assert_email_delivered_with(- to: [nil: invitee.email],- subject: @subject_prefix <> "You've been invited to \"#{team.name}\" team",- html_body: ~r/#{team_invitation.invitation_id}/- )- end- end-- for role <- Enum.map(Teams.Invitation.roles() -- [:guest], &to_string/1) do- test "creates an invitation with role #{role} as a string" do- inviter = new_user()- invitee = new_user()- _site = new_site(owner: inviter)- team = team_of(inviter)-- assert {:ok, %Plausible.Teams.Invitation{} = team_invitation} =- InviteToTeam.invite(team, inviter, invitee.email, unquote(role))-- assert team_invitation.team_id == team.id- assert team_invitation.role == unquote(String.to_existing_atom(role))- assert team_invitation.email == invitee.email- assert team_invitation.inviter_id == inviter.id- assert is_binary(team_invitation.invitation_id)- assert [] = Repo.preload(team_invitation, :guest_invitations).guest_invitations-- assert_email_delivered_with(- to: [nil: invitee.email],- subject: @subject_prefix <> "You've been invited to \"#{team.name}\" team"- )- end- end-- test "crashes on attempt to invite guest on a team level" do- inviter = new_user()- invitee = new_user()- _site = new_site(owner: inviter)- team = team_of(inviter)-- assert_raise RuntimeError, ~r/Invalid role passed/, fn ->- InviteToTeam.invite(team, inviter, invitee.email, :guest)- end-- assert_raise RuntimeError, ~r/Invalid role passed/, fn ->- InviteToTeam.invite(team, inviter, invitee.email, "guest")- end- end-- test "overwrites existing invitation" do- inviter = new_user()- invitee = new_user()- _site = new_site(owner: inviter)- team = team_of(inviter)- existing_invitation = invite_member(team, invitee.email, role: :viewer, inviter: inviter)-- assert {:ok, team_invitation} =- InviteToTeam.invite(team, inviter, invitee.email, :editor)-- assert team_invitation.id == existing_invitation.id- assert team_invitation.team_id == existing_invitation.team_id- assert team_invitation.email == invitee.email- assert team_invitation.role == :editor- end-- test "overwrites existing guest invitation and prunes guest invitation entries" do- inviter = new_user()- invitee = new_user()- site = new_site(owner: inviter)- team = team_of(inviter)- existing_invitation = invite_guest(site, invitee.email, role: :viewer, inviter: inviter)-- assert {:ok, team_invitation} =- InviteToTeam.invite(team, inviter, invitee.email, :viewer)-- assert team_invitation.id == existing_invitation.team_invitation.id- assert team_invitation.team_id == existing_invitation.team_invitation.team_id- assert team_invitation.email == invitee.email- assert team_invitation.role == :viewer- assert [] = Repo.preload(team_invitation, :guest_invitations).guest_invitations- end-- test "returns validation errors" do- inviter = new_user()- _site = new_site(owner: inviter)- team = team_of(inviter)-- assert {:error, changeset} = InviteToTeam.invite(team, inviter, "", :viewer)- assert {"can't be blank", _} = changeset.errors[:email]- end-- for role <- Teams.Invitation.roles() -- [:guest] do- test "returns error when existing user is already a member (role #{role})" do- inviter = new_user()- invitee = new_user()- _site = new_site(owner: inviter)- team = team_of(inviter)- add_member(team, user: invitee, role: unquote(role))-- assert {:error, :already_a_member} =- InviteToTeam.invite(team, inviter, invitee.email, :editor)- end- end-- test "returns error when existing user is a guest member" do- inviter = new_user()- invitee = new_user()- site = new_site(owner: inviter)- team = team_of(inviter)- add_guest(site, user: invitee, role: :viewer)-- assert {:error, :already_a_guest} =- InviteToTeam.invite(team, inviter, invitee.email, :viewer)- end-- @tag :ee_only- test "returns error when owner is over their team member limit" do- [owner, inviter, invitee] = for _ <- 1..3, do: new_user()- subscribe_to_growth_plan(owner)- _site = new_site(owner: owner)- team = team_of(owner)- inviter = add_member(team, user: inviter, role: :admin)- for _ <- 1..2, do: add_member(team, role: :viewer)-- assert {:error, {:over_limit, 3}} =- InviteToTeam.invite(team, inviter, invitee.email, :viewer)- end-- @tag :ee_only- test "allows creating an ownership transfer even when at team member limit" do- inviter = new_user()- invitee = build(:user)- _site = new_site(owner: inviter)- team = team_of(inviter)- for _ <- 1..3, do: add_member(team, role: :viewer)-- assert {:ok, _team_invitation} =- InviteToTeam.invite(team, inviter, invitee.email, :owner)- end-- for role <- Teams.Invitation.roles() -- [:guest, :owner] do- test "allows admins to invite new members except owners (invite role: #{role})" do- owner = new_user()- inviter = new_user()- invitee = build(:user)- _site = new_site(owner: owner)- team = team_of(owner)- add_member(team, user: inviter, role: :admin)-- assert {:ok, _team_invitation} =- InviteToTeam.invite(team, inviter, invitee.email, unquote(role))- end- end-- for role <- Teams.Invitation.roles() -- [:owner] do- test "only allows owners to invite new owners (inviter role: #{role})" do- owner = new_user()- inviter = new_user()- invitee = build(:user)- _site = new_site(owner: owner)- team = team_of(owner)- add_member(team, user: inviter, role: unquote(role))-- assert {:error, :permission_denied} =- InviteToTeam.invite(team, inviter, invitee.email, :owner)- end- end- end-describe "invite_all/3" dotest "creates invitations with a role per entry, without sending e-mails" doinviter = new_user()@@ -267,6 +58,21 @@ defmodule Plausible.Teams.Invitations.InviteToTeamTest doendend+ for role <- Teams.Invitation.roles() -- [:guest] do+ test "returns an error when inviting an existing member (role #{role})" do+ inviter = new_user()+ invitee = new_user()+ _site = new_site(owner: inviter)+ team = team_of(inviter)+ add_member(team, user: invitee, role: unquote(role))++ assert {:error, :already_a_member} =+ InviteToTeam.invite_all(team, inviter, [%{email: invitee.email, role: :editor}])++ refute Repo.get_by(Teams.Invitation, team_id: team.id, email: invitee.email)+ end+ end+test "returns an error when inviting a guest member" doinviter = new_user()invitee = new_user()@@ -286,7 +92,7 @@ defmodule Plausible.Teams.Invitations.InviteToTeamTest doteam = team_of(inviter)invite_guest(site, "[email protected]", role: :viewer, inviter: inviter)- assert {:error, :already_invited_guest} =+ assert {:error, :invited_as_guest} =InviteToTeam.invite_all(team, inviter, [%{email: "[email protected]", role: :editor}])@@ -320,7 +126,7 @@ defmodule Plausible.Teams.Invitations.InviteToTeamTest doexisting_invitation =invite_member(team, "[email protected]", role: :viewer, inviter: inviter)- assert {:error, :already_invited} =+ assert {:error, :invited_as_member} =InviteToTeam.invite_all(team, inviter, [%{email: "[email protected]", role: :admin}])diff --git a/test/plausible/teams/invitations/update_role_test.exs b/test/plausible/teams/invitations/update_role_test.exsindex e9e0a555fc..c99724368e 100644--- a/test/plausible/teams/invitations/update_role_test.exs+++ b/test/plausible/teams/invitations/update_role_test.exs@@ -50,7 +50,7 @@ defmodule Plausible.Teams.Invitations.UpdateRoleTest doUpdateRole.update(team, invitation.invitation_id, :editor, owner)end- test "returns error when the granter isn't allowed to make the change", %{+ test "returns error when the actor isn't allowed to make the change", %{user: owner,team: team} dodiff --git a/test/plausible/teams/management/layout_test.exs b/test/plausible/teams/management/layout_test.exsdeleted file mode 100644index f7c254ecf2..0000000000--- a/test/plausible/teams/management/layout_test.exs+++ /dev/null@@ -1,418 +0,0 @@-defmodule Plausible.Teams.Management.LayoutTest do- use Plausible.DataCase, async: true- use Bamboo.Test-- alias Plausible.Teams.Management.Layout- alias Plausible.Teams.Management.Layout.Entry- alias Plausible.Teams-- describe "no persistence" do- test "can be built of invitations and memberships" do- layout = sample_layout()-- assert %Entry{name: "Current User", role: :admin, type: :membership} =- layout["[email protected]"]-- assert %Entry{name: "Owner User", role: :owner, type: :membership} =- layout["[email protected]"]-- assert %Entry{- name: "Invited User",- role: :admin,- type: :invitation_sent- } =- layout["[email protected]"]-- assert %Entry{- name: "Invited User",- role: :admin,- type: :invitation_pending- } =- layout["[email protected]"]- end-- test "can be sorted for display" do- layout =- sample_layout()-- assert [- {"[email protected]", %Entry{type: :invitation_pending}},- {"[email protected]", %Entry{type: :invitation_sent}},- {"[email protected]", %Entry{type: :membership}},- {"[email protected]", %Entry{type: :membership}},- {"[email protected]", %Entry{role: :guest, type: :invitation_pending}},- {"[email protected]",- %Entry{role: :guest, type: :invitation_sent}},- {"[email protected]", %Entry{role: :guest, type: :membership}}- ] = Layout.sorted_for_display(layout)-- layout =- layout- |> put(membership(name: "Aa", email: "[email protected]", role: :viewer))- |> put(invitation_pending("[email protected]"))- |> put(invitation_sent("[email protected]"))- |> Layout.schedule_delete("[email protected]")-- assert [- {"[email protected]", %Entry{}},- {"[email protected]", %Entry{}},- {"[email protected]", %Entry{}},- {"[email protected]", %Entry{}},- {"[email protected]", %Entry{}},- {"[email protected]", %Entry{}},- {"[email protected]", %Entry{role: :guest, type: :invitation_pending}},- {"[email protected]",- %Entry{role: :guest, type: :invitation_sent}},- {"[email protected]", %Entry{role: :guest, type: :membership}}- ] = Layout.sorted_for_display(layout)- end-- test "removable?/2 + counters" do- layout = sample_layout()- assert Layout.removable?(layout, "[email protected]")- assert Layout.removable?(layout, "[email protected]")- refute Layout.removable?(layout, "[email protected]")-- layout =- put(- layout,- invitation_sent("[email protected]", role: :owner)- )-- refute Layout.removable?(layout, "[email protected]")-- layout =- put(- layout,- membership(- email: "[email protected]",- role: :owner- )- )-- assert Layout.removable?(layout, "[email protected]")- assert Layout.removable?(layout, "[email protected]")-- assert Layout.owners_count(layout) == 3- assert Layout.active_count(layout) == 9-- layout = Layout.schedule_delete(layout, "[email protected]")-- assert Layout.owners_count(layout) == 2- assert Layout.active_count(layout) == 8-- refute Layout.removable?(layout, "[email protected]")- end-- test "update_role/3" do- assert %Entry{queued_op: :update, role: :owner} =- sample_layout()- |> Layout.update_role("[email protected]", :owner)- |> Map.get("[email protected]")-- assert_raise KeyError, ~r/not found/, fn ->- Layout.update_role(sample_layout(), "x", :owner)- end- end-- test "schedule_send/3" do- assert %Entry{- queued_op: :send,- name: "Invited User",- role: :admin,- meta: %{email: "[email protected]"}- } =- sample_layout()- |> Layout.schedule_send("[email protected]", :admin)- |> Map.get("[email protected]")-- assert %Entry{- queued_op: :send,- name: "Joe Doe",- role: :admin,- meta: %{email: "[email protected]"}- } =- sample_layout()- |> Layout.schedule_send("[email protected]", :admin, name: "Joe Doe")- |> Map.get("[email protected]")- end-- test "schedule_delete/2" do- assert %Entry{queued_op: :delete} =- sample_layout()- |> Layout.schedule_delete("[email protected]")- |> Map.get("[email protected]")-- assert_raise KeyError, ~r/not found/, fn ->- Layout.schedule_delete(sample_layout(), "x")- end- end-- test "has_guests?/1" do- input = [- invitation_pending("[email protected]")- ]-- layout = Layout.build_by_email(input)- refute Layout.has_guests?(layout)-- layout =- put(- layout,- membership(email: "[email protected]", role: :guest)- )-- assert Layout.has_guests?(layout)- layout = Layout.schedule_delete(layout, "[email protected]")- refute Layout.has_guests?(layout)-- layout = Layout.update_role(layout, "[email protected]", :viewer)-- refute Layout.has_guests?(layout)- end-- test "overwrite" do- assert %Entry{queued_op: :send, type: :invitation_pending} =- sample_layout()- |> put(- membership(- name: "Aa",- email: "[email protected]",- role: :viewer- )- )- |> Layout.schedule_send("[email protected]", :admin)- |> Map.get("[email protected]")- end-- defp invitation_pending(email, attrs \\ []) do- build(:team_invitation, Keyword.merge([email: email], attrs))- end-- defp invitation_sent(email, attrs \\ []) do- build(- :team_invitation,- Keyword.merge(- [email: email, id: Enum.random(1..1_000_000)],- attrs- )- )- end-- defp membership(attrs) do- build(:team_membership,- role: attrs[:role],- user: attrs[:user] || build(:user, name: attrs[:name], email: attrs[:email])- )- end-- defp sample_layout() do- current_user = build(:user, id: 777, name: "Current User", email: "[email protected]")-- input = [- invitation_pending("[email protected]"),- membership(- role: :owner,- name: "Owner User",- email: "[email protected]"- ),- invitation_pending("[email protected]", role: :guest),- membership(role: :guest, name: "Guest User", email: "[email protected]"),- membership(role: :admin, user: current_user),- invitation_sent("[email protected]", role: :guest),- invitation_sent("[email protected]")- ]-- Layout.build_by_email(input)- end- end-- describe "persistence" do- @subject_prefix if ee?(), do: "[Plausible Analytics] ", else: "[Plausible CE] "- setup [:create_user, :create_team]-- test "unchanged layout no-op", %{user: user, team: team} do- add_member(team, role: :admin)- invite_member(team, "[email protected]", role: :viewer, inviter: user)-- assert {:ok, 0} =- team- |> Layout.init()- |> Layout.persist(%{current_user: user, current_team: team})-- assert_no_emails_delivered()- end-- test "invitation pending email goes out", %{user: user, team: team} do- assert {:ok, 1} =- team- |> Layout.init()- |> Layout.schedule_send("[email protected]", :admin)- |> Layout.persist(%{current_user: user, current_team: team})-- assert_email_delivered_with(- to: [nil: "[email protected]"],- subject: @subject_prefix <> "You've been invited to \"#{team.name}\" team"- )-- layout = Layout.init(team)- assert %{type: :invitation_sent} = Map.get(layout, "[email protected]")- end-- test "membership removal email goes out", %{user: user, team: team} do- add_member(team, role: :admin, user: new_user(email: "[email protected]"))-- assert {:ok, 1} =- team- |> Layout.init()- |> Layout.schedule_delete("[email protected]")- |> Layout.persist(%{current_user: user, current_team: team})-- assert_email_delivered_with(- to: [nil: "[email protected]"],- subject: @subject_prefix <> "Your access to \"#{team.name}\" team has been revoked"- )- end-- test "limits are checked", %{user: user, team: team} do- on_ee do- subscribe_to_growth_plan(user)-- assert {:error, {:over_limit, 3}} =- team- |> Layout.init()- |> Layout.schedule_send("[email protected]", :admin)- |> Layout.schedule_send("[email protected]", :admin)- |> Layout.schedule_send("[email protected]", :admin)- |> Layout.schedule_send("[email protected]", :admin)- |> Layout.persist(%{current_user: user, current_team: team})- end-- assert {:error, :only_one_owner} =- team- |> Layout.init()- |> Layout.schedule_delete(user.email)- |> put(invitation_pending("[email protected]", role: :owner))- |> put(invitation_sent("[email protected]", role: :owner))- |> Layout.persist(%{current_user: user, current_team: team})-- assert {:error, :only_one_owner} =- team- |> Layout.init()- |> Layout.update_role(user.email, :viewer)- |> Layout.persist(%{current_user: user, current_team: team})-- assert {:error, :already_a_member} =- team- |> Layout.init()- |> Layout.schedule_send(user.email, :admin)- |> Layout.persist(%{current_user: user, current_team: team})-- assert_no_emails_delivered()- end-- test "deletions are made first, so that limits apply accurately", %{user: user, team: team} do- add_member(team, role: :admin, user: new_user(email: "[email protected]"))- add_member(team, role: :admin, user: new_user(email: "[email protected]"))- add_member(team, role: :admin, user: new_user(email: "[email protected]"))-- assert {:ok, 3} =- team- |> Layout.init()- |> Layout.schedule_send("[email protected]", :admin)- |> Layout.schedule_delete("[email protected]")- |> Layout.schedule_delete("[email protected]")- |> Layout.persist(%{current_user: user, current_team: team})- end-- test "multiple ops queue", %{user: user, team: team} do- member1 = add_member(team, role: :admin, user: new_user(email: "[email protected]"))- member2 = add_member(team, role: :admin, user: new_user(email: "[email protected]"))-- assert {:ok, 3} =- team- |> Layout.init()- |> Layout.schedule_send("[email protected]", :admin)- |> Layout.schedule_delete("[email protected]")- |> Layout.update_role("[email protected]", :viewer)- |> Layout.persist(%{current_user: user, current_team: team})-- assert {:error, :not_a_member} = Teams.Memberships.team_role(team, member1)- assert {:ok, :viewer} = Teams.Memberships.team_role(team, member2)- assert [%{email: "[email protected]"}] = Teams.Invitations.pending_team_invitations_for(team)-- assert_email_delivered_with(- to: [nil: "[email protected]"],- subject: @subject_prefix <> "You've been invited to \"#{team.name}\" team"- )-- assert_email_delivered_with(- to: [nil: "[email protected]"],- subject: @subject_prefix <> "Your access to \"#{team.name}\" team has been revoked"- )-- assert_no_emails_delivered()- end-- test "deletion of scheduled invitations is no-op", %{user: user, team: team} do- assert {:ok, 0} =- team- |> Layout.init()- |> Layout.schedule_send("[email protected]", :admin)- |> Layout.schedule_delete("[email protected]")- |> Layout.persist(%{current_user: user, current_team: team})- end-- test "idempotence", %{user: user, team: team} do- add_member(team, role: :admin, user: new_user(email: "[email protected]"))- add_member(team, role: :admin, user: new_user(email: "[email protected]"))-- assert {:ok, 3} =- team- |> Layout.init()- |> Layout.schedule_send("[email protected]", :admin)- |> Layout.schedule_delete("[email protected]")- |> Layout.schedule_send("[email protected]", :admin)- |> Layout.update_role("[email protected]", :viewer)- |> Layout.schedule_delete("[email protected]")- |> Layout.update_role("[email protected]", :viewer)- |> Layout.persist(%{current_user: user, current_team: team})-- assert_email_delivered_with(- to: [nil: "[email protected]"],- subject: @subject_prefix <> "You've been invited to \"#{team.name}\" team"- )-- assert_email_delivered_with(- to: [nil: "[email protected]"],- subject: @subject_prefix <> "Your access to \"#{team.name}\" team has been revoked"- )-- assert_no_emails_delivered()- end-- test "guests promotion", %{user: user, team: team} do- site = new_site(owner: user)- u2 = new_user()-- add_guest(site, user: u2, role: :viewer)- assert_guest_membership(team, site, u2, :viewer)-- layout = Layout.init(team)- assert Layout.has_guests?(layout)-- layout- |> Layout.update_role(u2.email, :viewer)- |> Layout.persist(%{current_user: user, current_team: team})-- refute team |> Layout.init() |> Layout.has_guests?()-- assert_non_guest_membership(team, site, u2)- end- end-- def put(layout, entity) do- entry = Entry.new(entity)- Map.put(layout, entry.email, entry)- end-enddiff --git a/test/plausible/teams/management/roster_test.exs b/test/plausible/teams/management/roster_test.exsnew file mode 100644index 0000000000..409a5d4461--- /dev/null+++ b/test/plausible/teams/management/roster_test.exs@@ -0,0 +1,156 @@+defmodule Plausible.Teams.Management.RosterTest do+ use Plausible.DataCase, async: true++ alias Plausible.Teams.Management.Roster+ alias Plausible.Teams.Management.Roster.Entry+ alias Plausible.Teams++ describe "init/1" do+ setup [:create_user, :create_team]++ test "loads the team's members and pending invitations", %{user: owner, team: team} do+ viewer = add_member(team, role: :viewer)+ invite_member(team, "[email protected]", role: :editor, inviter: owner)++ roster = Roster.init(team)++ assert %Entry{role: :owner, source: %Teams.Membership{}} = roster[owner.email]+ assert %Entry{role: :viewer, source: %Teams.Membership{}} = roster[viewer.email]++ assert %Entry{name: "Invited User", role: :editor, source: %Teams.Invitation{}} =+ roster["[email protected]"]++ assert map_size(roster) == 3+ end+ end++ test "can be built of invitations and memberships" do+ roster = sample_roster()++ assert %Entry{name: "Current User", role: :admin, source: %Teams.Membership{user: %{id: 777}}} =+ roster["[email protected]"]++ assert %Entry{name: "Owner User", role: :owner, source: %Teams.Membership{}} =+ roster["[email protected]"]++ assert %Entry{name: "Invited User", role: :admin, source: %Teams.Invitation{}} =+ roster["[email protected]"]+ end++ test "can be sorted for display" do+ assert [+ {"[email protected]", %Entry{source: %Teams.Invitation{}}},+ {"[email protected]", %Entry{source: %Teams.Membership{}}},+ {"[email protected]", %Entry{source: %Teams.Membership{}}},+ {"[email protected]",+ %Entry{role: :guest, source: %Teams.Invitation{}}},+ {"[email protected]", %Entry{role: :guest, source: %Teams.Membership{}}}+ ] = Roster.sorted_for_display(sample_roster())++ roster =+ sample_roster()+ |> put(membership(name: "Aa", email: "[email protected]", role: :viewer))+ |> put(invitation_sent("[email protected]"))++ assert [+ {"[email protected]", %Entry{}},+ {"[email protected]", %Entry{}},+ {"[email protected]", %Entry{}},+ {"[email protected]", %Entry{}},+ {"[email protected]", %Entry{}},+ {"[email protected]",+ %Entry{role: :guest, source: %Teams.Invitation{}}},+ {"[email protected]", %Entry{role: :guest, source: %Teams.Membership{}}}+ ] = Roster.sorted_for_display(roster)+ end++ test "removable?/2 + owners_count/1" do+ roster = sample_roster()+ assert Roster.removable?(roster, "[email protected]")+ assert Roster.removable?(roster, "[email protected]")+ refute Roster.removable?(roster, "[email protected]")++ # A pending owner invitation doesn't count as another owner yet+ roster = put(roster, invitation_sent("[email protected]", role: :owner))++ refute Roster.removable?(roster, "[email protected]")++ roster = put(roster, membership(email: "[email protected]", role: :owner))++ assert Roster.removable?(roster, "[email protected]")+ assert Roster.removable?(roster, "[email protected]")++ assert Roster.owners_count(roster) == 3+ end++ test "users/1 returns the users of memberships, leaving out invitations" do+ current_user = build(:user, name: "Member", email: "[email protected]")++ roster =+ Roster.build_by_email([+ membership(role: :viewer, user: current_user),+ invitation_sent("[email protected]")+ ])++ assert [%{email: "[email protected]"}] = Roster.users(roster)+ end++ test "has_guests?/1" do+ roster = Roster.build_by_email([invitation_sent("[email protected]")])+ refute Roster.has_guests?(roster)++ assert roster+ |> put(membership(email: "[email protected]", role: :guest))+ |> Roster.has_guests?()++ assert roster+ |> put(invitation_sent("[email protected]", role: :guest))+ |> Roster.has_guests?()+ end++ test "a membership takes precedence over an invitation for the same e-mail" do+ roster =+ Roster.build_by_email([+ invitation_sent("[email protected]", role: :admin),+ membership(email: "[email protected]", role: :viewer)+ ])++ assert %{"[email protected]" => %Entry{source: %Teams.Membership{}, role: :viewer}} = roster+ end++ test "Entry.invitation?/1 tells invitations and memberships apart" do+ assert Entry.invitation?(Entry.new(invitation_sent("[email protected]")))+ refute Entry.invitation?(Entry.new(membership(email: "[email protected]", role: :viewer)))+ end++ defp put(roster, entity) do+ entry = Entry.new(entity)+ Map.put(roster, entry.email, entry)+ end++ defp invitation_sent(email, attrs \\ []) do+ build(+ :team_invitation,+ Keyword.merge([email: email, id: Enum.random(1..1_000_000)], attrs)+ )+ end++ defp membership(attrs) do+ build(:team_membership,+ role: attrs[:role],+ user: attrs[:user] || build(:user, name: attrs[:name], email: attrs[:email])+ )+ end++ defp sample_roster() do+ current_user = build(:user, id: 777, name: "Current User", email: "[email protected]")++ Roster.build_by_email([+ membership(role: :owner, name: "Owner User", email: "[email protected]"),+ membership(role: :guest, name: "Guest User", email: "[email protected]"),+ membership(role: :admin, user: current_user),+ invitation_sent("[email protected]", role: :guest),+ invitation_sent("[email protected]")+ ])+ end+enddiff --git a/test/plausible/teams/team_role_permissions_test.exs b/test/plausible/teams/team_role_permissions_test.exsindex f270188823..fceef3d651 100644--- a/test/plausible/teams/team_role_permissions_test.exs+++ b/test/plausible/teams/team_role_permissions_test.exs@@ -15,187 +15,129 @@ defmodule Plausible.Teams.TeamRolePermissionsTest doguest: "a guest"}- describe "ensure_can_change_role/3" do- test "raises for an unknown type" do- assert_raise ArgumentError, "unknown type: :unknown", fn ->- TeamRolePermissions.ensure_can_change_role(:unknown, :owner, :viewer)- end- end- end-- describe "ensure_can_change_role/3 for members" do+ describe "can_modify_member?/2" dofor current_role <- @roles dotest "as an owner, I can change the role of #{@as[current_role]}" do- assert :ok =- TeamRolePermissions.ensure_can_change_role(- :membership,- :owner,- unquote(current_role)- )+ assert TeamRolePermissions.can_modify_member?(:owner, unquote(current_role))endendfor current_role <- [:admin, :editor, :viewer] dotest "as an admin, I can change the role of #{@as[current_role]}" do- assert :ok =- TeamRolePermissions.ensure_can_change_role(- :membership,- :admin,- unquote(current_role)- )+ assert TeamRolePermissions.can_modify_member?(:admin, unquote(current_role))endendfor current_role <- [:owner, :billing, :guest] dotest "as an admin, I cannot change the role of #{@as[current_role]}" do- assert {:error, :permission_denied} =- TeamRolePermissions.ensure_can_change_role(- :membership,- :admin,- unquote(current_role)- )+ refute TeamRolePermissions.can_modify_member?(:admin, unquote(current_role))endend- for granter_role <- [:editor, :viewer, :billing, :guest] do- test "as #{@as[granter_role]}, I cannot change anyone's role" do- assert {:error, :permission_denied} =- TeamRolePermissions.ensure_can_change_role(- :membership,- unquote(granter_role),- :viewer- )+ for actor_role <- [:editor, :viewer, :billing, :guest] do+ test "as #{@as[actor_role]}, I cannot change anyone's role" do+ refute TeamRolePermissions.can_modify_member?(unquote(actor_role), :viewer)endendend- describe "ensure_can_change_role/3 for invitations" do- for granter_role <- [:owner, :admin] do- test "as #{@as[granter_role]}, I can create an invitation" do- assert :ok =- TeamRolePermissions.ensure_can_change_role(- :invitation,- unquote(granter_role),- nil- )- end- end-+ describe "can_modify_invitation?/2" dofor current_role <- @roles dotest "as an owner, I can change the role of a pending #{current_role} invitation" do- assert :ok =- TeamRolePermissions.ensure_can_change_role(- :invitation,- :owner,- unquote(current_role)- )+ assert TeamRolePermissions.can_modify_invitation?(:owner, unquote(current_role))endendfor current_role <- [:admin, :editor, :viewer, :billing] dotest "as an admin, I can change the role of a pending #{current_role} invitation" do- assert :ok =- TeamRolePermissions.ensure_can_change_role(- :invitation,- :admin,- unquote(current_role)- )+ assert TeamRolePermissions.can_modify_invitation?(:admin, unquote(current_role))endendfor current_role <- [:owner, :guest] dotest "as an admin, I cannot change the role of a pending #{current_role} invitation" do- assert {:error, :permission_denied} =- TeamRolePermissions.ensure_can_change_role(- :invitation,- :admin,- unquote(current_role)- )+ refute TeamRolePermissions.can_modify_invitation?(:admin, unquote(current_role))endend- for granter_role <- [:editor, :viewer, :billing, :guest] do- test "as #{@as[granter_role]}, I cannot create or change invitations" do- assert {:error, :permission_denied} =- TeamRolePermissions.ensure_can_change_role(- :invitation,- unquote(granter_role),- nil- )-- assert {:error, :permission_denied} =- TeamRolePermissions.ensure_can_change_role(- :invitation,- unquote(granter_role),- :viewer- )+ for actor_role <- [:editor, :viewer, :billing, :guest] do+ test "as #{@as[actor_role]}, I cannot change invitations" do+ refute TeamRolePermissions.can_modify_invitation?(unquote(actor_role), :viewer)endendend- describe "ensure_can_grant_role/2" do- for to_role <- @assignable_roles do- test "as an owner, I can grant the #{to_role} role" do- assert :ok = TeamRolePermissions.ensure_can_grant_role(:owner, unquote(to_role))+ describe "can_assign?/2" do+ for new_role <- @assignable_roles do+ test "as an owner, I can assign the #{new_role} role" do+ assert TeamRolePermissions.can_assign?(:owner, unquote(new_role))endend- for to_role <- [:admin, :editor, :viewer, :billing] do- test "as an admin, I can grant the #{to_role} role" do- assert :ok = TeamRolePermissions.ensure_can_grant_role(:admin, unquote(to_role))+ for new_role <- [:admin, :editor, :viewer, :billing] do+ test "as an admin, I can assign the #{new_role} role" do+ assert TeamRolePermissions.can_assign?(:admin, unquote(new_role))endend- test "as an admin, I cannot grant the owner role" do- assert {:error, :permission_denied} =- TeamRolePermissions.ensure_can_grant_role(:admin, :owner)+ test "as an admin, I cannot assign the owner role" do+ refute TeamRolePermissions.can_assign?(:admin, :owner)end- for granter_role <- [:editor, :viewer, :billing, :guest] do- test "as #{@as[granter_role]}, I cannot grant any role" do- assert {:error, :permission_denied} =- TeamRolePermissions.ensure_can_grant_role(unquote(granter_role), :viewer)+ for actor_role <- [:editor, :viewer, :billing, :guest] do+ test "as #{@as[actor_role]}, I cannot assign any role" do+ refute TeamRolePermissions.can_assign?(unquote(actor_role), :viewer)endend- for granter_role <- @roles do- test "as #{@as[granter_role]}, I cannot grant the guest role" do+ for actor_role <- @roles do+ test "as #{@as[actor_role]}, I cannot assign the guest role" doassert_raise ArgumentError, "invalid role: :guest", fn ->- TeamRolePermissions.ensure_can_grant_role(unquote(granter_role), :guest)+ TeamRolePermissions.can_assign?(unquote(actor_role), :guest)endendend- test "as an owner, I cannot grant an invalid role" do+ test "as an owner, I cannot assign an invalid role" doassert_raise ArgumentError, "invalid role: :unknown", fn ->- TeamRolePermissions.ensure_can_grant_role(:owner, :unknown)+ TeamRolePermissions.can_assign?(:owner, :unknown)endend- test "as an owner, I cannot grant a role given as a string" do+ test "as an owner, I cannot assign a role given as a string" doassert_raise ArgumentError, ~s(invalid role: "admin"), fn ->- TeamRolePermissions.ensure_can_grant_role(:owner, "admin")+ TeamRolePermissions.can_assign?(:owner, "admin")endendend- describe "ensure_can_grant_for_member/4" do+ describe "ensure_can_change_member_role/4" dosetup [:create_user, :create_team]- test "allows a change the granter's role permits", %{user: owner, team: team} do+ test "allows a change the actor's role permits", %{user: owner, team: team} domember = add_member(team, role: :viewer)membership = get_membership(team, member)assert :ok =- TeamRolePermissions.ensure_can_grant_for_member(team, owner, membership, :editor)+ TeamRolePermissions.ensure_can_change_member_role(+ team,+ owner,+ membership,+ :editor+ )end- test "denies a change the granter's role doesn't permit", %{user: owner, team: team} do+ test "denies a change the actor's role doesn't permit", %{user: owner, team: team} doadmin = add_member(team, role: :admin)membership = get_membership(team, owner)assert {:error, :permission_denied} =- TeamRolePermissions.ensure_can_grant_for_member(team, admin, membership, :viewer)+ TeamRolePermissions.ensure_can_change_member_role(+ team,+ admin,+ membership,+ :viewer+ )endfor invalid_role <- [:guest, :unknown, "admin"] do@@ -207,7 +149,7 @@ defmodule Plausible.Teams.TeamRolePermissionsTest domembership = get_membership(team, member)assert_raise ArgumentError, fn ->- TeamRolePermissions.ensure_can_grant_for_member(+ TeamRolePermissions.ensure_can_change_member_role(team,owner,membership,@@ -217,13 +159,13 @@ defmodule Plausible.Teams.TeamRolePermissionsTest doendend- test "returns permission error when the granter is not a member of the team", %{team: team} do+ test "returns permission error when the actor is not a member of the team", %{team: team} domember = add_member(team, role: :viewer)membership = get_membership(team, member)outsider = new_user()assert {:error, :permission_denied} =- TeamRolePermissions.ensure_can_grant_for_member(+ TeamRolePermissions.ensure_can_change_member_role(team,outsider,membership,@@ -232,35 +174,45 @@ defmodule Plausible.Teams.TeamRolePermissionsTest doendend- describe "ensure_can_grant_for_invitation/4" do+ describe "ensure_can_change_invitation_role/4" dosetup [:create_user, :create_team]- test "allows a role the granter's role permits", %{team: team} do+ test "allows a change the actor's role permits", %{user: owner, team: team} doadmin = add_member(team, role: :admin)+ invitation = invite_member(team, "[email protected]", role: :viewer, inviter: owner)- assert :ok = TeamRolePermissions.ensure_can_grant_for_invitation(team, admin, nil, :editor)+ assert :ok =+ TeamRolePermissions.ensure_can_change_invitation_role(+ team,+ admin,+ invitation,+ :editor+ )end- test "denies a role the granter's role doesn't permit", %{team: team} do+ test "takes the current role of the invitation into account", %{user: owner, team: team} doadmin = add_member(team, role: :admin)+ invitation = invite_member(team, "[email protected]", role: :owner, inviter: owner)assert {:error, :permission_denied} =- TeamRolePermissions.ensure_can_grant_for_invitation(team, admin, nil, :owner)+ TeamRolePermissions.ensure_can_change_invitation_role(+ team,+ admin,+ invitation,+ :viewer+ )end- test "takes the current role of a pending invitation into account", %{- user: owner,- team: team- } do+ test "denies a role the actor's role doesn't permit", %{user: owner, team: team} doadmin = add_member(team, role: :admin)- invitation = invite_member(team, "[email protected]", role: :owner, inviter: owner)+ invitation = invite_member(team, "[email protected]", role: :viewer, inviter: owner)assert {:error, :permission_denied} =- TeamRolePermissions.ensure_can_grant_for_invitation(+ TeamRolePermissions.ensure_can_change_invitation_role(team,admin,invitation,- :viewer+ :owner)end@@ -269,22 +221,91 @@ defmodule Plausible.Teams.TeamRolePermissionsTest douser: owner,team: team} do+ invitation = invite_member(team, "[email protected]", role: :viewer, inviter: owner)+assert_raise ArgumentError, fn ->- TeamRolePermissions.ensure_can_grant_for_invitation(+ TeamRolePermissions.ensure_can_change_invitation_role(team,owner,- nil,+ invitation,unquote(invalid_role))endendend- test "returns permission error when the granter is not a member of the team", %{team: team} do+ test "returns permission error when the actor is not a member of the team", %{+ user: owner,+ team: team+ } do+ invitation = invite_member(team, "[email protected]", role: :viewer, inviter: owner)outsider = new_user()assert {:error, :permission_denied} =- TeamRolePermissions.ensure_can_grant_for_invitation(team, outsider, nil, :viewer)+ TeamRolePermissions.ensure_can_change_invitation_role(+ team,+ outsider,+ invitation,+ :editor+ )+ end+ end++ describe "ensure_can_invite/3" do+ setup [:create_user, :create_team]++ test "allows a role the actor's role permits", %{team: team} do+ admin = add_member(team, role: :admin)++ assert :ok = TeamRolePermissions.ensure_can_invite(team, admin, :editor)+ end++ test "denies a role the actor's role doesn't permit", %{team: team} do+ admin = add_member(team, role: :admin)++ assert {:error, :permission_denied} =+ TeamRolePermissions.ensure_can_invite(team, admin, :owner)+ end++ for actor_role <- [:editor, :viewer, :billing] do+ test "as #{@as[actor_role]}, I cannot invite anyone", %{team: team} do+ actor = add_member(team, role: unquote(actor_role))++ assert {:error, :permission_denied} =+ TeamRolePermissions.ensure_can_invite(team, actor, :viewer)+ end+ end++ for invalid_role <- [:guest, :unknown, "admin"] do+ test "raises for an invalid role (#{inspect(invalid_role)})", %{+ user: owner,+ team: team+ } do+ assert_raise ArgumentError, fn ->+ TeamRolePermissions.ensure_can_invite(team, owner, unquote(invalid_role))+ end+ end+ end++ test "returns permission error when the actor is not a member of the team", %{team: team} do+ outsider = new_user()++ assert {:error, :permission_denied} =+ TeamRolePermissions.ensure_can_invite(team, outsider, :viewer)+ end+ end++ describe "can_manage_team?/1" do+ for role <- [:owner, :admin] do+ test "#{@as[role]} can manage the team" do+ assert TeamRolePermissions.can_manage_team?(unquote(role))+ end+ end++ for role <- [:editor, :viewer, :billing, :guest] do+ test "#{@as[role]} cannot manage the team" do+ refute TeamRolePermissions.can_manage_team?(unquote(role))+ endendenddiff --git a/test/plausible_web/live/customer_support/teams_test.exs b/test/plausible_web/live/customer_support/teams_test.exsindex 8216d120c2..fccfe23b2f 100644--- a/test/plausible_web/live/customer_support/teams_test.exs+++ b/test/plausible_web/live/customer_support/teams_test.exs@@ -336,6 +336,25 @@ defmodule PlausibleWeb.Live.CustomerSupport.TeamsTest doenddescribe "members" do+ test "lists members linking to their user page, and pending invitations without a link",+ %{conn: conn, user: user} do+ team = team_of(user)+ member = add_member(team, user: new_user(email: "[email protected]"), role: :editor)+ invite_member(team, "[email protected]", role: :viewer, inviter: user)++ {:ok, _lv, html} = live(conn, open_team(team.id, tab: "members"))++ assert text_of_element(html, ~s|a[href="#{~p"/cs/users/user/#{member.id}"}"]|) =~++ rows = html |> find("tbody tr") |> Enum.map(&text/1)++ assert Enum.any?(rows, &(&1 =~ "[email protected]" and &1 =~ "membership"))+ assert Enum.any?(rows, &(&1 =~ "[email protected]" and &1 =~ "invitation"))++ refute html |> find("tbody a") |> text() =~ "[email protected]"+ end+test "shows no suppression warning for a member whose e-mail isn't suppressed", %{conn: conn,user: user