🔨 Amélioration des controleur + mise en place de logger

code/server/ApiLeapHit/Controllers/ChatController.cs

@@ -1,6 +1,8 @@
-using DataBase.DataManager;
+using ApiLeapHit.Mapper;
+using DataBase.DataManager;
 using DataBase.Entity;
 using DTO;
+using DTO.Factory;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 
@@ -12,67 +14,195 @@ namespace ApiLeapHit.Controllers
     {
 
         private readonly DbDataManager _dataManager;
+        private readonly ILogger<ChatController> _logger;
 
-
+        public ChatController(DbDataManager dataManager, ILogger<ChatController> logger)
-        public ChatController(DbDataManager dataManager)
         {
             _dataManager = dataManager;
+            _logger = logger;
         }
 
         [HttpPost]
         public async Task<ActionResult> AddChat([FromBody] DTOChat dtoChat)
         {
-            var player1 = await _dataManager.GetPlayer(dtoChat.PlayerId2.playerId);
+            try
-            var player2 = await _dataManager.GetPlayer(dtoChat.PlayerId2.playerId);
-
-            var chat = new Chat
             {
-                chatId = dtoChat.chatId,
+                var player1 = await _dataManager.GetPlayer(dtoChat.PlayerId1.playerId);
-                player1 = player1.playerId,
+                var player2 = await _dataManager.GetPlayer(dtoChat.PlayerId2.playerId);
-                player2 = player2.playerId
+
-            };
+                await _dataManager.AddChat(dtoChat.ToChat(player1, player2));
 
-            await _dataManager.AddChat(chat);
+                var success_message = $"Le chat entre {player1.name} et {player2.name} a été ajouté avec succès.";
-            return Ok();
+                _logger.LogInformation(success_message);
+                return Ok(new ApiResponse<object>(success_message));
+            }
+            catch (Exception ex)
+            {
+                var error_message = $"Une erreur est survenue lors de l'ajout du chat : {ex.Message}";
+                _logger.LogError(ex, error_message);
+                return StatusCode(500, new ApiResponse<object>(error_message));
+            }
         }
 
         [HttpGet]
         public async Task<ActionResult<IEnumerable<DTOChat>>> GetChats()
         {
-            var chats = await _dataManager.GetChats();
+            try
-            if (chats == null)
+            {
+                var chats = await _dataManager.GetChats();
+                if (chats == null)
+                {
+                    var message = "Aucun chat n'a été trouvé.";
+                    _logger.LogWarning(message);
+                    return NotFound(new ApiResponse<object>(message));
+                }
+
+                var dtoChats = new List<DTOChat>();
+                foreach (var chat in chats)
+                {
+                    var player1 = await _dataManager.GetPlayer(chat.player1);
+                    var player2 = await _dataManager.GetPlayer(chat.player2);
+
+                    var dtoChat = chat.ToDto(player1, player2);
+
+                    dtoChats.Add(dtoChat);
+                }
+
+                var success_message = $"La récupération des chats a réussi. Nombre de chats : {dtoChats.Count}";
+                _logger.LogInformation(success_message);
+                return Ok(new ApiResponse<List<DTOChat>>(success_message,dtoChats));
+            }
+            catch (Exception ex)
             {
-                return NotFound();
+                var error_message = $"Une erreur est survenue lors de la récupération des chats : {ex.Message}";
+                _logger.LogError(ex, error_message);
+                return StatusCode(500, new ApiResponse<object>(error_message));
             }
+        }
 
