Initial commit with inital CMS

This commit is contained in:
2026-06-15 17:00:16 +02:00
commit 95d986790e
132 changed files with 7624 additions and 0 deletions
@@ -0,0 +1,41 @@
using System.Security.Claims;
using Microsoft.AspNetCore.Authorization;
namespace SlpModularCms.Core.Identity.Authorization;
/// <summary>
/// Handler die valideert of de gebruiker de minimaal vereiste rol heeft in de hiërarchie.
/// </summary>
public class HierarchicalRoleHandler : AuthorizationHandler<HierarchicalRoleRequirement>
{
private static readonly Dictionary<string, int> RoleHierarchy = new()
{
{ "Owner", 100 },
{ "Administrator", 50 },
{ "User", 10 }
};
protected override Task HandleRequirementAsync(
AuthorizationHandlerContext context,
HierarchicalRoleRequirement requirement)
{
var userRole = context.User.FindFirstValue(ClaimTypes.Role);
if (userRole == null || !RoleHierarchy.ContainsKey(userRole))
{
return Task.CompletedTask;
}
var userLevel = RoleHierarchy[userRole];
var requiredLevel = RoleHierarchy.ContainsKey(requirement.MinimumRole)
? RoleHierarchy[requirement.MinimumRole]
: 0;
if (userLevel >= requiredLevel)
{
context.Succeed(requirement);
}
return Task.CompletedTask;
}
}
@@ -0,0 +1,16 @@
using Microsoft.AspNetCore.Authorization;
namespace SlpModularCms.Core.Identity.Authorization;
/// <summary>
/// Requirement voor hiërarchische rol-gebaseerde autorisatie.
/// </summary>
public class HierarchicalRoleRequirement : IAuthorizationRequirement
{
public string MinimumRole { get; }
public HierarchicalRoleRequirement(string minimumRole)
{
MinimumRole = minimumRole;
}
}
@@ -0,0 +1,17 @@
using Microsoft.AspNetCore.Identity;
namespace SlpModularCms.Core.Identity.Entities;
/// <summary>
/// Aangepaste Role entiteit voor SlpModularCms.
/// </summary>
public class ApplicationRole : IdentityRole<Guid>
{
public ApplicationRole() : base()
{
}
public ApplicationRole(string roleName) : base(roleName)
{
}
}
@@ -0,0 +1,29 @@
using Microsoft.AspNetCore.Identity;
namespace SlpModularCms.Core.Identity.Entities;
/// <summary>
/// Aangepaste User entiteit voor SlpModularCms.
/// </summary>
public class ApplicationUser : IdentityUser<Guid>
{
/// <summary>
/// Geeft aan of het account actief is.
/// </summary>
public bool IsActive { get; set; } = true;
/// <summary>
/// Datum en tijd van aanmaak.
/// </summary>
public DateTimeOffset CreatedAt { get; set; } = DateTimeOffset.UtcNow;
/// <summary>
/// Navigatie-eigenschap naar module-specifieke rechten.
/// </summary>
public virtual ICollection<ModulePermission> ModulePermissions { get; set; } = new List<ModulePermission>();
/// <summary>
/// Navigatie-eigenschap naar refresh tokens.
/// </summary>
public virtual ICollection<RefreshToken> RefreshTokens { get; set; } = new List<RefreshToken>();
}
@@ -0,0 +1,15 @@
using SlpModularCms.Core.Availability;
namespace SlpModularCms.Core.Identity.Entities;
/// <summary>
/// Persistente opslag voor de globale systeemstatus.
/// </summary>
public class GlobalAvailabilityState
{
public Guid Id { get; set; }
public AvailabilityStatus Status { get; set; }
public string? Message { get; set; }
public DateTimeOffset LastUpdatedAt { get; set; }
public string? UpdatedBy { get; set; }
}
@@ -0,0 +1,17 @@
namespace SlpModularCms.Core.Identity.Entities;
/// <summary>
/// Entiteit voor gebruikersuitnodigingen.
/// </summary>
public class Invitation
{
public Guid Id { get; set; }
public string Email { get; set; } = string.Empty;
public string Role { get; set; } = string.Empty;
public string Token { get; set; } = string.Empty;
public DateTimeOffset ExpiryDate { get; set; }
public bool IsAccepted { get; set; }
public DateTimeOffset CreatedAt { get; set; } = DateTimeOffset.UtcNow;
public bool IsExpired => DateTimeOffset.UtcNow >= ExpiryDate;
}
@@ -0,0 +1,12 @@
namespace SlpModularCms.Core.Identity.Entities;
/// <summary>
/// Entiteit voor module-specifieke rechten per gebruiker.
/// </summary>
public class ModulePermission
{
public Guid UserId { get; set; }
public virtual ApplicationUser User { get; set; } = null!;
public string ModuleName { get; set; } = string.Empty;
public string Permission { get; set; } = string.Empty;
}
@@ -0,0 +1,20 @@
namespace SlpModularCms.Core.Identity.Entities;
/// <summary>
/// Entiteit voor het opslaan van refresh tokens.
/// </summary>
public class RefreshToken
{
public Guid Id { get; set; }
public string Token { get; set; } = string.Empty;
public Guid UserId { get; set; }
public virtual ApplicationUser User { get; set; } = null!;
public DateTimeOffset ExpiryDate { get; set; }
public bool IsUsed { get; set; }
public bool IsRevoked { get; set; }
public DateTimeOffset CreatedAt { get; set; } = DateTimeOffset.UtcNow;
public string? CreatedByIp { get; set; }
public bool IsExpired => DateTimeOffset.UtcNow >= ExpiryDate;
public bool IsActive => !IsRevoked && !IsExpired;
}
@@ -0,0 +1,7 @@
namespace SlpModularCms.Core.Identity.Models;
public record CreateOwnerRequest(string Email, string Password);
public record LoginRequest(string Email, string Password);
public record RefreshTokenRequest(string AccessToken, string RefreshToken);
public record InviteUserRequest(string Email, string Role);
public record CompleteSetupRequest(string Token, string Password);
@@ -0,0 +1,13 @@
namespace SlpModularCms.Core.Identity.Models;
/// <summary>
/// Configuratie-instellingen voor JWT.
/// </summary>
public class JwtSettings
{
public string Secret { get; set; } = string.Empty;
public string Issuer { get; set; } = string.Empty;
public string Audience { get; set; } = string.Empty;
public int ExpiryMinutes { get; set; } = 60;
public int RefreshTokenExpiryDays { get; set; } = 7;
}
@@ -0,0 +1,10 @@
namespace SlpModularCms.Core.Identity.Models;
/// <summary>
/// Model voor het retourneren van authenticatie tokens.
/// </summary>
public record TokenResponse(
string AccessToken,
string RefreshToken,
DateTimeOffset Expiry
);
@@ -0,0 +1,155 @@
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Security.Cryptography;
using System.Text;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Options;
using Microsoft.IdentityModel.Tokens;
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 AuthService : IAuthService
{
private readonly UserManager<ApplicationUser> _userManager;
private readonly ApplicationDbContext _context;
private readonly JwtSettings _jwtSettings;
public AuthService(
UserManager<ApplicationUser> userManager,
ApplicationDbContext context,
IOptions<JwtSettings> jwtSettings)
{
_userManager = userManager;
_context = context;
_jwtSettings = jwtSettings.Value;
}
public async Task<TokenResponse> AuthenticateAsync(string email, string password)
{
var user = await _userManager.FindByEmailAsync(email);
if (user == null || !user.IsActive || !await _userManager.CheckPasswordAsync(user, password))
{
throw new UnauthorizedException("Ongeldige inloggegevens.");
}
return await GenerateTokenResponseAsync(user);
}
public async Task<TokenResponse> RefreshTokenAsync(string accessToken, string refreshToken)
{
var principal = GetPrincipalFromExpiredToken(accessToken);
var userId = Guid.Parse(principal.FindFirstValue(ClaimTypes.NameIdentifier)!);
var savedRefreshToken = await _context.RefreshTokens
.Include(t => t.User)
.FirstOrDefaultAsync(t => t.Token == refreshToken && t.UserId == userId);
if (savedRefreshToken == null || !savedRefreshToken.IsActive)
{
throw new UnauthorizedException("Ongeldig refresh token.");
}
if (savedRefreshToken.IsUsed)
{
// Re-use detection: trek alle tokens van de gebruiker in
var allTokens = await _context.RefreshTokens.Where(t => t.UserId == userId).ToListAsync();
foreach (var token in allTokens) token.IsRevoked = true;
await _context.SaveChangesAsync();
throw new UnauthorizedException("Mogelijk token misbruik gedetecteerd. Alle sessies zijn beëindigd.");
}
savedRefreshToken.IsUsed = true;
await _context.SaveChangesAsync();
return await GenerateTokenResponseAsync(savedRefreshToken.User);
}
public async Task RevokeTokenAsync(string refreshToken)
{
var token = await _context.RefreshTokens.FirstOrDefaultAsync(t => t.Token == refreshToken);
if (token != null)
{
token.IsRevoked = true;
await _context.SaveChangesAsync();
}
}
private async Task<TokenResponse> GenerateTokenResponseAsync(ApplicationUser user)
{
var roles = await _userManager.GetRolesAsync(user);
var claims = new List<Claim>
{
new(JwtRegisteredClaimNames.Sub, user.Id.ToString()),
new(JwtRegisteredClaimNames.Email, user.Email!),
new(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
};
foreach (var role in roles)
{
claims.Add(new Claim(ClaimTypes.Role, role));
}
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_jwtSettings.Secret));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var expiry = DateTime.UtcNow.AddMinutes(_jwtSettings.ExpiryMinutes);
var token = new JwtSecurityToken(
_jwtSettings.Issuer,
_jwtSettings.Audience,
claims,
expires: expiry,
signingCredentials: creds
);
var accessToken = new JwtSecurityTokenHandler().WriteToken(token);
var refreshToken = GenerateRefreshToken();
_context.RefreshTokens.Add(new RefreshToken
{
Token = refreshToken,
UserId = user.Id,
ExpiryDate = DateTimeOffset.UtcNow.AddDays(_jwtSettings.RefreshTokenExpiryDays),
CreatedByIp = "Unknown" // In echte implementatie via HttpContextAccessor
});
await _context.SaveChangesAsync();
return new TokenResponse(accessToken, refreshToken, expiry);
}
private static string GenerateRefreshToken()
{
var randomNumber = new byte[32];
using var rng = RandomNumberGenerator.Create();
rng.GetBytes(randomNumber);
return Convert.ToBase64String(randomNumber);
}
private ClaimsPrincipal GetPrincipalFromExpiredToken(string token)
{
var tokenValidationParameters = new TokenValidationParameters
{
ValidateAudience = false,
ValidateIssuer = false,
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_jwtSettings.Secret)),
ValidateLifetime = false // We willen juist het verlopen token lezen
};
var tokenHandler = new JwtSecurityTokenHandler();
var principal = tokenHandler.ValidateToken(token, tokenValidationParameters, out var securityToken);
if (securityToken is not JwtSecurityToken jwtSecurityToken ||
!jwtSecurityToken.Header.Alg.Equals(SecurityAlgorithms.HmacSha256, StringComparison.InvariantCultureIgnoreCase))
{
throw new SecurityTokenException("Ongeldig token.");
}
return principal;
}
}
@@ -0,0 +1,24 @@
using SlpModularCms.Core.Identity.Models;
namespace SlpModularCms.Core.Identity.Services;
/// <summary>
/// Interface voor authenticatie en token management.
/// </summary>
public interface IAuthService
{
/// <summary>
/// Authenticeert een gebruiker en retourneert tokens.
/// </summary>
Task<TokenResponse> AuthenticateAsync(string email, string password);
/// <summary>
/// Vernieuwt een verlopen access token met een geldig refresh token.
/// </summary>
Task<TokenResponse> RefreshTokenAsync(string accessToken, string refreshToken);
/// <summary>
/// Trekt een refresh token in (uitloggen).
/// </summary>
Task RevokeTokenAsync(string refreshToken);
}
@@ -0,0 +1,22 @@
namespace SlpModularCms.Core.Identity.Services;
/// <summary>
/// Interface voor het uitnodigingsproces van nieuwe gebruikers.
/// </summary>
public interface IInvitationService
{
/// <summary>
/// Maakt een nieuwe uitnodiging aan en retourneert het token.
/// </summary>
Task<string> CreateInvitationAsync(string email, string role);
/// <summary>
/// Valideert of een uitnodigings-token nog geldig is.
/// </summary>
Task<bool> ValidateInvitationAsync(string token);
/// <summary>
/// Voltooit de uitnodiging door een gebruiker aan te maken met het opgegeven wachtwoord.
/// </summary>
Task CompleteInvitationAsync(string token, string password);
}
@@ -0,0 +1,87 @@
using System.Security.Cryptography;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using SlpModularCms.Core.Data;
using SlpModularCms.Core.Exceptions;
using SlpModularCms.Core.Identity.Entities;
namespace SlpModularCms.Core.Identity.Services;
public class InvitationService : IInvitationService
{
private readonly ApplicationDbContext _context;
private readonly UserManager<ApplicationUser> _userManager;
public InvitationService(ApplicationDbContext context, UserManager<ApplicationUser> userManager)
{
_context = context;
_userManager = userManager;
}
public async Task<string> CreateInvitationAsync(string email, string role)
{
var invitationForEmail = await _context.Invitations.FirstOrDefaultAsync(x => x.Email == email);
var user = await _userManager.FindByEmailAsync(email);
if (invitationForEmail != null || user != null)
{
throw new InvitationOrUserAlreadyExistsException("Een uitnodiging of gebruiker voor dit e-mailadres bestaat al.");
}
var token = GenerateSecureToken();
var invitation = new Invitation
{
Email = email,
Role = role,
Token = token,
ExpiryDate = DateTimeOffset.UtcNow.AddDays(1),
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)
{
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,
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();
}
private static string GenerateSecureToken()
{
var bytes = new byte[32];
using var rng = RandomNumberGenerator.Create();
rng.GetBytes(bytes);
return Convert.ToBase64String(bytes);
}
}
@@ -0,0 +1,62 @@
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using SlpModularCms.Core.Exceptions;
using SlpModularCms.Core.Identity.Entities;
namespace SlpModularCms.Core.Identity.Services;
public interface ISetupService
{
Task<bool> IsSystemInitializedAsync();
Task CreateInitialOwnerAsync(string email, string password);
}
public class SetupService : ISetupService
{
private readonly UserManager<ApplicationUser> _userManager;
private readonly RoleManager<ApplicationRole> _roleManager;
public SetupService(UserManager<ApplicationUser> userManager, RoleManager<ApplicationRole> roleManager)
{
_userManager = userManager;
_roleManager = roleManager;
}
public async Task<bool> IsSystemInitializedAsync()
{
return await _userManager.Users.AnyAsync();
}
public async Task CreateInitialOwnerAsync(string email, string password)
{
if (await IsSystemInitializedAsync())
{
throw new ValidationException("Systeem is al geïnitialiseerd.");
}
// Zorg dat rollen bestaan
string[] roles = { "Owner", "Administrator", "User" };
foreach (var roleName in roles)
{
if (!await _roleManager.RoleExistsAsync(roleName))
{
await _roleManager.CreateAsync(new ApplicationRole { Name = roleName });
}
}
var user = new ApplicationUser
{
UserName = email,
Email = email,
IsActive = true
};
var result = await _userManager.CreateAsync(user, password);
if (!result.Succeeded)
{
throw new ValidationException("Fout bij aanmaken eigenaar: " + string.Join(", ", result.Errors.Select(e => e.Description)));
}
await _userManager.AddToRoleAsync(user, "Owner");
}
}