Merge pull request 'Api' (#1) from Api into master

Reviewed-on: #1

code/server/ApiLeapHit/ApiLeapHit.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="7.0.0" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.2.3" />
+    <PackageReference Include="System.Configuration.ConfigurationManager" Version="7.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\DataBase\DataBase.csproj" />
+    <ProjectReference Include="..\DTO\DTO.csproj" />
+  </ItemGroup>
+
+</Project>

code/server/ApiLeapHit/Controllers/ChatController.cs

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

code/server/ApiLeapHit/Controllers/GameController.cs

@@ -0,0 +1,194 @@
+using ApiLeapHit.Mapper;
+using DataBase.DataManager;
+using DataBase.Entity;
+using DTO;
+using DTO.Factory;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using System.Diagnostics;
+using System.Net;
+using System.Text;
+
+namespace ApiLeapHit.Controllers
+{
+    [Route("api/[controller]")]
+    [ApiController]
+    public class GameController : ControllerBase
+    {
+        private readonly DbDataManager _dataManager;
+
+        private readonly ILogger<GameController> _logger;
+
+        public GameController(DbDataManager dataManager, ILogger<GameController> logger)
+        {
+            _dataManager = dataManager;
+            _logger = logger;
+        }
+
+        [HttpGet("{id}")]
+        public async Task<ActionResult<DTOGame>> GetGame(int id)
+        {
+            try
+            {
+                _logger.LogInformation("Récupération de la game avec l'identifiant {id}", id);
+
+                var game = await _dataManager.GetGame(id);
+                if (game == null)
+                {
+                    var message = $"La game avec l'identifiant {id} n'existe pas";
+                    _logger.LogWarning(message);
+                    return NotFound(new ApiResponse<object>(message));
+                }
+
+                _logger.LogInformation("Récupération des joueurs pour la game avec l'identifiant {id}", id);
+
+                return Ok(new ApiResponse<DTOGame>("Récupération de la game réussie.", game.ToDto()));
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, $"Une erreur est survenue lors de la récupération des données pour la game avec l'identifiant {id}");
+                return StatusCode(500, new ApiResponse<object>($"Une erreur est survenue lors de la récupération des données : {ex.Message}"));
+            }
+        }
+
+        [HttpGet]
+        public async Task<ActionResult<IEnumerable<DTOGame>>> GetGames()
+        {
+            try
+            {
+                _logger.LogInformation("Récupération de toutes les games.");
+
+                var games = await _dataManager.GetGames();
+                if (games == null)
+                {
+                    var message = "Aucune game n'a été trouvée.";
+                    _logger.LogWarning(message);
+                    return NotFound(new ApiResponse<object>(message));
+                }
+
+                var dtoGames = new List<DTOGame>();
+
+                foreach (var game in games)
+                {
+                    var winner = await _dataManager.GetPlayer(game.winner);
+                    var loser = await _dataManager.GetPlayer(game.loser);
+
+                    //ce cas n'est jamais censé arrivé
+                    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}.");
+                        continue;
+                    }
+
+                    dtoGames.Add(game.ToDto());
+                }
+
+                _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));
+            }
+            catch (Exception ex)
+            {
+                var message = "Une erreur est survenue lors de la récupération des données.";
+                _logger.LogError(ex, message);
+                return StatusCode(500, new ApiResponse<object>($"{message} {ex.Message}"));
+            }
+        }
+
+        [HttpGet("byPlayer/{id}")]
+        public async Task<ActionResult<IEnumerable<DTOGame>>> GetGameByIdPlayer(int id)
+        {
+            try
+            {
+                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);
+                    return NotFound(new ApiResponse<object>(message));
+                }
+
+                var dtoGames = new List<DTOGame>();
+
+                foreach (var game in games)
+                {
+                    var winner = await _dataManager.GetPlayer(game.winner);
+                    var loser = await _dataManager.GetPlayer(game.loser);
+
+                    //ce cas n'est jamais censé arrivé
+                    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}.");
+                        continue;
+                    }
+                    dtoGames.Add(game.ToDto());
+                }
+
+                var successMessage = $"Récupération réussie des games pour le joueur avec l'id {id}.";
+                _logger.LogInformation(successMessage);
+                return Ok(new ApiResponse<IEnumerable<DTOGame>>(successMessage, dtoGames));
+            }
+            catch (Exception ex)
+            {
+                var errorMessage = $"Une erreur est survenue lors de la récupération des games pour le joueur avec l'id {id}.";
+                _logger.LogError(errorMessage + " Error message: " + ex.Message);
+                return StatusCode(500, new ApiResponse<object>(errorMessage));
+            }
+        }
+
+        [HttpPost]
+        public async Task<ActionResult> AddGame([FromBody] 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));
+            }
+        }
+
+        [HttpDelete("{id}")]
+        public async Task<ActionResult> RemoveGame(int id)
+        {
+            try
+            {
+                var result = await _dataManager.RemoveGame(id);
+                if (result)
+                {
+                    var successMessage = $"La game avec l'identifiant {id} a été supprimée avec succès.";
+                    _logger.LogInformation(successMessage);
+                    return Ok(new ApiResponse<object>(successMessage));
+                }
+
+                var notFoundMessage = $"La game avec l'identifiant {id} n'existe pas.";
+                _logger.LogInformation(notFoundMessage);
+                return NotFound(new ApiResponse<object>(notFoundMessage));
+            }
+            catch (Exception ex)
+            {
+                var errorMessage = $"Une erreur est survenue lors de la suppression de la game avec l'identifiant {id} : {ex.Message}";
+                _logger.LogError(errorMessage);
+                return StatusCode(500, new ApiResponse<object>(errorMessage));
+            }
+        }
+    }
+}

