johnny.ratton
/
API_SQLuedo
1
0
Fork 0
Code Issues 15 Pull Requests Packages Projects 1 Releases Wiki Activity

Fusion de Master dans UnitTests pour récupérer la nouvelle logique de Success

Browse Source
pull/40/head
Maxime SAPOUNTZIS 1 year ago
parent 403aa3bdc4 5a8d8fe4e9
commit a3d9f7c2b7
68 changed files with 718 additions and 1067 deletions
Show Stats Download Patch File Download Diff File

25
API_SQLuedo/API/Controllers/InquiriesController.cs
Unescape View File

@ -13,16 +13,17 @@ namespace API.Controllers
[ApiController] [ApiController]
public class InquiriesController : Controller public class InquiriesController : Controller
{ {
private IInquiryService<InquiryDTO> _inquiryDataService; private readonly IInquiryService<InquiryDTO> _inquiryDataService;
private readonly ILogger<InquiriesController> _logger; private readonly ILogger<InquiriesController> _logger;
public InquiriesController(IInquiryService<InquiryDTO> inquiryDataService, ILogger<InquiriesController> logger) public InquiriesController(IInquiryService<InquiryDTO> inquiryDataService, ILogger<InquiriesController> logger)
{ {
_inquiryDataService = inquiryDataService; _inquiryDataService = inquiryDataService;
_logger = logger; _logger = logger;
} }
[HttpGet("inquiries/{page}/{number}/{orderCriteria}")] [HttpGet("inquiries/{page:int}/{number:int}/{orderCriteria}")]
[ProducesResponseType(typeof(InquiryDTO), 200)] [ProducesResponseType(typeof(InquiryDTO), 200)]
[ProducesResponseType(typeof(string), 204)] [ProducesResponseType(typeof(string), 204)]
public IActionResult GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria) public IActionResult GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria)
@ -33,6 +34,7 @@ namespace API.Controllers
_logger.LogError("[ERREUR] Aucune enquête trouvée."); _logger.LogError("[ERREUR] Aucune enquête trouvée.");
return StatusCode(204); return StatusCode(204);
} }
_logger.LogInformation("[INFORMATION] {nb} Enquête(s) trouvée(s)", nbInquiry); _logger.LogInformation("[INFORMATION] {nb} Enquête(s) trouvée(s)", nbInquiry);
return Ok(_inquiryDataService.GetInquiries(page, number, orderCriteria)); return Ok(_inquiryDataService.GetInquiries(page, number, orderCriteria));
} }
@ -71,7 +73,7 @@ namespace API.Controllers
} }
} }
[HttpDelete("inquiry/{id}")] [HttpDelete("inquiry/{id:int}")]
[ProducesResponseType(typeof(InquiryDTO), 200)] [ProducesResponseType(typeof(InquiryDTO), 200)]
[ProducesResponseType(typeof(string), 404)] [ProducesResponseType(typeof(string), 404)]
public IActionResult DeleteInquiry(int id) public IActionResult DeleteInquiry(int id)
@ -87,7 +89,6 @@ namespace API.Controllers
_logger.LogError("[ERREUR] Aucune enquête trouvée avec l'id {id}.", id); _logger.LogError("[ERREUR] Aucune enquête trouvée avec l'id {id}.", id);
return NotFound(); return NotFound();
} }
} }
[HttpPost] [HttpPost]
@ -99,11 +100,15 @@ namespace API.Controllers
{ {
return BadRequest(); return BadRequest();
} }
_logger.LogInformation("[INFORMATION] Une enquête a été créé : title - {title}, description - {description}, isUser - {isUser}", dto.Title, dto.Description, dto.IsUser);
return Created(nameof(GetInquiries), _inquiryDataService.CreateInquiry(dto.Title, dto.Description, dto.IsUser)); _logger.LogInformation(
"[INFORMATION] Une enquête a été créé : title - {title}, description - {description}, isUser - {isUser}",
dto.Title, dto.Description, dto.IsUser);
return Created(nameof(GetInquiries),
_inquiryDataService.CreateInquiry(dto.Title, dto.Description, dto.IsUser));
} }
[HttpPut("inquiry/{id}")] [HttpPut("inquiry/{id:int}")]
[ProducesResponseType(typeof(InquiryDTO), 200)] [ProducesResponseType(typeof(InquiryDTO), 200)]
[ProducesResponseType(typeof(string), 400)] [ProducesResponseType(typeof(string), 400)]
[ProducesResponseType(typeof(string), 404)] [ProducesResponseType(typeof(string), 404)]
@ -114,16 +119,20 @@ namespace API.Controllers
_logger.LogError("[ERREUR] Problème ID - La mise à jour de l'enquête avec l'id {id} a échouée.", id); _logger.LogError("[ERREUR] Problème ID - La mise à jour de l'enquête avec l'id {id} a échouée.", id);
return BadRequest(); return BadRequest();
} }
if (!ModelState.IsValid) if (!ModelState.IsValid)
{ {
_logger.LogError("[ERREUR] Problème controlleur - La mise à jour de l'enquête avec l'id {id} a échouée.", id); _logger.LogError(
"[ERREUR] Problème controlleur - La mise à jour de l'enquête avec l'id {id} a échouée.", id);
return BadRequest(); return BadRequest();
} }
if (inquiryDTO != null) if (inquiryDTO != null)
{ {
_logger.LogInformation("[INFORMATION] La mise à jour de l'enquête avec l'id {id} a été effectuée", id); _logger.LogInformation("[INFORMATION] La mise à jour de l'enquête avec l'id {id} a été effectuée", id);
return Ok(_inquiryDataService.UpdateInquiry(id, inquiryDTO)); return Ok(_inquiryDataService.UpdateInquiry(id, inquiryDTO));
} }
_logger.LogError("[ERREUR] Aucune enquête trouvée avec l'id {id}.", id); _logger.LogError("[ERREUR] Aucune enquête trouvée avec l'id {id}.", id);
return NotFound(); return NotFound();
} }

24
API_SQLuedo/API/Controllers/LessonsController.cs
Unescape View File

@ -13,7 +13,7 @@ namespace API.Controllers
[ApiController] [ApiController]
public class LessonsController : Controller public class LessonsController : Controller
{ {
private ILessonService<LessonDTO> _lessonDataService; private readonly ILessonService<LessonDTO> _lessonDataService;
private readonly ILogger<LessonsController> _logger; private readonly ILogger<LessonsController> _logger;
@ -23,7 +23,7 @@ namespace API.Controllers
_logger = logger; _logger = logger;
} }
[HttpGet("lessons/{page}/{number}/{orderCriteria}")] [HttpGet("lessons/{page:int}/{number:int}/{orderCriteria}")]
[ProducesResponseType(typeof(LessonDTO), 200)] [ProducesResponseType(typeof(LessonDTO), 200)]
[ProducesResponseType(typeof(string), 204)] [ProducesResponseType(typeof(string), 204)]
public IActionResult GetLessons(int page, int number, LessonOrderCriteria orderCriteria) public IActionResult GetLessons(int page, int number, LessonOrderCriteria orderCriteria)
@ -34,6 +34,7 @@ namespace API.Controllers
_logger.LogError("[ERREUR] Aucune leçon trouvée."); _logger.LogError("[ERREUR] Aucune leçon trouvée.");
return StatusCode(204); return StatusCode(204);
} }
_logger.LogInformation("[INFORMATION] {nb} Leçon(s) trouvée(s)", nbLesson); _logger.LogInformation("[INFORMATION] {nb} Leçon(s) trouvée(s)", nbLesson);
return Ok(_lessonDataService.GetLessons(page, number, orderCriteria)); return Ok(_lessonDataService.GetLessons(page, number, orderCriteria));
} }
@ -72,7 +73,7 @@ namespace API.Controllers
} }
} }
[HttpDelete("lesson/{id}")] [HttpDelete("lesson/{id:int}")]
[ProducesResponseType(typeof(LessonDTO), 200)] [ProducesResponseType(typeof(LessonDTO), 200)]
[ProducesResponseType(typeof(string), 404)] [ProducesResponseType(typeof(string), 404)]
public IActionResult DeleteLesson(int id) public IActionResult DeleteLesson(int id)
@ -88,7 +89,6 @@ namespace API.Controllers
_logger.LogError("[ERREUR] Aucune leçon trouvée avec l'id {id}.", id); _logger.LogError("[ERREUR] Aucune leçon trouvée avec l'id {id}.", id);
return NotFound(); return NotFound();
} }
} }
[HttpPost] [HttpPost]
@ -100,11 +100,15 @@ namespace API.Controllers
{ {
return BadRequest(); return BadRequest();
} }
_logger.LogInformation("[INFORMATION] Une leçon a été créé : title - {title}, lastPublisher - {publisher}, lastEdit - {lastEdit}", dto.Title, dto.LastPublisher, dto.LastEdit);
return Created(nameof(GetLessons), _lessonDataService.CreateLesson(dto.Title, dto.LastPublisher, dto.LastEdit)); _logger.LogInformation(
"[INFORMATION] Une leçon a été créé : title - {title}, lastPublisher - {publisher}, lastEdit - {lastEdit}",
dto.Title, dto.LastPublisher, dto.LastEdit);
return Created(nameof(GetLessons),
_lessonDataService.CreateLesson(dto.Title, dto.LastPublisher, dto.LastEdit));
} }
[HttpPut("lesson/{id}")] [HttpPut("lesson/{id:int}")]
[ProducesResponseType(typeof(LessonDTO), 200)] [ProducesResponseType(typeof(LessonDTO), 200)]
[ProducesResponseType(typeof(string), 400)] [ProducesResponseType(typeof(string), 400)]
[ProducesResponseType(typeof(string), 404)] [ProducesResponseType(typeof(string), 404)]
@ -115,16 +119,20 @@ namespace API.Controllers
_logger.LogError("[ERREUR] Problème ID - La mise à jour de la leçon avec l'id {id} a échouée.", id); _logger.LogError("[ERREUR] Problème ID - La mise à jour de la leçon avec l'id {id} a échouée.", id);
return BadRequest(); return BadRequest();
} }
if (!ModelState.IsValid) if (!ModelState.IsValid)
{ {
_logger.LogError("[ERREUR] Problème controlleur - La mise à jour de la leçon avec l'id {id} a échouée.", id); _logger.LogError("[ERREUR] Problème controlleur - La mise à jour de la leçon avec l'id {id} a échouée.",
id);
return BadRequest(); return BadRequest();
} }
if (lessonDTO != null) if (lessonDTO != null)
{ {
_logger.LogInformation("[INFORMATION] La mise à jour de la leçon avec l'id {id} a été effectuée", id); _logger.LogInformation("[INFORMATION] La mise à jour de la leçon avec l'id {id} a été effectuée", id);
return Ok(_lessonDataService.UpdateLesson(id, lessonDTO)); return Ok(_lessonDataService.UpdateLesson(id, lessonDTO));
} }
_logger.LogError("[ERREUR] Aucune leçon trouvée avec l'id {id}.", id); _logger.LogError("[ERREUR] Aucune leçon trouvée avec l'id {id}.", id);
return NotFound(); return NotFound();
} }

43
API_SQLuedo/API/Controllers/ParagraphsController.cs
Unescape View File

@ -13,27 +13,29 @@ namespace API.Controllers
[ApiController] [ApiController]
public class ParagraphsController : Controller public class ParagraphsController : Controller
{ {
private IParagraphService<ParagraphDTO> _paragraphDataService; private readonly IParagraphService<ParagraphDTO> _paragraphDataService;
private readonly ILogger<ParagraphsController> _logger; private readonly ILogger<ParagraphsController> _logger;
public ParagraphsController(IParagraphService<ParagraphDTO> paragraphDataService, ILogger<ParagraphsController> logger) public ParagraphsController(IParagraphService<ParagraphDTO> paragraphDataService,
ILogger<ParagraphsController> logger)
{ {
_paragraphDataService = paragraphDataService; _paragraphDataService = paragraphDataService;
_logger = logger; _logger = logger;
} }
[HttpGet("paragraphs/{page}/{number}/{orderCriteria}")] [HttpGet("paragraphs/{page:int}/{number:int}/{orderCriteria}")]
[ProducesResponseType(typeof(ParagraphDTO), 200)] [ProducesResponseType(typeof(ParagraphDTO), 200)]
[ProducesResponseType(typeof(string), 204)] [ProducesResponseType(typeof(string), 204)]
public IActionResult GetParagraphs(int page, int number, ParagraphOrderCriteria orderCriteria) public IActionResult GetParagraphs(int page, int number, ParagraphOrderCriteria orderCriteria)
{ {
var nbParagraph = ( _paragraphDataService.GetParagraphs(page, number, orderCriteria)).ToList().Count(); var nbParagraph = _paragraphDataService.GetParagraphs(page, number, orderCriteria).ToList().Count;
if (nbParagraph == 0) if (nbParagraph == 0)
{ {
_logger.LogError("[ERREUR] Aucun paragraphe trouvé."); _logger.LogError("[ERREUR] Aucun paragraphe trouvé.");
return StatusCode(204); return StatusCode(204);
} }
_logger.LogInformation("[INFORMATION] {nb} Paragraphe(s) trouvé(s)", nbParagraph); _logger.LogInformation("[INFORMATION] {nb} Paragraphe(s) trouvé(s)", nbParagraph);
return Ok(_paragraphDataService.GetParagraphs(page, number, orderCriteria)); return Ok(_paragraphDataService.GetParagraphs(page, number, orderCriteria));
} }
@ -47,7 +49,8 @@ namespace API.Controllers
{ {
_logger.LogInformation("[INFORMATION] Le paragraphe avec l'id {id} a été trouvé.", id); _logger.LogInformation("[INFORMATION] Le paragraphe avec l'id {id} a été trouvé.", id);
return Ok(_paragraphDataService.GetParagraphById(id)); return Ok(_paragraphDataService.GetParagraphById(id));
} catch (ArgumentException) }
catch (ArgumentException)
{ {
_logger.LogError("[ERREUR] Aucun paragraphe trouvé avec l'id {id}.", id); _logger.LogError("[ERREUR] Aucun paragraphe trouvé avec l'id {id}.", id);
return NotFound(); return NotFound();
@ -63,15 +66,15 @@ namespace API.Controllers
{ {
_logger.LogInformation("[INFORMATION] Le paragraphe avec le titre {title} a été trouvé.", title); _logger.LogInformation("[INFORMATION] Le paragraphe avec le titre {title} a été trouvé.", title);
return Ok(_paragraphDataService.GetParagraphByTitle(title)); return Ok(_paragraphDataService.GetParagraphByTitle(title));
}catch (ArgumentException) }
catch (ArgumentException)
{ {
_logger.LogError("[ERREUR] Aucun paragraphe trouvé avec le titre {title}.", title); _logger.LogError("[ERREUR] Aucun paragraphe trouvé avec le titre {title}.", title);
return NotFound(); return NotFound();
} }
} }
[HttpDelete("paragraph/{id}")] [HttpDelete("paragraph/{id:int}")]
[ProducesResponseType(typeof(ParagraphDTO), 200)] [ProducesResponseType(typeof(ParagraphDTO), 200)]
[ProducesResponseType(typeof(string), 404)] [ProducesResponseType(typeof(string), 404)]
public IActionResult DeleteParagraph(int id) public IActionResult DeleteParagraph(int id)
@ -81,12 +84,12 @@ namespace API.Controllers
{ {
_logger.LogInformation("[INFORMATION] Le paragraphe avec l'id {id} a été supprimé.", id); _logger.LogInformation("[INFORMATION] Le paragraphe avec l'id {id} a été supprimé.", id);
return Ok(_paragraphDataService.DeleteParagraph(id)); return Ok(_paragraphDataService.DeleteParagraph(id));
} else }
else
{ {
_logger.LogError("[ERREUR] Aucun paragraphe trouvé avec l'id {id}.", id); _logger.LogError("[ERREUR] Aucun paragraphe trouvé avec l'id {id}.", id);
return NotFound(); return NotFound();
} }
} }
[HttpPost] [HttpPost]
@ -94,15 +97,21 @@ namespace API.Controllers
[ProducesResponseType(typeof(string), 400)] [ProducesResponseType(typeof(string), 400)]
public IActionResult CreateParagraph([FromBody] ParagraphDTO dto) public IActionResult CreateParagraph([FromBody] ParagraphDTO dto)
{ {
if (dto.Title == null || dto.Content == null || dto.Info == null || dto.Query == null || dto.Comment == null) if (dto.Title == null || dto.Content == null || dto.Info == null || dto.Query == null ||
dto.Comment == null)
{ {
return BadRequest(); return BadRequest();
} }
_logger.LogInformation("[INFORMATION] Un paragraphe a été créé : title - {title}, content - {content}, info - {info}, query - {query}, comment - {comment}", dto.Title, dto.Content, dto.Info, dto.Query, dto.Comment);
return Created(nameof(GetParagraphs), _paragraphDataService.CreateParagraph(dto.Title, dto.Content, dto.Info, dto.Query, dto.Comment, dto.LessonId)); _logger.LogInformation(
"[INFORMATION] Un paragraphe a été créé : title - {title}, content - {content}, info - {info}, query - {query}, comment - {comment}",
dto.Title, dto.Content, dto.Info, dto.Query, dto.Comment);
return Created(nameof(GetParagraphs),
_paragraphDataService.CreateParagraph(dto.Title, dto.Content, dto.Info, dto.Query, dto.Comment,
dto.LessonId));
} }
[HttpPut("paragraph/{id}")] [HttpPut("paragraph/{id:int}")]
[ProducesResponseType(typeof(ParagraphDTO), 200)] [ProducesResponseType(typeof(ParagraphDTO), 200)]
[ProducesResponseType(typeof(string), 400)] [ProducesResponseType(typeof(string), 400)]
[ProducesResponseType(typeof(string), 404)] [ProducesResponseType(typeof(string), 404)]
@ -113,16 +122,20 @@ namespace API.Controllers
_logger.LogError("[ERREUR] Problème ID - La mise à jour du paragraphe avec l'id {id} a échouée.", id); _logger.LogError("[ERREUR] Problème ID - La mise à jour du paragraphe avec l'id {id} a échouée.", id);
return BadRequest(); return BadRequest();
} }
if (!ModelState.IsValid) if (!ModelState.IsValid)
{ {
_logger.LogError("[ERREUR] Problème controlleur - La mise à jour du paragraphe avec l'id {id} a échouée.", id); _logger.LogError(
"[ERREUR] Problème controlleur - La mise à jour du paragraphe avec l'id {id} a échouée.", id);
return BadRequest(); return BadRequest();
} }
if (paragraphDTO != null) if (paragraphDTO != null)
{ {
_logger.LogInformation("[INFORMATION] La mise à jour du paragraphe avec l'id {id} a été effectuée", id); _logger.LogInformation("[INFORMATION] La mise à jour du paragraphe avec l'id {id} a été effectuée", id);
return Ok(_paragraphDataService.UpdateParagraph(id, paragraphDTO)); return Ok(_paragraphDataService.UpdateParagraph(id, paragraphDTO));
} }
_logger.LogError("[ERREUR] Aucun paragraphe trouvé avec l'id {id}.", id); _logger.LogError("[ERREUR] Aucun paragraphe trouvé avec l'id {id}.", id);
return NotFound(); return NotFound();
} }