-            var dtoChats = new List<DTOChat>();
+        [HttpGet("{id}")]
-            foreach (var chat in chats)
+        public async Task<ActionResult<IEnumerable<DTOChat>>> GetChatById(int id)
+        {
+            try
             {
+                var chat = await _dataManager.GetChat(id);
+                if (chat == null)
+                {
+                    var message = "Aucun chat n'a été trouvé.";
+                    _logger.LogWarning(message);
+                    return NotFound(new ApiResponse<object>(message));
+                }
+
                 var player1 = await _dataManager.GetPlayer(chat.player1);
                 var player2 = await _dataManager.GetPlayer(chat.player2);
 
-                var dtoChat = new DTOChat
+                var dtoChat = chat.ToDto(player1, player2);
+
+                var success_message = $"La récupération du chat a réussi pour le chat {id}.";
+                _logger.LogInformation(success_message);
+                return Ok(new ApiResponse<DTOChat>(success_message, dtoChat));
+            }
+            catch (Exception ex)
+            {
+                var error_message = $"Une erreur est survenue lors de la récupération du chat {id} : {ex.Message}";
+                _logger.LogError(ex, error_message);
+                return StatusCode(500, new ApiResponse<object>(error_message));
+            }
+        }
+
+        [HttpGet("byPlayer/{id}")]
+        public async Task<ActionResult<IEnumerable<DTOChat>>> GetChatsByIdPlayer(int id)
+        {
+            try
+            {
+                var chats = await _dataManager.GetChatsByIdPlayer(id);
+                if (chats == null || chats.Count() == 0)
+                {
+                    var message = "Aucun chat n'a été trouvé pour l'id : {id}.";
+                    _logger.LogWarning(message);
+                    return NotFound(new ApiResponse<object>(message));
+                }
+
+                var dtoChats = new List<DTOChat>();
+                foreach (var chat in chats)
                 {
-                    chatId = chat.chatId,
+                    var player1 = await _dataManager.GetPlayer(chat.player1);
-                    PlayerId1 = new DTOPlayer { playerId = player1.playerId, name = player1.name },
+                    var player2 = await _dataManager.GetPlayer(chat.player2);
-                    PlayerId2 = new DTOPlayer { playerId = player2.playerId, name = player2.name }
+
-                };
+                    var dtoChat = chat.ToDto(player1, player2);
+
+                    dtoChats.Add(dtoChat);
+                }
 
-                dtoChats.Add(dtoChat);
+                var success_message = $"La récupération des chats a réussi pour l'id : {id}. Nombre de chats : {dtoChats.Count}";
+                _logger.LogInformation(success_message);
+                return Ok(new ApiResponse<List<DTOChat>>(success_message, dtoChats));
             }
+            catch (Exception ex)
+            {
+                var error_message = $"Une erreur est survenue lors de la récupération des chats de l'utilisateur {id} : {ex.Message}";
+                _logger.LogError(ex, error_message);
+                return StatusCode(500, new ApiResponse<object>(error_message));
+            }
+        }
 
-            return Ok(dtoChats);
+        [HttpGet("players/{idPlayer1}/{idPlayer2}")]
+        public async Task<ActionResult<IEnumerable<DTOChat>>> GetChatsByIdPlayers(int idPlayer1, int idPlayer2)
+        {
+            try
+            {
+                var chats = await _dataManager.GetChatsByIdPlayers(idPlayer1,idPlayer2);
+                if (chats == null ||chats.Count() == 0)
+                {
+                    var message = $"Aucun chat n'a été trouvé pour les joueurs {idPlayer1} et {idPlayer2}.";
+                    _logger.LogWarning(message);
+                    return NotFound(new ApiResponse<object>(message));
+                }
+
+                var dtoChats = new List<DTOChat>();
+                foreach (var chat in chats)
+                {
+                    var player1 = await _dataManager.GetPlayer(chat.player1);
+                    var player2 = await _dataManager.GetPlayer(chat.player2);
+
+                    dtoChats.Add(chat.ToDto(player1, player2));
+                }
+
+                var success_message = $"La récupération des chats a réussi pour les joueurs {idPlayer1} et {idPlayer2}. Nombre de chats : {dtoChats.Count}";
+                _logger.LogInformation(success_message);
+                return Ok(new ApiResponse<List<DTOChat>>(success_message, dtoChats));
+            }
+            catch (Exception ex)
+            {
+                var error_message = $"Une erreur est survenue lors de la récupération des chats pour les joueurs {idPlayer1} et {idPlayer2} : {ex.Message}";
+                _logger.LogError(ex, error_message);
+                return StatusCode(500, new ApiResponse<object>(error_message));
+            }
         }
 
         [HttpDelete("{id}")]
         public async Task<ActionResult> RemoveChat(int id)
         {
-            var result = await _dataManager.RemoveChat(id);
+            try
-            if (result)
+            {
+                var result = await _dataManager.RemoveChat(id);
+                if (result)
+                {
+                    var success_message = $"Le chat avec l'identifiant {id} a été supprimé avec succès.";
+                    _logger.LogInformation(success_message);
+                    return Ok(new ApiResponse<object>(success_message));
+                }
+
+                var warning_message = $"Le chat avec l'identifiant {id} n'a pas été trouvé.";
+                _logger.LogWarning(warning_message);
+                return NotFound(new ApiResponse<object>(warning_message));
+            }
+            catch (Exception ex)
             {
-                return Ok(result);
+                var error_message = $"Une erreur est survenue lors de la suppression du chat : {ex.Message}";
+                _logger.LogError(ex, error_message);
+                return StatusCode(500, new ApiResponse<object>(error_message));
             }
-            return NotFound(result);
         }
     }
 }

code/server/ApiLeapHit/Controllers/GameController.cs

