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

Merge entre master et modifEntities et amélioration du code
continuous-integration/drone/push Build is failing Details

Browse Source
pull/40/head
Clement CHIEU 1 year ago
parent b750dcbb71 e2d1591aea
commit 4988a0ea26
95 changed files with 2538 additions and 1294 deletions
Show Stats Download Patch File Download Diff File

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

@ -13,17 +13,18 @@ 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,12 +34,13 @@ 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));
} }
[HttpGet("inquiry/{id:int}")] [HttpGet("inquiry/{id:int}")]
[ProducesResponseType(typeof(InquiryDTO), 200)] [ProducesResponseType(typeof(InquiryDto), 200)]
[ProducesResponseType(typeof(string), 404)] [ProducesResponseType(typeof(string), 404)]
public IActionResult GetInquiryById(int id) public IActionResult GetInquiryById(int id)
{ {
@ -55,7 +57,7 @@ namespace API.Controllers
} }
[HttpGet("inquiry/{title:alpha}")] [HttpGet("inquiry/{title:alpha}")]
[ProducesResponseType(typeof(InquiryDTO), 200)] [ProducesResponseType(typeof(InquiryDto), 200)]
[ProducesResponseType(typeof(string), 404)] [ProducesResponseType(typeof(string), 404)]
public IActionResult GetInquiryByTitle(string title) public IActionResult GetInquiryByTitle(string title)
{ {
@ -71,8 +73,8 @@ 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,43 +89,50 @@ 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]
[ProducesResponseType(typeof(InquiryDTO), 201)] [ProducesResponseType(typeof(InquiryDto), 201)]
[ProducesResponseType(typeof(string), 400)] [ProducesResponseType(typeof(string), 400)]
public IActionResult CreateInquiry([FromBody] InquiryDTO dto) public IActionResult CreateInquiry([FromBody] InquiryDto dto)
{ {
if (dto.Title == null || dto.Description == null) if (dto.Title == null || dto.Description == null)
{ {
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)]
public IActionResult UpdateInquiry(int id, [FromBody] InquiryDTO inquiryDTO) public IActionResult UpdateInquiry(int id, [FromBody] InquiryDto InquiryDto)
{ {
if (id != inquiryDTO.Id) if (id != InquiryDto.Id)
{ {
_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();
} }

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

@ -13,18 +13,18 @@ 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;
public LessonsController(ILessonService<LessonDTO> lessonDataService, ILogger<LessonsController> logger) public LessonsController(ILessonService<LessonDto> lessonDataService, ILogger<LessonsController> logger)
{ {
_lessonDataService = lessonDataService; _lessonDataService = lessonDataService;
_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,12 +34,13 @@ 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));
} }
[HttpGet("lesson/{id:int}")] [HttpGet("lesson/{id:int}")]
[ProducesResponseType(typeof(LessonDTO), 200)] [ProducesResponseType(typeof(LessonDto), 200)]
[ProducesResponseType(typeof(string), 404)] [ProducesResponseType(typeof(string), 404)]
public IActionResult GetLessonById(int id) public IActionResult GetLessonById(int id)
{ {
@ -56,7 +57,7 @@ namespace API.Controllers
} }
[HttpGet("lesson/{title:alpha}")] [HttpGet("lesson/{title:alpha}")]
[ProducesResponseType(typeof(LessonDTO), 200)] [ProducesResponseType(typeof(LessonDto), 200)]
[ProducesResponseType(typeof(string), 404)] [ProducesResponseType(typeof(string), 404)]
public IActionResult GetLessonByTitle(string title) public IActionResult GetLessonByTitle(string title)
{ {
@ -72,8 +73,8 @@ 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,43 +89,50 @@ 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]
[ProducesResponseType(typeof(LessonDTO), 201)] [ProducesResponseType(typeof(LessonDto), 201)]
[ProducesResponseType(typeof(string), 400)] [ProducesResponseType(typeof(string), 400)]
public IActionResult CreateLesson([FromBody] LessonDTO dto) public IActionResult CreateLesson([FromBody] LessonDto dto)
{ {
if (dto.Title == null || dto.LastPublisher == null) if (dto.Title == null || dto.LastPublisher == null)
{ {
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)]
public IActionResult UpdateLesson(int id, [FromBody] LessonDTO lessonDTO) public IActionResult UpdateLesson(int id, [FromBody] LessonDto LessonDto)
{ {
if (id != lessonDTO.Id) if (id != LessonDto.Id)
{ {
_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();
} }

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

@ -13,33 +13,35 @@ 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));
} }
[HttpGet("paragraph/{id:int}")] [HttpGet("paragraph/{id:int}")]
[ProducesResponseType(typeof(ParagraphDTO), 200)] [ProducesResponseType(typeof(ParagraphDto), 200)]
[ProducesResponseType(typeof(string), 404)] [ProducesResponseType(typeof(string), 404)]
public IActionResult GetParagraphById(int id) public IActionResult GetParagraphById(int id)
{ {
@ -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();
@ -55,7 +58,7 @@ namespace API.Controllers
} }
[HttpGet("paragraph/{title:alpha}")] [HttpGet("paragraph/{title:alpha}")]
[ProducesResponseType(typeof(ParagraphDTO), 200)] [ProducesResponseType(typeof(ParagraphDto), 200)]
[ProducesResponseType(typeof(string), 404)] [ProducesResponseType(typeof(string), 404)]
public IActionResult GetParagraphByTitle(string title) public IActionResult GetParagraphByTitle(string title)
{ {
@ -63,66 +66,76 @@ 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)
{ {
var success = _paragraphDataService.DeleteParagraph(id); var success = _paragraphDataService.DeleteParagraph(id);
if(success) if (success)
{ {
_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]
[ProducesResponseType(typeof(ParagraphDTO), 201)] [ProducesResponseType(typeof(ParagraphDto), 201)]
[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)]
public IActionResult UpdateParagraph(int id, [FromBody] ParagraphDTO paragraphDTO) public IActionResult UpdateParagraph(int id, [FromBody] ParagraphDto ParagraphDto)
{ {
if(id != paragraphDTO.Id) if (id != ParagraphDto.Id)
{ {
_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();
} }

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

@ -13,117 +13,129 @@ 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;
public SuccessesController(ISuccessService<SuccessDTO> successDataService, ILogger<SuccessesController> logger) public SuccessesController(ISuccessService<SuccessDto> successDataService, ILogger<SuccessesController> logger)
{ {
_successDataService = successDataService; _successDataService = successDataService;
_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));
} }
[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]
[ProducesResponseType(typeof(SuccessDTO), 201)] [ProducesResponseType(typeof(SuccessDto), 201)]
[ProducesResponseType(typeof(string), 400)] [ProducesResponseType(typeof(string), 400)]
public IActionResult CreateSuccess([FromBody] SuccessDTO dto) public IActionResult CreateSuccess([FromBody] SuccessDto dto)
{ {
/*if (dto.UserId == null || dto.InquiryId == null) /*if (dto.UserId == null || dto.InquiryId == null)
{ {
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();
} }
} }

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

@ -11,10 +11,10 @@ namespace API.Controllers
[Authorize] [Authorize]
[ApiVersion("1.0")] [ApiVersion("1.0")]
[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)
{ {
@ -30,7 +30,7 @@ namespace API.Controllers
} }
[HttpGet("user/{id:int}")] [HttpGet("user/{id:int}")]
[ProducesResponseType(typeof(UserDTO), 200)] [ProducesResponseType(typeof(UserDto), 200)]
[ProducesResponseType(typeof(string), 404)] [ProducesResponseType(typeof(string), 404)]
public IActionResult GetUserById(int id) public IActionResult GetUserById(int id)
{ {
@ -47,7 +47,7 @@ namespace API.Controllers
} }
[HttpGet("user/{username:alpha}")] [HttpGet("user/{username:alpha}")]
[ProducesResponseType(typeof(UserDTO), 200)] [ProducesResponseType(typeof(UserDto), 200)]
[ProducesResponseType(typeof(string), 404)] [ProducesResponseType(typeof(string), 404)]
public IActionResult GetUserByUsername(string username) public IActionResult GetUserByUsername(string username)
{ {
@ -63,8 +63,8 @@ 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
{ {
@ -82,9 +82,9 @@ namespace API.Controllers
} }
[HttpPost] [HttpPost]
[ProducesResponseType(typeof(UserDTO), 201)] [ProducesResponseType(typeof(UserDto), 201)]
[ProducesResponseType(typeof(string), 400)] [ProducesResponseType(typeof(string), 400)]
public IActionResult CreateUser([FromBody] UserDTO dto) public IActionResult CreateUser([FromBody] UserDto dto)
{ {
if (dto.Username == null || dto.Password == null || dto.Email == null) if (dto.Username == null || dto.Password == null || dto.Email == null)
{ {
@ -99,13 +99,13 @@ 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)]
public IActionResult UpdateUser(int id, [FromBody] UserDTO userDto) public IActionResult UpdateUser(int id, [FromBody] UserDto UserDto)
{ {
if (id != userDto.Id) if (id != UserDto.Id)
{ {
logger.LogError("[ERREUR] Problème ID - La mise à jour de l'utilisateur avec l'id {id} a échouée.", id); logger.LogError("[ERREUR] Problème ID - La mise à jour de l'utilisateur avec l'id {id} a échouée.", id);
return BadRequest(); return BadRequest();
@ -114,15 +114,15 @@ namespace API.Controllers
if (!ModelState.IsValid) if (!ModelState.IsValid)
{ {
logger.LogError( logger.LogError(
"[ERREUR] Problème controlleur - La mise à jour de l'utilisateur avec l'id {id} a échouée.", id); "[ERREUR] Problème controller - La mise à jour de l'utilisateur avec l'id {id} a échouée.", id);
return BadRequest(); return BadRequest();
} }
if (userDto != null) if (UserDto != null)
{ {
logger.LogInformation("[INFORMATION] La mise à jour de l'utilsiateur avec l'id {id} a été effectuée", logger.LogInformation("[INFORMATION] La mise à jour de l'utilisateur avec l'id {id} a été effectuée",
id); id);
return Ok(userService.UpdateUser(id, userDto)); return Ok(userService.UpdateUser(id, UserDto));
} }
logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id {id}.", id); logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id {id}.", id);

28
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"));
@ -72,11 +70,11 @@ builder.Services.AddSwaggerGen(option =>
{ {
Reference = new OpenApiReference Reference = new OpenApiReference
{ {
Type=ReferenceType.SecurityScheme, Type = ReferenceType.SecurityScheme,
Id="Bearer" Id = "Bearer"
} }
}, },
new string[]{} new string[] { }
} }
}); });
}); });

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)
{
}
} }
} }

22
API_SQLuedo/DbContextLib/UserDbContext.cs
Unescape View File

@ -12,28 +12,34 @@ 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 builder)
{ {
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<SuccessEntity>().HasKey(s => s.UserId); builder.Entity<ContentLessonEntity>().UseTpcMappingStrategy();
modelBuilder.Entity<SuccessEntity>().HasKey(s => s.InquiryId);
modelBuilder.Entity<InquiryEntity>().HasKey(s => s.Id); builder.Entity<SuccessEntity>().HasKey(s => s.UserId);
base.OnModelCreating(modelBuilder); builder.Entity<SuccessEntity>().HasKey(s => s.InquiryId);
builder.Entity<InquiryEntity>().HasKey(s => s.Id);
base.OnModelCreating(builder);
} }
} }
} }

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>

67
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,17 @@ 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
.Select(u => u); {
Title = title,
Description = description,
IsUser = isUser
};
DbContext.Inquiries.Add(newInquiryEntity);
DbContext.SaveChangesAsync();
return newInquiryEntity;
} }
public bool DeleteInquiry(int id) public bool DeleteInquiry(int id)
@ -65,25 +96,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.
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, pptt.SetValue(updatingInquiry, pptt.GetValue(inquiry));
Description = description, }
IsUser = isUser,
};
DbContext.Inquiries.Add(newInquiryEntity);
DbContext.SaveChangesAsync(); DbContext.SaveChangesAsync();
return newInquiryEntity; return updatingInquiry;
} }
} }

47
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,22 +77,23 @@ 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;
} }
public LessonEntity CreateLesson(string title, string lastPublisher, DateOnly? lastEdit) public LessonEntity CreateLesson(string title, string lastPublisher, DateOnly lastEdit)
{ {
var newLessonEntity = new LessonEntity() var newLessonEntity = new LessonEntity()
{ {

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

77
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,
}; };
DbContext.Successes.Add(newSuccessEntity); var success = DbContext.Successes.Where(s => s.UserId == userId && s.InquiryId == inquiryId);
DbContext.SaveChangesAsync(); if (success == null)
{
DbContext.Successes.Add(newSuccessEntity);
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,

5
API_SQLuedo/Dto/BlackListDTO.cs
Unescape View File

@ -1,11 +1,12 @@
namespace Dto; namespace Dto;
public class BlackListDTO 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(string email, DateOnly expirationDate) public BlackListDto() {}
public BlackListDto(string email, DateOnly expirationDate)
{ {
Email = email; Email = email;
ExpirationDate = expirationDate; ExpirationDate = expirationDate;

8
API_SQLuedo/Dto/ContentLessonDTO.cs
Unescape View File

@ -1,13 +1,13 @@
namespace Dto; namespace Dto;
public abstract class ContentLessonDTO public abstract class ContentLessonDto
{ {
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; }
public int LessonId { get; set; } public int LessonId { get; set; }
protected ContentLessonDTO(int id, string contentContent, string contentTitle, int lessonId) protected ContentLessonDto(int id, string contentContent, string contentTitle, int lessonId)
{ {
Id = id; Id = id;
ContentContent = contentContent; ContentContent = contentContent;
@ -15,14 +15,14 @@ public abstract class ContentLessonDTO
LessonId = lessonId; LessonId = lessonId;
} }
protected ContentLessonDTO(string contentContent, string contentTitle, int lessonId) protected ContentLessonDto(string contentContent, string contentTitle, int lessonId)
{ {
ContentContent = contentContent; ContentContent = contentContent;
ContentTitle = contentTitle; ContentTitle = contentTitle;
LessonId = lessonId; LessonId = lessonId;
} }
protected ContentLessonDTO() protected ContentLessonDto()
{ {
} }
} }

44
API_SQLuedo/Dto/InquiryDTO.cs
Unescape View File

@ -1,8 +1,8 @@
namespace Dto; namespace Dto;
public class InquiryDTO public class InquiryDto : IEquatable<InquiryDto>
{ {
public int Id { get;} public int Id { get; }
public string Title { get; set; } public string Title { get; set; }
@ -10,7 +10,8 @@ public class InquiryDTO
public bool IsUser { get; set; } public bool IsUser { get; set; }
public InquiryDTO(int id, string title, string description, bool isUser) public InquiryDto(){}
public InquiryDto(int id, string title, string description, bool isUser)
{ {
Id = id; Id = id;
Title = title; Title = title;
@ -18,10 +19,45 @@ public class InquiryDTO
IsUser = isUser; IsUser = isUser;
} }
public InquiryDTO(string title, string description, bool isUser) public InquiryDto(string title, string description, bool isUser)
{ {
Title = title; Title = title;
Description = description; Description = description;
IsUser = isUser; IsUser = isUser;
} }
public override string ToString()
{
return $"{Id}\t{Title}\t{Description}\t{IsUser}";
}
public override bool Equals(object right)
{
if (object.ReferenceEquals(right, null))
{
return false;
}
if (object.ReferenceEquals(this, right))
{
return true;
}
if (this.GetType() != right.GetType())
{
return false;
}
return this.Equals(right as InquiryDto);
}
public bool Equals(InquiryDto other)
{
return (this.Id == other.Id);
}
public override int GetHashCode()
{
return Id;
}
} }

9
API_SQLuedo/Dto/InquiryTableDTO.cs
Unescape View File

@ -1,15 +1,16 @@
namespace Dto; namespace Dto;
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)
{ {
OwnerId = ownerId; OwnerId = ownerId;
DatabaseName = databaseName; DatabaseName = databaseName;

53
API_SQLuedo/Dto/LessonDTO.cs
Unescape View File

@ -1,15 +1,18 @@
namespace Dto; namespace Dto;
public class LessonDTO public class LessonDto : IEquatable<LessonDto>
{ {
public int Id { get; } public int Id { get; }
public string? Title { get; set; } public string Title { get; set; }
public string? LastPublisher { get; set; } public string LastPublisher { get; set; }
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;
Title = title; Title = title;
@ -17,10 +20,44 @@ public class LessonDTO
LastEdit = lastEdit; LastEdit = lastEdit;
} }
public LessonDTO(string title, string lastPublisher, DateOnly? lastEdit) public LessonDto(string title, string lastPublisher, DateOnly lastEdit)
{ {
Title = title; Title = title;
LastPublisher = lastPublisher; LastPublisher = lastPublisher;
LastEdit = lastEdit; LastEdit = lastEdit;
} }
public override string ToString()
{
return $"{Id}\t{Title}\t{LastPublisher}\t{LastEdit}";
}
public override bool Equals(object right)
{
if (object.ReferenceEquals(right, null))
{
return false;
}
if (object.ReferenceEquals(this, right))
{
return true;
}
if (this.GetType() != right.GetType())
{
return false;
}
return this.Equals(right as LessonDto);
}
public bool Equals(LessonDto other)
{
return (this.Id == other.Id);
}
public override int GetHashCode()
{
return Id;
}
} }

11
API_SQLuedo/Dto/NotepadDTO.cs
Unescape View File

@ -1,22 +1,25 @@
namespace Dto; namespace Dto;
public class NotepadDTO public class NotepadDto
{ {
public int Id { get; set; } public int Id { get; set; }
public int UserId { get; set; } public int UserId { get; set; }
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)
{ {
Id = id; Id = id;
UserId = userId; UserId = userId;
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;
InquiryId = inquiryId; InquiryId = inquiryId;

42
API_SQLuedo/Dto/ParagraphDTO.cs
Unescape View File

@ -1,6 +1,6 @@
namespace Dto; namespace Dto;
public class ParagraphDTO : ContentLessonDTO public class ParagraphDto : ContentLessonDto, IEquatable<ParagraphDto>
{ {
public string Title { get; set; } public string Title { get; set; }
public string Content { get; set; } public string Content { get; set; }
@ -8,7 +8,7 @@ public class ParagraphDTO : ContentLessonDTO
public string Query { get; set; } public string Query { get; set; }
public string Comment { get; set; } public string Comment { get; set; }
public ParagraphDTO(string title, string content, string info, string query, string comment, int lessonId) : public ParagraphDto(string title, string content, string info, string query, string comment, int lessonId) :
base(content, base(content,
title, lessonId) title, lessonId)
{ {
@ -19,7 +19,7 @@ public class ParagraphDTO : ContentLessonDTO
Comment = comment; Comment = comment;
} }
public ParagraphDTO(int id, string title, string content, string info, string query, string comment, int lessonId) : public ParagraphDto(int id, string title, string content, string info, string query, string comment, int lessonId) :
base(id, content, base(id, content,
title, lessonId) title, lessonId)
{ {
@ -31,7 +31,41 @@ public class ParagraphDTO : ContentLessonDTO
Comment = comment; Comment = comment;
} }
public ParagraphDTO() : base() public ParagraphDto() : base()
{ {
} }
public override string ToString()
{
return $"{Id}\t{Title}\t{Content}\t{Info}\t{Query}\t{Comment}";
}
public override bool Equals(object right)
{
if (object.ReferenceEquals(right, null))
{
return false;
}
if (object.ReferenceEquals(this, right))
{
return true;
}
if (this.GetType() != right.GetType())
{
return false;
}
return this.Equals(right as ParagraphDto);
}
public bool Equals(ParagraphDto other)
{
return (this.Id == other.Id);
}
public override int GetHashCode()
{
return Id;
}
} }

15
API_SQLuedo/Dto/SolutionDTO.cs
Unescape View File

@ -1,6 +1,6 @@
namespace Dto; namespace Dto;
public class SolutionDTO public class SolutionDto
{ {
public int OwnerId { get; set; } public int OwnerId { get; set; }
public string MurdererFirstName { get; set; } public string MurdererFirstName { get; set; }
@ -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;

42
API_SQLuedo/Dto/SuccessDTO.cs
Unescape View File

@ -1,17 +1,53 @@
namespace Dto; namespace Dto;
public class SuccessDTO public class SuccessDto : IEquatable<SuccessDto>
{ {
public int UserId { get; set; } public int UserId { get; set; }
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)
{ {
UserId = userId; UserId = userId;
InquiryId = inquiryId; InquiryId = inquiryId;
IsFinished = isFinished; IsFinished = isFinished;
} }
public override string ToString()
{
return $"User :{UserId}\t Enquête : {InquiryId}\t{IsFinished}";
}
public override bool Equals(object right)
{
if (object.ReferenceEquals(right, null))
{
return false;
}
if (object.ReferenceEquals(this, right))
{
return true;
}
if (this.GetType() != right.GetType())
{
return false;
}
return this.Equals(right as SuccessDto);
}
public bool Equals(SuccessDto other)
{
return (this.UserId == other.UserId && this.InquiryId == other.InquiryId);
}
public override int GetHashCode()
{
return UserId * InquiryId;
}
} }

63
API_SQLuedo/Dto/UserDTO.cs
Unescape View File

@ -1,15 +1,18 @@
namespace Dto; namespace Dto
public class UserDTO
{ {
public int Id { get; set; } public class UserDto : IEquatable<UserDto>
public string Username { get; set; } {
public string Password { get; set; } public int Id { get; set; }
public string Email { get; set; } public string Username { get; set; }
public bool IsAdmin { get; set; } public string Password { get; set; }
public string Email { get; set; }
public UserDTO() { } public bool IsAdmin { get; set; }
public UserDTO(int id, string username, string password, string email, bool isAdmin)
public UserDto()
{
}
public UserDto(int id, string username, string password, string email, bool isAdmin)
{ {
Id = id; Id = id;
Username = username; Username = username;
@ -18,7 +21,7 @@ public class UserDTO
IsAdmin = isAdmin; IsAdmin = isAdmin;
} }
public UserDTO(string username, string password, string email, bool isAdmin) public UserDto(string username, string password, string email, bool isAdmin)
{ {
Username = username; Username = username;
Password = password; Password = password;
@ -26,8 +29,38 @@ public class UserDTO
IsAdmin = isAdmin; IsAdmin = isAdmin;
} }
public override string ToString() public override string ToString()
{ {
return $"{Id}\t{Username}\t{Email}\t{IsAdmin}"; return $"{Id}\t{Username}\t{Email}\t{IsAdmin}";
}
public override bool Equals(object right)
{
if (object.ReferenceEquals(right, null))
{
return false;
}
if (object.ReferenceEquals(this, right))
{
return true;
}
if (this.GetType() != right.GetType())
{
return false;
}
return this.Equals(right as UserDto);
}
public bool Equals(UserDto other)
{
return (this.Id == other.Id);
}
public override int GetHashCode()
{
return Id;
}
} }
} }

3
API_SQLuedo/EntityFramework/BlackListEntity.cs
Unescape View File

@ -6,7 +6,6 @@ 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; }
} }

1
API_SQLuedo/EntityFramework/ContentLessonEntity.cs
Unescape View File

@ -2,7 +2,6 @@
namespace Entities; namespace Entities;
[Table("ContentLesson")]
public abstract class ContentLessonEntity public abstract class ContentLessonEntity
{ {
public int Id { get; set; } public int Id { get; set; }

2
API_SQLuedo/EntityFramework/LessonEntity.cs
Unescape View File

@ -8,6 +8,6 @@ public class LessonEntity
public int Id { get; set; } public int Id { get; set; }
public string Title { get; set; } public string Title { get; set; }
public string LastPublisher { get; set; } public string LastPublisher { get; set; }
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>();
} }

6
API_SQLuedo/EntityFramework/SolutionEntity.cs
Unescape View File

@ -11,15 +11,11 @@ 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(int ownerId)
{
OwnerId = ownerId;
}
} }

6
API_SQLuedo/EntityFramework/SuccessEntity.cs
Unescape View File

@ -5,12 +5,10 @@ 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; }
} }

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

10
API_SQLuedo/Model/Lesson.cs
Unescape View File

@ -3,12 +3,12 @@
public class Lesson public class Lesson
{ {
public int Id { get; } public int Id { get; }
public string? Title { get; set; } public string Title { get; set; }
public string? LastPublisher { get; set; } public string LastPublisher { get; set; }
public DateOnly? LastEdit { get; set; } public DateOnly LastEdit { get; set; }
public ICollection<ContentLesson> Content { get; set; } = new List<ContentLesson>(); public ICollection<ContentLesson> Content { get; set; } = new List<ContentLesson>();
public Lesson(int id, string title, string lastPublisher, DateOnly? lastEdit) public Lesson(int id, string title, string lastPublisher, DateOnly lastEdit)
{ {
Id = id; Id = id;
Title = title; Title = title;
@ -16,7 +16,7 @@ public class Lesson
LastEdit = lastEdit; LastEdit = lastEdit;
} }
public Lesson(string title, string lastPublisher, DateOnly? lastEdit) public Lesson(string title, string lastPublisher, DateOnly lastEdit)
{ {
Title = title; Title = title;
LastPublisher = lastPublisher; LastPublisher = lastPublisher;

7
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,7 +18,8 @@ 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;
InquiryId = inquiryId; InquiryId = inquiryId;

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

2
API_SQLuedo/Shared/ILessonService.cs
Unescape View File

@ -9,5 +9,5 @@ public interface ILessonService<TLesson>
public TLesson GetLessonByTitle(string title); public TLesson GetLessonByTitle(string title);
public bool DeleteLesson(int id); public bool DeleteLesson(int id);
public TLesson UpdateLesson(int id, TLesson lesson); public TLesson UpdateLesson(int id, TLesson lesson);
public TLesson CreateLesson(string title, string lastPublisher, DateOnly? lastEdit); public TLesson 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;
}
}

12
API_SQLuedo/Shared/Mapper/BlackListMapper.cs
Unescape View File

@ -6,17 +6,17 @@ namespace Shared.Mapper;
public static class BlackListMapper public static class BlackListMapper
{ {
public static BlackListDTO FromModelToDTO(this BlackList model) public static BlackListDto FromModelToDto(this BlackList model)
{ {
return new BlackListDTO(model.Email, model.ExpirationDate); return new BlackListDto(model.Email, model.ExpirationDate);
} }
public static BlackListDTO FromEntityToDTO(this BlackListEntity ent) public static BlackListDto FromEntityToDto(this BlackListEntity ent)
{ {
return new BlackListDTO(ent.Email, ent.ExpirationDate); return new BlackListDto(ent.Email, ent.ExpirationDate);
} }
public static BlackList FromDTOToModel(this BlackListDTO dto) public static BlackList FromDtoToModel(this BlackListDto dto)
{ {
return new BlackList(dto.Email, dto.ExpirationDate); return new BlackList(dto.Email, dto.ExpirationDate);
} }
@ -26,7 +26,7 @@ public static class BlackListMapper
return new BlackList(ent.Email, ent.ExpirationDate); return new BlackList(ent.Email, ent.ExpirationDate);
} }
public static BlackListEntity FromDtoToEntity(this BlackListDTO dto) public static BlackListEntity FromDtoToEntity(this BlackListDto dto)
{ {
return new BlackListEntity return new BlackListEntity
{ {

12
API_SQLuedo/Shared/Mapper/InquiryMapper.cs
Unescape View File

@ -6,7 +6,7 @@ namespace Shared.Mapper;
public static class InquiryMapper public static class InquiryMapper
{ {
public static Inquiry FromDtoToModel(this InquiryDTO inqDto) public static Inquiry FromDtoToModel(this InquiryDto inqDto)
{ {
return new Inquiry(inqDto.Id, inqDto.Title, inqDto.Description, inqDto.IsUser); return new Inquiry(inqDto.Id, inqDto.Title, inqDto.Description, inqDto.IsUser);
} }
@ -28,7 +28,7 @@ public static class InquiryMapper
}; };
} }
public static InquiryEntity FromDtoToEntity(this InquiryDTO inqDto) public static InquiryEntity FromDtoToEntity(this InquiryDto inqDto)
{ {
return new InquiryEntity return new InquiryEntity
{ {
@ -39,13 +39,13 @@ public static class InquiryMapper
}; };
} }
public static InquiryDTO FromModelToDto(this Inquiry inq) public static InquiryDto FromModelToDto(this Inquiry inq)
{ {
return new InquiryDTO(inq.Id, inq.Title, inq.Description, inq.IsUser); return new InquiryDto(inq.Id, inq.Title, inq.Description, inq.IsUser);
} }
public static InquiryDTO FromEntityToDto(this InquiryEntity inqEntity) public static InquiryDto FromEntityToDto(this InquiryEntity inqEntity)
{ {
return new InquiryDTO(inqEntity.Id, inqEntity.Title, inqEntity.Description, inqEntity.IsUser); return new InquiryDto(inqEntity.Id, inqEntity.Title, inqEntity.Description, inqEntity.IsUser);
} }
} }

12
API_SQLuedo/Shared/Mapper/InquiryTableMapper.cs
Unescape View File

@ -6,7 +6,7 @@ namespace Shared.Mapper;
public static class InquiryTableMapper public static class InquiryTableMapper
{ {
public static InquiryTable FromDtoToModel(this InquiryTableDTO inqTDto) public static InquiryTable FromDtoToModel(this InquiryTableDto inqTDto)
{ {
return new InquiryTable(inqTDto.OwnerId, inqTDto.ConnectionInfo, inqTDto.DatabaseName); return new InquiryTable(inqTDto.OwnerId, inqTDto.ConnectionInfo, inqTDto.DatabaseName);
} }
@ -16,14 +16,14 @@ public static class InquiryTableMapper
return new InquiryTable(inqTEntity.OwnerId, inqTEntity.ConnectionInfo, inqTEntity.DatabaseName); return new InquiryTable(inqTEntity.OwnerId, inqTEntity.ConnectionInfo, inqTEntity.DatabaseName);
} }
public static InquiryTableDTO FromModelToDto(this InquiryTable inqT) public static InquiryTableDto FromModelToDto(this InquiryTable inqT)
{ {
return new InquiryTableDTO(inqT.OwnerId, inqT.DatabaseName, inqT.ConnectionInfo); return new InquiryTableDto(inqT.OwnerId, inqT.DatabaseName, inqT.ConnectionInfo);
} }
public static InquiryTableDTO FromEntityToDto(this InquiryTableEntity inqTEntity) public static InquiryTableDto FromEntityToDto(this InquiryTableEntity inqTEntity)
{ {
return new InquiryTableDTO(inqTEntity.OwnerId, inqTEntity.DatabaseName, inqTEntity.ConnectionInfo); return new InquiryTableDto(inqTEntity.OwnerId, inqTEntity.DatabaseName, inqTEntity.ConnectionInfo);
} }
public static InquiryTableEntity FromModelToEntity(this InquiryTable inqT) public static InquiryTableEntity FromModelToEntity(this InquiryTable inqT)
@ -36,7 +36,7 @@ public static class InquiryTableMapper
}; };
} }
public static InquiryTableEntity FromDtoToEntity(this InquiryTableDTO dto) public static InquiryTableEntity FromDtoToEntity(this InquiryTableDto dto)
{ {
return new InquiryTableEntity return new InquiryTableEntity
{ {

13
API_SQLuedo/Shared/Mapper/LessonMapper.cs
Unescape View File

@ -6,14 +6,14 @@ namespace Shared.Mapper;
public static class LessonMapper public static class LessonMapper
{ {
public static LessonDTO FromModelToDto(this Lesson model) public static LessonDto FromModelToDto(this Lesson model)
{ {
return new LessonDTO(model.Id, model.Title, model.LastPublisher, model.LastEdit); return new LessonDto(model.Id, model.Title, model.LastPublisher, model.LastEdit);
} }
public static LessonDTO FromEntityToDto(this LessonEntity model) public static LessonDto FromEntityToDto(this LessonEntity model)
{ {
return new LessonDTO(model.Id, model.Title, model.LastPublisher, model.LastEdit); return new LessonDto(model.Id, model.Title, model.LastPublisher, model.LastEdit);
} }
public static LessonEntity FromModelToEntity(this Lesson model) public static LessonEntity FromModelToEntity(this Lesson model)
@ -26,8 +26,7 @@ public static class LessonMapper
LastEdit = model.LastEdit LastEdit = model.LastEdit
}; };
} }
public static LessonEntity FromDtoToEntity(this LessonDto dto)
public static LessonEntity FromDtoToEntity(this LessonDTO dto)
{ {
return new LessonEntity return new LessonEntity
{ {
@ -38,7 +37,7 @@ public static class LessonMapper
}; };
} }
public static Lesson FromDtoToModel(this LessonDTO dto) public static Lesson FromDtoToModel(this LessonDto dto)
{ {
return new Lesson(dto.Id, dto.Title, dto.LastPublisher, dto.LastEdit); return new Lesson(dto.Id, dto.Title, dto.LastPublisher, dto.LastEdit);
} }

12
API_SQLuedo/Shared/Mapper/NotepadMapper.cs
Unescape View File

@ -6,7 +6,7 @@ namespace Shared.Mapper;
public static class NotepadMapper public static class NotepadMapper
{ {
public static Notepad FromDtoToModel(this NotepadDTO dto) public static Notepad FromDtoToModel(this NotepadDto dto)
{ {
return new Notepad(dto.Id, dto.UserId, dto.InquiryId, dto.Notes); return new Notepad(dto.Id, dto.UserId, dto.InquiryId, dto.Notes);
} }
@ -16,17 +16,17 @@ public static class NotepadMapper
return new Notepad(ent.Id, ent.UserId, ent.InquiryId, ent.Notes); return new Notepad(ent.Id, ent.UserId, ent.InquiryId, ent.Notes);
} }
public static NotepadDTO FromModelToDto(this Notepad not) public static NotepadDto FromModelToDto(this Notepad not)
{ {
return new NotepadDTO(not.Id, not.UserId, not.InquiryId, not.Notes); return new NotepadDto(not.Id, not.UserId, not.InquiryId, not.Notes);
} }
public static NotepadDTO FromEntityToDto(this NotepadEntity ent) public static NotepadDto FromEntityToDto(this NotepadEntity ent)
{ {
return new NotepadDTO(ent.Id, ent.UserId, ent.InquiryId, ent.Notes); return new NotepadDto(ent.Id, ent.UserId, ent.InquiryId, ent.Notes);
} }
public static NotepadEntity FromDtoToEntity(this NotepadDTO dto) public static NotepadEntity FromDtoToEntity(this NotepadDto dto)
{ {
return new NotepadEntity return new NotepadEntity
{ {

12
API_SQLuedo/Shared/Mapper/ParagraphMapper.cs
Unescape View File

@ -6,7 +6,7 @@ namespace Shared.Mapper;
public static class ParagraphMapper public static class ParagraphMapper
{ {
public static Paragraph FromDTOToModel(this ParagraphDTO dto) public static Paragraph FromDtoToModel(this ParagraphDto dto)
{ {
return new Paragraph(dto.ContentTitle, dto.ContentContent, dto.Info, dto.Query, dto.Comment); return new Paragraph(dto.ContentTitle, dto.ContentContent, dto.Info, dto.Query, dto.Comment);
} }
@ -16,19 +16,19 @@ public static class ParagraphMapper
return new Paragraph(model.ContentTitle, model.ContentContent, model.Info, model.Query, model.Comment); return new Paragraph(model.ContentTitle, model.ContentContent, model.Info, model.Query, model.Comment);
} }
public static ParagraphDTO FromEntityToDto(this ParagraphEntity model) public static ParagraphDto FromEntityToDto(this ParagraphEntity model)
{ {
return new ParagraphDTO(model.Id, model.ContentTitle, model.ContentContent, model.Info, model.Query, return new ParagraphDto(model.Id, model.ContentTitle, model.ContentContent, model.Info, model.Query,
model.Comment, model.LessonId); model.Comment, model.LessonId);
} }
public static ParagraphDTO FromModelToDTO(this Paragraph model) public static ParagraphDto FromModelToDto(this Paragraph model)
{ {
return new ParagraphDTO(model.Id, model.ContentTitle, model.ContentContent, model.Info, model.Query, return new ParagraphDto(model.Id, model.ContentTitle, model.ContentContent, model.Info, model.Query,
model.Comment, model.LessonId); model.Comment, model.LessonId);
} }
public static ParagraphEntity FromDtoToEntity(this ParagraphDTO dto) public static ParagraphEntity FromDtoToEntity(this ParagraphDto dto)
{ {
return new ParagraphEntity return new ParagraphEntity
{ {

12
API_SQLuedo/Shared/Mapper/SolutionMapper.cs
Unescape View File

@ -6,7 +6,7 @@ namespace Shared.Mapper;
public static class SolutionMapper public static class SolutionMapper
{ {
public static Solution FromDtoToModel(this SolutionDTO dto) public static Solution FromDtoToModel(this SolutionDto dto)
{ {
return new Solution(dto.OwnerId, dto.MurdererFirstName, dto.MurdererLastName, dto.MurderPlace, dto.MurderWeapon, return new Solution(dto.OwnerId, dto.MurdererFirstName, dto.MurdererLastName, dto.MurderPlace, dto.MurderWeapon,
dto.Explanation); dto.Explanation);
@ -18,15 +18,15 @@ public static class SolutionMapper
entity.MurderWeapon, entity.Explaination); entity.MurderWeapon, entity.Explaination);
} }
public static SolutionDTO FromModelToDto(this Solution model) public static SolutionDto FromModelToDto(this Solution model)
{ {
return new SolutionDTO(model.OwnerId, model.MurdererFirstName, model.MurdererLastName, model.MurderPlace, return new SolutionDto(model.OwnerId, model.MurdererFirstName, model.MurdererLastName, model.MurderPlace,
model.MurderWeapon, model.Explanation); model.MurderWeapon, model.Explanation);
} }
public static SolutionDTO FromEntityToDto(this SolutionEntity entity) public static SolutionDto FromEntityToDto(this SolutionEntity entity)
{ {
return new SolutionDTO(entity.OwnerId, entity.MurdererFirstName, entity.MurdererLastName, entity.MurderPlace, return new SolutionDto(entity.OwnerId, entity.MurdererFirstName, entity.MurdererLastName, entity.MurderPlace,
entity.MurderWeapon, entity.Explaination); entity.MurderWeapon, entity.Explaination);
} }
@ -47,7 +47,7 @@ public static class SolutionMapper
}; };
} }
public static SolutionEntity FromDtoToEntity(this SolutionDTO dto) public static SolutionEntity FromDtoToEntity(this SolutionDto dto)
{ {
return new SolutionEntity return new SolutionEntity
{ {

12
API_SQLuedo/Shared/Mapper/SuccessMapper.cs
Unescape View File

@ -6,7 +6,7 @@ namespace Shared.Mapper;
public static class SuccessMapper public static class SuccessMapper
{ {
public static Success FromDtoToModel(this SuccessDTO dto) public static Success FromDtoToModel(this SuccessDto dto)
{ {
return new Success(dto.UserId, dto.InquiryId, dto.IsFinished); return new Success(dto.UserId, dto.InquiryId, dto.IsFinished);
} }
@ -16,17 +16,17 @@ public static class SuccessMapper
return new Success(ent.UserId, ent.InquiryId, ent.IsFinished); return new Success(ent.UserId, ent.InquiryId, ent.IsFinished);
} }
public static SuccessDTO FromModelToDto(this Success suc) public static SuccessDto FromModelToDto(this Success suc)
{ {
return new SuccessDTO(suc.UserId, suc.InquiryId, suc.IsFinished); return new SuccessDto(suc.UserId, suc.InquiryId, suc.IsFinished);
} }
public static SuccessDTO FromEntityToDto(this SuccessEntity ent) public static SuccessDto FromEntityToDto(this SuccessEntity ent)
{ {
return new SuccessDTO(ent.UserId, ent.InquiryId, ent.IsFinished); return new SuccessDto(ent.UserId, ent.InquiryId, ent.IsFinished);
} }
public static SuccessEntity FromDtoToEntity(this SuccessDTO dto) public static SuccessEntity FromDtoToEntity(this SuccessDto dto)
{ {
return new SuccessEntity return new SuccessEntity
{ {

12
API_SQLuedo/Shared/Mapper/UserMapper.cs
Unescape View File

@ -6,12 +6,12 @@ namespace Shared.Mapper;
public static class UserMapper public static class UserMapper
{ {
public static User FromDtoToModel(this UserDTO dto) public static User FromDtoToModel(this UserDto dto)
{ {
return new User(dto.Id, dto.Username, dto.Password, dto.Email, dto.IsAdmin); return new User(dto.Id, dto.Username, dto.Password, dto.Email, dto.IsAdmin);
} }
public static UserEntity FromDtoToEntity(this UserDTO dto) public static UserEntity FromDtoToEntity(this UserDto dto)
{ {
return new UserEntity return new UserEntity
{ {
@ -28,14 +28,14 @@ public static class UserMapper
return new User(entity.Id, entity.Username, entity.Password, entity.Email, entity.IsAdmin); return new User(entity.Id, entity.Username, entity.Password, entity.Email, entity.IsAdmin);
} }
public static UserDTO FromEntityToDto(this UserEntity entity) public static UserDto FromEntityToDto(this UserEntity entity)
{ {
return new UserDTO(entity.Id, entity.Username, entity.Password, entity.Email, entity.IsAdmin); return new UserDto(entity.Id, entity.Username, entity.Password, entity.Email, entity.IsAdmin);
} }
public static UserDTO FromModelToDto(this User user) public static UserDto FromModelToDto(this User user)
{ {
return new UserDTO(user.Id, user.Username, user.Password, user.Email, user.IsAdmin); return new UserDto(user.Id, user.Username, user.Password, user.Email, user.IsAdmin);
} }
public static UserEntity FromModelToEntity(this User user) public static UserEntity FromModelToEntity(this User user)

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

15
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;
@ -13,10 +12,10 @@ public class StubbedContext : UserDbContext
{ {
} }
protected override void OnModelCreating(ModelBuilder modelBuilder) protected override void OnModelCreating(ModelBuilder builder)
{ {
base.OnModelCreating(modelBuilder); base.OnModelCreating(builder);
modelBuilder.Entity<UserEntity>().HasData( builder.Entity<UserEntity>().HasData(
new UserEntity new UserEntity
{ {
Id = 1, Id = 1,
@ -83,7 +82,7 @@ public class StubbedContext : UserDbContext
IsAdmin = true IsAdmin = true
}); });
modelBuilder.Entity<InquiryTableEntity>().HasData( builder.Entity<InquiryTableEntity>().HasData(
new InquiryTableEntity new InquiryTableEntity
{ {
OwnerId = 1, OwnerId = 1,
@ -106,7 +105,7 @@ public class StubbedContext : UserDbContext
"Server=localhost;Database=Inquiry3;Trusted_Connection=True;MultipleActiveResultSets=true" "Server=localhost;Database=Inquiry3;Trusted_Connection=True;MultipleActiveResultSets=true"
}); });
modelBuilder.Entity<SolutionEntity>().HasData( builder.Entity<SolutionEntity>().HasData(
new SolutionEntity new SolutionEntity
{ {
OwnerId = 1, OwnerId = 1,
@ -135,7 +134,7 @@ public class StubbedContext : UserDbContext
Explaination = "Parce que c'est Erwan" Explaination = "Parce que c'est Erwan"
}); });
modelBuilder.Entity<InquiryEntity>().HasData( builder.Entity<InquiryEntity>().HasData(
new InquiryEntity new InquiryEntity
{ {
Id = 1, Id = 1,

16
API_SQLuedo/TestAPI/Extensions/InquiryDto.EqualityComparer.cs
Unescape View File

@ -0,0 +1,16 @@
using Dto;
namespace TestAPI.Extensions;
class InquiryIdEqualityComparer : EqualityComparer<InquiryDto>
{
public override bool Equals(InquiryDto x, InquiryDto y)
{
return x.Id == y.Id;
}
public override int GetHashCode(InquiryDto obj)
{
return obj.Id;
}
}

16
API_SQLuedo/TestAPI/Extensions/LessonsDto.EqualityComparer.cs
Unescape View File

@ -0,0 +1,16 @@
using Dto;
namespace TestAPI.Extensions;
class LessonIdEqualityComparer : EqualityComparer<LessonDto>
{
public override bool Equals(LessonDto x, LessonDto y)
{
return x.Id == y.Id;
}
public override int GetHashCode(LessonDto obj)
{
return obj.Id;
}
}

16
API_SQLuedo/TestAPI/Extensions/ParagraphDto.EqualityComparer.cs
Unescape View File

@ -0,0 +1,16 @@
using Dto;
namespace TestAPI.Extensions;
class ParagraphIdEqualityComparer : EqualityComparer<ParagraphDto>
{
public override bool Equals(ParagraphDto x, ParagraphDto y)
{
return x.Id == y.Id;
}
public override int GetHashCode(ParagraphDto obj)
{
return obj.Id;
}
}

16
API_SQLuedo/TestAPI/Extensions/SuccessDto.EqualityComparer.cs
Unescape View File

@ -0,0 +1,16 @@
using Dto;
namespace TestAPI.Extensions;
class SuccessIdEqualityComparer : EqualityComparer<SuccessDto>
{
public override bool Equals(SuccessDto x, SuccessDto y)
{
return x.UserId == y.UserId && x.InquiryId == y.InquiryId;
}
public override int GetHashCode(SuccessDto obj)
{
return obj.UserId * obj.InquiryId;
}
}

16
API_SQLuedo/TestAPI/Extensions/UserDto.EqualityComparer.cs
Unescape View File

@ -0,0 +1,16 @@
using Dto;
namespace TestAPI.Extensions;
class UserIdEqualityComparer : EqualityComparer<UserDto>
{
public override bool Equals(UserDto x, UserDto y)
{
return x.Id == y.Id;
}
public override int GetHashCode(UserDto obj)
{
return obj.Id;
}
}

267
API_SQLuedo/TestAPI/InquiryUnitTest.cs
Unescape View File

@ -0,0 +1,267 @@
using Dto;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
using Shared;
using API.Controllers;
using TestAPI.Extensions;
namespace TestAPI;
public class InquiryUnitTest
{
private readonly Mock<IInquiryService<InquiryDto>> _inquiryService;
public InquiryUnitTest()
{
_inquiryService = new Mock<IInquiryService<InquiryDto>>();
}
[Fact]
public void GetInquiriesListSuccess()
{
var inquiryList = GetInquiriesData();
_inquiryService.Setup(x => x.GetInquiries(1, 4, 0))
.Returns(inquiryList);
var inquiryController = new InquiriesController(_inquiryService.Object, new NullLogger<InquiriesController>());
var inquiriesResult = inquiryController.GetInquiries(1, 4, 0);
if (inquiriesResult is OkObjectResult okObjectResult)
{
var valeur = okObjectResult.Value;
Assert.NotNull(valeur);
Assert.Equal(GetInquiriesData().ToString(), valeur.ToString());
Assert.True(inquiryList.SequenceEqual(valeur as IEnumerable<InquiryDto>, new InquiryIdEqualityComparer()));
}
}
[Fact]
public void GetInquiresListFail()
{
_inquiryService.Setup(x => x.GetInquiries(1, 4, 0))
.Returns(new List<InquiryDto>());
var inquiryController = new InquiriesController(_inquiryService.Object, new NullLogger<InquiriesController>());
var inquiriesResult = inquiryController.GetInquiries(2, 3, 0);
if (inquiriesResult is StatusCodeResult statusCodeResult && statusCodeResult.StatusCode == 204)
{
Assert.IsNotType<OkObjectResult>(inquiriesResult);
}
}
[Fact]
public void GetInquiryIdSuccess()
{
var inquiryList = GetInquiriesData();
_inquiryService.Setup(x => x.GetInquiryById(1))
.Returns(inquiryList[1]);
var inquiriesController =
new InquiriesController(_inquiryService.Object, new NullLogger<InquiriesController>());
var inquiryResult = inquiriesController.GetInquiryById(1);
if (inquiryResult is OkObjectResult okObjectResult)
{
InquiryDto valeur = okObjectResult.Value as InquiryDto;
Assert.NotNull(valeur);
Assert.Equal("titre 2", valeur.Title);
Assert.Equal("Description", valeur.Description);
Assert.True(valeur.IsUser);
Assert.Equal(valeur.GetHashCode(), inquiryList[1].GetHashCode());
Assert.True(valeur.Equals(inquiryList[1]));
Assert.False(valeur.Equals(new object()));
Assert.IsType<InquiryDto>(valeur);
Assert.Contains(valeur, inquiryList);
}
}
[Fact]
public void GetInquiryIdFail()
{
var inquiryList = GetInquiriesData();
_inquiryService.Setup(x => x.GetInquiryById(1))
.Returns(inquiryList[1]);
var inquiriesController =
new InquiriesController(_inquiryService.Object, new NullLogger<InquiriesController>());
var inquiryResult = inquiriesController.GetInquiryById(100);
if (inquiryResult is NotFoundObjectResult nfObjectResult)
{
var valeur = nfObjectResult.Value;
Assert.NotNull(valeur);
Assert.IsNotType<InquiryDto>(valeur);
Assert.DoesNotContain(valeur, inquiryList);
}
}
[Fact]
public void GetInquiryTitleSuccess()
{
var inquiryList = GetInquiriesData();
_inquiryService.Setup(x => x.GetInquiryByTitle("ZUDZU"))
.Returns(inquiryList[2]);
var inquiriesController =
new InquiriesController(_inquiryService.Object, new NullLogger<InquiriesController>());
var inquiriesResult = inquiriesController.GetInquiryByTitle("ZUDZU");
if (inquiriesResult is OkObjectResult okObjectResult)
{
InquiryDto valeur = okObjectResult.Value as InquiryDto;
Assert.NotNull(valeur);
Assert.IsType<InquiryDto>(valeur);
Assert.Contains(valeur, inquiryList);
Assert.Equal("ZUDZU", valeur.Title);
Assert.Equal("OUHHHH", valeur.Description);
Assert.Equal(2, valeur.Id);
Assert.False(valeur.IsUser);
}
}
[Fact]
public void GetInquiryTitleFail()
{
var inquiryList = GetInquiriesData();
_inquiryService.Setup(x => x.GetInquiryByTitle("ZUDZU"))
.Returns(inquiryList[2]);
var inquiriesController =
new InquiriesController(_inquiryService.Object, new NullLogger<InquiriesController>());
var inquiriesResult = inquiriesController.GetInquiryByTitle("GYIIieihhh");
if (inquiriesResult is NotFoundObjectResult nfObjectResult)
{
var valeur = nfObjectResult.Value;
Assert.NotNull(valeur);
Assert.IsNotType<InquiryDto>(valeur);
Assert.DoesNotContain(valeur, inquiryList);
Assert.False(inquiryList == valeur);
}
}
[Fact]
public void DeleteInquirySuccess()
{
_inquiryService.Setup(x => x.DeleteInquiry(1))
.Returns(true);
var inquiriesController =
new InquiriesController(_inquiryService.Object, new NullLogger<InquiriesController>());
var inquiryResult = inquiriesController.DeleteInquiry(1);
if (inquiryResult is OkObjectResult okObjectResult)
{
bool valeur = (bool)okObjectResult.Value;
Assert.True(valeur);
}
}
[Fact]
public void DeleteInquiryFail()
{
_inquiryService.Setup(x => x.DeleteInquiry(1))
.Returns(true);
var inquiriesController =
new InquiriesController(_inquiryService.Object, new NullLogger<InquiriesController>());
var inquiryResult = inquiriesController.DeleteInquiry(100);
if (inquiryResult is NotFoundObjectResult nfObjectResult)
{
Assert.Null(nfObjectResult.Value);
Assert.IsNotType<bool>(nfObjectResult.Value);
}
}
[Fact]
public void CreateInquirySuccess()
{
_inquiryService.Setup(x => x.CreateInquiry("Titros", "description", false))
.Returns(new InquiryDto(4, "Titros", "description", false));
var inquiriesController =
new InquiriesController(_inquiryService.Object, new NullLogger<InquiriesController>());
var inquiriesResult = inquiriesController.CreateInquiry(new InquiryDto("Titros", "description", false));
if (inquiriesResult is CreatedResult createdObjectResult)
{
InquiryDto valeur = createdObjectResult.Value as InquiryDto;
Assert.NotNull(valeur);
Assert.Equal(4, valeur.Id);
Assert.Equal("Titros", valeur.Title);
Assert.Equal("description", valeur.Description);
Assert.False(valeur.IsUser);
}
}
[Fact]
public void CreateInquiryFail()
{
_inquiryService.Setup(x => x.CreateInquiry("Titros", "description", false))
.Returns(new InquiryDto(4, "Titros", "description", false));
var inquiriesController =
new InquiriesController(_inquiryService.Object, new NullLogger<InquiriesController>());
var inquiriesResult = inquiriesController.CreateInquiry(new InquiryDto(4, null, "heudfk@hdye.com", true));
if (inquiriesResult is BadRequestResult bdObjectResult)
{
Assert.Equal(400, bdObjectResult.StatusCode);
}
}
[Fact]
public void UpdateInquirySuccess()
{
_inquiryService.Setup(x => x.UpdateInquiry(1, new InquiryDto(1, "Passssss", "heudfk@hdye.com", true)))
.Returns(new InquiryDto(1, "Passssss", "heudfk@hdye.com", true));
var inquiriesController =
new InquiriesController(_inquiryService.Object, new NullLogger<InquiriesController>());
var inquiriesResult =
inquiriesController.UpdateInquiry(1, new InquiryDto(1, "Passssss", "heudfk@hdye.com", true));
if (inquiriesResult is OkObjectResult okObjectResult)
{
InquiryDto valeur = okObjectResult.Value as InquiryDto;
Assert.NotNull(valeur);
Assert.Equal("Passssss", valeur.Title);
Assert.Equal("heudfk@hdye.com", valeur.Description);
Assert.True(valeur.IsUser);
}
}
[Fact]
public void UpdateInquiryFail()
{
_inquiryService.Setup(x => x.UpdateInquiry(1, new InquiryDto(1, "Passssss", "heudfk@hdye.com", true)))
.Returns(new InquiryDto(1, "Passssss", "heudfk@hdye.com", true));
var inquiriesController =
new InquiriesController(_inquiryService.Object, new NullLogger<InquiriesController>());
var inquiriesResult =
inquiriesController.UpdateInquiry(1, new InquiryDto(2, "Passssss", "heudfk@hdye.com", true));
if (inquiriesResult is BadRequestResult bdObjectResultx)
{
Assert.Equal(400, bdObjectResult.StatusCode);
}
}
private List<InquiryDto> GetInquiriesData()
{
List<InquiryDto> inquiriesData = new List<InquiryDto>(4)
{
new(0, "titre 1", "La desc", false),
new(1, "titre 2", "Description", true),
new(2, "ZUDZU", "OUHHHH", false),
new("titre premium", "Ascendant", true),
};
return inquiriesData;
}
}

267
API_SQLuedo/TestAPI/LessonUnitTest.cs
Unescape View File

@ -0,0 +1,267 @@
using API.Controllers;
using Dto;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
using Shared;
using TestAPI.Extensions;
namespace TestAPI;
public class LessonUnitTest
{
private readonly Mock<ILessonService<LessonDto>> _lessonService;
public LessonUnitTest()
{
_lessonService = new Mock<ILessonService<LessonDto>>();
}
[Fact]
public void GetLessonsListSuccess()
{
var lessonList = GetLessonsData();
_lessonService.Setup(x => x.GetLessons(1, 4, 0))
.Returns(lessonList);
var lessonsController = new LessonsController(_lessonService.Object, new NullLogger<LessonsController>());
var lessonsResult = lessonsController.GetLessons(1, 4, 0);
if (lessonsResult is OkObjectResult okObjectResult)
{
var valeur = okObjectResult.Value;
Assert.NotNull(valeur);
Assert.Equal(GetLessonsData().ToString(), valeur.ToString());
Assert.True(lessonList.SequenceEqual(valeur as IEnumerable<LessonDto>, new LessonIdEqualityComparer()));
}
}
[Fact]
public void GetLessonsListFail()
{
_lessonService.Setup(x => x.GetLessons(1, 4, 0))
.Returns(new List<LessonDto>());
var lessonsController = new LessonsController(_lessonService.Object, new NullLogger<LessonsController>());
var lessonsResult = lessonsController.GetLessons(2, 3, 0);
if (lessonsResult is StatusCodeResult statusCodeResult && statusCodeResult.StatusCode == 204)
{
Assert.IsNotType<OkObjectResult>(lessonsResult);
}
}
[Fact]
public void GetLessonIdSuccess()
{
var lessonList = GetLessonsData();
_lessonService.Setup(x => x.GetLessonById(1))
.Returns(lessonList[0]);
var lessonsController = new LessonsController(_lessonService.Object, new NullLogger<LessonsController>());
var lessonsResult = lessonsController.GetLessonById(1);
if (lessonsResult is OkObjectResult okObjectResult)
{
LessonDto valeur = okObjectResult.Value as LessonDto;
Assert.NotNull(valeur);
Assert.Equal("Le titre", valeur.Title);
Assert.Equal("Clément", valeur.LastPublisher);
Assert.Equal(new DateOnly(2024, 03, 10), valeur.LastEdit);
Assert.NotEqual(2, valeur.Id);
Assert.Equal(valeur.GetHashCode(), lessonList[0].GetHashCode());
Assert.True(valeur.Equals(lessonList[0]));
Assert.False(valeur.Equals(new object()));
Assert.True(valeur.Equals(valeur));
Assert.IsType<LessonDto>(valeur);
Assert.Contains(valeur, lessonList);
}
}
[Fact]
public void GetLessonIdFail()
{
var lessonList = GetLessonsData();
_lessonService.Setup(x => x.GetLessonById(1))
.Returns(lessonList[0]);
var lessonsController = new LessonsController(_lessonService.Object, new NullLogger<LessonsController>());
var lessonsResult = lessonsController.GetLessonById(100);
if (lessonsResult is NotFoundObjectResult nfObjectResult)
{
var valeur = nfObjectResult.Value;
Assert.NotNull(valeur);
Assert.IsNotType<LessonDto>(valeur);
Assert.DoesNotContain(valeur, lessonList);
}
}
[Fact]
public void GetLessonTitleSuccess()
{
var lessonList = GetLessonsData();
_lessonService.Setup(x => x.GetLessonByTitle("Chiant la"))
.Returns(lessonList[2]);
var lessonsController = new LessonsController(_lessonService.Object, new NullLogger<LessonsController>());
var lessonsResult = lessonsController.GetLessonByTitle("Chiant la");
if (lessonsResult is OkObjectResult okObjectResult)
{
LessonDto valeur = okObjectResult.Value as LessonDto;
Assert.NotNull(valeur);
Assert.Equal("Chiant la", valeur.Title);
Assert.Equal("Une personne", valeur.LastPublisher);
Assert.Equal(new DateOnly(2012, 12, 25), valeur.LastEdit);
Assert.Equal(3, valeur.Id);
Assert.IsType<LessonDto>(valeur);
Assert.Contains(valeur, lessonList);
}
}
[Fact]
public void GetLessonTitleFail()
{
var lessonList = GetLessonsData();
_lessonService.Setup(x => x.GetLessonByTitle("Chiant la"))
.Returns(lessonList[2]);
var lessonsController = new LessonsController(_lessonService.Object, new NullLogger<LessonsController>());
var lessonsResult = lessonsController.GetLessonByTitle("IUHIUHU");
if (lessonsResult is NotFoundObjectResult nfObjectResult)
{
var valeur = nfObjectResult.Value;
Assert.NotNull(valeur);
Assert.IsNotType<LessonDto>(valeur);
Assert.DoesNotContain(valeur, lessonList);
Assert.False(lessonList == valeur);
}
}
[Fact]
public void DeleteLessonSuccess()
{
_lessonService.Setup(x => x.DeleteLesson(1))
.Returns(true);
var lessonsController = new LessonsController(_lessonService.Object, new NullLogger<LessonsController>());
var lessonsResult = lessonsController.DeleteLesson(1);
if (lessonsResult is OkObjectResult okObjectResult)
{
bool valeur = (bool)okObjectResult.Value;
Assert.True(valeur);
}
}
[Fact]
public void DeleteLessonFail()
{
_lessonService.Setup(x => x.DeleteLesson(1))
.Returns(true);
var lessonsController = new LessonsController(_lessonService.Object, new NullLogger<LessonsController>());
var lessonsResult = lessonsController.DeleteLesson(100);
if (lessonsResult is NotFoundObjectResult nfObjectResult)
{
Assert.Null(nfObjectResult.Value);
Assert.IsNotType<bool>(nfObjectResult.Value);
}
}
[Fact]
public void CreateLessonSuccess()
{
_lessonService.Setup(x => x.CreateLesson("Le nouveau titre", "Le nouvel éditeur", new DateOnly(2024, 03, 16)))
.Returns(new LessonDto("Le nouveau titre", "Le nouvel éditeur", new DateOnly(2024, 03, 16)));
var lessonsController = new LessonsController(_lessonService.Object, new NullLogger<LessonsController>());
var lessonsResult =
lessonsController.CreateLesson(new LessonDto("Le nouveau titre", "Le nouvel éditeur",
new DateOnly(2024, 03, 16)));
if (lessonsResult is CreatedResult createdObjectResult)
{
LessonDto valeur = createdObjectResult.Value as LessonDto;
Assert.NotNull(valeur);
Assert.Equal("Le nouveau titre", valeur.Title);
Assert.Equal("Le nouvel éditeur", valeur.LastPublisher);
Assert.Equal(new DateOnly(2024, 03, 16), valeur.LastEdit);
}
}
[Fact]
public void CreateLessonFail()
{
_lessonService.Setup(x => x.CreateLesson("Le nouveau titre", "Le nouvel éditeur", new DateOnly(2024, 03, 16)))
.Returns(new LessonDto("Le nouveau titre", "Le nouvel éditeur", new DateOnly(2024, 03, 16)));
var lessonsController = new LessonsController(_lessonService.Object, new NullLogger<LessonsController>());
var lessonsResult =
lessonsController.CreateLesson(new LessonDto(null, "Le nouvel éditeur", new DateOnly(2024, 03, 16)));
if (lessonsResult is BadRequestResult bdObjectResult)
{
Assert.Equal(400, bdObjectResult.StatusCode);
}
}
[Fact]
public void UpdateLessonSuccess()
{
_lessonService.Setup(x =>
x.UpdateLesson(1, new LessonDto(1, "Titre update", "Le dernier publisher", new DateOnly(2022, 02, 02))))
.Returns(new LessonDto(1, "Titre update", "Le dernier publisher", new DateOnly(2022, 02, 02)));
var lessonsController = new LessonsController(_lessonService.Object, new NullLogger<LessonsController>());
var lessonsResult = lessonsController.UpdateLesson(1,
new LessonDto(1, "Titre update", "Le dernier publisher", new DateOnly(2022, 02, 02)));
if (lessonsResult is OkObjectResult okObjectResult)
{
LessonDto valeur = okObjectResult.Value as LessonDto;
Assert.NotNull(valeur);
Assert.Equal("Titre update", valeur.Title);
Assert.Equal("Le dernier publisher", valeur.LastPublisher);
Assert.Equal(new DateOnly(2022, 02, 02), valeur.LastEdit);
Assert.Equal(1, valeur.Id);
}
}
[Fact]
public void UpdateLessonFail()
{
_lessonService.Setup(x =>
x.UpdateLesson(1, new LessonDto(1, "Titre update", "Le dernier publisher", new DateOnly(2022, 02, 02))))
.Returns(new LessonDto(1, "Titre update", "Le dernier publisher", new DateOnly(2022, 02, 02)));
var lessonsController = new LessonsController(_lessonService.Object, new NullLogger<LessonsController>());
var lessonsResult = lessonsController.UpdateLesson(1,
new LessonDto(2, "Titre update", "Le dernier publisher", new DateOnly(2022, 02, 02)));
if (lessonsResult is BadRequestResult bdObjectResult)
{
Assert.Equal(400, bdObjectResult.StatusCode);
}
}
private List<LessonDto> GetLessonsData()
{
List<LessonDto> lessonsData = new List<LessonDto>(4)
{
new(1, "Le titre", "Clément", new DateOnly(2024, 03, 10)),
new(2, "Pas titre", "Erwan", new DateOnly(2024, 02, 11)),
new(3, "Chiant la", "Une personne", new DateOnly(2012, 12, 25)),
new("Les fleurs du mal", "Baudelaire", new DateOnly(1872, 10, 01)),
};
return lessonsData;
}
}

300
API_SQLuedo/TestAPI/ParagraphsUnitTest.cs
Unescape View File

@ -0,0 +1,300 @@
using API.Controllers;
using Dto;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
using Shared;
using TestAPI.Extensions;
namespace TestAPI;
public class ParagraphsUnitTest
{
private readonly Mock<IParagraphService<ParagraphDto>> _paragraphService;
public ParagraphsUnitTest()
{
_paragraphService = new Mock<IParagraphService<ParagraphDto>>();
}
[Fact]
public void GetParagraphsListSuccess()
{
var paragraphsList = GetParagraphsData();
_paragraphService.Setup(x => x.GetParagraphs(1, 4, 0))
.Returns(paragraphsList);
var paragraphsController =
new ParagraphsController(_paragraphService.Object, new NullLogger<ParagraphsController>());
var paragraphsResult = paragraphsController.GetParagraphs(1, 4, 0);
if (paragraphsResult is OkObjectResult okObjectResult)
{
var valeur = okObjectResult.Value;
Assert.NotNull(valeur);
Assert.Equal(GetParagraphsData().ToString(), valeur.ToString());
Assert.True(paragraphsList.SequenceEqual(valeur as IEnumerable<ParagraphDto>,
new ParagraphIdEqualityComparer()));
}
}
[Fact]
public void GetParagraphsListFail()
{
_paragraphService.Setup(x => x.GetParagraphs(1, 4, 0))
.Returns(new List<ParagraphDto>());
var paragraphsController =
new ParagraphsController(_paragraphService.Object, new NullLogger<ParagraphsController>());
var paragraphsResult = paragraphsController.GetParagraphs(1, 4, 0);
if (paragraphsResult is StatusCodeResult statusCodeResult && statusCodeResult.StatusCode == 204)
{
Assert.IsNotType<OkObjectResult>(paragraphsResult);
}
}
[Fact]
public void GetParagraphIdSuccess()
{
var paragraphsList = GetParagraphsData();
_paragraphService.Setup(x => x.GetParagraphById(1))
.Returns(paragraphsList[1]);
var paragraphsController =
new ParagraphsController(_paragraphService.Object, new NullLogger<ParagraphsController>());
var paragraphsResult = paragraphsController.GetParagraphById(1);
if (paragraphsResult is OkObjectResult okObjectResult)
{
ParagraphDto valeur = okObjectResult.Value as ParagraphDto;
Assert.NotNull(valeur);
Assert.Equal("Le titre", valeur.Title);
Assert.Equal("pas contenu", valeur.Content);
Assert.Equal("Pas d'infos ici", valeur.Info);
Assert.Equal("Delete * from Earth", valeur.Query);
Assert.Equal("Miam", valeur.Comment);
Assert.Equal(2, valeur.LessonId);
Assert.Equal(valeur.GetHashCode(), paragraphsList[1].GetHashCode());
Assert.True(valeur.Equals(paragraphsList[1]));
Assert.False(valeur.Equals(new object()));
Assert.True(valeur.Equals(valeur));
Assert.IsType<ParagraphDto>(valeur);
Assert.Contains(valeur, paragraphsList);
}
}
[Fact]
public void GetParagraphIdFail()
{
var paragraphsList = GetParagraphsData();
_paragraphService.Setup(x => x.GetParagraphById(1))
.Returns(paragraphsList[1]);
var paragraphsController =
new ParagraphsController(_paragraphService.Object, new NullLogger<ParagraphsController>());
var paragraphsResult = paragraphsController.GetParagraphById(100);
if (paragraphsResult is NotFoundObjectResult nfObjectResult)
{
var valeur = nfObjectResult.Value;
Assert.NotNull(valeur);
Assert.IsNotType<ParagraphDto>(valeur);
Assert.DoesNotContain(valeur, paragraphsList);
}
}
[Fact]
public void GetParagraphTitleSuccess()
{
var paragraphsList = GetParagraphsData();
_paragraphService.Setup(x => x.GetParagraphByTitle("Title"))
.Returns(paragraphsList[3]);
var paragraphsController =
new ParagraphsController(_paragraphService.Object, new NullLogger<ParagraphsController>());
var paragraphsResult = paragraphsController.GetParagraphByTitle("Title");
if (paragraphsResult is OkObjectResult okObjectResult)
{
ParagraphDto valeur = okObjectResult.Value as ParagraphDto;
Assert.NotNull(valeur);
Assert.Equal("Title", valeur.Title);
Assert.Equal("Content", valeur.Content);
Assert.Equal("Je ne parle pas anglais", valeur.Info);
Assert.Equal("Select select from select", valeur.Query);
Assert.Equal("Mais qui est ce commentaire", valeur.Comment);
Assert.Equal(3, valeur.LessonId);
Assert.IsType<ParagraphDto>(valeur);
Assert.Contains(valeur, paragraphsList);
}
}
[Fact]
public void GetParagraphTitleFail()
{
var paragraphsList = GetParagraphsData();
_paragraphService.Setup(x => x.GetParagraphByTitle("Title"))
.Returns(paragraphsList[3]);
var paragraphsController =
new ParagraphsController(_paragraphService.Object, new NullLogger<ParagraphsController>());
var paragraphsResult = paragraphsController.GetParagraphByTitle("IUHIUHU");
if (paragraphsResult is NotFoundObjectResult nfObjectResult)
{
var valeur = nfObjectResult.Value;
Assert.NotNull(valeur);
Assert.IsNotType<ParagraphDto>(valeur);
Assert.DoesNotContain(valeur, paragraphsList);
Assert.False(paragraphsList == valeur);
}
}
[Fact]
public void DeleteParagraphSuccess()
{
_paragraphService.Setup(x => x.DeleteParagraph(1))
.Returns(true);
var paragraphsController =
new ParagraphsController(_paragraphService.Object, new NullLogger<ParagraphsController>());
var paragraphsResult = paragraphsController.DeleteParagraph(1);
if (paragraphsResult is OkObjectResult okObjectResult)
{
bool valeur = (bool)okObjectResult.Value;
Assert.True(valeur);
}
}
[Fact]
public void DeleteParagraphFail()
{
_paragraphService.Setup(x => x.DeleteParagraph(1))
.Returns(true);
var paragraphsController =
new ParagraphsController(_paragraphService.Object, new NullLogger<ParagraphsController>());
var paragraphsResult = paragraphsController.DeleteParagraph(100);
if (paragraphsResult is NotFoundObjectResult nfObjectResult)
{
Assert.Null(nfObjectResult.Value);
Assert.IsNotType<bool>(nfObjectResult.Value);
}
}
[Fact]
public void CreateParagraphSuccess()
{
_paragraphService.Setup(x => x.CreateParagraph("Le nouveau titre", "Le nouveau content", "Les infos",
"La requête requêtante", "Commentaires", 2))
.Returns(new ParagraphDto("Le nouveau titre", "Le nouveau content", "Les infos", "La requête requêtante",
"Commentaires", 2));
var paragraphsController =
new ParagraphsController(_paragraphService.Object, new NullLogger<ParagraphsController>());
var paragraphsResult = paragraphsController.CreateParagraph(new ParagraphDto("Le nouveau titre",
"Le nouveau content", "Les infos", "La requête requêtante", "Commentaires", 2));
if (paragraphsResult is CreatedResult createdObjectResult)
{
ParagraphDto valeur = createdObjectResult.Value as ParagraphDto;
Assert.NotNull(valeur);
Assert.Equal("Le nouveau titre", valeur.Title);
Assert.Equal("Le nouveau content", valeur.Content);
Assert.Equal("Les infos", valeur.Info);
Assert.Equal("La requête requêtante", valeur.Query);
Assert.Equal("Commentaires", valeur.Comment);
Assert.Equal(2, valeur.LessonId);
}
}
[Fact]
public void CreateParagraphFail()
{
_paragraphService.Setup(x => x.CreateParagraph("Le nouveau titre", "Le nouveau content", "Les infos",
"La requête requêtante", "Commentaires", 2))
.Returns(new ParagraphDto("Le nouveau titre", "Le nouveau content", "Les infos", "La requête requêtante",
"Commentaires", 2));
var paragraphsController =
new ParagraphsController(_paragraphService.Object, new NullLogger<ParagraphsController>());
var paragraphsResult = paragraphsController.CreateParagraph(new ParagraphDto(null, "Le nouveau content",
"Les infos", "La requête requêtante", "Commentaires", 2));
if (paragraphsResult is BadRequestResult bdObjectResult)
{
Assert.Equal(400, bdObjectResult.StatusCode);
}
}
[Fact]
public void UpdateParagraphSuccess()
{
_paragraphService.Setup(x => x.UpdateParagraph(1,
new ParagraphDto(1, "Le nouveau titre", "Le nouveau content", "Les infos", "La requête requêtante",
"Commentaires", 2)))
.Returns(new ParagraphDto(1, "Le nouveau titre", "Le nouveau content", "Les infos", "La requête requêtante",
"Commentaires", 2));
var paragraphsController =
new ParagraphsController(_paragraphService.Object, new NullLogger<ParagraphsController>());
var paragraphsResult = paragraphsController.UpdateParagraph(1,
new ParagraphDto(1, "Le nouveau titre", "Le nouveau content", "Les infos", "La requête requêtante",
"Commentaires", 2));
if (paragraphsResult is OkObjectResult okObjectResult)
{
ParagraphDto valeur = okObjectResult.Value as ParagraphDto;
Assert.NotNull(valeur);
Assert.Equal("Le nouveau titre", valeur.Title);
Assert.Equal("Le nouveau content", valeur.Content);
Assert.Equal("Les infos", valeur.Info);
Assert.Equal("La requête requêtante", valeur.Query);
Assert.Equal("Commentaires", valeur.Comment);
Assert.Equal(2, valeur.LessonId);
}
}
[Fact]
public void UpdateParagraphFail()
{
_paragraphService.Setup(x => x.UpdateParagraph(1,
new ParagraphDto(1, "Le nouveau titre", "Le nouveau content", "Les infos", "La requête requêtante",
"Commentaires", 2)))
.Returns(new ParagraphDto(1, "Le nouveau titre", "Le nouveau content", "Les infos", "La requête requêtante",
"Commentaires", 2));
var paragraphsController =
new ParagraphsController(_paragraphService.Object, new NullLogger<ParagraphsController>());
var paragraphsResult = paragraphsController.UpdateParagraph(1,
new ParagraphDto(2, "Le nouveau titre", "Le nouveau content", "Les infos", "La requête requêtante",
"Commentaires", 2));
if (paragraphsResult is BadRequestResult bdObjectResult)
{
Assert.Equal(400, bdObjectResult.StatusCode);
}
}
private List<ParagraphDto> GetParagraphsData()
{
List<ParagraphDto> paragraphsData = new List<ParagraphDto>(4)
{
new(0, "Titre 1", "Le contenu", "Les infos de ce paragraphes sont ", "Select * from C#", "Le commentaire",
1),
new(1, "Le titre", "pas contenu", "Pas d'infos ici", "Delete * from Earth", "Miam", 2),
new(2, "Ceci n'est pas un titre", "Certainement hmmm", "OUOOOOO ", "Autocommit = {true}", "First", 1),
new("Title", "Content", "Je ne parle pas anglais", "Select select from select",
"Mais qui est ce commentaire", 3),
};
return paragraphsData;
}
}

278
API_SQLuedo/TestAPI/SuccessesUnitTest.cs
Unescape View File

@ -0,0 +1,278 @@
using API.Controllers;
using Dto;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
using Shared;
using TestAPI.Extensions;
namespace TestAPI;
public class SuccessesUnitTest
{
private readonly Mock<ISuccessService<SuccessDto>> _successService;
public SuccessesUnitTest()
{
_successService = new Mock<ISuccessService<SuccessDto>>();
}
[Fact]
public void GetSuccessesListSuccess()
{
var successesList = GetSuccessesData();
_successService.Setup(x => x.GetSuccesses(1, 4, 0))
.Returns(successesList);
var successesController =
new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
var successesResult = successesController.GetSuccesses(1, 4, 0);
if (successesResult is OkObjectResult okObjectResult)
{
var valeur = okObjectResult.Value;
Assert.NotNull(valeur);
Assert.Equal(GetSuccessesData().ToString(), valeur.ToString());
Assert.True(successesList.SequenceEqual(valeur as IEnumerable<SuccessDto>,
new SuccessIdEqualityComparer()));
}
}
[Fact]
public void GetSuccessesListFail()
{
_successService.Setup(x => x.GetSuccesses(1, 4, 0))
.Returns(new List<SuccessDto>());
var successesController =
new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
var successesResult = successesController.GetSuccesses(2, 3, 0);
if (successesResult is StatusCodeResult statusCodeResult && statusCodeResult.StatusCode == 204)
{
Assert.IsNotType<OkObjectResult>(successesResult);
}
}
[Fact]
public void GetSuccessInquiryIdSuccess()
{
var successesList = GetSuccessesData();
_successService.Setup(x => x.GetSuccessesByInquiryId(1))
.Returns(new List<SuccessDto> { successesList[0], successesList[1] });
var successesController =
new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
var sucessesResult = successesController.GetSuccessByInquiryId(1);
if (sucessesResult is OkObjectResult okObjectResult)
{
List<SuccessDto> valeur = okObjectResult.Value as List<SuccessDto>;
Assert.NotNull(valeur);
Assert.Equal(0, valeur[0].UserId);
Assert.Equal(1, valeur[0].InquiryId);
Assert.True(valeur[0].IsFinished);
Assert.Equal(1, valeur[1].UserId);
Assert.Equal(1, valeur[1].InquiryId);
Assert.True(valeur[1].IsFinished);
Assert.Equal(valeur[1].GetHashCode(), successesList[1].GetHashCode());
Assert.True(valeur[1].Equals(successesList[1]));
Assert.False(valeur.Equals(new object()));
Assert.False(valeur.Equals(null));
Assert.True(valeur.Equals(valeur));
Assert.IsType<SuccessDto>(valeur[0]);
Assert.Contains(valeur[1], successesList);
}
}
[Fact]
public void GetSuccessInquiryIdFail()
{
var successesList = GetSuccessesData();
_successService.Setup(x => x.GetSuccessesByInquiryId(1))
.Returns(new List<SuccessDto> { successesList[0], successesList[1] });
var successesController =
new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
var sucessesResult = successesController.GetSuccessByInquiryId(100);
if (sucessesResult is NotFoundObjectResult nfObjectResult)
{
var valeur = nfObjectResult.Value;
Assert.NotNull(valeur);
Assert.IsNotType<SuccessDto>(valeur);
Assert.DoesNotContain(valeur, successesList);
}
}
[Fact]
public void GetSuccessUserIdSuccess()
{
var successesList = GetSuccessesData();
_successService.Setup(x => x.GetSuccessesByUserId(2))
.Returns(new List<SuccessDto> { successesList[2], successesList[3] });
var successesController =
new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
var sucessesResult = successesController.GetSuccessByUserId(2);
if (sucessesResult is OkObjectResult okObjectResult)
{
List<SuccessDto> valeur = okObjectResult.Value as List<SuccessDto>;
Assert.NotNull(valeur);
Assert.Equal(2, valeur[0].UserId);
Assert.Equal(3, valeur[0].InquiryId);
Assert.True(valeur[0].IsFinished);
Assert.Equal(2, valeur[1].UserId);
Assert.Equal(4, valeur[1].InquiryId);
Assert.True(valeur[1].IsFinished);
Assert.Equal(valeur[1].GetHashCode(), successesList[3].GetHashCode());
Assert.True(valeur[1].Equals(successesList[3]));
Assert.False(valeur.Equals(new object()));
Assert.IsType<SuccessDto>(valeur[0]);
Assert.Contains(valeur[1], successesList);
}
}
[Fact]
public void GetSuccessUserIdFail()
{
var successesList = GetSuccessesData();
_successService.Setup(x => x.GetSuccessesByUserId(2))
.Returns(new List<SuccessDto> { successesList[2], successesList[3] });
var successesController =
new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
var sucessesResult = successesController.GetSuccessByUserId(200);
if (sucessesResult is NotFoundObjectResult nfObjectResult)
{
var valeur = nfObjectResult.Value;
Assert.NotNull(valeur);
Assert.IsNotType<SuccessDto>(valeur);
Assert.DoesNotContain(valeur, successesList);
}
}
[Fact]
public void DeleteSuccessSuccess()
{
_successService.Setup(x => x.DeleteSuccess(1, 1))
.Returns(true);
var successesController =
new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
var sucessesResult = successesController.DeleteSuccess(1, 1);
if (sucessesResult is OkObjectResult okObjectResult)
{
bool valeur = (bool)okObjectResult.Value;
Assert.True(valeur);
}
}
[Fact]
public void DeleteSuccessFail()
{
_successService.Setup(x => x.DeleteSuccess(1, 1))
.Returns(true);
var successesController =
new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
var sucessesResult = successesController.DeleteSuccess(100, 278);
if (sucessesResult is NotFoundObjectResult nfObjectResult)
{
Assert.Null(nfObjectResult.Value);
Assert.IsNotType<bool>(nfObjectResult.Value);
}
}
[Fact]
public void CreateSuccessSuccess()
{
_successService.Setup(x => x.CreateSuccess(8, 8, true))
.Returns(new SuccessDto(8, 8, true));
var successesController =
new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
var successesResult = successesController.CreateSuccess(new SuccessDto(8, 8, true));
if (successesResult is CreatedResult createdObjectResult)
{
SuccessDto valeur = createdObjectResult.Value as SuccessDto;
Assert.NotNull(valeur);
Assert.Equal(8, valeur.UserId);
Assert.Equal(8, valeur.InquiryId);
Assert.True(valeur.IsFinished);
}
}
[Fact]
public void CreateSuccessFail()
{
_successService.Setup(x => x.CreateSuccess(8, 8, true))
.Returns(new SuccessDto(8, 8, true));
var successesController =
new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
var successesResult = successesController.CreateSuccess(new SuccessDto(882, 818, true));
if (successesResult is BadRequestResult bdObjectResult)
{
Assert.Equal(400, bdObjectResult.StatusCode);
}
}
[Fact]
public void UpdateSuccessSuccess()
{
_successService.Setup(x => x.UpdateSuccess(1, 1, new SuccessDto(1, 1, true)))
.Returns(new SuccessDto(1, 1, true));
var successesController =
new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
var successesResult = successesController.UpdateSuccess(1, 1, new SuccessDto(1, 1, true));
if (successesResult is OkObjectResult okObjectResult)
{
SuccessDto valeur = okObjectResult.Value as SuccessDto;
Assert.NotNull(valeur);
Assert.Equal(1, valeur.UserId);
Assert.Equal(1, valeur.InquiryId);
Assert.True(valeur.IsFinished);
}
}
[Fact]
public void UpdateSuccessFail()
{
_successService.Setup(x => x.UpdateSuccess(1, 1, new SuccessDto(1, 2, true)))
.Returns(new SuccessDto(1, 2, true));
var successesController =
new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
var successesResult = successesController.UpdateSuccess(1, 1, new SuccessDto(1, 2, true));
if (successesResult is BadRequestResult bdObjectResult)
{
Assert.Equal(400, bdObjectResult.StatusCode);
}
}
private List<SuccessDto> GetSuccessesData()
{
List<SuccessDto> successesData = new List<SuccessDto>(4)
{
new(0, 1, true),
new(1, 1, true),
new(2, 3, true),
new(2, 4, true),
};
return successesData;
}
}

5
API_SQLuedo/TestAPI/TestAPI.csproj
Unescape View File

@ -22,6 +22,7 @@
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference> </PackageReference>
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.9.0" /> <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.9.0" />
<PackageReference Include="Moq" Version="4.20.70" />
<PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="8.0.0" /> <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="8.0.0" />
<PackageReference Include="xunit" Version="2.7.0" /> <PackageReference Include="xunit" Version="2.7.0" />
<PackageReference Include="xunit.runner.visualstudio" Version="2.5.7"> <PackageReference Include="xunit.runner.visualstudio" Version="2.5.7">
@ -34,4 +35,8 @@
</PackageReference> </PackageReference>
</ItemGroup> </ItemGroup>
<ItemGroup>
<ProjectReference Include="..\API\API.csproj" />
</ItemGroup>
</Project> </Project>

11
API_SQLuedo/TestAPI/UnitTest1.cs
Unescape View File

@ -1,11 +0,0 @@
namespace TestAPI
{
public class UnitTest1
{
[Fact]
public void Test1()
{
}
}
}

281
API_SQLuedo/TestAPI/UserUnitTest.cs
Unescape View File

@ -0,0 +1,281 @@
using API.Controllers;
using Dto;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging.Abstractions;
using Moq;
using Shared;
using TestAPI.Extensions;
namespace TestAPI;
public class UserUnitTest
{
private readonly Mock<IUserService<UserDto>> _userService;
public UserUnitTest()
{
_userService = new Mock<IUserService<UserDto>>();
}
[Fact]
public void GetUserListSuccess()
{
var userList = GetUsersData();
_userService.Setup(x => x.GetUsers(1, 4, 0))
.Returns(userList);
var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
var userResult = usersController.GetUsers(1, 4, 0);
if (userResult is OkObjectResult okObjectResult)
{
var valeur = okObjectResult.Value;
Assert.NotNull(valeur);
Assert.Equal(GetUsersData().ToString(), valeur.ToString());
Assert.True(userList.SequenceEqual(valeur as IEnumerable<UserDto>, new UserIdEqualityComparer()));
}
}
[Fact]
public void GetUserListFail()
{
_userService.Setup(x => x.GetUsers(1, 4, 0))
.Returns(new List<UserDto>());
var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
var userResult = usersController.GetUsers(2, 3, 0);
if (userResult is StatusCodeResult statusCodeResult && statusCodeResult.StatusCode == 204)
{
Assert.IsNotType<OkObjectResult>(userResult);
}
}
[Fact]
public void GetUserIdSuccess()
{
var userList = GetUsersData();
_userService.Setup(x => x.GetUserById(1))
.Returns(userList[1]);
var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
var userResult = usersController.GetUserById(1);
if (userResult is OkObjectResult okObjectResult)
{
UserDto valeur = okObjectResult.Value as UserDto;
Assert.NotNull(valeur);
Assert.Equal("Leuser", valeur.Username);
Assert.Equal("motdepasse", valeur.Password);
Assert.Equal("deuxadresse@gmail.com", valeur.Email);
Assert.IsType<UserDto>(valeur);
Assert.Contains(valeur, userList);
}
}
[Fact]
public void GetUserIdFail()
{
var userList = GetUsersData();
_userService.Setup(x => x.GetUserById(1))
.Returns(userList[1]);
var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
var userResult = usersController.GetUserById(100);
if (userResult is NotFoundObjectResult nfObjectResult)
{
var valeur = nfObjectResult.Value;
Assert.NotNull(valeur);
Assert.IsNotType<UserDto>(valeur);
Assert.DoesNotContain(valeur, userList);
}
}
[Fact]
public void GetUserUsernameSuccess()
{
var userList = GetUsersData();
_userService.Setup(x => x.GetUserByUsername("Useruser"))
.Returns(userList[0]);
var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
var userResult = usersController.GetUserByUsername("Useruser");
if (userResult is OkObjectResult okObjectResult)
{
UserDto valeur = okObjectResult.Value as UserDto;
Assert.NotNull(valeur);
Assert.IsType<UserDto>(valeur);
Assert.Contains(valeur, userList);
Assert.Equal("adressemail@gmail.com", valeur.Email);
Assert.Equal("Useruser", valeur.Username);
Assert.Equal("motdepasse", valeur.Password);
Assert.True(valeur.IsAdmin);
}
}
[Fact]
public void GetUserUsernameFail()
{
var userList = GetUsersData();
_userService.Setup(x => x.GetUserByUsername("Useruser"))
.Returns(userList[0]);
var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
var userResult = usersController.GetUserByUsername("GYIIieihhh");
if (userResult is NotFoundObjectResult nfObjectResult)
{
var valeur = nfObjectResult.Value;
Assert.NotNull(valeur);
Assert.IsNotType<UserDto>(valeur);
Assert.DoesNotContain(valeur, userList);
Assert.False(userList == valeur);
}
}
[Fact]
public void DeleteUserSuccess()
{
_userService.Setup(x => x.DeleteUser(1))
.Returns(true);
var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
var userResult = usersController.DeleteUser(1);
if (userResult is OkObjectResult okObjectResult)
{
bool valeur = (bool)okObjectResult.Value;
Assert.True(valeur);
}
}
[Fact]
public void DeleteUserFail()
{
_userService.Setup(x => x.DeleteUser(1))
.Returns(true);
var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
var userResult = usersController.DeleteUser(100);
if (userResult is NotFoundObjectResult nfObjectResult)
{
Assert.Null(nfObjectResult.Value);
Assert.IsNotType<bool>(nfObjectResult.Value);
}
}
[Fact]
public void CreateUserSuccess()
{
_userService.Setup(x => x.CreateUser("Nom", "Passssss", "heudfk@hdye.com", true))
.Returns(new UserDto("Nom", "Passssss", "heudfk@hdye.com", true));
var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
var userResult = usersController.CreateUser(new UserDto("Nom", "Passssss", "heudfk@hdye.com", true));
if (userResult is CreatedResult createdObjectResult)
{
UserDto valeur = createdObjectResult.Value as UserDto;
Assert.NotNull(valeur);
Assert.Equal("Nom", valeur.Username);
Assert.Equal("Passssss", valeur.Password);
Assert.Equal("heudfk@hdye.com", valeur.Email);
Assert.True(valeur.IsAdmin);
}
}
[Fact]
public void CreateUserFail()
{
GetUsersData();
_userService.Setup(x => x.CreateUser("Nom", "Passssss", "heudfk@hdye.com", true))
.Returns(new UserDto("Nom", "Passssss", "heudfk@hdye.com", true));
var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
var userResult = usersController.CreateUser(new UserDto(null, "Passssss", "heudfk@hdye.com", true));
if (userResult is BadRequestResult bdObjectResult)
{
Assert.Equal(400, bdObjectResult.StatusCode);
}
}
[Fact]
public void UpdateUserSuccess()
{
_userService.Setup(x => x.UpdateUser(1, new UserDto("Nom", "Passssss", "heudfk@hdye.com", true)))
.Returns(new UserDto("Nom", "Passssss", "heudfk@hdye.com", true));
var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
var userResult = usersController.UpdateUser(1, new UserDto("Nom", "Passssss", "heudfk@hdye.com", true));
if (userResult is OkObjectResult okObjectResult)
{
UserDto valeur = okObjectResult.Value as UserDto;
Assert.NotNull(valeur);
Assert.Equal("Nom", valeur.Username);
Assert.Equal("Passssss", valeur.Password);
Assert.Equal("heudfk@hdye.com", valeur.Email);
Assert.True(valeur.IsAdmin);
}
}
[Fact]
public void UpdateUserFail()
{
_userService.Setup(x => x.UpdateUser(1, new UserDto(1, "Nom", "Passssss", "heudfk@hdye.com", true)))
.Returns(new UserDto("Nom", "Passssss", "heudfk@hdye.com", true));
var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
var userResult = usersController.UpdateUser(1, new UserDto(2, "Nom", "Passssss", "heudfk@hdye.com", true));
if (userResult is BadRequestResult bdObjectResult)
{
Assert.Equal(400, bdObjectResult.StatusCode);
}
}
private List<UserDto> GetUsersData()
{
List<UserDto> usersData = new List<UserDto>(4)
{
new(
0,
"Useruser",
"motdepasse",
"adressemail@gmail.com",
true
),
new
(
1,
"Leuser",
"motdepasse",
"deuxadresse@gmail.com",
false
),
new
(
2,
"gygyggyg",
"ennodlavehc",
"thirdadress@gmail.com",
false
),
new
(
"ferferf",
"h_nh_78",
"fourthadress@gmail.com",
false
),
};
return usersData;
}
}

125
API_SQLuedo/TestConsoleAPI/Program.cs
Unescape View File

@ -1,20 +1,25 @@
// 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();
var options = new DbContextOptionsBuilder<UserDbContext>() var options = new DbContextOptionsBuilder<UserDbContext>()
.UseSqlite(connection) .UseSqlite(connection)
.Options; .Options;
using ILoggerFactory factory = new LoggerFactory(); using ILoggerFactory factory = new LoggerFactory();
ILogger<UsersController> userLogger = factory.CreateLogger<UsersController>(); ILogger<UsersController> userLogger = factory.CreateLogger<UsersController>();
ILogger<InquiriesController> inquiryLogger = factory.CreateLogger<InquiriesController>(); ILogger<InquiriesController> inquiryLogger = factory.CreateLogger<InquiriesController>();
@ -25,17 +30,22 @@ 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()
{ {
Console.WriteLine(); Console.WriteLine();
var users = userController.GetUsers(1, 10, UserOrderCriteria.None) as OkObjectResult; var users = userController.GetUsers(1, 10, UserOrderCriteria.None) as OkObjectResult;
foreach (var item in users.Value as IEnumerable<UserDTO>) foreach (var item in users.Value as IEnumerable<UserDto>)
{ {
Console.WriteLine(item); Console.WriteLine(item);
} }
@ -45,7 +55,7 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine(); Console.WriteLine();
var inquiries = inquiryController.GetInquiries(1, 10, InquiryOrderCriteria.None) as OkObjectResult; var inquiries = inquiryController.GetInquiries(1, 10, InquiryOrderCriteria.None) as OkObjectResult;
foreach (var item in inquiries.Value as IEnumerable<InquiryDTO>) foreach (var item in inquiries.Value as IEnumerable<InquiryDto>)
{ {
Console.WriteLine(item); Console.WriteLine(item);
} }
@ -55,7 +65,7 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine(); Console.WriteLine();
var paragraphs = paragraphController.GetParagraphs(1, 10, ParagraphOrderCriteria.None) as OkObjectResult; var paragraphs = paragraphController.GetParagraphs(1, 10, ParagraphOrderCriteria.None) as OkObjectResult;
foreach (var item in paragraphs.Value as IEnumerable<ParagraphDTO>) foreach (var item in paragraphs.Value as IEnumerable<ParagraphDto>)
{ {
Console.WriteLine(item); Console.WriteLine(item);
} }
@ -65,7 +75,7 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine(); Console.WriteLine();
var lessons = lessonController.GetLessons(1, 10, LessonOrderCriteria.None) as OkObjectResult; var lessons = lessonController.GetLessons(1, 10, LessonOrderCriteria.None) as OkObjectResult;
foreach (var item in lessons.Value as IEnumerable<LessonDTO>) foreach (var item in lessons.Value as IEnumerable<LessonDto>)
{ {
Console.WriteLine(item); Console.WriteLine(item);
} }
@ -75,7 +85,7 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine(); Console.WriteLine();
var successes = successController.GetSuccesses(1, 10, SuccessOrderCriteria.None) as OkObjectResult; var successes = successController.GetSuccesses(1, 10, SuccessOrderCriteria.None) as OkObjectResult;
foreach (var item in successes.Value as IEnumerable<SuccessDTO>) foreach (var item in successes.Value as IEnumerable<SuccessDto>)
{ {
Console.WriteLine(item); Console.WriteLine(item);
} }
@ -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,7 +115,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(inquiry.Value as InquiryDTO);
Console.WriteLine(inquiry.Value as InquiryDto);
} }
void SearchParagraphByTitle() void SearchParagraphByTitle()
@ -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,7 +185,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(inquiry.Value as InquiryDTO);
Console.WriteLine(inquiry.Value as InquiryDto);
} }
void SearchParagraphById() void SearchParagraphById()
@ -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()
@ -227,7 +239,7 @@ using (var context = new UserDbContext(options))
var email = Console.ReadLine(); var email = Console.ReadLine();
Console.WriteLine("Veuillez saisir un mot de passe :"); Console.WriteLine("Veuillez saisir un mot de passe :");
var mdp = Console.ReadLine(); var mdp = Console.ReadLine();
var res = userController.CreateUser(new UserDTO(username, mdp, email, false)); var res = userController.CreateUser(new UserDto(username, mdp, email, false));
if (res.GetType() == typeof(CreatedResult)) if (res.GetType() == typeof(CreatedResult))
{ {
Console.WriteLine("\nUtilisateur créé avec succès"); Console.WriteLine("\nUtilisateur créé avec succès");
@ -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()
@ -251,7 +262,7 @@ using (var context = new UserDbContext(options))
var database = Convert.ToInt32(Console.ReadLine()); var database = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Veuillez saisir l'id de la solution :"); Console.WriteLine("Veuillez saisir l'id de la solution :");
var solution = Convert.ToInt32(Console.ReadLine()); var solution = Convert.ToInt32(Console.ReadLine());
var res = inquiryController.CreateInquiry(new InquiryDTO(title, description, false)); var res = inquiryController.CreateInquiry(new InquiryDto(title, description, false));
if (res.GetType() == typeof(CreatedResult)) if (res.GetType() == typeof(CreatedResult))
{ {
Console.WriteLine("\nEnquête créée avec succès"); Console.WriteLine("\nEnquête créée avec succès");
@ -276,7 +287,7 @@ 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 res = paragraphController.CreateParagraph(new ParagraphDTO(title, content, info, query, comment, lesson)); var res = paragraphController.CreateParagraph(new ParagraphDto(title, content, info, query, comment, lesson));
if (res.GetType() == typeof(CreatedResult)) if (res.GetType() == typeof(CreatedResult))
{ {
Console.WriteLine("\nParagraphe créé avec succès"); Console.WriteLine("\nParagraphe créé avec succès");
@ -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()
@ -333,7 +343,7 @@ using (var context = new UserDbContext(options))
var res = (userController.GetUserById(id)); var res = (userController.GetUserById(id));
if (res.GetType() == typeof(OkObjectResult)) if (res.GetType() == typeof(OkObjectResult))
{ {
var user = (res as OkObjectResult).Value as UserDTO; var user = (res as OkObjectResult).Value as UserDto;
if (user == null) if (user == null)
{ {
Console.WriteLine("Erreur, un problème est survenu"); Console.WriteLine("Erreur, un problème est survenu");
@ -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()
@ -371,7 +381,7 @@ using (var context = new UserDbContext(options))
var res = (inquiryController.GetInquiryById(id)); var res = (inquiryController.GetInquiryById(id));
if (res.GetType() == typeof(OkObjectResult)) if (res.GetType() == typeof(OkObjectResult))
{ {
var user = (res as OkObjectResult).Value as InquiryDTO; var user = (res as OkObjectResult).Value as InquiryDto;
if (user == null) if (user == null)
{ {
Console.WriteLine("Erreur, un problème est survenu"); Console.WriteLine("Erreur, un problème est survenu");
@ -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()
@ -415,7 +425,7 @@ using (var context = new UserDbContext(options))
var res = (paragraphController.GetParagraphById(id)); var res = (paragraphController.GetParagraphById(id));
if (res.GetType() == typeof(OkObjectResult)) if (res.GetType() == typeof(OkObjectResult))
{ {
var paragraph = (res as OkObjectResult).Value as ParagraphDTO; var paragraph = (res as OkObjectResult).Value as ParagraphDto;
if (paragraph == null) if (paragraph == null)
{ {
Console.WriteLine("Erreur, un problème est survenu"); Console.WriteLine("Erreur, un problème est survenu");
@ -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()
@ -461,7 +471,7 @@ using (var context = new UserDbContext(options))
var res = (lessonController.GetLessonById(id)); var res = (lessonController.GetLessonById(id));
if (res.GetType() == typeof(OkObjectResult)) if (res.GetType() == typeof(OkObjectResult))
{ {
var lesson = (res as OkObjectResult).Value as LessonDTO; var lesson = (res as OkObjectResult).Value as LessonDto;
if (lesson == null) if (lesson == null)
{ {
Console.WriteLine("Erreur, un problème est survenu"); Console.WriteLine("Erreur, un problème est survenu");
@ -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()
@ -499,7 +509,7 @@ using (var context = new UserDbContext(options))
var res = (successController.GetSuccessByUserId(id)); var res = (successController.GetSuccessByUserId(id));
if (res.GetType() == typeof(OkObjectResult)) if (res.GetType() == typeof(OkObjectResult))
{ {
var lesson = (res as OkObjectResult).Value as SuccessDTO; var lesson = (res as OkObjectResult).Value as SuccessDto;
if (lesson == null) if (lesson == null)
{ {
Console.WriteLine("Erreur, un problème est survenu"); Console.WriteLine("Erreur, un problème est survenu");
@ -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();
@ -771,7 +780,7 @@ using (var context = new UserDbContext(options))
} }
else else
{ {
var users = res as IEnumerable<UserDTO>; var users = res as IEnumerable<UserDto>;
if (users == null) if (users == null)
{ {
Console.WriteLine("\nErreur, les ustilisateurs n'ont pas été trouvés !"); Console.WriteLine("\nErreur, les ustilisateurs n'ont pas été trouvés !");
@ -827,7 +836,7 @@ using (var context = new UserDbContext(options))
// Ajout d'un utilisateur // Ajout d'un utilisateur
Console.WriteLine("\n##########################################################\n"); Console.WriteLine("\n##########################################################\n");
Console.WriteLine("Création de l'utilisateur :\n"); Console.WriteLine("Création de l'utilisateur :\n");
var user2 = new UserDTO("JohnDoe", "motdepasse", "johndoe@gmail.com", false); var user2 = new UserDto("JohnDoe", "motdepasse", "johndoe@gmail.com", false);
Console.WriteLine(user2); Console.WriteLine(user2);
var res3 = userController.CreateUser(user2); var res3 = userController.CreateUser(user2);
if (res3 == null) if (res3 == null)
@ -854,7 +863,7 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine(user2); Console.WriteLine(user2);
Console.WriteLine("\nNouvelle adresse : John.DOE@etu.uca.fr"); Console.WriteLine("\nNouvelle adresse : John.DOE@etu.uca.fr");
var user3 = new UserDTO(user2.Id, user2.Username, user2.Password, "John.DOE@etu.uca.fr", user2.IsAdmin); var user3 = new UserDto(user2.Id, user2.Username, user2.Password, "John.DOE@etu.uca.fr", user2.IsAdmin);
var res4 = userController.UpdateUser(1, user3); var res4 = userController.UpdateUser(1, user3);
if (res4 == null) if (res4 == null)
{ {

8
API_SQLuedo/TestEF/Dto/TestInquiryDTO.cs
Unescape View File

@ -2,7 +2,7 @@ using Dto;
namespace TestEF.Dto; namespace TestEF.Dto;
public class TestInquiryDTO public class TestInquiryDto
{ {
private const int _id = 1; private const int _id = 1;
private const string _title = "Title"; private const string _title = "Title";
@ -12,7 +12,7 @@ public class TestInquiryDTO
[Fact] [Fact]
public void TestConstructorWithId() public void TestConstructorWithId()
{ {
InquiryDTO inquiry = new InquiryDTO(_id, _title, _description, _isUser); InquiryDto inquiry = new InquiryDto(_id, _title, _description, _isUser);
Assert.Equal(_id, inquiry.Id); Assert.Equal(_id, inquiry.Id);
Assert.Equal(_title, inquiry.Title); Assert.Equal(_title, inquiry.Title);
Assert.Equal(_description, inquiry.Description); Assert.Equal(_description, inquiry.Description);
@ -22,7 +22,7 @@ public class TestInquiryDTO
[Fact] [Fact]
public void TestConstructorWithoutId() public void TestConstructorWithoutId()
{ {
InquiryDTO inquiry = new InquiryDTO(_title,_description,_isUser); InquiryDto inquiry = new InquiryDto(_title,_description,_isUser);
Assert.Equal(0, inquiry.Id); Assert.Equal(0, inquiry.Id);
Assert.Equal(_title,inquiry.Title); Assert.Equal(_title,inquiry.Title);
Assert.Equal(_description,inquiry.Description); Assert.Equal(_description,inquiry.Description);
@ -32,7 +32,7 @@ public class TestInquiryDTO
[Fact] [Fact]
public void TestConstructorWithAllAttributes() public void TestConstructorWithAllAttributes()
{ {
InquiryDTO inquiry = new InquiryDTO(_id,_title,_description,_isUser); InquiryDto inquiry = new InquiryDto(_id,_title,_description,_isUser);
Assert.Equal(_id, inquiry.Id); Assert.Equal(_id, inquiry.Id);
Assert.Equal(_title,inquiry.Title); Assert.Equal(_title,inquiry.Title);
Assert.Equal(_description,inquiry.Description); Assert.Equal(_description,inquiry.Description);

18
API_SQLuedo/TestEF/Dto/TestInquiryTableDTO.cs
Unescape View File

@ -2,25 +2,25 @@ using Dto;
namespace TestEF.Dto; namespace TestEF.Dto;
public class TestInquiryTableDTO public class TestInquiryTableDto
{ {
private const int _id = 1; private const int Id = 1;
private const string _database = "database"; private const string Database = "database";
private const string _connection = "_connection"; private const string Connection = "_connection";
[Fact] [Fact]
public void TestConstructorWithId() public void TestConstructorWithId()
{ {
InquiryTableDTO inquiry = new InquiryTableDTO(_id, _database, _connection); InquiryTableDto inquiry = new InquiryTableDto(Id, Database, Connection);
Assert.Equal(_id, inquiry.OwnerId); Assert.Equal(Id, inquiry.OwnerId);
Assert.Equal(_database, inquiry.DatabaseName); Assert.Equal(Database, inquiry.DatabaseName);
Assert.Equal(_connection, inquiry.ConnectionInfo); Assert.Equal(Connection, inquiry.ConnectionInfo);
} }
[Fact] [Fact]
public void TestDefaultConstructor() public void TestDefaultConstructor()
{ {
InquiryTableDTO inquiry = new InquiryTableDTO(); InquiryTableDto inquiry = new InquiryTableDto();
Assert.Equal(0, inquiry.OwnerId); Assert.Equal(0, inquiry.OwnerId);
Assert.Null(inquiry.DatabaseName); Assert.Null(inquiry.DatabaseName);
Assert.Null(inquiry.ConnectionInfo); Assert.Null(inquiry.ConnectionInfo);

33
API_SQLuedo/TestEF/Dto/TestLessonDTO.cs
Unescape View File

@ -2,40 +2,41 @@ using Dto;
namespace TestEF.Dto; namespace TestEF.Dto;
public class TestLessonDTO public class TestLessonDto
{ {
private const int _id = 42; private const int Id = 42;
private const string _title = "Title"; private const string Title = "Title";
private const string _lastPublisher = "Last Publisher"; private const string LastPublisher = "Last Publisher";
private static DateOnly _lastEdit = new DateOnly(); private static readonly DateOnly LastEdit = new();
[Fact] [Fact]
public void TestDefaultConstructor() public void TestDefaultConstructor()
{ {
LessonDTO lesson = new LessonDTO(); LessonDto lesson = new LessonDto();
Assert.Equal(0, lesson.Id); Assert.Equal(0, lesson.Id);
Assert.Null(lesson.Title); Assert.Null(lesson.Title);
Assert.Null(lesson.LastPublisher); Assert.Null(lesson.LastPublisher);
Assert.Null(lesson.LastEdit); // Default date
Assert.Equal(new DateOnly(0001, 01, 01), LastEdit);
} }
[Fact] [Fact]
public void TestConstructorWithoutId() public void TestConstructorWithoutId()
{ {
LessonDTO lesson = new LessonDTO(_title,_lastPublisher,_lastEdit); LessonDto lesson = new LessonDto(Title, LastPublisher, LastEdit);
Assert.Equal(0, lesson.Id); Assert.Equal(0, lesson.Id);
Assert.Equal(_title,lesson.Title); Assert.Equal(Title, lesson.Title);
Assert.Equal(_lastPublisher,lesson.LastPublisher); Assert.Equal(LastPublisher, lesson.LastPublisher);
Assert.Equal(_lastEdit,lesson.LastEdit); Assert.Equal(LastEdit, lesson.LastEdit);
} }
[Fact] [Fact]
public void TestConstructorWithAllAttributes() public void TestConstructorWithAllAttributes()
{ {
LessonDTO lesson = new LessonDTO(_id,_title,_lastPublisher,_lastEdit); LessonDto lesson = new LessonDto(Id, Title, LastPublisher, LastEdit);
Assert.Equal(_id, lesson.Id); Assert.Equal(Id, lesson.Id);
Assert.Equal(_title,lesson.Title); Assert.Equal(Title, lesson.Title);
Assert.Equal(_lastPublisher,lesson.LastPublisher); Assert.Equal(LastPublisher, lesson.LastPublisher);
Assert.Equal(_lastEdit,lesson.LastEdit); Assert.Equal(LastEdit, lesson.LastEdit);
} }
} }

30
API_SQLuedo/TestEF/Dto/TestNotepadDTO.cs
Unescape View File

@ -2,17 +2,17 @@ using Dto;
namespace TestEF.Dto; namespace TestEF.Dto;
public class TestNotepadDTO public class TestNotepadDto
{ {
private const int _id = 42; private const int Id = 42;
private const int _userId = 42; private const int UserId = 42;
private const int _inquiryId = 42; private const int InquiryId = 42;
private const string _notes = "This is some notes example"; private const string Notes = "This is some notes example";
[Fact] [Fact]
public void TestDefaultConstructor() public void TestDefaultConstructor()
{ {
NotepadDTO notepad = new NotepadDTO(); NotepadDto notepad = new NotepadDto();
Assert.Equal(0,notepad.Id); Assert.Equal(0,notepad.Id);
Assert.Equal(0,notepad.UserId); Assert.Equal(0,notepad.UserId);
Assert.Equal(0,notepad.InquiryId); Assert.Equal(0,notepad.InquiryId);
@ -22,20 +22,20 @@ public class TestNotepadDTO
[Fact] [Fact]
public void TestConstructorWithoutId() public void TestConstructorWithoutId()
{ {
NotepadDTO notepad = new NotepadDTO(_userId,_inquiryId,_notes); NotepadDto notepad = new NotepadDto(UserId,InquiryId,Notes);
Assert.Equal(0,notepad.Id); Assert.Equal(0,notepad.Id);
Assert.Equal(_userId,notepad.UserId); Assert.Equal(UserId,notepad.UserId);
Assert.Equal(_inquiryId,notepad.InquiryId); Assert.Equal(InquiryId,notepad.InquiryId);
Assert.Equal(_notes,notepad.Notes); Assert.Equal(Notes,notepad.Notes);
} }
[Fact] [Fact]
public void TestConstructorWithAllAttributes() public void TestConstructorWithAllAttributes()
{ {
NotepadDTO notepad = new NotepadDTO(_id,_userId,_inquiryId,_notes); NotepadDto notepad = new NotepadDto(Id,UserId,InquiryId,Notes);
Assert.Equal(_id,notepad.Id); Assert.Equal(Id,notepad.Id);
Assert.Equal(_userId,notepad.UserId); Assert.Equal(UserId,notepad.UserId);
Assert.Equal(_inquiryId,notepad.InquiryId); Assert.Equal(InquiryId,notepad.InquiryId);
Assert.Equal(_notes,notepad.Notes); Assert.Equal(Notes,notepad.Notes);
} }
} }

42
API_SQLuedo/TestEF/Dto/TestParagraphDTO.cs
Unescape View File

@ -2,19 +2,19 @@ using Dto;
namespace TestEF.Dto; namespace TestEF.Dto;
public class TestParagraphDTO public class TestParagraphDto
{ {
private const int _id = 42; private const int Id = 42;
private const string _title = "Title"; private const string Title = "Title";
private const string _info = "Info"; private const string Info = "Info";
private const string _content = "Content"; private const string Content = "Content";
private const string _query = "Query"; private const string Query = "Query";
private const string _comment = "Comment"; private const string Comment = "Comment";
[Fact] [Fact]
public void TestDefaultConstructor() public void TestDefaultConstructor()
{ {
ParagraphDTO paragraph = new ParagraphDTO(); ParagraphDto paragraph = new ParagraphDto();
Assert.Equal(0, paragraph.Id); Assert.Equal(0, paragraph.Id);
Assert.Null(paragraph.Title); Assert.Null(paragraph.Title);
Assert.Null(paragraph.Info); Assert.Null(paragraph.Info);
@ -26,25 +26,25 @@ public class TestParagraphDTO
[Fact] [Fact]
public void TestConstructorWithoutId() public void TestConstructorWithoutId()
{ {
ParagraphDTO paragraph = new ParagraphDTO(_title,_content,_info,_query,_comment, 10); ParagraphDto paragraph = new ParagraphDto(Title,Content,Info,Query,Comment, 10);
Assert.Equal(0, paragraph.Id); Assert.Equal(0, paragraph.Id);
Assert.Equal(_title,paragraph.Title); Assert.Equal(Title,paragraph.Title);
Assert.Equal(_info,paragraph.Info); Assert.Equal(Info,paragraph.Info);
Assert.Equal(_content,paragraph.Content); Assert.Equal(Content,paragraph.Content);
Assert.Equal(_query,paragraph.Query); Assert.Equal(Query,paragraph.Query);
Assert.Equal(_comment,paragraph.Comment); Assert.Equal(Comment,paragraph.Comment);
} }
[Fact] [Fact]
public void TestConstructorWithAllAttributes() public void TestConstructorWithAllAttributes()
{ {
ParagraphDTO paragraph = new ParagraphDTO(_id,_title,_content,_info,_query,_comment,10); ParagraphDto paragraph = new ParagraphDto(Id,Title,Content,Info,Query,Comment,10);
Assert.Equal(_id, paragraph.Id); Assert.Equal(Id, paragraph.Id);
Assert.Equal(_title,paragraph.Title); Assert.Equal(Title,paragraph.Title);
Assert.Equal(_info,paragraph.Info); Assert.Equal(Info,paragraph.Info);
Assert.Equal(_content,paragraph.Content); Assert.Equal(Content,paragraph.Content);
Assert.Equal(_query,paragraph.Query); Assert.Equal(Query,paragraph.Query);
Assert.Equal(_comment,paragraph.Comment); Assert.Equal(Comment,paragraph.Comment);
Assert.Equal(10, paragraph.LessonId); Assert.Equal(10, paragraph.LessonId);
} }
} }

42
API_SQLuedo/TestEF/Dto/TestSolutionDTO.cs
Unescape View File

@ -2,19 +2,19 @@ using Dto;
namespace TestEF.Dto; namespace TestEF.Dto;
public class TestSolutionDTO public class TestSolutionDto
{ {
private const string _murdererFirstName = "John"; private const string MurdererFirstName = "John";
private const string _murdererLastName = "Doe"; private const string MurdererLastName = "Doe";
private const string _murderPlace = "WhiteHouse"; private const string MurderPlace = "WhiteHouse";
private const string _murderWeapon = "Nuclear Bomb"; private const string MurderWeapon = "Nuclear Bomb";
private const string _explaination = "This is an explaination"; private const string Explaination = "This is an explaination";
private const int _inquiryId = 42; private const int InquiryId = 42;
[Fact] [Fact]
public void TestDefaultConstructor() public void TestDefaultConstructor()
{ {
SolutionDTO solution = new SolutionDTO(); SolutionDto solution = new SolutionDto();
Assert.Equal(0,solution.OwnerId); Assert.Equal(0,solution.OwnerId);
Assert.Null(solution.MurdererFirstName); Assert.Null(solution.MurdererFirstName);
Assert.Null(solution.MurdererLastName); Assert.Null(solution.MurdererLastName);
@ -25,24 +25,24 @@ public class TestSolutionDTO
[Fact] [Fact]
public void TestConstructorWithoutOwnerId() public void TestConstructorWithoutOwnerId()
{ {
SolutionDTO solution = new SolutionDTO(_murdererFirstName,_murdererLastName,_murderPlace,_murderWeapon, _explaination); SolutionDto solution = new SolutionDto(MurdererFirstName,MurdererLastName,MurderPlace,MurderWeapon, Explaination);
Assert.Equal(0,solution.OwnerId); Assert.Equal(0,solution.OwnerId);
Assert.Equal(_murdererFirstName,solution.MurdererFirstName); Assert.Equal(MurdererFirstName,solution.MurdererFirstName);
Assert.Equal(_murdererLastName,solution.MurdererLastName); Assert.Equal(MurdererLastName,solution.MurdererLastName);
Assert.Equal(_murderPlace,solution.MurderPlace); Assert.Equal(MurderPlace,solution.MurderPlace);
Assert.Equal(_murderWeapon,solution.MurderWeapon); Assert.Equal(MurderWeapon,solution.MurderWeapon);
Assert.Equal(_explaination, solution.Explanation); Assert.Equal(Explaination, solution.Explanation);
} }
[Fact] [Fact]
public void TestConstructorWithAllAttributes() public void TestConstructorWithAllAttributes()
{ {
SolutionDTO solution = new SolutionDTO(_inquiryId,_murdererFirstName,_murdererLastName,_murderPlace,_murderWeapon, _explaination); SolutionDto solution = new SolutionDto(InquiryId,MurdererFirstName,MurdererLastName,MurderPlace,MurderWeapon, Explaination);
Assert.Equal(_inquiryId,solution.OwnerId); Assert.Equal(InquiryId,solution.OwnerId);
Assert.Equal(_murdererFirstName,solution.MurdererFirstName); Assert.Equal(MurdererFirstName,solution.MurdererFirstName);
Assert.Equal(_murdererLastName,solution.MurdererLastName); Assert.Equal(MurdererLastName,solution.MurdererLastName);
Assert.Equal(_murderPlace,solution.MurderPlace); Assert.Equal(MurderPlace,solution.MurderPlace);
Assert.Equal(_murderWeapon,solution.MurderWeapon); Assert.Equal(MurderWeapon,solution.MurderWeapon);
Assert.Equal(_explaination, solution.Explanation); Assert.Equal(Explaination, solution.Explanation);
} }
} }

16
API_SQLuedo/TestEF/Dto/TestSuccessDTO.cs
Unescape View File

@ -2,16 +2,16 @@ using Dto;
namespace TestEF.Dto; namespace TestEF.Dto;
public class TestSuccessDTO public class TestSuccessDto
{ {
private const int _userId = 42; private const int UserId = 42;
private const int _inquiryId = 7; private const int InquiryId = 7;
private const bool _isFinished = true; private const bool IsFinished = true;
[Fact] [Fact]
public void TestDefaultConstructor() public void TestDefaultConstructor()
{ {
SuccessDTO success = new SuccessDTO(); SuccessDto success = new SuccessDto();
Assert.Equal(0, success.UserId); Assert.Equal(0, success.UserId);
Assert.Equal(0, success.InquiryId); Assert.Equal(0, success.InquiryId);
Assert.False(success.IsFinished); Assert.False(success.IsFinished);
@ -20,9 +20,9 @@ public class TestSuccessDTO
[Fact] [Fact]
public void TestConstructorWithIds() public void TestConstructorWithIds()
{ {
SuccessDTO success = new SuccessDTO(_userId, _inquiryId, _isFinished); SuccessDto success = new SuccessDto(UserId, InquiryId, IsFinished);
Assert.Equal(_userId, success.UserId); Assert.Equal(UserId, success.UserId);
Assert.Equal(_inquiryId, success.InquiryId); Assert.Equal(InquiryId, success.InquiryId);
Assert.True(success.IsFinished); Assert.True(success.IsFinished);
} }
} }

32
API_SQLuedo/TestEF/Dto/TestUserDTO.cs
Unescape View File

@ -2,18 +2,18 @@ using Dto;
namespace TestEF.Dto namespace TestEF.Dto
{ {
public class TestUserDTO public class TestUserDto
{ {
private const string _username = "username"; private const string Username = "username";
private const string _email = "example@email.com"; private const string Email = "example@email.com";
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()
{ {
UserDTO user = new UserDTO(); UserDto user = new UserDto();
Assert.Equal(0,user.Id); Assert.Equal(0,user.Id);
Assert.Null(user.Username); Assert.Null(user.Username);
Assert.Null(user.Email); Assert.Null(user.Email);
@ -24,22 +24,22 @@ namespace TestEF.Dto
[Fact] [Fact]
public void TestConstructorWithoutId() public void TestConstructorWithoutId()
{ {
UserDTO user = new UserDTO(_username, _password, _email, _isAdmin); UserDto user = new UserDto(Username, Password, Email, IsAdmin);
Assert.Equal(0,user.Id); Assert.Equal(0,user.Id);
Assert.Equal(_username, user.Username); Assert.Equal(Username, user.Username);
Assert.Equal(_email, user.Email); Assert.Equal(Email, user.Email);
Assert.Equal(_password, user.Password); Assert.Equal(Password, user.Password);
Assert.True(user.IsAdmin); Assert.True(user.IsAdmin);
} }
[Fact] [Fact]
public void TestConstructorWithoutAllAttributes() public void TestConstructorWithoutAllAttributes()
{ {
UserDTO user = new UserDTO(_id, _username, _password, _email, _isAdmin); UserDto user = new UserDto(Id, Username, Password, Email, IsAdmin);
Assert.Equal(_id,user.Id); Assert.Equal(Id,user.Id);
Assert.Equal(_username, user.Username); Assert.Equal(Username, user.Username);
Assert.Equal(_email, user.Email); Assert.Equal(Email, user.Email);
Assert.Equal(_password, user.Password); Assert.Equal(Password, user.Password);
Assert.True(user.IsAdmin); Assert.True(user.IsAdmin);
} }
} }

2
API_SQLuedo/TestEF/EntitiesTests/TestInquiryTableEntity.cs
Unescape View File

@ -5,7 +5,7 @@ namespace TestEF.EntitiesTests;
public class TestInquiryTableEntity public class TestInquiryTableEntity
{ {
private const int InquiryId = 42; private const int InquiryId = 42;
private static readonly InquiryEntity Inquiry = new (); private static readonly InquiryEntity Inquiry = new();
private const string DatabaseName = "Database"; private const string DatabaseName = "Database";
private const string ConnectionInfo = "Connection"; private const string ConnectionInfo = "Connection";

4
API_SQLuedo/TestEF/EntitiesTests/TestLessonEntity.cs
Unescape View File

@ -7,7 +7,7 @@ public class TestLessonEntity
private const int Id = 42; private const int Id = 42;
private const string Title = "Title"; private const string Title = "Title";
private const string LastPublisher = "Last Publisher"; private const string LastPublisher = "Last Publisher";
private static readonly DateOnly LastEdit = new (); private static readonly DateOnly LastEdit = new();
[Fact] [Fact]
public void TestDefaultConstructor() public void TestDefaultConstructor()
@ -16,7 +16,7 @@ public class TestLessonEntity
Assert.Equal(0, lesson.Id); Assert.Equal(0, lesson.Id);
Assert.Null(lesson.Title); Assert.Null(lesson.Title);
Assert.Null(lesson.LastPublisher); Assert.Null(lesson.LastPublisher);
Assert.Null(lesson.LastEdit); Assert.Equal(new DateOnly(0001, 01, 01), LastEdit);
} }
[Fact] [Fact]

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

@ -24,7 +24,7 @@ public class TestUserEntity
[Fact] [Fact]
public void TestConstructorWithOnlyId() public void TestConstructorWithOnlyId()
{ {
UserEntity user = new UserEntity{ Id = Id}; UserEntity user = new UserEntity { Id = Id };
Assert.Equal(Id, user.Id); Assert.Equal(Id, user.Id);
Assert.Null(user.Username); Assert.Null(user.Username);
Assert.Null(user.Email); Assert.Null(user.Email);

Write Preview
Loading…
Cancel
Save