webzine/Webzine.Repository/DbArtisteRepository.cs

// <copyright file="DbArtisteRepository.cs" company="PlaceholderCompany">
// Copyright (c) PlaceholderCompany. All rights reserved.
// </copyright>

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.
    /// </summary>
    public class DbArtisteRepository : IArtisteRepository
    {
        private readonly 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.</param>
        /// <param name="logger">Le service de journalisation.</param>
        public DbArtisteRepository(WebzineDbContext context, ILogger<LocalArtisteRepository> logger)
        {
            this.logger = logger;
            this.context = context;
        }

        /// <inheritdoc/>
        public void Add(Artiste artiste)
        {
            try
            {
                this.context.Artistes.Add(artiste);
                this.context.SaveChanges();
            }
            catch (DbUpdateException dbex)
            {
                this.logger.LogError(dbex, "Erreur de base de données lors de l'ajout de l'artiste: {id}", artiste.IdArtiste);
                throw;
            }
            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
            {
                this.context.Artistes.Remove(artiste);
                this.context.SaveChanges();
                this.logger.LogDebug("L'artiste {IdArtiste} a bien été supprimé", artiste.IdArtiste);
            }
            catch (DbUpdateException dbex)
            {
                this.logger.LogError(dbex, "Erreur de base de données lors de la suppression de l'artiste: {Id}", artiste.IdArtiste);
                throw;
            }
            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)
        {
            try
            {
                Artiste artiste = this.context.Artistes
                    .Include(a => a.Titres)
                    .FirstOrDefault(a => a.IdArtiste == id);
                return artiste;
            }
            catch (Exception ex)
            {
                this.logger.LogError(ex, "Erreur lors de la recherche de l'artiste: {Id}", id);
                throw;
            }
        }

        /// <inheritdoc/>
        public Artiste FindByName(string nom)
        {
            try
            {
                var artiste = this.context.Artistes
                    .Include(a => a.Titres)
                    .FirstOrDefault(a => a.Nom == nom);

                return artiste;
            }
            catch (Exception ex)
            {
                this.logger.LogError(ex, "Erreur lors de la recherche de l'artiste avec le nom: {Nom}", nom);
                throw;
            }
        }

        /// <inheritdoc/>
        public IEnumerable<Artiste> FindAll()
        {
            try
            {
                // .AsNoTracking() rend la requête beaucoup plus rapide pour de la lecture
                var artistes = this.context.Artistes
                    .AsNoTracking()
                    .Include(t => t.Titres)
                    .ToList();
                this.logger.LogDebug("{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.");
                throw;
            }
        }

        /// <inheritdoc/>
        public void Update(Artiste artiste)
        {
            try
            {
                this.context.Artistes.Update(artiste);
                this.context.SaveChanges();
                this.logger.LogDebug("Artiste {Id} ({Nom}) mis à jour avec succès.", artiste.IdArtiste, artiste.Nom);
            }
            catch (DbUpdateException ex)
            {
                this.logger.LogError(ex, "Erreur de base de données lors de la mise à jour de l'artiste ID: {IdArtiste}", artiste.IdArtiste);
                throw;
            }
            catch (Exception ex)
            {
                this.logger.LogError(ex, "Erreur lors de la mise à jour de l'artiste {Id}.", artiste.IdArtiste);
                throw;
            }
        }

        /// <inheritdoc/>
        public IEnumerable<Artiste> Search(string mot)
        {
            try
            {
                // Récupération des artistes et des titres
                // qui leurs sont associés.
                // ajout de 'ToLower' pour ne pas être sensible à la casse.
                // NoTracking car action de lecture seulement.
                var artiste = this.context.Artistes
                    .Where(a => a.Nom.ToLower().Contains(mot.ToLower()))
                    .Include(t => t.Titres)
                    .AsNoTracking()
                    .ToList();
                return artiste;
            }
            catch (Exception ex)
            {
                throw new Exception("Erreur lors de la recherche d'artiste {error}", ex);
            }
        }

        /// <inheritdoc/>
        public int Count()
        {
            try
            {
                int count = Enumerable.Count(this.context.Artistes);
                this.logger.LogDebug("Nombre total d'artistes dans la base: {Count}", count);
                return count;
            }
            catch (Exception ex)
            {
                this.logger.LogError(ex, "Erreur lors du comptage des artistes.");
                throw;
            }
        }

        /// <inheritdoc/>
        public int Count(Func<Artiste, bool> predicate)
        {
            try
            {
                int count = this.context.Artistes.Count(predicate);
                this.logger.LogDebug("Nombre d'artistes (avec prédicat): {Count}", count);
                return count;
            }
            catch (Exception ex)
            {
                this.logger.LogError(ex, "Erreur lors du comptage des artistes avec prédicat.");
                throw;
            }
        }
    }
}