@@ -30,28 +30,27 @@ namespace ApiLeapHit.Controllers
         {
             try
             {
+                _logger.LogInformation("Récupération de la game avec l'identifiant {id}", id);
+
                 var game = await _dataManager.GetGame(id);
                 if (game == null)
                 {
-                    return NotFound(new ApiResponse<DTOGame>("La game avec l'identifiant " + id + " n'existe pas."));
+                    var message = $"La game avec l'identifiant {id} n'existe pas";
+                    _logger.LogWarning(message);
+                    return NotFound(new ApiResponse<object>(message));
                 }
-                var winner = await _dataManager.GetPlayer(game.winner);
-                //if (winner == null)
-                //{
-                //    return NotFound("Le joueur avec l'identifiant " + game.winner + " n'existe pas.");
-                //}
 
+                var winner = await _dataManager.GetPlayer(game.winner);
                 var loser = await _dataManager.GetPlayer(game.loser);
-                //if (loser == null)
+
-                //{
+                _logger.LogInformation("Récupération des joueurs pour la game avec l'identifiant {id}", id);
-                //    return NotFound("Le joueur avec l'identifiant " + game.loser + " n'existe pas.");
-                //}
 
                 return Ok(new ApiResponse<DTOGame>("Récupération de la game réussie.", game.ToDto(winner, loser)));
             }
             catch (Exception ex)
             {
-                return StatusCode(500, new ApiResponse<Game>("Une erreur est survenue lors de la récupération des données : " + ex.Message));
+                _logger.LogError(ex, $"Une erreur est survenue lors de la récupération des données pour la game avec l'identifiant {id}");
+                return StatusCode(500, new ApiResponse<object>($"Une erreur est survenue lors de la récupération des données : {ex.Message}"));
             }
         }
 