code/server/ApiLeapHit/Controllers/MessageController.cs

@@ -0,0 +1,123 @@
+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é."));
+                }
+
+                _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/PlayerController.cs

@@ -0,0 +1,215 @@
+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<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<object>("Joueur ajouté avec succès.");
+                response.Links.Add(new ApiLink(
+                    Url.Action("GetPlayer", "Player", new { id = player.playerId }),
+                    "self",
+                    "GET"
+                ));
+
+                return Ok(response);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Une erreur est survenue lors de l'ajout du joueur.");
+                return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse<object>("Une erreur est survenue lors de l'ajout du joueur."));
+            }
+        }
+
+        [HttpGet]
+        public async Task<ActionResult<IEnumerable<DTOPlayer>>> GetPlayers()
+        {
+            try
+            {
+                var players = await _dataManager.GetPlayers();
+                if (players == null || players.Count() == 0)
+                {
+                    return NotFound(new ApiResponse<IEnumerable<DTOPlayer>>("Aucun joueur trouvé."));
+                }
+
+                var dtoPlayers = players.Select(p => p.ToDto()).ToList();
+
+                var response = new ApiResponse<IEnumerable<DTOPlayer>>($"La récupération des players a réussi. Nombre de players : {dtoPlayers.Count}", dtoPlayers);
+
+                // Ajout des liens HATEOAS
+                response.Links.Add(new ApiLink(
+                    Url.Action("GetPlayers", "Player"),
+                    "self",
+                    "GET"
+                ));
+                response.Links.Add(new ApiLink(
+                    Url.Action("AddPlayer", "Player"),
+                    "create",
+                    "POST"
+                ));
+
+                foreach (var player in dtoPlayers)
+                {
+                    response.Links.Add(new ApiLink(
+                        Url.Action("GetPlayer", "Player", new { id = player.playerId }),
+                        "get_player",
+                        "GET"
+                    ));
+                    response.Links.Add(new ApiLink(
+                        Url.Action("RemovePlayer", "Player", new { id = player.playerId }),
+                        "delete_player",
+                        "DELETE"
+                    ));
+                    response.Links.Add(new ApiLink(
+                        Url.Action("Put", "Player", new { id = player.playerId }),
+                        "update_player",
+                        "PUT"
+                    ));
+                }
+
+                return Ok(response);
+            }
+            catch (Exception ex)
+            {
+                _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/IDataManager.cs

@@ -0,0 +1,3 @@
+internal interface IDataManager
+{
+}

code/server/ApiLeapHit/Mapper/ChatMapper.cs

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

code/server/ApiLeapHit/Mapper/GameMapper.cs

@@ -0,0 +1,32 @@
+using DataBase.Entity;
+using DTO;
+
+namespace ApiLeapHit.Mapper
+{
+    public static class GameMapper
+    {
+        public static DTOGame ToDto(this Game game)
+        {
+            DTOGame dtoGame = new DTOGame()
+            {
+                gameId = game.gameId,
+                durationGame = game.durationGame,
+                nbMaxEchanges = game.nbMaxEchanges,
+                playerWinner = game.winner,
+                playerLoser = game.loser
+            };
+            return dtoGame;
+        }
+
+        public static Game ToGame(this DTOGame dtoGame)
+        {
+            return new Game
+            {
+                durationGame = dtoGame.durationGame,
+                nbMaxEchanges = dtoGame.nbMaxEchanges,
+                winner = dtoGame.playerWinner,
+                loser = dtoGame.playerLoser
+            };
+        }
+    }
+}

code/server/ApiLeapHit/Mapper/GameWithIdPlayerMapper.cs

@@ -0,0 +1,19 @@
+using DataBase.Entity;
+using DTO;
+
+namespace ApiLeapHit.Mapper
+{
+    public static class GameWithIdPlayerMapper
+    {
+        public static Game ToGame(this DTOGameWithIdPlayer dtoGame, Player winner, Player loser)
+        {
+            return new Game
+            {
+                durationGame = dtoGame.durationGame,
+                nbMaxEchanges = dtoGame.nbMaxEchanges,
+                winner = winner.playerId,
+                loser = loser.playerId
+            };
+        }
+    }
+}

code/server/ApiLeapHit/Mapper/MessageMapper.cs

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

code/server/ApiLeapHit/Mapper/PlayerMapper.cs

@@ -0,0 +1,31 @@
+using DataBase.Entity;
+using DTO;
+
+namespace ApiLeapHit.Mapper
+{
+    public static class PlayerMapper
+    {
+        public static DTOPlayer ToDto(this Player player)
+        {
+            DTOPlayer dtoPlayer = new DTOPlayer()
+            {
+                playerId = player.playerId,
+                name = player.name,
+                nbBallTouchTotal = player.nbBallTouchTotal,
+                timePlayed = player.timePlayed
+            };
+            return dtoPlayer;
+        }
+
+        public static Player ToPlayer(this DTOPlayer dtoPlayer)
+        {
+            return new Player
+            {
+                playerId = dtoPlayer.playerId,
+                name = dtoPlayer.name,
+                nbBallTouchTotal = dtoPlayer.nbBallTouchTotal,
+                timePlayed = dtoPlayer.timePlayed
+            };
+        }
+    }
+}

code/server/ApiLeapHit/Program.cs

@@ -0,0 +1,32 @@
+using DataBase.DataManager;
+using Microsoft.Extensions.Logging;
+
+var builder = WebApplication.CreateBuilder(args);
+
+// Add services to the container.
+builder.Services.AddControllers();
+// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
+builder.Services.AddEndpointsApiExplorer();
+builder.Services.AddSwaggerGen();
+builder.Services.AddScoped<DbDataManager>();
+//builder.Services.AddSingleton<IDataManager, StubData>();
+
+// Add logging
+builder.Logging.AddConsole();
+
+var app = builder.Build();
+
+// Configure the HTTP request pipeline.
+if (app.Environment.IsDevelopment())
+{
+    app.UseSwagger();
+    app.UseSwaggerUI();
+}
+
+app.UseHttpsRedirection();
+
+app.UseAuthorization();
+
+app.MapControllers();
+
+app.Run();

code/server/ApiLeapHit/Properties/launchSettings.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "https://json.schemastore.org/launchsettings.json",
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:33994",
+      "sslPort": 44350
+    }
+  },
+  "profiles": {
+    "ApiLeapHit": {
+      "commandName": "Project",
+      "dotnetRunMessages": true,
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "applicationUrl": "https://localhost:7153;http://localhost:5153",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

code/server/ApiLeapHit/appsettings.Development.json

@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  }
+}

