Merge remote-tracking branch 'origin/j2/refactor/controler-style-titre' into j2/ajout_repo

Webzine.Repository/DbArtisteRepository.cs

@@ -0,0 +1,142 @@
+namespace Webzine.Repository
+{
+    using Microsoft.EntityFrameworkCore;
+    using Microsoft.Extensions.Logging;
+    using Webzine.EntitiesContext;
+    using Webzine.Entity;
+    using Webzine.Repository.Contracts;
+
+    /// <summary>
+    /// Initialise une classe <see cref="DbArtisteRepository"/> qui implémente l'interface <see cref="IArtisteRepository"/> pour gérer les opérations de base de données liées aux artistes.
+    /// Utilise <see cref="IArtisteRepository"/> en injection de dépendances.
+    /// </summary>
+    public class DbArtisteRepository : IArtisteRepository
+    {
+        private WebzineDbContext _context;
+        private readonly ILogger<LocalArtisteRepository> _logger;
+
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DbArtisteRepository"/> class.
+        /// </summary>
+        /// <param name="context">Le contexte de base de données à utiliser pour accéder aux entités et effectuer des opérations de
+        /// persistance. Ne peut pas être null.</param>
+        public DbArtisteRepository(WebzineDbContext context,  ILogger<LocalArtisteRepository> logger)
+        {
+            this._logger = logger;
+            this._context = context;
+        }
+
+        /// <inheritdoc/>
+        public void Add(Artiste artiste)
+        {
+            try
+            {
+                if (artiste == null)
+                {
+                    throw new ArgumentNullException(nameof(artiste), "L'artiste à ajouter ne peut pas être null.");
+                }
+
+                this._context.Artistes.Add(artiste);
+                this._context.SaveChanges();
+            }
+            catch (Exception ex)
+            {
+                this._logger.LogError(ex, "Une erreur est survenue lors de l'ajout de l'artiste {Nom}.", artiste?.Nom);
+                throw new Exception("Une erreur est survenue lors de l'ajout de l'artiste.", ex);
+            }
+        }
+
+        /// <inheritdoc/>
+        public void Delete(Artiste artiste)
+        {
+            try 
+            {
+                if (artiste == null)
+                {
+                    throw new ArgumentNullException(nameof(artiste), "L'artiste à supprimer ne peut pas être null.");
+                }
+
+                this._context.Artistes.Remove(artiste);
+                this._context.SaveChanges();
+            }
+            catch (Exception ex)
+            {
+                this._logger.LogError(ex, "Une erreur est survenue lors de la suppression de l'artiste {Nom}.", artiste?.Nom);
+                throw new Exception("Une erreur est survenue lors de la suppression de l'artiste.", ex);
+            }
+        }
+
+        /// <inheritdoc/>
+        public Artiste Find(int id)
+        {
+            Artiste artiste = this._context.Artistes
+            .Include(a => a.Titres)
+            .FirstOrDefault(a => a.IdArtiste == id);
+            if (artiste == null)
+            {
+                this._logger.LogWarning("Aucun artiste trouvé avec l'identifiant {Id}", id);
+            }
+            return artiste;
+        }
+
+        /// <inheritdoc/>
+        public Artiste FindByName(string nom)
+        {
+            if (string.IsNullOrWhiteSpace(nom))
+            {
+                this._logger.LogWarning("Tentative de recherche avec un nom vide ou null.");
+                return null; 
+            }
+
+            var artiste = this._context.Artistes
+                .Include(a => a.Titres)
+                .FirstOrDefault(a => a.Nom == nom);
+
+            if (artiste == null)
+            {
+                this._logger.LogWarning("Recherche Nom : Aucun artiste trouvé pour '{Nom}'.", nom);
+            }
+
+            return artiste;
+        }
+
+        /// <inheritdoc/>
+        public IEnumerable<Artiste> FindAll()
+        {
+        try
+            {
+                // .AsNoTracking() rend la requête beaucoup plus rapide pour de la lecture
+                var artistes = this._context.Artistes.AsNoTracking().ToList();
+                this._logger.LogInformation("{Count} artistes récupérés de la base.", artistes.Count);
+                return artistes;
+            }
+            catch (Exception ex)
+            {
+                this._logger.LogError(ex, "Erreur lors de la récupération de tous les artistes.");
+                return Enumerable.Empty<Artiste>(); // Retourne une liste vide au lieu de faire crash l'UI
+            }
+    }
+
+        /// <inheritdoc/>
+        public void Update(Artiste artiste)
+        {
+            if (artiste == null)
+                {
+                    throw new ArgumentNullException(nameof(artiste));
+                }
+
+            try
+            {
+                this._context.Artistes.Update(artiste);
+                this._context.SaveChanges();
+                this._logger.LogInformation("Artiste {Id} ({Nom}) mis à jour avec succès.", artiste.IdArtiste, artiste.Nom);
+            }
+            catch (Exception ex)
+            {
+                this._logger.LogError(ex, "Erreur lors de la mise à jour de l'artiste {Id}.", artiste.IdArtiste);
+                throw;
+            }
+        }
+    }
+}

Webzine.Repository/DbEntityRepository.cs

