Files
slp-modular-cms/src/SlpModularCms.Core/Identity/Services/InvitationService.cs
T
SluijsensandClaude Sonnet 5.5 026a12a3f1 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 <noreply@anthropic.com>
2026-11-08 15:59:10 +01:00

180 lines
6.4 KiB
C#

using System.Security.Cryptography;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Options;
using SlpModularCms.Core.Data;
using SlpModularCms.Core.Exceptions;
using SlpModularCms.Core.Identity.Entities;
using SlpModularCms.Core.Identity.Models;
namespace SlpModularCms.Core.Identity.Services;
public class InvitationService : IInvitationService
{
private readonly ApplicationDbContext _context;
private readonly UserManager<ApplicationUser> _userManager;
private readonly InvitationSettings _settings;
public InvitationService(
ApplicationDbContext context,
UserManager<ApplicationUser> userManager,
IOptions<InvitationSettings> settings)
{
_context = context;
_userManager = userManager;
_settings = settings.Value;
}
public async Task<string> CreateInvitationAsync(string email, string role)
{
var user = await _userManager.FindByEmailAsync(email);
if (user != null)
{
throw new InvitationOrUserAlreadyExistsException("Er bestaat al een gebruiker met dit e-mailadres.");
}
var normalized = email.ToLower();
var invitationsForEmail = await _context.Invitations
.Where(x => x.Email.ToLower() == normalized)
.ToListAsync();
if (invitationsForEmail.Any(i => !i.IsAccepted && !i.IsExpired))
{
throw new InvitationOrUserAlreadyExistsException(
"Er staat al een openstaande uitnodiging voor dit e-mailadres.");
}
// What is left is stale: an expired invitation, or an accepted one whose user no longer
// exists (the account was deleted). Neither can be used again, and an accepted one used to
// block re-inviting the same address for good.
if (invitationsForEmail.Count > 0)
{
_context.Invitations.RemoveRange(invitationsForEmail);
}
var token = GenerateSecureToken();
var invitation = new Invitation
{
Email = email,
Role = role,
Token = token,
ExpiryDate = DateTimeOffset.UtcNow.AddHours(_settings.ExpiryHours),
IsAccepted = false
};
_context.Invitations.Add(invitation);
await _context.SaveChangesAsync();
return token;
}
public async Task<bool> ValidateInvitationAsync(string token)
{
var invitation = await _context.Invitations.FirstOrDefaultAsync(i => i.Token == token);
return invitation != null && !invitation.IsAccepted && !invitation.IsExpired;
}
public async Task CompleteInvitationAsync(string token, string password, string? name = null)
{
var invitation = await _context.Invitations.FirstOrDefaultAsync(i => i.Token == token);
if (invitation == null || invitation.IsAccepted || invitation.IsExpired)
{
throw new UnauthorizedException("Ongeldige of verlopen uitnodiging.");
}
var user = new ApplicationUser
{
UserName = invitation.Email,
Email = invitation.Email,
DisplayName = string.IsNullOrWhiteSpace(name) ? null : name.Trim(),
IsActive = true
};
var result = await _userManager.CreateAsync(user, password);
if (!result.Succeeded)
{
throw new ValidationException("Kan gebruiker niet aanmaken: " + string.Join(", ", result.Errors.Select(e => e.Description)));
}
await _userManager.AddToRoleAsync(user, invitation.Role);
invitation.IsAccepted = true;
await _context.SaveChangesAsync();
}
public async Task<(bool IsPending, string? Token)> GetPendingInvitationByEmailAsync(string email)
{
var invitation = await _context.Invitations
.FirstOrDefaultAsync(i => i.Email == email && !i.IsAccepted && i.ExpiryDate > DateTimeOffset.UtcNow);
return invitation is null ? (false, null) : (true, invitation.Token);
}
public async Task DeleteInvitationsByEmailAsync(string email)
{
var invitations = await _context.Invitations
.Where(i => i.Email.ToLower() == email.ToLower())
.ToListAsync();
if (invitations.Count > 0)
{
_context.Invitations.RemoveRange(invitations);
await _context.SaveChangesAsync();
}
}
public async Task<IReadOnlyList<PendingInvitationInfo>> GetAllPendingInvitationsAsync()
{
var invitations = await _context.Invitations
.Where(i => !i.IsAccepted)
.OrderBy(i => i.CreatedAt)
.ToListAsync();
// Expired ones are included on purpose: dropping them made an invited person who did not
// activate in time vanish from the list, so the administrator could neither see nor remove them.
return invitations
.Select(i => new PendingInvitationInfo(i.Id, i.Email, i.Role, i.Token, i.CreatedAt, i.IsExpired))
.ToList();
}
public async Task<bool> DeleteInvitationByIdAsync(Guid invitationId)
{
var invitation = await _context.Invitations
.FirstOrDefaultAsync(i => i.Id == invitationId && !i.IsAccepted);
if (invitation is null) return false;
_context.Invitations.Remove(invitation);
await _context.SaveChangesAsync();
return true;
}
public async Task<bool> UpdateInvitationRoleAsync(Guid invitationId, string newRole)
{
var invitation = await _context.Invitations
.FirstOrDefaultAsync(i => i.Id == invitationId && !i.IsAccepted);
if (invitation is null) return false;
invitation.Role = newRole;
await _context.SaveChangesAsync();
return true;
}
public async Task<string?> 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];
using var rng = RandomNumberGenerator.Create();
rng.GetBytes(bytes);
return Convert.ToBase64String(bytes);
}
}