.drone.yml

@@ -10,8 +10,8 @@ steps:
     - name: build-docker-image
       image: plugins/docker
       settings:
-          dockerfile: code/Dockerfile
+          dockerfile: code/server/Dockerfile
-          context: code/
+          context: code/server
           registry: hub.codefirst.iut.uca.fr
           repo: hub.codefirst.iut.uca.fr/leap-hit-team/leap-hit-server
           username:

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(string 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(string idPlayer1, string 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,57 +51,58 @@ 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)
+        public async Task<ActionResult<IEnumerable<DTOGame>>> GetGameByIdPlayer(string id)
         {
             try
             {
                 var games = await _dataManager.GetGameById(id);
 
                 if (games == null || games.Count == 0)
+
                 {
                     var message = $"Aucune game trouvée pour le joueur avec l'id {id}.";
                     _logger.LogInformation(message);
@@ -144,12 +145,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,216 +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> AddPlayer([FromBody] DTOPlayer dtoPlayer)
-        {
-            try
-            {
-               var player = dtoPlayer.ToPlayer();
-
-               await _dataManager.AddPlayer(player);
-
-                // Ajout des liens HATEOAS
-                var response = new ApiResponse<DTOPlayer>("Joueur ajouté avec succès.");
-                response.Links.Add(new ApiLink(
-                    Url.Action("GetPlayer", "Player", new { id = player.playerId }),
-                    "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,172 @@
+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;
+        }
+
+        [HttpGet("/clePlayer/{idIdentification}")]
+        public async Task<ActionResult<ApiResponse<string>>> CreatePlayer(string idIdentification)
+        {
+            try
+            {
+                if(!idIdentification.Equals("K02q7naLzjmodzAFfoSO4mPydr7W5hydPMrHtA6D"))
+                {
+                    return StatusCode((int)HttpStatusCode.NotFound, new ApiResponse("Le numéo n'est pas correct."));
+                }
+                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/ApiLeapHit/Mapper/GameMapper.cs

@@ -14,8 +14,8 @@ namespace ApiLeapHit.Mapper
                 nbMaxEchanges = game.nbMaxEchanges,
                 playerWinner = game.winner,
                 playerLoser = game.loser,
-                scoreLoser = game.loser,
+                scoreLoser = game.scoreLoser,
-                scoreWinner = game.winner
+                scoreWinner = game.scoreWinner
             };
             return dtoGame;
         }

code/server/ApiLeapHit/Mapper/PlayerMapper.cs

@@ -23,7 +23,7 @@ namespace ApiLeapHit.Mapper
             {
                 playerId = dtoPlayer.playerId,
                 name = dtoPlayer.name,
-                nbBallTouchTotal = dtoPlayer.nbBallTouchTotal,
+                nbBallTouchTotal = dtoPlayer.nbBallTouchTotal,  
                 timePlayed = dtoPlayer.timePlayed
             };
         }

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

@@ -11,8 +11,7 @@ namespace DTO.Factory
     {
         public string Message { get; set; }
         public T Data { get; set; }
-        public List<ApiLink> Links { get;  set; }
+        public List<ApiLink> Links { get; set; } = new List<ApiLink>();
-        private List<ApiLink> links = new();
 
 
         public ApiResponse(string message, T data = default)
@@ -21,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/PongDbContext.cs

@@ -1,5 +1,7 @@
 using DataBase.Entity;
 using Microsoft.EntityFrameworkCore;
+using System.Diagnostics;
+using System.Reflection;
 
 namespace DataBase.Context
 {
@@ -19,8 +21,19 @@ namespace DataBase.Context
 
             if (!optionsBuilder.IsConfigured)
             {
-                optionsBuilder.UseSqlite($"Data Source=C:\\Users\\noanr\\source\\repos\\leap-hit-server\\code\\server\\DataBase\\PongDB.db");
+                //optionsBuilder.UseNpgsql(@"host=localhost;database=postgres;user id=postgres;password=1234;");
+                string path = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "..\\..\\..\\..\\DataBase\\PongDB.db");
+                optionsBuilder.UseSqlite($"Data Source={path}");
+
             }
         }
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<Player>().ToTable("Players");
+            modelBuilder.Entity<Game>().ToTable("Games");
+            modelBuilder.Entity<Message>().ToTable("Messages");
+            modelBuilder.Entity<Chat>().ToTable("Chats");
+
+        }
     }
 }

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/DataBase/Migrations/20230316103854_mymigrations.Designer.cs

@@ -10,9 +10,9 @@ using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
 
 namespace DataBase.Migrations
 {
-    [DbContext(typeof(PongDbContextWithStub))]
+    [DbContext(typeof(PongDbContext))]
-    [Migration("20230228121953_Migrations")]
+    [Migration("20230316103854_mymigrations")]
-    partial class Migrations
+    partial class mymigrations
     {
         /// <inheritdoc />
         protected override void BuildTargetModel(ModelBuilder modelBuilder)
@@ -26,11 +26,13 @@ namespace DataBase.Migrations
                         .ValueGeneratedOnAdd()
                         .HasColumnType("INTEGER");
 
-                    b.Property<int>("player1")
+                    b.Property<string>("player1")
-                        .HasColumnType("INTEGER");
+                        .IsRequired()
+                        .HasColumnType("TEXT");
 
-                    b.Property<int>("player2")
+                    b.Property<string>("player2")
-                        .HasColumnType("INTEGER");
+                        .IsRequired()
+                        .HasColumnType("TEXT");
 
                     b.HasKey("chatId");
 
@@ -38,15 +40,7 @@ namespace DataBase.Migrations
 
                     b.HasIndex("player2");
 
-                    b.ToTable("Chats");
+                    b.ToTable("Chats", (string)null);
-
-                    b.HasData(
-                        new
-                        {
-                            chatId = 1,
-                            player1 = 1,
-                            player2 = 2
-                        });
                 });
 
             modelBuilder.Entity("DataBase.Entity.Game", b =>
@@ -58,8 +52,9 @@ namespace DataBase.Migrations
                     b.Property<int>("durationGame")
                         .HasColumnType("INTEGER");
 
-                    b.Property<int>("loser")
+                    b.Property<string>("loser")
-                        .HasColumnType("INTEGER");
+                        .IsRequired()
+                        .HasColumnType("TEXT");
 
                     b.Property<int>("nbMaxEchanges")
                         .HasColumnType("INTEGER");
@@ -70,8 +65,9 @@ namespace DataBase.Migrations
                     b.Property<int>("scoreWinner")
                         .HasColumnType("INTEGER");
 
-                    b.Property<int>("winner")
+                    b.Property<string>("winner")
-                        .HasColumnType("INTEGER");
+                        .IsRequired()
+                        .HasColumnType("TEXT");
 
                     b.HasKey("gameId");
 
@@ -79,19 +75,7 @@ namespace DataBase.Migrations
 
                     b.HasIndex("winner");
 
-                    b.ToTable("Games");
+                    b.ToTable("Games", (string)null);
-
-                    b.HasData(
-                        new
-                        {
-                            gameId = 1,
-                            durationGame = 65,
-                            loser = 2,
-                            nbMaxEchanges = 5,
-                            scoreLoser = 2,
-                            scoreWinner = 6,
-                            winner = 1
-                        });
                 });
 
             modelBuilder.Entity("DataBase.Entity.Message", b =>
@@ -107,8 +91,9 @@ namespace DataBase.Migrations
                         .IsRequired()
                         .HasColumnType("TEXT");
 
-                    b.Property<int>("player")
+                    b.Property<string>("player")
-                        .HasColumnType("INTEGER");
+                        .IsRequired()
+                        .HasColumnType("TEXT");
 
                     b.Property<DateTime>("timestamp")
                         .HasColumnType("TEXT");
@@ -119,32 +104,13 @@ namespace DataBase.Migrations
 
                     b.HasIndex("player");
 
-                    b.ToTable("Messages");
+                    b.ToTable("Messages", (string)null);
-
-                    b.HasData(
-                        new
-                        {
-                            messageId = 1,
-                            chat = 1,
-                            message = "Salut mon gars !",
-                            player = 1,
-                            timestamp = new DateTime(2023, 2, 16, 17, 5, 12, 0, DateTimeKind.Unspecified)
-                        },
-                        new
-                        {
-                            messageId = 2,
-                            chat = 1,
-                            message = "Comment tu vas ?",
-                            player = 2,
-                            timestamp = new DateTime(2023, 2, 16, 17, 12, 35, 0, DateTimeKind.Unspecified)
-                        });
                 });
 
             modelBuilder.Entity("DataBase.Entity.Player", b =>
                 {
-                    b.Property<int>("playerId")
+                    b.Property<string>("playerId")
-                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
-                        .HasColumnType("INTEGER");
 
                     b.Property<string>("name")
                         .IsRequired()
@@ -158,23 +124,7 @@ namespace DataBase.Migrations
 
                     b.HasKey("playerId");
 
-                    b.ToTable("Players");
+                    b.ToTable("Players", (string)null);
-
-                    b.HasData(
-                        new
-                        {
-                            playerId = 1,
-                            name = "Rami",
-                            nbBallTouchTotal = 20,
-                            timePlayed = 120
-                        },
-                        new
-                        {
-                            playerId = 2,
-                            name = "Hugo",
-                            nbBallTouchTotal = 90,
-                            timePlayed = 250
-                        });
                 });
 
             modelBuilder.Entity("DataBase.Entity.Chat", b =>

code/server/DataBase/Migrations/20230316103854_mymigrations.cs

@@ -3,12 +3,10 @@ using Microsoft.EntityFrameworkCore.Migrations;
 
 #nullable disable
 
-#pragma warning disable CA1814 // Prefer jagged arrays over multidimensional
-
 namespace DataBase.Migrations
 {
     /// <inheritdoc />
-    public partial class Migrations : Migration
+    public partial class mymigrations : Migration
     {
         /// <inheritdoc />
         protected override void Up(MigrationBuilder migrationBuilder)
@@ -17,8 +15,7 @@ namespace DataBase.Migrations
                 name: "Players",
                 columns: table => new
                 {
-                    playerId = table.Column<int>(type: "INTEGER", nullable: false)
+                    playerId = table.Column<string>(type: "TEXT", nullable: false),
-                        .Annotation("Sqlite:Autoincrement", true),
                     name = table.Column<string>(type: "TEXT", nullable: false),
                     nbBallTouchTotal = table.Column<int>(type: "INTEGER", nullable: false),
                     timePlayed = table.Column<int>(type: "INTEGER", nullable: false)
@@ -34,8 +31,8 @@ namespace DataBase.Migrations
                 {
                     chatId = table.Column<int>(type: "INTEGER", nullable: false)
                         .Annotation("Sqlite:Autoincrement", true),
-                    player1 = table.Column<int>(type: "INTEGER", nullable: false),
+                    player1 = table.Column<string>(type: "TEXT", nullable: false),
-                    player2 = table.Column<int>(type: "INTEGER", nullable: false)
+                    player2 = table.Column<string>(type: "TEXT", nullable: false)
                 },
                 constraints: table =>
                 {
@@ -62,8 +59,8 @@ namespace DataBase.Migrations
                         .Annotation("Sqlite:Autoincrement", true),
                     durationGame = table.Column<int>(type: "INTEGER", nullable: false),
                     nbMaxEchanges = table.Column<int>(type: "INTEGER", nullable: false),
-                    winner = table.Column<int>(type: "INTEGER", nullable: false),
+                    winner = table.Column<string>(type: "TEXT", nullable: false),
-                    loser = table.Column<int>(type: "INTEGER", nullable: false),
+                    loser = table.Column<string>(type: "TEXT", nullable: false),
                     scoreWinner = table.Column<int>(type: "INTEGER", nullable: false),
                     scoreLoser = table.Column<int>(type: "INTEGER", nullable: false)
                 },
@@ -92,7 +89,7 @@ namespace DataBase.Migrations
                         .Annotation("Sqlite:Autoincrement", true),
                     message = table.Column<string>(type: "TEXT", nullable: false),
                     timestamp = table.Column<DateTime>(type: "TEXT", nullable: false),
-                    player = table.Column<int>(type: "INTEGER", nullable: false),
+                    player = table.Column<string>(type: "TEXT", nullable: false),
                     chat = table.Column<int>(type: "INTEGER", nullable: false)
                 },
                 constraints: table =>
@@ -112,34 +109,6 @@ namespace DataBase.Migrations
                         onDelete: ReferentialAction.Cascade);
                 });
 
-            migrationBuilder.InsertData(
-                table: "Players",
-                columns: new[] { "playerId", "name", "nbBallTouchTotal", "timePlayed" },
-                values: new object[,]
-                {
-                    { 1, "Rami", 20, 120 },
-                    { 2, "Hugo", 90, 250 }
-                });
-
-            migrationBuilder.InsertData(
-                table: "Chats",
-                columns: new[] { "chatId", "player1", "player2" },
-                values: new object[] { 1, 1, 2 });
-
-            migrationBuilder.InsertData(
-                table: "Games",
-                columns: new[] { "gameId", "durationGame", "loser", "nbMaxEchanges", "scoreLoser", "scoreWinner", "winner" },
-                values: new object[] { 1, 65, 2, 5, 2, 6, 1 });
-
-            migrationBuilder.InsertData(
-                table: "Messages",
-                columns: new[] { "messageId", "chat", "message", "player", "timestamp" },
-                values: new object[,]
-                {
-                    { 1, 1, "Salut mon gars !", 1, new DateTime(2023, 2, 16, 17, 5, 12, 0, DateTimeKind.Unspecified) },
-                    { 2, 1, "Comment tu vas ?", 2, new DateTime(2023, 2, 16, 17, 12, 35, 0, DateTimeKind.Unspecified) }
-                });
-
             migrationBuilder.CreateIndex(
                 name: "IX_Chats_player1",
                 table: "Chats",

code/server/DataBase/Migrations/PongDbContextModelSnapshot.cs

@@ -9,8 +9,8 @@ using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
 
 namespace DataBase.Migrations
 {
-    [DbContext(typeof(PongDbContextWithStub))]
+    [DbContext(typeof(PongDbContext))]
-    partial class PongDbContextWithStubModelSnapshot : ModelSnapshot
+    partial class PongDbContextModelSnapshot : ModelSnapshot
     {
         protected override void BuildModel(ModelBuilder modelBuilder)
         {
@@ -23,11 +23,13 @@ namespace DataBase.Migrations
                         .ValueGeneratedOnAdd()
                         .HasColumnType("INTEGER");
 
-                    b.Property<int>("player1")
+                    b.Property<string>("player1")
-                        .HasColumnType("INTEGER");
+                        .IsRequired()
+                        .HasColumnType("TEXT");
 
-                    b.Property<int>("player2")
+                    b.Property<string>("player2")
-                        .HasColumnType("INTEGER");
+                        .IsRequired()
+                        .HasColumnType("TEXT");
 
                     b.HasKey("chatId");
 
@@ -35,15 +37,7 @@ namespace DataBase.Migrations
 
                     b.HasIndex("player2");
 
-                    b.ToTable("Chats");
+                    b.ToTable("Chats", (string)null);
-
-                    b.HasData(
-                        new
-                        {
-                            chatId = 1,
-                            player1 = 1,
-                            player2 = 2
-                        });
                 });
 
             modelBuilder.Entity("DataBase.Entity.Game", b =>
@@ -55,8 +49,9 @@ namespace DataBase.Migrations
                     b.Property<int>("durationGame")
                         .HasColumnType("INTEGER");
 
-                    b.Property<int>("loser")
+                    b.Property<string>("loser")
-                        .HasColumnType("INTEGER");
+                        .IsRequired()
+                        .HasColumnType("TEXT");
 
                     b.Property<int>("nbMaxEchanges")
                         .HasColumnType("INTEGER");
@@ -67,8 +62,9 @@ namespace DataBase.Migrations
                     b.Property<int>("scoreWinner")
                         .HasColumnType("INTEGER");
 
-                    b.Property<int>("winner")
+                    b.Property<string>("winner")
-                        .HasColumnType("INTEGER");
+                        .IsRequired()
+                        .HasColumnType("TEXT");
 
                     b.HasKey("gameId");
 
@@ -76,19 +72,7 @@ namespace DataBase.Migrations
 
                     b.HasIndex("winner");
 
-                    b.ToTable("Games");
+                    b.ToTable("Games", (string)null);
-
-                    b.HasData(
-                        new
-                        {
-                            gameId = 1,
-                            durationGame = 65,
-                            loser = 2,
-                            nbMaxEchanges = 5,
-                            scoreLoser = 2,
-                            scoreWinner = 6,
-                            winner = 1
-                        });
                 });
 
             modelBuilder.Entity("DataBase.Entity.Message", b =>
@@ -104,8 +88,9 @@ namespace DataBase.Migrations
                         .IsRequired()
                         .HasColumnType("TEXT");
 
-                    b.Property<int>("player")
+                    b.Property<string>("player")
-                        .HasColumnType("INTEGER");
+                        .IsRequired()
+                        .HasColumnType("TEXT");
 
                     b.Property<DateTime>("timestamp")
                         .HasColumnType("TEXT");
@@ -116,32 +101,13 @@ namespace DataBase.Migrations
 
                     b.HasIndex("player");
 
-                    b.ToTable("Messages");
+                    b.ToTable("Messages", (string)null);
-
-                    b.HasData(
-                        new
-                        {
-                            messageId = 1,
-                            chat = 1,
-                            message = "Salut mon gars !",
-                            player = 1,
-                            timestamp = new DateTime(2023, 2, 16, 17, 5, 12, 0, DateTimeKind.Unspecified)
-                        },
-                        new
-                        {
-                            messageId = 2,
-                            chat = 1,
-                            message = "Comment tu vas ?",
-                            player = 2,
-                            timestamp = new DateTime(2023, 2, 16, 17, 12, 35, 0, DateTimeKind.Unspecified)
-                        });
                 });
 
             modelBuilder.Entity("DataBase.Entity.Player", b =>
                 {
-                    b.Property<int>("playerId")
+                    b.Property<string>("playerId")
-                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
-                        .HasColumnType("INTEGER");
 
                     b.Property<string>("name")
                         .IsRequired()
@@ -155,23 +121,7 @@ namespace DataBase.Migrations
 
                     b.HasKey("playerId");
 
-                    b.ToTable("Players");
+                    b.ToTable("Players", (string)null);
-
-                    b.HasData(
-                        new
-                        {
-                            playerId = 1,
-                            name = "Rami",
-                            nbBallTouchTotal = 20,
-                            timePlayed = 120
-                        },
-                        new
-                        {
-                            playerId = 2,
-                            name = "Hugo",
-                            nbBallTouchTotal = 90,
-                            timePlayed = 250
-                        });
                 });
 
             modelBuilder.Entity("DataBase.Entity.Chat", b =>

code/server/Server/Program.cs

@@ -1,21 +1,21 @@
-using System;
+using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
-using System.Net;
+using System.Net;
-using System.Net.Sockets;
+using System.Net.Sockets;
-using System.Text;
+using System.Text;
-using System.Threading;
+using System.Threading;
-using DataBase.Entity;
+using DataBase.Entity;
-using Shared.DTO;
+using Shared.DTO;
-using System.Text.Json;
+using System.Text.Json;
-using Server;
+using Server;
-
+
-class Program
+class Program
-{
+{
-    static void Main(string[] args)
+    static void Main(string[] args)
-    {
+    {
-        PongServer server = new PongServer();
+        PongServer server = new PongServer();
-        Console.WriteLine("Welcome to LeapHit Multiplayer - Server");
+        Console.WriteLine("Welcome to LeapHit Multiplayer - Server");
-        server.StartServer();
+        server.StartServer();
-    }
+    }
-
+
 }

code/server/Server/Server.csproj

@@ -1,15 +1,15 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
-
+
-	<PropertyGroup>
+	<PropertyGroup>
-		<OutputType>Exe</OutputType>
+		<OutputType>Exe</OutputType>
-		<TargetFramework>net6.0</TargetFramework>
+		<TargetFramework>net6.0</TargetFramework>
-		<ImplicitUsings>enable</ImplicitUsings>
+		<ImplicitUsings>enable</ImplicitUsings>
-		<Nullable>enable</Nullable>
+		<Nullable>enable</Nullable>
-	</PropertyGroup>
+	</PropertyGroup>
-
+
-	<ItemGroup>
+	<ItemGroup>
-		<ProjectReference Include="..\DataBase\DataBase.csproj" />
+		<ProjectReference Include="..\DataBase\DataBase.csproj" />
-		<ProjectReference Include="..\Shared\Shared.csproj" />
+		<ProjectReference Include="..\Shared\Shared.csproj" />
-	</ItemGroup>
+	</ItemGroup>
-
+
 </Project>

code/server/TestControleurs/TestControleurs.csproj

@@ -9,6 +9,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
+    <PackageReference Include="Moq" Version="4.18.4" />
     <PackageReference Include="MSTest.TestAdapter" Version="2.2.7" />
     <PackageReference Include="MSTest.TestFramework" Version="2.2.7" />
     <PackageReference Include="coverlet.collector" Version="3.1.0" />

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,7 +7,9 @@ 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;
 using System.Text.Json;
 using System.Threading.Tasks;
@@ -17,30 +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 TestGetPlayer_ValidId()
+        public async Task GetGame_ReturnsOkResult()
         {
             // Arrange
-            int id = 8;
+            var controller = new GamesController(_dataManager, _logger);
-            DbDataManager dataManager = new DbDataManager();
+            var nb = _dataManager.GetNbGames();
-            ILoggerFactory loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
+            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(dataManager, loggerFactory.CreateLogger<PlayerController>());
 
+            // Act
+            var result = await controller.GetGame(nb.Result + 1);
+            var objectResult = (ObjectResult)result.Result;
 
-            var rep = await controller.AddPlayer(player.ToDto());
+            // 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.GetPlayer(id);
+            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 RemoveGame_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.RemoveGame(nb.Result + 1);
+            var objectResult = (ObjectResult)result;
+
+            // 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.GetGameByIdPlayer(nbP.Result);
             var objectResult = (ObjectResult)result.Result;
-            var apiResponse = (ApiResponse<DTOPlayer>)objectResult.Value;
 
             // 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);
+        //}
+    }
+}