Refactored endpoints to use services

2026-08-30 14:24:13 +02:00
parent b288450cbb
commit f51b1feb4b
78 changed files with 1494 additions and 870 deletions
@@ -0,0 +1,178 @@
+using Asp.Versioning;
+using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Domain.Api;
+using PostFundManagement.Domain.Api.Configuration;
+
+namespace PostFundManagement.Application.Extensions;
+
+public static class Api
+{
+    public static void ConfigureCookieOidcSameSiteSupport(this IServiceCollection services) =>
+        services.Configure<CookiePolicyOptions>(options =>
+        {
+            options.MinimumSameSitePolicy = SameSiteMode.Unspecified;
+            options.OnAppendCookie = cookieContext => CheckSameSite(cookieContext.Context, cookieContext.CookieOptions);
+            options.OnDeleteCookie = cookieContext => CheckSameSite(cookieContext.Context, cookieContext.CookieOptions);
+        });
+
+    public static void CheckSameSite(HttpContext httpContext, CookieOptions options)
+    {
+        if (options.SameSite == SameSiteMode.None)
+        {
+            bool isSecure = httpContext.Request.IsHttps;
+
+            if (!isSecure && httpContext.Request.Headers.TryGetValue("X-Forwarded-Proto", out var proto))
+                isSecure = string.Equals(proto, "https", StringComparison.OrdinalIgnoreCase);
+
+            if (!isSecure && httpContext.Request.Headers.TryGetValue("Forwarded", out var forwarded))
+                isSecure = forwarded.ToString().Contains("proto=https", StringComparison.OrdinalIgnoreCase);
+
+            if (!isSecure) options.SameSite = SameSiteMode.Unspecified;
+        }
+    }
+
+    public static IServiceCollection AddLiteCharmsApiSecurity(this IServiceCollection services, IConfiguration configuration)
+    {
+        var configSection = configuration.GetSection(nameof(SecuritySettings));
+
+        var authOptions = new SecuritySettings();
+        configSection.Bind(authOptions);
+
+        services.Configure<SecuritySettings>(configSection);
+
+        services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
+            .AddJwtBearer(options =>
+            {
+                options.Authority = authOptions.Authority;
+                options.Audience = authOptions.Audience;
+                options.TokenValidationParameters = new TokenValidationParameters
+                {
+                    ValidIssuer = authOptions.Authority,
+                    ValidateAudience = true,
+                    ValidateIssuer = true,
+                };
+            });
+
+        services.AddAuthorization();
+
+        return services;
+    }
+
+    public static WebApplication AddSecurityEndpoints(this WebApplication app)
+    {
+        app.MapGet("/login", async (HttpContext context, string redirectUri = "/") =>
+        {
+            await context.ChallengeAsync(OpenIdConnectDefaults.AuthenticationScheme, new AuthenticationProperties
+            {
+                RedirectUri = redirectUri,
+            });
+        });
+
+        app.MapGet("/logout", async (HttpContext context, string? redirectUri = null) =>
+        {
+            var idToken = await context.GetTokenAsync("id_token");
+
+            if (string.IsNullOrWhiteSpace(redirectUri))
+            {
+                var host = context.Request.Host.ToUriComponent();
+                redirectUri = $"https://{host}/";
+            }
+
+            var authProperties = new AuthenticationProperties { RedirectUri = redirectUri, };
+
+            if (!string.IsNullOrEmpty(idToken))
+                authProperties.Parameters.Add("id_token_hint", idToken);
+
+            await context.SignOutAsync(OpenIdConnectDefaults.AuthenticationScheme, authProperties);
+        });
+
+        return app;
+    }
+
+    public static IServiceCollection AddApiServices(this IServiceCollection services, IConfiguration configuration)
+    {
+        services.AddHttpClient();
+
+        services.AddApiVersioning(options =>
+        {
+            options.ReportApiVersions = true;
+            options.AssumeDefaultVersionWhenUnspecified = true;
+            options.ApiVersionReader = ApiVersionReader.Combine(new UrlSegmentApiVersionReader(),
+                new QueryStringApiVersionReader("version"),
+                new QueryStringApiVersionReader("version"),
+                new MediaTypeApiVersionReader("version"));
+        })
+        .AddApiExplorer(options =>
+        {
+            options.GroupNameFormat = "'v'VVV";
+            options.SubstituteApiVersionInUrl = true;
+        });
+
+        var urls = configuration["ASPNETCORE_URLS"] ?? configuration["Urls"];
+        var healthUrl = "http://localhost:8080/health";
+
+        if (!string.IsNullOrWhiteSpace(urls))
+        {
+            string firstUrl = urls.Split(';').FirstOrDefault(s => s.Contains("http://", StringComparison.InvariantCultureIgnoreCase))!
+                .Replace("0.0.0.0", "localhost")
+                .Replace("*", "localhost")
+                .Replace("+", "localhost");
+
+            healthUrl = $"{firstUrl.TrimEnd('/')}/health";
+        }
+
+        services.AddHealthChecksUI(setup =>
+        {
+            setup.SetNotifyUnHealthyOneTimeUntilChange();
+            setup.AddHealthCheckEndpoint("primary, heal", healthUrl);
+            setup.SetHeaderText("Midrand Books");
+        })
+        .AddInMemoryStorage();
+
+        services.AddOutputCache(options =>
+        {
+            options.AddBasePolicy(builder => builder.Cache());
+            options.DefaultExpirationTimeSpan = TimeSpan.FromSeconds(10);
+        });
+
+        services.AddOpenApi(options => options.AddDocumentTransformer<OpenApiBearerSecuritySchemeTransformer>());
+
+        return services;
+    }
+
+    public static IApplicationBuilder MapEndpoints(this WebApplication app, IDictionary<int, RouteGroupBuilder> versionGroups)
+    {
+        var endpoints = app.Services.GetRequiredService<IEnumerable<IEndpoint>>();
+
+        foreach (var endpoint in endpoints)
+        {
+            var versionAttributes = endpoint.GetType().GetCustomAttributes<ApiVersionTargetAttribute>().ToList();
+
+            if (versionAttributes.Count != 0)
+            {
+                foreach (var attr in versionAttributes)
+                    if (versionGroups.TryGetValue(attr.MajorVersion, out var targetGroup))
+                        endpoint.Map(targetGroup);
+            }
+            else
+                endpoint.Map(app);
+        }
+
+        return app;
+    }
+
+    public static IServiceCollection AddEndpoints(this IServiceCollection services, Assembly assembly)
+    {
+        ServiceDescriptor[] discriptors = [.. assembly.DefinedTypes
+        .Where(t => t is { IsInterface: false, IsAbstract: false })
+        .Where(t => t.IsAssignableTo(typeof(IEndpoint)))
+        .Select(t => ServiceDescriptor.Transient(typeof(IEndpoint), t))];
+
+        services.TryAddEnumerable(discriptors);
+
+        return services;
+    }
+
+    public static string ToEndpointName(this Type target, string? annotation = "") =>
+        $"{target.Name.Replace("Endpoint", string.Empty)}{annotation}".ToLower(CultureInfo.CurrentCulture);
+}
@@ -0,0 +1,23 @@
+using PostFundManagement.Application.Shared;
+using PostFundManagement.Domain.Configuration.Email;
+
+namespace PostFundManagement.Application.Extensions;
+
+public static class Email
+{    
+    public const string EmailFromName = "PFM Team";
+    public const string EmailFromAddress = "info@pfm.co.za"; // TODO: replace with real address
+
+    public static IServiceCollection AddEmailServices(this IServiceCollection services, IConfiguration configuration)
+    {
+        services.Configure<SmtpSettings>(configuration.GetSection("Email"));
+
+        services.AddSingleton<EmailService>();
+
+        services.AddOpenTelemetry()
+            .WithTracing(tracing => tracing.AddSource("Pfm.EmailService"))
+            .WithMetrics(metrics => metrics.AddMeter("Pfm.EmailService"));
+
+        return services;
+    }
+}
@@ -0,0 +1,19 @@
+using PostFundManagement.Application.Abstractions;
+using PostFundManagement.Domain.Abstractions;
+
+namespace PostFundManagement.Application.Extensions;
+
+public static class General
+{
+    public static IServiceCollection AddRegisterServices(this IServiceCollection services)
+    {
+        var serviceType = typeof(IService);
+
+        var sharedImplementations = typeof(IApplication).Assembly.GetTypes()
+            .Where(t => serviceType.IsAssignableFrom(t) && t.IsClass && !t.IsAbstract);
+
+        foreach (var sharedImplementation in sharedImplementations) services.AddScoped(sharedImplementation);
+
+        return services;
+    }
+}
@@ -0,0 +1,23 @@
+using PostFundManagement.Application.Shared;
+using PostFundManagement.Domain.Configuration.Hash;
+
+namespace PostFundManagement.Application.Extensions;
+
+public static class Hash
+{
+    public const string HasherConfigSectionName = "HasherSettings";
+
+    public static IServiceCollection AddHashServices(this IServiceCollection services, IConfiguration configuration)
+    {
+        services.Configure<HasherSettings>(configuration.GetSection(HasherConfigSectionName));
+
+        var settings = configuration.GetSection(HasherConfigSectionName).Get<HasherSettings>();
+
+        services.AddSingleton<IHashids>(_ =>
+            new Hashids(settings!.Salt, minHashLength: settings.MinHashLength));
+
+        services.AddSingleton<HashService>();
+
+        return services;
+    }    
+}
@@ -0,0 +1,64 @@
+using PostFundManagement.Application.Shared;
+using PostFundManagement.Domain.Abstractions;
+using static PostFundManagement.Domain.Extensions.Constants;
+
+namespace PostFundManagement.Application.Extensions;
+
+public static class S3
+{
+    public static IServiceCollection AddGarageS3(this IServiceCollection services, IConfiguration configuration)
+    {        
+        if (!string.IsNullOrWhiteSpace(configuration.GetSection($"{GeneralS3SettingsSection}:ServiceUrl").Value))
+        {
+            services.AddKeyedSingleton<IAmazonS3, AmazonS3Client>(GeneralBucketName, (provider, client) =>
+                new AmazonS3Client(new BasicAWSCredentials(configuration.GetSection($"{GeneralS3SettingsSection}:AccessKey").Value,
+                configuration.GetSection($"{GeneralS3SettingsSection}:SecretKey").Value),
+                new AmazonS3Config
+                {
+                    ServiceURL = configuration.GetSection($"{GeneralS3SettingsSection}:ServiceUrl").Value,
+                    AuthenticationRegion = configuration.GetSection($"{GeneralS3SettingsSection}:Region").Value,
+                    ForcePathStyle = true,
+                    EndpointDiscoveryEnabled = true,
+                    UseHttp = configuration.GetSection($"{GeneralS3SettingsSection}:ServiceUrl").Value!.Contains("http://", StringComparison.InvariantCultureIgnoreCase),
+                }));
+
+            services.AddKeyedScoped<IS3Service, GeneralS3Service>(GeneralBucketName); 
+        }
+
+        if (!string.IsNullOrWhiteSpace(configuration.GetSection($"{EvidenceS3SettingsSection}:ServiceUrl").Value))
+        {
+            services.AddKeyedSingleton<IAmazonS3, AmazonS3Client>(EvidenceBucketName, (provider, client) =>
+                new AmazonS3Client(new BasicAWSCredentials(configuration.GetSection($"{EvidenceS3SettingsSection}:AccessKey").Value,
+                configuration.GetSection($"{EvidenceS3SettingsSection}:SecretKey").Value),
+                new AmazonS3Config
+                {
+                    ServiceURL = configuration.GetSection($"{EvidenceS3SettingsSection}:ServiceUrl").Value,
+                    AuthenticationRegion = configuration.GetSection($"{EvidenceS3SettingsSection}:Region").Value,
+                    ForcePathStyle = true,
+                    EndpointDiscoveryEnabled = true,
+                    UseHttp = configuration.GetSection($"{EvidenceS3SettingsSection}:ServiceUrl").Value!.Contains("http://", StringComparison.InvariantCultureIgnoreCase),
+                }));
+
+            services.AddKeyedScoped<IS3Service, EvidenceS3Service>(EvidenceBucketName);
+        }
+
+        if (!string.IsNullOrWhiteSpace(configuration.GetSection($"{ContractS3SettingsSection}:ServiceUrl").Value))
+        {
+            services.AddKeyedSingleton<IAmazonS3, AmazonS3Client>(ContractBucketName, (provider, client) =>
+                new AmazonS3Client(new BasicAWSCredentials(configuration.GetSection($"{ContractS3SettingsSection}:AccessKey").Value,
+                configuration.GetSection($"{ContractS3SettingsSection}:SecretKey").Value),
+                new AmazonS3Config
+                {
+                    ServiceURL = configuration.GetSection($"{ContractS3SettingsSection}:ServiceUrl").Value,
+                    AuthenticationRegion = configuration.GetSection($"{ContractS3SettingsSection}:Region").Value,
+                    ForcePathStyle = true,
+                    EndpointDiscoveryEnabled = true,
+                    UseHttp = configuration.GetSection($"{ContractS3SettingsSection}:ServiceUrl").Value!.Contains("http://", StringComparison.InvariantCultureIgnoreCase),
+                }));
+
+            services.AddKeyedScoped<IS3Service, ContractS3Service>(ContractBucketName);
+        }
+
+        return services;
+    }
+}