🔨 Ajout d'un id unique pour le player

code/server/ApiLeapHit/Controllers/ChatsController.cs

@@ -5,45 +5,53 @@ using DTO;
 using DTO.Factory;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
+using System.Net;
 
 namespace ApiLeapHit.Controllers
 {
     [Route("api/[controller]")]
     [ApiController]
-    public class ChatController : Controller
+    public class ChatsController : Controller
     {
 
         private readonly DbDataManager _dataManager;
-        private readonly ILogger<ChatController> _logger;
+        private readonly ILogger<ChatsController> _logger;
 
-        public ChatController(DbDataManager dataManager, ILogger<ChatController> logger)
+        public ChatsController(DbDataManager dataManager, ILogger<ChatsController> logger)
         {
             _dataManager = dataManager;
             _logger = logger;
         }
 
         [HttpPost]
-        public async Task<ActionResult> AddChat([FromBody] DTOChat dtoChat)
+        public async Task<IActionResult> AddChat([FromBody] DTOChat dtoChat)
         {
             try
             {
                 var player1 = await _dataManager.GetPlayer(dtoChat.PlayerId1);
                 var player2 = await _dataManager.GetPlayer(dtoChat.PlayerId2);
+                if (player1 == null || player2 == null)
+                {
+                    var message = "Les ids de player ne sont pas valides.";
+                    _logger.LogInformation(message);
+                    return BadRequest(message);
+                }
 
                 await _dataManager.AddChat(dtoChat.ToChat());
 
                 var success_message = $"Le chat entre {player1.name} et {player2.name} a été ajouté avec succès.";
                 _logger.LogInformation(success_message);
-                return Ok(new ApiResponse<object>(success_message));
+                return Ok(success_message);
             }
             catch (Exception ex)
             {
-                var error_message = $"Une erreur est survenue lors de l'ajout du chat : {ex.Message}";
+                var error_message = $"Une erreur est survenue lors de l'ajout du chat.";
                 _logger.LogError(ex, error_message);
-                return StatusCode(500, new ApiResponse<object>(error_message));
+                return StatusCode((int)HttpStatusCode.InternalServerError, error_message);
             }
         }
 
+
         [HttpGet]
         public async Task<ActionResult<IEnumerable<DTOChat>>> GetChats()
         {
@@ -53,35 +61,26 @@ namespace ApiLeapHit.Controllers
                 if (chats == null)
                 {
                     var message = "Aucun chat n'a été trouvé.";
-                    _logger.LogWarning(message);
+                    _logger.LogInformation(message);
-                    return NotFound(new ApiResponse<object>(message));
+                    return NotFound(message);
                 }
 
-                var dtoChats = new List<DTOChat>();
+                var dtoChats = chats.Select(c => c.ToDto());
-                foreach (var chat in chats)
-                {
-                    //var player1 = await _dataManager.GetPlayer(chat.player1);
-                    //var player2 = await _dataManager.GetPlayer(chat.player2);
-
-                    var dtoChat = chat.ToDto();
 
-                    dtoChats.Add(dtoChat);
+                var success_message = $"La récupération des chats a réussi. Nombre de chats : {dtoChats.Count()}";
-                }
-
-                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));
+                return Ok(dtoChats);
             }
             catch (Exception ex)
             {
-                var error_message = $"Une erreur est survenue lors de la récupération des chats : {ex.Message}";
+                var error_message = $"Une erreur est survenue lors de la récupération des chats.";
                 _logger.LogError(ex, error_message);
-                return StatusCode(500, new ApiResponse<object>(error_message));
+                return StatusCode((int)HttpStatusCode.InternalServerError, error_message);
             }
         }
 
         [HttpGet("{id}")]
-        public async Task<ActionResult<IEnumerable<DTOChat>>> GetChatById(int id)
+        public async Task<ActionResult<DTOChat>> GetChatById(int id)
         {
             try
             {
@@ -89,90 +88,77 @@ namespace ApiLeapHit.Controllers
                 if (chat == null)
                 {
                     var message = "Aucun chat n'a été trouvé.";
-                    _logger.LogWarning(message);
+                    _logger.LogInformation(message);
-                    return NotFound(new ApiResponse<object>(message));
+                    return NotFound(message);
                 }
 
-                //var player1 = await _dataManager.GetPlayer(chat.player1);
-                //var player2 = await _dataManager.GetPlayer(chat.player2);
-
                 var dtoChat = chat.ToDto();
 
                 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));
+                return Ok(dtoChat);
             }
             catch (Exception ex)
             {
-                var error_message = $"Une erreur est survenue lors de la récupération du chat {id} : {ex.Message}";
+                var error_message = $"Une erreur est survenue lors de la récupération du chat {id}.";
                 _logger.LogError(ex, error_message);
-                return StatusCode(500, new ApiResponse<object>(error_message));
+                return StatusCode((int)HttpStatusCode.InternalServerError, error_message);
             }
         }
 
-        [HttpGet("byPlayer/{id}")]
+
-        public async Task<ActionResult<IEnumerable<DTOChat>>> GetChatsByIdPlayer(int id)
+        [HttpGet("Player/{id}")]
+        public async Task<ActionResult<List<DTOChat>>> GetChatsByIdPlayer(int id)
         {
             try
             {
                 var chats = await _dataManager.GetChatsByIdPlayer(id);
-                if (chats == null || chats.Count() == 0)
+                if (chats == null || !chats.Any())
                 {
-                    var message = "Aucun chat n'a été trouvé pour l'id : {id}.";
+                    var message = $"Aucun chat n'a été trouvé pour l'id : {id}.";
-                    _logger.LogWarning(message);
+                    _logger.LogInformation(message);
-                    return NotFound(new ApiResponse<object>(message));
+                    return NotFound(new ApiResponse(message));
-                }
-
-                var dtoChats = new List<DTOChat>();
-                foreach (var chat in chats)
-                {
-                    dtoChats.Add(chat.ToDto());
                 }
 
+                var dtoChats = chats.Select(c => c.ToDto()).ToList();
                 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}";
+                var error_message = $"Une erreur est survenue lors de la récupération des chats de l'utilisateur {id}.";
                 _logger.LogError(ex, error_message);
-                return StatusCode(500, new ApiResponse<object>(error_message));
+                return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse(error_message));
             }
+
         }
 
-        [HttpGet("players/{idPlayer1}/{idPlayer2}")]
+        [HttpGet("Players/{idPlayer1}/{idPlayer2}")]
-        public async Task<ActionResult<IEnumerable<DTOChat>>> GetChatsByIdPlayers(int idPlayer1, int idPlayer2)
+        public async Task<ActionResult<List<DTOChat>>> GetChatsByIdPlayers(int idPlayer1, int idPlayer2)
         {
             try
             {
-                var chats = await _dataManager.GetChatsByIdPlayers(idPlayer1,idPlayer2);
+                var chats = await _dataManager.GetChatsByIdPlayers(idPlayer1, idPlayer2);
-                if (chats == null ||chats.Count() == 0)
+                if (chats == null || !chats.Any())
                 {
                     var message = $"Aucun chat n'a été trouvé pour les joueurs {idPlayer1} et {idPlayer2}.";
-                    _logger.LogWarning(message);
+                    _logger.LogInformation(message);
-                    return NotFound(new ApiResponse<object>(message));
+                    return NotFound(new ApiResponse(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());
                 }
 
+                var dtoChats = chats.Select(c => c.ToDto()).ToList();
                 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}";
+                var error_message = $"Une erreur est survenue lors de la récupération des chats pour les joueurs {idPlayer1} et {idPlayer2}.";
                 _logger.LogError(ex, error_message);
-                return StatusCode(500, new ApiResponse<object>(error_message));
+                return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse(error_message));
             }