@@ -60,137 +59,132 @@ namespace ApiLeapHit.Controllers
         {
             try
             {
+                _logger.LogInformation("Récupération de toutes les games.");
+
                 var games = await _dataManager.GetGames();
                 if (games == null)
                 {
-                    return NotFound(new ApiResponse<IEnumerable<DTOGame>>("Aucune game n'ont été trouvées."));
+                    var message = "Aucune game n'a été trouvée.";
+                    _logger.LogWarning(message);
+                    return NotFound(new ApiResponse<object>(message));
                 }
 
-                //StringBuilder errorMessage = new StringBuilder();
                 var dtoGames = new List<DTOGame>();
+
                 foreach (var game in games)
                 {
                     var winner = await _dataManager.GetPlayer(game.winner);
                     var loser = await _dataManager.GetPlayer(game.loser);
 
-                    //if (winner == null || loser == null)
+                    //ce cas n'est jamais censé arrivé
-                    //{
+                    if (winner == null || loser == null)
-                    //    errorMessage.Append("Le joueur gagnant ou le joueur perdant n'existe pas pour le jeu avec l'identifiant ");
+                    {
-                    //    errorMessage.Append(game.gameId);
+                        _logger.LogError($"Le joueur gagnant ou le joueur perdant n'existe pas pour le jeu avec l'identifiant {game.gameId}.");
-                    //    errorMessage.Append(".");
+                        continue;
-                    //    break;
+                    }
-                    //}
+
                     dtoGames.Add(game.ToDto(winner, loser));
                 }
 
-                //if (errorMessage.Length > 0)
+                _logger.LogInformation("{Count} games ont été récupérées.", dtoGames.Count);
-                //{
+                return Ok(new ApiResponse<IEnumerable<DTOGame>>("La récupération des games a réussi.", dtoGames));
-                //    return NotFound(errorMessage.ToString());
-                //}
-                return Ok(new ApiResponse<IEnumerable<DTOGame>>("La récupération des games à réussit." , dtoGames));
             }
             catch (Exception ex)
             {
-                return StatusCode(500, new ApiResponse<Game>("Une erreur est survenue lors de la récupération des données : " + ex.Message));
+                var message = "Une erreur est survenue lors de la récupération des données.";
+                _logger.LogError(ex, message);
+                return StatusCode(500, new ApiResponse<object>($"{message} {ex.Message}"));
             }
         }
 
         [HttpGet("byPlayer/{id}")]
         public async Task<ActionResult<IEnumerable<DTOGame>>> GetGameByIdPlayer(int id)
         {
-            try { 
+            try
+            {
                 var games = await _dataManager.GetGameById(id);
+
                 if (games == null || games.Count == 0)
                 {
-                    return NotFound(new ApiResponse<IEnumerable<DTOGame>>("Aucune game trouvé pour le joueur avec l'id  : " + id));
+                    var message = $"Aucune game trouvée pour le joueur avec l'id {id}.";
+                    _logger.LogInformation(message);
+                    return NotFound(new ApiResponse<object>(message));
                 }
-                //StringBuilder errorMessage = new StringBuilder();
+
                 var dtoGames = new List<DTOGame>();
+
                 foreach (var game in games)
                 {
                     var winner = await _dataManager.GetPlayer(game.winner);
                     var loser = await _dataManager.GetPlayer(game.loser);
 
-
-                    //if (winner == null)
-                    //{
-                    //    errorMessage.Append("Le joueur gagnant n'existe pas pour le jeu avec l'identifiant ");
-                    //    errorMessage.Append(game.gameId);
-                    //    errorMessage.Append(".");
-                    //    break;
-                    //}
-
-                    //if (loser == null)
-                    //{
-                    //    errorMessage.Append("Le joueur perdant n'existe pas pour le jeu avec l'identifiant ");
-                    //    errorMessage.Append(game.gameId);
-                    //    errorMessage.Append(".");
-                    //    break;
-                    //}
-
                     dtoGames.Add(game.ToDto(winner, loser));
                 }
 
-                //if (errorMessage.Length > 0)
+                var successMessage = $"Récupération réussie des games pour le joueur avec l'id {id}.";
-                //{
+                _logger.LogInformation(successMessage);
-                //    return NotFound(errorMessage.ToString());
+                return Ok(new ApiResponse<IEnumerable<DTOGame>>(successMessage, dtoGames));
-                //}
-                return Ok(new ApiResponse<IEnumerable<DTOGame>>("Récupérations réussis des games pour le joueur " + id, dtoGames));
             }
             catch (Exception ex)
             {
-                return StatusCode(500, new ApiResponse<Game>("Une erreur est survenue lors de la récupération des données : " + ex.Message));
+                var errorMessage = $"Une erreur est survenue lors de la récupération des games pour le joueur avec l'id {id}.";
+                _logger.LogError(errorMessage + " Error message: " + ex.Message);
+                return StatusCode(500, new ApiResponse<object>(errorMessage));
             }
         }
 
         [HttpPost]
         public async Task<ActionResult> AddGame([FromBody] DTOGameWithIdPlayer dtoGame)
         {
-            try { 
+            try
+            {
                 var winner = await _dataManager.GetPlayer(dtoGame.playerWinner);
                 var loser = await _dataManager.GetPlayer(dtoGame.playerLoser);
 
-                //StringBuilder errorMessage = new StringBuilder();
+                //if (winner == null || loser == null)
-
-                //if (winner == null)
-                //{
-                //    errorMessage.Append("Le joueur gagnant avec l'identifiant ");
-                //    errorMessage.Append(dtoGame.playerWinner.playerId);
-                //    errorMessage.Append(" n'existe pas.");
-                //    return NotFound(errorMessage.ToString());
-                //}
-
-                //if (loser == null)
                 //{
-                //    errorMessage.Append("Le joueur perdant avec l'identifiant ");
+                //    var errorMessage = "Le joueur gagnant ou le joueur perdant n'existe pas pour la partie avec l'identifiant " + dtoGame.gameId + ".";
-                //    errorMessage.Append(dtoGame.playerLoser.playerId);
+                //    _logger.LogError(errorMessage);
-                //    errorMessage.Append(" n'existe pas.");
+                //    return NotFound(new ApiResponse<Game>(errorMessage));
-                //    return NotFound(errorMessage.ToString());
                 //}
 
                 var game = dtoGame.ToGame(winner, loser);
-                return Ok(new ApiResponse<Game>("La game a été ajoutée avec succès.", game));
+                await _dataManager.AddGame(game);
+
+                var successMessage = "La partie avec l'identifiant " + game.gameId + " a été ajoutée avec succès.";
+                _logger.LogInformation(successMessage);
+                return Ok(new ApiResponse<Game>(successMessage, game));
             }
             catch (Exception ex)
             {
-                return StatusCode(500, new ApiResponse<Game>("Une erreur est survenue lors de la récupération des données : " + ex.Message));
+                var errorMessage = "Une erreur est survenue lors de l'ajout de la partie : " + ex.Message;
+                _logger.LogError(errorMessage);
+                return StatusCode(500, new ApiResponse<object>(errorMessage));
             }
         }
 
-    [HttpDelete("{id}")]
+        [HttpDelete("{id}")]
         public async Task<ActionResult> RemoveGame(int id)
         {
-            try { 
+            try
+            {
                 var result = await _dataManager.RemoveGame(id);
                 if (result)
                 {
-                    return Ok(new ApiResponse<object>( "La game avec l'identifiant " + id + " a été supprimée avec succès."));
+                    var successMessage = $"La game avec l'identifiant {id} a été supprimée avec succès.";
+                    _logger.LogInformation(successMessage);
+                    return Ok(new ApiResponse<object>(successMessage));
                 }
-                return NotFound(new ApiResponse<object>("La game avec l'identifiant " + id + " n'existe pas."));
+
+                var notFoundMessage = $"La game avec l'identifiant {id} n'existe pas.";
+                _logger.LogInformation(notFoundMessage);
+                return NotFound(new ApiResponse<object>(notFoundMessage));
             }
             catch (Exception ex)
             {
-                return StatusCode(500, new ApiResponse<object>("Une erreur est survenue lors de la récupération des données : " + ex.Message));
+                var errorMessage = $"Une erreur est survenue lors de la suppression de la game avec l'identifiant {id} : {ex.Message}";
+                _logger.LogError(errorMessage);
+                return StatusCode(500, new ApiResponse<object>(errorMessage));
             }
         }
     }

code/server/ApiLeapHit/Controllers/MessageController.cs

@@ -1,6 +1,7 @@
 using DataBase.DataManager;
 using DataBase.Entity;
 using DTO;
+using DTO.Factory;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 
@@ -10,68 +11,88 @@ namespace ApiLeapHit.Controllers
     [ApiController]
     public class MessageController : Controller
     {
-        private readonly DbDataManager _dataManager;
 
+        private readonly DbDataManager _dataManager;
+        private readonly ILogger<MessageController> _logger;
 
-        public MessageController(DbDataManager dataManager)
+        public MessageController(DbDataManager dataManager, ILogger<MessageController> logger)
         {
             _dataManager = dataManager;
+            _logger = logger;
         }
 
-        [HttpGet("{id}")]
+        [HttpPost]
-        public async Task<ActionResult<DTOMessage>> ReceiveMessage(int id)
+        public async Task<ActionResult> SendMessage([FromBody] DTOMessage dtoMessage)
         {
-            var message = await _dataManager.ReceiveMessage(id);
+            try
-            if (message == null)
             {
-                return NotFound();
+                var player = await _dataManager.GetPlayer(dtoMessage.PlayerId.playerId);
-            }
+                if (player == null)
+                {
+                    _logger.LogWarning($"Le joueur avec l'identifiant {dtoMessage.PlayerId.playerId} n'existe pas.");
+                    return NotFound(new ApiResponse<object>($"Le joueur avec l'identifiant {dtoMessage.PlayerId.playerId} n'existe pas."));
+                }
 
-            var player = await _dataManager.GetPlayer(message.player);
+                var message = new Message
+                {
+                    messageId = dtoMessage.messageId,
+                    message = dtoMessage.message,
+                    timestamp = dtoMessage.timestamp,
+                    player = player.playerId
+                };
 
+                await _dataManager.SendMessage(message);
 
-            var dtoMessage = new DTOMessage
+                _logger.LogInformation($"Le message avec l'identifiant {message.messageId} a été envoyé avec succès.");
+                return Ok(new ApiResponse<object>($"Le message avec l'identifiant {message.messageId} a été envoyé avec succès."));
+            }
+            catch (Exception ex)
             {
-                messageId = message.messageId,
+                _logger.LogError($"Une erreur est survenue lors de l'envoi du message : {ex.Message}");
-                message = message.message,
+                return StatusCode(500, new ApiResponse<object>($"Une erreur est survenue lors de l'envoi du message : {ex.Message}"));
-                timestamp = message.timestamp,
+            }
-                PlayerId = new DTOPlayer
-                {
-                    playerId = player.playerId,
-                    name = player.name,
-                    nbBallTouchTotal = player.nbBallTouchTotal,
-                    timePlayed = player.timePlayed
-                }
-            };
-            return Ok(dtoMessage);
         }
 
-        [HttpPost]
+        [HttpDelete("{id}")]
-        public async Task<ActionResult> SendMessage([FromBody] DTOMessage dtoMessage)
+        public async Task<ActionResult> RemoveMessage(int id)
         {
-            var player = await _dataManager.GetPlayer(dtoMessage.PlayerId.playerId);
+            try
-
-            var message = new Message
             {
-                messageId = dtoMessage.messageId,
+                var result = await _dataManager.RemoveMessage(id);
-                message = dtoMessage.message,
+                if (result)
-                timestamp = dtoMessage.timestamp,
+                {
-                player = player.playerId
+                    _logger.LogInformation($"Le message avec l'identifiant {id} a été supprimé avec succès.");
-            };
+                    return Ok(new ApiResponse<object>($"Le message avec l'identifiant {id} a été supprimé avec succès."));
-
+                }
-            await _dataManager.SendMessage(message);
+                else
-            return Ok();
+                {
+                    _logger.LogWarning($"Le message avec l'identifiant {id} n'existe pas.");
+                    return NotFound(new ApiResponse<object>($"Le message avec l'identifiant {id} n'existe pas."));
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError($"Une erreur est survenue lors de la suppression du message avec l'identifiant {id} : {ex.Message}");
+                return StatusCode(500, new ApiResponse<object>($"Une erreur est survenue lors de la suppression du message avec l'identifiant {id} : {ex.Message}"));
+            }
         }
 
-        [HttpDelete("{id}")]
+        [HttpGet("{id}")]
-        public async Task<ActionResult> RemoveMessage(int id)
+        public async Task<ActionResult<DTOMessage>> ReceiveMessage(int id)
         {
-            var result = await _dataManager.RemoveMessage(id);
+            var message = await _dataManager.ReceiveMessage(id);
-            if (result)
+            if (message == null)
             {
-                return Ok(result);
+                return NotFound();
             }
-            return NotFound(result);
+
+            var player = await _dataManager.GetPlayer(message.player);
+            var chat = await _dataManager.GetChat(message.chat);
+
+
+
+            return Ok(message);
         }
+
     }
 }

code/server/ApiLeapHit/Controllers/PlayerController.cs

@@ -1,6 +1,8 @@
-using DataBase.DataManager;
+using ApiLeapHit.Mapper;
+using DataBase.DataManager;
 using DataBase.Entity;
 using DTO;
+using DTO.Factory;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using System.Net;
@@ -12,46 +14,132 @@ namespace ApiLeapHit.Controllers
     public class PlayerController : ControllerBase
     {
         private readonly DbDataManager _dataManager;
+        private readonly ILogger<PlayerController> _logger;
 
-        public PlayerController(DbDataManager dataManager)
+        public PlayerController(DbDataManager dataManager, ILogger<PlayerController> logger)
         {
             _dataManager = dataManager;
+            _logger = logger;
         }
+
         [HttpGet("{id}")]
         public async Task<ActionResult<DTOPlayer>> GetPlayer(int id)
         {
-            var player = await _dataManager.GetPlayer(id);
+            try
-            if (player == null)
             {
-                return NotFound();
+                var player = await _dataManager.GetPlayer(id);
-            }
+                if (player == null)
+                {
+                    return NotFound(new ApiResponse<object>("Joueur non trouvé."));
+                }
+
+                var response = new ApiResponse<DTOPlayer>($"Le joueur avec l'id {id} a été récupéré avec succès.", player.ToDto());
 
+                // Ajout des liens HATEOAS
+                response.Links.Add(new ApiLink(
+                    Url.Action("GetPlayer", "Player", new { id }),
+                    "self",
+                    "GET"
+                ));
+                response.Links.Add(new ApiLink(
+                    Url.Action("RemovePlayer", "Player", new { id }),
+                    "delete",
+                    "DELETE"
+                ));
+                response.Links.Add(new ApiLink(
+                    Url.Action("Put", "Player", new { id }),
+                    "update",
+                    "PUT"
+                ));
 
-            var dtoPlayer = new DTOPlayer
+                return Ok(response);
+            }
+            catch (Exception ex)
             {
-                playerId = player.playerId,
+                _logger.LogError(ex, $"Une erreur est survenue lors de la récupération du joueur avec l'id {id}.");
-                name = player.name,
+                return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse<object>("Une erreur est survenue lors de la récupération du joueur."));
-                nbBallTouchTotal = player.nbBallTouchTotal,
+            }
-                timePlayed = player.timePlayed,
-                
-            };
-            return Ok(dtoPlayer);
         }
 
         [HttpPost]
         public async Task<ActionResult> AddPlayer([FromBody] DTOPlayer dtoPlayer)
         {
-            
+            try
-            var player = new Player
+            {
+                var player = dtoPlayer.ToPlayer();
+
+                await _dataManager.AddPlayer(player);
+
+                // Ajout des liens HATEOAS
+                var response = new ApiResponse<object>("Joueur ajouté avec succès.");
+                response.Links.Add(new ApiLink(
+                    Url.Action("GetPlayer", "Player", new { id = player.playerId }),
+                    "self",
+                    "GET"
+                ));
+
+                return Ok(response);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Une erreur est survenue lors de l'ajout du joueur.");
+                return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse<object>("Une erreur est survenue lors de l'ajout du joueur."));
+            }
+        }
+
+        [HttpGet]
+        public async Task<ActionResult<IEnumerable<DTOPlayer>>> GetPlayers()
+        {
+            try
+            {
+                var players = await _dataManager.GetPlayers();
+                if (players == null || players.Count() == 0)
+                {
+                    return NotFound(new ApiResponse<IEnumerable<DTOPlayer>>("Aucun joueur trouvé."));
+                }
+
+                var dtoPlayers = players.Select(p => p.ToDto()).ToList();
+
+                var response = new ApiResponse<IEnumerable<DTOPlayer>>($"La récupération des players a réussi. Nombre de players : {dtoPlayers.Count}", dtoPlayers);
+
+                // Ajout des liens HATEOAS
+                response.Links.Add(new ApiLink(
+                    Url.Action("GetPlayers", "Player"),
+                    "self",
+                    "GET"
+                ));
+                response.Links.Add(new ApiLink(
+                    Url.Action("AddPlayer", "Player"),
+                    "create",
+                    "POST"
+                ));
+
+                foreach (var player in dtoPlayers)
+                {
+                    response.Links.Add(new ApiLink(
+                        Url.Action("GetPlayer", "Player", new { id = player.playerId }),
+                        "get_player",
+                        "GET"
+                    ));
+                    response.Links.Add(new ApiLink(
+                        Url.Action("RemovePlayer", "Player", new { id = player.playerId }),
+                        "delete_player",
+                        "DELETE"
+                    ));
+                    response.Links.Add(new ApiLink(
+                        Url.Action("Put", "Player", new { id = player.playerId }),
+                        "update_player",
+                        "PUT"
+                    ));
+                }
+
+                return Ok(response);
+            }
+            catch (Exception ex)
             {
-                playerId = dtoPlayer.playerId,
+                _logger.LogError(ex, "Une erreur est survenue lors de la récupération des joueurs.");
-                name = dtoPlayer.name,
+                return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse<object>("Une erreur est survenue lors de la récupération des joueurs."));
-                nbBallTouchTotal = dtoPlayer.nbBallTouchTotal,
+            }
-                timePlayed = dtoPlayer.timePlayed,
-            };
-
-            await _dataManager.AddPlayer(player);
-            return Ok();
         }
 
         [HttpDelete("{id}")]
@@ -62,39 +150,66 @@ namespace ApiLeapHit.Controllers
                 var result = await _dataManager.RemovePlayer(id);
                 if (result)
                 {
-                    return Ok();
+                    // Ajout des liens HATEOAS
+                    var response = new ApiResponse<object>("Joueur supprimé avec succès.");
+                    response.Links.Add(new ApiLink(
+                        Url.Action("GetPlayers", "Player"),
+                        "self",
+                        "GET"
+                    ));
+
+                    return Ok(response);
                 }
-                return NotFound();
+                return NotFound(new ApiResponse<object>("Joueur non trouvé."));
             }
             catch (Exception ex)
             {
-                return StatusCode((int)HttpStatusCode.InternalServerError);
+                _logger.LogError(ex, $"Une erreur est survenue lors de la suppression du joueur avec l'id {id}.");
+                return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse<object>("Une erreur est survenue lors de la suppression du joueur."));
             }
         }
-
-        
         [HttpPut("{id}")]
         public async Task<IActionResult> Put(int id, [FromBody] DTOPlayer dtoPlayer)
-        {   
+        {
-            if (!ModelState.IsValid)
+            try
-                return StatusCode((int)HttpStatusCode.BadRequest); //"Les données du player ne sont pas correctes"
+            {
+                if (!ModelState.IsValid)
+                {
+                    return BadRequest(new ApiResponse<object>("Les données du joueur sont invalides."));
+                }
+
+                var player = dtoPlayer.ToPlayer();
+
+                var playerTest = await _dataManager.GetPlayer(id);
+                if (playerTest == null)
+                {
+                    return NotFound(new ApiResponse<object>("Joueur non trouvé."));
+                }
+
+                await _dataManager.UpdatePlayer(id, player.name);
 
-            Player playerTeste = await _dataManager.GetPlayer(id);
+                // Ajout des liens HATEOAS
-            if (playerTeste != null)
+                var response = new ApiResponse<object>("Joueur mis à jour avec succès.");
-                return StatusCode((int)HttpStatusCode.NotFound); //"Le player n'existe pas."
+                response.Links.Add(new ApiLink(
+                    Url.Action("GetPlayer", "Player", new { id }),
+                    "self",
+                    "GET"
+                ));
+                response.Links.Add(new ApiLink(
+                    Url.Action ("RemovePlayer", "Player", new { id }),
+                    "delete",
+                    "DELETE"
+                    ));
 
-            var player = new Player
+        
+                return Ok(response);
+            }
+            catch (Exception ex)
             {
-                playerId = dtoPlayer.playerId,
+                _logger.LogError(ex, $"Une erreur est survenue lors de la modification du joueur avec l'id {id}.");
-                name = dtoPlayer.name,
+                return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse<object>("Une erreur est survenue lors de la modification du joueur."));
-                nbBallTouchTotal = dtoPlayer.nbBallTouchTotal,
+            }
-                timePlayed = dtoPlayer.timePlayed,
-            };
-
-            Player playerUpdate = await _dataManager.GetPlayer(id);
-            await _dataManager.UpdatePlayer(id,player.name);
-            return StatusCode((int)HttpStatusCode.OK); //"Le champion a été modifié."
-        }
 
+        }
     }
 }

code/server/ApiLeapHit/Mapper/ChatMapper.cs

@@ -0,0 +1,29 @@
+using DataBase.Entity;
+using DTO;
+
+namespace ApiLeapHit.Mapper
+{
+    public static class ChatMapper
+    {
+        public static DTOChat ToDto(this Chat chat, Player player1, Player player2)
+        {
+            DTOChat dtoChat = new DTOChat()
+            {
+                chatId = chat.chatId,
+                PlayerId1 = player1.ToDto(),
+                PlayerId2 = player2.ToDto()
+            };
+            return dtoChat;
+        }
+
+        public static Chat ToChat(this DTOChat dtoChat, Player player1, Player player2)
+        {
+            return new Chat
+            {
+                chatId = dtoChat.chatId,
+                player1 = player1.playerId,
+                player2 = player2.playerId
+            };
+        }
+    }
+}

code/server/ApiLeapHit/Mapper/MessageMapper.cs

@@ -0,0 +1,21 @@
+using DataBase.Entity;
+using DTO;
+
+namespace ApiLeapHit.Mapper
+{
+    public static class MessageMapper
+    {
+        public static DTOMessage ToDto(this Message message, Player player,  Chat chat)
+        {
+            DTOMessage dtoMessage = new DTOMessage()
+            {
+                messageId = message.messageId,
+                message = message.message,
+                timestamp = message.timestamp,
+                PlayerId = player.ToDto(),
+                //ChatId = chat.ToDto()
+            };
+            return dtoMessage;
+        }
+    }
+}

code/server/ApiLeapHit/Mapper/PlayerMapper.cs

@@ -16,5 +16,16 @@ namespace ApiLeapHit.Mapper
             };
             return dtoPlayer;
         }
+
+        public static Player ToPlayer(this DTOPlayer dtoPlayer)
+        {
+            return new Player
+            {
+                playerId = dtoPlayer.playerId,
+                name = dtoPlayer.name,
+                nbBallTouchTotal = dtoPlayer.nbBallTouchTotal,
+                timePlayed = dtoPlayer.timePlayed
+            };
+        }
     }
 }

code/server/DTO/Factory/ApiLink.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DTO.Factory
+{
+    public class ApiLink
+    {
+        public string Href { get; set; }
+        public string Rel { get; set; }
+        public string Method { get; set; }
+
+        public ApiLink(string href, string rel, string method)
+        {
+            Href = href;
+            Rel = rel;
+            Method = method;
+        }
+    }
+}

code/server/DTO/Factory/ApiResponse.cs

@@ -10,6 +10,8 @@ namespace DTO.Factory
     {
         public string Message { get; set; }
         public T Data { get; set; }
+        public List<ApiLink> Links { get; set; } = new List<ApiLink>();
+
 
         public ApiResponse(string message, T data = default)
         {

code/server/DataBase/DataManager/DbDataManager.Chat.cs

@@ -42,7 +42,32 @@ namespace DataBase.DataManager
                 return Task.FromResult(chats);
             }
         }
+        public Task<Chat> GetChat(int id)
+        {
+            using (var context = new PongDbContext())
+            {
+                var chat = context.Chats.Where(g => g.chatId == id).ToList().FirstOrDefault();
+                return Task.FromResult<Chat>(chat);
+            }
+        }
+
+        public Task<List<Chat>> GetChatsByIdPlayer(int id)
+        {
+            using (var context = new PongDbContext())
+            {
+                var chats = context.Chats.Where(g => g.player1 == id || g.player2 == id).ToList();
+                return Task.FromResult(chats);
+            }
+        }
 
+        public Task<List<Chat>> GetChatsByIdPlayers(int idPlayer1, int idPlayer2)
+        {
+            using (var context = new PongDbContext())
+            {
+                var chats = context.Chats.Where(g => (g.player1 == idPlayer1 && g.player2 == idPlayer2) || (g.player1 == idPlayer2 && g.player2 == idPlayer1)).ToList();
+                return Task.FromResult(chats);
+            }
+        }
 
     }
 }

code/server/DataBase/DataManager/DbDataManager.Player.cs

@@ -58,5 +58,14 @@ namespace DataBase.DataManager
                 return Task.FromResult<Player>(player);
             }
         }
+
+        public Task<List<Player>> GetPlayers()
+        {
+            using (var context = new PongDbContext())
+            {
+                var players = context.Players.ToList();
+                return Task.FromResult(players);
+            }
+        }
     }
 }