refactor(DigitalData.Core.Security.RSAKey.Base): Ordnerverzeichnisse und Namespaces geordnet

DigitalData.Core.Security/Extensions/DIExtensions.cs

@@ -0,0 +1,36 @@
+using DigitalData.Core.Abstractions.Security.Services;
+using DigitalData.Core.Security.Config;
+using DigitalData.Core.Security.Services;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using System.Security.Claims;
+
+namespace DigitalData.Core.Security.Extensions;
+
+public static class DIExtensions
+{
+    /// <summary>
+    /// Registers a custom asym crypt service with specified parameters from the given configuration section.
+    /// </summary>
+    /// <param name="services"></param>
+    /// <param name="section"></param>
+    /// <returns>The updated <see cref="IServiceCollection"/> with the RSA Factory registered.</returns>
+    public static IServiceCollection AddCryptoFactory(this IServiceCollection services, IConfiguration configuration) => services
+        .Configure<RSAParams>(configuration)
+        .AddAutoMapper(typeof(MappingProfile).Assembly)
+        .AddSingleton<IAsymmetricKeyPool, RSAPool>()
+        .AddSingleton<IAsymmetricKeyFactory, RSAFactory>()
+        .AddHostedService<PemFileInitalizer>();
+
+    public static IServiceCollection AddJwtSignatureHandler<TPrincipal>(this IServiceCollection services,
+        Func<TPrincipal, IDictionary<string, object>>? claimsMapper = null,
+        Func<TPrincipal, ClaimsIdentity>? subjectMapper = null)
+        => services
+            .AddSingleton<IJwtSignatureHandler<TPrincipal>, JwtSignatureHandler<TPrincipal>>()
+            .AddSingleton(sp => Options.Create(new ClaimDescriptor<TPrincipal>
+            {
+                CreateClaims = claimsMapper,
+                CreateSubject = subjectMapper
+            }));
+}

DigitalData.Core.Security/Extensions/Extension.cs

@@ -0,0 +1,88 @@
+using AutoMapper;
+using DigitalData.Core.Abstractions.Security.Key;
+using Microsoft.IdentityModel.Tokens;
+
+namespace DigitalData.Core.Security.Extensions;
+
+internal static class Extension
+{
+    /// <summary>
+    /// Converts a <see cref="DateTime"/> to a formatted string based on the specified format string.
+    /// <br />
+    /// - If the format contains the symbol “//”, the method divides the numeric value obtained from the left side of the format
+    ///   by one minus the numeric value obtained from the right side of the format string and adds one. For instance:
+    /// <br />
+    /// - If the date is 02.03.2024 and the format is "MM//2", it extracts the month (02), subtracts one (3), divides it by 2,
+    ///   rounds down the outgoing number (1), adds one to the number (resulting in 2).
+    ///   <br />
+    /// - If the format does not contain "//", the method uses the default <see cref="DateTime.ToString"/> format.
+    /// <br />
+    /// </summary>
+    /// <param name="date">The <see cref="DateTime"/> value to be formatted.</param>
+    /// <param name="format">The format string that dictates the formatting of the date. If the format includes the "//" symbol, 
+    /// it splits the string at "//" and divides the left-side value by the right-side value. The format string can include standard
+    /// <see cref="DateTime.ToString"/> format patterns.</param>
+    /// <returns>A string representation of the formatted date, or the result of the division operation if "//" is present in the format.</returns>
+    /// <exception cref="ArgumentException">Thrown if the format string is invalid, such as having an incorrect number of parts after "//".</exception>
+    /// <exception cref="DivideByZeroException">Thrown if the right side of the "//" contains a zero, resulting in division by zero.</exception>
+    /// <exception cref="FormatException">Thrown if either the left-side or right-side value of "//" cannot be parsed as an integer.</exception>
+    internal static string ToTag(this DateTime date, string format)
+    {
+        if (format is not null && format.Contains("//"))
+        {
+            var subStrings = format.Split("//");
+
+            if (subStrings.Length != 2)
+                throw new ArgumentException($"Date tag format {format} is invalid. It must contain exactly one '//' separator.", nameof(format));
+
+            var formattedLeft = date.ToString(subStrings[0]);
+
+            if (!int.TryParse(formattedLeft, out var dateValue))
+                throw new FormatException($"The left-side value ({formattedLeft}) of the format could not be parsed to an integer.");
+
+            if (!int.TryParse(subStrings[1], out var divisor))
+                throw new FormatException($"The right-side value ({divisor}) of the format could not be parsed to an integer.");
+
+            if (divisor == 0)
+                throw new DivideByZeroException($"Date tag format {format} includes division by zero, which is not allowed.");
+
+            var result = (dateValue - 1) / divisor + 1;
+            return result.ToString();
+        }
+
+        return date.ToString(format);
+    }
+
+    /// <summary>
+    /// Converts a <see cref="DateTime"/> to a formatted string based on the specified format string.
+    /// <br />
+    /// - If the format contains the symbol “//”, the method divides the numeric value obtained from the left side of the format
+    ///   by one minus the numeric value obtained from the right side of the format string and adds one. For instance:
+    /// <br />
+    /// - If the date is 02.03.2024 and the format is "MM//2", it extracts the month (02), subtracts one (3), divides it by 2,
+    ///   rounds down the outgoing number (1), adds one to the number (resulting in 2).
+    ///   <br />
+    /// - If the format does not contain "//", the method uses the default <see cref="DateTime.ToString"/> format.
+    /// <br />
+    /// This method provides a way to format the date based on typical or customized rules, including mathematical operations like division.
+    /// </summary>
+    /// <param name="date">The <see cref="DateOnly"/> value to be formatted. It will convert to DateTime to use the method shared with DateTime.</param>
+    /// <param name="format">The format string that dictates the formatting of the date. If the format includes the "//" symbol, 
+    /// it splits the string at "//" and divides the left-side value by the right-side value. The format string can include standard
+    /// <see cref="DateTime.ToString"/> format patterns.</param>
+    /// <returns>A string representation of the formatted date, or the result of the division operation if "//" is present in the format.</returns>
+    /// <exception cref="ArgumentException">Thrown if the format string is invalid, such as having an incorrect number of parts after "//".</exception>
+    /// <exception cref="DivideByZeroException">Thrown if the right side of the "//" contains a zero, resulting in division by zero.</exception>
+    /// <exception cref="FormatException">Thrown if either the left-side or right-side value of "//" cannot be parsed as an integer.</exception>
+    internal static string ToTag(this DateOnly date, string format) => date.ToDateTime(new()).ToTag(format);
+
+    /// <summary>
+    /// Maps a <see cref="RSATokenDescriptor"/> to a <see cref="SecurityTokenDescriptor"/>.
+    /// </summary>
+    /// <param name="mapper">The <see cref="IMapper"/> instance used for mapping.</param>
+    /// <param name="description">The <see cref="RSATokenDescriptor"/> instance to be mapped.</param>
+    /// <returns>A <see cref="SecurityTokenDescriptor"/> instance populated with the mapped values.</returns>
+    /// <exception cref="ArgumentNullException">Thrown if <paramref name="mapper"/> or <paramref name="description"/> is <c>null</c>.</exception>
+    internal static SecurityTokenDescriptor Map(this IMapper mapper, IAsymmetricTokenDescriptor description)
+        => mapper.Map(description, new SecurityTokenDescriptor());
+}