many fixes and improvements - rework for modules/ and common/

feat(emailer): add Postmark and Resend providers

backend/Infrastructure/Security/ClaimsPrincipalExtensions.cs

@@ -0,0 +1,57 @@
+using System.Security.Claims;
+
+namespace Hutopy.Infrastructure.Security;
+
+public static class ClaimsPrincipalExtensions
+{
+    public static Guid GetUserId(this ClaimsPrincipal claims)
+    {
+        return (Guid)claims.GetRequiredClaim<Guid>(ClaimTypes.NameIdentifier);
+    }
+    
+    public static string GetName(this ClaimsPrincipal claims)
+    {
+        return (string)claims.GetRequiredClaim<string>(ClaimTypes.Name);
+    }
+    
+    public static string? GetAlias(this ClaimsPrincipal claims)
+    {
+        return (string?)claims.GetClaim<string?>(KnownClaims.Alias);
+    } 
+    
+    public static string? GetPortraitUrl(this ClaimsPrincipal claims)
+    {
+        return (string?)claims.GetClaim<string?>(KnownClaims.PortraitUrl);
+    } 
+    
+    public static string GetFirstName(this ClaimsPrincipal claims)
+    {
+        return (string)claims.GetRequiredClaim<string>(ClaimTypes.GivenName);
+    }
+
+    public static string GetLastName(this ClaimsPrincipal claims)
+    {
+        return (string)claims.GetRequiredClaim<string>(ClaimTypes.Surname);
+    }
+
+    public static string GetEmail(this ClaimsPrincipal claims)
+    {
+        return (string)claims.GetRequiredClaim<string>(ClaimTypes.Email);
+    }
+
+    private static object? GetClaim<TValue>(this ClaimsPrincipal claims, string key)
+    {
+        var claim = claims.FindFirst(key);
+
+        return claim is null ? null : claims.GetRequiredClaim<TValue>(key);
+    }
+
+    private static object GetRequiredClaim<TValue>(this ClaimsPrincipal claims, string key)
+    {
+        var claim = claims.FindFirst(key);
+
+        if (claim is null) throw new MissingClaimException(key);
+
+        return typeof(TValue) == typeof(Guid) ? Guid.Parse(claim.Value) : Convert.ChangeType(claim.Value, typeof(TValue));
+    }
+}

backend/Infrastructure/Security/GenerateJwtToken.cs

@@ -0,0 +1,52 @@
+using System.IdentityModel.Tokens.Jwt;
+using System.Security.Claims;
+using System.Text;
+using Microsoft.IdentityModel.Tokens;
+
+namespace Hutopy.Infrastructure.Security;
+
+public static class JwtTokenHelper
+{
+    public static string GenerateJwtToken(
+        TimeSpan expiresIn,
+        string issuer,
+        string audience,
+        string key,
+        string userId,
+        string email,
+        string? alias,
+        string firstname,
+        string lastname,
+        string? portraitUrl)
+    {
+        var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(key));
+        var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);
+
+        var claims = new List<Claim>([
+            new Claim(JwtRegisteredClaimNames.Sub, userId),
+            new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
+            new Claim(ClaimTypes.NameIdentifier, userId), new Claim(ClaimTypes.Email, email),
+            new Claim(ClaimTypes.Name, email), new Claim(ClaimTypes.GivenName, firstname),
+            new Claim(ClaimTypes.Surname, lastname)
+        ]);
+
+        if (alias is not null)
+        {
+            claims.Add(new Claim(KnownClaims.Alias, alias));
+        }
+
+        if (portraitUrl is not null)
+        {
+            claims.Add(new Claim(KnownClaims.PortraitUrl, portraitUrl));
+        }
+
+        var token = new JwtSecurityToken(
+            issuer: issuer,
+            audience: audience,
+            claims: claims,
+            expires: DateTime.Now.Add(expiresIn),
+            signingCredentials: credentials);
+
+        return new JwtSecurityTokenHandler().WriteToken(token);
+    }
+}

backend/Infrastructure/Security/KnownClaims.cs

@@ -0,0 +1,7 @@
+namespace Hutopy.Infrastructure.Security;
+
+public static class KnownClaims
+{
+    public const string Alias = "alias";
+    public const string PortraitUrl = "portraitUrl";
+}

backend/Infrastructure/Security/MissingClaimException.cs

@@ -0,0 +1,5 @@
+namespace Hutopy.Infrastructure.Security;
+
+public class MissingClaimException(
+    string claimName)
+    : Exception($"Claim '{claimName}' is missing.");

backend/Infrastructure/Security/PasswordGenerator.cs

@@ -0,0 +1,76 @@
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Hutopy.Infrastructure.Security;
+
+// If we need to add special characters we can alternate between 2 pools.
+public static class PasswordGenerator
+{
+    private const string LowerLetters = "abcdefghijklmnopqrstuvwxyz";
+    private const string UpperLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    private const string Numbers = "0123456789";
+    private const string SpecialCharacters = "!@#$%^&*()_+-=[];',./`~{}|:\"<>?";
+
+    private static readonly Random Random = new();
+
+    public static string Next(
+        int length = 15,
+        bool requireNumber = true,
+        bool requireLowercase = true,
+        bool requireCapital = true,
+        bool requireSpecialCharacter = true)
+    {
+        // Create pools based on the requirements
+        var characterPool = new StringBuilder();
+
+        if (requireNumber)
+            characterPool.Append(LowerLetters);
+        
+        if (requireCapital)
+            characterPool.Append(UpperLetters);
+
+        if (requireNumber)
+            characterPool.Append(Numbers);
+
+        if (requireSpecialCharacter)
+            characterPool.Append(SpecialCharacters);
+
+        // Ensure that the length is within the specified bounds
+        var password = new char[length];
+
+        // Ensure at least one character from each required category is included
+        int index = 0;
+        
+        if (requireLowercase)
+            password[index++] = LowerLetters[Random.Next(LowerLetters.Length)];
+        
+        if (requireCapital)
+            password[index++] = UpperLetters[Random.Next(UpperLetters.Length)];
+        
+        if (requireNumber)
+            password[index++] = Numbers[Random.Next(Numbers.Length)];
+        
+        if (requireSpecialCharacter)
+            password[index++] = SpecialCharacters[Random.Next(SpecialCharacters.Length)];
+        
+        // Fill the rest with the password
+        for (int i = index; i < length; i++)
+        {
+            password[i] = characterPool[RandomNumberGenerator.GetInt32(characterPool.Length)];
+        }
+
+        // Shuffle the password to randomize the placement of the required characters
+        Shuffle(password);
+        return new string(password);
+    }
+
+    private static void Shuffle(
+        char[] array)
+    {
+        for (int i = array.Length - 1; i > 0; i--)
+        {
+            int j = Random.Next(i + 1);
+            (array[i], array[j]) = (array[j], array[i]); // Swap elements
+        }
+    }
+}

backend/Infrastructure/Security/RefreshTokenGenerator.cs

@@ -0,0 +1,13 @@
+using System.Security.Cryptography;
+
+namespace Hutopy.Infrastructure.Security;
+
+public static class RefreshTokenGenerator
+{
+    public static string Next()
+    {
+        var randomNumber = new byte[32];
+        RandomNumberGenerator.Fill(randomNumber);
+        return Convert.ToBase64String(randomNumber);
+    }
+}