+
         }
 
         [HttpDelete("{id}")]
@@ -185,18 +171,18 @@ namespace ApiLeapHit.Controllers
                 {
                     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));
+                    return Ok(new ApiResponse(success_message));
                 }
 
                 var warning_message = $"Le chat avec l'identifiant {id} n'a pas été trouvé.";
-                _logger.LogWarning(warning_message);
+                _logger.LogInformation(warning_message);
-                return NotFound(new ApiResponse<object>(warning_message));
+                return NotFound(new ApiResponse(warning_message));
             }
             catch (Exception ex)
             {
                 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 StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse(error_message));
             }
         }
     }

code/server/ApiLeapHit/Controllers/GamesController.cs

@@ -13,13 +13,13 @@ namespace ApiLeapHit.Controllers
 {
     [Route("api/[controller]")]
     [ApiController]
-    public class GameController : ControllerBase
+    public class GamesController : ControllerBase
     {
         private readonly DbDataManager _dataManager;
 
-        private readonly ILogger<GameController> _logger;
+        private readonly ILogger<GamesController> _logger;
 
-        public GameController(DbDataManager dataManager, ILogger<GameController> logger)
+        public GamesController(DbDataManager dataManager, ILogger<GamesController> logger)
         {
             _dataManager = dataManager;
             _logger = logger;
@@ -51,50 +51,50 @@ namespace ApiLeapHit.Controllers
             }
         }
 
-        [HttpGet]
+        //[HttpGet]
-        public async Task<ActionResult<IEnumerable<DTOGame>>> GetGames()
+        //public async Task<ActionResult<IEnumerable<DTOGame>>> GetGames()
-        {
+        //{
-            try
+        //    try
-            {
+        //    {
-                _logger.LogInformation("Récupération de toutes les games.");
+        //        _logger.LogInformation("Récupération de toutes les games.");
-
+
-                var games = await _dataManager.GetGames();
+        //        var games = await _dataManager.GetGames();
-                if (games == null)
+        //        if (games == null)
-                {
+        //        {
-                    var message = "Aucune game n'a été trouvée.";
+        //            var message = "Aucune game n'a été trouvée.";
-                    _logger.LogWarning(message);
+        //            _logger.LogWarning(message);
-                    return NotFound(new ApiResponse<object>(message));
+        //            return NotFound(new ApiResponse<object>(message));
-                }
+        //        }
-
+
-                var dtoGames = new List<DTOGame>();
+        //        var dtoGames = new List<DTOGame>();
-
+
-                foreach (var game in games)
+        //        foreach (var game in games)
-                {
+        //        {
-                    var winner = await _dataManager.GetPlayer(game.winner);
+        //            var winner = await _dataManager.GetPlayer(game.winner);
-                    var loser = await _dataManager.GetPlayer(game.loser);
+        //            var loser = await _dataManager.GetPlayer(game.loser);
-
+
-                    //ce cas n'est jamais censé arrivé
+        //            //ce cas n'est jamais censé arrivé
-                    if (winner == null || loser == null)
+        //            if (winner == null || loser == null)
-                    {
+        //            {
-                        _logger.LogError($"Le joueur gagnant ou le joueur perdant n'existe pas pour le jeu avec l'identifiant {game.gameId}.");
+        //                _logger.LogError($"Le joueur gagnant ou le joueur perdant n'existe pas pour le jeu avec l'identifiant {game.gameId}.");
-                        continue;
+        //                continue;
-                    }
+        //            }
-
+
-                    dtoGames.Add(game.ToDto());
+        //            dtoGames.Add(game.ToDto());
-                }
+        //        }
-
+
-                _logger.LogInformation("{Count} games ont été récupérées.", dtoGames.Count);
+        //        _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 Ok(new ApiResponse<IEnumerable<DTOGame>>("La récupération des games a réussi.", dtoGames));
-            }
+        //    }
-            catch (Exception ex)
+        //    catch (Exception ex)
-            {
+        //    {
-                var message = "Une erreur est survenue lors de la récupération des données.";
+        //        var message = "Une erreur est survenue lors de la récupération des données.";
-                _logger.LogError(ex, message);
+        //        _logger.LogError(ex, message);
-                return StatusCode(500, new ApiResponse<object>($"{message} {ex.Message}"));
+        //        return StatusCode(500, new ApiResponse<object>($"{message} {ex.Message}"));
-            }
+        //    }
-        }
+        //}
-
+
-        [HttpGet("byPlayer/{id}")]
+        [HttpGet("Player/{id}")]
         public async Task<ActionResult<IEnumerable<DTOGame>>> GetGameByIdPlayer(int id)
         {
             try
@@ -144,12 +144,12 @@ namespace ApiLeapHit.Controllers
                 var winner = await _dataManager.GetPlayer(dtoGame.playerWinner);
                 var loser = await _dataManager.GetPlayer(dtoGame.playerLoser);
 
-                //if (winner == null || loser == null)
+                if (winner == null || loser == null)
-                //{
+                {
-                //    var errorMessage = "Le joueur gagnant ou le joueur perdant n'existe pas pour la partie avec l'identifiant " + dtoGame.gameId + ".";
+                    var errorMessage = "Le joueur gagnant ou le joueur perdant n'existe pas pour la partie avec l'identifiant " + dtoGame.gameId + ".";
-                //    _logger.LogError(errorMessage);
+                    _logger.LogError(errorMessage);
-                //    return NotFound(new ApiResponse<Game>(errorMessage));
+                    return NotFound(new ApiResponse<Game>(errorMessage));
-                //}
+                }
 
                 var game = dtoGame.ToGame();
                 await _dataManager.AddGame(game);

code/server/ApiLeapHit/Controllers/MessageController.cs

@@ -1,130 +0,0 @@
-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;
-
-namespace ApiLeapHit.Controllers
-{
-    [Route("api/[controller]")]
-    [ApiController]
-    public class MessageController : Controller
-    {
-
-        private readonly DbDataManager _dataManager;
-        private readonly ILogger<MessageController> _logger;
-
-        public MessageController(DbDataManager dataManager, ILogger<MessageController> logger)
-        {
-            _dataManager = dataManager;
-            _logger = logger;
-        }
-
-        [HttpPost]
-        public async Task<ActionResult> SendMessage([FromBody] DTOMessage dtoMessage)
-        {
-            try
-            {
-                var player = await _dataManager.GetPlayer(dtoMessage.PlayerId);
-                if (player == null)
-                {
-                    _logger.LogWarning($"Le joueur avec l'identifiant {dtoMessage.PlayerId} n'existe pas.");
-                    return NotFound(new ApiResponse<object>($"Le joueur avec l'identifiant {dtoMessage.PlayerId} n'existe pas."));
-                }
-
-                await _dataManager.SendMessage(dtoMessage.ToMessage());
-
-                _logger.LogInformation($"Le message avec l'identifiant {dtoMessage.messageId} a été envoyé avec succès.");
-                return Ok(new ApiResponse<object>($"Le message avec l'identifiant {dtoMessage.messageId} a été envoyé avec succès."));
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError($"Une erreur est survenue lors de l'envoi du message : {ex.Message}");
-                return StatusCode(500, new ApiResponse<object>($"Une erreur est survenue lors de l'envoi du message : {ex.Message}"));
-            }
-        }
-
-        [HttpDelete("{id}")]
-        public async Task<ActionResult> RemoveMessage(int id)
-        {
-            try
-            {
-                var result = await _dataManager.RemoveMessage(id);
-                if (result)
-                {
-                    _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."));
-                }
-                else
-                {
-                    _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}"));
-            }
-        }
-
-        [HttpGet("{id}")]
-        public async Task<ActionResult<DTOMessage>> ReceiveMessage(int id)
-        {
-            try
-            {
-                var message = await _dataManager.ReceiveMessage(id);
-
-                if (message == null)
-                {
-                    _logger.LogWarning($"Aucun message avec l'idée {id} n'a été trouvé.");
-                    return NotFound(new ApiResponse<object>("Le message n'a pas été trouvé."));
-                }
-
-                //var response = new ApiResponse<DTOMessage>("Joueur ajouté avec succès.");
-                //response.Links.Add(new ApiLink(
-                //    Url.Action("GetPlayer", "Player", new { id = player.playerId }),
-                //    "self",
-                //    "GET"
-                //));
-
-                _logger.LogInformation($"Le message avec l'identifiant {id} a été reçu avec succès.");
-                return Ok(new ApiResponse<DTOMessage>("Message reçu avec succès.", message.ToDto()));
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, $"Une erreur est survenue lors de la récupération du message avec l'id {id}.");
-                return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse<object>($"Une erreur est survenue lors de la récupération du message. : {ex.Message}"));
-            }
-        }
-
-        [HttpGet]
-        public async Task<ActionResult<DTOMessage>> ReceiveAllMessages()
-        {
-            try
-            {
-                var messages = await _dataManager.ReceiveAllMessages();
-
-                if (messages == null || messages.Count() == 0)
-                {
-                    _logger.LogWarning($"Aucun message n'a été trouvé.");
-                    return NotFound(new ApiResponse<object>("Aucun message n'a pas été trouvé."));
-                }
-
-                var dtosMessages = messages.Select(message => message.ToDto()).ToList();
-
-                _logger.LogInformation($"Les messages ont été reçus avec succès.");
-                return Ok(new ApiResponse<List<DTOMessage>>("Messages reçus avec succès.", dtosMessages));
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, $"Une erreur est survenue lors de la récupération des messages.");
-                return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse<object>($"Une erreur est survenue lors de la récupération des messages. : {ex.Message}"));
-            }
-        }
-
-    }
-}

