Files
slp-modular-cms/src/SlpModularCms.Modules.Identity/Controllers/UsersController.cs
T

246 lines
9.2 KiB
C#

using System.Security.Claims;
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;
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, 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,
inv.IsExpired ? null : $"/invite/complete?token={Uri.EscapeDataString(inv.Token)}",
inv.IsExpired));
}
}
return Ok(result.OrderBy(u => u.CreatedAt));
}
[HttpPut("me")]
[Authorize]
public async Task<IActionResult> UpdateProfile([FromBody] UpdateProfileRequest request)
{
var userIdClaim = User.FindFirstValue(ClaimTypes.NameIdentifier)
?? User.FindFirstValue("sub");
if (!Guid.TryParse(userIdClaim, out var userId))
return Unauthorized();
var user = await _userManager.FindByIdAsync(userId.ToString());
if (user is null) return NotFound();
// Check email uniqueness if email is changing
if (!string.Equals(user.Email, request.Email, StringComparison.OrdinalIgnoreCase))
{
var existing = await _userManager.FindByEmailAsync(request.Email);
if (existing is not null)
return BadRequest(new { detail = "Email is already in use." });
}
user.DisplayName = request.Name;
user.Email = request.Email;
user.UserName = request.Email;
user.NormalizedEmail = request.Email.ToUpperInvariant();
user.NormalizedUserName = request.Email.ToUpperInvariant();
var result = await _userManager.UpdateAsync(user);
if (!result.Succeeded)
return StatusCode(500, new { detail = "Failed to update profile." });
var roles = await _userManager.GetRolesAsync(user);
var role = roles.FirstOrDefault() ?? "User";
return Ok(new UserDto(
user.Id,
user.Email ?? string.Empty,
user.DisplayName ?? user.Email ?? string.Empty,
role,
user.IsActive,
user.CreatedAt,
false,
null));
}
[HttpPost("invite")]
public async Task<IActionResult> Invite([FromBody] InviteUserRequest request)
{
var token = await _invitationService.CreateInvitationAsync(request.Email, request.Role);
var inviteLink = $"/invite/complete?token={Uri.EscapeDataString(token)}";
return Ok(new { inviteLink });
}
[HttpPut("{userId:guid}/role")]
public async Task<IActionResult> ChangeRole(Guid userId, [FromBody] ChangeRoleRequest request)
{
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();
}
[HttpPut("{userId:guid}/active")]
public async Task<IActionResult> SetUserActive(Guid userId, [FromBody] SetUserActiveRequest request)
{
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.DeleteInvitationsByEmailAsync(target.Email ?? string.Empty);
var result = await _userManager.DeleteAsync(target);
if (!result.Succeeded)
return StatusCode(500, new { detail = "Failed to delete user." });
return NoContent();
}
}