78
API_SQLuedo/API/Controllers/SuccessesController.cs
Unescape View File

@ -13,7 +13,7 @@ namespace API.Controllers
[ApiController] [ApiController]
public class SuccessesController : Controller public class SuccessesController : Controller
{ {
private ISuccessService<SuccessDTO> _successDataService; private readonly ISuccessService<SuccessDTO> _successDataService;
private readonly ILogger<SuccessesController> _logger; private readonly ILogger<SuccessesController> _logger;
@ -23,17 +23,18 @@ namespace API.Controllers
_logger = logger; _logger = logger;
} }
[HttpGet("successes/{page}/{number}/{orderCriteria}")] [HttpGet("successes/{page:int}/{number:int}/{orderCriteria}")]
[ProducesResponseType(typeof(SuccessDTO), 200)] [ProducesResponseType(typeof(SuccessDTO), 200)]
[ProducesResponseType(typeof(string), 204)] [ProducesResponseType(typeof(string), 204)]
public IActionResult GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria) public IActionResult GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria)
{ {
var nbUser = (_successDataService.GetSuccesses(page, number, orderCriteria)).ToList().Count(); var nbUser = _successDataService.GetSuccesses(page, number, orderCriteria).ToList().Count;
if (nbUser == 0) if (nbUser == 0)
{ {
_logger.LogError("[ERREUR] Aucun utilisateur trouvé."); _logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
return StatusCode(204); return StatusCode(204);
} }
_logger.LogInformation("[INFORMATION] {nb} Utilisateur(s) trouvé(s)", nbUser); _logger.LogInformation("[INFORMATION] {nb} Utilisateur(s) trouvé(s)", nbUser);
return Ok(_successDataService.GetSuccesses(page, number, orderCriteria)); return Ok(_successDataService.GetSuccesses(page, number, orderCriteria));
} }
@ -41,52 +42,54 @@ namespace API.Controllers
[HttpGet("success/user/{id:int}")] [HttpGet("success/user/{id:int}")]
[ProducesResponseType(typeof(SuccessDTO), 200)] [ProducesResponseType(typeof(SuccessDTO), 200)]
[ProducesResponseType(typeof(string), 404)] [ProducesResponseType(typeof(string), 404)]
public IActionResult GetSuccessByUserId(int userId) public IActionResult GetSuccessByUserId(int id)
{ {
try try
{ {
_logger.LogInformation("[INFORMATION] Le succès avec l'id de l'utilisateur {id} a été trouvé.", userId); _logger.LogInformation("[INFORMATION] Le succès avec l'id de l'utilisateur {id} a été trouvé.", id);
return Ok(_successDataService.GetSuccessByUserId(userId)); return Ok(_successDataService.GetSuccessesByUserId(id));
} catch (ArgumentException) }
catch (ArgumentException)
{ {
_logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id de l'utilisateur {id}.", userId); _logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id de l'utilisateur {id}.", id);
return NotFound(); return NotFound();
} }
} }
[HttpGet("success/inquiry/{inquiryId:int}")] [HttpGet("success/inquiry/{id:int}")]
[ProducesResponseType(typeof(SuccessDTO), 200)] [ProducesResponseType(typeof(SuccessDTO), 200)]
[ProducesResponseType(typeof(string), 404)] [ProducesResponseType(typeof(string), 404)]
public IActionResult GetSuccessByInquiryId(int inquiryId) public IActionResult GetSuccessByInquiryId(int id)
{ {
try try
{ {
_logger.LogInformation("[INFORMATION] Utilisateur avec l'id de l'enquête {inquiryId} a été trouvé.", inquiryId); _logger.LogInformation("[INFORMATION] Utilisateur avec l'id de l'enquête {inquiryId} a été trouvé.",
return Ok(_successDataService.GetSuccessByInquiryId(inquiryId)); id);
}catch (ArgumentException) return Ok(_successDataService.GetSuccessesByInquiryId(id));
}
catch (ArgumentException)
{ {
_logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id de l'enquête {inquiryId}.", inquiryId); _logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id de l'enquête {inquiryId}.", id);
return NotFound(); return NotFound();
} }
} }
[HttpDelete("success/{id}")] [HttpDelete("success/{idUser:int}/{idInquiry:int}")]
[ProducesResponseType(typeof(SuccessDTO), 200)] [ProducesResponseType(typeof(SuccessDTO), 200)]
[ProducesResponseType(typeof(string), 404)] [ProducesResponseType(typeof(string), 404)]
public IActionResult DeleteSuccess(int id) public IActionResult DeleteSuccess(int idUser, int idInquiry)
{ {
var success = _successDataService.DeleteSuccess(id); var success = _successDataService.DeleteSuccess(idUser, idInquiry);
if (success) if (success)
{ {
_logger.LogInformation("[INFORMATION] Le succès avec l'id {id} a été supprimé.", id); _logger.LogInformation("[INFORMATION] Le succès avec l'id {id} a été supprimé.", idUser);
return Ok(_successDataService.DeleteSuccess(id)); return Ok(success);
} else }
else
{ {
_logger.LogError("[ERREUR] Aucun succès trouvé avec l'id {id}.", id); _logger.LogError("[ERREUR] Aucun succès trouvé avec l'id {id}.", idUser);
return NotFound(); return NotFound();
} }
} }
[HttpPost] [HttpPost]
@ -98,32 +101,41 @@ namespace API.Controllers
{ {
return BadRequest(); return BadRequest();
}*/ }*/
_logger.LogInformation("[INFORMATION] Un succès a été créé : userId - {userId}, inquiryId - {inquiryId}, isFinished - {isFinished}", dto.UserId, dto.InquiryId, dto.IsFinished); _logger.LogInformation(
return Created(nameof(GetSuccesses), _successDataService.CreateSuccess(dto.UserId, dto.InquiryId, dto.IsFinished)); "[INFORMATION] Un succès a été créé : userId - {userId}, inquiryId - {inquiryId}, isFinished - {isFinished}",
dto.UserId, dto.InquiryId, dto.IsFinished);
return Created(nameof(GetSuccesses),
_successDataService.CreateSuccess(dto.UserId, dto.InquiryId, dto.IsFinished));
} }
[HttpPut("success/{id}")] [HttpPut("success/{idUser:int}/{idInquiry:int}")]
[ProducesResponseType(typeof(SuccessDTO), 200)] [ProducesResponseType(typeof(SuccessDTO), 200)]
[ProducesResponseType(typeof(string), 400)] [ProducesResponseType(typeof(string), 400)]
[ProducesResponseType(typeof(string), 404)] [ProducesResponseType(typeof(string), 404)]
public IActionResult UpdateSuccess(int id, [FromBody] SuccessDTO successDTO) public IActionResult UpdateSuccess(int idUser, int idInquiry, [FromBody] SuccessDTO successDTO)
{ {
if(id != successDTO.UserId) if (idUser != successDTO.UserId || idInquiry != successDTO.InquiryId)
{ {
_logger.LogError("[ERREUR] Problème ID - La mise à jour du succès avec l'id de l'utilisateur {id} a échouée.", id); _logger.LogError(
"[ERREUR] Problème ID - La mise à jour du succès avec l'id de l'utilisateur {id} a échouée.", idUser);
return BadRequest(); return BadRequest();
} }
if (!ModelState.IsValid) if (!ModelState.IsValid)
{ {
_logger.LogError("[ERREUR] Problème controlleur - La mise à jour du succès avec l'id de l'utilisateur {id} a échouée.", id); _logger.LogError(
"[ERREUR] Problème controlleur - La mise à jour du succès avec l'id de l'utilisateur {id} a échouée.",
idUser);
return BadRequest(); return BadRequest();
} }
if (successDTO != null) if (successDTO != null)
{ {
_logger.LogInformation("[INFORMATION] La mise à jour du succès avec l'id de l'utilisateur {id} a été effectuée", id); _logger.LogInformation(
return Ok(_successDataService.UpdateSuccess(id, successDTO)); "[INFORMATION] La mise à jour du succès avec l'id de l'utilisateur {id} a été effectuée", idUser);
return Ok(_successDataService.UpdateSuccess(idUser,idInquiry, successDTO));
} }
_logger.LogError("[ERREUR] Aucun succès trouvé avec l'id de l'utilisateur {id}.", id);
_logger.LogError("[ERREUR] Aucun succès trouvé avec l'id de l'utilisateur {id}.", idUser);
return NotFound(); return NotFound();
} }
} }

8
API_SQLuedo/API/Controllers/UserController.cs
Unescape View File

@ -13,7 +13,7 @@ namespace API.Controllers
[ApiController] [ApiController]
public class UsersController(ILogger<UsersController> logger, IUserService<UserDTO> userService) : ControllerBase public class UsersController(ILogger<UsersController> logger, IUserService<UserDTO> userService) : ControllerBase
{ {
[HttpGet("users/{page}/{number}")] [HttpGet("users/{page:int}/{number:int}")]
[ProducesResponseType(typeof(UserDTO), 200)] [ProducesResponseType(typeof(UserDTO), 200)]
[ProducesResponseType(typeof(string), 204)] [ProducesResponseType(typeof(string), 204)]
public IActionResult GetUsers(int page, int number, UserOrderCriteria orderCriteria) public IActionResult GetUsers(int page, int number, UserOrderCriteria orderCriteria)
@ -63,7 +63,7 @@ namespace API.Controllers
} }
} }
[HttpDelete("user/{id}")] [HttpDelete("user/{id:int}")]
[ProducesResponseType(typeof(UserDTO), 200)] [ProducesResponseType(typeof(UserDTO), 200)]
[ProducesResponseType(typeof(string), 404)] [ProducesResponseType(typeof(string), 404)]
public IActionResult DeleteUser(int id) public IActionResult DeleteUser(int id)
@ -72,7 +72,7 @@ namespace API.Controllers
if (success) if (success)
{ {
logger.LogInformation("[INFORMATION] L'utilisateur avec l'id {id} a été supprimé.", id); logger.LogInformation("[INFORMATION] L'utilisateur avec l'id {id} a été supprimé.", id);
return Ok(userService.DeleteUser(id)); return Ok();
} }
else else
{ {
@ -99,7 +99,7 @@ namespace API.Controllers
userService.CreateUser(dto.Username, dto.Password, dto.Email, dto.IsAdmin)); userService.CreateUser(dto.Username, dto.Password, dto.Email, dto.IsAdmin));
} }
[HttpPut("user/{id}")] [HttpPut("user/{id:int}")]
[ProducesResponseType(typeof(UserDTO), 200)] [ProducesResponseType(typeof(UserDTO), 200)]
[ProducesResponseType(typeof(string), 400)] [ProducesResponseType(typeof(string), 400)]
[ProducesResponseType(typeof(string), 404)] [ProducesResponseType(typeof(string), 404)]

22
API_SQLuedo/API/Program.cs
Unescape View File

@ -6,9 +6,7 @@ using DbDataManager.Service;
using Dto; using Dto;
using Entities; using Entities;
using Microsoft.AspNetCore.Identity; using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.OpenApi.Models; using Microsoft.OpenApi.Models;
using Shared; using Shared;
@ -21,20 +19,20 @@ builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer(); builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(); builder.Services.AddSwaggerGen();
builder.Services.AddScoped<IUserService<UserEntity>, DbDataManager.Service.UserDataService>(); builder.Services.AddScoped<IUserService<UserEntity>, UserDataService>();
builder.Services.AddScoped<IUserService<UserDTO>, Shared.UserDataService>(); builder.Services.AddScoped<IUserService<UserDTO>, UserDataServiceApi>();
builder.Services.AddScoped<IInquiryService<InquiryEntity>, DbDataManager.Service.InquiryDataService>(); builder.Services.AddScoped<IInquiryService<InquiryEntity>, InquiryDataService>();
builder.Services.AddScoped<IInquiryService<InquiryDTO>, Shared.InquiryDataService>(); builder.Services.AddScoped<IInquiryService<InquiryDTO>, InquiryDataServiceApi>();
builder.Services.AddScoped<IParagraphService<ParagraphEntity>, DbDataManager.Service.ParagraphDataService>(); builder.Services.AddScoped<IParagraphService<ParagraphEntity>, ParagraphDataService>();
builder.Services.AddScoped<IParagraphService<ParagraphDTO>, Shared.ParagraphDataService>(); builder.Services.AddScoped<IParagraphService<ParagraphDTO>, ParagraphDataServiceApi>();
builder.Services.AddScoped<ISuccessService<SuccessEntity>, DbDataManager.Service.SuccessDataService>(); builder.Services.AddScoped<ISuccessService<SuccessEntity>, SuccessDataService>();
builder.Services.AddScoped<ISuccessService<SuccessDTO>, Shared.SuccessDataService>(); builder.Services.AddScoped<ISuccessService<SuccessDTO>, SuccessDataServiceApi>();
builder.Services.AddScoped<ILessonService<LessonEntity>, DbDataManager.Service.LessonDataService>(); builder.Services.AddScoped<ILessonService<LessonEntity>, LessonDataService>();
builder.Services.AddScoped<ILessonService<LessonDTO>, Shared.LessonDataService>(); builder.Services.AddScoped<ILessonService<LessonDTO>, LessonDataServiceApi>();
builder.Services.AddDbContext<DbContext, UserDbContext>(); builder.Services.AddDbContext<DbContext, UserDbContext>();
builder.Services.AddDbContext<WebAPIDbContext>(options => options.UseInMemoryDatabase("appDb")); builder.Services.AddDbContext<WebAPIDbContext>(options => options.UseInMemoryDatabase("appDb"));

28
API_SQLuedo/API/Service/InquiryDataServiceAPI.cs
Unescape View File

@ -1,14 +1,21 @@
using Entities; using Dto;
using Entities;
using Model.OrderCriteria; using Model.OrderCriteria;
using Shared; using Shared;
using Shared.Mapper;
namespace API.Service; namespace API.Service;
public class InquiryDataServiceApi(IInquiryService<InquiryEntity> inquiryService) : IInquiryService<InquiryEntity> public class InquiryDataServiceApi(IInquiryService<InquiryEntity> inquiryService) : IInquiryService<InquiryDTO>
{ {
public InquiryEntity CreateInquiry(string title, string description, bool isUser) public InquiryDTO UpdateInquiry(int id, InquiryDTO inquiry)
{ {
return inquiryService.CreateInquiry(title, description, isUser); return inquiryService.UpdateInquiry(id, inquiry.FromDTOToEntity()).FromEntityToDTO();
}
public InquiryDTO CreateInquiry(string title, string description, bool isUser)
{
return inquiryService.CreateInquiry(title, description, isUser).FromEntityToDTO();
} }
public bool DeleteInquiry(int id) public bool DeleteInquiry(int id)
@ -16,18 +23,13 @@ public class InquiryDataServiceApi(IInquiryService<InquiryEntity> inquiryService
return inquiryService.DeleteInquiry(id); return inquiryService.DeleteInquiry(id);
} }
public IEnumerable<InquiryEntity> GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria) public IEnumerable<InquiryDTO> GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria)
{ {
var inquiries = inquiryService.GetInquiries(page, number, orderCriteria); var inquiries = inquiryService.GetInquiries(page, number, orderCriteria);
return inquiries.Select(i => i).ToList(); return inquiries.Select(i => i.FromEntityToDTO()).ToList();
} }
public InquiryEntity GetInquiryById(int id) => inquiryService.GetInquiryById(id); public InquiryDTO GetInquiryById(int id) => inquiryService.GetInquiryById(id).FromEntityToDTO();
public InquiryEntity GetInquiryByTitle(string title) => inquiryService.GetInquiryByTitle(title); public InquiryDTO GetInquiryByTitle(string title) => inquiryService.GetInquiryByTitle(title).FromEntityToDTO();
public InquiryEntity UpdateInquiry(int id, InquiryEntity inquiry)
{
return inquiryService.UpdateInquiry(id, inquiry);
}
} }

25
API_SQLuedo/API/Service/LessonDataServiceAPI.cs
Unescape View File

@ -1,26 +1,31 @@
using Entities; using Dto;
using Entities;
using Model.OrderCriteria; using Model.OrderCriteria;
using Shared; using Shared;
using Shared.Mapper;
namespace API.Service; namespace API.Service;
public class LessonDataServiceApi(ILessonService<LessonEntity> lessonService) : ILessonService<LessonEntity> public class LessonDataServiceApi(ILessonService<LessonEntity> lessonService) : ILessonService<LessonDTO>
{ {
public IEnumerable<LessonEntity> GetLessons(int page, int number, LessonOrderCriteria orderCriteria) public IEnumerable<LessonDTO> GetLessons(int page, int number, LessonOrderCriteria orderCriteria)
{ {
var lessonsEntities = lessonService.GetLessons(page, number, orderCriteria); var lessonsEntities = lessonService.GetLessons(page, number, orderCriteria);
return lessonsEntities.Select(e => e).ToList(); return lessonsEntities.Select(e => e.FromEntityToDTO()).ToList();
} }
public LessonEntity GetLessonById(int id) => lessonService.GetLessonById(id); public LessonDTO GetLessonById(int id) => lessonService.GetLessonById(id).FromEntityToDTO();
public LessonEntity GetLessonByTitle(string title) => lessonService.GetLessonByTitle(title); public LessonDTO GetLessonByTitle(string title) => lessonService.GetLessonByTitle(title).FromEntityToDTO();
public bool DeleteLesson(int id) => lessonService.DeleteLesson(id); public bool DeleteLesson(int id) => lessonService.DeleteLesson(id);
public LessonEntity UpdateLesson(int id, LessonEntity lesson) => public LessonDTO UpdateLesson(int id, LessonDTO lesson) =>
lessonService.UpdateLesson(id, lesson); lessonService.UpdateLesson(id, lesson.FromDTOToEntity()).FromEntityToDTO();
public LessonEntity CreateLesson(string title, string lastPublisher, DateOnly? lastEdit) => public LessonDTO UpdateLesson(int id, LessonEntity lesson) =>
lessonService.CreateLesson(title, lastPublisher, lastEdit); lessonService.UpdateLesson(id, lesson).FromEntityToDTO();
public LessonDTO CreateLesson(string title, string lastPublisher, DateOnly? lastEdit) =>
lessonService.CreateLesson(title, lastPublisher, lastEdit).FromEntityToDTO();
} }

25
API_SQLuedo/API/Service/ParagraphDataServiceAPI.cs
Unescape View File

@ -1,26 +1,31 @@
using Entities; using Dto;
using Entities;
using Model.OrderCriteria; using Model.OrderCriteria;
using Shared; using Shared;
using Shared.Mapper;
namespace API.Service; namespace API.Service;
public class ParagraphDataServiceApi(IParagraphService<ParagraphEntity> paragraphService) : IParagraphService<ParagraphEntity> public class ParagraphDataServiceApi(IParagraphService<ParagraphEntity> paragraphService)
: IParagraphService<ParagraphDTO>
{ {
public IEnumerable<ParagraphEntity> GetParagraphs(int page, int number, ParagraphOrderCriteria orderCriteria) public IEnumerable<ParagraphDTO> GetParagraphs(int page, int number, ParagraphOrderCriteria orderCriteria)
{ {
var paragraphsEntities = paragraphService.GetParagraphs(page, number, orderCriteria); var paragraphsEntities = paragraphService.GetParagraphs(page, number, orderCriteria);
return paragraphsEntities.Select(e => e).ToList(); return paragraphsEntities.Select(e => e.FromEntityToDTO()).ToList();
} }
public ParagraphEntity GetParagraphById(int id) => paragraphService.GetParagraphById(id); public ParagraphDTO GetParagraphById(int id) => paragraphService.GetParagraphById(id).FromEntityToDTO();
public ParagraphEntity GetParagraphByTitle(string title) => paragraphService.GetParagraphByTitle(title); public ParagraphDTO GetParagraphByTitle(string title) =>
paragraphService.GetParagraphByTitle(title).FromEntityToDTO();
public bool DeleteParagraph(int id) => paragraphService.DeleteParagraph(id); public bool DeleteParagraph(int id) => paragraphService.DeleteParagraph(id);
public ParagraphEntity UpdateParagraph(int id, ParagraphEntity paragraph) => public ParagraphDTO UpdateParagraph(int id, ParagraphDTO paragraph) =>
paragraphService.UpdateParagraph(id, paragraph); paragraphService.UpdateParagraph(id, paragraph.FromDTOToEntity()).FromEntityToDTO();
public ParagraphEntity CreateParagraph(string title, string content, string info, string query, string comment, int lessonId) => public ParagraphDTO CreateParagraph(string title, string content, string info, string query, string comment,
paragraphService.CreateParagraph(title, content, info, query, comment, lessonId); int lessonId) =>
paragraphService.CreateParagraph(title, content, info, query, comment, lessonId).FromEntityToDTO();
} }

24
API_SQLuedo/API/Service/SuccessDataServiceAPI.cs
Unescape View File

@ -1,26 +1,28 @@
using Entities; using Dto;
using Entities;
using Model.OrderCriteria; using Model.OrderCriteria;
using Shared; using Shared;
using Shared.Mapper;
namespace API.Service; namespace API.Service;
public class SuccessDataServiceApi(ISuccessService<SuccessEntity> sucessService) : ISuccessService<SuccessEntity> public class SuccessDataServiceApi(ISuccessService<SuccessEntity> sucessService) : ISuccessService<SuccessDTO>
{ {
public IEnumerable<SuccessEntity> GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria) public IEnumerable<SuccessDTO> GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria)
{ {
var successesEntities = sucessService.GetSuccesses(page, number, orderCriteria); var successesEntities = sucessService.GetSuccesses(page, number, orderCriteria);
return successesEntities.Select(e => e).ToList(); return successesEntities.Select(e => e.FromEntityToDTO()).ToList();
} }
public SuccessEntity GetSuccessByUserId(int id) => sucessService.GetSuccessByUserId(id); public IEnumerable<SuccessDTO> GetSuccessesByUserId(int id) => sucessService.GetSuccessesByUserId(id).Select(s => s.FromEntityToDTO());
public SuccessEntity GetSuccessByInquiryId(int id) => sucessService.GetSuccessByInquiryId(id); public IEnumerable<SuccessDTO> GetSuccessesByInquiryId(int id) => sucessService.GetSuccessesByInquiryId(id).Select(s => s.FromEntityToDTO());
public bool DeleteSuccess(int id) => sucessService.DeleteSuccess(id); public bool DeleteSuccess(int idUser, int idInquiry) => sucessService.DeleteSuccess(idUser, idInquiry);
public SuccessEntity UpdateSuccess(int id, SuccessEntity success) => public SuccessDTO UpdateSuccess(int idUser, int idInquiry, SuccessDTO success) =>
sucessService.UpdateSuccess(id, success); sucessService.UpdateSuccess(idUser, idInquiry, success.FromDTOToEntity()).FromEntityToDTO();
public SuccessEntity CreateSuccess(int userId, int inquiryId, bool isFinished) => public SuccessDTO CreateSuccess(int userId, int inquiryId, bool isFinished) =>
sucessService.CreateSuccess(userId, inquiryId, isFinished); sucessService.CreateSuccess(userId, inquiryId, isFinished).FromEntityToDTO();
} }

22
API_SQLuedo/API/Service/UserDataServiceAPI.cs
Unescape View File

@ -1,26 +1,28 @@
using Entities; using Dto;
using Entities;
using Model.OrderCriteria; using Model.OrderCriteria;
using Shared; using Shared;
using Shared.Mapper;
namespace API.Service; namespace API.Service;
public class UserDataServiceApi(IUserService<UserEntity> userService) : IUserService<UserEntity> public class UserDataServiceApi(IUserService<UserEntity> userService) : IUserService<UserDTO>
{ {
public IEnumerable<UserEntity> GetUsers(int page, int number, UserOrderCriteria orderCriteria) public IEnumerable<UserDTO> GetUsers(int page, int number, UserOrderCriteria orderCriteria)
{ {
var usersEntities = userService.GetUsers(page, number, orderCriteria); var usersEntities = userService.GetUsers(page, number, orderCriteria);
return usersEntities.Select(e => e).ToList(); return usersEntities.Select(e => e.FromEntityToDTO()).ToList();
} }
public UserEntity GetUserById(int id) => userService.GetUserById(id); public UserDTO GetUserById(int id) => userService.GetUserById(id).FromEntityToDTO();
public UserEntity GetUserByUsername(string username) => userService.GetUserByUsername(username); public UserDTO GetUserByUsername(string username) => userService.GetUserByUsername(username).FromEntityToDTO();
public bool DeleteUser(int id) => userService.DeleteUser(id); public bool DeleteUser(int id) => userService.DeleteUser(id);
public UserEntity UpdateUser(int id, UserEntity user) => public UserDTO UpdateUser(int id, UserDTO user) =>
userService.UpdateUser(id, user); userService.UpdateUser(id, user.FromDTOToEntity()).FromEntityToDTO();
public UserEntity CreateUser(string username, string password, string email, bool isAdmin) => public UserDTO CreateUser(string username, string password, string email, bool isAdmin) =>
userService.CreateUser(username, password, email, isAdmin); userService.CreateUser(username, password, email, isAdmin).FromEntityToDTO();
} }

4
API_SQLuedo/API/WebAPIDbContext.cs
Unescape View File

@ -6,6 +6,8 @@ namespace API
{ {
public class WebAPIDbContext : IdentityDbContext<IdentityUser> public class WebAPIDbContext : IdentityDbContext<IdentityUser>
{ {
public WebAPIDbContext(DbContextOptions<WebAPIDbContext> options) : base(options) { } public WebAPIDbContext(DbContextOptions<WebAPIDbContext> options) : base(options)
{
}
} }
} }

12
API_SQLuedo/DbContextLib/UserDbContext.cs
Unescape View File

@ -12,24 +12,30 @@ namespace DbContextLib
public DbSet<InquiryEntity> Inquiries { get; set; } public DbSet<InquiryEntity> Inquiries { get; set; }
public DbSet<InquiryTableEntity> InquiryTables { get; set; } public DbSet<InquiryTableEntity> InquiryTables { get; set; }
public DbSet<LessonEntity> Lessons { get; set; } public DbSet<LessonEntity> Lessons { get; set; }
public DbSet<ContentLessonEntity> ContentLessons { get; set; }
public DbSet<ParagraphEntity> Paragraphs { get; set; } public DbSet<ParagraphEntity> Paragraphs { get; set; }
public DbSet<SolutionEntity> Solutions { get; set; } public DbSet<SolutionEntity> Solutions { get; set; }
public DbSet<SuccessEntity> Successes { get; set; } public DbSet<SuccessEntity> Successes { get; set; }
public DbSet<NotepadEntity> Notepads { get; set; } public DbSet<NotepadEntity> Notepads { get; set; }
public UserDbContext(DbContextOptions<UserDbContext> options) : base(options) { }
public UserDbContext(DbContextOptions<UserDbContext> options) : base(options)
{
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{ {
if (!optionsBuilder.IsConfigured) if (!optionsBuilder.IsConfigured)
{ {
optionsBuilder.UseNpgsql("Host=localhost;Database=SQLuedo;Username=admin;Password=motdepasse"); optionsBuilder.UseNpgsql("Host=localhost;Database=SQLuedo;Username=admin;Password=motdepasse");
} }
base.OnConfiguring(optionsBuilder); base.OnConfiguring(optionsBuilder);
} }
protected override void OnModelCreating(ModelBuilder modelBuilder) protected override void OnModelCreating(ModelBuilder modelBuilder)
{ {
modelBuilder.Entity<ContentLessonEntity>().HasKey(c => c.LessonId); // Permet d'avoir les champs de la classe mère dans les classes filles et de ne pas avoir de table pour la classe mère
modelBuilder.Entity<ContentLessonEntity>().UseTpcMappingStrategy();
modelBuilder.Entity<SuccessEntity>().HasKey(s => s.UserId); modelBuilder.Entity<SuccessEntity>().HasKey(s => s.UserId);
modelBuilder.Entity<SuccessEntity>().HasKey(s => s.InquiryId); modelBuilder.Entity<SuccessEntity>().HasKey(s => s.InquiryId);
modelBuilder.Entity<InquiryEntity>().HasKey(s => s.Id); modelBuilder.Entity<InquiryEntity>().HasKey(s => s.Id);

2
API_SQLuedo/DbDataManager/DbDataManager.csproj
Unescape View File

@ -4,7 +4,7 @@
<TargetFramework>net8.0</TargetFramework> <TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings> <ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable> <Nullable>enable</Nullable>
<RootNamespace>ModelToEntities</RootNamespace> <RootNamespace>DbDataManager</RootNamespace>
</PropertyGroup> </PropertyGroup>
<ItemGroup> <ItemGroup>

60
API_SQLuedo/DbDataManager/Service/InquiryDataService.cs
Unescape View File

@ -8,7 +8,7 @@ namespace DbDataManager.Service;
public class InquiryDataService : IInquiryService<InquiryEntity> public class InquiryDataService : IInquiryService<InquiryEntity>
{ {
private UserDbContext DbContext { get; } private UserDbContext DbContext { get; set; }
public InquiryDataService(UserDbContext context) public InquiryDataService(UserDbContext context)
{ {
@ -16,9 +16,33 @@ public class InquiryDataService : IInquiryService<InquiryEntity>
context.Database.EnsureCreated(); context.Database.EnsureCreated();
} }
public IEnumerable<InquiryEntity> GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria)
{
IQueryable<InquiryEntity> query = DbContext.Inquiries.Skip((page - 1) * number).Take(number);
switch (orderCriteria)
{
case InquiryOrderCriteria.None:
break;
case InquiryOrderCriteria.ByTitle:
query = query.OrderBy(s => s.Title);
break;
case InquiryOrderCriteria.ByDescription:
query = query.OrderBy(s => s.Description);
break;
case InquiryOrderCriteria.ByIsUser:
query = query.OrderBy(s => s.IsUser);
break;
default:
break;
}
var inquiries = query.ToList();
return inquiries;
}
public InquiryEntity GetInquiryById(int id) public InquiryEntity GetInquiryById(int id)
{ {
var inquiryEntity = DbContext.Inquiries.FirstOrDefault(u => u.Id == id); var inquiryEntity = DbContext.Inquiries.FirstOrDefault(i => i.Id == id);
if (inquiryEntity == null) if (inquiryEntity == null)
{ {
throw new ArgumentException("Impossible de trouver l'enquête", nameof(id)); throw new ArgumentException("Impossible de trouver l'enquête", nameof(id));
@ -29,7 +53,7 @@ public class InquiryDataService : IInquiryService<InquiryEntity>
public InquiryEntity GetInquiryByTitle(string title) public InquiryEntity GetInquiryByTitle(string title)
{ {
var inquiryEntity = DbContext.Inquiries.FirstOrDefault(u => u.Title == title); var inquiryEntity = DbContext.Inquiries.FirstOrDefault(i => i.Title == title);
if (inquiryEntity == null) if (inquiryEntity == null)
{ {
throw new ArgumentException("Impossible de trouver l'enquête", nameof(title)); throw new ArgumentException("Impossible de trouver l'enquête", nameof(title));
@ -38,10 +62,12 @@ public class InquiryDataService : IInquiryService<InquiryEntity>
return inquiryEntity; return inquiryEntity;
} }
public IEnumerable<InquiryEntity> GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria) public InquiryEntity CreateInquiry(string title, string description, bool isUser)
{ {
return DbContext.Inquiries.Skip((page - 1) * number).Take(number).ToList() var newInquiryEntity = new InquiryEntity(title, description, isUser);
.Select(u => u); DbContext.Inquiries.Add(newInquiryEntity);
DbContext.SaveChangesAsync();
return newInquiryEntity;
} }
public bool DeleteInquiry(int id) public bool DeleteInquiry(int id)
@ -65,25 +91,13 @@ public class InquiryDataService : IInquiryService<InquiryEntity>
throw new ArgumentException("Impossible de trouver l'enquête", nameof(id)); throw new ArgumentException("Impossible de trouver l'enquête", nameof(id));
} }
updatingInquiry.Title = inquiry.Title; foreach (var pptt in typeof(InquiryEntity).GetProperties()
updatingInquiry.Description = inquiry.Description; .Where(p => p.CanWrite && p.Name != nameof(InquiryEntity.Id)))
updatingInquiry.IsUser = inquiry.IsUser; {
// Permet d'indiquer en Db que l'entité a été modifiée. pptt.SetValue(updatingInquiry, pptt.GetValue(inquiry));
DbContext.Entry(updatingInquiry).State = EntityState.Modified;
DbContext.SaveChangesAsync();
return updatingInquiry;
} }
public InquiryEntity CreateInquiry(string title, string description, bool isUser)
{
var newInquiryEntity = new InquiryEntity()
{
Title = title,
Description = description,
IsUser = isUser,
};
DbContext.Inquiries.Add(newInquiryEntity);
DbContext.SaveChangesAsync(); DbContext.SaveChangesAsync();
return newInquiryEntity; return updatingInquiry;
} }
} }

45
API_SQLuedo/DbDataManager/Service/LessonDataService.cs
Unescape View File

@ -16,6 +16,30 @@ public class LessonDataService : ILessonService<LessonEntity>
context.Database.EnsureCreated(); context.Database.EnsureCreated();
} }
public IEnumerable<LessonEntity> GetLessons(int page, int number, LessonOrderCriteria orderCriteria)
{
IQueryable<LessonEntity> query = DbContext.Lessons.Skip((page - 1) * number).Take(number);
switch (orderCriteria)
{
case LessonOrderCriteria.None:
break;
case LessonOrderCriteria.ByTitle:
query = query.OrderBy(s => s.Title);
break;
case LessonOrderCriteria.ByLastPublisher:
query = query.OrderBy(s => s.LastPublisher);
break;
case LessonOrderCriteria.ByLastEdit:
query = query.OrderBy(s => s.LastEdit);
break;
default:
break;
}
var lessons = query.ToList();
return lessons;
}
public LessonEntity GetLessonById(int id) public LessonEntity GetLessonById(int id)
{ {
var lessonEntity = DbContext.Lessons.FirstOrDefault(u => u.Id == id); var lessonEntity = DbContext.Lessons.FirstOrDefault(u => u.Id == id);
@ -38,15 +62,9 @@ public class LessonDataService : ILessonService<LessonEntity>
return lessonEntity; return lessonEntity;
} }
public IEnumerable<LessonEntity> GetLessons(int page, int number, LessonOrderCriteria orderCriteria)
{
return DbContext.Lessons.Skip((page - 1) * number).Take(number).ToList()
.Select(u => u);
}
public bool DeleteLesson(int id) public bool DeleteLesson(int id)
{ {
var lessonEntity = DbContext.Lessons.FirstOrDefault(u => u.Id == id); var lessonEntity = DbContext.Lessons.FirstOrDefault(l => l.Id == id);
if (lessonEntity == null) if (lessonEntity == null)
{ {
return false; return false;
@ -59,17 +77,18 @@ public class LessonDataService : ILessonService<LessonEntity>
public LessonEntity UpdateLesson(int id, LessonEntity lesson) public LessonEntity UpdateLesson(int id, LessonEntity lesson)
{ {
var updatingLesson = DbContext.Lessons.FirstOrDefault(u => u.Id == id); var updatingLesson = DbContext.Lessons.FirstOrDefault(l => l.Id == id);
if (updatingLesson == null) if (updatingLesson == null)
{ {
throw new ArgumentException("Impossible de trouver la leçon", nameof(id)); throw new ArgumentException("Impossible de trouver la leçon", nameof(id));
} }
updatingLesson.Title = lesson.Title; foreach (var pptt in typeof(LessonEntity).GetProperties()
updatingLesson.LastPublisher = lesson.LastPublisher; .Where(p => p.CanWrite && p.Name != nameof(LessonEntity.Id)))
updatingLesson.LastEdit = lesson.LastEdit; {
// Permet d'indiquer en Db que l'entité a été modifiée. pptt.SetValue(updatingLesson, pptt.GetValue(lesson));
DbContext.Entry(updatingLesson).State = EntityState.Modified; }
DbContext.SaveChangesAsync(); DbContext.SaveChangesAsync();
return updatingLesson; return updatingLesson;
} }

57
API_SQLuedo/DbDataManager/Service/ParagraphDataService.cs
Unescape View File

@ -16,6 +16,36 @@ public class ParagraphDataService : IParagraphService<ParagraphEntity>
context.Database.EnsureCreated(); context.Database.EnsureCreated();
} }
public IEnumerable<ParagraphEntity> GetParagraphs(int page, int number, ParagraphOrderCriteria orderCriteria)
{
IQueryable<ParagraphEntity> query = DbContext.Paragraphs.Skip((page - 1) * number).Take(number);
switch (orderCriteria)
{
case ParagraphOrderCriteria.None:
break;
case ParagraphOrderCriteria.ByTitle:
query = query.OrderBy(s => s.Title);
break;
case ParagraphOrderCriteria.ByContent:
query = query.OrderBy(s => s.Content);
break;
case ParagraphOrderCriteria.ByInfo:
query = query.OrderBy(s => s.Info);
break;
case ParagraphOrderCriteria.ByQuery:
query = query.OrderBy(s => s.Query);
break;
case ParagraphOrderCriteria.ByComment:
query = query.OrderBy(s => s.Comment);
break;
default:
break;
}
var paragraphs = query.ToList();
return paragraphs;
}
public ParagraphEntity GetParagraphById(int id) public ParagraphEntity GetParagraphById(int id)
{ {
var paragraphEntity = DbContext.Paragraphs.FirstOrDefault(u => u.Id == id); var paragraphEntity = DbContext.Paragraphs.FirstOrDefault(u => u.Id == id);
@ -38,15 +68,9 @@ public class ParagraphDataService : IParagraphService<ParagraphEntity>
return paragraphEntity; return paragraphEntity;
} }
public IEnumerable<ParagraphEntity> GetParagraphs(int page, int number, ParagraphOrderCriteria orderCriteria)
{
return DbContext.Paragraphs.Skip((page - 1) * number).Take(number).ToList()
.Select(u => u);
}
public bool DeleteParagraph(int id) public bool DeleteParagraph(int id)
{ {
var paragraphEntity = DbContext.Paragraphs.FirstOrDefault(u => u.Id == id); var paragraphEntity = DbContext.Paragraphs.FirstOrDefault(p => p.Id == id);
if (paragraphEntity == null) if (paragraphEntity == null)
{ {
return false; return false;
@ -59,25 +83,24 @@ public class ParagraphDataService : IParagraphService<ParagraphEntity>
public ParagraphEntity UpdateParagraph(int id, ParagraphEntity paragraph) public ParagraphEntity UpdateParagraph(int id, ParagraphEntity paragraph)
{ {
var updatingParagraph = DbContext.Paragraphs.FirstOrDefault(u => u.Id == id); var updatingParagraph = DbContext.Paragraphs.FirstOrDefault(p => p.Id == id);
if (updatingParagraph == null) if (updatingParagraph == null)
{ {
throw new ArgumentException("Impossible de trouver le paragraphe", nameof(id)); throw new ArgumentException("Impossible de trouver le paragraphe", nameof(id));
} }
updatingParagraph.Title = paragraph.Title; foreach (var pptt in typeof(ParagraphEntity).GetProperties().Where(p =>
updatingParagraph.Content = paragraph.Content; p.CanWrite && p.Name != nameof(ParagraphEntity.Id) && p.Name != nameof(ParagraphEntity.LessonId)))
updatingParagraph.Info = paragraph.Info; {
updatingParagraph.Query = paragraph.Query; pptt.SetValue(updatingParagraph, pptt.GetValue(paragraph));
updatingParagraph.Comment = paragraph.Comment; }
updatingParagraph.LessonId = paragraph.LessonId;
// Permet d'indiquer en Db que l'entité a été modifiée.
DbContext.Entry(updatingParagraph).State = EntityState.Modified;
DbContext.SaveChangesAsync(); DbContext.SaveChangesAsync();
return updatingParagraph; return updatingParagraph;
} }
public ParagraphEntity CreateParagraph(string title, string content, string info, string query, string comment, int lessonId) public ParagraphEntity CreateParagraph(string title, string content, string info, string query, string comment,
int lessonId)
{ {
var newParagraphEntity = new ParagraphEntity() var newParagraphEntity = new ParagraphEntity()
{ {

73
API_SQLuedo/DbDataManager/Service/SuccessDataService.cs
Unescape View File

@ -16,60 +16,77 @@ public class SuccessDataService : ISuccessService<SuccessEntity>
context.Database.EnsureCreated(); context.Database.EnsureCreated();
} }
public SuccessEntity GetSuccessByUserId(int id) public IEnumerable<SuccessEntity> GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria)
{ {
var successEntity = DbContext.Successes.FirstOrDefault(u => u.UserId == id); IQueryable<SuccessEntity> query = DbContext.Successes.Skip((page - 1) * number).Take(number);
if (successEntity == null) switch (orderCriteria)
{ {
throw new ArgumentException("Impossible de trouver le succès avec l'user id", nameof(id)); case SuccessOrderCriteria.None:
break;
case SuccessOrderCriteria.ByUserId:
query = query.OrderBy(s => s.UserId);
break;
case SuccessOrderCriteria.ByInquiryId:
query = query.OrderBy(s => s.InquiryId);
break;
case SuccessOrderCriteria.ByIsFinished:
query = query.OrderBy(s => s.IsFinished);
break;
default:
break;
} }
return successEntity; var successes = query.ToList();
return successes;
} }
public SuccessEntity GetSuccessByInquiryId(int id) public IEnumerable<SuccessEntity> GetSuccessesByUserId(int id)
{ {
var successEntity = DbContext.Successes.FirstOrDefault(u => u.InquiryId == id); var successes = DbContext.Successes.Where(u => u.UserId == id);
if (successEntity == null) if (successes == null)
{ {
throw new ArgumentException("Impossible de trouver le succès avec l'inquiry id", nameof(id)); throw new ArgumentException("Impossible de trouver le succès", nameof(id));
} }
return successEntity; return successes;
} }
public IEnumerable<SuccessEntity> GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria) public IEnumerable<SuccessEntity> GetSuccessesByInquiryId(int id)
{ {
return DbContext.Successes.Skip((page - 1) * number).Take(number).ToList() var successes = DbContext.Successes.Where(u => u.InquiryId == id);
.Select(u => u); if (successes == null)
{
throw new ArgumentException("Impossible de trouver le succès", nameof(id));
}
return successes;
} }
public bool DeleteSuccess(int id) public bool DeleteSuccess(int idUser, int idInquiry)
{ {
var userEntity = DbContext.Successes.FirstOrDefault(u => u.UserId == id); var successEntity = DbContext.Successes.FirstOrDefault(u => u.UserId == idUser && u.InquiryId == idInquiry);
if (userEntity == null) if (successEntity == null)
{ {
return false; return false;
} }
DbContext.Successes.Remove(successEntity);
DbContext.Successes.Remove(userEntity);
DbContext.SaveChangesAsync(); DbContext.SaveChangesAsync();
return true; return true;
} }
public SuccessEntity UpdateSuccess(int id, SuccessEntity success) public SuccessEntity UpdateSuccess(int idUser, int idInquiry, SuccessEntity success)
{ {
var updatingSuccess = DbContext.Successes.FirstOrDefault(u => u.UserId == id); var updatingSuccess = DbContext.Successes.FirstOrDefault(u => u.UserId == idUser && u.InquiryId == idInquiry);
if (updatingSuccess == null) if (updatingSuccess == null)
{ {
throw new ArgumentException("Impossible de trouver le succès avec l'user id", nameof(id)); throw new ArgumentException("Impossible de trouver le succès", nameof(idUser));
} }
/*foreach (var pptt in typeof(SuccessEntity).GetProperties().Where(p =>
updatingSuccess.UserId = success.UserId; p.CanWrite && p.Name != nameof(SuccessEntity.UserId) && p.Name != nameof(SuccessEntity.InquiryId)))
updatingSuccess.InquiryId = success.InquiryId; {
pptt.SetValue(updatingSuccess, pptt.GetValue(success));
}*/
updatingSuccess.IsFinished = success.IsFinished; updatingSuccess.IsFinished = success.IsFinished;
// Permet d'indiquer en Db que l'entité a été modifiée.
DbContext.Entry(updatingSuccess).State = EntityState.Modified;
DbContext.SaveChangesAsync(); DbContext.SaveChangesAsync();
return updatingSuccess; return updatingSuccess;
} }
@ -82,8 +99,12 @@ public class SuccessDataService : ISuccessService<SuccessEntity>
InquiryId = inquiryId, InquiryId = inquiryId,
IsFinished = isFinished, IsFinished = isFinished,
}; };
var success = DbContext.Successes.Where(s => s.UserId == userId && s.InquiryId == inquiryId);
if (success == null)
{
DbContext.Successes.Add(newSuccessEntity); DbContext.Successes.Add(newSuccessEntity);
DbContext.SaveChangesAsync(); DbContext.SaveChangesAsync();
}
return newSuccessEntity; return newSuccessEntity;
} }
} }

41
API_SQLuedo/DbDataManager/Service/UserDataService.cs
Unescape View File

@ -1,6 +1,5 @@
using DbContextLib; using DbContextLib;
using Entities; using Entities;
using Microsoft.EntityFrameworkCore;
using Model.OrderCriteria; using Model.OrderCriteria;
using Shared; using Shared;
@ -8,7 +7,6 @@ namespace DbDataManager.Service;
public class UserDataService : IUserService<UserEntity> public class UserDataService : IUserService<UserEntity>
{ {
private UserDbContext DbContext { get; set; } private UserDbContext DbContext { get; set; }
public UserDataService(UserDbContext context) public UserDataService(UserDbContext context)
@ -41,8 +39,29 @@ public class UserDataService : IUserService<UserEntity>
public IEnumerable<UserEntity> GetUsers(int page, int number, UserOrderCriteria orderCriteria) public IEnumerable<UserEntity> GetUsers(int page, int number, UserOrderCriteria orderCriteria)
{ {
return DbContext.Users.Skip((page - 1) * number).Take(number).ToList() IQueryable<UserEntity> query = DbContext.Users.Skip((page - 1) * number).Take(number);
.Select(u => u); switch (orderCriteria)
{
case UserOrderCriteria.None:
break;
case UserOrderCriteria.ById:
query = query.OrderBy(s => s.Id);
break;
case UserOrderCriteria.ByUsername:
query = query.OrderBy(s => s.Username);
break;
case UserOrderCriteria.ByEmail:
query = query.OrderBy(s => s.Email);
break;
case UserOrderCriteria.ByIsAdmin:
query = query.OrderBy(s => s.IsAdmin);
break;
default:
break;
}
var users = query.ToList();
return users;
} }
public bool DeleteUser(int id) public bool DeleteUser(int id)
@ -66,19 +85,19 @@ public class UserDataService : IUserService<UserEntity>
throw new ArgumentException("Impossible de trouver l'utilisateur", nameof(id)); throw new ArgumentException("Impossible de trouver l'utilisateur", nameof(id));
} }
updatingUser.Username = user.Username; foreach (var pptt in typeof(UserEntity).GetProperties()
updatingUser.Password = user.Password; .Where(p => p.CanWrite && p.Name != nameof(UserEntity.Id)))
updatingUser.Email = user.Email; {
updatingUser.IsAdmin = user.IsAdmin; pptt.SetValue(updatingUser, pptt.GetValue(user));
// Permet d'indiquer en Db que l'entité a été modifiée. }
DbContext.Entry(updatingUser).State = EntityState.Modified;
DbContext.SaveChangesAsync(); DbContext.SaveChangesAsync();
return updatingUser; return updatingUser;
} }
public UserEntity CreateUser(string username, string password, string email, bool isAdmin) public UserEntity CreateUser(string username, string password, string email, bool isAdmin)
{ {
var newUserEntity = new UserEntity() var newUserEntity = new UserEntity
{ {
Username = username, Username = username,
Password = password, Password = password,

1
API_SQLuedo/Dto/BlackListDTO.cs
Unescape View File

@ -5,6 +5,7 @@ public class BlackListDTO
public string Email { get; set; } public string Email { get; set; }
public DateOnly ExpirationDate { get; set; } public DateOnly ExpirationDate { get; set; }
public BlackListDTO() {}
public BlackListDTO(string email, DateOnly expirationDate) public BlackListDTO(string email, DateOnly expirationDate)
{ {
Email = email; Email = email;

1
API_SQLuedo/Dto/InquiryDTO.cs
Unescape View File

@ -10,6 +10,7 @@ public class InquiryDTO : IEquatable<InquiryDTO>
public bool IsUser { get; set; } public bool IsUser { get; set; }
public InquiryDTO(){}
public InquiryDTO(int id, string title, string description, bool isUser) public InquiryDTO(int id, string title, string description, bool isUser)
{ {
Id = id; Id = id;

5
API_SQLuedo/Dto/InquiryTableDTO.cs
Unescape View File

@ -2,12 +2,13 @@
public class InquiryTableDTO public class InquiryTableDTO
{ {
public int OwnerId { get; set; } public int OwnerId { get; set; }
public string DatabaseName { get; set; } public string DatabaseName { get; set; }
public string ConnectionInfo { get; set; } public string ConnectionInfo { get; set; }
public InquiryTableDTO() { } public InquiryTableDTO()
{
}
public InquiryTableDTO(int ownerId, string databaseName, string connectionInfo) public InquiryTableDTO(int ownerId, string databaseName, string connectionInfo)
{ {

5
API_SQLuedo/Dto/LessonDTO.cs
Unescape View File

@ -8,7 +8,10 @@ public class LessonDTO
public DateOnly? LastEdit { get; set; } public DateOnly? LastEdit { get; set; }
public ICollection<ContentLessonDTO> Content { get; set; } = new List<ContentLessonDTO>(); public ICollection<ContentLessonDTO> Content { get; set; } = new List<ContentLessonDTO>();
public LessonDTO() { } public LessonDTO()
{
}
public LessonDTO(int id, string title, string lastPublisher, DateOnly? lastEdit) public LessonDTO(int id, string title, string lastPublisher, DateOnly? lastEdit)
{ {
Id = id; Id = id;

5
API_SQLuedo/Dto/NotepadDTO.cs
Unescape View File

@ -7,7 +7,9 @@ public class NotepadDTO
public int InquiryId { get; set; } public int InquiryId { get; set; }
public string Notes { get; set; } public string Notes { get; set; }
public NotepadDTO() { } public NotepadDTO()
{
}
public NotepadDTO(int id, int userId, int inquiryId, string notes) public NotepadDTO(int id, int userId, int inquiryId, string notes)
{ {
@ -16,6 +18,7 @@ public class NotepadDTO
InquiryId = inquiryId; InquiryId = inquiryId;
Notes = notes; Notes = notes;
} }
public NotepadDTO(int userId, int inquiryId, string notes) public NotepadDTO(int userId, int inquiryId, string notes)
{ {
UserId = userId; UserId = userId;

13
API_SQLuedo/Dto/SolutionDTO.cs
Unescape View File

@ -8,8 +8,13 @@ public class SolutionDTO
public string MurderPlace { get; set; } public string MurderPlace { get; set; }
public string MurderWeapon { get; set; } public string MurderWeapon { get; set; }
public string Explanation { get; set; } public string Explanation { get; set; }
public SolutionDTO() { }
public SolutionDTO(int ownerId, string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon, string explanation) public SolutionDTO()
{
}
public SolutionDTO(int ownerId, string murdererFirstName, string murdererLastName, string murderPlace,
string murderWeapon, string explanation)
{ {
OwnerId = ownerId; OwnerId = ownerId;
MurdererFirstName = murdererFirstName; MurdererFirstName = murdererFirstName;
@ -18,7 +23,9 @@ public class SolutionDTO
MurderWeapon = murderWeapon; MurderWeapon = murderWeapon;
Explanation = explanation; Explanation = explanation;
} }
public SolutionDTO(string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon, string explanation)
public SolutionDTO(string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon,
string explanation)
{ {
MurdererFirstName = murdererFirstName; MurdererFirstName = murdererFirstName;
MurdererLastName = murdererLastName; MurdererLastName = murdererLastName;

4
API_SQLuedo/Dto/SuccessDTO.cs
Unescape View File

@ -6,7 +6,9 @@ public class SuccessDTO
public int InquiryId { get; set; } public int InquiryId { get; set; }
public bool IsFinished { get; set; } public bool IsFinished { get; set; }
public SuccessDTO() { } public SuccessDTO()
{
}
public SuccessDTO(int userId, int inquiryId, bool isFinished) public SuccessDTO(int userId, int inquiryId, bool isFinished)
{ {

5
API_SQLuedo/Dto/UserDTO.cs
Unescape View File

@ -8,7 +8,10 @@
public string Email { get; set; } public string Email { get; set; }
public bool IsAdmin { get; set; } public bool IsAdmin { get; set; }
public UserDTO() { } public UserDTO()
{
}
public UserDTO(int id, string username, string password, string email, bool isAdmin) public UserDTO(int id, string username, string password, string email, bool isAdmin)
{ {
Id = id; Id = id;

9
API_SQLuedo/EntityFramework/BlackListEntity.cs
Unescape View File

@ -6,10 +6,13 @@ namespace Entities;
[Table("BlackList")] [Table("BlackList")]
public class BlackListEntity public class BlackListEntity
{ {
[Key] [Key] public string Email { get; set; }
public string Email { get; set; }
public DateOnly ExpirationDate { get; set; } public DateOnly ExpirationDate { get; set; }
public BlackListEntity() { }
public BlackListEntity()
{
}
public BlackListEntity(string email, DateOnly expirationDate) public BlackListEntity(string email, DateOnly expirationDate)
{ {
Email = email; Email = email;

5
API_SQLuedo/EntityFramework/ContentLessonEntity.cs
Unescape View File

@ -2,14 +2,13 @@
namespace Entities; namespace Entities;
[Table("ContentLesson")]
public abstract class ContentLessonEntity public abstract class ContentLessonEntity
{ {
public int Id { get; set; } public int Id { get; set; }
public string ContentContent { get; set; } public string ContentContent { get; set; }
public string ContentTitle { get; set; } public string ContentTitle { get; set; }
[ForeignKey(nameof(Lesson))] public int LessonId { get; set; } [ForeignKey(nameof(Lesson))] public virtual int LessonId { get; set; }
public LessonEntity Lesson { get; set; } = null!; public virtual LessonEntity Lesson { get; set; } = null!;
protected ContentLessonEntity() protected ContentLessonEntity()
{ {

6
API_SQLuedo/EntityFramework/InquiryTableEntity.cs
Unescape View File

@ -11,16 +11,20 @@ public class InquiryTableEntity
[DatabaseGenerated(DatabaseGeneratedOption.Identity)] [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
[Required] [Required]
public int OwnerId { get; set; } public int OwnerId { get; set; }
public InquiryEntity Owner { get; set; } public InquiryEntity Owner { get; set; }
public string DatabaseName { get; set; } public string DatabaseName { get; set; }
public string ConnectionInfo { get; set; } public string ConnectionInfo { get; set; }
public InquiryTableEntity() { } public InquiryTableEntity()
{
}
public InquiryTableEntity(int inquiryId) public InquiryTableEntity(int inquiryId)
{ {
OwnerId = inquiryId; OwnerId = inquiryId;
} }
public InquiryTableEntity(int inquiryId, string databaseName, string connectionInfo) public InquiryTableEntity(int inquiryId, string databaseName, string connectionInfo)
{ {
OwnerId = inquiryId; OwnerId = inquiryId;

4
API_SQLuedo/EntityFramework/LessonEntity.cs
Unescape View File

@ -11,7 +11,9 @@ public class LessonEntity
public DateOnly? LastEdit { get; set; } public DateOnly? LastEdit { get; set; }
public ICollection<ContentLessonEntity> Content { get; set; } = new List<ContentLessonEntity>(); public ICollection<ContentLessonEntity> Content { get; set; } = new List<ContentLessonEntity>();
public LessonEntity() { } public LessonEntity()
{
}
public LessonEntity(int id, string title, string lastPublisher, DateOnly? lastEdit) public LessonEntity(int id, string title, string lastPublisher, DateOnly? lastEdit)
{ {

11
API_SQLuedo/EntityFramework/NotepadEntity.cs
Unescape View File

@ -7,16 +7,16 @@ public class NotepadEntity
{ {
public int Id { get; set; } public int Id { get; set; }
[ForeignKey(nameof(User))] [ForeignKey(nameof(User))] public int UserId { get; set; }
public int UserId { get; set; }
public UserEntity User { get; set; } public UserEntity User { get; set; }
[ForeignKey(nameof(Inquiry))] [ForeignKey(nameof(Inquiry))] public int InquiryId { get; set; }
public int InquiryId { get; set; }
public InquiryEntity Inquiry { get; set; } public InquiryEntity Inquiry { get; set; }
public string Notes { get; set; } public string Notes { get; set; }
public NotepadEntity() { } public NotepadEntity()
{
}
public NotepadEntity(int id, int userId, UserEntity user, int inquiryId, InquiryEntity inquiry, string notes) public NotepadEntity(int id, int userId, UserEntity user, int inquiryId, InquiryEntity inquiry, string notes)
{ {
@ -27,6 +27,7 @@ public class NotepadEntity
Inquiry = inquiry; Inquiry = inquiry;
Notes = notes; Notes = notes;
} }
public NotepadEntity(int userId, UserEntity user, int inquiryId, InquiryEntity inquiry, string notes) public NotepadEntity(int userId, UserEntity user, int inquiryId, InquiryEntity inquiry, string notes)
{ {
UserId = userId; UserId = userId;

19
API_SQLuedo/EntityFramework/SolutionEntity.cs
Unescape View File

@ -11,18 +11,25 @@ public class SolutionEntity
[DatabaseGenerated(DatabaseGeneratedOption.Identity)] [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
[Required] [Required]
public int OwnerId { get; set; } public int OwnerId { get; set; }
public InquiryEntity? Owner { get; set; } public InquiryEntity? Owner { get; set; }
public string? MurdererFirstName { get; set; } public string? MurdererFirstName { get; set; }
public string? MurdererLastName { get; set; } public string? MurdererLastName { get; set; }
public string? MurderPlace { get; set; } public string? MurderPlace { get; set; }
public string? MurderWeapon { get; set; } public string? MurderWeapon { get; set; }
public string? Explaination { get; set; } public string? Explaination { get; set; }
public SolutionEntity() { }
public SolutionEntity()
{
}
public SolutionEntity(int ownerId) public SolutionEntity(int ownerId)
{ {
OwnerId = ownerId; OwnerId = ownerId;
} }
public SolutionEntity(int ownerId, InquiryEntity? owner, string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon, string explaination)
public SolutionEntity(int ownerId, InquiryEntity? owner, string murdererFirstName, string murdererLastName,
string murderPlace, string murderWeapon, string explaination)
{ {
OwnerId = ownerId; OwnerId = ownerId;
Owner = owner; Owner = owner;
@ -32,7 +39,9 @@ public class SolutionEntity
MurderWeapon = murderWeapon; MurderWeapon = murderWeapon;
Explaination = explaination; Explaination = explaination;
} }
public SolutionEntity(InquiryEntity? owner, string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon, string explaination)
public SolutionEntity(InquiryEntity? owner, string murdererFirstName, string murdererLastName, string murderPlace,
string murderWeapon, string explaination)
{ {
Owner = owner; Owner = owner;
MurdererFirstName = murdererFirstName; MurdererFirstName = murdererFirstName;
@ -41,7 +50,9 @@ public class SolutionEntity
MurderWeapon = murderWeapon; MurderWeapon = murderWeapon;
Explaination = explaination; Explaination = explaination;
} }
public SolutionEntity(int ownerId, string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon, string explanation)
public SolutionEntity(int ownerId, string murdererFirstName, string murdererLastName, string murderPlace,
string murderWeapon, string explanation)
{ {
OwnerId = ownerId; OwnerId = ownerId;
MurdererFirstName = murdererFirstName; MurdererFirstName = murdererFirstName;

10
API_SQLuedo/EntityFramework/SuccessEntity.cs
Unescape View File

@ -5,16 +5,16 @@ namespace Entities;
[Table("Success")] [Table("Success")]
public class SuccessEntity public class SuccessEntity
{ {
[ForeignKey(nameof(User))] [ForeignKey(nameof(User))] public int UserId { get; set; }
public int UserId { get; set; }
public UserEntity User { get; set; } public UserEntity User { get; set; }
[ForeignKey(nameof(Inquiry))] [ForeignKey(nameof(Inquiry))] public int InquiryId { get; set; }
public int InquiryId { get; set; }
public InquiryEntity Inquiry { get; set; } public InquiryEntity Inquiry { get; set; }
public bool IsFinished { get; set; } public bool IsFinished { get; set; }
public SuccessEntity() { } public SuccessEntity()
{
}
public SuccessEntity(int userId, UserEntity user, int inquiryId, InquiryEntity inquiry, bool isFinished) public SuccessEntity(int userId, UserEntity user, int inquiryId, InquiryEntity inquiry, bool isFinished)
{ {

4
API_SQLuedo/Model/Inquiry.cs
Unescape View File

@ -7,7 +7,9 @@ public class Inquiry
public string Description { get; set; } public string Description { get; set; }
public bool IsUser { get; set; } public bool IsUser { get; set; }
public Inquiry() { } public Inquiry()
{
}
public Inquiry(int id, string title, string description, bool isUser) public Inquiry(int id, string title, string description, bool isUser)
{ {

6
API_SQLuedo/Model/InquiryTable.cs
Unescape View File

@ -6,12 +6,14 @@ public class InquiryTable
public string DatabaseName { get; set; } public string DatabaseName { get; set; }
public string ConnectionInfo { get; set; } public string ConnectionInfo { get; set; }
public InquiryTable() { } public InquiryTable()
{
}
public InquiryTable(int inquiryId, string databaseName, string connectionInfo) public InquiryTable(int inquiryId, string databaseName, string connectionInfo)
{ {
OwnerId = inquiryId; OwnerId = inquiryId;
DatabaseName = databaseName; DatabaseName = databaseName;
ConnectionInfo = connectionInfo; ConnectionInfo = connectionInfo;
} }
} }

5
API_SQLuedo/Model/Notepad.cs
Unescape View File

@ -7,7 +7,9 @@ public class Notepad
public int InquiryId { get; set; } public int InquiryId { get; set; }
public string Notes { get; set; } public string Notes { get; set; }
public Notepad() { } public Notepad()
{
}
public Notepad(int id, int userId, int inquiryId, string notes) public Notepad(int id, int userId, int inquiryId, string notes)
{ {
@ -16,6 +18,7 @@ public class Notepad
InquiryId = inquiryId; InquiryId = inquiryId;
Notes = notes; Notes = notes;
} }
public Notepad(int userId, int inquiryId, string notes) public Notepad(int userId, int inquiryId, string notes)
{ {
UserId = userId; UserId = userId;

5
API_SQLuedo/Model/OrderCriteria/InquiryOrderCriteria.cs
Unescape View File

@ -2,5 +2,8 @@ namespace Model.OrderCriteria;
public enum InquiryOrderCriteria public enum InquiryOrderCriteria
{ {
None, ByTitle, ByDescription, ByIsUser None,
ByTitle,
ByDescription,
ByIsUser
} }

5
API_SQLuedo/Model/OrderCriteria/LessonOrderCriteria.cs
Unescape View File

@ -2,5 +2,8 @@ namespace Model.OrderCriteria;
public enum LessonOrderCriteria public enum LessonOrderCriteria
{ {
None, ByTitle, ByLastPublisher, ByLastEdit None,
ByTitle,
ByLastPublisher,
ByLastEdit
} }

7
API_SQLuedo/Model/OrderCriteria/ParagraphOrderCriteria.cs
Unescape View File

@ -2,5 +2,10 @@ namespace Model.OrderCriteria;
public enum ParagraphOrderCriteria public enum ParagraphOrderCriteria
{ {
None, ByTitle, ByContent, ByInfo, ByQuery, ByComment None,
ByTitle,
ByContent,
ByInfo,
ByQuery,
ByComment
} }

5
API_SQLuedo/Model/OrderCriteria/SuccessOrderCriteria.cs
Unescape View File

@ -2,5 +2,8 @@ namespace Model.OrderCriteria;
public enum SuccessOrderCriteria public enum SuccessOrderCriteria
{ {
None, ByUserId, ByInquiryId, ByIsFinished None,
ByUserId,
ByInquiryId,
ByIsFinished
} }

6
API_SQLuedo/Model/OrderCriteria/UserOrderCriteria.cs
Unescape View File

@ -2,5 +2,9 @@ namespace Model.OrderCriteria;
public enum UserOrderCriteria public enum UserOrderCriteria
{ {
None, ById, ByUsername, ByEmail, ByIsAdmin None,
ById,
ByUsername,
ByEmail,
ByIsAdmin
} }

13
API_SQLuedo/Model/Solution.cs
Unescape View File

@ -8,8 +8,13 @@ public class Solution
public string MurderPlace { get; set; } public string MurderPlace { get; set; }
public string MurderWeapon { get; set; } public string MurderWeapon { get; set; }
public string Explanation { get; set; } public string Explanation { get; set; }
public Solution() { }
public Solution(int ownerId, string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon, string explanation) public Solution()
{
}
public Solution(int ownerId, string murdererFirstName, string murdererLastName, string murderPlace,
string murderWeapon, string explanation)
{ {
OwnerId = ownerId; OwnerId = ownerId;
MurdererFirstName = murdererFirstName; MurdererFirstName = murdererFirstName;
@ -18,7 +23,9 @@ public class Solution
MurderWeapon = murderWeapon; MurderWeapon = murderWeapon;
Explanation = explanation; Explanation = explanation;
} }
public Solution(string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon, string explanation)
public Solution(string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon,
string explanation)
{ {
MurdererFirstName = murdererFirstName; MurdererFirstName = murdererFirstName;
MurdererLastName = murdererLastName; MurdererLastName = murdererLastName;

4
API_SQLuedo/Model/Success.cs
Unescape View File

@ -6,7 +6,9 @@ public class Success
public int InquiryId { get; set; } public int InquiryId { get; set; }
public bool IsFinished { get; set; } public bool IsFinished { get; set; }
public Success() { } public Success()
{
}
public Success(int userId, int inquiryId, bool isFinished) public Success(int userId, int inquiryId, bool isFinished)
{ {

5
API_SQLuedo/Model/User.cs
Unescape View File

@ -8,7 +8,10 @@ public class User
public string Email { get; set; } public string Email { get; set; }
public bool IsAdmin { get; set; } public bool IsAdmin { get; set; }
public User() { } public User()
{
}
public User(int id, string username, string password, string email, bool isAdmin) public User(int id, string username, string password, string email, bool isAdmin)
{ {
Id = id; Id = id;

14
API_SQLuedo/Shared/IInquiryDataService.cs
Unescape View File

@ -1,14 +0,0 @@
using Dto;
using Model.OrderCriteria;
namespace Shared;
public interface IInquiryDataService : IInquiryService<InquiryDTO>
{
public IEnumerable<InquiryDTO> GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria);
public InquiryDTO GetInquiryById(int id);
public InquiryDTO GetInquiryByTitle(string title);
public bool DeleteInquiry(int id);
public InquiryDTO UpdateInquiry(int id, InquiryDTO inquiry);
public InquiryDTO CreateInquiry(string title, string description, bool isUser);
}

15
API_SQLuedo/Shared/ILessonDataService.cs
Unescape View File

@ -1,15 +0,0 @@
using Dto;
using Model.OrderCriteria;
namespace Shared;
public interface ILessonDataService : ILessonService<LessonDTO>
{
public IEnumerable<LessonDTO> GetLessons(int page, int number, LessonOrderCriteria orderCriteria);
public LessonDTO GetLessonById(int id);
public LessonDTO GetLessonByTitle(string title);
public bool DeleteLesson(int id);
public LessonDTO UpdateLesson(int id, LessonDTO lesson);
public LessonDTO CreateLesson(string title, string lastPublisher, DateOnly? lastEdit);
}

14
API_SQLuedo/Shared/IParagraphDataService.cs
Unescape View File

@ -1,14 +0,0 @@
using Dto;
using Model.OrderCriteria;
namespace Shared;
public interface IParagraphDataService : IParagraphService<ParagraphDTO>
{
public IEnumerable<ParagraphDTO> GetParagraphs(int page, int number, ParagraphOrderCriteria orderCriteria);
public ParagraphDTO GetParagraphById(int id);
public ParagraphDTO GetParagraphByTitle(string title);
public bool DeleteParagraph(int id);
public ParagraphDTO UpdateParagraph(int id, ParagraphDTO paragraph);
public ParagraphDTO CreateParagraph(string title, string content, string info, string query, string comment, int lessonId);
}

4
API_SQLuedo/Shared/IParagraphService.cs
Unescape View File

@ -9,6 +9,8 @@ namespace Shared
public TParagraph GetParagraphByTitle(string title); public TParagraph GetParagraphByTitle(string title);
public bool DeleteParagraph(int id); public bool DeleteParagraph(int id);
public TParagraph UpdateParagraph(int id, TParagraph paragraph); public TParagraph UpdateParagraph(int id, TParagraph paragraph);
public TParagraph CreateParagraph(string title, string content, string info, string query, string comment, int lessonId);
public TParagraph CreateParagraph(string title, string content, string info, string query, string comment,
int lessonId);
} }
} }

14
API_SQLuedo/Shared/ISuccessDataService.cs
Unescape View File

@ -1,14 +0,0 @@
using Dto;
using Model.OrderCriteria;
namespace Shared;
public interface ISuccessDataService : ISuccessService<SuccessDTO>
{
public IEnumerable<SuccessDTO> GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria);
public SuccessDTO GetSuccessByUserId(int id);
public SuccessDTO GetSuccessByInquiryId(int id);
public bool DeleteSuccess(int id);
public SuccessDTO UpdateSuccess(int id, SuccessDTO success);
public SuccessDTO CreateSuccess(int userId, int inquiryId, bool isFinished);
}

8
API_SQLuedo/Shared/ISuccessService.cs
Unescape View File

@ -5,10 +5,10 @@ namespace Shared
public interface ISuccessService<TSuccess> public interface ISuccessService<TSuccess>
{ {
public IEnumerable<TSuccess> GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria); public IEnumerable<TSuccess> GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria);
public TSuccess GetSuccessByUserId(int id); public IEnumerable<TSuccess> GetSuccessesByUserId(int id);
public TSuccess GetSuccessByInquiryId(int id); public IEnumerable<TSuccess> GetSuccessesByInquiryId(int id);
public bool DeleteSuccess(int id); public bool DeleteSuccess(int idUser, int idInquiry);
public TSuccess UpdateSuccess(int id, TSuccess success); public TSuccess UpdateSuccess(int idUser, int idInquiry, TSuccess success);
public TSuccess CreateSuccess(int userId, int inquiryId, bool isFinished); public TSuccess CreateSuccess(int userId, int inquiryId, bool isFinished);
} }
} }

14
API_SQLuedo/Shared/IUserDataService.cs
Unescape View File

@ -1,14 +0,0 @@
using Dto;
using Model.OrderCriteria;
namespace Shared;
public interface IUserDataService : IUserService<UserDTO>
{
public IEnumerable<UserDTO> GetUsers(int page, int number, UserOrderCriteria orderCriteria);
public UserDTO GetUserById(int id);
public UserDTO GetUserByUsername(string username);
public bool DeleteUser(int id);
public UserDTO UpdateUser(int id, UserDTO user);
public UserDTO CreateUser(string username, string password, string email, bool isAdmin);
}

101
API_SQLuedo/Shared/InquiryDataService.cs
Unescape View File

@ -1,101 +0,0 @@
using Entities;
using Microsoft.EntityFrameworkCore;
using Dto;
using Model.OrderCriteria;
using DbContextLib;
using Shared.Mapper;
namespace Shared;
public class InquiryDataService : IInquiryDataService
{
private UserDbContext DbContext { get; set; }
public InquiryDataService(UserDbContext context)
{
DbContext = context;
context.Database.EnsureCreated();
}
public IEnumerable<InquiryDTO> GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria)
{
IQueryable<InquiryEntity> query = DbContext.Inquiries.Skip((page - 1) * number).Take(number);
switch (orderCriteria)
{
case InquiryOrderCriteria.None:
break;
case InquiryOrderCriteria.ByTitle:
query = query.OrderBy(s => s.Title);
break;
case InquiryOrderCriteria.ByDescription:
query = query.OrderBy(s => s.Description);
break;
case InquiryOrderCriteria.ByIsUser:
query = query.OrderBy(s => s.IsUser);
break;
default:
break;
}
var inquiries = query.ToList();
return inquiries.Select(s => s.FromEntityToDTO());
}
public InquiryDTO GetInquiryById(int id)
{
var inquiryEntity = DbContext.Inquiries.FirstOrDefault(i => i.Id == id);
if (inquiryEntity == null)
{
throw new ArgumentException("Impossible de trouver l'enquête", nameof(id));
}
return inquiryEntity.FromEntityToDTO();
}
public InquiryDTO GetInquiryByTitle(string title)
{
var inquiryEntity = DbContext.Inquiries.FirstOrDefault(i => i.Title == title);
if (inquiryEntity == null)
{
throw new ArgumentException("Impossible de trouver l'enquête", nameof(title));
}
return inquiryEntity.FromEntityToDTO();
}
public InquiryDTO CreateInquiry(string title, string description, bool isUser)
{
var newInquiryEntity = new InquiryDTO(title, description, isUser);
DbContext.Inquiries.Add(newInquiryEntity.FromDTOToEntity());
DbContext.SaveChangesAsync();
return newInquiryEntity;
}
public bool DeleteInquiry(int id)
{
var inquiryEntity = DbContext.Inquiries.FirstOrDefault(u => u.Id == id);
if (inquiryEntity == null)
{
return false;
}
DbContext.Inquiries.Remove(inquiryEntity);
DbContext.SaveChangesAsync();
return true;
}
public InquiryDTO UpdateInquiry(int id, InquiryDTO inquiry)
{
var updatingInquiry = DbContext.Inquiries.FirstOrDefault(u => u.Id == id);
if (updatingInquiry == null)
{
throw new ArgumentException("Impossible de trouver l'enquête", nameof(id));
}
updatingInquiry.Title = inquiry.Title;
updatingInquiry.Description = inquiry.Description;
updatingInquiry.IsUser = inquiry.IsUser;
DbContext.SaveChangesAsync();
return updatingInquiry.FromEntityToDTO();
}
}

103
API_SQLuedo/Shared/LessonDataService.cs
Unescape View File

@ -1,103 +0,0 @@
using DbContextLib;
using Entities;
using Microsoft.EntityFrameworkCore;
using Dto;
using Model.OrderCriteria;
using Shared.Mapper;
namespace Shared;
public class LessonDataService : ILessonDataService
{
private UserDbContext DbContext { get; set; }
public LessonDataService(UserDbContext context)
{
DbContext = context;
context.Database.EnsureCreated();
}
public IEnumerable<LessonDTO> GetLessons(int page, int number, LessonOrderCriteria orderCriteria)
{
IQueryable<LessonEntity> query = DbContext.Lessons.Skip((page - 1) * number).Take(number);
switch (orderCriteria)
{
case LessonOrderCriteria.None:
break;
case LessonOrderCriteria.ByTitle:
query = query.OrderBy(s => s.Title);
break;
case LessonOrderCriteria.ByLastPublisher:
query = query.OrderBy(s => s.LastPublisher);
break;
case LessonOrderCriteria.ByLastEdit:
query = query.OrderBy(s => s.LastEdit);
break;
default:
break;
}
var lessons = query.ToList();
return lessons.Select(s => s.FromEntityToDTO());
}
public LessonDTO GetLessonById(int id)
{
var lessonEntity = DbContext.Lessons.FirstOrDefault(u => u.Id == id);
if (lessonEntity == null)
{
throw new ArgumentException("Impossible de trouver la leçon", nameof(id));
}
return lessonEntity.FromEntityToDTO();
}
public LessonDTO GetLessonByTitle(string title)
{
var lessonEntity = DbContext.Lessons.FirstOrDefault(u => u.Title == title);
if (lessonEntity == null)
{
throw new ArgumentException("Impossible de trouver la leçon", nameof(title));
}
return lessonEntity.FromEntityToDTO();
}
public bool DeleteLesson(int id)
{
var lessonEntity = DbContext.Lessons.FirstOrDefault(l => l.Id == id);
if (lessonEntity == null)
{
return false;
}
DbContext.Lessons.Remove(lessonEntity);
DbContext.SaveChangesAsync();
return true;
}
public LessonDTO UpdateLesson(int id, LessonDTO lesson)
{
var updatingLesson = DbContext.Lessons.FirstOrDefault(l => l.Id == id);
if (updatingLesson == null)
{
throw new ArgumentException("Impossible de trouver la leçon", nameof(id));
}
updatingLesson.Title = lesson.Title;
updatingLesson.LastPublisher = lesson.LastPublisher;
updatingLesson.LastEdit = lesson.LastEdit;
DbContext.SaveChangesAsync();
return updatingLesson.FromEntityToDTO();
}
public LessonDTO CreateLesson(string title, string lastPublisher, DateOnly? lastEdit)
{
var newLessonEntity = new LessonDTO()
{
Title = title,
LastPublisher = lastPublisher,
LastEdit = lastEdit,
};
DbContext.Lessons.Add(newLessonEntity.FromDTOToEntity());
DbContext.SaveChangesAsync();
return newLessonEntity;
}
}

116
API_SQLuedo/Shared/ParagraphDataService.cs
Unescape View File

@ -1,116 +0,0 @@
using Entities;
using Microsoft.EntityFrameworkCore;
using Dto;
using DbContextLib;
using Model.OrderCriteria;
using Shared;
using Shared.Mapper;
namespace Shared;
public class ParagraphDataService : IParagraphDataService
{
private UserDbContext DbContext { get; set; }
public ParagraphDataService(UserDbContext context)
{
DbContext = context;
context.Database.EnsureCreated();
}
public IEnumerable<ParagraphDTO> GetParagraphs(int page, int number, ParagraphOrderCriteria orderCriteria)
{
IQueryable<ParagraphEntity> query = DbContext.Paragraphs.Skip((page - 1) * number).Take(number);
switch (orderCriteria)
{
case ParagraphOrderCriteria.None:
break;
case ParagraphOrderCriteria.ByTitle:
query = query.OrderBy(s => s.Title);
break;
case ParagraphOrderCriteria.ByContent:
query = query.OrderBy(s => s.Content);
break;
case ParagraphOrderCriteria.ByInfo:
query = query.OrderBy(s => s.Info);
break;
case ParagraphOrderCriteria.ByQuery:
query = query.OrderBy(s => s.Query);
break;
case ParagraphOrderCriteria.ByComment:
query = query.OrderBy(s => s.Comment);
break;
default:
break;
}
var paragraphs = query.ToList();
return paragraphs.Select(s => s.FromEntityToDTO());
}
public ParagraphDTO GetParagraphById(int id)
{
var paragraphEntity = DbContext.Paragraphs.FirstOrDefault(u => u.Id == id);
if (paragraphEntity == null)
{
throw new ArgumentException("Impossible de trouver le paragraphe", nameof(id));
}
return paragraphEntity.FromEntityToDTO();
}
public ParagraphDTO GetParagraphByTitle(string title)
{
var paragraphEntity = DbContext.Paragraphs.FirstOrDefault(u => u.Title == title);
if (paragraphEntity == null)
{
throw new ArgumentException("Impossible de trouver le paragraphe", nameof(title));
}
return paragraphEntity.FromEntityToDTO();
}
public bool DeleteParagraph(int id)
{
var paragraphEntity = DbContext.Paragraphs.FirstOrDefault(p => p.Id == id);
if (paragraphEntity == null)
{
return false;
}
DbContext.Paragraphs.Remove(paragraphEntity);
DbContext.SaveChangesAsync();
return true;
}
public ParagraphDTO UpdateParagraph(int id, ParagraphDTO paragraphDTO)
{
var updatingParagraph = DbContext.Paragraphs.FirstOrDefault(p => p.Id == id);
if (updatingParagraph == null)
{
throw new ArgumentException("Impossible de trouver le paragraphe", nameof(id));
}
updatingParagraph.Title = paragraphDTO.Title;
updatingParagraph.Content = paragraphDTO.Content;
updatingParagraph.Info = paragraphDTO.Info;
updatingParagraph.Query = paragraphDTO.Query;
updatingParagraph.Comment = paragraphDTO.Comment;
DbContext.SaveChangesAsync();
return updatingParagraph.FromEntityToDTO();
}
public ParagraphDTO CreateParagraph(string title, string content, string info, string query, string comment, int lessonId)
{
var newParagraphEntity = new ParagraphDTO()
{
Title = title,
Content = content,
Info = info,
Query = query,
Comment = comment,
LessonId = lessonId
};
DbContext.Paragraphs.Add(newParagraphEntity.FromDTOToEntity());
DbContext.SaveChangesAsync();
return newParagraphEntity;
}
}

103
API_SQLuedo/Shared/SuccessDataService.cs
Unescape View File

@ -1,103 +0,0 @@
using Entities;
using Microsoft.EntityFrameworkCore;
using Dto;
using DbContextLib;
using Model.OrderCriteria;
using Shared.Mapper;
namespace Shared;
public class SuccessDataService : ISuccessDataService
{
private UserDbContext DbContext { get; set; }
public SuccessDataService(UserDbContext context)
{
DbContext = context;
context.Database.EnsureCreated();
}
public IEnumerable<SuccessDTO> GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria)
{
IQueryable<SuccessEntity> query = DbContext.Successes.Skip((page - 1) * number).Take(number);
switch (orderCriteria)
{
case SuccessOrderCriteria.None:
break;
case SuccessOrderCriteria.ByUserId:
query = query.OrderBy(s => s.UserId);
break;
case SuccessOrderCriteria.ByInquiryId:
query = query.OrderBy(s => s.InquiryId);
break;
case SuccessOrderCriteria.ByIsFinished:
query = query.OrderBy(s => s.IsFinished);
break;
default:
break;
}
var successes = query.ToList();
return successes.Select(s => s.FromEntityToDTO());
}
public SuccessDTO GetSuccessByUserId(int id)
{
var userEntity = DbContext.Successes.FirstOrDefault(u => u.UserId == id);
if (userEntity == null)
{
throw new ArgumentException("Impossible de trouver le succès", nameof(id));
}
return userEntity.FromEntityToDTO();
}
public SuccessDTO GetSuccessByInquiryId(int id)
{
var userEntity = DbContext.Successes.FirstOrDefault(u => u.InquiryId == id);
if (userEntity == null)
{
throw new ArgumentException("Impossible de trouver le succès", nameof(id));
}
return userEntity.FromEntityToDTO();
}
public bool DeleteSuccess(int id)
{
var successEntity = DbContext.Successes.FirstOrDefault(u => u.UserId == id);
if (successEntity == null)
{
return false;
}
DbContext.Successes.Remove(successEntity);
DbContext.SaveChangesAsync();
return true;
}
public SuccessDTO UpdateSuccess(int id, SuccessDTO success)
{
var updatingSuccess = DbContext.Successes.FirstOrDefault(u => u.UserId == id);
if (updatingSuccess == null)
{
throw new ArgumentException("Impossible de trouver le succès", nameof(id));
}
updatingSuccess.UserId = success.UserId;
updatingSuccess.InquiryId = success.InquiryId;
updatingSuccess.IsFinished = success.IsFinished;
DbContext.SaveChangesAsync();
return updatingSuccess.FromEntityToDTO();
}
public SuccessDTO CreateSuccess(int userId, int inquiryId, bool isFinished)
{
var newSuccessEntity = new SuccessDTO()
{
UserId = userId,
InquiryId = inquiryId,
IsFinished = isFinished,
};
DbContext.Successes.Add(newSuccessEntity.FromDTOToEntity());
DbContext.SaveChangesAsync();
return newSuccessEntity;
}
}

121
API_SQLuedo/Shared/UserDataService.cs
Unescape View File

@ -1,121 +0,0 @@
using Dto;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using Entities;
using Shared.Mapper;
using DbContextLib;
using Model.OrderCriteria;
namespace Shared
{
public class UserDataService : IUserDataService
{
private UserDbContext DbContext { get; set; }
public UserDataService(UserDbContext context)
{
DbContext = context;
context.Database.EnsureCreated();
}
public UserDTO GetUserById(int id)
{
var userEntity = DbContext.Users.FirstOrDefault(u => u.Id == id);
if (userEntity == null)
{
throw new ArgumentException("Impossible de trouver l'utilisateur", nameof(id));
}
return userEntity.FromEntityToDTO();
}
public UserDTO GetUserByUsername(string username)
{
var userEntity = DbContext.Users.FirstOrDefault(u => u.Username == username);
if (userEntity == null)
{
throw new ArgumentException("Impossible de trouver l'utilisateur", nameof(username));
}
return userEntity.FromEntityToDTO();
}
public IEnumerable<UserDTO> GetUsers(int page, int number, UserOrderCriteria orderCriteria)
{
IQueryable<UserEntity> query = DbContext.Users.Skip((page - 1) * number).Take(number);
switch (orderCriteria)
{
case UserOrderCriteria.None:
break;
case UserOrderCriteria.ById:
query = query.OrderBy(s => s.Id);
break;
case UserOrderCriteria.ByUsername:
query = query.OrderBy(s => s.Username);
break;
case UserOrderCriteria.ByEmail:
query = query.OrderBy(s => s.Email);
break;
case UserOrderCriteria.ByIsAdmin:
query = query.OrderBy(s => s.IsAdmin);
break;
default:
break;
}
var users = query.ToList();
return users.Select(s => s.FromEntityToDTO());
}
public bool DeleteUser(int id)
{
var userEntity = DbContext.Users.FirstOrDefault(u => u.Id == id);
if (userEntity == null)
{
return false;
}
DbContext.Users.Remove(userEntity);
DbContext.SaveChangesAsync();
return true;
}
public UserDTO UpdateUser(int id, UserDTO user)
{
var updatingUser = DbContext.Users.FirstOrDefault(u => u.Id == id);
if (updatingUser == null)
{
throw new ArgumentException("Impossible de trouver l'utilisateur", nameof(id));
}
updatingUser.Username = user.Username;
updatingUser.Password = user.Password;
updatingUser.Email = user.Email;
updatingUser.IsAdmin = user.IsAdmin;
DbContext.SaveChangesAsync();
return updatingUser.FromEntityToDTO();
}
public UserDTO CreateUser(string username, string password, string email, bool isAdmin)
{
var newUserEntity = new UserDTO
{
Username = username,
Password = password,
Email = email,
IsAdmin = isAdmin
};
DbContext.Users.Add(newUserEntity.FromDTOToEntity());
DbContext.SaveChangesAsync();
return newUserEntity;
}
}
}

22
API_SQLuedo/StubbedContextLib/StubbedContext.cs
Unescape View File

@ -1,5 +1,4 @@
using System.Runtime.CompilerServices; using System.Security.Cryptography;
using System.Security.Cryptography;
using DbContextLib; using DbContextLib;
using Entities; using Entities;
using Microsoft.AspNetCore.Cryptography.KeyDerivation; using Microsoft.AspNetCore.Cryptography.KeyDerivation;
@ -58,9 +57,26 @@ public class StubbedContext : UserDbContext
modelBuilder.Entity<SolutionEntity>().HasData( modelBuilder.Entity<SolutionEntity>().HasData(
new SolutionEntity(1, "Maxime", "Sapountzis", "La cuisine", "Le couteau", "Parce que c'est Maxime"), new SolutionEntity(1, "Maxime", "Sapountzis", "La cuisine", "Le couteau", "Parce que c'est Maxime"),
new SolutionEntity(2, "Johnny", "Ratton", "La cuisine", "Le couteau", "Parce que il est ra****"), new SolutionEntity(2, "Johnny", "Ratton", "La cuisine", "Le couteau", "Parce que il est fou"),
new SolutionEntity(3, "Erwan", "Menager", "La salle de bain", "L'arachide", "Parce que c'est Erwan")); new SolutionEntity(3, "Erwan", "Menager", "La salle de bain", "L'arachide", "Parce que c'est Erwan"));
modelBuilder.Entity<LessonEntity>().HasData(
new LessonEntity(1, "La cuisine", "Maxime", new DateOnly(2021, 10, 10)),
new LessonEntity(2, "La salle de bain", "Erwan", new DateOnly(2021, 10, 10)),
new LessonEntity(3, "La chambre", "Johnny", new DateOnly(2021, 10, 10)),
new LessonEntity(4, "Le salon", "Clement", new DateOnly(2021, 10, 10)));
modelBuilder.Entity<ParagraphEntity>().HasData(
new ParagraphEntity(1, "Le premier paragraphe", "Le contenu du premier paragraphe", "Attention", "La query",
"Le commentaire", 1),
new ParagraphEntity(2, "Le deuxième paragraphe", "Le contenu du deuxième paragraphe", "Attention",
"La query", "Le commentaire", 1),
new ParagraphEntity(3, "Le troisième paragraphe", "Le contenu du troisième paragraphe", "Attention",
"query", "commentaire", 2),
new ParagraphEntity(4, "Le quatrième paragraphe", "Le contenu du quatrième paragraphe", "Attention",
"La query", "Le commentaire", 3),
new ParagraphEntity(5, "Le cinquième paragraphe", "Le contenu du quatrième paragraphe", "Attention",
"La query", "Le commentaire", 4));
modelBuilder.Entity<InquiryEntity>().HasData( modelBuilder.Entity<InquiryEntity>().HasData(
new InquiryEntity(1, "L'enquête de la carotte", "La description de l'inquiry1", true), new InquiryEntity(1, "L'enquête de la carotte", "La description de l'inquiry1", true),
new InquiryEntity(2, "L'enquête sur les orang outan", "The new description", false), new InquiryEntity(2, "L'enquête sur les orang outan", "The new description", false),

85
API_SQLuedo/TestConsoleAPI/Program.cs
Unescape View File

@ -1,14 +1,19 @@
// See https://aka.ms/new-console-template for more information // See https://aka.ms/new-console-template for more information
using API.Controllers; using API.Controllers;
using API.Service;
using DbContextLib; using DbContextLib;
using DbDataManager.Service;
using Dto; using Dto;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using Microsoft.Data.Sqlite; using Microsoft.Data.Sqlite;
using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging;
using Model.OrderCriteria; using Model.OrderCriteria;
using Shared; using Service_LessonDataService = DbDataManager.Service.LessonDataService;
using Service_ParagraphDataService = DbDataManager.Service.ParagraphDataService;
using Service_SuccessDataService = DbDataManager.Service.SuccessDataService;
using Service_UserDataService = DbDataManager.Service.UserDataService;
var connection = new SqliteConnection("DataSource=:memory:"); var connection = new SqliteConnection("DataSource=:memory:");
connection.Open(); connection.Open();
@ -25,11 +30,16 @@ ILogger<SuccessesController> successLogger = factory.CreateLogger<SuccessesContr
using (var context = new UserDbContext(options)) using (var context = new UserDbContext(options))
{ {
var userController = new UsersController(userLogger, new UserDataService(context)); var userController = new UsersController(userLogger, new UserDataServiceApi(new Service_UserDataService(context)));
var inquiryController = new InquiriesController(new InquiryDataService(context), inquiryLogger); var inquiryController =
var paragraphController = new ParagraphsController(new ParagraphDataService(context), paragraphLogger); new InquiriesController(new InquiryDataServiceApi(new InquiryDataService(context)), inquiryLogger);
var lessonController = new LessonsController(new LessonDataService(context), lessonLogger); var paragraphController =
var successController = new SuccessesController(new SuccessDataService(context), successLogger); new ParagraphsController(new ParagraphDataServiceApi(new Service_ParagraphDataService(context)),
paragraphLogger);
var lessonController =
new LessonsController(new LessonDataServiceApi(new Service_LessonDataService(context)), lessonLogger);
var successController = new SuccessesController(new SuccessDataServiceApi(new Service_SuccessDataService(context)),
successLogger);
void PrintUsers() void PrintUsers()
{ {
@ -91,8 +101,8 @@ using (var context = new UserDbContext(options))
Console.WriteLine("Erreur, la requête n'a rien donné."); Console.WriteLine("Erreur, la requête n'a rien donné.");
return; return;
} }
Console.WriteLine(user.Value as UserDTO);
Console.WriteLine(user.Value as UserDTO);
} }
void SearchInquiryByTitle() void SearchInquiryByTitle()
@ -105,6 +115,7 @@ using (var context = new UserDbContext(options))
Console.WriteLine("Erreur, la requête n'a rien donné."); Console.WriteLine("Erreur, la requête n'a rien donné.");
return; return;
} }
Console.WriteLine(inquiry.Value as InquiryDTO); Console.WriteLine(inquiry.Value as InquiryDTO);
} }
@ -118,8 +129,8 @@ using (var context = new UserDbContext(options))
Console.WriteLine("Erreur, la requête n'a rien donné."); Console.WriteLine("Erreur, la requête n'a rien donné.");
return; return;
} }
Console.WriteLine(paragraph.Value as ParagraphDTO);
Console.WriteLine(paragraph.Value as ParagraphDTO);
} }
void SearchLessonByTitle() void SearchLessonByTitle()
@ -132,8 +143,8 @@ using (var context = new UserDbContext(options))
Console.WriteLine("Erreur, la requête n'a rien donné."); Console.WriteLine("Erreur, la requête n'a rien donné.");
return; return;
} }
Console.WriteLine(lesson.Value as LessonDTO);
Console.WriteLine(lesson.Value as LessonDTO);
} }
void SearchSuccessByUserId() void SearchSuccessByUserId()
@ -146,8 +157,8 @@ using (var context = new UserDbContext(options))
Console.WriteLine("Erreur, la requête n'a rien donné."); Console.WriteLine("Erreur, la requête n'a rien donné.");
return; return;
} }
Console.WriteLine(success.Value as SuccessDTO);
Console.WriteLine(success.Value as SuccessDTO);
} }
void SearchUserById() void SearchUserById()
@ -160,8 +171,8 @@ using (var context = new UserDbContext(options))
Console.WriteLine("Erreur, la requête n'a rien donné."); Console.WriteLine("Erreur, la requête n'a rien donné.");
return; return;
} }
Console.WriteLine(user.Value as UserDTO);
Console.WriteLine(user.Value as UserDTO);
} }
void SearchInquiryById() void SearchInquiryById()
@ -174,6 +185,7 @@ using (var context = new UserDbContext(options))
Console.WriteLine("Erreur, la requête n'a rien donné."); Console.WriteLine("Erreur, la requête n'a rien donné.");
return; return;
} }
Console.WriteLine(inquiry.Value as InquiryDTO); Console.WriteLine(inquiry.Value as InquiryDTO);
} }
@ -187,8 +199,8 @@ using (var context = new UserDbContext(options))
Console.WriteLine("Erreur, la requête n'a rien donné."); Console.WriteLine("Erreur, la requête n'a rien donné.");
return; return;
} }
Console.WriteLine(paragraph.Value as ParagraphDTO);
Console.WriteLine(paragraph.Value as ParagraphDTO);
} }
void SearchSuccessByInquiryId() void SearchSuccessByInquiryId()
@ -201,8 +213,8 @@ using (var context = new UserDbContext(options))
Console.WriteLine("Erreur, la requête n'a rien donné."); Console.WriteLine("Erreur, la requête n'a rien donné.");
return; return;
} }
Console.WriteLine(success.Value as SuccessDTO);
Console.WriteLine(success.Value as SuccessDTO);
} }
void SearchLessonById() void SearchLessonById()
@ -215,8 +227,8 @@ using (var context = new UserDbContext(options))
Console.WriteLine("Erreur, la requête n'a rien donné."); Console.WriteLine("Erreur, la requête n'a rien donné.");
return; return;
} }
Console.WriteLine(lesson.Value as LessonDTO);
Console.WriteLine(lesson.Value as LessonDTO);
} }
void AddUser() void AddUser()
@ -236,7 +248,6 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("\nErreur lors de la création de l'utilisateur !"); Console.WriteLine("\nErreur lors de la création de l'utilisateur !");
} }
} }
void AddInquiry() void AddInquiry()
@ -285,7 +296,6 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("\nErreur lors de la création du paragraphe !"); Console.WriteLine("\nErreur lors de la création du paragraphe !");
} }
} }
void AddLesson() void AddLesson()
@ -294,7 +304,8 @@ using (var context = new UserDbContext(options))
var title = Console.ReadLine(); var title = Console.ReadLine();
Console.WriteLine("Veuillez saisir votre nom :"); Console.WriteLine("Veuillez saisir votre nom :");
var lastPublisher = Console.ReadLine(); var lastPublisher = Console.ReadLine();
var res = lessonController.CreateLesson(new LessonDTO(title, lastPublisher, DateOnly.FromDateTime(DateTime.Now))); var res = lessonController.CreateLesson(
new LessonDTO(title, lastPublisher, DateOnly.FromDateTime(DateTime.Now)));
if (res.GetType() == typeof(CreatedResult)) if (res.GetType() == typeof(CreatedResult))
{ {
Console.WriteLine("\nLeçon créée avec succès"); Console.WriteLine("\nLeçon créée avec succès");
@ -303,7 +314,6 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("\nErreur lors de la création de la leçon !"); Console.WriteLine("\nErreur lors de la création de la leçon !");
} }
} }
void AddSuccess() void AddSuccess()
@ -314,7 +324,8 @@ using (var context = new UserDbContext(options))
var inquiryId = Console.ReadLine(); var inquiryId = Console.ReadLine();
Console.WriteLine("Veuillez indiquer si l'enquête a été complété (true/false) :"); Console.WriteLine("Veuillez indiquer si l'enquête a été complété (true/false) :");
var isFinished = Console.ReadLine(); var isFinished = Console.ReadLine();
var res = successController.CreateSuccess(new SuccessDTO(int.Parse(userId), int.Parse(inquiryId), bool.Parse(isFinished))); var res = successController.CreateSuccess(new SuccessDTO(int.Parse(userId), int.Parse(inquiryId),
bool.Parse(isFinished)));
if (res.GetType() == typeof(CreatedResult)) if (res.GetType() == typeof(CreatedResult))
{ {
Console.WriteLine("\nSuccès créé avec succès"); Console.WriteLine("\nSuccès créé avec succès");
@ -323,7 +334,6 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("\nErreur lors de la création du succès !"); Console.WriteLine("\nErreur lors de la création du succès !");
} }
} }
void UpdateUser() void UpdateUser()
@ -346,7 +356,8 @@ using (var context = new UserDbContext(options))
var username = Console.ReadLine(); var username = Console.ReadLine();
Console.WriteLine("Veuillez saisir l'email :"); Console.WriteLine("Veuillez saisir l'email :");
var email = Console.ReadLine(); var email = Console.ReadLine();
var retour = userController.UpdateUser(id, new UserDTO(id, username, user.Password, email, user.IsAdmin)); var retour =
userController.UpdateUser(id, new UserDTO(id, username, user.Password, email, user.IsAdmin));
if (retour.GetType() == typeof(OkObjectResult)) if (retour.GetType() == typeof(OkObjectResult))
{ {
Console.WriteLine("Mise à jour effectué avec succès !"); Console.WriteLine("Mise à jour effectué avec succès !");
@ -361,7 +372,6 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("Une erreur est survenue lors de la mise à jour !"); Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
} }
} }
void UpdateInquiry() void UpdateInquiry()
@ -390,7 +400,8 @@ using (var context = new UserDbContext(options))
var database = Convert.ToInt32(Console.ReadLine()); var database = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Veuillez saisir un commentaire :"); Console.WriteLine("Veuillez saisir un commentaire :");
var inquiryTable = Convert.ToInt32(Console.ReadLine()); var inquiryTable = Convert.ToInt32(Console.ReadLine());
var retour = inquiryController.UpdateInquiry(id, new InquiryDTO(id, title, description, bool.Parse(isUser))); var retour =
inquiryController.UpdateInquiry(id, new InquiryDTO(id, title, description, bool.Parse(isUser)));
if (retour.GetType() == typeof(OkObjectResult)) if (retour.GetType() == typeof(OkObjectResult))
{ {
Console.WriteLine("Mise à jour effectué avec succès !"); Console.WriteLine("Mise à jour effectué avec succès !");
@ -405,7 +416,6 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("Une erreur est survenue lors de la mise à jour !"); Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
} }
} }
void UpdateParagraph() void UpdateParagraph()
@ -436,7 +446,8 @@ using (var context = new UserDbContext(options))
var comment = Console.ReadLine(); var comment = Console.ReadLine();
Console.WriteLine("Veuillez saisir l'id de la leçon :"); Console.WriteLine("Veuillez saisir l'id de la leçon :");
var lesson = Convert.ToInt32(Console.ReadLine()); var lesson = Convert.ToInt32(Console.ReadLine());
var retour = paragraphController.UpdateParagraph(id, new ParagraphDTO(id, title, content, info, query, comment, lesson)); var retour = paragraphController.UpdateParagraph(id,
new ParagraphDTO(id, title, content, info, query, comment, lesson));
if (retour.GetType() == typeof(OkObjectResult)) if (retour.GetType() == typeof(OkObjectResult))
{ {
Console.WriteLine("Mise à jour effectué avec succès !"); Console.WriteLine("Mise à jour effectué avec succès !");
@ -451,7 +462,6 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("Une erreur est survenue lors de la mise à jour !"); Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
} }
} }
void UpdateLesson() void UpdateLesson()
@ -474,7 +484,8 @@ using (var context = new UserDbContext(options))
var title = Console.ReadLine(); var title = Console.ReadLine();
Console.WriteLine("Veuillez saisir votre nom :"); Console.WriteLine("Veuillez saisir votre nom :");
var lastPublisher = Console.ReadLine(); var lastPublisher = Console.ReadLine();
var retour = lessonController.UpdateLesson(id, new LessonDTO(id, title, lastPublisher, DateOnly.FromDateTime(DateTime.Now))); var retour = lessonController.UpdateLesson(id,
new LessonDTO(id, title, lastPublisher, DateOnly.FromDateTime(DateTime.Now)));
if (retour.GetType() == typeof(OkObjectResult)) if (retour.GetType() == typeof(OkObjectResult))
{ {
Console.WriteLine("Mise à jour effectué avec succès !"); Console.WriteLine("Mise à jour effectué avec succès !");
@ -489,7 +500,6 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("Une erreur est survenue lors de la mise à jour !"); Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
} }
} }
void UpdateSuccess() void UpdateSuccess()
@ -509,12 +519,13 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("Succès trouvé !\n"); Console.WriteLine("Succès trouvé !\n");
Console.WriteLine("Veuillez saisir l'identifiant de l'utilisateur lié au succès :"); Console.WriteLine("Veuillez saisir l'identifiant de l'utilisateur lié au succès :");
var userId = Console.ReadLine(); var userId = int.Parse(Console.ReadLine());
Console.WriteLine("Veuillez saisir l'identifiant de l'enquête lié au succès :"); Console.WriteLine("Veuillez saisir l'identifiant de l'enquête lié au succès :");
var inquiryId = Console.ReadLine(); var inquiryId = int.Parse(Console.ReadLine());
Console.WriteLine("Veuillez saisir si l'enquête est terminée (0/1) :"); Console.WriteLine("Veuillez saisir si l'enquête est terminée (0/1) :");
var isFinished = Console.ReadLine(); var isFinished = Console.ReadLine();
var retour = successController.UpdateSuccess(id, new SuccessDTO(int.Parse(userId), int.Parse(inquiryId), bool.Parse(isFinished))); var retour = successController.UpdateSuccess(userId, inquiryId,
new SuccessDTO(userId, inquiryId, bool.Parse(isFinished)));
if (retour.GetType() == typeof(OkObjectResult)) if (retour.GetType() == typeof(OkObjectResult))
{ {
Console.WriteLine("Mise à jour effectué avec succès !"); Console.WriteLine("Mise à jour effectué avec succès !");
@ -529,7 +540,6 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("Une erreur est survenue lors de la mise à jour !"); Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
} }
} }
void DeleteUser() void DeleteUser()
@ -545,7 +555,6 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("Erreur lors de la suppression !"); Console.WriteLine("Erreur lors de la suppression !");
} }
} }
void DeleteInquiry() void DeleteInquiry()
@ -576,7 +585,6 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("Erreur lors de la suppression !"); Console.WriteLine("Erreur lors de la suppression !");
} }
} }
void DeleteLesson() void DeleteLesson()
@ -592,14 +600,15 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("Erreur lors de la suppression !"); Console.WriteLine("Erreur lors de la suppression !");
} }
} }
void DeleteSuccess() void DeleteSuccess()
{ {
Console.WriteLine("Quel est l'identifiant de l'utilisateur lié au succès à supprimer ?"); Console.WriteLine("Quel est l'identifiant de l'utilisateur lié au succès à supprimer ?");
var id = int.Parse(Console.ReadLine()); var idUser = int.Parse(Console.ReadLine());
var res = successController.DeleteSuccess(id); Console.WriteLine("Quel est l'identifiant de l'enquête lié au succès à supprimer ?");
var idInquiry = int.Parse(Console.ReadLine());
var res = successController.DeleteSuccess(idUser,idInquiry);
if (res.GetType() == typeof(OkObjectResult)) if (res.GetType() == typeof(OkObjectResult))
{ {
Console.WriteLine("La suppression a été effectuée avec succès !"); Console.WriteLine("La suppression a été effectuée avec succès !");
@ -608,7 +617,6 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("Erreur lors de la suppression !"); Console.WriteLine("Erreur lors de la suppression !");
} }
} }
void MenuUsers() void MenuUsers()
@ -747,6 +755,7 @@ using (var context = new UserDbContext(options))
default: default:
break; break;
} }
Console.WriteLine("\nAppuyez sur n'importe quelle touche pour continuer..."); Console.WriteLine("\nAppuyez sur n'importe quelle touche pour continuer...");
Console.ReadKey(); Console.ReadKey();
Console.Clear(); Console.Clear();

1
API_SQLuedo/TestEF/EntitiesTests/TestUserEntity.cs
Unescape View File

@ -9,6 +9,7 @@ namespace TestEF
private const string _password = "password"; private const string _password = "password";
private const bool _isAdmin = true; private const bool _isAdmin = true;
private const int _id = 42; private const int _id = 42;
[Fact] [Fact]
public void TestDefaultConstructor() public void TestDefaultConstructor()
{ {

Write Preview
Loading…
Cancel
Save