code/server/ApiLeapHit/Controllers/MessagesController.cs

@@ -0,0 +1,132 @@
+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;
+
+namespace ApiLeapHit.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class MessagesController : Controller
+    {
+
+        private readonly DbDataManager _dataManager;
+        private readonly ILogger<MessagesController> _logger;
+
+        public MessagesController(DbDataManager dataManager, ILogger<MessagesController> logger)
+        {
+            _dataManager = dataManager;
+            _logger = logger;
+        }
+
+        [HttpPost]
+        public async Task<ActionResult> SendMessage([FromBody] DTOMessage dtoMessage)
+        {
+            try
+            {
+                var player = await _dataManager.GetPlayer(dtoMessage.PlayerId);
+                if (player == null)
+                {
+                    var message = $"Le joueur avec l'identifiant {dtoMessage.PlayerId} n'existe pas.";
+                    _logger.LogWarning(message);
+                    return StatusCode((int)HttpStatusCode.NotFound, new ApiResponse(message));
+                }
+
+                await _dataManager.SendMessage(dtoMessage.ToMessage());
+
+                var message_success = $"Le message avec l'identifiant {dtoMessage.messageId} a été envoyé avec succès.";
+                _logger.LogInformation(message_success);
+                return StatusCode((int)HttpStatusCode.Created, new ApiResponse(message_success));
+            }
+            catch (Exception ex)
+            {
+                var erroe_message = "Une erreur est survenue lors de l'envoi du message.";
+                _logger.LogError(ex,erroe_message);
+                return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse(erroe_message));
+            }
+        }
+
+        [HttpDelete("{id}")]
+        public async Task<ActionResult> RemoveMessage(int id)
+        {
+            try
+            {
+                var result = await _dataManager.RemoveMessage(id);
+                if (result)
+                {
+                    var message_success = $"Le message avec l'identifiant {id} a été supprimé avec succès.";
+                    _logger.LogInformation(message_success);
+                    return StatusCode((int)HttpStatusCode.OK, new ApiResponse(message_success));
+                }
+                else
+                {
+                    var message = $"Le message avec l'identifiant {id} n'existe pas.";
+                    _logger.LogInformation(message);
+                    return StatusCode((int)HttpStatusCode.BadRequest, new ApiResponse(message));
+                }
+            }
+            catch (Exception ex)
+            {
+                var error_message = $"Une erreur est survenue lors de la suppression du message avec l'identifiant {id}.";
+                _logger.LogError(ex, error_message);
+                return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse(error_message));
+            }
+        }
+
+        [HttpGet("{id}")]
+        public async Task<ActionResult<DTOMessage>> ReceiveMessage(int id)
+        {
+            try
+            {
+                var message = await _dataManager.ReceiveMessage(id);
+
+                if (message == null)
+                {
+                    var message_notFound = $"Aucun message avec l'idée {id} n'a été trouvé.";
+                    _logger.LogInformation(message_notFound);
+                    return StatusCode((int)HttpStatusCode.NotFound, new ApiResponse(message_notFound));
+                }
+
+                var message_success = $"Le message avec l'identifiant {id} a été reçu avec succès.";
+                _logger.LogInformation(message_success);
+                return StatusCode((int)HttpStatusCode.OK, new ApiResponse<DTOMessage>(message_success, message.ToDto()));
+            }
+            catch (Exception ex)
+            {
+                var message_error = $"Une erreur est survenue lors de la récupération du message avec l'id {id}.";
+                _logger.LogError(ex, message_error);
+                return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse(message_error));
+            }
+        }
+
+        //[HttpGet]
+        //public async Task<ActionResult<DTOMessage>> ReceiveAllMessages()
+        //{
+        //    try
+        //    {
+        //        var messages = await _dataManager.ReceiveAllMessages();
+
+        //        if (messages == null || messages.Count() == 0)
+        //        {
+        //            _logger.LogWarning($"Aucun message n'a été trouvé.");
+        //            return NotFound(new ApiResponse("Aucun message n'a pas été trouvé."));
+        //        }
+
+        //        var dtosMessages = messages.Select(message => message.ToDto()).ToList();
+
+        //        _logger.LogInformation($"Les messages ont été reçus avec succès.");
+        //        return Ok(new ApiResponse<List<DTOMessage>>("Messages reçus avec succès.", dtosMessages));
+        //    }
+        //    catch (Exception ex)
+        //    {
+        //        _logger.LogError(ex, $"Une erreur est survenue lors de la récupération des messages.");
+        //        return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse($"Une erreur est survenue lors de la récupération des messages. : {ex.Message}"));
+        //    }
+        //}
+
+    }
+}

