webzine/Webzine.Repository/DbTitreRepository.cs

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 injected into DbTitreRepository");
    }

    /// <summary>
    /// Ajoute un titre à la base de données.
    /// </summary>
    /// <param name="titre">L'objet titre à ajouter.</param>
    public void Add(Titre titre)
    {
        this.logger.LogInformation($"Adding new titre: {titre.Libelle}");
        this.context.Titres.Add(titre);
        this.context.SaveChanges();
        this.logger.LogDebug($"Titre added with Id: {titre.IdTitre}");
    }

    /// <summary>
    /// Remonte le nombre de titres.
    /// </summary>
    /// <returns>Le nombre total de titres présents dans la base de données.</returns>
    public int Count()
    {
        var count = this.context.Titres.Count();
        this.logger.LogDebug($"Total titres count: {count}");
        return count;
    }

    /// <summary>
    /// Supprime un titre de la base de données.
    /// </summary>
    /// <param name="titre">L'objet titre à supprimer.</param>
    public void Delete(Titre titre)
    {
        this.logger.LogInformation($"Deleting titre with Id: {titre.IdTitre}");
        this.context.Titres.Remove(titre);
        this.context.SaveChanges();
        this.logger.LogDebug($"Titre deleted: {titre.IdTitre}");
    }

    /// <summary>
    /// Recherche les titres dans la base de données en fonction de l'offset et de la limite spécifiés, permettant ainsi une pagination des résultats.
    /// </summary>
    /// <param name="offset">L'offset à partir duquel commencer la recherche des titres.</param>
    /// <param name="limit">Le nombre maximum de titres à retourner dans les résultats de la recherche.</param>
    /// <returns>Une collection de titres correspondant au critère de recherche, triée par libellé.</returns>
    public IEnumerable<Titre> FindTitres(int offset, int limit)
    {
        this.logger.LogDebug($"Finding titres with offset: {offset}, limit: {limit}");

        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($"Found {titres.Count} titres");
        return titres;
    }

    /// <summary>
    /// Incrémente le nombre de lectures d'un titre dans la base de données.
    /// </summary>
    /// <param name="titre">L'objet titre pour lequel le nombre de lectures doit être incrémenté.</param>
    public void IncrementNbLectures(Titre titre)
    {
        this.logger.LogInformation($"Incrementing lecture count for titre Id: {titre.IdTitre}");

        var existingTitre = this.context.Titres.Find(titre.IdTitre);
        if (existingTitre != null)
        {
            existingTitre.NbLectures++;
            this.context.SaveChanges();
            this.logger.LogDebug($"New lecture count: {existingTitre.NbLectures}");
        }
        else
        {
            this.logger.LogWarning($"Titre with Id {titre.IdTitre} not found for incrementing lectures");
        }
    }

    /// <summary>
    /// Incrémente le nombre de likes d'un titre dans la base de données.
    /// </summary>
    /// <param name="titre">L'objet titre pour lequel le nombre de likes doit être incrémenté.</param>
    public void IncrementNbLikes(Titre titre)
    {
        this.logger.LogInformation($"Incrementing like count for titre Id: {titre.IdTitre}");

        var existingTitre = this.context.Titres.Find(titre.IdTitre);
        if (existingTitre != null)
        {
            existingTitre.NbLikes++;
            this.context.SaveChanges();
            this.logger.LogDebug($"New like count: {existingTitre.NbLikes}");
        }
        else
        {
            this.logger.LogWarning($"Titre with Id {titre.IdTitre} not found for incrementing likes");
        }
    }

    /// <summary>
    /// Met à jour les informations d'un titre dans la base de données en fonction de son identifiant.
    /// </summary>
    /// <param name="titre">L'objet titre à mettre à jour.</param>
    public void Update(Titre titre)
    {
        this.logger.LogInformation($"Updating titre with Id: {titre.IdTitre}");

        var existingTitre = this.context.Titres.Find(titre.IdTitre);
        if (existingTitre != null)
        {
            this.context.Entry(existingTitre).CurrentValues.SetValues(titre);

            // Handle many-to-many relationships
            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 updated: {titre.IdTitre}");
        }
        else
        {
            this.logger.LogWarning($"Titre with Id {titre.IdTitre} not found for update");
        }
    }

    /// <summary>
    /// Recherche les titres dont le libellé contient le mot spécifié, en ignorant la casse.
    /// </summary>
    /// <param name="mot">Le mot à rechercher dans les libellés des titres.</param>
    /// <returns>Une collection de titres correspondant au critère de recherche, triée par libellé.</returns>
    public IEnumerable<Titre> Search(string mot)
    {
        this.logger.LogInformation($"Searching titres with keyword: {mot}");

        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($"Found {titres.Count} titres matching '{mot}'");
        return titres;
    }

    /// <summary>
    /// Trouve un titre dans la base de données en fonction de son identifiant.
    /// </summary>
    /// <param name="idTitre">L'identifiant du titre à trouver.</param>
    /// <returns>Le titre correspondant à l'identifiant fourni, ou null si aucun titre n'est trouvé.</returns>
    public Titre? Find(int idTitre)
    {
        this.logger.LogDebug($"Finding titre with Id: {idTitre}");

        var titre = this.context.Titres
            .Include(t => t.Artiste)
            .Include(t => t.Styles)
            .Include(t => t.Commentaires)
            .FirstOrDefault(t => t.IdTitre == idTitre);

        if (titre == null)
        {
            this.logger.LogWarning($"Titre with Id {idTitre} not found");
        }
        else
        {
            this.logger.LogDebug($"Found titre: {titre.Libelle}");
        }

        return titre;
    }

    /// <summary>
    /// Trouve tous les titres dans la base de données.
    /// </summary>
    /// <returns>Une collection de tous les titres présents dans la base de données.</returns>
    public IEnumerable<Titre> FindAll()
    {
        this.logger.LogDebug("Finding all titres");

        var titres = this.context.Titres
            .Include(t => t.Artiste)
            .Include(t => t.Styles)
            .OrderBy(t => t.Libelle)
            .ToList();

        this.logger.LogDebug($"Found {titres.Count} total titres");
        return titres;
    }

    /// <summary>
    /// Recherche les titres associés à un style dont le libellé correspond à celui spécifié, en ignorant la casse.
    /// </summary>
    /// <param name="libelle">Le libellé du style à rechercher.</param>
    /// <returns>Une collection de titres correspondant au critère de recherche, triée par libellé.</returns>
    public IEnumerable<Titre> SearchByStyle(string libelle)
    {
        this.logger.LogInformation($"Searching titres by style: {libelle}");

        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($"Found {titres.Count} titres for style '{libelle}'");
        return titres;
    }
}