lmasi/webzine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

#123 refactor: refonte de DbCommentaireRepository et LocalCommentaireRepository en prenant comme model Joséphine:

Browse Source 
- Nettoyage du code
 - ajout des <inheritdoc/>
 - InMemoryDataStore pour le mode local
This commit is contained in:
b.nodon
2026-03-27 10:21:20 +01:00
parent b7f06c8e8b
commit a3db0059ab
2 changed files with 117 additions and 209 deletions
Download Patch File Download Diff File Expand all files Collapse all files

122
Webzine.Repository/DbCommentaireRepository.cs
View File

@@ -15,7 +15,7 @@ public class DbCommentaireRepository : ICommentaireRepository
private readonly WebzineDbContext context;
/// <summary>
/// Init de <see cref="DbCommentaireRepository"/> .
/// Initialisation de <see cref="DbCommentaireRepository"/>.
/// </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>
@@ -23,87 +23,99 @@ public class DbCommentaireRepository : ICommentaireRepository
{
this.logger = logger;
this.context = context;
this.logger.LogDebug(1, "NLog injecté dans DbCommentaireRepository");
this.logger.LogDebug("NLog injecté dans DbCommentaireRepository");
}
/// <summary>
/// Ajoute un commentaire à la base de données.
/// </summary>
/// <param name="commentaire">L'objet commentaire à ajouter.</param>
/// <inheritdoc/>
public void Add(Commentaire commentaire)
{
this.logger.LogInformation($"Ajout nouveau commentaire depuis auteur: {commentaire.Auteur}");
this.context.Commentaires.Add(commentaire);
this.context.SaveChanges();
this.logger.LogDebug($"Commentaire ajouté avec l'id: {commentaire.IdCommentaire}");
try
{
if (commentaire == null)
{
throw new ArgumentNullException(nameof(commentaire), "Le commentaire à ajouter ne peut pas être null.");
}
/// <summary>
/// Remonte le nombre de commentaires.
/// </summary>
/// <returns>Le nombre total de commentaires présents dans la base de données.</returns>
this.logger.LogInformation("Ajout d'un nouveau commentaire de l'auteur : {Auteur}", commentaire.Auteur);
this.context.Commentaires.Add(commentaire);
this.context.SaveChanges();
this.logger.LogDebug("Commentaire ajouté avec l'id : {Id}", commentaire.IdCommentaire);
}
catch (DbUpdateException dbex)
{
this.logger.LogError(dbex, "Erreur de base de données lors de l'ajout du commentaire de l'auteur : {Auteur}", commentaire?.Auteur);
throw;
}
catch (Exception ex)
{
this.logger.LogError(ex, "Une erreur est survenue lors de l'ajout d'un commentaire.");
throw new Exception("Une erreur est survenue lors de l'ajout du commentaire.", ex);
}
}
/// <inheritdoc/>
public void Delete(Commentaire commentaire)
{
try
{
if (commentaire == null)
{
throw new ArgumentNullException(nameof(commentaire), "Le commentaire à supprimer ne peut pas être null.");
}
this.context.Commentaires.Remove(commentaire);
this.context.SaveChanges();
this.logger.LogInformation("Le commentaire {IdCommentaire} a bien été supprimé", commentaire.IdCommentaire);
}
catch (DbUpdateException dbex)
{
this.logger.LogError(dbex, "Erreur de base de données lors de la suppression du commentaire : {Id}", commentaire.IdCommentaire);
throw;
}
catch (Exception ex)
{
this.logger.LogError(ex, "Une erreur est survenue lors de la suppression du commentaire {Id}.", commentaire?.IdCommentaire);
throw new Exception("Une erreur est survenue lors de la suppression du commentaire.", ex);
}
}
/// <inheritdoc/>
public int Count()
{
var count = this.context.Commentaires.Count();
this.logger.LogDebug($"Compte total des commentaires: {count}");
this.logger.LogDebug("Compte total des commentaires : {Count}", count);
return count;
}
/// <summary>
/// Supprime un commentaire de la base de données.
/// </summary>
/// <param name="commentaire">L'objet commentaire à supprimer.</param>
public void Delete(Commentaire commentaire)
{
this.logger.LogInformation($"suppression du commentaire avec l'id: {commentaire.IdCommentaire}");
this.context.Commentaires.Remove(commentaire);
this.context.SaveChanges();
this.logger.LogDebug($"Commentaire supprimé: {commentaire.IdCommentaire}");
}
/// <summary>
/// Trouve un commentaire dans la base de données en fonction de son identifiant.
/// </summary>
/// <param name="idCommentaire">L'identifiant du commentaire à trouver.</param>
/// <returns>Le commentaire correspondant à l'identifiant fourni, ou null si aucun n'est trouvé.</returns>
/// <inheritdoc/>
public Commentaire Find(int idCommentaire)
{
this.logger.LogDebug($"Commentaire cherché avec l'id: {idCommentaire}");
this.logger.LogDebug("Recherche du commentaire avec l'id : {Id}", idCommentaire);
// On inclut le titre car il est souvent affiché avec le commentaire (ex: vue Delete)
var commentaire = this.context.Commentaires
// On inclut le titre car il est souvent affiché avec le commentaire
return this.context.Commentaires
.Include(c => c.Titre)
.FirstOrDefault(c => c.IdCommentaire == idCommentaire);
return commentaire;
}
/// <summary>
/// Trouve tous les commentaires dans la base de données, triés du plus récent au plus ancien.
/// </summary>
/// <returns>Une collection de tous les commentaires présents.</returns>
/// <inheritdoc/>
public IEnumerable<Commentaire> FindAll()
{
this.logger.LogDebug("Trouver tout les commentaires");
this.logger.LogDebug("Récupération de tous les commentaires");
var commentaires = this.context.Commentaires
.Include(c => c.Titre)
.OrderByDescending(c => c.DateCreation)
.ToList();
this.logger.LogDebug($"Nombre de tout les commentaires trouvé: {commentaires.Count}");
this.logger.LogDebug("Nombre de commentaires trouvés : {Count}", commentaires.Count);
return commentaires;
}
/// <summary>
/// Recherche les commentaires dans la base de données avec pagination.
/// </summary>
/// <param name="offset">L'offset à partir duquel commencer la recherche.</param>
/// <param name="limit">Le nombre maximum de commentaires à retourner.</param>
/// <returns>Une collection de commentaires paginée.</returns>
/// <inheritdoc/>
public IEnumerable<Commentaire> FindCommentaires(int offset, int limit)
{
this.logger.LogDebug($"Récherche des commentaires (décalage : {offset}, limite : {limit})");
this.logger.LogDebug("Recherche paginée des commentaires (offset : {Offset}, limit : {Limit})", offset, limit);
var commentaires = this.context.Commentaires
.Include(c => c.Titre)
@@ -112,18 +124,14 @@ public class DbCommentaireRepository : ICommentaireRepository
.Take(limit)
.ToList();
this.logger.LogDebug($"{commentaires.Count} commentaires trouvés");
this.logger.LogDebug("{Count} commentaires trouvés pour cette page", commentaires.Count);
return commentaires;
}
/// <summary>
/// Trouve tous les commentaires associés à un titre spécifique.
/// </summary>
/// <param name="idTitre">L'identifiant du titre.</param>
/// <returns>Une collection de commentaires pour ce titre.</returns>
/// <inheritdoc/>
public IEnumerable<Commentaire> FindByIdTitre(int idTitre)
{
this.logger.LogInformation($"Recherche des commentaires pour l'ID de titre : {idTitre}");
this.logger.LogInformation("Recherche des commentaires pour le titre ID : {IdTitre}", idTitre);
var commentaires = this.context.Commentaires
.Where(c => c.Titre.IdTitre == idTitre)

170
Webzine.Repository/LocalCommentaireRepository.cs
View File

@@ -1,198 +1,98 @@
using Microsoft.Extensions.Logging;
using Webzine.Entity;
using Webzine.Repository.Contracts;
// <copyright file="LocalCommentaireRepository.cs" company="PlaceholderCompany">
// Copyright (c) PlaceholderCompany. All rights reserved.
// </copyright>
namespace Webzine.Repository;
/// <summary>
/// Classe qui implémente le repository pour les commentaires en utilisant une liste locale comme source de données.
/// </summary>
public class LocalCommentaireRepository : ICommentaireRepository
namespace Webzine.Repository
{
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Extensions.Logging;
using Webzine.Entity;
using Webzine.Repository.Contracts;
/// <summary>
/// Initialise une classe <see cref="LocalCommentaireRepository"/> qui implémente l'interface <see cref="ICommentaireRepository"/> pour gérer les opérations liées aux commentaires.
/// Utilise <see cref="ICommentaireRepository"/> en injection de dépendances.
/// </summary>
public class LocalCommentaireRepository : ICommentaireRepository
{
private readonly ILogger<LocalCommentaireRepository> logger;
private readonly List<Commentaire> commentaires;
private readonly InMemoryDataStore dataStore;
/// <summary>
/// Initialise une nouvelle instance du <see cref="LocalCommentaireRepository"/> .
/// Est liée à un magasin de données en mémoire et utilise un logger pour enregistrer les opérations.
/// </summary>
/// <param name="logger">Le service de journalisation injecté pour suivre les opérations du repository.</param>
/// <param name="commentaires">La liste de commentaires à utiliser comme source de données pour le repository.</param>
public LocalCommentaireRepository(ILogger<LocalCommentaireRepository> logger, List<Commentaire> commentaires)
/// <param name="dataStore">Le magasin de données en mémoire. 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 LocalCommentaireRepository(InMemoryDataStore dataStore, ILogger<LocalCommentaireRepository> logger)
{
this.logger = logger;
this.commentaires = commentaires;
this.logger.LogDebug(1, "NLog injecté dans LocalCommentaireRepository");
this.dataStore = dataStore;
}
/// <inheritdoc/>
public void Add(Commentaire commentaire)
{
try
{
this.logger.LogDebug("Ajout du commentaire rédigé par: {Auteur}", commentaire.Auteur);
// Simulation d'auto-incrémentation pour l'ID si nécessaire (selon votre logique)
if (commentaire.IdCommentaire == 0 && this.commentaires.Any())
{
commentaire.IdCommentaire = this.commentaires.Max(c => c.IdCommentaire) + 1;
}
else if (commentaire.IdCommentaire == 0)
{
commentaire.IdCommentaire = 1;
}
this.commentaires.Add(commentaire);
this.logger.LogDebug("Commentaire ajouté avec succès, ID: {IdCommentaire}", commentaire.IdCommentaire);
}
catch (Exception ex)
{
this.logger.LogError(ex, "Erreur lors de l'ajout du commentaire rédigé par: {Auteur}", commentaire.Auteur);
throw;
}
}
/// <inheritdoc/>
public int Count()
{
try
{
var count = this.commentaires.Count;
this.logger.LogDebug("Nombre total de commentaires: {Count}", count);
return count;
}
catch (Exception ex)
{
this.logger.LogError(ex, "Erreur lors du comptage des commentaires");
throw;
}
throw new NotSupportedException("Mode Local");
}
/// <inheritdoc/>
public void Delete(Commentaire commentaire)
{
try
{
this.logger.LogDebug("Suppression du commentaire ID: {IdCommentaire}", commentaire.IdCommentaire);
if (!this.commentaires.Contains(commentaire))
{
this.logger.LogWarning("Le commentaire avec l'identifiant {IdCommentaire} n'existe pas dans la liste.", commentaire.IdCommentaire);
throw new NotSupportedException("Mode Local");
}
this.commentaires.Remove(commentaire);
this.logger.LogDebug("Commentaire supprimé avec succès, ID: {IdCommentaire}", commentaire.IdCommentaire);
}
catch (Exception ex)
/// <inheritdoc/>
public int Count()
{
this.logger.LogError(ex, "Erreur lors de la suppression du commentaire ID: {IdCommentaire}", commentaire.IdCommentaire);
throw;
}
return this.dataStore.Commentaires.Count;
}
/// <inheritdoc/>
public Commentaire Find(int idCommentaire)
{
try
{
this.logger.LogDebug("Recherche du commentaire avec ID: {IdCommentaire}", idCommentaire);
// FirstOrDefault car le contrôleur s'attend potentiellement à un null si non trouvé
Commentaire commentaire = this.commentaires.FirstOrDefault(c => c.IdCommentaire == idCommentaire);
var commentaire = this.dataStore.Commentaires.FirstOrDefault(c => c.IdCommentaire == idCommentaire);
if (commentaire == null)
{
this.logger.LogWarning("Aucun commentaire trouvé avec l'ID: {IdCommentaire}", idCommentaire);
}
else
{
this.logger.LogDebug("Commentaire trouvé: ID {IdCommentaire} par {Auteur}", commentaire.IdCommentaire, commentaire.Auteur);
return new Commentaire();
}
return commentaire;
}
catch (Exception ex)
{
this.logger.LogError(ex, "Erreur lors de la recherche du commentaire avec ID: {IdCommentaire}", idCommentaire);
throw;
}
}
/// <inheritdoc/>
public IEnumerable<Commentaire> FindAll()
{
try
{
this.logger.LogDebug("Récupération de tous les commentaires");
// on affiche les commentaires du plus récent au plus ancien et la je fais un commentaire super long pour que joséphine le voie et crois que ca va etre plus complexe que ce que c'est vraiment mais non en fait t'as eu peur hein :)
var result = this.commentaires.OrderByDescending(c => c.DateCreation).ToList();
this.logger.LogDebug("{Count} commentaires 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 commentaires");
throw;
}
return this.dataStore.Commentaires
.OrderByDescending(c => c.DateCreation)
.ToList();
}
/// <inheritdoc/>
public IEnumerable<Commentaire> FindCommentaires(int offset, int limit)
{
try
{
this.logger.LogDebug("Recherche des commentaires avec offset: {Offset}, limit: {Limit}", offset, limit);
if (offset < 0 || limit <= 0)
{
this.logger.LogWarning("FindCommentaires appelé avec offset {Offset} ou limit {Limit} invalide.", offset, limit);
return Enumerable.Empty<Commentaire>();
}
var result = this.commentaires
return this.dataStore.Commentaires
.OrderByDescending(c => c.DateCreation)
.Skip(offset)
.Take(limit)
.ToList();
this.logger.LogDebug("{Count} commentaires trouvés", result.Count);
return result;
}
catch (Exception ex)
{
this.logger.LogError(ex, "Erreur lors de la recherche des commentaires avec offset: {Offset}, limit: {Limit}", offset, limit);
throw;
}
}
/// <inheritdoc/>
public IEnumerable<Commentaire> FindByIdTitre(int idTitre)
{
try
{
this.logger.LogDebug("Recherche des commentaires pour le titre ID: {IdTitre}", idTitre);
IEnumerable<Commentaire> result = this.commentaires
return this.dataStore.Commentaires
.Where(c => c.Titre != null && c.Titre.IdTitre == idTitre)
.OrderByDescending(c => c.DateCreation)
.ToList();
if (!result.Any())
{
this.logger.LogInformation("Aucun commentaire trouvé pour le titre ID '{IdTitre}'.", idTitre);
}
else
{
this.logger.LogDebug("{Count} commentaires trouvés pour le titre ID '{IdTitre}'", result.Count(), idTitre);
}
return result;
}
catch (Exception ex)
{
this.logger.LogError(ex, "Erreur lors de la recherche des commentaires pour le titre ID: {IdTitre}", idTitre);
throw;
}
}
}