Adds user management

This commit is contained in:
2026-06-22 21:14:22 +02:00
parent 5331be4279
commit 6976eb4337
40 changed files with 3392 additions and 146 deletions
@@ -1,5 +1,8 @@
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using SlpModularCms.Core.Identity.Entities;
using SlpModularCms.Core.Identity.Models;
using SlpModularCms.Core.Identity.Services;
@@ -7,38 +10,189 @@ namespace SlpModularCms.Modules.Identity.Controllers;
[ApiController]
[Route("[controller]")]
[Authorize(Policy = "AdminOnly")]
public class UsersController : ControllerBase
{
private readonly IInvitationService _invitationService;
private readonly UserManager<ApplicationUser> _userManager;
public UsersController(IInvitationService invitationService)
public UsersController(IInvitationService invitationService, UserManager<ApplicationUser> userManager)
{
_invitationService = invitationService;
_userManager = userManager;
}
[HttpGet]
public async Task<IActionResult> GetUsers()
{
var users = await _userManager.Users.OrderBy(u => u.CreatedAt).ToListAsync();
var userEmails = users
.Select(u => u.Email?.ToLowerInvariant())
.Where(e => e is not null)
.ToHashSet();
var result = new List<UserDto>(users.Count);
foreach (var user in users)
{
var roles = await _userManager.GetRolesAsync(user);
var role = roles.FirstOrDefault() ?? "User";
var (isPending, token) = await _invitationService.GetPendingInvitationByEmailAsync(user.Email ?? string.Empty);
var inviteLink = isPending && token is not null
? $"/invite/complete?token={Uri.EscapeDataString(token)}"
: null;
result.Add(new UserDto(
user.Id,
user.Email ?? string.Empty,
user.DisplayName ?? user.Email ?? string.Empty,
role,
user.IsActive,
user.CreatedAt,
isPending,
inviteLink));
}
// Include pending invitations that have no user account yet
var pendingInvitations = await _invitationService.GetAllPendingInvitationsAsync();
foreach (var inv in pendingInvitations)
{
if (!userEmails.Contains(inv.Email.ToLowerInvariant()))
{
result.Add(new UserDto(
inv.Id,
inv.Email,
inv.Email,
inv.Role,
true,
inv.CreatedAt,
true,
$"/invite/complete?token={Uri.EscapeDataString(inv.Token)}"));
}
}
return Ok(result.OrderBy(u => u.CreatedAt));
}
[HttpPost("invite")]
[Authorize(Policy = "AdminOnly")]
public async Task<IActionResult> Invite([FromBody] InviteUserRequest request)
{
var token = await _invitationService.CreateInvitationAsync(request.Email, request.Role);
// In een echte app zou je hier een email sturen. Voor nu geven we de link terug.
var inviteLink = $"/setup/complete?token={Uri.EscapeDataString(token)}";
return Ok(new { InviteLink = inviteLink });
var inviteLink = $"/invite/complete?token={Uri.EscapeDataString(token)}";
return Ok(new { inviteLink });
}
[HttpPost("complete-setup")]
[AllowAnonymous]
public async Task<IActionResult> CompleteSetup([FromBody] CompleteSetupRequest request)
[HttpPut("{userId:guid}/role")]
public async Task<IActionResult> ChangeRole(Guid userId, [FromBody] ChangeRoleRequest request)
{
await _invitationService.CompleteInvitationAsync(request.Token, request.Password);
return Ok(new { Message = "Account succesvol ingesteld. Je kunt nu inloggen." });
var target = await _userManager.FindByIdAsync(userId.ToString());
// 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")
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")
return Forbid();
if (targetRole == "Owner" && request.NewRole != "Owner")
{
var ownerCount = (await _userManager.GetUsersInRoleAsync("Owner")).Count;
if (ownerCount <= 1)
return BadRequest(new { detail = "At least one Owner must remain." });
}
if (targetRoles.Count > 0)
await _userManager.RemoveFromRolesAsync(target, targetRoles);
await _userManager.AddToRoleAsync(target, request.NewRole);
return Ok();
}
[HttpGet("validate-invitation")]
[AllowAnonymous]
public async Task<IActionResult> ValidateInvitation([FromQuery] string token)
[HttpPut("{userId:guid}/active")]
public async Task<IActionResult> SetUserActive(Guid userId, [FromBody] SetUserActiveRequest request)
{
var isValid = await _invitationService.ValidateInvitationAsync(token);
return Ok(new { Valid = isValid });
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))
return BadRequest(new { detail = "You cannot change your own active status." });
if (!request.IsActive)
{
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." });
}
}
target.IsActive = request.IsActive;
var result = await _userManager.UpdateAsync(target);
if (!result.Succeeded)
return StatusCode(500, new { detail = "Failed to update user." });
return Ok();
}
[HttpDelete("{userId:guid}")]
public async Task<IActionResult> DeleteUser(Guid userId)
{
var target = await _userManager.FindByIdAsync(userId.ToString());
// If no user account found, try to cancel a pending invitation with this ID
if (target is null)
{
var deleted = await _invitationService.DeleteInvitationByIdAsync(userId);
return deleted ? NoContent() : NotFound();
}
var requesterEmail = User.Identity?.Name;
if (string.Equals(target.Email, requesterEmail, StringComparison.OrdinalIgnoreCase))
return BadRequest(new { detail = "You cannot delete your own account." });
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." });
}
await _invitationService.DeletePendingInvitationsByEmailAsync(target.Email ?? string.Empty);
var result = await _userManager.DeleteAsync(target);
if (!result.Succeeded)
return StatusCode(500, new { detail = "Failed to delete user." });
return NoContent();
}
}