19-1 Model/Repository/Service

On sait que pour ajouter le support pour des questions, il nous faudra:

• Un modèle Question
• Un repository QuestionRepository pour le lien avec la BD
• Un service QuestionService pour la couche applicative

On découvrira au fur et à mesure les différentes fonctions requises par le service et le repository, mais on peut tout de même créer les coquilles. Pour le modèle, on sait les propriétés qu'il devra contenir.

Finalement, ces coquilles nous permettront à tout de moins de configurer l'injection de dépendance.

Créer le Modèle Question

Quelles propriétés le modèle question aura-t-il besoin?

• Id: le id de la question
• EvenementId: le id de l'événement associé
• UtilisateurId: l'auteur de la question
• Contenu: le contenu de la question
• CreatedAt: la date de création de la question
• UpdatedAt: la date de modification de la question

Super, procédons à la création de ce modèle!

1. Dans le projet Domain, sous le dossier Models, créez une classe Question.
2. Ajoutez les propriétés.
   Snowfall.Domain/Models/Question.cs

   namespace Snowfall.Domain.Models;
   
   public class Question
   {
       public int Id { get; set; }
       public int EvenementId { get; set; }
       public required string UtilisateurId { get; set; }
       public ApplicationUser? Utilisateur { get; set; }
       public required string Contenu { get; set; }
       public DateTime UpdatedAt { get; set; }
       public DateTime CreatedAt { get; set; }
   }

info

On ajoute une référence à un objet de type ApplicationUser puisque seulement UtilisateurId ne serait pas suffisant pour afficher le nom de l'utilisateur associé au commentaire, par exemple.

Il s'agit d'une propriété optionnelle puisqu'elle ne sera utilisée qu'en lecture, lors de l'obtention des commentaires.

Créer le Repository QuestionRepository

Le repository nous permettra de communiquer avec la base de données via Dapper.

1. Dans le projet Data, sous le dossier Repositories, créez une classe QuestionRepository.
   Snowfall.Data/Repositories/QuestionRepository.cs

   namespace Snowfall.Data.Repositories;
   
   public class QuestionRepository
   {
       
   }
2. Ajoutez une fonction Create qui pour l'instant ne fera rien, nous préciserons le détail de l'implémentation plus tard.
   Snowfall.Data/Repositories/QuestionRepository.cs

   using Snowfall.Domain.Models;
   
   namespace Snowfall.Data.Repositories;
   
   public class QuestionRepository
   {
       public async Task<Question> Create(Question question)
       {
           throw new NotImplementedException();
       }
   }
3. Implémenter l'interface. À l'aide de clic droit sur le nom de la classe -> Refactor -> Extract Interface.
4. Choisir In its own file et sélectionner tous les membres (Create).
5. Appuyer sur Next
6. Ce qui devrait vous donner une interface comme celle-ci
   Snowfall.Data/Repositories/IQuestionRepository.cs

   using Snowfall.Domain.Models;
   
   namespace Snowfall.Data.Repositories;
   
   public interface IQuestionRepository
   {
       Task<Question> Create(Question question);
   }

Créer le Service QuestionService

Le service ne fera qu'imiter la structure du repository.

1. Dans le projet Application, sous le dossier Services, créez une classe QuestionService.
   Snowfall.Application/Services/QuestionService.cs

   namespace Snowfall.Application.Services;
   
   public class QuestionService
   {
       
   }
2. Ensuite, ajoutez le repository nécessaire au service via l'injection de dépendance dans son constructeur.
   Snowfall.Application/Services/QuestionService.cs

   public class QuestionService
   {
       private readonly IQuestionRepository _questionRepository;
   
       public QuestionService(IQuestionRepository questionRepository)
       {
           _questionRepository = questionRepository;
       }
   }
3. Ajoutez une fonction Create qui ne fera qu'appeler la fonction associée du repo.
   Snowfall.Application/Services/QuestionService.cs

   // ...
   
   public async Task<Question> Create(Question question)
   {
       return await _questionRepository.Create(question);
   }
4. Implémenter l'interface. À l'aide de clic droit sur le nom de la classe -> Refactor -> Extract Interface.
5. Choisir In its own file et sélectionner tous les membres (Create).
6. Ce qui devrait vous donner une interface comme celle-ci
   Snowfall.Application/Services/IQuestionService.cs

   using Snowfall.Domain.Models;
   
   namespace Snowfall.Application.Services;
   
   public interface IQuestionService
   {
       Task<Question> Create(Question question);
   }

Configurer l'injection de dépendances

Finalement, ajoutons le nouveau services et repository à la liste de classes disponibles pour injection de dépendances dans le fichier Program.cs.

Snowfall.Web.Mvc/Program.cs

builder.Services.AddScoped<IEvenementRepository, EvenementRepository>();
builder.Services.AddScoped<IVilleRepository, VilleRepository>();
builder.Services.AddScoped<IQuestionRepository, QuestionRepository>();
builder.Services.AddScoped<IEvenementService, EvenementService>();
builder.Services.AddScoped<IVilleService, VilleService>();
builder.Services.AddScoped<IQuestionService, QuestionService>();
builder.Services.AddScoped<IRoleStore<ApplicationRole>, RoleRepository>();
builder.Services.AddScoped<IUserStore<ApplicationUser>, UserRepository>();