diff --git a/src/SlpModularCms.Core.Tests/Identity/DateTimeOffsetRoundTripTests.cs b/src/SlpModularCms.Core.Tests/Identity/DateTimeOffsetRoundTripTests.cs new file mode 100644 index 0000000..aa6aa02 --- /dev/null +++ b/src/SlpModularCms.Core.Tests/Identity/DateTimeOffsetRoundTripTests.cs @@ -0,0 +1,67 @@ +using FluentAssertions; +using Microsoft.EntityFrameworkCore; +using MySql.Data.MySqlClient; +using SlpModularCms.Core.Data; +using SlpModularCms.Core.Identity.Entities; + +namespace SlpModularCms.Core.Tests.Identity; + +/// +/// Evidence that an invitation keeps its full lifetime through the real MySQL/MariaDB storage: +/// DateTimeOffset is stored in a datetime column (no offset), so a provider that +/// stored local time but read it as UTC (or the reverse) would silently shorten or lengthen it. +/// +/// +/// Needs a reachable MariaDB, taken from ConnectionStrings__DefaultConnection (set in CI; the +/// same variable the Api tests use). It uses its OWN database, created and dropped here, never the +/// one named in the variable. Without the variable the test does nothing, so a plain +/// dotnet test on a machine without MariaDB stays green. +/// +public class DateTimeOffsetRoundTripTests +{ + private static string? ScratchConnectionString() + { + var raw = Environment.GetEnvironmentVariable("ConnectionStrings__DefaultConnection"); + if (string.IsNullOrWhiteSpace(raw)) return null; + var builder = new MySqlConnectionStringBuilder(raw) { Database = "roundtrip_datetime_probe" }; + return builder.ConnectionString; + } + + [Theory] + [InlineData(0)] + [InlineData(1)] + [InlineData(2)] + [InlineData(-5)] + public async Task ExpiryDate_SurvivesTheDatabase_WhateverOffsetItWasWrittenWith(int offsetHours) + { + var cs = ScratchConnectionString(); + if (cs is null) return; // no MariaDB available here, see remarks + + var options = new DbContextOptionsBuilder().UseMySQL(cs).Options; + var instant = DateTimeOffset.UtcNow.AddHours(24); + var written = instant.ToOffset(TimeSpan.FromHours(offsetHours)); + + await using (var db = new ApplicationDbContext(options)) + { + await db.Database.EnsureDeletedAsync(); + await db.Database.EnsureCreatedAsync(); + db.Invitations.Add(new Invitation { Email = "a@b.nl", Role = "User", Token = "t", ExpiryDate = written }); + await db.SaveChangesAsync(); + } + + try + { + await using var db = new ApplicationDbContext(options); + var read = (await db.Invitations.AsNoTracking().SingleAsync()).ExpiryDate; + + // The column keeps whole seconds only, so compare within a second. + (read - instant).Duration().Should().BeLessThan(TimeSpan.FromSeconds(1.5)); + (read - DateTimeOffset.UtcNow).TotalHours.Should().BeApproximately(24, 0.01); + } + finally + { + await using var cleanup = new ApplicationDbContext(options); + await cleanup.Database.EnsureDeletedAsync(); + } + } +} diff --git a/src/SlpModularCms.Core.Tests/Identity/InvitationServiceTests.cs b/src/SlpModularCms.Core.Tests/Identity/InvitationServiceTests.cs index 762cc5d..c62bb87 100644 --- a/src/SlpModularCms.Core.Tests/Identity/InvitationServiceTests.cs +++ b/src/SlpModularCms.Core.Tests/Identity/InvitationServiceTests.cs @@ -363,4 +363,35 @@ public class InvitationServiceTests (await _service.DeleteInvitationByIdAsync(inv.Id)).Should().BeTrue(); (await _context.Invitations.AnyAsync()).Should().BeFalse(); } + + [Fact] + public async Task RegenerateInvitationAsync_GivesANewTokenAndLifetime_AndTheOldLinkStopsWorking() + { + var oldToken = await _service.CreateInvitationAsync("again@example.com", "User"); + var inv = await _context.Invitations.SingleAsync(); + inv.ExpiryDate = DateTimeOffset.UtcNow.AddHours(-3); // expired + await _context.SaveChangesAsync(); + + var newToken = await _service.RegenerateInvitationAsync(inv.Id); + + newToken.Should().NotBeNullOrEmpty().And.NotBe(oldToken); + (await _service.ValidateInvitationAsync(oldToken)).Should().BeFalse(); + (await _service.ValidateInvitationAsync(newToken!)).Should().BeTrue(); + var reloaded = await _context.Invitations.AsNoTracking().SingleAsync(); + (reloaded.ExpiryDate - DateTimeOffset.UtcNow).Should().BeCloseTo(TimeSpan.FromHours(24), TimeSpan.FromMinutes(1)); + reloaded.Email.Should().Be("again@example.com"); + } + + [Fact] + public async Task RegenerateInvitationAsync_ReturnsNull_ForUnknownOrAcceptedInvitations() + { + (await _service.RegenerateInvitationAsync(Guid.NewGuid())).Should().BeNull(); + + var token = await _service.CreateInvitationAsync("done@example.com", "User"); + var inv = await _context.Invitations.SingleAsync(i => i.Token == token); + inv.IsAccepted = true; + await _context.SaveChangesAsync(); + + (await _service.RegenerateInvitationAsync(inv.Id)).Should().BeNull(); + } } diff --git a/src/SlpModularCms.Core/Identity/Authorization/UserManagementRules.cs b/src/SlpModularCms.Core/Identity/Authorization/UserManagementRules.cs new file mode 100644 index 0000000..811645a --- /dev/null +++ b/src/SlpModularCms.Core/Identity/Authorization/UserManagementRules.cs @@ -0,0 +1,24 @@ +namespace SlpModularCms.Core.Identity.Authorization; + +/// +/// Who may act on whom in user management. One place, enforced by the API and mirrored by the UI. +/// +/// +/// An Owner may manage everyone. An Administrator may manage only plain Users, never another +/// Administrator or an Owner, and may not hand out the Owner role. The "at least one Owner must +/// remain" rule is separate and stays in the controller. +/// +public static class UserManagementRules +{ + public const string Owner = "Owner"; + public const string Administrator = "Administrator"; + public const string User = "User"; + + /// May the requester delete, (de)activate, re-role or withdraw an invitation of a target holding this role? + public static bool CanManage(string requesterRole, string targetRole) => + requesterRole == Owner || (requesterRole == Administrator && targetRole == User); + + /// May the requester give somebody (or an invitation) this role? + public static bool CanAssign(string requesterRole, string role) => + requesterRole == Owner || (requesterRole == Administrator && role != Owner); +} diff --git a/src/SlpModularCms.Core/Identity/Services/IInvitationService.cs b/src/SlpModularCms.Core/Identity/Services/IInvitationService.cs index 1a57a10..8dcdc5b 100644 --- a/src/SlpModularCms.Core/Identity/Services/IInvitationService.cs +++ b/src/SlpModularCms.Core/Identity/Services/IInvitationService.cs @@ -46,4 +46,10 @@ public interface IInvitationService /// Wijzigt de rol van een pending uitnodiging. Retourneert false als niet gevonden. /// Task UpdateInvitationRoleAsync(Guid invitationId, string newRole); + + /// + /// Geeft een openstaande (ook verlopen) uitnodiging een nieuw token en een nieuwe geldigheid; het oude + /// token werkt daarna niet meer. Retourneert het nieuwe token, of null als niet gevonden. + /// + Task RegenerateInvitationAsync(Guid invitationId); } diff --git a/src/SlpModularCms.Core/Identity/Services/InvitationService.cs b/src/SlpModularCms.Core/Identity/Services/InvitationService.cs index 0c14abd..33fff9e 100644 --- a/src/SlpModularCms.Core/Identity/Services/InvitationService.cs +++ b/src/SlpModularCms.Core/Identity/Services/InvitationService.cs @@ -157,6 +157,18 @@ public class InvitationService : IInvitationService return true; } + public async Task RegenerateInvitationAsync(Guid invitationId) + { + var invitation = await _context.Invitations + .FirstOrDefaultAsync(i => i.Id == invitationId && !i.IsAccepted); + if (invitation is null) return null; + + invitation.Token = GenerateSecureToken(); + invitation.ExpiryDate = DateTimeOffset.UtcNow.AddHours(_settings.ExpiryHours); + await _context.SaveChangesAsync(); + return invitation.Token; + } + private static string GenerateSecureToken() { var bytes = new byte[32]; diff --git a/src/SlpModularCms.Modules.Identity.Tests/Controllers/UsersControllerRoleHierarchyTests.cs b/src/SlpModularCms.Modules.Identity.Tests/Controllers/UsersControllerRoleHierarchyTests.cs new file mode 100644 index 0000000..b5b7586 --- /dev/null +++ b/src/SlpModularCms.Modules.Identity.Tests/Controllers/UsersControllerRoleHierarchyTests.cs @@ -0,0 +1,333 @@ +using System.Security.Claims; +using FluentAssertions; +using Microsoft.AspNetCore.Http; +using Microsoft.AspNetCore.Identity; +using Microsoft.AspNetCore.Identity.EntityFrameworkCore; +using Microsoft.AspNetCore.Mvc; +using Microsoft.EntityFrameworkCore; +using Microsoft.Extensions.Logging.Abstractions; +using Microsoft.Extensions.Options; +using NSubstitute; +using SlpModularCms.Core.Data; +using SlpModularCms.Core.Identity.Authorization; +using SlpModularCms.Core.Identity.Entities; +using SlpModularCms.Core.Identity.Models; +using SlpModularCms.Core.Identity.Services; +using SlpModularCms.Modules.Identity.Controllers; + +namespace SlpModularCms.Modules.Identity.Tests.Controllers; + +/// +/// Who may act on whom, enforced by the API itself (the UI only mirrors it): an Administrator reaches +/// plain Users only; Owners and Administrators are an Owner's to manage; the last Owner stays. +/// +public class UsersControllerRoleHierarchyTests : IDisposable +{ + private readonly ApplicationDbContext _context; + private readonly UserManager _userManager; + private readonly RoleManager _roleManager; + private readonly IInvitationService _invitations = Substitute.For(); + + public UsersControllerRoleHierarchyTests() + { + var dbOptions = new DbContextOptionsBuilder() + .UseInMemoryDatabase(Guid.NewGuid().ToString()) + .Options; + _context = new ApplicationDbContext(dbOptions); + + _userManager = new UserManager( + new UserStore(_context), + Options.Create(new IdentityOptions()), + new PasswordHasher(), + Array.Empty>(), + Array.Empty>(), + new UpperInvariantLookupNormalizer(), + new IdentityErrorDescriber(), + null!, + NullLogger>.Instance); + + _roleManager = new RoleManager( + new RoleStore(_context), + Array.Empty>(), + new UpperInvariantLookupNormalizer(), + new IdentityErrorDescriber(), + NullLogger>.Instance); + + _invitations.GetAllPendingInvitationsAsync().Returns(new List()); + } + + public void Dispose() + { + _userManager.Dispose(); + _roleManager.Dispose(); + _context.Dispose(); + } + + private async Task Add(string email, string role) + { + if (!await _roleManager.RoleExistsAsync(role)) + await _roleManager.CreateAsync(new ApplicationRole { Name = role }); + + var user = new ApplicationUser + { + Id = Guid.NewGuid(), Email = email, UserName = email, + NormalizedEmail = email.ToUpperInvariant(), NormalizedUserName = email.ToUpperInvariant(), + DisplayName = email, IsActive = true, CreatedAt = DateTimeOffset.UtcNow + }; + await _userManager.CreateAsync(user, "Password1!"); + await _userManager.AddToRoleAsync(user, role); + return user; + } + + private UsersController As(ApplicationUser caller) + { + var controller = new UsersController(_invitations, _userManager); + controller.ControllerContext = new ControllerContext + { + HttpContext = new DefaultHttpContext + { + User = new ClaimsPrincipal(new ClaimsIdentity([new Claim(ClaimTypes.Name, caller.UserName!)], "Test")) + } + }; + return controller; + } + + private void OpenInvitation(Guid id, string role) => + _invitations.GetAllPendingInvitationsAsync().Returns(new List + { + new(id, "invited@test.com", role, "tok", DateTimeOffset.UtcNow) + }); + + // --- rules --- + + [Theory] + [InlineData("Owner", "Owner", true)] + [InlineData("Owner", "Administrator", true)] + [InlineData("Owner", "User", true)] + [InlineData("Administrator", "User", true)] + [InlineData("Administrator", "Administrator", false)] + [InlineData("Administrator", "Owner", false)] + [InlineData("User", "User", false)] + public void CanManage_FollowsTheHierarchy(string requester, string target, bool expected) => + UserManagementRules.CanManage(requester, target).Should().Be(expected); + + [Theory] + [InlineData("Owner", "Owner", true)] + [InlineData("Administrator", "Administrator", true)] + [InlineData("Administrator", "User", true)] + [InlineData("Administrator", "Owner", false)] + public void CanAssign_AdministratorNeverHandsOutOwner(string requester, string role, bool expected) => + UserManagementRules.CanAssign(requester, role).Should().Be(expected); + + // --- delete --- + + [Theory] + [InlineData("Owner")] + [InlineData("Administrator")] + public async Task Administrator_CannotDelete_OwnerOrAdministrator(string targetRole) + { + var admin = await Add("admin@test.com", "Administrator"); + var target = await Add("target@test.com", targetRole); + + (await As(admin).DeleteUser(target.Id)).Should().BeOfType(); + + (await _userManager.FindByIdAsync(target.Id.ToString())).Should().NotBeNull(); + } + + [Fact] + public async Task Administrator_CanDelete_PlainUser() + { + var admin = await Add("admin@test.com", "Administrator"); + var target = await Add("target@test.com", "User"); + + (await As(admin).DeleteUser(target.Id)).Should().BeOfType(); + } + + [Theory] + [InlineData("Administrator")] + [InlineData("User")] + public async Task Owner_CanDelete_AdministratorAndUser(string targetRole) + { + var owner = await Add("owner@test.com", "Owner"); + var target = await Add("target@test.com", targetRole); + + (await As(owner).DeleteUser(target.Id)).Should().BeOfType(); + } + + [Fact] + public async Task Administrator_CannotWithdraw_AnInvitationForAnAdministrator_ButCanForAUser() + { + var admin = await Add("admin@test.com", "Administrator"); + var id = Guid.NewGuid(); + + OpenInvitation(id, "Administrator"); + (await As(admin).DeleteUser(id)).Should().BeOfType(); + await _invitations.DidNotReceive().DeleteInvitationByIdAsync(Arg.Any()); + + OpenInvitation(id, "User"); + _invitations.DeleteInvitationByIdAsync(id).Returns(true); + (await As(admin).DeleteUser(id)).Should().BeOfType(); + } + + [Fact] + public async Task Owner_CanWithdraw_AnyInvitation() + { + var owner = await Add("owner@test.com", "Owner"); + var id = Guid.NewGuid(); + OpenInvitation(id, "Administrator"); + _invitations.DeleteInvitationByIdAsync(id).Returns(true); + + (await As(owner).DeleteUser(id)).Should().BeOfType(); + } + + // --- deactivate --- + + [Theory] + [InlineData("Owner")] + [InlineData("Administrator")] + public async Task Administrator_CannotDeactivate_OwnerOrAdministrator(string targetRole) + { + var admin = await Add("admin@test.com", "Administrator"); + var target = await Add("target@test.com", targetRole); + + (await As(admin).SetUserActive(target.Id, new SetUserActiveRequest(false))).Should().BeOfType(); + + (await _userManager.FindByIdAsync(target.Id.ToString()))!.IsActive.Should().BeTrue(); + } + + [Fact] + public async Task Administrator_CanDeactivate_PlainUser() + { + var admin = await Add("admin@test.com", "Administrator"); + var target = await Add("target@test.com", "User"); + + (await As(admin).SetUserActive(target.Id, new SetUserActiveRequest(false))).Should().BeOfType(); + + (await _userManager.FindByIdAsync(target.Id.ToString()))!.IsActive.Should().BeFalse(); + } + + [Fact] + public async Task Owner_CanDeactivate_Administrator() + { + var owner = await Add("owner@test.com", "Owner"); + var target = await Add("target@test.com", "Administrator"); + + (await As(owner).SetUserActive(target.Id, new SetUserActiveRequest(false))).Should().BeOfType(); + } + + // --- change role --- + + [Fact] + public async Task Administrator_CannotChangeTheRole_OfAnotherAdministratorOrOwner() + { + var admin = await Add("admin@test.com", "Administrator"); + var otherAdmin = await Add("other@test.com", "Administrator"); + var owner = await Add("owner@test.com", "Owner"); + + (await As(admin).ChangeRole(otherAdmin.Id, new ChangeRoleRequest("User"))).Should().BeOfType(); + (await As(admin).ChangeRole(owner.Id, new ChangeRoleRequest("User"))).Should().BeOfType(); + } + + [Fact] + public async Task Administrator_CannotMakeAnyoneOwner_NotEvenAPlainUser() + { + var admin = await Add("admin@test.com", "Administrator"); + var user = await Add("user@test.com", "User"); + + (await As(admin).ChangeRole(user.Id, new ChangeRoleRequest("Owner"))).Should().BeOfType(); + + (await _userManager.GetRolesAsync(user)).Should().ContainSingle().Which.Should().Be("User"); + } + + [Fact] + public async Task Administrator_CanPromoteAUserToAdministrator_AndStepDownThemselves() + { + var admin = await Add("admin@test.com", "Administrator"); + var user = await Add("user@test.com", "User"); + + (await As(admin).ChangeRole(user.Id, new ChangeRoleRequest("Administrator"))).Should().BeOfType(); + (await As(admin).ChangeRole(admin.Id, new ChangeRoleRequest("User"))).Should().BeOfType(); + } + + [Fact] + public async Task Administrator_CannotChangeTheRole_OfAnInvitationForAnAdministrator() + { + var admin = await Add("admin@test.com", "Administrator"); + var id = Guid.NewGuid(); + OpenInvitation(id, "Administrator"); + + (await As(admin).ChangeRole(id, new ChangeRoleRequest("User"))).Should().BeOfType(); + await _invitations.DidNotReceive().UpdateInvitationRoleAsync(Arg.Any(), Arg.Any()); + } + + [Fact] + public async Task TheLastOwner_CannotBeDemoted_EvenByThemselves() + { + var owner = await Add("owner@test.com", "Owner"); + + var result = await As(owner).ChangeRole(owner.Id, new ChangeRoleRequest("User")); + + result.Should().BeOfType(); + (await _userManager.GetRolesAsync(owner)).Should().ContainSingle().Which.Should().Be("Owner"); + } + + // --- invite --- + + [Fact] + public async Task Administrator_CannotInviteAnOwner_ButCanInviteAUser() + { + var admin = await Add("admin@test.com", "Administrator"); + _invitations.CreateInvitationAsync("new@test.com", "User").Returns("tok"); + + (await As(admin).Invite(new InviteUserRequest("new@test.com", "Owner"))).Should().BeOfType(); + await _invitations.DidNotReceive().CreateInvitationAsync("new@test.com", "Owner"); + + (await As(admin).Invite(new InviteUserRequest("new@test.com", "User"))).Should().BeOfType(); + } + + [Fact] + public async Task Owner_CanInviteAnOwner() + { + var owner = await Add("owner@test.com", "Owner"); + _invitations.CreateInvitationAsync("new@test.com", "Owner").Returns("tok"); + + (await As(owner).Invite(new InviteUserRequest("new@test.com", "Owner"))).Should().BeOfType(); + } + + // --- regenerate --- + + [Fact] + public async Task RegenerateInvite_ReturnsANewLink_ForAnOpenOrExpiredInvitation() + { + var admin = await Add("admin@test.com", "Administrator"); + var id = Guid.NewGuid(); + OpenInvitation(id, "User"); + _invitations.RegenerateInvitationAsync(id).Returns("new-token"); + + var result = await As(admin).RegenerateInvite(id); + + result.Should().BeOfType().Which.Value + .Should().BeEquivalentTo(new { inviteLink = "/invite/complete?token=new-token" }); + } + + [Fact] + public async Task RegenerateInvite_IsNotFound_ForAnUnknownInvitation() + { + var admin = await Add("admin@test.com", "Administrator"); + + (await As(admin).RegenerateInvite(Guid.NewGuid())).Should().BeOfType(); + } + + [Fact] + public async Task RegenerateInvite_FollowsTheSameHierarchy() + { + var admin = await Add("admin@test.com", "Administrator"); + var owner = await Add("owner@test.com", "Owner"); + var id = Guid.NewGuid(); + OpenInvitation(id, "Administrator"); + _invitations.RegenerateInvitationAsync(id).Returns("new-token"); + + (await As(admin).RegenerateInvite(id)).Should().BeOfType(); + (await As(owner).RegenerateInvite(id)).Should().BeOfType(); + } +} diff --git a/src/SlpModularCms.Modules.Identity/Controllers/UsersController.cs b/src/SlpModularCms.Modules.Identity/Controllers/UsersController.cs index 876e689..5985d9a 100644 --- a/src/SlpModularCms.Modules.Identity/Controllers/UsersController.cs +++ b/src/SlpModularCms.Modules.Identity/Controllers/UsersController.cs @@ -3,6 +3,7 @@ using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Identity; using Microsoft.AspNetCore.Mvc; using Microsoft.EntityFrameworkCore; +using SlpModularCms.Core.Identity.Authorization; using SlpModularCms.Core.Identity.Entities; using SlpModularCms.Core.Identity.Models; using SlpModularCms.Core.Identity.Services; @@ -125,45 +126,61 @@ public class UsersController : ControllerBase [HttpPost("invite")] public async Task Invite([FromBody] InviteUserRequest request) { + var requesterRole = await GetRequesterRoleAsync(); + if (!UserManagementRules.CanAssign(requesterRole, request.Role)) + return Forbid(); + var token = await _invitationService.CreateInvitationAsync(request.Email, request.Role); var inviteLink = $"/invite/complete?token={Uri.EscapeDataString(token)}"; return Ok(new { inviteLink }); } + /// + /// Issues a fresh link for an open (or expired) invitation: new token and a new lifetime. The + /// old link stops working. Until e-mail exists this is how an administrator re-sends one. + /// + [HttpPost("{invitationId:guid}/regenerate-invite")] + public async Task RegenerateInvite(Guid invitationId) + { + var invitationRole = await GetInvitationRoleAsync(invitationId); + if (invitationRole is null) return NotFound(); + + if (!UserManagementRules.CanManage(await GetRequesterRoleAsync(), invitationRole)) + return Forbid(); + + var token = await _invitationService.RegenerateInvitationAsync(invitationId); + if (token is null) return NotFound(); + + return Ok(new { inviteLink = $"/invite/complete?token={Uri.EscapeDataString(token)}" }); + } + [HttpPut("{userId:guid}/role")] public async Task ChangeRole(Guid userId, [FromBody] ChangeRoleRequest request) { + var requesterRole = await GetRequesterRoleAsync(); + if (!UserManagementRules.CanAssign(requesterRole, request.NewRole)) + return Forbid(); + var target = await _userManager.FindByIdAsync(userId.ToString()); - // Pending invite: no user account yet — update the invitation's role directly + // Pending invite: no user account yet - update the invitation's role directly if (target is null) { - var requesterEmailForInvite = User.Identity?.Name; - var requesterForInvite = requesterEmailForInvite is not null - ? await _userManager.FindByNameAsync(requesterEmailForInvite) - : null; - var requesterRolesForInvite = requesterForInvite is not null - ? await _userManager.GetRolesAsync(requesterForInvite) - : []; - var requesterRoleForInvite = requesterRolesForInvite.FirstOrDefault() ?? "User"; - - // Admins cannot assign Owner role via invitation either - if (requesterRoleForInvite == "Administrator" && request.NewRole == "Owner") + var invitationRole = await GetInvitationRoleAsync(userId); + if (invitationRole is not null && !UserManagementRules.CanManage(requesterRole, invitationRole)) return Forbid(); var updated = await _invitationService.UpdateInvitationRoleAsync(userId, request.NewRole); return updated ? Ok() : NotFound(); } - var requesterEmail = User.Identity?.Name; - var requester = requesterEmail is not null ? await _userManager.FindByNameAsync(requesterEmail) : null; - var requesterRoles = requester is not null ? await _userManager.GetRolesAsync(requester) : []; - var requesterRole = requesterRoles.FirstOrDefault() ?? "User"; - var targetRoles = await _userManager.GetRolesAsync(target); var targetRole = targetRoles.FirstOrDefault() ?? "User"; - if (requesterRole == "Administrator" && targetRole != "User") + // An Administrator may step down to User themselves; otherwise only plain Users are theirs to change. + var isSelfDemotion = IsSelf(target) && requesterRole == UserManagementRules.Administrator + && request.NewRole == UserManagementRules.User; + if (!isSelfDemotion && !UserManagementRules.CanManage(requesterRole, targetRole)) return Forbid(); if (targetRole == "Owner" && request.NewRole != "Owner") @@ -186,19 +203,19 @@ public class UsersController : ControllerBase var target = await _userManager.FindByIdAsync(userId.ToString()); if (target is null) return NotFound(); - var requesterEmail = User.Identity?.Name; - if (string.Equals(target.Email, requesterEmail, StringComparison.OrdinalIgnoreCase)) + if (IsSelf(target)) return BadRequest(new { detail = "You cannot change your own active status." }); - if (!request.IsActive) + var targetRoles = await _userManager.GetRolesAsync(target); + var targetRole = targetRoles.FirstOrDefault() ?? "User"; + if (!UserManagementRules.CanManage(await GetRequesterRoleAsync(), targetRole)) + return Forbid(); + + if (!request.IsActive && targetRoles.Contains("Owner")) { - var targetRoles = await _userManager.GetRolesAsync(target); - if (targetRoles.Contains("Owner")) - { - var ownerCount = (await _userManager.GetUsersInRoleAsync("Owner")).Count; - if (ownerCount <= 1) - return BadRequest(new { detail = "At least one Owner must remain." }); - } + var ownerCount = (await _userManager.GetUsersInRoleAsync("Owner")).Count; + if (ownerCount <= 1) + return BadRequest(new { detail = "At least one Owner must remain." }); } target.IsActive = request.IsActive; @@ -217,15 +234,21 @@ public class UsersController : ControllerBase // If no user account found, try to cancel a pending invitation with this ID if (target is null) { + var invitationRole = await GetInvitationRoleAsync(userId); + if (invitationRole is not null && !UserManagementRules.CanManage(await GetRequesterRoleAsync(), invitationRole)) + return Forbid(); + var deleted = await _invitationService.DeleteInvitationByIdAsync(userId); return deleted ? NoContent() : NotFound(); } - var requesterEmail = User.Identity?.Name; - if (string.Equals(target.Email, requesterEmail, StringComparison.OrdinalIgnoreCase)) + if (IsSelf(target)) return BadRequest(new { detail = "You cannot delete your own account." }); var targetRoles = await _userManager.GetRolesAsync(target); + if (!UserManagementRules.CanManage(await GetRequesterRoleAsync(), targetRoles.FirstOrDefault() ?? "User")) + return Forbid(); + if (targetRoles.Contains("Owner")) { var ownerCount = (await _userManager.GetUsersInRoleAsync("Owner")).Count; @@ -242,4 +265,26 @@ public class UsersController : ControllerBase return NoContent(); } + private bool IsSelf(ApplicationUser target) => + string.Equals(target.Email, User.Identity?.Name, StringComparison.OrdinalIgnoreCase); + + /// + /// The role of the caller from the database (not the token, which can be stale). A caller that cannot + /// be resolved is treated as an Administrator, the most restricted role that reaches this controller. + /// + private async Task GetRequesterRoleAsync() + { + var name = User.Identity?.Name; + var requester = name is not null ? await _userManager.FindByNameAsync(name) : null; + if (requester is null) return UserManagementRules.Administrator; + + var roles = await _userManager.GetRolesAsync(requester); + return roles.FirstOrDefault() ?? UserManagementRules.User; + } + + private async Task GetInvitationRoleAsync(Guid invitationId) + { + var all = await _invitationService.GetAllPendingInvitationsAsync(); + return all?.FirstOrDefault(i => i.Id == invitationId)?.Role; + } }