Allow admins to grant admin rights (#2216)

* Make sure admin can grant the admin role

* Use `site` and `current_user_role` from conn.assigns to avoid extra lookups

* Add some missing documentation

* Restrict owners in the `update_role` action

* Move @moduledoc to appropriate location

* Use Ecto.Enum to get role atoms

* Remove unused functionality

* Ensure that owners cannot lock themselves out

* Add question mark to `can_grant_role`

Co-authored-by: Adam Rutkowski <hq@mtod.org>

* Use strict short-circuit operator for booleans

Co-authored-by: Adam Rutkowski <hq@mtod.org>

Co-authored-by: Adam Rutkowski <hq@mtod.org>
pull/2242/head
Uku Taht 4 years ago committed by GitHub
parent b239f73a6d
commit 5d4918b66b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

@ -14,17 +14,5 @@ defmodule Plausible.Site.Membership do
schema
|> cast(attrs, [:user_id, :site_id, :role])
|> validate_required([:user_id, :site_id])
|> validate_inclusion(:role, valid_roles(schema.role))
end
def override_role(schema, role) do
schema
|> change(%{role: role})
|> validate_required([:user_id, :site_id, :role])
end
defp valid_roles(_prev_role = nil), do: [:owner, :admin, :viewer]
defp valid_roles(:owner), do: [:owner, :admin, :viewer]
defp valid_roles(:admin), do: [:admin, :viewer]
defp valid_roles(:viewer), do: [:viewer]
end

@ -27,7 +27,7 @@ defmodule PlausibleWeb.InvitationController do
membership_changeset =
(existing_membership ||
%Membership{user_id: user.id, site_id: invitation.site.id})
|> Membership.override_role(invitation.role)
|> Membership.changeset(%{role: invitation.role})
multi =
multi

@ -1,4 +1,15 @@
defmodule PlausibleWeb.Site.MembershipController do
@moduledoc """
This controller deals with user management via the UI in Site Settings -> People. It's important to enforce permissions in this controller.
Owner - Can manage users, can trigger a 'transfer ownership' request
Admin - Can manage users
Viewer - Can not access user management settings
Anyone - Can accept invitations
Everything else should be explicitly disallowed.
"""
use PlausibleWeb, :controller
use Plausible.Repo
alias Plausible.Sites
@ -101,28 +112,66 @@ defmodule PlausibleWeb.Site.MembershipController do
|> redirect(to: Routes.site_path(conn, :settings_people, site.domain))
end
def update_role(conn, %{"id" => id, "new_role" => new_role}) do
membership =
Repo.get!(Membership, id)
|> Repo.preload([:site, :user])
|> Membership.changeset(%{role: new_role})
|> Repo.update!()
@doc """
Updates the role of a user. The user being updated could be the same or different from the user taking
the action. When updating the role, it's important to enforce permissions:
redirect_target =
if membership.user.id == conn.assigns[:current_user].id && new_role == "viewer" do
"/#{URI.encode_www_form(membership.site.domain)}"
Owner - Can update anyone's role except for themselves. If they want to change their own role, they have to use the 'transfer ownership' feature.
Admin - Can update anyone's role except for owners. Can downgrade their own access to 'viewer'. Can promote a viewer to admin.
"""
@role_mappings Membership
|> Ecto.Enum.mappings(:role)
|> Enum.map(fn {k, v} -> {v, k} end)
|> Enum.into(%{})
def update_role(conn, %{"id" => id, "new_role" => new_role_str}) do
%{site: site, current_user: current_user, current_user_role: current_user_role} = conn.assigns
membership = Repo.get!(Membership, id) |> Repo.preload(:user)
new_role = Map.fetch!(@role_mappings, new_role_str)
can_grant_role? =
if membership.user.id == current_user.id do
can_grant_role_to_self?(current_user_role, new_role)
else
Routes.site_path(conn, :settings_people, membership.site.domain)
can_grant_role_to_other?(current_user_role, new_role)
end
conn
|> put_flash(
:success,
"#{membership.user.name} is now #{PlausibleWeb.SiteView.with_indefinite_article(new_role)}"
)
|> redirect(to: redirect_target)
if can_grant_role? do
membership =
membership
|> Membership.changeset(%{role: new_role})
|> Repo.update!()
redirect_target =
if membership.user.id == current_user.id and new_role == :viewer do
"/#{URI.encode_www_form(site.domain)}"
else
Routes.site_path(conn, :settings_people, site.domain)
end
conn
|> put_flash(
:success,
"#{membership.user.name} is now #{PlausibleWeb.SiteView.with_indefinite_article(new_role_str)}"
)
|> redirect(to: redirect_target)
else
conn
|> put_flash(:error, "You are not allowed to grant the #{new_role} role")
|> redirect(to: Routes.site_path(conn, :settings_people, site.domain))
end
end
defp can_grant_role_to_self?(:admin, :viewer), do: true
defp can_grant_role_to_self?(_, _), do: false
defp can_grant_role_to_other?(:owner, :admin), do: true
defp can_grant_role_to_other?(:owner, :viewer), do: true
defp can_grant_role_to_other?(:admin, :admin), do: true
defp can_grant_role_to_other?(:admin, :viewer), do: true
defp can_grant_role_to_other?(_, _), do: false
def remove_member(conn, %{"id" => id}) do
membership =
Repo.get!(Membership, id)

@ -160,7 +160,10 @@ defmodule PlausibleWeb.Site.MembershipControllerTest do
assert redirected_to(conn) == "/#{site.domain}"
end
test "admin can't make themselves an owner", %{conn: conn, user: user} do
test "owner cannot make anyone else owner", %{
conn: conn,
user: user
} do
admin = insert(:user)
site =
@ -173,13 +176,73 @@ defmodule PlausibleWeb.Site.MembershipControllerTest do
membership = Repo.get_by(Plausible.Site.Membership, user_id: admin.id)
assert_raise Ecto.InvalidChangesetError, fn ->
put(conn, "/sites/#{site.domain}/memberships/#{membership.id}/role/owner")
end
conn = put(conn, "/sites/#{site.domain}/memberships/#{membership.id}/role/owner")
membership = Repo.reload!(membership)
assert membership.role == :admin
assert get_flash(conn, :error) == "You are not allowed to grant the owner role"
end
test "owner cannot downgrade themselves", %{
conn: conn,
user: user
} do
site = insert(:site, memberships: [build(:site_membership, user: user, role: :owner)])
membership = Repo.get_by(Plausible.Site.Membership, user_id: user.id)
conn = put(conn, "/sites/#{site.domain}/memberships/#{membership.id}/role/admin")
membership = Repo.reload!(membership)
assert membership.role == :owner
assert get_flash(conn, :error) == "You are not allowed to grant the admin role"
end
test "admin can make another user admin", %{
conn: conn,
user: user
} do
viewer = insert(:user)
site =
insert(:site,
memberships: [
build(:site_membership, user: user, role: :admin),
build(:site_membership, user: viewer, role: :viewer)
]
)
viewer_membership = Repo.get_by(Plausible.Site.Membership, user_id: viewer.id)
conn = put(conn, "/sites/#{site.domain}/memberships/#{viewer_membership.id}/role/admin")
viewer_membership = Repo.reload!(viewer_membership)
assert viewer_membership.role == :admin
assert redirected_to(conn) == "/#{site.domain}/settings/people"
end
test "admin can't make themselves an owner", %{conn: conn, user: user} do
owner = insert(:user)
site =
insert(:site,
memberships: [
build(:site_membership, user: owner, role: :owner),
build(:site_membership, user: user, role: :admin)
]
)
membership = Repo.get_by(Plausible.Site.Membership, user_id: user.id)
conn = put(conn, "/sites/#{site.domain}/memberships/#{membership.id}/role/owner")
membership = Repo.reload!(membership)
assert membership.role == :admin
assert get_flash(conn, :error) == "You are not allowed to grant the owner role"
end
end

Loading…
Cancel
Save