code/server/ApiLeapHit/appsettings.json

@@ -0,0 +1,18 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information"
+    },
+    "Console": {
+      "IncludeScopes": true,
+      "LogLevel": {
+        "Default": "Debug",
+        "System": "Information",
+        "Microsoft": "Information"
+      }
+    }
+  },
+  "AllowedHosts": "*"
+}

code/server/DTO/DTO.csproj

@@ -0,0 +1,10 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>

code/server/DTO/DTOChat.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DTO
+{
+    public class DTOChat
+    {
+        public int chatId { get; set; }
+        public int PlayerId1 { get; set; }
+        public int PlayerId2 { get; set; }
+    }
+}

code/server/DTO/DTOGame.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DTO
+{
+    public class DTOGame
+    {
+        public int gameId { get; set; }
+        public int durationGame { get; set; }
+        public int nbMaxEchanges { get; set; }
+        public int playerWinner { get; set; }
+        public int playerLoser { get; set; }
+    }
+}

code/server/DTO/DTOGameWithIdPlayer.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DTO
+{
+    public class DTOGameWithIdPlayer
+    {
+        public int gameId { get; set; }
+        public int durationGame { get; set; }
+        public int nbMaxEchanges { get; set; }
+        public int playerWinner { get; set; }
+        public int playerLoser { get; set; }
+    }
+}

