webzine/Webzine.WebApplication/Program.cs

// L'erreur SA1200 (ordre des using directives) est desactivée pour Program.cs
#pragma warning disable SA1200

using Microsoft.EntityFrameworkCore;

using NLog;
using NLog.Web;

using Webzine.Business;
using Webzine.Business.Contracts;
using Webzine.EntitiesContext;
using Webzine.Entity;
using Webzine.Entity.Fixtures;
using Webzine.Repository;
using Webzine.Repository.Contracts;
using Webzine.WebApplication.Configuration;
using Webzine.WebApplication.Extensions;
using Webzine.WebApplication.Filters;
using Webzine.WebApplication.Interceptors;

// Initiation du logger NLog pour la classe courante afin de pouvoir l'utiliser pour logger des messages d'information, d'erreur, etc avant la construction de l'application.
var logger = LogManager.Setup().LoadConfigurationFromAppSettings().GetCurrentClassLogger();
logger.Debug("init main");

try
{
    var builder = WebApplication.CreateBuilder(args);

    // Ajoute les services necessaires pour permettre l'utilisation des
    // controllers avec des vues.
    builder.Services.AddControllersWithViews(options =>
        {
            options.Filters.Add<ValidationActionFilter>();
            options.Filters.Add<GlobalExceptionFilter>();
        })
        // Ajoute la compilation des vues lors de l'execution de l'application.
        // Cela nous evite de recompiler l'application a chaque modification de vue.
        // Necessite le package Nuget Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation.
        .AddRazorRuntimeCompilation();

    // NLog: Setup NLog for Dependency injection
    builder.Logging.ClearProviders();
    builder.Host.UseNLog();

    builder.Services.Configure<EfPerformanceOptions>(options =>
    {
        options.SeuilMs = builder.Configuration.GetValue<int>("EfPerformance:SeuilMs");
    });
    builder.Services.AddSingleton<EfSlowQueryInterceptor>();

    // En fonction de la configuration, utilise soit les repositories basés sur une base de données, soit les repositories basés sur des listes locales.
    var repositoryType = builder.Configuration.GetValue<RepositoryType>("Repository");
    var seederType = builder.Configuration.GetValue<SeederType>("Seeder");
    var shouldSeed = args.Contains("--seed");
    if (repositoryType == RepositoryType.Db)
    {
        if (builder.Environment.IsProduction())
        {
            builder.Services.AddDbContext<WebzineDbContext>((serviceProvider, options) =>
            {
                options
                    .UseNpgsql(builder.Configuration.GetConnectionString("PostGreSQLConnection"))
                    .AddInterceptors(serviceProvider.GetRequiredService<EfSlowQueryInterceptor>());
            });
        }
        else
        {
            builder.Services.AddDbContext<WebzineDbContext>((serviceProvider, options) =>
            {
                options
                    .UseSqlite(builder.Configuration.GetConnectionString("SqliteConnection"))
                    .AddInterceptors(serviceProvider.GetRequiredService<EfSlowQueryInterceptor>());
            });
        }

        builder.Services.AddScoped<DbEntityRepository>();
        builder.Services.AddScoped<ITitreRepository, DbTitreRepository>();
        builder.Services.AddScoped<IStyleRepository, DbStyleRepository>();
        builder.Services.AddScoped<IArtisteRepository, DbArtisteRepository>();
        builder.Services.AddScoped<ICommentaireRepository, DbCommentaireRepository>();
    }
    else
    {
        builder.Services.AddScoped<ITitreRepository, LocalTitreRepository>();
        builder.Services.AddScoped<IStyleRepository, LocalStyleRepository>();
        builder.Services.AddScoped<IArtisteRepository, LocalArtisteRepository>();
        builder.Services.AddScoped<ICommentaireRepository, LocalCommentaireRepository>();
        builder.Services.AddSingleton<InMemoryDataStore>();
    }

    builder.Services.AddScoped<IDashboardService, DashboardService>();
    builder.Services.AddScoped<ITitreAdminService, TitreAdminService>();

    builder.Services.AddScoped<ValidationActionFilter>();
    builder.Services.AddScoped<GlobalExceptionFilter>();

    // https://learn.microsoft.com/fr-fr/aspnet/core/performance/response-compression?view=aspnetcore-10.0#configuration
    // Ajoute le service de compression des réponses HTTP pour réduire la taille des données envoyées au client et améliorer les performances de l'application.
    builder.Services.AddResponseCompression();

    var app = builder.Build();

    app.UseMiddleware<Webzine.WebApplication.Middlewares.LogTempsExecutionMiddleware>();

    if (repositoryType == RepositoryType.Db)
    {
        using (var scope = app.Services.CreateScope())
        {
            var db = scope.ServiceProvider.GetRequiredService<WebzineDbContext>();
            db.Database.EnsureCreated();

            if (shouldSeed)
            {
                db.Database.EnsureDeleted();
                db.Database.EnsureCreated();
                var repo = scope.ServiceProvider.GetRequiredService<DbEntityRepository>();

                if (seederType == SeederType.Local)
                {
                    repo.SeedBaseDeDonnees();
                }
                else if (seederType == SeederType.Spotify)
                {
                    // Seed à l'aide de l'API Spotify.
                }
            }
        }
    }
    else
    {
        using (var scope = app.Services.CreateScope())
        {
            var store = scope.ServiceProvider.GetRequiredService<InMemoryDataStore>();

            var artistes = SeedDataLocal.GenererListeArtiste(100);
            var styles = SeedDataLocal.GenererListeStyle(15, 20);
            var albums = SeedDataLocal.GenererListeAlbums(50);
            var commentaires = new List<Commentaire>();
            var titres = SeedDataLocal.GenererListeTitre(500, artistes, styles, albums);

            foreach (var titre in titres)
            {
                var commentairesForTitre = SeedDataLocal.GenererListeCommentaire(titre, 0, 5);
                titre.Commentaires.AddRange(commentairesForTitre);
                commentaires.AddRange(commentairesForTitre);
            }

            store.Artistes.AddRange(artistes);
            store.Styles = styles;
            store.Titres = titres;
            store.Commentaires.AddRange(commentaires);
        }
    }

    app.UseResponseCompression();

    // Active la possibilité de servir des fichiers statiques presents dans
    // le dossier wwwroot.
    app.UseStaticFiles(new StaticFileOptions
    {
        OnPrepareResponse = ctx =>
        {
            // https://learn.microsoft.com/fr-fr/aspnet/core/fundamentals/static-files?view=aspnetcore-10.0#set-http-response-headers
            ctx.Context.Response.Headers.Append("Cache-Control", "public, max-age=31536000");
        },
    });

    // Active le middleware permettant le routage des requetes entrantes.
    app.UseRouting();

    // Appelle les routes définies dans le dossier Extensions.
    app.MapCustomRoutes();

    app.Run();
}
catch (Exception exception)
{
    // NLog: attrape les exceptions non gerees et les logger.
    logger.Error(exception, "Stopped program because of exception");
    throw;
}
finally
{
    // Assure que NLog flush tous les messages de log avant de fermer l'application.
    LogManager.Shutdown();
}