leap-hit-team
/
leap-hit-server
7
2
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity

🔨 Ajout d'un id unique pour le player
continuous-integration/drone/push Build is failing Details

Browse Source
Api
Noan07 2 years ago
parent 2c89f32cf6
commit 33661038ce
26 changed files with 943 additions and 512 deletions
Show Stats Download Patch File Download Diff File

120
code/server/ApiLeapHit/Controllers/ChatController.cs → code/server/ApiLeapHit/Controllers/ChatsController.cs
Unescape View File

@ -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);
return NotFound(new ApiResponse<object>(message));
_logger.LogInformation(message);
return NotFound(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();
var dtoChats = chats.Select(c => c.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);
return NotFound(new ApiResponse<object>(message));
_logger.LogInformation(message);
return NotFound(message);
}
//var player1 = await _dataManager.GetPlayer(chat.player1);
//var player2 = await _dataManager.GetPlayer(chat.player2);
var dtoChat = chat.ToDto();
var success_message = $"La récupération du chat a réussi pour le chat {id}.";
_logger.LogInformation(success_message);
return Ok(new ApiResponse<DTOChat>(success_message, dtoChat));
return Ok(dtoChat);
}
catch (Exception ex)
{
var error_message = $"Une erreur est survenue lors de la récupération du chat {id} : {ex.Message}";
var error_message = $"Une erreur est survenue lors de la récupération du chat {id}.";
_logger.LogError(ex, error_message);
return StatusCode(500, new ApiResponse<object>(error_message));
return StatusCode((int)HttpStatusCode.InternalServerError, error_message);
}
}
[HttpGet("byPlayer/{id}")]
public async Task<ActionResult<IEnumerable<DTOChat>>> GetChatsByIdPlayer(int id)
[HttpGet("Player/{id}")]
public async Task<ActionResult<List<DTOChat>>> GetChatsByIdPlayer(int id)
{
try
{
var chats = await _dataManager.GetChatsByIdPlayer(id);
if (chats == null || chats.Count() == 0)
if (chats == null || !chats.Any())
{
var message = "Aucun chat n'a été trouvé pour l'id : {id}.";
_logger.LogWarning(message);
return NotFound(new ApiResponse<object>(message));
}
var dtoChats = new List<DTOChat>();
foreach (var chat in chats)
{
dtoChats.Add(chat.ToDto());
var message = $"Aucun chat n'a été trouvé pour l'id : {id}.";
_logger.LogInformation(message);
return NotFound(new ApiResponse(message));
}
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}")]
public async Task<ActionResult<IEnumerable<DTOChat>>> GetChatsByIdPlayers(int idPlayer1, int idPlayer2)
[HttpGet("Players/{idPlayer1}/{idPlayer2}")]
public async Task<ActionResult<List<DTOChat>>> GetChatsByIdPlayers(int idPlayer1, int idPlayer2)
{
try
{
var chats = await _dataManager.GetChatsByIdPlayers(idPlayer1,idPlayer2);
if (chats == null ||chats.Count() == 0)
var chats = await _dataManager.GetChatsByIdPlayers(idPlayer1, idPlayer2);
if (chats == null || !chats.Any())
{
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());
_logger.LogInformation(message);
return NotFound(new ApiResponse(message));
}
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);
return NotFound(new ApiResponse<object>(warning_message));
_logger.LogInformation(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));
}
}
}

106
code/server/ApiLeapHit/Controllers/GameController.cs → code/server/ApiLeapHit/Controllers/GamesController.cs
Unescape View File

@ -13,13 +13,13 @@ namespace ApiLeapHit.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class GameController : ControllerBase
public class GamesController : ControllerBase
{
private readonly DbDataManager _dataManager;
private readonly ILogger<GameController> _logger;
private readonly ILogger<GamesController> _logger;
public GameController(DbDataManager dataManager, ILogger<GameController> logger)
public GamesController(DbDataManager dataManager, ILogger<GamesController> logger)
{
_dataManager = dataManager;
_logger = logger;
@ -51,50 +51,50 @@ namespace ApiLeapHit.Controllers
}
}
[HttpGet]
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}")]
//[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("Player/{id}")]
public async Task<ActionResult<IEnumerable<DTOGame>>> GetGameByIdPlayer(int id)
{
try
@ -144,12 +144,12 @@ namespace ApiLeapHit.Controllers
var winner = await _dataManager.GetPlayer(dtoGame.playerWinner);
var loser = await _dataManager.GetPlayer(dtoGame.playerLoser);
//if (winner == null || loser == null)
//{
// 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));
//}
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);

