Skip to content

Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.

[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.ex
index 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 do
import PlausibleWeb.CustomerSupport.Live
import PlausibleWeb.CustomerSupport.Components.SuppressionWarning
alias Plausible.Teams
+ alias Plausible.Teams.Management.Roster
def update(%{team: team}, socket) do
{:ok, refresh_members(socket, team)}
@@ -14,7 +15,7 @@ defmodule PlausibleWeb.CustomerSupport.Team.Components.Members do
def 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">
<img
src={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 do
end
defp 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"
end
end
diff --git a/lib/plausible/teams.ex b/lib/plausible/teams.ex
index 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 in
a 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.ex
index c715d11663..0da75cb9bf 100644
--- a/lib/plausible/teams/invitations.ex
+++ b/lib/plausible/teams/invitations.ex
@@ -588,26 +588,6 @@ defmodule Plausible.Teams.Invitations do
end
@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) do
check_permissions? = Keyword.get(opts, :check_permissions, true)
@@ -660,7 +640,7 @@ defmodule Plausible.Teams.Invitations do
end
end
- def ensure_not_already_invited(%Teams.Team{} = team, invitee_email) do
+ def ensure_no_invitations(%Teams.Team{} = team, invitee_email) do
pending_invitation_role =
Repo.one(
from ti in Teams.Invitation,
@@ -671,8 +651,8 @@ defmodule Plausible.Teams.Invitations do
case pending_invitation_role do
nil -> :ok
- :guest -> {:error, :already_invited_guest}
- _ -> {:error, :already_invited}
+ :guest -> {:error, :invited_as_guest}
+ _ -> {:error, :invited_as_member}
end
end
diff --git a/lib/plausible/teams/invitations/invite_to_team.ex b/lib/plausible/teams/invitations/invite_to_team.ex
index 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 do
alias Plausible.Repo
alias 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 do
defp do_invite(team, inviter, invitee_email, role) do
with :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) do
Teams.Invitations.invite(team, invitee_email, role, inviter)
end
end
diff --git a/lib/plausible/teams/invitations/update_role.ex b/lib/plausible/teams/invitations/update_role.ex
index 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 do
with {: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.ex
deleted file mode 100644
index 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
-end
diff --git a/lib/plausible/teams/management/layout/entry.ex b/lib/plausible/teams/management/layout/entry.ex
deleted file mode 100644
index 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
-end
diff --git a/lib/plausible/teams/management/roster.ex b/lib/plausible/teams/management/roster.ex
new file mode 100644
index 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
+end
diff --git a/lib/plausible/teams/management/roster/entry.ex b/lib/plausible/teams/management/roster/entry.ex
new file mode 100644
index 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
+end
diff --git a/lib/plausible/teams/memberships/update_role.ex b/lib/plausible/teams/memberships/update_role.ex
index 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 do
def update(%Teams.Team{} = team, user_id, new_role, current_user) do
with {: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.ex
index 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 (the
last 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 do
def 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 of
someone 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}
end
end
@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}
end
end
@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: false
end
diff --git a/lib/plausible_web/live/components/team.ex b/lib/plausible_web/live/components/team.ex
index 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 do
defp selectable_role_descriptions(my_role) do
Enum.filter(@role_descriptions, fn {role, _description} ->
- TeamRolePermissions.ensure_can_grant_role(my_role, role) == :ok
+ TeamRolePermissions.can_assign?(my_role, role)
end)
end
diff --git a/lib/plausible_web/live/team_management.ex b/lib/plausible_web/live/team_management.ex
index 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 do
alias Plausible.Auth.User
import PlausibleWeb.Live.Components.Team
- alias Plausible.Teams.Management.Layout
+ alias Plausible.Teams.Management.Roster
def mount(_params, _session, socket) do
{:ok, reset(socket)}
@@ -18,12 +18,12 @@ defmodule PlausibleWeb.Live.TeamManagement do
defp 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 do
placeholder="Enter e-mail"
phx-debounce={200}
readonly={
- at_limit?(@layout, @team_members_limit) or
+ at_limit?(@roster, @team_members_limit) or
not TeamRolePermissions.can_manage_team?(@my_role)
}
/>
@@ -69,7 +69,7 @@ defmodule PlausibleWeb.Live.TeamManagement do
id="invite-member"
type="submit"
disabled={
- at_limit?(@layout, @team_members_limit) or
+ at_limit?(@roster, @team_members_limit) or
not 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) or
not 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 do
socket = 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))}
end
def 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.assigns
myself? = 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)
end
end
- 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.assigns
case 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)
end
end
- 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.assigns
demoting_myself? =
@@ -249,7 +221,7 @@ defmodule PlausibleWeb.Live.TeamManagement do
not 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)
end
end
- 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.assigns
case 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)
end
end
+ 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) do
push_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) do
not Plausible.Billing.Quota.below_limit?(
- Layout.active_count(layout) - 1,
+ map_size(roster) - 1,
limit
)
end
diff --git a/lib/plausible_web/live/team_setup.ex b/lib/plausible_web/live/team_setup.ex
index 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.exs
index 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" do
test "creates invitations with a role per entry, without sending e-mails" do
inviter = new_user()
@@ -267,6 +58,21 @@ defmodule Plausible.Teams.Invitations.InviteToTeamTest do
end
end
+ 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" do
inviter = new_user()
invitee = new_user()
@@ -286,7 +92,7 @@ defmodule Plausible.Teams.Invitations.InviteToTeamTest do
team = 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 do
existing_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.exs
index 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 do
UpdateRole.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
} do
diff --git a/test/plausible/teams/management/layout_test.exs b/test/plausible/teams/management/layout_test.exs
deleted file mode 100644
index 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}},
- %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}},
- %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",
- ),
- 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
-end
diff --git a/test/plausible/teams/management/roster_test.exs b/test/plausible/teams/management/roster_test.exs
new file mode 100644
index 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{}}},
+ %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{}},
+ %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
+end
diff --git a/test/plausible/teams/team_role_permissions_test.exs b/test/plausible/teams/team_role_permissions_test.exs
index 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 do
guest: "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" do
for current_role <- @roles do
test "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))
end
end
for current_role <- [:admin, :editor, :viewer] do
test "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))
end
end
for current_role <- [:owner, :billing, :guest] do
test "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))
end
end
- 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)
end
end
end
- 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" do
for current_role <- @roles do
test "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))
end
end
for current_role <- [:admin, :editor, :viewer, :billing] do
test "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))
end
end
for current_role <- [:owner, :guest] do
test "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))
end
end
- 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)
end
end
end
- 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))
end
end
- 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))
end
end
- 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)
end
end
- 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" do
assert_raise ArgumentError, "invalid role: :guest", fn ->
- TeamRolePermissions.ensure_can_grant_role(unquote(granter_role), :guest)
+ TeamRolePermissions.can_assign?(unquote(actor_role), :guest)
end
end
end
- test "as an owner, I cannot grant an invalid role" do
+ test "as an owner, I cannot assign an invalid role" do
assert_raise ArgumentError, "invalid role: :unknown", fn ->
- TeamRolePermissions.ensure_can_grant_role(:owner, :unknown)
+ TeamRolePermissions.can_assign?(:owner, :unknown)
end
end
- 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" do
assert_raise ArgumentError, ~s(invalid role: "admin"), fn ->
- TeamRolePermissions.ensure_can_grant_role(:owner, "admin")
+ TeamRolePermissions.can_assign?(:owner, "admin")
end
end
end
- describe "ensure_can_grant_for_member/4" do
+ describe "ensure_can_change_member_role/4" do
setup [: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} do
member = 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} do
admin = 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
+ )
end
for invalid_role <- [:guest, :unknown, "admin"] do
@@ -207,7 +149,7 @@ defmodule Plausible.Teams.TeamRolePermissionsTest do
membership = 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 do
end
end
- 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} do
member = 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 do
end
end
- describe "ensure_can_grant_for_invitation/4" do
+ describe "ensure_can_change_invitation_role/4" do
setup [: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} do
admin = 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} do
admin = 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} do
admin = 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 do
user: 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)
)
end
end
end
- 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))
+ end
end
end
diff --git a/test/plausible_web/live/customer_support/teams_test.exs b/test/plausible_web/live/customer_support/teams_test.exs
index 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 do
end
describe "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