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
defmodule PlausibleWeb.Live.TeamManagement do
@moduledoc """
Live view for applying team membership adjustments.
"""
use PlausibleWeb, :live_view
alias Plausible.Teams
alias Plausible.Teams.TeamRolePermissions
alias Plausible.Auth.User
import PlausibleWeb.Live.Components.Team
alias Plausible.Teams.Management.Roster
def mount(_params, _session, socket) do
{:ok, reset(socket)}
end
defp reset(%{assigns: %{current_user: current_user, current_team: current_team}} = socket) do
{:ok, my_role} = Teams.Memberships.team_role(current_team, current_user)
roster = Roster.init(current_team)
team_members_limit = Plausible.Teams.Billing.team_member_limit(current_team)
assign(socket,
team_members_limit: team_members_limit,
roster: roster,
my_role: my_role,
input_email: ""
)
end
def render(assigns) do
~H"""
<.flash_messages flash={@flash} />
<PlausibleWeb.Components.Billing.Notice.limit_exceeded
:if={@team_members_limit != 0 and at_limit?(@roster, @team_members_limit)}
current_user={@current_user}
current_team={@current_team}
limit={@team_members_limit}
resource="members"
class="mb-4"
/>
<div>
<.form id="team-layout-form" for={} phx-submit="input-invitation" phx-change="form-changed">
<div class="flex gap-x-3 mb-8">
<div class="flex-1">
<.input
name="input-email"
type="email"
value={@input_email}
placeholder="Enter e-mail"
phx-debounce={200}
readonly={
at_limit?(@roster, @team_members_limit) or
not TeamRolePermissions.can_manage_team?(@my_role)
}
/>
</div>
<.role_select_input
id="input-role-picker"
name="input-role"
role={:viewer}
my_role={@my_role}
/>
<.button
id="invite-member"
type="submit"
disabled={
at_limit?(@roster, @team_members_limit) or
not TeamRolePermissions.can_manage_team?(@my_role)
}
>
Invite
</.button>
</div>
</.form>
<div id="member-list">
<.member
: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?={me?(entry, @current_user)}
pending?={Roster.Entry.invitation?(entry)}
my_role={@my_role}
remove_disabled={not Roster.removable?(@roster, email)}
disabled={
(entry.role == :owner && Roster.owners_count(@roster) == 1) or
not TeamRolePermissions.can_manage_team?(@my_role)
}
/>
</div>
<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
</span>
<hr class="grow border-t border-gray-200 dark:border-gray-700" />
</div>
<div :if={Roster.has_guests?(@roster)} id="guest-list">
<.member
: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?={Roster.Entry.invitation?(entry)}
my_role={@my_role}
remove_disabled={not Roster.removable?(@roster, email)}
role_change_disabled={Roster.Entry.invitation?(entry)}
disabled={not TeamRolePermissions.can_manage_team?(@my_role)}
/>
</div>
</div>
"""
end
def handle_event("form-changed", params, socket) do
{:noreply, assign(socket, input_email: params["input-email"])}
end
def handle_event(
"input-invitation",
%{"input-email" => email, "input-role" => role},
%{assigns: %{current_team: team, current_user: current_user}} = socket
) do
email = String.trim(email)
role = role_to_atom(role)
socket = assign(socket, input_email: email)
socket =
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,
: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: %{roster: roster}} = socket) do
{:noreply, remove(socket, Map.fetch!(roster, email))}
end
def handle_event(
"update-role",
%{"email" => email, "role" => role},
%{assigns: %{roster: roster}} = socket
) do
{:noreply, update_role(socket, Map.fetch!(roster, email), role_to_atom(role))}
end
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
{:ok, _} when myself? ->
socket
|> put_flash(:success, "You have left the team")
|> redirect(to: ~p"/sites?#{[__team: "none"]}")
{:ok, _} ->
socket
|> reset()
|> put_live_flash(:success, "#{membership.user.email} has been removed from the team")
{: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, %Roster.Entry{source: %Teams.Invitation{} = invitation}) do
%{current_team: team, current_user: current_user} = socket.assigns
case Teams.Invitations.RemoveFromTeam.remove(
reload!(team),
invitation.invitation_id,
current_user
) do
{:ok, _} ->
socket
|> reset()
|> put_live_flash(:success, "The invitation for #{invitation.email} has been removed")
{:error, reason}
when reason in [:invitation_not_found, :permission_denied, :not_a_member] ->
put_error_flash(socket, reason)
end
end
defp update_role(socket, %Roster.Entry{source: %Teams.Membership{} = membership}, role) do
%{current_team: team, current_user: current_user} = socket.assigns
demoting_myself? =
membership.user.id == current_user.id and
not TeamRolePermissions.can_manage_team?(role)
case Teams.Memberships.UpdateRole.update(
reload!(team),
membership.user.id,
role,
current_user
) do
{:ok, _} when demoting_myself? ->
socket
|> put_flash(:success, "Your role has been changed to #{role_name(role)}")
|> redirect(to: ~p"/settings/team/general?#{[__team: team.identifier]}")
{:ok, _} ->
socket
|> reset()
|> put_live_flash(
:success,
"#{membership.user.email}'s role has been changed to #{role_name(role)}"
)
|> animate_role_change(membership.user.email)
{: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, %Roster.Entry{source: %Teams.Invitation{} = invitation}, role) do
%{current_team: team, current_user: current_user} = socket.assigns
case Teams.Invitations.UpdateRole.update(
reload!(team),
invitation.invitation_id,
role,
current_user
) do
{:ok, _} ->
socket
|> reset()
|> put_live_flash(
:success,
"The invitation for #{invitation.email} now has the #{role_name(role)} role"
)
|> animate_role_change(invitation.email)
{: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)}",
attr: "data-role-changed"
})
end
defp reload!(team), do: Plausible.Repo.reload!(team)
defp role_name(role), do: role |> to_string() |> String.capitalize()
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(%Roster.Entry{source: %{user: %{id: id, type: :sso}}}, %{id: id}),
do: "You (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
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?(
map_size(roster) - 1,
limit
)
end
end