130
code/server/ApiLeapHit/Controllers/MessageController.cs
Unescape View File

@ -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}"));
}
}
}
}

132
code/server/ApiLeapHit/Controllers/MessagesController.cs
Unescape View File

@ -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}"));
// }
//}
}
}

218
code/server/ApiLeapHit/Controllers/PlayerController.cs
Unescape View File

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

168
code/server/ApiLeapHit/Controllers/PlayersController.cs
Unescape View File

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

2
code/server/ApiLeapHit/Mapper/PlayerMapper.cs
Unescape View File

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

4
code/server/DTO/DTOChat.cs
Unescape View File

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

4
code/server/DTO/DTOGame.cs
Unescape View File

@ -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 int playerLoser { get; set; }
public string playerWinner { get; set; }
public string playerLoser { get; set; }
public int scoreWinner { get; set; }
public int scoreLoser { get; set; }
}

4
code/server/DTO/DTOGameWithIdPlayer.cs
Unescape View File

@ -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 int playerLoser { get; set; }
public string playerWinner { get; set; }
public string playerLoser { get; set; }
}
}

2
code/server/DTO/DTOMessage.cs
Unescape View File

@ -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; }
}
}

3
code/server/DTO/DTOPlayer.cs
Unescape View File

@ -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; }

12
code/server/DTO/Factory/ApiResponse.cs
Unescape View File

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

12
code/server/DataBase/Context/PongDbContextWithStub.cs
Unescape View File

@ -15,18 +15,18 @@ namespace DataBase.Context
{
base.OnModelCreating(modelBuilder);
Player player1 = new() { playerId = 1, name = "Rami", timePlayed = 120, nbBallTouchTotal = 20 };
Player player2 = new() { playerId = 2, name = "Hugo", timePlayed = 250, nbBallTouchTotal = 90 };
Player player1 = new() { playerId = "test", name = "Rami", timePlayed = 120, nbBallTouchTotal = 20 };
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 message2 = new() { messageId = 2, message = "Comment tu vas ?", player = 2, timestamp = new DateTime(2023, 02, 16, 17, 12, 35), 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 = "test2", timestamp = new DateTime(2023, 02, 16, 17, 12, 35), chat = 1 };
modelBuilder.Entity<Message>().HasData(message1, message2);
}
}

33
code/server/DataBase/DataManager/DbDataManager.Chat.cs
Unescape View File

@ -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();
if (chat != null)
using (var context = new PongDbContext())
{
var result = context.Chats.Remove(chat);
await context.SaveChangesAsync();
return result != null;
var chat = context.Chats.Where(c => c.chatId == id).ToList().FirstOrDefault();
if (chat != 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);
}
}
}
}

2
code/server/DataBase/DataManager/DbDataManager.Game.cs
Unescape View File

@ -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())
{

9
code/server/DataBase/DataManager/DbDataManager.Message.cs
Unescape View File

@ -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);
}
}
}
}

15
code/server/DataBase/DataManager/DbDataManager.Player.cs
Unescape View File

@ -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);
}
}
}
}

4
code/server/DataBase/Entity/Chat.cs
Unescape View File

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

4
code/server/DataBase/Entity/Game.cs
Unescape View File

@ -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 int loser { get; set; }
public string winner { get; set; }
public string loser { get; set; }
public int scoreWinner { get; set; }

2
code/server/DataBase/Entity/Message.cs
Unescape View File

@ -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")]

2
code/server/DataBase/Entity/Player.cs
Unescape View File

@ -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; }

165
code/server/TestControleurs/UnitTestChats.cs
Unescape View File

@ -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);
}
}
}

133
code/server/TestControleurs/UnitTestGames.cs
Unescape View File

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

129
code/server/TestControleurs/UnitTestMessages.cs
Unescape View File

@ -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);
}
}
}

40
code/server/TestControleurs/UnitTestPlayers.cs
Unescape View File

@ -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);
//}
}
}
Write Preview
Loading…
Cancel
Save