code/server/ApiLeapHit/Controllers/PlayerController.cs

@@ -1,218 +0,0 @@
-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;
-
-namespace ApiLeapHit.Controllers
-{
-    [Route("api/[controller]")]
-    [ApiController]
-    public class PlayerController : ControllerBase
-    {
-        private readonly DbDataManager _dataManager;
-        private readonly ILogger<PlayerController> _logger;
-
-        public PlayerController(DbDataManager dataManager, ILogger<PlayerController> logger)
-        {
-            _dataManager = dataManager;
-            _logger = logger;
-        }
-
-        [HttpGet("{id}")]
-        public async Task<ActionResult<ApiResponse<DTOPlayer>>> GetPlayer(int id)
-        {
-            try
-            {
-                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"
-                ));
-
-                return Ok(response);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, $"Une erreur est survenue lors de la récupération du joueur avec l'id {id}.");
-                return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse<object>("Une erreur est survenue lors de la récupération du joueur."));
-            }
-        }
-
-        [HttpPost]
-        public async Task<ActionResult<ApiResponse<object>>> AddPlayer([FromBody] DTOPlayer dtoPlayer)
-        {
-            try
-            {
-               var player = dtoPlayer.ToPlayer();
-
-               await _dataManager.AddPlayer(player);
-
-                var url = Url.Action("GetPlayer", "Player", new { id = 9 });
-
-                // Ajout des liens HATEOAS
-                var response = new ApiResponse<object>("Joueur ajouté avec succès.");
-                response.Links.Add(new ApiLink(
-                    href: url,
-                    "self",
-                    "GET"
-                ));
-
-                var response2 = new ApiResponse<object>("Joueur ajouté avec succès.");
-                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. {ex.Message}"));
-            }
-        }
-
-        [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)
-            {
-                _logger.LogError(ex, "Une erreur est survenue lors de la récupération des joueurs.");
-                return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse<object>("Une erreur est survenue lors de la récupération des joueurs."));
-            }
-        }
-
-        [HttpDelete("{id}")]
-        public async Task<ActionResult> RemovePlayer(int id)
-        {
-            try
-            {
-                var result = await _dataManager.RemovePlayer(id);
-                if (result)
-                {
-                    // 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(new ApiResponse<object>("Joueur non trouvé."));
-            }
-            catch (Exception ex)
-            {
-                _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)
-        {
-            try
-            {
-                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);
-
-                // Ajout des liens HATEOAS
-                var response = new ApiResponse<object>("Joueur mis à jour avec succès.");
-                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"
-                    ));
-
-        
-                return Ok(response);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, $"Une erreur est survenue lors de la modification du joueur avec l'id {id}.");
-                return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse<object>("Une erreur est survenue lors de la modification du joueur."));
-            }
-
-        }
-    }
-}

code/server/ApiLeapHit/Controllers/PlayersController.cs

@@ -0,0 +1,168 @@
+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;
+
+namespace ApiLeapHit.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class PlayersController : ControllerBase
+    {
+        private readonly DbDataManager _dataManager;
+        private readonly ILogger<PlayersController> _logger;
+
+        public PlayersController(DbDataManager dataManager, ILogger<PlayersController> logger)
+        {
+            _dataManager = dataManager;
+            _logger = logger;
+        }
+
+        [HttpPost]
+        public async Task<ActionResult<ApiResponse<string>>> CreatePlayer()
+        {
+            try
+            {
+                var player = new Player();
+                string id;
+                do
+                {
+                    // Générer un id unique avec des chiffres et des lettres
+                    id = Guid.NewGuid().ToString("N");
+                }
+                while (await _dataManager.GetPlayer(id) != null); 
+                player.playerId = id;
+                await _dataManager.AddPlayer(player);
+
+                var response = new ApiResponse<string>($"Le joueur a été créé avec succès. Id du joueur : {id}.", id);
+                return Ok(response);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Une erreur est survenue lors de la création du joueur.");
+                return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse("Une erreur est survenue lors de la création du joueur."));
+            }
+        }
+
+        [HttpGet("{id}")]
+        public async Task<ActionResult<ApiResponse<DTOPlayer>>> GetPlayer(string id)
+        {
+            try
+            {
+                var player = await _dataManager.GetPlayer(id);
+                if (player == null)
+                {
+                    return NotFound(new ApiResponse("Joueur non trouvé."));
+                }
+
+                var response = new ApiResponse<DTOPlayer>($"Le joueur avec l'id {id} a été récupéré avec succès.", player.ToDto());
+
+                return Ok(response);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, $"Une erreur est survenue lors de la récupération du joueur avec l'id {id}.");
+                return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse("Une erreur est survenue lors de la récupération du joueur."));
+            }
+        }
+
+        [HttpPost]
+        public async Task<ActionResult<ApiResponse<object>>> AddPlayer([FromBody] DTOPlayer dtoPlayer)
+        {
+            try
+            {
+                var player = dtoPlayer.ToPlayer();
+
+                await _dataManager.AddPlayer(player);
+
+                var response = new ApiResponse("Joueur ajouté avec succès.");
+                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($"Une erreur est survenue lors de l'ajout du joueur. {ex.Message}"));
+            }
+        }
+
+        //[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);
+
+        //        return Ok(response);
+        //    }
+        //    catch (Exception ex)
+        //    {
+        //        _logger.LogError(ex, "Une erreur est survenue lors de la récupération des joueurs.");
+        //        return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse("Une erreur est survenue lors de la récupération des joueurs."));
+        //    }
+        //}
+
+        [HttpDelete("{id}")]
+        public async Task<ActionResult> RemovePlayer(string id)
+        {
+            try
+            {
+                var result = await _dataManager.RemovePlayer(id);
+                if (result)
+                {
+                    var response = new ApiResponse("Joueur supprimé avec succès.");
+
+                    return Ok(response);
+                }
+                return NotFound(new ApiResponse("Joueur non trouvé."));
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, $"Une erreur est survenue lors de la suppression du joueur avec l'id {id}.");
+                return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse("Une erreur est survenue lors de la suppression du joueur."));
+            }
+        }
+        [HttpPut("{id}")]
+        public async Task<IActionResult> Put(string id, [FromBody] DTOPlayer dtoPlayer)
+        {
+            try
+            {
+                if (!ModelState.IsValid)
+                {
+                    return BadRequest(new ApiResponse("Les données du joueur sont invalides."));
+                }
+
+                var player = dtoPlayer.ToPlayer();
+
+                var playerTest = await _dataManager.GetPlayer(id);
+                if (playerTest == null)
+                {
+                    return NotFound(new ApiResponse("Joueur non trouvé."));
+                }
+
+                await _dataManager.UpdatePlayer(id, player.name);
+
+                var response = new ApiResponse("Joueur mis à jour avec succès.");
+
+                return Ok(response);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, $"Une erreur est survenue lors de la modification du joueur avec l'id {id}.");
+                return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse("Une erreur est survenue lors de la modification du joueur."));
+            }
+
+        }
+    }
+}

