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,17 @@
namespace SlpModularCms.Core.Availability;
/// <summary>
/// Configuratie-opties voor de Availability module.
/// </summary>
public class AvailabilityOptions
{
/// <summary>
/// De tijd (in seconden) dat de status gecached wordt na een fout (Circuit Breaker).
/// </summary>
public int CircuitBreakerSeconds { get; set; } = 30;
/// <summary>
/// De tijd (in seconden) dat de status gecached wordt bij een succesvolle check.
/// </summary>
public int StatusCacheSeconds { get; set; } = 1;
}
@@ -0,0 +1,32 @@
namespace SlpModularCms.Core.Availability;
/// <summary>
/// Mogelijke statussen voor de beschikbaarheid van de API.
/// </summary>
public enum AvailabilityStatus
{
/// <summary>
/// De API is volledig operationeel.
/// </summary>
Available,
/// <summary>
/// De API is momenteel niet beschikbaar (bijv. storing).
/// </summary>
NotAvailable,
/// <summary>
/// De API is in onderhoud.
/// </summary>
Maintenance,
/// <summary>
/// De API is beperkt beschikbaar.
/// </summary>
Degraded,
/// <summary>
/// De status van de API kan niet worden vastgesteld (bijv. timeout).
/// </summary>
Unknown
}
@@ -0,0 +1,13 @@
namespace SlpModularCms.Core.Availability;
/// <summary>
/// Service voor het controleren van de beschikbaarheid van het systeem.
/// </summary>
public interface IAvailabilityService
{
/// <summary>
/// Controleert de algemene beschikbaarheid van de API.
/// </summary>
/// <returns>De huidige <see cref="AvailabilityStatus"/>.</returns>
Task<AvailabilityStatus> IsAvailableAsync();
}
@@ -0,0 +1,79 @@
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;
using SlpModularCms.Core.Identity.Entities;
namespace SlpModularCms.Core.Data;
/// <summary>
/// Database context voor de applicatie, inclusief Identity en RBAC tabellen.
/// </summary>
public class ApplicationDbContext : IdentityDbContext<ApplicationUser, ApplicationRole, Guid>
{
public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
: base(options)
{
}
public DbSet<RefreshToken> RefreshTokens => Set<RefreshToken>();
public DbSet<Invitation> Invitations => Set<Invitation>();
public DbSet<ModulePermission> ModulePermissions => Set<ModulePermission>();
public DbSet<GlobalAvailabilityState> AvailabilityStates => Set<GlobalAvailabilityState>();
protected override void OnModelCreating(ModelBuilder builder)
{
base.OnModelCreating(builder);
// Hernoemen van standaard Identity tabellen (NFR-ID-MAINT-01)
builder.Entity<ApplicationUser>(entity => { entity.ToTable("Users"); });
builder.Entity<ApplicationRole>(entity => { entity.ToTable("Roles"); });
builder.Entity<IdentityUserRole<Guid>>(entity => { entity.ToTable("UserRoles"); });
builder.Entity<IdentityUserClaim<Guid>>(entity => { entity.ToTable("UserClaims"); });
builder.Entity<IdentityUserLogin<Guid>>(entity => { entity.ToTable("UserLogins"); });
builder.Entity<IdentityRoleClaim<Guid>>(entity => { entity.ToTable("RoleClaims"); });
builder.Entity<IdentityUserToken<Guid>>(entity => { entity.ToTable("UserTokens"); });
// Configuratie voor GlobalAvailabilityState
builder.Entity<GlobalAvailabilityState>(entity =>
{
entity.ToTable("AvailabilityState");
entity.HasKey(e => e.Id);
});
// Configuratie voor RefreshTokens
builder.Entity<RefreshToken>(entity =>
{
entity.HasKey(e => e.Id);
entity.HasIndex(e => e.Token).IsUnique();
entity.Property(e => e.Token).IsRequired().HasMaxLength(256);
entity.HasOne(e => e.User)
.WithMany(u => u.RefreshTokens)
.HasForeignKey(e => e.UserId)
.OnDelete(DeleteBehavior.Cascade);
});
// Configuratie voor Invitations
builder.Entity<Invitation>(entity =>
{
entity.HasKey(e => e.Id);
entity.HasIndex(e => e.Token).IsUnique();
entity.Property(e => e.Token).IsRequired().HasMaxLength(256);
entity.Property(e => e.Email).IsRequired().HasMaxLength(256);
});
// Configuratie voor ModulePermissions
builder.Entity<ModulePermission>(entity =>
{
entity.HasKey(e => new { e.UserId, e.ModuleName, e.Permission });
entity.HasOne(e => e.User)
.WithMany(u => u.ModulePermissions)
.HasForeignKey(e => e.UserId)
.OnDelete(DeleteBehavior.Cascade);
entity.Property(e => e.ModuleName).IsRequired().HasMaxLength(128);
entity.Property(e => e.Permission).IsRequired().HasMaxLength(128);
});
}
}
@@ -0,0 +1,13 @@
namespace SlpModularCms.Core.Exceptions;
/// <summary>
/// Gestandaardiseerd error response object voor de API.
/// </summary>
/// <param name="Message">De (veilige) foutmelding.</param>
/// <param name="Detail">Extra details, zoals een stacktrace (alleen in Development).</param>
/// <param name="TraceId">Uniek correlatie ID voor log-analyse.</param>
public record ApiErrorResponse(
string Message,
string? Detail = null,
string? TraceId = null
);
@@ -0,0 +1,60 @@
using System.Diagnostics;
using Microsoft.AspNetCore.Diagnostics;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
namespace SlpModularCms.Core.Exceptions;
/// <summary>
/// Globale exception handler conform .NET 8+ IExceptionHandler.
/// </summary>
public class GlobalExceptionHandler : IExceptionHandler
{
private readonly ILogger<GlobalExceptionHandler> _logger;
private readonly IHostEnvironment _env;
public GlobalExceptionHandler(ILogger<GlobalExceptionHandler> logger, IHostEnvironment env)
{
_logger = logger;
_env = env;
}
public async ValueTask<bool> TryHandleAsync(
HttpContext httpContext,
Exception exception,
CancellationToken cancellationToken)
{
var traceId = Activity.Current?.Id ?? httpContext.TraceIdentifier;
_logger.LogError(
exception,
"Ongehandled exception opgetreden op {MachineName}. TraceId: {TraceId}",
Environment.MachineName,
traceId);
var (statusCode, message) = MapException(exception);
httpContext.Response.StatusCode = statusCode;
var response = new ApiErrorResponse(
Message: message,
Detail: _env.IsDevelopment() ? exception.ToString() : null,
TraceId: traceId
);
await httpContext.Response.WriteAsJsonAsync(response, cancellationToken);
return true;
}
private static (int StatusCode, string Message) MapException(Exception exception)
{
return exception switch
{
// Hier kunnen specifieke uitzonderingen worden toegevoegd
// Bijv: ValidationException => (StatusCodes.Status400BadRequest, exception.Message),
_ => (StatusCodes.Status500InternalServerError, "Er is een interne serverfout opgetreden.")
};
}
}
@@ -0,0 +1,11 @@
namespace SlpModularCms.Core.Exceptions;
/// <summary>
/// Exception die gegooid wordt bij authenticatie- of autorisatiefouten.
/// </summary>
public class InvitationOrUserAlreadyExistsException : Exception
{
public InvitationOrUserAlreadyExistsException(string message) : base(message)
{
}
}
@@ -0,0 +1,11 @@
namespace SlpModularCms.Core.Exceptions;
/// <summary>
/// Exception die gegooid wordt bij authenticatie- of autorisatiefouten.
/// </summary>
public class UnauthorizedException : Exception
{
public UnauthorizedException(string message) : base(message)
{
}
}
@@ -0,0 +1,11 @@
namespace SlpModularCms.Core.Exceptions;
/// <summary>
/// Exception die gegooid wordt bij validatiefouten.
/// </summary>
public class ValidationException : Exception
{
public ValidationException(string message) : base(message)
{
}
}
@@ -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");
}
}
@@ -0,0 +1,430 @@
// <auto-generated />
using System;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
using Microsoft.EntityFrameworkCore.Migrations;
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
using SlpModularCms.Core.Data;
#nullable disable
namespace SlpModularCms.Core.Migrations
{
[DbContext(typeof(ApplicationDbContext))]
[Migration("20260612191736_InitialCreate")]
partial class InitialCreate
{
/// <inheritdoc />
protected override void BuildTargetModel(ModelBuilder modelBuilder)
{
#pragma warning disable 612, 618
modelBuilder
.HasAnnotation("ProductVersion", "10.0.9")
.HasAnnotation("Relational:MaxIdentifierLength", 128);
SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<System.Guid>", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("int");
SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
b.Property<string>("ClaimType")
.HasColumnType("nvarchar(max)");
b.Property<string>("ClaimValue")
.HasColumnType("nvarchar(max)");
b.Property<Guid>("RoleId")
.HasColumnType("uniqueidentifier");
b.HasKey("Id");
b.HasIndex("RoleId");
b.ToTable("RoleClaims", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<System.Guid>", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("int");
SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
b.Property<string>("ClaimType")
.HasColumnType("nvarchar(max)");
b.Property<string>("ClaimValue")
.HasColumnType("nvarchar(max)");
b.Property<Guid>("UserId")
.HasColumnType("uniqueidentifier");
b.HasKey("Id");
b.HasIndex("UserId");
b.ToTable("UserClaims", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<System.Guid>", b =>
{
b.Property<string>("LoginProvider")
.HasColumnType("nvarchar(450)");
b.Property<string>("ProviderKey")
.HasColumnType("nvarchar(450)");
b.Property<string>("ProviderDisplayName")
.HasColumnType("nvarchar(max)");
b.Property<Guid>("UserId")
.HasColumnType("uniqueidentifier");
b.HasKey("LoginProvider", "ProviderKey");
b.HasIndex("UserId");
b.ToTable("UserLogins", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<System.Guid>", b =>
{
b.Property<Guid>("UserId")
.HasColumnType("uniqueidentifier");
b.Property<Guid>("RoleId")
.HasColumnType("uniqueidentifier");
b.HasKey("UserId", "RoleId");
b.HasIndex("RoleId");
b.ToTable("UserRoles", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<System.Guid>", b =>
{
b.Property<Guid>("UserId")
.HasColumnType("uniqueidentifier");
b.Property<string>("LoginProvider")
.HasColumnType("nvarchar(450)");
b.Property<string>("Name")
.HasColumnType("nvarchar(450)");
b.Property<string>("Value")
.HasColumnType("nvarchar(max)");
b.HasKey("UserId", "LoginProvider", "Name");
b.ToTable("UserTokens", (string)null);
});
modelBuilder.Entity("SlpModularCms.Core.Identity.Entities.ApplicationRole", b =>
{
b.Property<Guid>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("uniqueidentifier");
b.Property<string>("ConcurrencyStamp")
.IsConcurrencyToken()
.HasColumnType("nvarchar(max)");
b.Property<string>("Name")
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.Property<string>("NormalizedName")
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.HasKey("Id");
b.HasIndex("NormalizedName")
.IsUnique()
.HasDatabaseName("RoleNameIndex")
.HasFilter("[NormalizedName] IS NOT NULL");
b.ToTable("Roles", (string)null);
});
modelBuilder.Entity("SlpModularCms.Core.Identity.Entities.ApplicationUser", b =>
{
b.Property<Guid>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("uniqueidentifier");
b.Property<int>("AccessFailedCount")
.HasColumnType("int");
b.Property<string>("ConcurrencyStamp")
.IsConcurrencyToken()
.HasColumnType("nvarchar(max)");
b.Property<DateTimeOffset>("CreatedAt")
.HasColumnType("datetimeoffset");
b.Property<string>("Email")
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.Property<bool>("EmailConfirmed")
.HasColumnType("bit");
b.Property<bool>("IsActive")
.HasColumnType("bit");
b.Property<bool>("LockoutEnabled")
.HasColumnType("bit");
b.Property<DateTimeOffset?>("LockoutEnd")
.HasColumnType("datetimeoffset");
b.Property<string>("NormalizedEmail")
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.Property<string>("NormalizedUserName")
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.Property<string>("PasswordHash")
.HasColumnType("nvarchar(max)");
b.Property<string>("PhoneNumber")
.HasColumnType("nvarchar(max)");
b.Property<bool>("PhoneNumberConfirmed")
.HasColumnType("bit");
b.Property<string>("SecurityStamp")
.HasColumnType("nvarchar(max)");
b.Property<bool>("TwoFactorEnabled")
.HasColumnType("bit");
b.Property<string>("UserName")
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.HasKey("Id");
b.HasIndex("NormalizedEmail")
.HasDatabaseName("EmailIndex");
b.HasIndex("NormalizedUserName")
.IsUnique()
.HasDatabaseName("UserNameIndex")
.HasFilter("[NormalizedUserName] IS NOT NULL");
b.ToTable("Users", (string)null);
});
modelBuilder.Entity("SlpModularCms.Core.Identity.Entities.GlobalAvailabilityState", b =>
{
b.Property<Guid>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("uniqueidentifier");
b.Property<DateTimeOffset>("LastUpdatedAt")
.HasColumnType("datetimeoffset");
b.Property<string>("Message")
.HasColumnType("nvarchar(max)");
b.Property<int>("Status")
.HasColumnType("int");
b.Property<string>("UpdatedBy")
.HasColumnType("nvarchar(max)");
b.HasKey("Id");
b.ToTable("AvailabilityState", (string)null);
});
modelBuilder.Entity("SlpModularCms.Core.Identity.Entities.Invitation", b =>
{
b.Property<Guid>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("uniqueidentifier");
b.Property<DateTimeOffset>("CreatedAt")
.HasColumnType("datetimeoffset");
b.Property<string>("Email")
.IsRequired()
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.Property<DateTimeOffset>("ExpiryDate")
.HasColumnType("datetimeoffset");
b.Property<bool>("IsAccepted")
.HasColumnType("bit");
b.Property<string>("Role")
.IsRequired()
.HasColumnType("nvarchar(max)");
b.Property<string>("Token")
.IsRequired()
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.HasKey("Id");
b.HasIndex("Token")
.IsUnique();
b.ToTable("Invitations");
});
modelBuilder.Entity("SlpModularCms.Core.Identity.Entities.ModulePermission", b =>
{
b.Property<Guid>("UserId")
.HasColumnType("uniqueidentifier");
b.Property<string>("ModuleName")
.HasMaxLength(128)
.HasColumnType("nvarchar(128)");
b.Property<string>("Permission")
.HasMaxLength(128)
.HasColumnType("nvarchar(128)");
b.HasKey("UserId", "ModuleName", "Permission");
b.ToTable("ModulePermissions");
});
modelBuilder.Entity("SlpModularCms.Core.Identity.Entities.RefreshToken", b =>
{
b.Property<Guid>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("uniqueidentifier");
b.Property<DateTimeOffset>("CreatedAt")
.HasColumnType("datetimeoffset");
b.Property<string>("CreatedByIp")
.HasColumnType("nvarchar(max)");
b.Property<DateTimeOffset>("ExpiryDate")
.HasColumnType("datetimeoffset");
b.Property<bool>("IsRevoked")
.HasColumnType("bit");
b.Property<bool>("IsUsed")
.HasColumnType("bit");
b.Property<string>("Token")
.IsRequired()
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.Property<Guid>("UserId")
.HasColumnType("uniqueidentifier");
b.HasKey("Id");
b.HasIndex("Token")
.IsUnique();
b.HasIndex("UserId");
b.ToTable("RefreshTokens");
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<System.Guid>", b =>
{
b.HasOne("SlpModularCms.Core.Identity.Entities.ApplicationRole", null)
.WithMany()
.HasForeignKey("RoleId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<System.Guid>", b =>
{
b.HasOne("SlpModularCms.Core.Identity.Entities.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<System.Guid>", b =>
{
b.HasOne("SlpModularCms.Core.Identity.Entities.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<System.Guid>", b =>
{
b.HasOne("SlpModularCms.Core.Identity.Entities.ApplicationRole", null)
.WithMany()
.HasForeignKey("RoleId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.HasOne("SlpModularCms.Core.Identity.Entities.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<System.Guid>", b =>
{
b.HasOne("SlpModularCms.Core.Identity.Entities.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("SlpModularCms.Core.Identity.Entities.ModulePermission", b =>
{
b.HasOne("SlpModularCms.Core.Identity.Entities.ApplicationUser", "User")
.WithMany("ModulePermissions")
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.Navigation("User");
});
modelBuilder.Entity("SlpModularCms.Core.Identity.Entities.RefreshToken", b =>
{
b.HasOne("SlpModularCms.Core.Identity.Entities.ApplicationUser", "User")
.WithMany("RefreshTokens")
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.Navigation("User");
});
modelBuilder.Entity("SlpModularCms.Core.Identity.Entities.ApplicationUser", b =>
{
b.Navigation("ModulePermissions");
b.Navigation("RefreshTokens");
});
#pragma warning restore 612, 618
}
}
}
@@ -0,0 +1,330 @@
using System;
using Microsoft.EntityFrameworkCore.Migrations;
#nullable disable
namespace SlpModularCms.Core.Migrations
{
/// <inheritdoc />
public partial class InitialCreate : Migration
{
/// <inheritdoc />
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.CreateTable(
name: "AvailabilityState",
columns: table => new
{
Id = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
Status = table.Column<int>(type: "int", nullable: false),
Message = table.Column<string>(type: "nvarchar(max)", nullable: true),
LastUpdatedAt = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: false),
UpdatedBy = table.Column<string>(type: "nvarchar(max)", nullable: true)
},
constraints: table =>
{
table.PrimaryKey("PK_AvailabilityState", x => x.Id);
});
migrationBuilder.CreateTable(
name: "Invitations",
columns: table => new
{
Id = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
Email = table.Column<string>(type: "nvarchar(256)", maxLength: 256, nullable: false),
Role = table.Column<string>(type: "nvarchar(max)", nullable: false),
Token = table.Column<string>(type: "nvarchar(256)", maxLength: 256, nullable: false),
ExpiryDate = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: false),
IsAccepted = table.Column<bool>(type: "bit", nullable: false),
CreatedAt = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_Invitations", x => x.Id);
});
migrationBuilder.CreateTable(
name: "Roles",
columns: table => new
{
Id = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
Name = table.Column<string>(type: "nvarchar(256)", maxLength: 256, nullable: true),
NormalizedName = table.Column<string>(type: "nvarchar(256)", maxLength: 256, nullable: true),
ConcurrencyStamp = table.Column<string>(type: "nvarchar(max)", nullable: true)
},
constraints: table =>
{
table.PrimaryKey("PK_Roles", x => x.Id);
});
migrationBuilder.CreateTable(
name: "Users",
columns: table => new
{
Id = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
IsActive = table.Column<bool>(type: "bit", nullable: false),
CreatedAt = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: false),
UserName = table.Column<string>(type: "nvarchar(256)", maxLength: 256, nullable: true),
NormalizedUserName = table.Column<string>(type: "nvarchar(256)", maxLength: 256, nullable: true),
Email = table.Column<string>(type: "nvarchar(256)", maxLength: 256, nullable: true),
NormalizedEmail = table.Column<string>(type: "nvarchar(256)", maxLength: 256, nullable: true),
EmailConfirmed = table.Column<bool>(type: "bit", nullable: false),
PasswordHash = table.Column<string>(type: "nvarchar(max)", nullable: true),
SecurityStamp = table.Column<string>(type: "nvarchar(max)", nullable: true),
ConcurrencyStamp = table.Column<string>(type: "nvarchar(max)", nullable: true),
PhoneNumber = table.Column<string>(type: "nvarchar(max)", nullable: true),
PhoneNumberConfirmed = table.Column<bool>(type: "bit", nullable: false),
TwoFactorEnabled = table.Column<bool>(type: "bit", nullable: false),
LockoutEnd = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: true),
LockoutEnabled = table.Column<bool>(type: "bit", nullable: false),
AccessFailedCount = table.Column<int>(type: "int", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_Users", x => x.Id);
});
migrationBuilder.CreateTable(
name: "RoleClaims",
columns: table => new
{
Id = table.Column<int>(type: "int", nullable: false)
.Annotation("SqlServer:Identity", "1, 1"),
RoleId = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
ClaimType = table.Column<string>(type: "nvarchar(max)", nullable: true),
ClaimValue = table.Column<string>(type: "nvarchar(max)", nullable: true)
},
constraints: table =>
{
table.PrimaryKey("PK_RoleClaims", x => x.Id);
table.ForeignKey(
name: "FK_RoleClaims_Roles_RoleId",
column: x => x.RoleId,
principalTable: "Roles",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
});
migrationBuilder.CreateTable(
name: "ModulePermissions",
columns: table => new
{
UserId = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
ModuleName = table.Column<string>(type: "nvarchar(128)", maxLength: 128, nullable: false),
Permission = table.Column<string>(type: "nvarchar(128)", maxLength: 128, nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_ModulePermissions", x => new { x.UserId, x.ModuleName, x.Permission });
table.ForeignKey(
name: "FK_ModulePermissions_Users_UserId",
column: x => x.UserId,
principalTable: "Users",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
});
migrationBuilder.CreateTable(
name: "RefreshTokens",
columns: table => new
{
Id = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
Token = table.Column<string>(type: "nvarchar(256)", maxLength: 256, nullable: false),
UserId = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
ExpiryDate = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: false),
IsUsed = table.Column<bool>(type: "bit", nullable: false),
IsRevoked = table.Column<bool>(type: "bit", nullable: false),
CreatedAt = table.Column<DateTimeOffset>(type: "datetimeoffset", nullable: false),
CreatedByIp = table.Column<string>(type: "nvarchar(max)", nullable: true)
},
constraints: table =>
{
table.PrimaryKey("PK_RefreshTokens", x => x.Id);
table.ForeignKey(
name: "FK_RefreshTokens_Users_UserId",
column: x => x.UserId,
principalTable: "Users",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
});
migrationBuilder.CreateTable(
name: "UserClaims",
columns: table => new
{
Id = table.Column<int>(type: "int", nullable: false)
.Annotation("SqlServer:Identity", "1, 1"),
UserId = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
ClaimType = table.Column<string>(type: "nvarchar(max)", nullable: true),
ClaimValue = table.Column<string>(type: "nvarchar(max)", nullable: true)
},
constraints: table =>
{
table.PrimaryKey("PK_UserClaims", x => x.Id);
table.ForeignKey(
name: "FK_UserClaims_Users_UserId",
column: x => x.UserId,
principalTable: "Users",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
});
migrationBuilder.CreateTable(
name: "UserLogins",
columns: table => new
{
LoginProvider = table.Column<string>(type: "nvarchar(450)", nullable: false),
ProviderKey = table.Column<string>(type: "nvarchar(450)", nullable: false),
ProviderDisplayName = table.Column<string>(type: "nvarchar(max)", nullable: true),
UserId = table.Column<Guid>(type: "uniqueidentifier", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_UserLogins", x => new { x.LoginProvider, x.ProviderKey });
table.ForeignKey(
name: "FK_UserLogins_Users_UserId",
column: x => x.UserId,
principalTable: "Users",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
});
migrationBuilder.CreateTable(
name: "UserRoles",
columns: table => new
{
UserId = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
RoleId = table.Column<Guid>(type: "uniqueidentifier", nullable: false)
},
constraints: table =>
{
table.PrimaryKey("PK_UserRoles", x => new { x.UserId, x.RoleId });
table.ForeignKey(
name: "FK_UserRoles_Roles_RoleId",
column: x => x.RoleId,
principalTable: "Roles",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
table.ForeignKey(
name: "FK_UserRoles_Users_UserId",
column: x => x.UserId,
principalTable: "Users",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
});
migrationBuilder.CreateTable(
name: "UserTokens",
columns: table => new
{
UserId = table.Column<Guid>(type: "uniqueidentifier", nullable: false),
LoginProvider = table.Column<string>(type: "nvarchar(450)", nullable: false),
Name = table.Column<string>(type: "nvarchar(450)", nullable: false),
Value = table.Column<string>(type: "nvarchar(max)", nullable: true)
},
constraints: table =>
{
table.PrimaryKey("PK_UserTokens", x => new { x.UserId, x.LoginProvider, x.Name });
table.ForeignKey(
name: "FK_UserTokens_Users_UserId",
column: x => x.UserId,
principalTable: "Users",
principalColumn: "Id",
onDelete: ReferentialAction.Cascade);
});
migrationBuilder.CreateIndex(
name: "IX_Invitations_Token",
table: "Invitations",
column: "Token",
unique: true);
migrationBuilder.CreateIndex(
name: "IX_RefreshTokens_Token",
table: "RefreshTokens",
column: "Token",
unique: true);
migrationBuilder.CreateIndex(
name: "IX_RefreshTokens_UserId",
table: "RefreshTokens",
column: "UserId");
migrationBuilder.CreateIndex(
name: "IX_RoleClaims_RoleId",
table: "RoleClaims",
column: "RoleId");
migrationBuilder.CreateIndex(
name: "RoleNameIndex",
table: "Roles",
column: "NormalizedName",
unique: true,
filter: "[NormalizedName] IS NOT NULL");
migrationBuilder.CreateIndex(
name: "IX_UserClaims_UserId",
table: "UserClaims",
column: "UserId");
migrationBuilder.CreateIndex(
name: "IX_UserLogins_UserId",
table: "UserLogins",
column: "UserId");
migrationBuilder.CreateIndex(
name: "IX_UserRoles_RoleId",
table: "UserRoles",
column: "RoleId");
migrationBuilder.CreateIndex(
name: "EmailIndex",
table: "Users",
column: "NormalizedEmail");
migrationBuilder.CreateIndex(
name: "UserNameIndex",
table: "Users",
column: "NormalizedUserName",
unique: true,
filter: "[NormalizedUserName] IS NOT NULL");
}
/// <inheritdoc />
protected override void Down(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropTable(
name: "AvailabilityState");
migrationBuilder.DropTable(
name: "Invitations");
migrationBuilder.DropTable(
name: "ModulePermissions");
migrationBuilder.DropTable(
name: "RefreshTokens");
migrationBuilder.DropTable(
name: "RoleClaims");
migrationBuilder.DropTable(
name: "UserClaims");
migrationBuilder.DropTable(
name: "UserLogins");
migrationBuilder.DropTable(
name: "UserRoles");
migrationBuilder.DropTable(
name: "UserTokens");
migrationBuilder.DropTable(
name: "Roles");
migrationBuilder.DropTable(
name: "Users");
}
}
}
@@ -0,0 +1,427 @@
// <auto-generated />
using System;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
using SlpModularCms.Core.Data;
#nullable disable
namespace SlpModularCms.Core.Migrations
{
[DbContext(typeof(ApplicationDbContext))]
partial class ApplicationDbContextModelSnapshot : ModelSnapshot
{
protected override void BuildModel(ModelBuilder modelBuilder)
{
#pragma warning disable 612, 618
modelBuilder
.HasAnnotation("ProductVersion", "10.0.9")
.HasAnnotation("Relational:MaxIdentifierLength", 128);
SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<System.Guid>", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("int");
SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
b.Property<string>("ClaimType")
.HasColumnType("nvarchar(max)");
b.Property<string>("ClaimValue")
.HasColumnType("nvarchar(max)");
b.Property<Guid>("RoleId")
.HasColumnType("uniqueidentifier");
b.HasKey("Id");
b.HasIndex("RoleId");
b.ToTable("RoleClaims", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<System.Guid>", b =>
{
b.Property<int>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("int");
SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
b.Property<string>("ClaimType")
.HasColumnType("nvarchar(max)");
b.Property<string>("ClaimValue")
.HasColumnType("nvarchar(max)");
b.Property<Guid>("UserId")
.HasColumnType("uniqueidentifier");
b.HasKey("Id");
b.HasIndex("UserId");
b.ToTable("UserClaims", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<System.Guid>", b =>
{
b.Property<string>("LoginProvider")
.HasColumnType("nvarchar(450)");
b.Property<string>("ProviderKey")
.HasColumnType("nvarchar(450)");
b.Property<string>("ProviderDisplayName")
.HasColumnType("nvarchar(max)");
b.Property<Guid>("UserId")
.HasColumnType("uniqueidentifier");
b.HasKey("LoginProvider", "ProviderKey");
b.HasIndex("UserId");
b.ToTable("UserLogins", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<System.Guid>", b =>
{
b.Property<Guid>("UserId")
.HasColumnType("uniqueidentifier");
b.Property<Guid>("RoleId")
.HasColumnType("uniqueidentifier");
b.HasKey("UserId", "RoleId");
b.HasIndex("RoleId");
b.ToTable("UserRoles", (string)null);
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<System.Guid>", b =>
{
b.Property<Guid>("UserId")
.HasColumnType("uniqueidentifier");
b.Property<string>("LoginProvider")
.HasColumnType("nvarchar(450)");
b.Property<string>("Name")
.HasColumnType("nvarchar(450)");
b.Property<string>("Value")
.HasColumnType("nvarchar(max)");
b.HasKey("UserId", "LoginProvider", "Name");
b.ToTable("UserTokens", (string)null);
});
modelBuilder.Entity("SlpModularCms.Core.Identity.Entities.ApplicationRole", b =>
{
b.Property<Guid>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("uniqueidentifier");
b.Property<string>("ConcurrencyStamp")
.IsConcurrencyToken()
.HasColumnType("nvarchar(max)");
b.Property<string>("Name")
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.Property<string>("NormalizedName")
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.HasKey("Id");
b.HasIndex("NormalizedName")
.IsUnique()
.HasDatabaseName("RoleNameIndex")
.HasFilter("[NormalizedName] IS NOT NULL");
b.ToTable("Roles", (string)null);
});
modelBuilder.Entity("SlpModularCms.Core.Identity.Entities.ApplicationUser", b =>
{
b.Property<Guid>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("uniqueidentifier");
b.Property<int>("AccessFailedCount")
.HasColumnType("int");
b.Property<string>("ConcurrencyStamp")
.IsConcurrencyToken()
.HasColumnType("nvarchar(max)");
b.Property<DateTimeOffset>("CreatedAt")
.HasColumnType("datetimeoffset");
b.Property<string>("Email")
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.Property<bool>("EmailConfirmed")
.HasColumnType("bit");
b.Property<bool>("IsActive")
.HasColumnType("bit");
b.Property<bool>("LockoutEnabled")
.HasColumnType("bit");
b.Property<DateTimeOffset?>("LockoutEnd")
.HasColumnType("datetimeoffset");
b.Property<string>("NormalizedEmail")
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.Property<string>("NormalizedUserName")
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.Property<string>("PasswordHash")
.HasColumnType("nvarchar(max)");
b.Property<string>("PhoneNumber")
.HasColumnType("nvarchar(max)");
b.Property<bool>("PhoneNumberConfirmed")
.HasColumnType("bit");
b.Property<string>("SecurityStamp")
.HasColumnType("nvarchar(max)");
b.Property<bool>("TwoFactorEnabled")
.HasColumnType("bit");
b.Property<string>("UserName")
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.HasKey("Id");
b.HasIndex("NormalizedEmail")
.HasDatabaseName("EmailIndex");
b.HasIndex("NormalizedUserName")
.IsUnique()
.HasDatabaseName("UserNameIndex")
.HasFilter("[NormalizedUserName] IS NOT NULL");
b.ToTable("Users", (string)null);
});
modelBuilder.Entity("SlpModularCms.Core.Identity.Entities.GlobalAvailabilityState", b =>
{
b.Property<Guid>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("uniqueidentifier");
b.Property<DateTimeOffset>("LastUpdatedAt")
.HasColumnType("datetimeoffset");
b.Property<string>("Message")
.HasColumnType("nvarchar(max)");
b.Property<int>("Status")
.HasColumnType("int");
b.Property<string>("UpdatedBy")
.HasColumnType("nvarchar(max)");
b.HasKey("Id");
b.ToTable("AvailabilityState", (string)null);
});
modelBuilder.Entity("SlpModularCms.Core.Identity.Entities.Invitation", b =>
{
b.Property<Guid>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("uniqueidentifier");
b.Property<DateTimeOffset>("CreatedAt")
.HasColumnType("datetimeoffset");
b.Property<string>("Email")
.IsRequired()
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.Property<DateTimeOffset>("ExpiryDate")
.HasColumnType("datetimeoffset");
b.Property<bool>("IsAccepted")
.HasColumnType("bit");
b.Property<string>("Role")
.IsRequired()
.HasColumnType("nvarchar(max)");
b.Property<string>("Token")
.IsRequired()
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.HasKey("Id");
b.HasIndex("Token")
.IsUnique();
b.ToTable("Invitations");
});
modelBuilder.Entity("SlpModularCms.Core.Identity.Entities.ModulePermission", b =>
{
b.Property<Guid>("UserId")
.HasColumnType("uniqueidentifier");
b.Property<string>("ModuleName")
.HasMaxLength(128)
.HasColumnType("nvarchar(128)");
b.Property<string>("Permission")
.HasMaxLength(128)
.HasColumnType("nvarchar(128)");
b.HasKey("UserId", "ModuleName", "Permission");
b.ToTable("ModulePermissions");
});
modelBuilder.Entity("SlpModularCms.Core.Identity.Entities.RefreshToken", b =>
{
b.Property<Guid>("Id")
.ValueGeneratedOnAdd()
.HasColumnType("uniqueidentifier");
b.Property<DateTimeOffset>("CreatedAt")
.HasColumnType("datetimeoffset");
b.Property<string>("CreatedByIp")
.HasColumnType("nvarchar(max)");
b.Property<DateTimeOffset>("ExpiryDate")
.HasColumnType("datetimeoffset");
b.Property<bool>("IsRevoked")
.HasColumnType("bit");
b.Property<bool>("IsUsed")
.HasColumnType("bit");
b.Property<string>("Token")
.IsRequired()
.HasMaxLength(256)
.HasColumnType("nvarchar(256)");
b.Property<Guid>("UserId")
.HasColumnType("uniqueidentifier");
b.HasKey("Id");
b.HasIndex("Token")
.IsUnique();
b.HasIndex("UserId");
b.ToTable("RefreshTokens");
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<System.Guid>", b =>
{
b.HasOne("SlpModularCms.Core.Identity.Entities.ApplicationRole", null)
.WithMany()
.HasForeignKey("RoleId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<System.Guid>", b =>
{
b.HasOne("SlpModularCms.Core.Identity.Entities.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<System.Guid>", b =>
{
b.HasOne("SlpModularCms.Core.Identity.Entities.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<System.Guid>", b =>
{
b.HasOne("SlpModularCms.Core.Identity.Entities.ApplicationRole", null)
.WithMany()
.HasForeignKey("RoleId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.HasOne("SlpModularCms.Core.Identity.Entities.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<System.Guid>", b =>
{
b.HasOne("SlpModularCms.Core.Identity.Entities.ApplicationUser", null)
.WithMany()
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
});
modelBuilder.Entity("SlpModularCms.Core.Identity.Entities.ModulePermission", b =>
{
b.HasOne("SlpModularCms.Core.Identity.Entities.ApplicationUser", "User")
.WithMany("ModulePermissions")
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.Navigation("User");
});
modelBuilder.Entity("SlpModularCms.Core.Identity.Entities.RefreshToken", b =>
{
b.HasOne("SlpModularCms.Core.Identity.Entities.ApplicationUser", "User")
.WithMany("RefreshTokens")
.HasForeignKey("UserId")
.OnDelete(DeleteBehavior.Cascade)
.IsRequired();
b.Navigation("User");
});
modelBuilder.Entity("SlpModularCms.Core.Identity.Entities.ApplicationUser", b =>
{
b.Navigation("ModulePermissions");
b.Navigation("RefreshTokens");
});
#pragma warning restore 612, 618
}
}
}
+30
View File
@@ -0,0 +1,30 @@
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
namespace SlpModularCms.Core.Modules;
/// <summary>
/// Interface voor een module binnen het SlpModularCms systeem.
/// </summary>
public interface IModule
{
/// <summary>
/// De unieke naam van de module.
/// </summary>
string Name { get; }
/// <summary>
/// De versie van de module.
/// </summary>
string Version { get; }
/// <summary>
/// Registreert services in de dependency injection container.
/// </summary>
void RegisterServices(IServiceCollection services);
/// <summary>
/// Configureert de module in de HTTP request pipeline.
/// </summary>
void UseModule(IApplicationBuilder app);
}
@@ -0,0 +1,11 @@
namespace SlpModularCms.Core.Modules;
/// <summary>
/// Metadata over een geladen module.
/// </summary>
public record ModuleInfo(
string Name,
string Version,
string? Description = null,
bool IsLoaded = false
);
@@ -0,0 +1,22 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net10.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<FrameworkReference Include="Microsoft.AspNetCore.App" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="10.0.9" />
<PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="10.0.9" />
<PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="10.0.9" />
<PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="10.0.9" />
<PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="10.0.9" />
<PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.9" />
</ItemGroup>
</Project>