code/server/DTO/DTOMessage.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DTO
+{
+    public class DTOMessage
+    {
+        public int messageId { get; set; }
+        public string message { get; set; }
+        public DateTime timestamp { get; set; }
+        public int PlayerId { get; set; }
+        public int ChatId { get; set; }
+    }
+}

code/server/DTO/DTOPlayer.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DTO
+{
+    public class DTOPlayer
+    {
+        public int playerId { get; set; }
+        public string name { get; set; }
+        public int nbBallTouchTotal { get; set; }
+        public int timePlayed { get; set; }
+    }
+}

code/server/DTO/Factory/ApiLink.cs

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

code/server/DTO/Factory/ApiResponse.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace DTO.Factory
+{
+    public class ApiResponse<T>
+    {
+        public string Message { get; set; }
+        public T Data { get; set; }
+        public List<ApiLink> Links { get; set; } = new List<ApiLink>();
+
+
+        public ApiResponse(string message, T data = default)
+        {
+            Message = message;
+            Data = data;
+        }
+    }
+}

code/server/DTO/Program.cs

@@ -0,0 +1,2 @@
+// See https://aka.ms/new-console-template for more information
+Console.WriteLine("Hello, World!");

code/server/DataBase/Context/PongDbContext.cs

@@ -19,7 +19,7 @@ namespace DataBase.Context
 
             if (!optionsBuilder.IsConfigured)
             {
-                optionsBuilder.UseSqlite($"Data Source=PongDB.db");
+                optionsBuilder.UseSqlite($"Data Source=../DataBase/PongDB.db");
             }
         }
     }

code/server/DataBase/DataBase.csproj

@@ -5,6 +5,7 @@
     <TargetFramework>net6.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+	<StartWorkingDirectory>$(MSBuildProjectDirectory)</StartWorkingDirectory>
   </PropertyGroup>
 
   <ItemGroup>

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

@@ -15,10 +15,11 @@ namespace DataBase.DataManager
             using (var context = new PongDbContext())
             {
                 await context.Chats.AddAsync(chat);
+                await context.SaveChangesAsync();
             }
         }
 
-        public Task<bool> RemoveChat(int id)
+        public async Task<bool> RemoveChat(int id)
         {
             using (var context = new PongDbContext())
             {
@@ -26,10 +27,47 @@ namespace DataBase.DataManager
                 if (chat != null)
                 {
                     var result = context.Chats.Remove(chat);
-                    return Task.FromResult(result != null);
+                    await context.SaveChangesAsync();
+                    return result != null;
                 }
-                return Task.FromResult(false);
+                return false;
             }
         }
+
+        public Task<List<Chat>> GetChats()
+        {
+            using (var context = new PongDbContext())
+            {
+                var chats = context.Chats.ToList();
+                return Task.FromResult(chats);
+            }
+        }
+        public Task<Chat> GetChat(int id)
+        {
+            using (var context = new PongDbContext())
+            {
+                var chat = context.Chats.Where(g => g.chatId == id).ToList().FirstOrDefault();
+                return Task.FromResult<Chat>(chat);
+            }
+        }
+
+        public Task<List<Chat>> GetChatsByIdPlayer(int id)
+        {
+            using (var context = new PongDbContext())
+            {
+                var chats = context.Chats.Where(g => g.player1 == id || g.player2 == id).ToList();
+                return Task.FromResult(chats);
+            }
+        }
+
+        public Task<List<Chat>> GetChatsByIdPlayers(int idPlayer1, int idPlayer2)
+        {
+            using (var context = new PongDbContext())
+            {
+                var chats = context.Chats.Where(g => (g.player1 == idPlayer1 && g.player2 == idPlayer2) || (g.player1 == idPlayer2 && g.player2 == idPlayer1)).ToList();
+                return Task.FromResult(chats);
+            }
+        }
+
     }
 }

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

