pfm/PostFundManagement.Domain/Extensions/Api.cs

using PostFundManagement.Domain.Abstractions;
using PostFundManagement.Domain.Api;
using PostFundManagement.Domain.Api.Configuration;

namespace PostFundManagement.Domain.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);
}