code/server/DTO/DTOChat.cs

@@ -9,7 +9,7 @@ namespace DTO
     public class DTOChat
     {
         public int chatId { get; set; }
-        public int PlayerId1 { get; set; }
+        public string PlayerId1 { get; set; }
-        public int PlayerId2 { get; set; }
+        public string PlayerId2 { get; set; }
     }
 }

code/server/DTO/DTOGame.cs

@@ -11,8 +11,8 @@ namespace DTO
         public int gameId { get; set; }
         public int durationGame { get; set; }
         public int nbMaxEchanges { get; set; }
-        public int playerWinner { get; set; }
+        public string playerWinner { get; set; }
-        public int playerLoser { get; set; }
+        public string playerLoser { get; set; }
         public int scoreWinner { get; set; }
         public int scoreLoser { get; set; }
     }

code/server/DTO/DTOGameWithIdPlayer.cs

@@ -11,7 +11,7 @@ namespace DTO
         public int gameId { get; set; }
         public int durationGame { get; set; }
         public int nbMaxEchanges { get; set; }
-        public int playerWinner { get; set; }
+        public string playerWinner { get; set; }
-        public int playerLoser { get; set; }
+        public string playerLoser { get; set; }
     }
 }

code/server/DTO/DTOMessage.cs

@@ -11,7 +11,7 @@ namespace DTO
         public int messageId { get; set; }
         public string message { get; set; }
         public DateTime timestamp { get; set; }
-        public int PlayerId { get; set; }
+        public string PlayerId { get; set; }
         public int ChatId { get; set; }
     }
 }

code/server/DTO/DTOPlayer.cs

@@ -8,7 +8,8 @@ namespace DTO
 {
     public class DTOPlayer
     {
-        public int playerId { get; set; }
+        public string playerId { get; set; }
+        // public string playerIdUniq { get; set; }
         public string name { get; set; }
         public int nbBallTouchTotal { get; set; }
         public int timePlayed { get; set; }

code/server/DTO/Factory/ApiResponse.cs

@@ -20,4 +20,16 @@ namespace DTO.Factory
             Data = data;
         }
     }
+    public class ApiResponse
+    {
+        public string Message { get; set; }
+        public List<ApiLink> Links { get; set; } = new List<ApiLink>();
+
+
+        public ApiResponse(string message)
+        {
+            Message = message;
+        }
+    }
+
 }

code/server/DataBase/Context/PongDbContextWithStub.cs

@@ -15,18 +15,18 @@ namespace DataBase.Context
         {
             base.OnModelCreating(modelBuilder);
 
-            Player player1 = new() { playerId = 1, name = "Rami", timePlayed = 120, nbBallTouchTotal = 20 };
+            Player player1 = new() { playerId = "test", name = "Rami", timePlayed = 120, nbBallTouchTotal = 20 };
-            Player player2 = new() { playerId = 2, name = "Hugo", timePlayed = 250, nbBallTouchTotal = 90 };
+            Player player2 = new() { playerId = "test2", name = "Hugo", timePlayed = 250, nbBallTouchTotal = 90 };
             modelBuilder.Entity<Player>().HasData(player1, player2);
 
-            Game game = new() { gameId = 1, durationGame = 65, nbMaxEchanges = 5, winner = 1, loser = 2, scoreLoser = 2, scoreWinner = 6};
+            Game game = new() { gameId = 1, durationGame = 65, nbMaxEchanges = 5, winner = "test", loser = "test2", scoreLoser = 2, scoreWinner = 6};
             modelBuilder.Entity<Game>().HasData(game);
 
-            Chat chat = new() { chatId = 1, player1 = 1, player2 = 2 };
+            Chat chat = new() { chatId = 1, player1 = "test", player2 = "test2" };
             modelBuilder.Entity<Chat>().HasData(chat);
 
-            Message message1 = new() { messageId = 1, message = "Salut mon gars !", player = 1, timestamp = new DateTime(2023, 02, 16, 17, 05, 12), chat = 1 };
+            Message message1 = new() { messageId = 1, message = "Salut mon gars !", player = "test", timestamp = new DateTime(2023, 02, 16, 17, 05, 12), chat = 1 };
-            Message message2 = new() { messageId = 2, message = "Comment tu vas ?", player = 2, timestamp = new DateTime(2023, 02, 16, 17, 12, 35), chat = 1 };
+            Message message2 = new() { messageId = 2, message = "Comment tu vas ?", player = "test2", timestamp = new DateTime(2023, 02, 16, 17, 12, 35), chat = 1 };
             modelBuilder.Entity<Message>().HasData(message1, message2);
         }
     }

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

@@ -21,16 +21,23 @@ namespace DataBase.DataManager
 
         public async Task<bool> RemoveChat(int id)
         {
-            using (var context = new PongDbContext())
+            try
             {
-                var chat = context.Chats.Where(c => c.chatId == id).ToList().FirstOrDefault();
+                using (var context = new PongDbContext())
-                if (chat != null)
                 {
-                    var result = context.Chats.Remove(chat);
+                    var chat = context.Chats.Where(c => c.chatId == id).ToList().FirstOrDefault();
-                    await context.SaveChangesAsync();
+                    if (chat != null)
-                    return result != null;
+                    {
+                        var result = context.Chats.Remove(chat);
+                        await context.SaveChangesAsync();
+                        return result != null;
+                    }
+                    return false;
                 }
-                return false;
+            }
+            catch (Exception ex)
+            {
+                throw;
             }
         }
 
@@ -51,7 +58,7 @@ namespace DataBase.DataManager
             }
         }
 
-        public Task<List<Chat>> GetChatsByIdPlayer(int id)
+        public Task<List<Chat>> GetChatsByIdPlayer(string id)
         {
             using (var context = new PongDbContext())
             {
@@ -60,7 +67,7 @@ namespace DataBase.DataManager
             }
         }
 
-        public Task<List<Chat>> GetChatsByIdPlayers(int idPlayer1, int idPlayer2)
+        public Task<List<Chat>> GetChatsByIdPlayers(string idPlayer1, string idPlayer2)
         {
             using (var context = new PongDbContext())
             {
@@ -69,5 +76,13 @@ namespace DataBase.DataManager
             }
         }
 
