ldap-cesi/ldap-cesi/Configurations/Conf.cs

using System.Reflection;
using System.Security.Cryptography;
using System.Text;
using FluentValidation;
using FluentValidation.AspNetCore;
using ldap_cesi.Context;
using ldap_cesi.Repository;
using ldap_cesi.Repository.Services;
using ldap_cesi.Services;
using ldap_cesi.Services.Interfaces;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.EntityFrameworkCore;
using Microsoft.IdentityModel.Tokens;
using Microsoft.OpenApi.Models;
using Serilog;

namespace ldap_cesi.Configurations;

public static class Conf
{
    public static void BuildConf(this WebApplicationBuilder builder)
    {
        builder.AddRepositories();
        builder.AddServices();
        builder.Services.AddControllers();
        builder.AddEFCoreConfiguration();
        builder.CorseConfiguration();
        builder.AddSwagger();
        builder.AddSerilog();
        builder.AddJwt();
        builder.Services.AddAutoMapper(typeof(Program));
        
    }
    
    public static void AddRepositories(this WebApplicationBuilder builder)
    {
        builder.Services.AddScoped<IRepositoryService, ServiceRepository>();
        builder.Services.AddScoped<IRepositorySite, SiteRepository>();
        builder.Services.AddScoped<IRepositorySalarie, SalarieRepository>();
        builder.Services.AddScoped<IRepositoryRole, RoleRepository>();
        builder.Services.AddScoped<IRepositoryUtilisateur, UtilisateurRepository>();
    }

    public static void AddServices(this WebApplicationBuilder builder)
    {
        builder.Services.AddScoped<IServiceService, ServiceService >();
        builder.Services.AddScoped<IRoleService, RoleService>();
        builder.Services.AddScoped<ISiteService, SiteService>();
        builder.Services.AddScoped<ISalarieService, SalarieService>();
        builder.Services.AddScoped<IUtilisateurService, UtilisateurService>();
        builder.Services.AddScoped<IJwtService, JwtService>();
        builder.Services.AddSingleton<IRsaKeyService, RsaKeyService>();
        builder.Services.AddValidatorsFromAssemblyContaining<Program>();
        builder.Services.AddFluentValidationAutoValidation();
    }    
    public static void AddEFCoreConfiguration(this WebApplicationBuilder builder)
    {
        string connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
        builder.Services.AddDbContext<PgContext>(options => options.UseNpgsql(connectionString));
    }   
    public static void CorseConfiguration(this WebApplicationBuilder builder)
    {
        builder.Services.AddCors(options =>
        {
            options.AddPolicy("AllowSpecific",
                builder => builder
                    .WithOrigins("http://localhost:3000")
                    .AllowAnyMethod()
                    .AllowAnyHeader());
        }); 
    }

    public static void AddSerilog(this WebApplicationBuilder builder)
    {
        var loggerConfiguration = new LoggerConfiguration()
            .WriteTo.Console()
            .WriteTo.File("logs/log.txt", rollingInterval: RollingInterval.Hour);
        var logger = loggerConfiguration.CreateLogger();
        builder.Logging.AddSerilog(logger);
        builder.Services.AddLogging();
    }

    public static void AddJwt(this WebApplicationBuilder builder)
    {
        var rsaKeyService = builder.Services.BuildServiceProvider().GetRequiredService<IRsaKeyService>();
        var rsaKey = rsaKeyService.GetRsaKey();

        builder.Services.AddAuthentication(options =>
            {
                options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
                options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
            })
            .AddJwtBearer(options =>
            {
                options.TokenValidationParameters = new TokenValidationParameters
                {
                    ValidateIssuer = true,
                    ValidateAudience = true,
                    ValidateLifetime = true,
                    ValidateIssuerSigningKey = true,
                    ValidIssuer = builder.Configuration["Jwt:Issuer"],
                    ValidAudience = builder.Configuration["Jwt:Audience"],
                    IssuerSigningKey = new RsaSecurityKey(rsaKey)
                };
            });
    }
    
    public static void AddSwagger(this WebApplicationBuilder builder)
    {
        // Add services to the container.
        // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
        builder.Services.AddEndpointsApiExplorer();
        builder.Services.AddAuthorization();
        builder.Configuration.AddEnvironmentVariables();
        builder.Services.AddSwaggerGen(c =>
        {
            c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
            {
                Name = "Authorization",
                In = ParameterLocation.Header,
                Type = SecuritySchemeType.ApiKey,
                Scheme = "Bearer",
                Description = "JWT Token. Use \"Bearer {token}\""
            });
            c.AddSecurityRequirement(new OpenApiSecurityRequirement
            {
                {
                    new OpenApiSecurityScheme
                    {
                        Reference = new OpenApiReference
                        {
                            Id = "Bearer",
                            Type = ReferenceType.SecurityScheme
                        }
                    },
                    new List<string>()
                }
            });
            c.SwaggerDoc("v1", new OpenApiInfo
            {
                Title = "LDAP - Backend",
                Version = "v1"
            });
            var xmlFilename = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
            c.IncludeXmlComments(Path.Combine(AppContext.BaseDirectory, xmlFilename));
        });
    }
}