@@ -1,69 +0,0 @@
-// <copyright file="DbEntityRepository.cs" company="PlaceholderCompany">
-// Copyright (c) PlaceholderCompany. All rights reserved.
-// </copyright>
-
-namespace Webzine.Repository
-{
-    using Webzine.EntitiesContext;
-    using Webzine.Entity;
-    using Webzine.Entity.Fixtures;
-    using Webzine.Repository.Contracts;
-    using Webzine.Repository.Fake;
-
-    public class DbEntityRepository
-    {
-        private readonly WebzineDbContext context;
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DbEntityRepository"/> class.
-        /// </summary>
-        public DbEntityRepository(WebzineDbContext context)
-        {
-            this.context = context;
-        }
-
-        /// <summary>
-        /// Seed de la base de données à partir de données générées.
-        /// </summary>
-        public void SeedBaseDeDonnees(
-            int nbArtistes = 100,
-            int nbTitres = 500,
-            int minStyles = 15,
-            int maxStyles = 20,
-            int minCommentairesParTitre = 0,
-            int maxCommentairesParTitre = 5)
-        {
-            if (this.context.Artistes.Any() ||
-                this.context.Titres.Any() ||
-                this.context.Styles.Any() ||
-                this.context.Commentaires.Any())
-            {
-                return;
-            }
-
-            List<Artiste> artistes = ArtisteFactory.CreerListeArtiste(nbArtistes);
-            List<Style> styles = StyleFactory.CreerListeStyle(minStyles, maxStyles);
-
-            this.context.Artistes.AddRange(artistes);
-            this.context.Styles.AddRange(styles);
-            this.context.SaveChanges();
-
-            List<Titre> titres = TitreFactory.CreerListeTitre(nbTitres, artistes, styles);
-            this.context.Titres.AddRange(titres);
-            this.context.SaveChanges();
-
-            List<Commentaire> commentaires = new List<Commentaire>();
-
-            foreach (Titre titre in titres)
-            {
-                commentaires.AddRange(
-                    CommentaireFactory.CreerListeCommentaire(
-                        titre,
-                        minCommentairesParTitre,
-                        maxCommentairesParTitre));
-            }
-
-            this.context.Commentaires.AddRange(commentaires);
-            this.context.SaveChanges();
-        }
-    }
-}

Webzine.Repository/DbStyleRepository.cs

