246 lines
9.2 KiB
C#
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();
|
|
}
|
|
|
|
}
|