pfm/PostFundManagement.Application/Extensions/Services.cs

using PostFundManagement.Application.Abstractions;
using PostFundManagement.Application.Abstractions.Services;
using PostFundManagement.Application.Interceptors;
using PostFundManagement.Application.Services.Communications;
using PostFundManagement.Application.Services.Evidence;
using PostFundManagement.Application.Services.Execution;
using PostFundManagement.Application.Services.Governance;
using PostFundManagement.Application.Services.Grants;
using PostFundManagement.Application.Services.Projects;
using PostFundManagement.Application.Services.Shared;
using PostFundManagement.Application.Services.Tools;
using PostFundManagement.Application.Services.Users;
using PostFundManagement.Domain.Abstractions;

namespace PostFundManagement.Application.Extensions;

public static class Services
{
    public static IServiceCollection AddAuditedCachedScoped<TInterface, TImplementation, TCacheDecorator>(this IServiceCollection services)
        where TInterface : class
        where TImplementation : class, TInterface
        where TCacheDecorator : class, TInterface
    {
        services.AddScoped<TImplementation>();
        services.AddScoped<TCacheDecorator>();

        services.AddScoped(sp =>
        {
            var proxyGenerator = sp.GetRequiredService<ProxyGenerator>();
            var interceptor = sp.GetRequiredService<AuditInterceptor>();

            var actual = sp.GetRequiredService<TImplementation>();

            var cached = ActivatorUtilities.CreateInstance<TCacheDecorator>(sp, actual);

            return proxyGenerator.CreateInterfaceProxyWithTarget<TInterface>(cached, interceptor.ToInterceptor());
        });

        return services;
    }

    public static IServiceCollection AddAuditedScoped<TInterface, TImplementation>(this IServiceCollection services)
            where TInterface : class
            where TImplementation : class, TInterface
    {
        services.AddScoped<TImplementation>();
        services.AddScoped(sp =>
        {
            var proxyGenerator = sp.GetRequiredService<ProxyGenerator>();
            var actual = sp.GetRequiredService<TImplementation>();
            var interceptor = sp.GetRequiredService<AuditInterceptor>();

            return proxyGenerator.CreateInterfaceProxyWithTarget<TInterface>(actual, interceptor.ToInterceptor());
        });

        return services;
    }

    public static IServiceCollection AddRegisterServicesWithCaching(this IServiceCollection services, IConfiguration configuration)
    {
        services.AddScoped<AuditInterceptor>();
        services.AddSingleton<ProxyGenerator>();

        services.AddAuditedCachedScoped<ICommunicationsService, CommunicationsService, CommunicationsCacheService>();
        services.AddAuditedCachedScoped<IEvidenceService, EvidenceService, EvidenceCacheService>();
        services.AddAuditedCachedScoped<IUserService, UserService, UserCacheService>();
        services.AddAuditedCachedScoped<IExecutionService, ExecutionService, ExecutionCacheService>();
        services.AddAuditedCachedScoped<IGovernanceService, GovernanceService, GovernanceCacheService>();
        services.AddAuditedCachedScoped<IGrantsService, GrantsService, GrantsCacheService>();
        services.AddAuditedCachedScoped<IProjectService, ProjectService, ProjectCacheService>();

        services.AddScoped<IIdentityService, IdentityService>();
        services.Decorate<IIdentityService, IdentityCacheService>();

        services.AddScoped<IToolService, ToolService>();
        services.Decorate<IToolService, ToolCacheService>();

        services.AddStackExchangeRedisCache(options =>
        {
            options.Configuration = configuration.GetConnectionString("Redis");
            options.InstanceName = "PFM-API_";
        });

        services.AddHybridCache(options => options.DefaultEntryOptions = new HybridCacheEntryOptions
        {
            Expiration = TimeSpan.FromMinutes(2),
            LocalCacheExpiration = TimeSpan.FromMinutes(30)
        });

        return services;
    }

    public static IServiceCollection AddSharedServices(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;
    }
}