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

🔨 Amélioration des controleur + mise en place de logger
continuous-integration/drone/push Build is passing Details

Browse Source
pull/1/head
Noan07 2 years ago
parent ba5e9be3c7
commit 22352c7de1
12 changed files with 570 additions and 191 deletions
Show Stats Download Patch File Download Diff File

188
code/server/ApiLeapHit/Controllers/ChatController.cs
Unescape View File

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

144
code/server/ApiLeapHit/Controllers/GameController.cs
Unescape View File

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

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

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

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

@ -1,6 +1,8 @@
using DataBase.DataManager;
using ApiLeapHit.Mapper;
using DataBase.DataManager;
using DataBase.Entity;
using DTO;
using DTO.Factory;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.Net;
@ -12,46 +14,132 @@ namespace ApiLeapHit.Controllers
public class PlayerController : ControllerBase
{
private readonly DbDataManager _dataManager;
private readonly ILogger<PlayerController> _logger;
public PlayerController(DbDataManager dataManager)
public PlayerController(DbDataManager dataManager, ILogger<PlayerController> logger)
{
_dataManager = dataManager;
_logger = logger;
}
[HttpGet("{id}")]
public async Task<ActionResult<DTOPlayer>> GetPlayer(int id)
{
var player = await _dataManager.GetPlayer(id);
if (player == null)
try
{
return NotFound();
}
var player = await _dataManager.GetPlayer(id);
if (player == null)
{
return NotFound(new ApiResponse<object>("Joueur non trouvé."));
}
var response = new ApiResponse<DTOPlayer>($"Le joueur avec l'id {id} a été récupéré avec succès.", player.ToDto());
var dtoPlayer = new DTOPlayer
{
playerId = player.playerId,
name = player.name,
nbBallTouchTotal = player.nbBallTouchTotal,
timePlayed = player.timePlayed,
// 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(dtoPlayer);
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"
));
var player = new Player
return Ok(response);
}
catch (Exception ex)
{
playerId = dtoPlayer.playerId,
name = dtoPlayer.name,
nbBallTouchTotal = dtoPlayer.nbBallTouchTotal,
timePlayed = dtoPlayer.timePlayed,
};
await _dataManager.AddPlayer(player);
return Ok();
_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}")]
@ -62,39 +150,66 @@ namespace ApiLeapHit.Controllers
var result = await _dataManager.RemovePlayer(id);
if (result)
{
return Ok();
// Ajout des liens HATEOAS
var response = new ApiResponse<object>("Joueur supprimé avec succès.");
response.Links.Add(new ApiLink(
Url.Action("GetPlayers", "Player"),
"self",
"GET"
));
return Ok(response);
}
return NotFound();
return NotFound(new ApiResponse<object>("Joueur non trouvé."));
}
catch (Exception ex)
{
return StatusCode((int)HttpStatusCode.InternalServerError);
_logger.LogError(ex, $"Une erreur est survenue lors de la suppression du joueur avec l'id {id}.");
return StatusCode((int)HttpStatusCode.InternalServerError, new ApiResponse<object>("Une erreur est survenue lors de la suppression du joueur."));
}
}
[HttpPut("{id}")]
public async Task<IActionResult> Put(int id, [FromBody] DTOPlayer dtoPlayer)
{
if (!ModelState.IsValid)
return StatusCode((int)HttpStatusCode.BadRequest); //"Les données du player ne sont pas correctes"
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);
Player playerTeste = await _dataManager.GetPlayer(id);
if (playerTeste != null)
return StatusCode((int)HttpStatusCode.NotFound); //"Le player n'existe pas."
// 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"
));
var player = new Player
return Ok(response);
}
catch (Exception ex)
{
playerId = dtoPlayer.playerId,
name = dtoPlayer.name,
nbBallTouchTotal = dtoPlayer.nbBallTouchTotal,
timePlayed = dtoPlayer.timePlayed,
};
Player playerUpdate = await _dataManager.GetPlayer(id);
await _dataManager.UpdatePlayer(id,player.name);
return StatusCode((int)HttpStatusCode.OK); //"Le champion a été modifié."
}
_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."));
}
}
}
}

29
code/server/ApiLeapHit/Mapper/ChatMapper.cs
Unescape View File

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

21
code/server/ApiLeapHit/Mapper/MessageMapper.cs
Unescape View File

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

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

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

22
code/server/DTO/Factory/ApiLink.cs
Unescape View File

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

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

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

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

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

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

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

BIN
code/server/DataBase/PongDB.db
View File

Binary file not shown.
Write Preview
Loading…
Cancel
Save