From 026a12a3f141a1df18236188a421a39e1ac3a821 Mon Sep 17 00:00:00 2001 From: Sluijsens Date: Sun, 8 Nov 2026 15:59:10 +0100 Subject: [PATCH] Gebruikersbeheer: rolhierarchie in de API afdwingen en uitnodiging opnieuw aanmaken Een Beheerder mag alleen gebruikers met rol User verwijderen, deactiveren, van rol wisselen of hun uitnodiging intrekken, en kent nooit de Owner-rol toe. De regels staan op een plek (UserManagementRules) en worden in de API afgedwongen. Nieuwe actie om een openstaande of verlopen uitnodiging een nieuwe link te geven (oude link vervalt). Co-Authored-By: Claude Sonnet 5.5 --- .../Identity/DateTimeOffsetRoundTripTests.cs | 67 ++++ .../Identity/InvitationServiceTests.cs | 31 ++ .../Authorization/UserManagementRules.cs | 24 ++ .../Identity/Services/IInvitationService.cs | 6 + .../Identity/Services/InvitationService.cs | 12 + .../UsersControllerRoleHierarchyTests.cs | 333 ++++++++++++++++++ .../Controllers/UsersController.cs | 105 ++++-- 7 files changed, 548 insertions(+), 30 deletions(-) create mode 100644 src/SlpModularCms.Core.Tests/Identity/DateTimeOffsetRoundTripTests.cs create mode 100644 src/SlpModularCms.Core/Identity/Authorization/UserManagementRules.cs create mode 100644 src/SlpModularCms.Modules.Identity.Tests/Controllers/UsersControllerRoleHierarchyTests.cs 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; + } }