@@ -15,10 +15,11 @@ namespace DataBase.DataManager
             using (var context = new PongDbContext())
             {
                 await context.Games.AddAsync(game);
+                await context.SaveChangesAsync();
             }
         }
 
-        public Task<bool> RemoveGame(int id)
+        public async Task<bool> RemoveGame(int id)
         {
             using (var context = new PongDbContext())
             {
@@ -26,9 +27,10 @@ namespace DataBase.DataManager
                 if (game != null)
                 {
                     var result = context.Games.Remove(game);
-                    return Task.FromResult(result != null);
+                    await context.SaveChangesAsync();
+                    return result != null;
                 }
-                return Task.FromResult(false);
+                return false;
             }
         }
 
@@ -40,5 +42,32 @@ namespace DataBase.DataManager
                 return Task.FromResult<Game>(game);
             }
         }
+
+        public Task<List<Game>> GetGameById(int id)
+        {
+            using (var context = new PongDbContext())
+            {
+                var games = context.Games.Where(g => g.winner == id || g.loser == id).ToList();
+                return Task.FromResult(games);
+            }
+        }
+
+        public Task<List<Game>> GetGames()
+        {
+            using (var context = new PongDbContext())
+            {
+                var games = context.Games.ToList();
+                return Task.FromResult(games);
+            }
+        }
+
+        public Task<int> GetNbGames()
+        {
+            using (var context = new PongDbContext())
+            {
+                var nbgames = context.Games.ToList().Count();
+                return Task.FromResult(nbgames);
+            }
+        }
     }
 }

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

@@ -16,6 +16,7 @@ namespace DataBase.DataManager
             using (var context = new PongDbContext())
             {
                 await context.Messages.AddAsync(message);
+                await context.SaveChangesAsync();
             }
         }
 
@@ -28,7 +29,7 @@ namespace DataBase.DataManager
             }
         }
 
-        public Task<bool> RemoveMessage(int id)
+        public async Task<bool> RemoveMessage(int id)
         {
             using (var context = new PongDbContext())
             {
@@ -36,9 +37,19 @@ namespace DataBase.DataManager
                 if (message != null)
                 {
                     var result = context.Messages.Remove(message);
-                    return Task.FromResult(result != null);
+                    await context.SaveChangesAsync();
+                    return result != null;
                 }
-                return Task.FromResult(false);
+                return false;
+            }
+        }
+
+        public Task<List<Message>> ReceiveAllMessages()
+        {
+            using (var context = new PongDbContext())
+            {
+                var messages = context.Messages.ToList();
+                return Task.FromResult(messages);
             }
         }
     }

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

@@ -17,10 +17,11 @@ namespace DataBase.DataManager
             using (var context = new PongDbContext())
             {
                 await context.Players.AddAsync(player);
+                await context.SaveChangesAsync();
             }
         }
 
-        public Task<bool> RemovePlayer(int id)
+        public async Task<bool> RemovePlayer(int id)
         {
             using (var context = new PongDbContext())
             {
@@ -28,13 +29,14 @@ namespace DataBase.DataManager
                 if (player != null) 
                 { 
                     var result = context.Players.Remove(player);
-                    return Task.FromResult(result != null);
+                    await context.SaveChangesAsync();
+                    return result != null;
                 }
-                return Task.FromResult(false);
+                return false;
             }
         }
 
-        public Task<Player> UpdatePlayer(int id, string newName)
+        public async Task<Player> UpdatePlayer(int id, string newName)
         {
             using (var context = new PongDbContext())
             {
@@ -43,7 +45,8 @@ namespace DataBase.DataManager
                 {
                     player.name = newName;
                 }
-                return Task.FromResult<Player>(player);
+                await   context.SaveChangesAsync();
+                return player;
             }
         }
 
