delete

Sources/BowlingApi/Controllers/PartieController.cs

@@ -63,7 +63,15 @@ namespace BowlingApi.Controllers
             //return Ok(result);
         }
 
-        // GET: api/Partie/djon
+        /// <summary>
+        /// Get a partie by id
+        /// GET: api/parti/Djon
+        /// </summary>
+        /// <param name="id"></param>
+        /// <response code="200">Retourne la parti</response>
+        /// <response code="400">Si le id null</response>
+        /// <response code="404">Si la partie existe pas</response>
+        /// <response code="500">Si une erreur est survenue</response>
         [HttpGet("{id}")]
         public async Task<IActionResult> Get(int id)
         {
@@ -121,7 +129,74 @@ namespace BowlingApi.Controllers
                 throw;
             }
 
-        }
+        }/// <summary>
+         /// Get player with pagination
+         /// Get : api/Joueur?page=1&pageSize=10
+         /// </summary>
+         /// <returns>la liste des Joueurs </returns>
+         /// <response code="200">Retourne la liste des joueurs</response>
+         /// <response code="404">Si la liste est vide</response>
+         /// <response code="500">Si une erreur est survenue</response>
+
+        [HttpGet("{page}/{pageSize}")]
+        [ProducesResponseType(typeof(string), StatusCodes.Status500InternalServerError)]
+        [ProducesResponseType(typeof(string), StatusCodes.Status404NotFound)]
+        [ProducesResponseType(typeof(IEnumerable<PartieDTO>), StatusCodes.Status200OK)]
+        public async Task<IActionResult> Get(int page = 1, int pageSize = 10)
+        {
+            try
+            {
+                var result = await _partieService.GetAll();
+                if (result == null)
+                {
+                    return NotFound();
+                }
+                var data = result.Skip((page - 1) * pageSize).Take(pageSize);
+                Response.Headers.Add("X-Pagination", Newtonsoft.Json.JsonConvert.SerializeObject(new
+                {
+                    totalCount = result.Count(),
+                    pageSize = pageSize,
+                    currentPage = page,
+                    totalPages = (int)Math.Ceiling(result.Count() / (double)pageSize)
+                }));
+                return Ok(data);
+            }
+            catch (Exception e)
+            {
+                return StatusCode(StatusCodes.Status500InternalServerError, e.Message);
+                throw;
+            }
+        }/// <summary>
+         /// Supprimer une partie par son id
+         /// DELETE: api/parti/5
+         /// </summary>
+         /// <param name="id"></param>
+         /// <response code="200">Retourne la partie  supprimé</response>
+         /// <response code="404">Si la partie n'existe pas</response>
+         /// <response code="500">Si une erreur est survenue</response>
+        [HttpDelete("{id}")]
+        [ProducesResponseType(typeof(string), StatusCodes.Status500InternalServerError)]
+        [ProducesResponseType(typeof(string), StatusCodes.Status404NotFound)]
+        [ProducesResponseType(typeof(bool), StatusCodes.Status200OK)]
+       // [MapToApiVersion("2")]
+        //public async Task<ActionResult<bool>> Delete(long id)
+        //{
+        //    try
+        //    {
+        //        var parti = _partieService.Delete(id);
+        //        if (parti.Result == false)
+        //        {
+        //            return NotFound();
+        //        }
+        //        return Ok(parti);
+        //    }
+        //    catch (Exception e)
+        //    {
+        //        StatusCode(StatusCodes.Status500InternalServerError, e.Message);
+        //        throw;
+        //    }
+      //  }
+
 
         /// <summary>
         /// Modification partie

Sources/BowlingRepository/Interface/IEquipeRepository.cs

@@ -1,7 +1,9 @@
   using BowlingEF.Entities;
 
 namespace BowlingRepository.Interface;
-
+/// <summary>
+/// Interface définissant les méthodes nécessaires pour gérer les opérations CRUD pour les entités `EquipeEntity`.
+/// </summary>
 public interface IEquipeRepository
 {
     public void Add(EquipeEntity equipe);

Sources/BowlingService/EquipeDbDataManager.cs

@@ -8,26 +8,27 @@ using Microsoft.EntityFrameworkCore;
 namespace BowlingService
 {
     public class EquipeDbDataManager : IDataManager<Equipe>
-    {
+    {        // Un contexte de bowling qui fournit une interface pour accéder à la base de données
         private readonly BowlingContext _context;
-        
+        // Le constructeur prend en entrée un contexte de bowling
         public EquipeDbDataManager(BowlingContext context)
-        {
+        {            // Stocker le contexte de bowling pour une utilisation ultérieure
             _context = context;
         }
-        
+        // Les méthodes suivantes fournissent une implémentation pour les méthodes déclarées dans l'interface IDataManager
         #region Méthodes
         public async Task<bool> Add(Equipe _equipe)
-        {
+        {            // Indicateur de résultat pour déterminer si l'opération a réussi ou échoué
             bool result = false;
-             EquipeEntity entity = new EquipeEntity
+            // Mapping entre la classe Equipe et la classe EquipeEntity
+            EquipeEntity entity = new EquipeEntity
                 {
                     Id = _equipe.Id,
                     Nom = _equipe.Nom,
                     
                 };
-
-                for (int i = 0; i < _equipe.Joueurs.Count; i++)
+            // Boucle sur la liste des joueurs dans l'équipe
+            for (int i = 0; i < _equipe.Joueurs.Count; i++)
                 {
                     //Mapping entre la classe joueur et la classe joueurEntity
                     JoueurEntity joueurEntity = new JoueurEntity
@@ -50,9 +51,8 @@ namespace BowlingService
 
                         //Parcourt de la liste des frames d'une partie
                         for (int k = 0; k < _equipe.Joueurs[i].Parties[j].Frames.Count; k++)
-                        {
-                            //Mapping entre les frames d'une partie et les frameEntity d'une partieEntity
-                            FrameEntity frameEntity = new FrameEntity
+                    {                        // Mapping entre la classe Frame et la classe FrameEntity
+                        FrameEntity frameEntity = new FrameEntity
                             {
                                 Id = _equipe.Joueurs[i].Parties[j].Frames[k].Id,
                                 Lancer1 = _equipe.Joueurs[i].Parties[j].Frames[k].Lancer1.QuillesTombees,

Sources/BowlingStub/StubJoueur.cs

@@ -6,10 +6,15 @@ namespace BowlingStub
 {
     public class StubJoueur : IDataManager<Joueur>
 
-    {
-        private List<Joueur> listJoueurs = new List<Joueur>();
-
-
+    {
+        // Liste pour stocker les joueurs
+        private List<Joueur> listJoueurs = new List<Joueur>();
+
+        /// <summary>
+        /// Ajouter un joueur à la liste
+        /// </summary>
+        /// <param name="data">Joueur à ajouter</param>
+        /// <returns>Retourne `true` si le joueur a été ajouté avec succès, sinon `false`</returns>
         public async Task<bool> Add(Joueur data)
         {
             if (data != null)
@@ -19,7 +24,11 @@ namespace BowlingStub
             }
             return false;
         }
-
+        /// <summary>
+        /// Supprimer un joueur de la liste
+        /// </summary>
+        /// <param name="data">Joueur à supprimer</param>
+        /// <returns>Retourne `true` si le joueur a été supprimé avec succès, sinon `false`</returns>
         public async Task<bool> Delete(Joueur data)
         {
             if (data != null)
@@ -28,8 +37,12 @@ namespace BowlingStub
                 return  true;
             }
             return false;
-        }
-
+        }
+        /// <summary>
+        /// Créer une liste de joueurs
+        /// </summary>
+        /// <param name="n">Nombre de joueurs à créer</param>
+        /// <returns>Liste de joueurs</returns>
         public async Task<IEnumerable<Joueur>> GetAll()
         {
             return listJoueurs;
@@ -42,13 +55,21 @@ namespace BowlingStub
                 Add(new Joueur("Joueur " + i + 1));
             }
             return listJoueurs;
-        }
-        ///ged 
+        }
+        // <summary>
+        /// Obtenir un joueur en fonction de son identifiant
+        /// </summary>
+        /// <param name="id">Identifiant du joueur</param>
+        /// <returns>Joueur correspondant à l'identifiant</returns>
         public async Task<Joueur >GetDataWithId (int id)
         {
             throw new NotImplementedException();
         }
-
+        /// <summary>
+        /// Obtenir un joueur en fonction de son nom
+        /// </summary>
+        /// <param name="name">Nom du joueur</param>
+        /// <returns>Joueur correspondant au nom</returns>
         public async Task<Joueur> GetDataWithName(string name)
         {
             throw new NotImplementedException();

Sources/DTOs/EquipeDTO.cs

@@ -10,13 +10,16 @@ namespace DTOs
     /// Classe de gestion des equipes
     /// </summary>
     public class EquipeDTO
-    {
+    {//les proprietés
         #region Propriétés
         public long Id { get; set; }
         public string Nom { get; set; }
         public ICollection<JoueurDTO> Joueurs { get; set; }
         #endregion
         #region Constructeurs
+        //constructeur
+
+
         public EquipeDTO()
         {
             Joueurs = new List<JoueurDTO>();

Sources/DTOs/FrameDTO.cs

@@ -8,7 +8,7 @@ namespace BowlingEF.Entities
     /// Classe de gestion des frames
     /// </summary>
     public class FrameDTO
-    {
+    {//proprieté
         #region Properties
         
         public long Id { get; set; }

Sources/Mapper/JoueurProfile.cs

@@ -5,7 +5,11 @@ using DTOs;
 namespace Mapper;
 
 public class JoueurProfile:Profile
-{
+{/// <summary>
+ /// Ce constructeur définit la configuration de mapping entre le type `JoueurDTO` et le type `JoueurEntity`.
+ /// Il utilise la méthode `CreateMap` pour définir la façon dont les propriétés des objets sont mappées entre les deux types.
+ /// La méthode `ReverseMap` permet également de définir une configuration de mapping inverse, pour mapper les propriétés des objets `JoueurEntity` vers des objets `JoueurDTO`.
+ /// </summary>
     public JoueurProfile()
     {
         CreateMap<JoueurDTO, JoueurEntity>().ReverseMap();