+        public Task<int> GetNbChats()
+        {
+            using (var context = new PongDbContext())
+            {
+                var nbchats = context.Chats.ToList().Count();
+                return Task.FromResult(nbchats);
+            }
+        }
     }
 }

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

@@ -43,7 +43,7 @@ namespace DataBase.DataManager
             }
         }
 
-        public Task<List<Game>> GetGameById(int id)
+        public Task<List<Game>> GetGameById(string id)
         {
             using (var context = new PongDbContext())
             {

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

@@ -52,5 +52,14 @@ namespace DataBase.DataManager
                 return Task.FromResult(messages);
             }
         }
+
+        public Task<int> GetNbMessages()
+        {
+            using (var context = new PongDbContext())
+            {
+                var nbmessages = context.Messages.ToList().Count();
+                return Task.FromResult(nbmessages);
+            }
+        }
     }
 }

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

@@ -21,7 +21,7 @@ namespace DataBase.DataManager
             }
         }
 
-        public async Task<bool> RemovePlayer(int id)
+        public async Task<bool> RemovePlayer(string id)
         {
             using (var context = new PongDbContext())
             {
@@ -36,7 +36,7 @@ namespace DataBase.DataManager
             }
         }
 
-        public async Task<Player> UpdatePlayer(int id, string newName)
+        public async Task<Player> UpdatePlayer(string id, string newName)
         {
             using (var context = new PongDbContext())
             {
@@ -50,7 +50,7 @@ namespace DataBase.DataManager
             }
         }
 
-        public Task<Player> GetPlayer(int id) 
+        public Task<Player> GetPlayer(string id) 
         {
             using (var context = new PongDbContext())
             {
@@ -67,5 +67,14 @@ namespace DataBase.DataManager
                 return Task.FromResult(players);
             }
         }
+
+        public Task<int> GetNbPlayers()
+        {
+            using (var context = new PongDbContext())
+            {
+                var nbplayers = context.Players.ToList().Count();
+                return Task.FromResult(nbplayers);
+            }
+        }
     }
 }

code/server/DataBase/Entity/Chat.cs

@@ -6,8 +6,8 @@ namespace DataBase.Entity
     public class Chat
     {
         public int chatId { get; set; }
-        public int player1 { get; set; }
+        public string player1 { get; set; }
-        public int player2 { get; set; }
+        public string player2 { get; set; }
 
         [ForeignKey("player1")]
         public Player PlayerId1 { get; set; }

code/server/DataBase/Entity/Game.cs

@@ -9,8 +9,8 @@ namespace DataBase.Entity
         public int gameId { get; set; }
         public int durationGame { get; set; }
         public int nbMaxEchanges { get; set; }
-        public int winner { get; set; }
+        public string winner { get; set; }
-        public int loser { get; set; }
+        public string loser { get; set; }
 
         public int scoreWinner { get; set; }
 

code/server/DataBase/Entity/Message.cs

@@ -9,7 +9,7 @@ namespace DataBase.Entity
         public int messageId { get; set; }
         public string message { get; set; }
         public DateTime timestamp { get; set; }
-        public int player { get; set; }
+        public string player { get; set; }
         public int chat { get; set; }
 
         [ForeignKey("player")]

code/server/DataBase/Entity/Player.cs

@@ -5,7 +5,7 @@ namespace DataBase.Entity
 {
     public class Player
     {
-        public int playerId { get; set; }
+        public string playerId { get; set; }
         public string name { get; set; }
         public int nbBallTouchTotal { get; set; }
         public int timePlayed { get; set; }

code/server/TestControleurs/UnitTestChats.cs

@@ -0,0 +1,165 @@
+using ApiLeapHit.Controllers;
+using DataBase.DataManager;
+using DataBase.Entity;
+using DTO;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TestControleurs
+{
+    [TestClass]
+    public class UnitTestChats
+    {
+        private  DbDataManager _dataManager = new DbDataManager(); 
+        private readonly ILogger<ChatsController> _logger = new NullLogger<ChatsController>();
+
+        [TestMethod]
+        public async Task AddChat_ReturnsOkResult_WhenChatIsAdded()
+        {
+            // Arrange
+            var player1 = new Player { playerId = 1, name = "Player1" };
+            var player2 = new Player { playerId = 2, name = "Player2" };
+            var dtoChat = new DTOChat { PlayerId1 = player1.playerId, PlayerId2 = player2.playerId };
+            var controller = new ChatsController(_dataManager, _logger);
+
+            // Act
+            var result = await controller.AddChat(dtoChat);
+            var objectResult = result as ObjectResult;
+
+            // Assert
+            Assert.IsNotNull(objectResult);
+            Assert.AreEqual((int)HttpStatusCode.OK, objectResult.StatusCode);
+        }
+
+        [TestMethod]
+        public async Task AddChat_ReturnsBadRequestResult()
+        {
+            // Arrange
+            var nb = await _dataManager.GetNbChats();
+            var dtoChat = new DTOChat { PlayerId1 = 1, PlayerId2 = nb+10 };
+            var controller = new ChatsController(_dataManager, _logger);
+
+            // Act
+            var result = await controller.AddChat(dtoChat);
+            var objectResult = result as ObjectResult;
+
+            // Assert
+            Assert.IsNotNull(objectResult);
+            Assert.AreEqual((int)HttpStatusCode.BadRequest, objectResult.StatusCode);
+        }
+
+        [TestMethod]
+        public async Task GetChats_ReturnsOkResult()
+        {
+            // Arrange
+            var controller = new ChatsController(_dataManager, _logger);
+
+            // Act
+            var result = await controller.GetChats();
+            var objectResult = (ObjectResult)result.Result;
+            var dtoChats = objectResult.Value as IEnumerable<DTOChat>;
+
+            // Assert
+            Assert.IsNotNull(objectResult);
+            Assert.AreEqual((int)HttpStatusCode.OK, objectResult.StatusCode);
+        }
+    
+
+        //[TestMethod]
+        //public async Task GetChats_ReturnsNotFoundResult()
+        //{
+        //    // Arrange
+        //    var mockDataManager = new Mock<DbDataManager>();
+        //    mockDataManager.Setup(dm => dm.GetChats()).ReturnsAsync(new List<Chat>());
+        //    var controller = new ChatsController(mockDataManager.Object, _logger);
+
+        //    // Act
+        //    var result = await controller.GetChats();
+        //    var objectResult = (ObjectResult)result.Result;
+
+        //    // Assert
+        //    Assert.IsNotNull(objectResult);
+        //    Assert.AreEqual((int)HttpStatusCode.NotFound, objectResult.StatusCode);
+        //}
+
+        [TestMethod]
+        public async Task GetChatById_ReturnsOkResult()
+        {
+            // Arrange
+            var chat = new Chat { chatId = 1, player1 = 1, player2 = 2 };
+            var controller = new ChatsController(_dataManager, _logger);
+
+            // Act
+            var result = await controller.GetChatById(chat.chatId);
+            var objectResult = result.Result as ObjectResult;
+            var dtoChat = objectResult.Value as DTOChat;
+
+            // Assert
+            Assert.IsNotNull(objectResult);
+            Assert.AreEqual((int)HttpStatusCode.OK, objectResult.StatusCode);
+            Assert.IsNotNull(dtoChat);
+            Assert.AreEqual(chat.chatId, dtoChat.chatId);
+        }
+
+        [TestMethod]
+        public async Task GetChatById_ReturnsNotFoundResult()
+        {
+            // Arrange
+            var chatId = 1000;
+            var controller = new ChatsController(_dataManager, _logger);
+
+            // Act
+            var result = await controller.GetChatById(chatId);
+            var objectResult = result.Result as ObjectResult;
+
+            // Assert
+            Assert.IsNotNull(objectResult);
+            Assert.AreEqual((int)HttpStatusCode.NotFound, objectResult.StatusCode);
+        }
+
+        [TestMethod]
+        public async Task RemoveChat_ReturnsOkResult()
+        {
+            // Arrange
+            var nb = await _dataManager.GetNbChats();
+            var chat = new Chat { chatId = nb+1, player1 = 1, player2 = 2 };
+            await _dataManager.AddChat(chat);
+            var controller = new ChatsController(_dataManager, _logger);
+
+            // Act
+            var result = await controller.RemoveChat(chat.chatId);
+            var objectResult = result as ObjectResult;
+
+            // Assert
+            Assert.IsNotNull(objectResult);
+            Assert.AreEqual((int)HttpStatusCode.OK, objectResult.StatusCode);
+        }
+
+        [TestMethod]
+        public async Task RemoveChat_ReturnsNotFoundResult()
+        {
+            // Arrange
+            var chatId = 1000;
+            var controller = new ChatsController(_dataManager, _logger);
+
+            // Act
+            var result = await controller.RemoveChat(chatId);
+            var objectResult = result as ObjectResult;
+
+            // Assert
+            Assert.IsNotNull(objectResult);
+            Assert.AreEqual((int)HttpStatusCode.NotFound, objectResult.StatusCode);
+        }
+
+    }
+}

code/server/TestControleurs/UnitTestGames.cs

@@ -7,6 +7,7 @@ using DTO;
 using DTO.Factory;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Moq;
 using System.Net;
@@ -18,28 +19,140 @@ namespace TestControleurs
     [TestClass]
     public class UnitTestGames
     {
+        private DbDataManager _dataManager = new DbDataManager();
+        private readonly ILogger<GamesController> _logger = new NullLogger<GamesController>();
+
+        [TestMethod]
+        public async Task GetGame_ReturnsOkResult()
+        {
+            // Arrange
+            var controller = new GamesController(_dataManager, _logger);
+            var nb = _dataManager.GetNbGames();
+            var testGame = new Game { gameId = nb.Result + 1, durationGame = 3, loser = 1, winner = 2, nbMaxEchanges = 33, scoreLoser = 5, scoreWinner = 6 };
+            await _dataManager.AddGame(testGame);
+
+            // Act
+            var result = await controller.GetGame(nb.Result + 1);
+            var objectResult = (ObjectResult)result.Result;
+
+            // Assert
+            Assert.IsNotNull(objectResult);
+            Assert.AreEqual((int)HttpStatusCode.OK, objectResult.StatusCode);
+        }
+
+        [TestMethod]
+        public async Task GetGame_ReturnsNotFoundResult()
+        {
+            // Arrange
+            var controller = new GamesController(_dataManager, _logger);
+            var nb = _dataManager.GetNbGames();
+
+            // Act
+            var result = await controller.GetGame(nb.Result + 1);
+            var objectResult = (ObjectResult)result.Result;
+
+            // Assert
+            Assert.IsNotNull(objectResult);
+            Assert.AreEqual((int)HttpStatusCode.NotFound, objectResult.StatusCode);
+        }
+
+        [TestMethod]
+        public async Task RemoveGame_ReturnsNotFoundResult()
+        {
+            // Arrange
+            var controller = new GamesController(_dataManager, _logger);
+            var nb = _dataManager.GetNbGames();
+
+            // Act
+            var result = await controller.RemoveGame(nb.Result + 1);
+            var objectResult = (ObjectResult)result;
+
+            // Assert
+            Assert.IsNotNull(objectResult);
+            Assert.AreEqual((int)HttpStatusCode.NotFound, objectResult.StatusCode);
+        }
+
         [TestMethod]
-        public async Task TestGetPlayer_ValidId()
+        public async Task RemoveGame_ReturnsOKResult()
         {
             // Arrange
-            int id = 9;
+            var controller = new GamesController(_dataManager, _logger);
-            var mockDataManager = new Mock<DbDataManager>();
+            var nb = _dataManager.GetNbGames();
-            var mockLogger = new Mock<ILogger<PlayerController>>();
+            var testGame = new Game { gameId = nb.Result + 1, durationGame = 3, loser = 1, winner = 2, nbMaxEchanges = 33, scoreLoser = 5, scoreWinner = 6 }; 
-            var player = new Player { playerId = id, name = "Test Player", nbBallTouchTotal = 0, timePlayed = 3 };
+            await _dataManager.AddGame(testGame);
-            var controller = new PlayerController(mockDataManager.Object, mockLogger.Object);
+
+            // Act
+            var result = await controller.RemoveGame(nb.Result + 1);
+            var objectResult = (ObjectResult)result;
 
-            var rep = await controller.AddPlayer(player.ToDto());
+            // Assert
+            Assert.IsNotNull(objectResult);
+            Assert.AreEqual((int)HttpStatusCode.OK, objectResult.StatusCode);
+        }
+
+        [TestMethod]
+        public async Task GetGameByIdPlayer_ReturnsOKResult()
+        {
+            // Arrange
+            var controller = new GamesController(_dataManager, _logger);
+            var nb = _dataManager.GetNbGames();
+            var nbP = _dataManager.GetNbPlayers();
+            var testGame = new Game { gameId = nb.Result + 1, durationGame = 3, loser = nbP.Result, winner = 2, nbMaxEchanges = 33, scoreLoser = 5, scoreWinner = 6 };
+            await _dataManager.AddGame(testGame);
 
             // Act
-            var result = await controller.GetPlayer(id);
+            var result = await controller.GetGameByIdPlayer(nbP.Result);
             var objectResult = (ObjectResult)result.Result;
-            var apiResponse = objectResult.Value as ApiResponse<DTOPlayer>;
 
             // Assert
             Assert.IsNotNull(objectResult);
             Assert.AreEqual((int)HttpStatusCode.OK, objectResult.StatusCode);
-            Assert.AreEqual(apiResponse.Data.playerId, id);
         }
 
+        [TestMethod]
+        public async Task GetGameByIdPlayer_ReturnsNotFoundResult()
+        {
+            // Arrange
+            var controller = new GamesController(_dataManager, _logger);
+            var nb = _dataManager.GetNbPlayers();
+
+            // Act
+            var result = await controller.GetGameByIdPlayer(nb.Result + 1);
+            var objectResult = (ObjectResult)result.Result;
+
+            // Assert
+            Assert.IsNotNull(objectResult);
+            Assert.AreEqual((int)HttpStatusCode.NotFound, objectResult.StatusCode);
+        }
+
+        //[HttpPost]
+        //public async Task<ActionResult> AddGame([FromBody] DTOGame dtoGame)
+        //{
+        //    try
+        //    {
+        //        var winner = await _dataManager.GetPlayer(dtoGame.playerWinner);
+        //        var loser = await _dataManager.GetPlayer(dtoGame.playerLoser);
+
+        //        if (winner == null || loser == null)
+        //        {
+        //            var errorMessage = "Le joueur gagnant ou le joueur perdant n'existe pas pour la partie avec l'identifiant " + dtoGame.gameId + ".";
+        //            _logger.LogError(errorMessage);
+        //            return NotFound(new ApiResponse<Game>(errorMessage));
+        //        }
+
+        //        var game = dtoGame.ToGame();
+        //        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)
+        //    {
+        //        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));
+        //    }
+        //}
     }
 }

code/server/TestControleurs/UnitTestMessages.cs

@@ -0,0 +1,129 @@
+using ApiLeapHit.Controllers;
+using ApiLeapHit.Mapper;
+using DataBase.DataManager;
+using DataBase.Entity;
+using DTO;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TestControleurs
+{
+    [TestClass]
+    public class UnitTestMessages
+    {
+        private DbDataManager _dataManager = new DbDataManager();
+        private readonly ILogger<MessagesController> _logger = new NullLogger<MessagesController>();
+
+        [TestMethod]
+        public async Task ReceiveMessage_ReturnsOkResult()
+        {
+            // Arrange
+            var controller = new MessagesController(_dataManager, _logger);
+            var nb = _dataManager.GetNbMessages();
+            var testMessage = new Message { messageId = nb.Result+1, message = "Test message", timestamp = new DateTime(2023, 3, 10, 14, 30, 0, DateTimeKind.Utc), player = 1 , chat =1};
+            await _dataManager.SendMessage(testMessage);
+
+            // Act
+            var result = await controller.ReceiveMessage(1);
+            var objectResult = (ObjectResult)result.Result;
+
+            // Assert
+            Assert.IsNotNull(objectResult);
+            Assert.AreEqual((int)HttpStatusCode.OK, objectResult.StatusCode);
+        }
+
+        [TestMethod]
+        public async Task ReceiveMessage_ReturnsNotFound()
+        {
+            // Arrange
+            var controller = new MessagesController(_dataManager, _logger);
+            var nb = _dataManager.GetNbMessages();
+
+            // Act
+            var result = await controller.ReceiveMessage(nb.Result+1);
+            var objectResult = (ObjectResult)result.Result;
+
+            // Assert
+            Assert.IsNotNull(objectResult);
+            Assert.AreEqual((int)HttpStatusCode.NotFound, objectResult.StatusCode);
+        }
+
+        [TestMethod]
+        public async Task RemoveMessage_ReturnsBadRequest()
+        {
+            // Arrange
+            var controller = new MessagesController(_dataManager, _logger);
+            var nb = _dataManager.GetNbMessages();
+
+            // Act
+            var result = await controller.RemoveMessage(nb.Result + 1);
+            var objectResult = (ObjectResult)result;
+
+            // Assert
+            Assert.IsNotNull(objectResult);
+            Assert.AreEqual((int)HttpStatusCode.BadRequest, objectResult.StatusCode);
+        }
+
+        [TestMethod]
+        public async Task RemoveMessage_ReturnsOk()
+        {
+            // Arrange
+            var controller = new MessagesController(_dataManager, _logger);
+            var nb = _dataManager.GetNbMessages();
+            var testMessage = new Message { messageId = nb.Result + 1, message = "Test message", timestamp = new DateTime(2023, 3, 10, 14, 30, 0, DateTimeKind.Utc), player = 1, chat = 1 };
+
+            // Act
+            var result = await controller.RemoveMessage(nb.Result + 1);
+            var objectResult = (ObjectResult)result;
+
+            // Assert
+            Assert.IsNotNull(objectResult);
+            Assert.AreEqual((int)HttpStatusCode.BadRequest, objectResult.StatusCode);
+        }
+
+        [TestMethod]
+        public async Task SendMessage_ReturnsCreated()
+        {
+            // Arrange
+            var controller = new MessagesController(_dataManager, _logger);
+            var nb = _dataManager.GetNbMessages();
+            var testMessage = new DTOMessage { messageId = nb.Result + 1, message = "Test message", timestamp = new DateTime(2023, 3, 10, 14, 30, 0, DateTimeKind.Utc), PlayerId = 1, ChatId = 1 };
+
+            // Act
+            var result = await controller.SendMessage(testMessage);
+            var objectResult = (ObjectResult)result;
+
+            // Assert
+            Assert.IsNotNull(objectResult);
+            Assert.AreEqual((int)HttpStatusCode.Created, objectResult.StatusCode);
+            await controller.RemoveMessage(nb.Result + 1);
+        }
+
+        [TestMethod]
+        public async Task SendMessage_ReturnsNotFound()
+        {
+            // Arrange
+            var controller = new MessagesController(_dataManager, _logger);
+            var nb = _dataManager.GetNbMessages();
+            var nbP = _dataManager.GetNbPlayers();
+            var testMessage = new DTOMessage { messageId = nb.Result + 1, message = "Test message", timestamp = new DateTime(2023, 3, 10, 14, 30, 0, DateTimeKind.Utc), PlayerId = nb.Result+1, ChatId = 1 };
+
+            // Act
+            var result = await controller.SendMessage(testMessage);
+            var objectResult = (ObjectResult)result;
+
+            // Assert
+            Assert.IsNotNull(objectResult);
+            Assert.AreEqual((int)HttpStatusCode.NotFound, objectResult.StatusCode);
+            await controller.RemoveMessage(nb.Result + 1);
+        }
+    }
+}

code/server/TestControleurs/UnitTestPlayers.cs

@@ -0,0 +1,40 @@
+using ApiLeapHit.Controllers;
+using DataBase.DataManager;
+using DataBase.Entity;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TestControleurs
+{
+    [TestClass]
+    public class UnitTestPlayers
+    {
+        private DbDataManager _dataManager = new DbDataManager();
+        private readonly ILogger<PlayersController> _logger = new NullLogger<PlayersController>();
+
+        //[TestMethod]
+        //public async Task GetPlayer_ReturnsOkResult()
+        //{
+        //    // Arrange
+        //    var playerId = 1;
+
+        //    var player = new Player() { Id = playerId, Name = "John Doe" };
+        //    _mockDataManager.Setup(dm => dm.GetPlayer(playerId)).ReturnsAsync(player);
+
+        //    // Act
+        //    var result = await _controller.GetPlayer(playerId);
+
+        //    // Assert
+        //    Assert.IsInstanceOfType(result, typeof(OkObjectResult));
+        //    var apiResponse = ((OkObjectResult)result).Value as ApiResponse<DTOPlayer>;
+        //    Assert.IsNotNull(apiResponse);
+        //}
+    }
+}