@@ -55,5 +58,14 @@ namespace DataBase.DataManager
                 return Task.FromResult<Player>(player);
             }
         }
+
+        public Task<List<Player>> GetPlayers()
+        {
+            using (var context = new PongDbContext())
+            {
+                var players = context.Players.ToList();
+                return Task.FromResult(players);
+            }
+        }
     }
 }

code/server/DataBase/Migrations/20230222115848_mymigration.Designer.cs

@@ -11,8 +11,8 @@ using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
 namespace DataBase.Migrations
 {
     [DbContext(typeof(PongDbContextWithStub))]
-    [Migration("20230216161314_initMigration")]
-    partial class initMigration
+    [Migration("20230222115848_mymigration")]
+    partial class mymigration
     {
         /// <inheritdoc />
         protected override void BuildTargetModel(ModelBuilder modelBuilder)
@@ -38,7 +38,7 @@ namespace DataBase.Migrations
 
                     b.HasIndex("player2");
 
-                    b.ToTable("Chat");
+                    b.ToTable("Chats");
 
                     b.HasData(
                         new
@@ -73,7 +73,7 @@ namespace DataBase.Migrations
 
                     b.HasIndex("winner");
 
-                    b.ToTable("Game");
+                    b.ToTable("Games");
 
                     b.HasData(
                         new
@@ -111,7 +111,7 @@ namespace DataBase.Migrations
 
                     b.HasIndex("player");
 
-                    b.ToTable("Message");
+                    b.ToTable("Messages");
 
                     b.HasData(
                         new
@@ -150,7 +150,7 @@ namespace DataBase.Migrations
 
                     b.HasKey("playerId");
 
-                    b.ToTable("Player");
+                    b.ToTable("Players");
 
                     b.HasData(
                         new

code/server/DataBase/Migrations/20230222115848_mymigration.cs

@@ -8,13 +8,13 @@ using Microsoft.EntityFrameworkCore.Migrations;
 namespace DataBase.Migrations
 {
     /// <inheritdoc />
-    public partial class initMigration : Migration
+    public partial class mymigration : Migration
     {
         /// <inheritdoc />
         protected override void Up(MigrationBuilder migrationBuilder)
         {
             migrationBuilder.CreateTable(
-                name: "Player",
+                name: "Players",
                 columns: table => new
                 {
                     playerId = table.Column<int>(type: "INTEGER", nullable: false)
@@ -25,11 +25,11 @@ namespace DataBase.Migrations
                 },
                 constraints: table =>
                 {
-                    table.PrimaryKey("PK_Player", x => x.playerId);
+                    table.PrimaryKey("PK_Players", x => x.playerId);
                 });
 
             migrationBuilder.CreateTable(
-                name: "Chat",
+                name: "Chats",
                 columns: table => new
                 {
                     chatId = table.Column<int>(type: "INTEGER", nullable: false)
@@ -39,23 +39,23 @@ namespace DataBase.Migrations
                 },
                 constraints: table =>
                 {
-                    table.PrimaryKey("PK_Chat", x => x.chatId);
+                    table.PrimaryKey("PK_Chats", x => x.chatId);
                     table.ForeignKey(
-                        name: "FK_Chat_Player_player1",
+                        name: "FK_Chats_Players_player1",
                         column: x => x.player1,
-                        principalTable: "Player",
+                        principalTable: "Players",
                         principalColumn: "playerId",
                         onDelete: ReferentialAction.Cascade);
                     table.ForeignKey(
-                        name: "FK_Chat_Player_player2",
+                        name: "FK_Chats_Players_player2",
                         column: x => x.player2,
-                        principalTable: "Player",
+                        principalTable: "Players",
                         principalColumn: "playerId",
                         onDelete: ReferentialAction.Cascade);
                 });
 
             migrationBuilder.CreateTable(
-                name: "Game",
+                name: "Games",
                 columns: table => new
                 {
                     gameId = table.Column<int>(type: "INTEGER", nullable: false)
@@ -67,23 +67,23 @@ namespace DataBase.Migrations
                 },
                 constraints: table =>
                 {
-                    table.PrimaryKey("PK_Game", x => x.gameId);
+                    table.PrimaryKey("PK_Games", x => x.gameId);
                     table.ForeignKey(
-                        name: "FK_Game_Player_loser",
+                        name: "FK_Games_Players_loser",
                         column: x => x.loser,
-                        principalTable: "Player",
+                        principalTable: "Players",
                         principalColumn: "playerId",
                         onDelete: ReferentialAction.Cascade);
                     table.ForeignKey(
-                        name: "FK_Game_Player_winner",
+                        name: "FK_Games_Players_winner",
                         column: x => x.winner,
-                        principalTable: "Player",
+                        principalTable: "Players",
                         principalColumn: "playerId",
                         onDelete: ReferentialAction.Cascade);
                 });
 
             migrationBuilder.CreateTable(
-                name: "Message",
+                name: "Messages",
                 columns: table => new
                 {
                     messageId = table.Column<int>(type: "INTEGER", nullable: false)
@@ -95,23 +95,23 @@ namespace DataBase.Migrations
                 },
                 constraints: table =>
                 {
-                    table.PrimaryKey("PK_Message", x => x.messageId);
+                    table.PrimaryKey("PK_Messages", x => x.messageId);
                     table.ForeignKey(
-                        name: "FK_Message_Chat_chat",
+                        name: "FK_Messages_Chats_chat",
                         column: x => x.chat,
-                        principalTable: "Chat",
+                        principalTable: "Chats",
                         principalColumn: "chatId",
                         onDelete: ReferentialAction.Cascade);
                     table.ForeignKey(
-                        name: "FK_Message_Player_player",
+                        name: "FK_Messages_Players_player",
                         column: x => x.player,
-                        principalTable: "Player",
+                        principalTable: "Players",
                         principalColumn: "playerId",
                         onDelete: ReferentialAction.Cascade);
                 });
 
             migrationBuilder.InsertData(
-                table: "Player",
+                table: "Players",
                 columns: new[] { "playerId", "name", "nbBallTouchTotal", "timePlayed" },
                 values: new object[,]
                 {
@@ -120,17 +120,17 @@ namespace DataBase.Migrations
                 });
 
             migrationBuilder.InsertData(
-                table: "Chat",
+                table: "Chats",
                 columns: new[] { "chatId", "player1", "player2" },
                 values: new object[] { 1, 1, 2 });
 
             migrationBuilder.InsertData(
-                table: "Game",
+                table: "Games",
                 columns: new[] { "gameId", "durationGame", "loser", "nbMaxEchanges", "winner" },
                 values: new object[] { 1, 65, 2, 5, 1 });
 
             migrationBuilder.InsertData(
-                table: "Message",
+                table: "Messages",
                 columns: new[] { "messageId", "chat", "message", "player", "timestamp" },
                 values: new object[,]
                 {
@@ -139,33 +139,33 @@ namespace DataBase.Migrations
                 });
 
             migrationBuilder.CreateIndex(
-                name: "IX_Chat_player1",
-                table: "Chat",
+                name: "IX_Chats_player1",
+                table: "Chats",
                 column: "player1");
 
             migrationBuilder.CreateIndex(
-                name: "IX_Chat_player2",
-                table: "Chat",
+                name: "IX_Chats_player2",
+                table: "Chats",
                 column: "player2");
 
             migrationBuilder.CreateIndex(
-                name: "IX_Game_loser",
-                table: "Game",
+                name: "IX_Games_loser",
+                table: "Games",
                 column: "loser");
 
             migrationBuilder.CreateIndex(
-                name: "IX_Game_winner",
-                table: "Game",
+                name: "IX_Games_winner",
+                table: "Games",
                 column: "winner");
 
             migrationBuilder.CreateIndex(
-                name: "IX_Message_chat",
-                table: "Message",
+                name: "IX_Messages_chat",
+                table: "Messages",
                 column: "chat");
 
             migrationBuilder.CreateIndex(
-                name: "IX_Message_player",
-                table: "Message",
+                name: "IX_Messages_player",
+                table: "Messages",
                 column: "player");
         }
 
@@ -173,16 +173,16 @@ namespace DataBase.Migrations
         protected override void Down(MigrationBuilder migrationBuilder)
         {
             migrationBuilder.DropTable(
-                name: "Game");
+                name: "Games");
 
             migrationBuilder.DropTable(
-                name: "Message");
+                name: "Messages");
 
             migrationBuilder.DropTable(
-                name: "Chat");
+                name: "Chats");
 
             migrationBuilder.DropTable(
-                name: "Player");
+                name: "Players");
         }
     }
 }

code/server/DataBase/Migrations/PongDbContextWithStubModelSnapshot.cs

@@ -35,7 +35,7 @@ namespace DataBase.Migrations
 
                     b.HasIndex("player2");
 
-                    b.ToTable("Chat");
+                    b.ToTable("Chats");
 
                     b.HasData(
                         new
@@ -70,7 +70,7 @@ namespace DataBase.Migrations
 
                     b.HasIndex("winner");
 
-                    b.ToTable("Game");
+                    b.ToTable("Games");
 
                     b.HasData(
                         new
@@ -108,7 +108,7 @@ namespace DataBase.Migrations
 
                     b.HasIndex("player");
 
-                    b.ToTable("Message");
+                    b.ToTable("Messages");
 
                     b.HasData(
                         new
@@ -147,7 +147,7 @@ namespace DataBase.Migrations
 
                     b.HasKey("playerId");
 
-                    b.ToTable("Player");
+                    b.ToTable("Players");
 
                     b.HasData(
                         new

code/server/DataBase/Program.cs

@@ -1,2 +1 @@
-
-Console.WriteLine("Hello world !");
+Console.WriteLine("Hello world !");

code/server/Server.sln

@@ -3,9 +3,13 @@ Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio Version 17
 VisualStudioVersion = 17.2.32526.322
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DataBase", "DataBase\DataBase.csproj", "{240EEEA0-7EFB-4919-A5C9-584DC6505C58}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Server", "Server\Server.csproj", "{95CCBA12-CAB4-4574-A91C-77844E5C2C10}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Server", "Server\Server.csproj", "{95CCBA12-CAB4-4574-A91C-77844E5C2C10}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ApiLeapHit", "ApiLeapHit\ApiLeapHit.csproj", "{693F37D1-B10C-45B2-A180-24D26B5A4841}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DTO", "DTO\DTO.csproj", "{BDA37278-912D-47E9-BD69-47A924A69004}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DataBase", "DataBase\DataBase.csproj", "{FCCE7DEC-1F7B-4C66-8C61-3FCB668F9008}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -13,14 +17,22 @@ Global
 		Release|Any CPU = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{240EEEA0-7EFB-4919-A5C9-584DC6505C58}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{240EEEA0-7EFB-4919-A5C9-584DC6505C58}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{240EEEA0-7EFB-4919-A5C9-584DC6505C58}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{240EEEA0-7EFB-4919-A5C9-584DC6505C58}.Release|Any CPU.Build.0 = Release|Any CPU
 		{95CCBA12-CAB4-4574-A91C-77844E5C2C10}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{95CCBA12-CAB4-4574-A91C-77844E5C2C10}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{95CCBA12-CAB4-4574-A91C-77844E5C2C10}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{95CCBA12-CAB4-4574-A91C-77844E5C2C10}.Release|Any CPU.Build.0 = Release|Any CPU
+		{693F37D1-B10C-45B2-A180-24D26B5A4841}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{693F37D1-B10C-45B2-A180-24D26B5A4841}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{693F37D1-B10C-45B2-A180-24D26B5A4841}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{693F37D1-B10C-45B2-A180-24D26B5A4841}.Release|Any CPU.Build.0 = Release|Any CPU
+		{BDA37278-912D-47E9-BD69-47A924A69004}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{BDA37278-912D-47E9-BD69-47A924A69004}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{BDA37278-912D-47E9-BD69-47A924A69004}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{BDA37278-912D-47E9-BD69-47A924A69004}.Release|Any CPU.Build.0 = Release|Any CPU
+		{FCCE7DEC-1F7B-4C66-8C61-3FCB668F9008}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{FCCE7DEC-1F7B-4C66-8C61-3FCB668F9008}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{FCCE7DEC-1F7B-4C66-8C61-3FCB668F9008}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{FCCE7DEC-1F7B-4C66-8C61-3FCB668F9008}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE