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.EntitiesContext;
using Webzine.Entity;
using Webzine.Entity.Fixtures;
using Webzine.Repository;
using Webzine.Repository.Contracts;
using Webzine.WebApplication.Extensions;

// 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()

        // 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();

    // 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.
    bool useDatabase = builder.Configuration.GetValue<bool>("UseDatabase");
    bool isSQLite = builder.Configuration.GetValue<bool>("IsSQLite");
    if (useDatabase)
    {
        if (isSQLite)
        {
            builder.Services.AddDbContext<WebzineDbContext>(options =>
                options.UseSqlite(builder.Configuration.GetConnectionString("SqliteConnection")));
        }
        else
        {
            builder.Services.AddDbContext<WebzineDbContext>(options =>
                options.UseNpgsql(builder.Configuration.GetConnectionString("PostGreSQLConnection")));
        }

        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>();
    }

    // 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();

    if (useDatabase)
    {
        if (isSQLite)
        {
            using (var scope = app.Services.CreateScope())
            {
                var db = scope.ServiceProvider.GetRequiredService<WebzineDbContext>();
                db.Database.EnsureDeleted();
                db.Database.EnsureCreated();
                var repo = scope.ServiceProvider.GetRequiredService<DbEntityRepository>();
                repo.SeedBaseDeDonnees();
            }
        }
        else
        {
            using (var scope = app.Services.CreateScope())
            {
                // TODO : A modifier pour ne pas supprimer la base de donnée en prod
                var db = scope.ServiceProvider.GetRequiredService<WebzineDbContext>();
                db.Database.EnsureDeleted();
                db.Database.EnsureCreated();
                var repo = scope.ServiceProvider.GetRequiredService<DbEntityRepository>();
                repo.SeedBaseDeDonnees();
            }
        }
    }
    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();
}