@@ -0,0 +1,180 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Webzine.EntitiesContext;
+using Webzine.Entity;
+using Webzine.Repository.Contracts;
+
+namespace Webzine.Repository;
+
+/// <summary>
+/// Classe qui implémente le repository pour les styles en utilisant une base de données.
+/// </summary>
+public class DbStyleRepository : IStyleRepository
+{
+    private readonly ILogger<DbStyleRepository> logger;
+    private readonly WebzineDbContext context;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DbStyleRepository"/> class.
+    /// </summary>
+    /// <param name="logger">Le service de journalisation injecté pour suivre les opérations du repository.</param>
+    /// <param name="context">Le contexte de base de données injecté.</param>
+    public DbStyleRepository(ILogger<DbStyleRepository> logger, WebzineDbContext context)
+    {
+        this.logger = logger;
+        this.context = context;
+        this.logger.LogDebug(1, "NLog injecté dans DbStyleRepository");
+    }
+
+    /// <inheritdoc/>
+    public void Add(Style style)
+    {
+        try
+        {
+            this.logger.LogInformation("Ajout d'un nouveau style: {Libelle}", style.Libelle);
+            this.logger.LogDebug("Début de l'ajout du style en base de données");
+
+            this.context.Styles.Add(style);
+            this.context.SaveChanges();
+
+            this.logger.LogDebug("Style ajouté avec succès avec l'ID: {IdStyle}", style.IdStyle);
+        }
+        catch (DbUpdateException ex)
+        {
+            this.logger.LogError(ex, "Erreur de base de données lors de l'ajout du style: {Libelle}", style.Libelle);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de l'ajout du style: {Libelle}", style.Libelle);
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public void Delete(Style style)
+    {
+        try
+        {
+            this.logger.LogInformation("Suppression du style avec l'ID: {IdStyle}", style.IdStyle);
+            this.logger.LogDebug("Vérification de l'existence du style en base de données");
+
+            // Check if style exists
+            var existingStyle = this.context.Styles.Find(style.IdStyle);
+            if (existingStyle == null)
+            {
+                this.logger.LogWarning("Style avec l'ID {IdStyle} non trouvé pour la suppression", style.IdStyle);
+                throw new InvalidOperationException($"Style avec l'ID {style.IdStyle} non trouvé.");
+            }
+
+            this.logger.LogDebug("Style trouvé, suppression en cours");
+            this.context.Styles.Remove(existingStyle);
+            this.context.SaveChanges();
+
+            this.logger.LogDebug("Style supprimé avec succès: {IdStyle}", style.IdStyle);
+        }
+        catch (DbUpdateException ex)
+        {
+            this.logger.LogError(ex, "Erreur de base de données lors de la suppression du style ID: {IdStyle}", style.IdStyle);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la suppression du style ID: {IdStyle}", style.IdStyle);
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public Style Find(int id)
+    {
+        try
+        {
+            this.logger.LogDebug("Recherche du style avec l'ID: {Id}", id);
+
+            if (id <= 0)
+            {
+                this.logger.LogWarning("Tentative de recherche d'un style avec un Id invalide: {Id}", id);
+                return new Style();
+            }
+
+            this.logger.LogDebug("Préparation de la requête avec inclusion des titres");
+            var style = this.context.Styles
+                .Include(s => s.Titres)
+                .FirstOrDefault(s => s.IdStyle == id);
+
+            if (style == null)
+            {
+                this.logger.LogWarning("Style avec l'ID {Id} non trouvé", id);
+                style = new Style();
+            }
+            else
+            {
+                this.logger.LogDebug("Style trouvé: {Libelle}", style.Libelle);
+            }
+
+            return style;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la recherche du style avec l'ID: {Id}", id);
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<Style> FindAll()
+    {
+        try
+        {
+            this.logger.LogDebug("Récupération de tous les styles");
+            this.logger.LogDebug("Tri des styles par libellé");
+
+            var styles = this.context.Styles
+                .OrderBy(s => s.Libelle)
+                .ToList();
+
+            this.logger.LogDebug("{Count} styles récupérés", styles.Count);
+            return styles;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la récupération de tous les styles");
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public void Update(Style style)
+    {
+        try
+        {
+            this.logger.LogInformation("Mise à jour du style avec l'ID: {IdStyle}", style.IdStyle);
+            this.logger.LogDebug("Recherche du style en base de données");
+
+            var existingStyle = this.context.Styles.Find(style.IdStyle);
+            if (existingStyle == null)
+            {
+                this.logger.LogWarning("Style avec l'ID {IdStyle} non trouvé pour la mise à jour", style.IdStyle);
+                throw new InvalidOperationException($"Style avec l'ID {style.IdStyle} non trouvé.");
+            }
+
+            // Update properties
+            this.logger.LogDebug("Style trouvé, mise à jour des propriétés");
+            existingStyle.Libelle = style.Libelle;
+
+            this.context.SaveChanges();
+            this.logger.LogDebug("Style mis à jour avec succès: {IdStyle}", style.IdStyle);
+        }
+        catch (DbUpdateException ex)
+        {
+            this.logger.LogError(ex, "Erreur de base de données lors de la mise à jour du style ID: {IdStyle}", style.IdStyle);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la mise à jour du style ID: {IdStyle}", style.IdStyle);
+            throw;
+        }
+    }
+}

Webzine.Repository/DbTitreRepository.cs

@@ -0,0 +1,334 @@
+using Microsoft.EntityFrameworkCore;
+using Webzine.EntitiesContext;
+using Microsoft.Extensions.Logging;
+using Webzine.Entity;
+using Webzine.Repository.Contracts;
+
+namespace Webzine.Repository;
+
+/// <summary>
+/// Classe qui implémente le repository pour les titres en utilisant une base de données.
+/// </summary>
+public class DbTitreRepository : ITitreRepository
+{
+    private readonly ILogger<DbTitreRepository> logger;
+    private readonly WebzineDbContext context;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DbTitreRepository"/> class.
+    /// </summary>
+    /// <param name="logger">Le service de journalisation injecté pour suivre les opérations du repository.</param>
+    /// <param name="context">Le contexte de base de données injecté.</param>
+    public DbTitreRepository(ILogger<DbTitreRepository> logger, WebzineDbContext context)
+    {
+        this.logger = logger;
+        this.context = context;
+        this.logger.LogDebug(1, "NLog injecté dans DbTitreRepository");
+    }
+
+    /// <inheritdoc/>
+    public void Add(Titre titre)
+    {
+        try
+        {
+            this.logger.LogInformation("Ajout d'un nouveau titre: {Libelle}", titre.Libelle);
+            this.logger.LogDebug("Début de l'ajout du titre en base de données");
+
+            this.context.Titres.Add(titre);
+            this.context.SaveChanges();
+
+            this.logger.LogDebug("Titre ajouté avec succès avec l'ID: {IdTitre}", titre.IdTitre);
+        }
+        catch (DbUpdateException ex)
+        {
+            this.logger.LogError(ex, "Erreur de base de données lors de l'ajout du titre: {Libelle}", titre.Libelle);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de l'ajout du titre: {Libelle}", titre.Libelle);
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public int Count()
+    {
+        try
+        {
+            this.logger.LogDebug("Comptage des titres en base de données");
+            var count = this.context.Titres.Count();
+            this.logger.LogDebug("Nombre total de titres: {Count}", count);
+            return count;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors du comptage des titres");
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public void Delete(Titre titre)
+    {
+        try
+        {
+            this.logger.LogInformation("Suppression du titre avec l'ID: {IdTitre}", titre.IdTitre);
+            this.logger.LogDebug("Début de la suppression du titre en base de données");
+
+            this.context.Titres.Remove(titre);
+            this.context.SaveChanges();
+
+            this.logger.LogDebug("Titre supprimé avec succès: {IdTitre}", titre.IdTitre);
+        }
+        catch (DbUpdateException ex)
+        {
+            this.logger.LogError(ex, "Erreur de base de données lors de la suppression du titre ID: {IdTitre}", titre.IdTitre);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la suppression du titre ID: {IdTitre}", titre.IdTitre);
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<Titre> FindTitres(int offset, int limit)
+    {
+        try
+        {
+            this.logger.LogDebug("Recherche des titres avec offset: {Offset}, limit: {Limit}", offset, limit);
+            this.logger.LogDebug("Préparation de la requête avec les inclusions Artiste et Styles");
+
+            var titres = this.context.Titres
+                .Include(t => t.Artiste)
+                .Include(t => t.Styles)
+                .OrderBy(t => t.Libelle)
+                .Skip(offset)
+                .Take(limit)
+                .ToList();
+
+            this.logger.LogDebug("{Count} titres trouvés", titres.Count);
+            return titres;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la recherche des titres avec offset: {Offset}, limit: {Limit}", offset, limit);
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public void IncrementNbLectures(Titre titre)
+    {
+        try
+        {
+            this.logger.LogInformation("Incrémentation du nombre de lectures pour le titre ID: {IdTitre}", titre.IdTitre);
+            this.logger.LogDebug("Recherche du titre en base de données");
+
+            var existingTitre = this.context.Titres.Find(titre.IdTitre);
+            if (existingTitre != null)
+            {
+                this.logger.LogDebug("Titre trouvé, incrémentation du compteur de lectures");
+                existingTitre.NbLectures++;
+                this.context.SaveChanges();
+                this.logger.LogDebug("Nouveau nombre de lectures: {NbLectures}", existingTitre.NbLectures);
+            }
+            else
+            {
+                this.logger.LogWarning("Titre avec l'ID {IdTitre} non trouvé pour l'incrémentation des lectures", titre.IdTitre);
+            }
+        }
+        catch (DbUpdateException ex)
+        {
+            this.logger.LogError(ex, "Erreur de base de données lors de l'incrémentation des lectures pour le titre ID: {IdTitre}", titre.IdTitre);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de l'incrémentation des lectures pour le titre ID: {IdTitre}", titre.IdTitre);
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public void IncrementNbLikes(Titre titre)
+    {
+        try
+        {
+            this.logger.LogInformation("Incrémentation du nombre de likes pour le titre ID: {IdTitre}", titre.IdTitre);
+            this.logger.LogDebug("Recherche du titre en base de données");
+
+            var existingTitre = this.context.Titres.Find(titre.IdTitre);
+            if (existingTitre != null)
+            {
+                this.logger.LogDebug("Titre trouvé, incrémentation du compteur de likes");
+                existingTitre.NbLikes++;
+                this.context.SaveChanges();
+                this.logger.LogDebug("Nouveau nombre de likes: {NbLikes}", existingTitre.NbLikes);
+            }
+            else
+            {
+                this.logger.LogWarning("Titre avec l'ID {IdTitre} non trouvé pour l'incrémentation des likes", titre.IdTitre);
+            }
+        }
+        catch (DbUpdateException ex)
+        {
+            this.logger.LogError(ex, "Erreur de base de données lors de l'incrémentation des likes pour le titre ID: {IdTitre}", titre.IdTitre);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de l'incrémentation des likes pour le titre ID: {IdTitre}", titre.IdTitre);
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public void Update(Titre titre)
+    {
+        try
+        {
+            this.logger.LogInformation("Mise à jour du titre avec l'ID: {IdTitre}", titre.IdTitre);
+            this.logger.LogDebug("Début de la mise à jour du titre en base de données");
+
+            var existingTitre = this.context.Titres.Find(titre.IdTitre);
+            if (existingTitre != null)
+            {
+                this.logger.LogDebug("Titre trouvé, mise à jour des propriétés");
+                this.context.Entry(existingTitre).CurrentValues.SetValues(titre);
+
+                // Handle many-to-many relationships
+                this.logger.LogDebug("Mise à jour des relations many-to-many (Styles)");
+                this.context.Entry(existingTitre).Collection(t => t.Styles).Load();
+                existingTitre.Styles.Clear();
+                foreach (var style in titre.Styles)
+                {
+                    existingTitre.Styles.Add(style);
+                }
+
+                this.context.SaveChanges();
+                this.logger.LogDebug("Titre mis à jour avec succès: {IdTitre}", titre.IdTitre);
+            }
+            else
+            {
+                this.logger.LogWarning("Titre avec l'ID {IdTitre} non trouvé pour la mise à jour", titre.IdTitre);
+                throw new InvalidOperationException($"Titre avec l'ID {titre.IdTitre} non trouvé.");
+            }
+        }
+        catch (DbUpdateException ex)
+        {
+            this.logger.LogError(ex, "Erreur de base de données lors de la mise à jour du titre ID: {IdTitre}", titre.IdTitre);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la mise à jour du titre ID: {IdTitre}", titre.IdTitre);
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<Titre> Search(string mot)
+    {
+        try
+        {
+            this.logger.LogInformation("Recherche des titres avec le mot-clé: {Mot}", mot);
+            this.logger.LogDebug("Préparation de la requête de recherche avec les inclusions");
+
+            var titres = this.context.Titres
+                .Include(t => t.Artiste)
+                .Include(t => t.Styles)
+                .Where(t => t.Libelle.ToLower().Contains(mot.ToLower()))
+                .OrderBy(t => t.Libelle)
+                .ToList();
+
+            this.logger.LogDebug("{Count} titres trouvés correspondant à '{Mot}'", titres.Count, mot);
+            return titres;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la recherche des titres avec le mot-clé: {Mot}", mot);
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public Titre Find(int idTitre)
+    {
+        try
+        {
+            this.logger.LogDebug("Recherche du titre avec l'ID: {IdTitre}", idTitre);
+            this.logger.LogDebug("Préparation de la requête avec les inclusions Artiste, Styles et Commentaires");
+
+            var titre = this.context.Titres
+                .Include(t => t.Artiste)
+                .Include(t => t.Styles)
+                .Include(t => t.Commentaires)
+                .First(t => t.IdTitre == idTitre);
+
+            this.logger.LogDebug("Titre trouvé: {Libelle}", titre.Libelle);
+            return titre;
+        }
+        catch (InvalidOperationException ex)
+        {
+            this.logger.LogWarning(ex, "Aucun titre trouvé avec l'ID: {IdTitre}", idTitre);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la recherche du titre avec l'ID: {IdTitre}", idTitre);
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<Titre> FindAll()
+    {
+        try
+        {
+            this.logger.LogDebug("Récupération de tous les titres");
+            this.logger.LogDebug("Préparation de la requête avec les inclusions Artiste et Styles");
+
+            var titres = this.context.Titres
+                .Include(t => t.Artiste)
+                .Include(t => t.Styles)
+                .OrderBy(t => t.Libelle)
+                .ToList();
+
+            this.logger.LogDebug("{Count} titres récupérés", titres.Count);
+            return titres;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la récupération de tous les titres");
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<Titre> SearchByStyle(string libelle)
+    {
+        try
+        {
+            this.logger.LogInformation("Recherche des titres par style: {Libelle}", libelle);
+            this.logger.LogDebug("Préparation de la requête de recherche par style");
+
+            var titres = this.context.Titres
+                .Include(t => t.Artiste)
+                .Include(t => t.Styles)
+                .Where(t => t.Styles.Any(s => s.Libelle.ToLower() == libelle.ToLower()))
+                .OrderBy(t => t.Libelle)
+                .ToList();
+
+            this.logger.LogDebug("{Count} titres trouvés pour le style '{Libelle}'", titres.Count, libelle);
+            return titres;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la recherche des titres par style: {Libelle}", libelle);
+            throw;
+        }
+    }
+}

Webzine.Repository/LocalArtisteRepository.cs

@@ -0,0 +1,133 @@
+namespace Webzine.Repository
+{
+    using Microsoft.Extensions.Logging;
+    using Webzine.Entity;
+    using Webzine.Repository.Contracts;
+
+    /// <summary>
+    /// Initialise une classe <see cref="LocalArtisteRepository"/> qui implémente l'interface <see cref="IArtisteRepository"/> pour gérer les opérations de base de données liées aux artistes.
+    /// Utilise <see cref="IArtisteRepository"/> en injection de dépendances.
+    /// </summary>
+    public class LocalArtisteRepository : IArtisteRepository
+    {
+        private readonly ILogger<LocalArtisteRepository> _logger;
+        private readonly List<Artiste> _artistes;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LocalArtisteRepository"/> class.
+        /// Est liéee à une liste d'artistes en local et utilise un logger pour enregistrer les opérations effectuées sur les artistes.
+        /// </summary>
+        /// <param name="artistes">La liste des artistes à initialiser. Ne peut pas être null.</param>
+        /// <param name="logger">Le logger à utiliser pour enregistrer les messages de journalisation. Ne peut pas être null.</param>
+        public LocalArtisteRepository(List<Artiste> artistes, ILogger<LocalArtisteRepository> logger)
+        {
+            this._logger = logger;
+            this._artistes = artistes;
+        }
+
+        /// <inheritdoc/>
+        public void Add(Artiste artiste)
+        {
+            try
+            {
+                if (artiste == null)
+                {
+                    this._logger.LogError("L'artiste à ajouter ne peut pas être null.");
+                    throw new ArgumentNullException(nameof(artiste));
+                }
+
+                if (this._artistes.Any(a => a.IdArtiste == artiste.IdArtiste))
+                {
+                    this._logger.LogWarning("Un artiste avec l'ID {Id} existe déjà. L'ajout est ignoré.", artiste.IdArtiste);
+                    return;
+                }
+
+                this._artistes.Add(artiste);
+                this._logger.LogInformation("Artiste ajouté : {Nom}", artiste.Nom);
+            }
+            catch (Exception ex)
+            {
+                this._logger.LogError(ex, "Erreur lors de l'ajout de l'artiste : {Nom}", artiste?.Nom);
+                throw;
+            }
+        }
+
+        /// <inheritdoc/>
+        public void Delete(Artiste artiste)
+        {
+            try
+            {
+                this._artistes.Remove(artiste);
+                this._logger.LogInformation("Artiste supprimé : {Nom}", artiste.Nom);
+            }
+            catch (Exception ex)
+            {
+                this._logger.LogError(ex, "Erreur lors de la suppression de l'artiste : {Nom}", artiste.Nom);
+                throw;
+            }
+        }
+
+        /// <inheritdoc/>
+        public Artiste Find(int id)
+        {
+            Artiste artiste = this._artistes.FirstOrDefault(a => a.IdArtiste == id);
+            if (artiste == null)
+            {
+                this._logger.LogWarning("Aucun artiste trouvé avec l'identifiant {Id}", id);
+            }
+            return artiste;
+        }
+
+        /// <inheritdoc/>
+        public Artiste FindByName(string nom)
+        {
+            Artiste artiste = this._artistes.FirstOrDefault(a => a.Nom == nom);
+            if (artiste == null)
+            {
+                this._logger.LogWarning("Aucun artiste trouvé avec le nom {Nom}", nom);
+            }
+            return artiste;
+        }
+
+        /// <inheritdoc/>
+        /// La liste retournée est une copie de la liste interne, donc elle ne peut être nulle.
+        public IEnumerable<Artiste> FindAll()
+        {
+            return this._artistes;
+        }
+
+        /// <inheritdoc/>
+        public void Update(Artiste artiste)
+        {
+            if (artiste == null)
+            {
+                this._logger.LogError("L'artiste à mettre à jour ne peut pas être null.");
+                throw new ArgumentNullException(nameof(artiste));
+            }
+
+            try
+            {
+                var artisteToUpdate = this._artistes.FirstOrDefault(a => a.IdArtiste == artiste.IdArtiste);
+
+                if (artisteToUpdate != null)
+                {
+                    artisteToUpdate.Nom = artiste.Nom;
+                    artisteToUpdate.Biographie = artiste.Biographie;
+                    artisteToUpdate.Titres = artiste.Titres;
+
+                    this._logger.LogInformation("Artiste {Id} mis à jour avec succès.", artiste.IdArtiste);
+                }
+                else
+                {
+                    this._logger.LogWarning("Mise à jour impossible : l'artiste avec l'ID {Id} n'existe pas.", artiste.IdArtiste);
+                    throw new KeyNotFoundException($"L'artiste {artiste.IdArtiste} est introuvable.");
+                }
+            }
+            catch (Exception ex)
+            {
+                this._logger.LogError(ex, "Une erreur est survenue lors de la mise à jour de l'artiste {Id}.", artiste.IdArtiste);
+                throw;
+            }
+        }
+    }
+}

Webzine.Repository/LocalEntityRepository.cs

@@ -1,91 +0,0 @@
-using Microsoft.Extensions.Logging;
-using Webzine.Entity;
-using Webzine.Entity.Fixtures;
-using Webzine.Repository.Contracts;
-
-namespace Webzine.Repository;
-
-/// <summary>
-/// Classe qui permet d'initialiser un jeu de données
-/// pour tester l'application.
-/// </summary>
-public class LocalEntityRepository : ITitreRepository
-{
-    private readonly ILogger<LocalEntityRepository> _logger;
-    private readonly List<Titre> _titres;
-
-    /// <summary>
-    /// Initialise une nouvelle instance du <see cref="LocalEntityRepository"/> avec un service de journalisation injecte.
-    /// </summary>
-    /// <param name="logger">Service de journalisation injecte pour suivre les operations du repository.</param>
-    public LocalEntityRepository(ILogger<LocalEntityRepository> logger)
-    {
-        this._logger = logger;
-        this._logger.LogDebug(1, "NLog injected into LocalEntityRepository");
-
-        var factory = new DataFactory();
-        var artistes = factory.GenerateArtists(10);
-        var styles = factory.GenerateStyles(10);
-
-        _titres = factory.GenerateTitres(30, artistes, styles);
-        factory.GenerateCommentaires(50, _titres);
-    }
-
-    public IEnumerable<Titre> Search(string mot)
-    {
-        if (string.IsNullOrWhiteSpace(mot))
-        {
-            return Enumerable.Empty<Titre>();
-        }
-
-        return _titres
-            .Where(t => !string.IsNullOrWhiteSpace(t.Libelle)
-                && t.Libelle.Contains(mot, StringComparison.OrdinalIgnoreCase))
-            .OrderBy(t => t.Libelle)
-            .ToList();
-    }
-
-    public Titre? Find(int idTitre)
-    {
-        return _titres.FirstOrDefault(t => t.IdTitre == idTitre);
-    }
-
-    public IEnumerable<Titre> FindTitres(
-        int offset,
-        int limit)
-    {
-        return this._titres
-            .OrderByDescending(t => t.DateCreation)
-            .Skip((offset - 1) * limit)
-            .Take(limit)
-            .ToList();
-    }
-
-    /// <summary>
-    /// Retourner tous les titres.
-    /// </summary>
-    /// <returns>IEnumerable de titre.</returns>
-    public IEnumerable<Titre> FindAll()
-    {
-        return _titres;
-    }
-
-    /// <summary>
-    /// Rechercher les titres par style.
-    /// </summary>
-    /// <param name="libelle">Libelle du style.</param>
-    /// <returns>IEnumerable de titre.</returns>
-    public IEnumerable<Titre> SearchByStyle(string libelle)
-    {
-        if (string.IsNullOrWhiteSpace(libelle))
-        {
-            return Enumerable.Empty<Titre>();
-        }
-
-        return _titres
-            .Where(t => t.Styles.Any(s => !string.IsNullOrWhiteSpace(s.Libelle)
-                && s.Libelle.Contains(libelle, StringComparison.OrdinalIgnoreCase)))
-            .OrderBy(t => t.Libelle)
-            .ToList();
-    }
-}

Webzine.Repository/LocalStyleRepository.cs

@@ -0,0 +1,135 @@
+using Microsoft.Extensions.Logging;
+using Webzine.Entity;
+using Webzine.Repository.Contracts;
+
+namespace Webzine.Repository;
+
+/// <summary>
+/// Classe qui implémente le repository pour les styles en utilisant une liste locale comme source de données.
+/// </summary>
+public class LocalStyleRepository : IStyleRepository
+{
+    private readonly ILogger<LocalStyleRepository> logger;
+    private readonly List<Style> styles;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="LocalStyleRepository"/> class.
+    /// </summary>
+    /// <param name="logger">Le service de journalisation injecté pour suivre les opérations du repository.</param>
+    /// <param name="styles">La liste de styles à utiliser comme source de données pour le repository.</param>
+    public LocalStyleRepository(ILogger<LocalStyleRepository> logger, List<Style> styles)
+    {
+        this.logger = logger;
+        this.styles = styles;
+        this.logger.LogDebug(1, "NLog injecté dans LocalStyleRepository");
+    }
+
+    /// <inheritdoc/>
+    public void Add(Style style)
+    {
+        try
+        {
+            this.logger.LogDebug("Ajout du style: {Libelle}", style.Libelle);
+            this.styles.Add(style);
+            this.logger.LogDebug("Style ajouté avec succès, ID: {IdStyle}", style.IdStyle);
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de l'ajout du style: {Libelle}", style.Libelle);
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public void Delete(Style style)
+    {
+        try
+        {
+            this.logger.LogDebug("Suppression du style ID: {IdStyle}", style.IdStyle);
+
+            if (!this.styles.Contains(style))
+            {
+                this.logger.LogWarning("Le style avec l'identifiant {IdStyle} n'existe pas dans la liste.", style.IdStyle);
+            }
+
+            this.styles.Remove(style);
+            this.logger.LogDebug("Style supprimé avec succès, ID: {IdStyle}", style.IdStyle);
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la suppression du style ID: {IdStyle}", style.IdStyle);
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public Style Find(int id)
+    {
+        try
+        {
+            this.logger.LogDebug("Recherche du style avec ID: {Id}", id);
+
+            if (id <= 0)
+            {
+                this.logger.LogWarning("Tentative de recherche d'un style avec un Id invalide: {Id}", id);
+                return new Style();
+            }
+
+            Style style = this.styles.First(s => s.IdStyle == id);
+            this.logger.LogDebug("Style trouvé: {Libelle}", style.Libelle);
+            return style;
+        }
+        catch (InvalidOperationException ex)
+        {
+            this.logger.LogWarning(ex, "Aucun style trouvé avec l'ID: {Id}", id);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la recherche du style avec ID: {Id}", id);
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<Style> FindAll()
+    {
+        try
+        {
+            this.logger.LogDebug("Récupération de tous les styles");
+            var result = this.styles;
+            this.logger.LogDebug("{Count} styles récupérés", result.Count);
+            return result;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la récupération de tous les styles");
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public void Update(Style style)
+    {
+        try
+        {
+            this.logger.LogDebug("Mise à jour du style ID: {IdStyle}", style.IdStyle);
+
+            int index = this.styles.FindIndex(s => s.IdStyle == style.IdStyle);
+
+            if (index == -1)
+            {
+                this.logger.LogWarning("Aucun style trouvé avec l'identifiant {IdStyle}.", style.IdStyle);
+                throw new InvalidOperationException($"Aucun style trouvé avec l'identifiant {style.IdStyle}.");
+            }
+
+            this.styles[index] = style;
+            this.logger.LogDebug("Style mis à jour avec succès, ID: {IdStyle}", style.IdStyle);
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la mise à jour du style ID: {IdStyle}", style.IdStyle);
+            throw;
+        }
+    }
+}

Webzine.Repository/LocalTitreRepository.cs

@@ -0,0 +1,274 @@
+using Microsoft.Extensions.Logging;
+using Webzine.Entity;
+using Webzine.Repository.Contracts;
+
+namespace Webzine.Repository;
+
+/// <summary>
+/// Classe qui implémente le repository pour les titres en utilisant une liste locale comme source de données.
+/// </summary>
+public class LocalTitreRepository : ITitreRepository
+{
+    private readonly ILogger<LocalTitreRepository> logger;
+    private readonly List<Titre> titres;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="LocalTitreRepository"/> class.
+    /// </summary>
+    /// <param name="logger">Le service de journalisation injecté pour suivre les opérations du repository.</param>
+    /// <param name="titres">La liste de titres à utiliser comme source de données pour le repository.</param>
+    public LocalTitreRepository(ILogger<LocalTitreRepository> logger, List<Titre> titres)
+    {
+        this.logger = logger;
+        this.titres = titres;
+        this.logger.LogDebug(1, "NLog injecté dans LocalTitreRepository");
+    }
+
+    /// <inheritdoc/>
+    public void Add(Titre titre)
+    {
+        try
+        {
+            this.logger.LogDebug("Ajout du titre: {Libelle}", titre.Libelle);
+            this.titres.Add(titre);
+            this.logger.LogDebug("Titre ajouté avec succès, ID: {IdTitre}", titre.IdTitre);
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de l'ajout du titre: {Libelle}", titre.Libelle);
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public int Count()
+    {
+        try
+        {
+            var count = this.titres.Count;
+            this.logger.LogDebug("Nombre total de titres: {Count}", count);
+            return count;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors du comptage des titres");
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public void Delete(Titre titre)
+    {
+        try
+        {
+            this.logger.LogDebug("Suppression du titre ID: {IdTitre}", titre.IdTitre);
+
+            if (!this.titres.Contains(titre))
+            {
+                this.logger.LogWarning("Le titre avec l'identifiant {IdTitre} n'existe pas dans la liste.", titre.IdTitre);
+            }
+
+            this.titres.Remove(titre);
+            this.logger.LogDebug("Titre supprimé avec succès, ID: {IdTitre}", titre.IdTitre);
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la suppression du titre ID: {IdTitre}", titre.IdTitre);
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<Titre> FindTitres(int offset, int limit)
+    {
+        try
+        {
+            this.logger.LogDebug("Recherche des titres avec offset: {Offset}, limit: {Limit}", offset, limit);
+
+            if (offset < 0 || limit <= 0)
+            {
+                this.logger.LogWarning("FindTitres appelé avec offset {Offset} ou limit {Limit} invalide.", offset, limit);
+                return Enumerable.Empty<Titre>();
+            }
+
+            var result = this.titres.Skip(offset).Take(limit).ToList();
+            this.logger.LogDebug("{Count} titres trouvés", result.Count);
+            return result;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la recherche des titres avec offset: {Offset}, limit: {Limit}", offset, limit);
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public void IncrementNbLectures(Titre titre)
+    {
+        try
+        {
+            this.logger.LogDebug("Incrémentation du nombre de lectures pour le titre ID: {IdTitre}", titre.IdTitre);
+            titre.NbLectures++;
+            this.logger.LogDebug("Nouveau nombre de lectures: {NbLectures}", titre.NbLectures);
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de l'incrémentation des lectures pour le titre ID: {IdTitre}", titre.IdTitre);
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public void IncrementNbLikes(Titre titre)
+    {
+        try
+        {
+            this.logger.LogDebug("Incrémentation du nombre de likes pour le titre ID: {IdTitre}", titre.IdTitre);
+            titre.NbLikes++;
+            this.logger.LogDebug("Nouveau nombre de likes: {NbLikes}", titre.NbLikes);
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de l'incrémentation des likes pour le titre ID: {IdTitre}", titre.IdTitre);
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<Titre> Search(string mot)
+    {
+        try
+        {
+            this.logger.LogDebug("Recherche de titres avec le mot-clé: {Mot}", mot);
+
+            if (string.IsNullOrWhiteSpace(mot))
+            {
+                this.logger.LogWarning("Search appelé avec une chaîne vide ou contenant uniquement des espaces.");
+                return Enumerable.Empty<Titre>();
+            }
+
+            IEnumerable<Titre> list = this.titres
+                .Where(t => !string.IsNullOrWhiteSpace(t.Libelle)
+                            && t.Libelle.Contains(mot, StringComparison.OrdinalIgnoreCase))
+                .OrderBy(t => t.Libelle)
+                .ToList();
+
+            if (!list.Any())
+            {
+                this.logger.LogInformation("Aucun titre trouvé correspondant au terme de recherche '{Mot}'.", mot);
+            }
+            else
+            {
+                this.logger.LogDebug("{Count} titres trouvés pour le mot-clé '{Mot}'", list.Count(), mot);
+            }
+
+            return list;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la recherche des titres avec le mot-clé: {Mot}", mot);
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public Titre Find(int idTitre)
+    {
+        try
+        {
+            this.logger.LogDebug("Recherche du titre avec ID: {IdTitre}", idTitre);
+            Titre titre = this.titres.First(t => t.IdTitre == idTitre);
+            this.logger.LogDebug("Titre trouvé: {Libelle}", titre.Libelle);
+            return titre;
+        }
+        catch (InvalidOperationException ex)
+        {
+            this.logger.LogWarning(ex, "Aucun titre trouvé avec l'ID: {IdTitre}", idTitre);
+            throw;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la recherche du titre avec ID: {IdTitre}", idTitre);
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<Titre> FindAll()
+    {
+        try
+        {
+            this.logger.LogDebug("Récupération de tous les titres");
+            var result = this.titres;
+            this.logger.LogDebug("{Count} titres récupérés", result.Count);
+            return result;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la récupération de tous les titres");
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<Titre> SearchByStyle(string libelle)
+    {
+        try
+        {
+            this.logger.LogDebug("Recherche des titres par style: {Libelle}", libelle);
+
+            if (string.IsNullOrWhiteSpace(libelle))
+            {
+                this.logger.LogWarning("SearchByStyle appelé avec une chaîne vide ou contenant uniquement des espaces.");
+                return Enumerable.Empty<Titre>();
+            }
+
+            IEnumerable<Titre> list = this.titres
+                .Where(t => t.Styles.Any(s => !string.IsNullOrWhiteSpace(s.Libelle)
+                                                && s.Libelle.Contains(libelle, StringComparison.OrdinalIgnoreCase)))
+                .OrderBy(t => t.Libelle)
+                .ToList();
+
+            if (!list.Any())
+            {
+                this.logger.LogInformation("Aucun titre trouvé correspondant au style '{Libelle}'.", libelle);
+            }
+            else
+            {
+                this.logger.LogDebug("{Count} titres trouvés pour le style '{Libelle}'", list.Count(), libelle);
+            }
+
+            return list;
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la recherche des titres par style: {Libelle}", libelle);
+            throw;
+        }
+    }
+
+    /// <inheritdoc/>
+    public void Update(Titre titre)
+    {
+        try
+        {
+            this.logger.LogDebug("Mise à jour du titre ID: {IdTitre}", titre.IdTitre);
+
+            int index = this.titres.FindIndex(t => t.IdTitre == titre.IdTitre);
+
+            if (index == -1)
+            {
+                this.logger.LogWarning("Aucun titre trouvé avec l'identifiant {IdTitre}.", titre.IdTitre);
+                throw new InvalidOperationException($"Aucun titre trouvé avec l'identifiant {titre.IdTitre}.");
+            }
+
+            this.titres[index] = titre;
+            this.logger.LogDebug("Titre mis à jour avec succès, ID: {IdTitre}", titre.IdTitre);
+        }
+        catch (Exception ex)
+        {
+            this.logger.LogError(ex, "Erreur lors de la mise à jour du titre ID: {IdTitre}", titre.IdTitre);
+            throw;
+        }
+    }
+}