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

suppressionServiceInutile #37

Merged
clement.chieu merged 12 commits from suppressionServiceInutile into master 1 year ago
Conversation 0 Commits 12 Files Changed 66
66 changed files with 667 additions and 1038 deletions
Show Stats Download Patch File Download Diff File

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

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

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

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

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

@ -13,27 +13,29 @@ namespace API.Controllers
[ApiController] [ApiController]
public class ParagraphsController : Controller public class ParagraphsController : Controller
{ {
private IParagraphService<ParagraphDTO> _paragraphDataService; private readonly IParagraphService<ParagraphDTO> _paragraphDataService;
private readonly ILogger<ParagraphsController> _logger; private readonly ILogger<ParagraphsController> _logger;
public ParagraphsController(IParagraphService<ParagraphDTO> paragraphDataService, ILogger<ParagraphsController> logger) public ParagraphsController(IParagraphService<ParagraphDTO> paragraphDataService,
ILogger<ParagraphsController> logger)
{ {
_paragraphDataService = paragraphDataService; _paragraphDataService = paragraphDataService;
_logger = logger; _logger = logger;
} }
[HttpGet("paragraphs/{page}/{number}/{orderCriteria}")] [HttpGet("paragraphs/{page:int}/{number:int}/{orderCriteria}")]
[ProducesResponseType(typeof(ParagraphDTO), 200)] [ProducesResponseType(typeof(ParagraphDTO), 200)]
[ProducesResponseType(typeof(string), 204)] [ProducesResponseType(typeof(string), 204)]
public IActionResult GetParagraphs(int page, int number, ParagraphOrderCriteria orderCriteria) public IActionResult GetParagraphs(int page, int number, ParagraphOrderCriteria orderCriteria)
{ {
var nbParagraph = ( _paragraphDataService.GetParagraphs(page, number, orderCriteria)).ToList().Count(); var nbParagraph = _paragraphDataService.GetParagraphs(page, number, orderCriteria).ToList().Count;
if(nbParagraph == 0) if (nbParagraph == 0)
{ {
_logger.LogError("[ERREUR] Aucun paragraphe trouvé."); _logger.LogError("[ERREUR] Aucun paragraphe trouvé.");
return StatusCode(204); return StatusCode(204);
} }
_logger.LogInformation("[INFORMATION] {nb} Paragraphe(s) trouvé(s)", nbParagraph); _logger.LogInformation("[INFORMATION] {nb} Paragraphe(s) trouvé(s)", nbParagraph);
return Ok(_paragraphDataService.GetParagraphs(page, number, orderCriteria)); return Ok(_paragraphDataService.GetParagraphs(page, number, orderCriteria));
} }
@ -47,7 +49,8 @@ namespace API.Controllers
{ {
_logger.LogInformation("[INFORMATION] Le paragraphe avec l'id {id} a été trouvé.", id); _logger.LogInformation("[INFORMATION] Le paragraphe avec l'id {id} a été trouvé.", id);
return Ok(_paragraphDataService.GetParagraphById(id)); return Ok(_paragraphDataService.GetParagraphById(id));
} catch (ArgumentException) }
catch (ArgumentException)
{ {
_logger.LogError("[ERREUR] Aucun paragraphe trouvé avec l'id {id}.", id); _logger.LogError("[ERREUR] Aucun paragraphe trouvé avec l'id {id}.", id);
return NotFound(); return NotFound();
@ -63,30 +66,30 @@ 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]
@ -94,37 +97,47 @@ namespace API.Controllers
[ProducesResponseType(typeof(string), 400)] [ProducesResponseType(typeof(string), 400)]
public IActionResult CreateParagraph([FromBody] ParagraphDTO dto) public IActionResult CreateParagraph([FromBody] ParagraphDTO dto)
{ {
if (dto.Title == null || dto.Content == null || dto.Info == null || dto.Query == null || dto.Comment == null) if (dto.Title == null || dto.Content == null || dto.Info == null || dto.Query == null ||
dto.Comment == null)
{ {
return BadRequest(); return BadRequest();
} }
_logger.LogInformation("[INFORMATION] Un paragraphe a été créé : title - {title}, content - {content}, info - {info}, query - {query}, comment - {comment}", dto.Title, dto.Content, dto.Info, dto.Query, dto.Comment);
return Created(nameof(GetParagraphs), _paragraphDataService.CreateParagraph(dto.Title, dto.Content, dto.Info, dto.Query, dto.Comment, dto.LessonId)); _logger.LogInformation(
"[INFORMATION] Un paragraphe a été créé : title - {title}, content - {content}, info - {info}, query - {query}, comment - {comment}",
dto.Title, dto.Content, dto.Info, dto.Query, dto.Comment);
return Created(nameof(GetParagraphs),
_paragraphDataService.CreateParagraph(dto.Title, dto.Content, dto.Info, dto.Query, dto.Comment,
dto.LessonId));
} }
[HttpPut("paragraph/{id}")] [HttpPut("paragraph/{id:int}")]
[ProducesResponseType(typeof(ParagraphDTO), 200)] [ProducesResponseType(typeof(ParagraphDTO), 200)]
[ProducesResponseType(typeof(string), 400)] [ProducesResponseType(typeof(string), 400)]
[ProducesResponseType(typeof(string), 404)] [ProducesResponseType(typeof(string), 404)]
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();
} }
} }
} }

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

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

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

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

32
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[] { }
} }
}); });
}); });
@ -86,7 +84,7 @@ var app = builder.Build();
// Configure the HTTP request pipeline. // Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment()) if (app.Environment.IsDevelopment())
{ {
app.UseSwagger(); app.UseSwagger();
app.UseSwaggerUI(); app.UseSwaggerUI();
} }
@ -98,4 +96,4 @@ app.MapControllers();
app.MapIdentityApi<IdentityUser>(); app.MapIdentityApi<IdentityUser>();
app.Run(); app.Run();

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

22
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 SuccessDTO GetSuccessByUserId(int id) => sucessService.GetSuccessByUserId(id).FromEntityToDTO();
public SuccessEntity GetSuccessByInquiryId(int id) => sucessService.GetSuccessByInquiryId(id); public SuccessDTO GetSuccessByInquiryId(int id) => sucessService.GetSuccessByInquiryId(id).FromEntityToDTO();
public bool DeleteSuccess(int id) => sucessService.DeleteSuccess(id); public bool DeleteSuccess(int id) => sucessService.DeleteSuccess(id);
public SuccessEntity UpdateSuccess(int id, SuccessEntity success) => public SuccessDTO UpdateSuccess(int id, SuccessDTO success) =>
sucessService.UpdateSuccess(id, success); sucessService.UpdateSuccess(id, 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();
} }

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

9
API_SQLuedo/DbContextLib/UserDbContext.cs
Unescape View File

@ -17,13 +17,18 @@ namespace DbContextLib
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);
} }
@ -36,4 +41,4 @@ namespace DbContextLib
base.OnModelCreating(modelBuilder); base.OnModelCreating(modelBuilder);
} }
} }
} }

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>

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

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

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

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

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

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

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

@ -16,43 +16,61 @@ 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 SuccessEntity GetSuccessByUserId(int id)
{ {
var successEntity = DbContext.Successes.FirstOrDefault(u => u.InquiryId == id); var userEntity = DbContext.Successes.FirstOrDefault(u => u.UserId == id);
if (successEntity == null) if (userEntity == 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 userEntity;
} }
public IEnumerable<SuccessEntity> GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria) public SuccessEntity GetSuccessByInquiryId(int id)
{ {
return DbContext.Successes.Skip((page - 1) * number).Take(number).ToList() var userEntity = DbContext.Successes.FirstOrDefault(u => u.InquiryId == id);
.Select(u => u); if (userEntity == null)
{
throw new ArgumentException("Impossible de trouver le succès", nameof(id));
}
return userEntity;
} }
public bool DeleteSuccess(int id) public bool DeleteSuccess(int id)
{ {
var userEntity = DbContext.Successes.FirstOrDefault(u => u.UserId == id); var successEntity = DbContext.Successes.FirstOrDefault(u => u.UserId == id);
if (userEntity == null) if (successEntity == null)
{ {
return false; return false;
} }
DbContext.Successes.Remove(userEntity); DbContext.Successes.Remove(successEntity);
DbContext.SaveChangesAsync(); DbContext.SaveChangesAsync();
return true; return true;
} }
@ -62,14 +80,15 @@ public class SuccessDataService : ISuccessService<SuccessEntity>
var updatingSuccess = DbContext.Successes.FirstOrDefault(u => u.UserId == id); var updatingSuccess = DbContext.Successes.FirstOrDefault(u => u.UserId == id);
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(id));
}
foreach (var pptt in typeof(SuccessEntity).GetProperties().Where(p =>
p.CanWrite && p.Name != nameof(SuccessEntity.UserId) && p.Name != nameof(SuccessEntity.InquiryId)))
{
pptt.SetValue(updatingSuccess, pptt.GetValue(success));
} }
updatingSuccess.UserId = success.UserId;
updatingSuccess.InquiryId = success.InquiryId;
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;
} }

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,

2
API_SQLuedo/Dto/InquiryDTO.cs
Unescape View File

@ -2,7 +2,7 @@
public class InquiryDTO public class InquiryDTO
{ {
public int Id { get;} public int Id { get; }
public string Title { get; set; } public string Title { get; set; }

5
API_SQLuedo/Dto/InquiryTableDTO.cs
Unescape View File

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

5
API_SQLuedo/Dto/LessonDTO.cs
Unescape View File

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

5
API_SQLuedo/Dto/NotepadDTO.cs
Unescape View File

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

12
API_SQLuedo/Dto/ParagraphDTO.cs
Unescape View File

@ -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)
{ {
@ -29,9 +29,9 @@ public class ParagraphDTO : ContentLessonDTO
Info = info; Info = info;
Query = query; Query = query;
Comment = comment; Comment = comment;
} }
public ParagraphDTO() : base() public ParagraphDTO() : base()
{ {
} }
} }

13
API_SQLuedo/Dto/SolutionDTO.cs
Unescape View File

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

4
API_SQLuedo/Dto/SuccessDTO.cs
Unescape View File

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

5
API_SQLuedo/Dto/UserDTO.cs
Unescape View File

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

9
API_SQLuedo/EntityFramework/BlackListEntity.cs
Unescape View File

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

6
API_SQLuedo/EntityFramework/InquiryTableEntity.cs
Unescape View File

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

4
API_SQLuedo/EntityFramework/LessonEntity.cs
Unescape View File

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

11
API_SQLuedo/EntityFramework/NotepadEntity.cs
Unescape View File

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

19
API_SQLuedo/EntityFramework/SolutionEntity.cs
Unescape View File

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

10
API_SQLuedo/EntityFramework/SuccessEntity.cs
Unescape View File

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

4
API_SQLuedo/Model/Inquiry.cs
Unescape View File

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

6
API_SQLuedo/Model/InquiryTable.cs
Unescape View File

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

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

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

14
API_SQLuedo/Shared/IUserDataService.cs
Unescape View File

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

101
API_SQLuedo/Shared/InquiryDataService.cs
Unescape View File

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

103
API_SQLuedo/Shared/LessonDataService.cs
Unescape View File

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

116
API_SQLuedo/Shared/ParagraphDataService.cs
Unescape View File

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

103
API_SQLuedo/Shared/SuccessDataService.cs
Unescape View File

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

121
API_SQLuedo/Shared/UserDataService.cs
Unescape View File

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

4
API_SQLuedo/StubbedContextLib/StubbedContext.cs
Unescape View File

@ -47,7 +47,7 @@ public class StubbedContext : UserDbContext
prf: KeyDerivationPrf.HMACSHA256, prf: KeyDerivationPrf.HMACSHA256,
iterationCount: 100000, iterationCount: 100000,
numBytesRequested: 256 / 8)), "Victor.GABORIT@etu.uca.fr", true)); numBytesRequested: 256 / 8)), "Victor.GABORIT@etu.uca.fr", true));
modelBuilder.Entity<InquiryTableEntity>().HasData( modelBuilder.Entity<InquiryTableEntity>().HasData(
new InquiryTableEntity(1, "Inquiry1", new InquiryTableEntity(1, "Inquiry1",
"Server=localhost;Database=Inquiry1;Trusted_Connection=True;MultipleActiveResultSets=true"), "Server=localhost;Database=Inquiry1;Trusted_Connection=True;MultipleActiveResultSets=true"),
@ -60,7 +60,7 @@ public class StubbedContext : UserDbContext
new SolutionEntity(1, "Maxime", "Sapountzis", "La cuisine", "Le couteau", "Parce que c'est Maxime"), new SolutionEntity(1, "Maxime", "Sapountzis", "La cuisine", "Le couteau", "Parce que c'est Maxime"),
new SolutionEntity(2, "Johnny", "Ratton", "La cuisine", "Le couteau", "Parce que il est ra****"), new SolutionEntity(2, "Johnny", "Ratton", "La cuisine", "Le couteau", "Parce que il est ra****"),
new SolutionEntity(3, "Erwan", "Menager", "La salle de bain", "L'arachide", "Parce que c'est Erwan")); new SolutionEntity(3, "Erwan", "Menager", "La salle de bain", "L'arachide", "Parce que c'est Erwan"));
modelBuilder.Entity<InquiryEntity>().HasData( modelBuilder.Entity<InquiryEntity>().HasData(
new InquiryEntity(1, "L'enquête de la carotte", "La description de l'inquiry1", true), new InquiryEntity(1, "L'enquête de la carotte", "La description de l'inquiry1", true),
new InquiryEntity(2, "L'enquête sur les orang outan", "The new description", false), new InquiryEntity(2, "L'enquête sur les orang outan", "The new description", false),

1
API_SQLuedo/TestAPI/UnitTest1.cs
Unescape View File

@ -5,7 +5,6 @@ namespace TestAPI
[Fact] [Fact]
public void Test1() public void Test1()
{ {
} }
} }
} }

79
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,11 +30,16 @@ ILogger<SuccessesController> successLogger = factory.CreateLogger<SuccessesContr
using (var context = new UserDbContext(options)) using (var context = new UserDbContext(options))
{ {
var userController = new UsersController(userLogger, new UserDataService(context)); var userController = new UsersController(userLogger, new UserDataServiceApi(new Service_UserDataService(context)));
var inquiryController = new InquiriesController(new InquiryDataService(context), inquiryLogger); var inquiryController =
var paragraphController = new ParagraphsController(new ParagraphDataService(context), paragraphLogger); new InquiriesController(new InquiryDataServiceApi(new InquiryDataService(context)), inquiryLogger);
var lessonController = new LessonsController(new LessonDataService(context), lessonLogger); var paragraphController =
var successController = new SuccessesController(new SuccessDataService(context), successLogger); new ParagraphsController(new ParagraphDataServiceApi(new Service_ParagraphDataService(context)),
paragraphLogger);
var lessonController =
new LessonsController(new LessonDataServiceApi(new Service_LessonDataService(context)), lessonLogger);
var successController = new SuccessesController(new SuccessDataServiceApi(new Service_SuccessDataService(context)),
successLogger);
void PrintUsers() void PrintUsers()
{ {
@ -91,8 +101,8 @@ using (var context = new UserDbContext(options))
Console.WriteLine("Erreur, la requête n'a rien donné."); Console.WriteLine("Erreur, la requête n'a rien donné.");
return; return;
} }
Console.WriteLine(user.Value as UserDTO);
Console.WriteLine(user.Value as UserDTO);
} }
void SearchInquiryByTitle() void SearchInquiryByTitle()
@ -105,6 +115,7 @@ using (var context = new UserDbContext(options))
Console.WriteLine("Erreur, la requête n'a rien donné."); Console.WriteLine("Erreur, la requête n'a rien donné.");
return; return;
} }
Console.WriteLine(inquiry.Value as InquiryDTO); Console.WriteLine(inquiry.Value as InquiryDTO);
} }
@ -118,8 +129,8 @@ using (var context = new UserDbContext(options))
Console.WriteLine("Erreur, la requête n'a rien donné."); Console.WriteLine("Erreur, la requête n'a rien donné.");
return; return;
} }
Console.WriteLine(paragraph.Value as ParagraphDTO);
Console.WriteLine(paragraph.Value as ParagraphDTO);
} }
void SearchLessonByTitle() void SearchLessonByTitle()
@ -132,8 +143,8 @@ using (var context = new UserDbContext(options))
Console.WriteLine("Erreur, la requête n'a rien donné."); Console.WriteLine("Erreur, la requête n'a rien donné.");
return; return;
} }
Console.WriteLine(lesson.Value as LessonDTO);
Console.WriteLine(lesson.Value as LessonDTO);
} }
void SearchSuccessByUserId() void SearchSuccessByUserId()
@ -146,8 +157,8 @@ using (var context = new UserDbContext(options))
Console.WriteLine("Erreur, la requête n'a rien donné."); Console.WriteLine("Erreur, la requête n'a rien donné.");
return; return;
} }
Console.WriteLine(success.Value as SuccessDTO);
Console.WriteLine(success.Value as SuccessDTO);
} }
void SearchUserById() void SearchUserById()
@ -160,8 +171,8 @@ using (var context = new UserDbContext(options))
Console.WriteLine("Erreur, la requête n'a rien donné."); Console.WriteLine("Erreur, la requête n'a rien donné.");
return; return;
} }
Console.WriteLine(user.Value as UserDTO);
Console.WriteLine(user.Value as UserDTO);
} }
void SearchInquiryById() void SearchInquiryById()
@ -174,6 +185,7 @@ using (var context = new UserDbContext(options))
Console.WriteLine("Erreur, la requête n'a rien donné."); Console.WriteLine("Erreur, la requête n'a rien donné.");
return; return;
} }
Console.WriteLine(inquiry.Value as InquiryDTO); Console.WriteLine(inquiry.Value as InquiryDTO);
} }
@ -187,8 +199,8 @@ using (var context = new UserDbContext(options))
Console.WriteLine("Erreur, la requête n'a rien donné."); Console.WriteLine("Erreur, la requête n'a rien donné.");
return; return;
} }
Console.WriteLine(paragraph.Value as ParagraphDTO);
Console.WriteLine(paragraph.Value as ParagraphDTO);
} }
void SearchSuccessByInquiryId() void SearchSuccessByInquiryId()
@ -201,8 +213,8 @@ using (var context = new UserDbContext(options))
Console.WriteLine("Erreur, la requête n'a rien donné."); Console.WriteLine("Erreur, la requête n'a rien donné.");
return; return;
} }
Console.WriteLine(success.Value as SuccessDTO);
Console.WriteLine(success.Value as SuccessDTO);
} }
void SearchLessonById() void SearchLessonById()
@ -215,8 +227,8 @@ using (var context = new UserDbContext(options))
Console.WriteLine("Erreur, la requête n'a rien donné."); Console.WriteLine("Erreur, la requête n'a rien donné.");
return; return;
} }
Console.WriteLine(lesson.Value as LessonDTO);
Console.WriteLine(lesson.Value as LessonDTO);
} }
void AddUser() void AddUser()
@ -236,7 +248,6 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("\nErreur lors de la création de l'utilisateur !"); Console.WriteLine("\nErreur lors de la création de l'utilisateur !");
} }
} }
void AddInquiry() void AddInquiry()
@ -285,7 +296,6 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("\nErreur lors de la création du paragraphe !"); Console.WriteLine("\nErreur lors de la création du paragraphe !");
} }
} }
void AddLesson() void AddLesson()
@ -294,7 +304,8 @@ using (var context = new UserDbContext(options))
var title = Console.ReadLine(); var title = Console.ReadLine();
Console.WriteLine("Veuillez saisir votre nom :"); Console.WriteLine("Veuillez saisir votre nom :");
var lastPublisher = Console.ReadLine(); var lastPublisher = Console.ReadLine();
var res = lessonController.CreateLesson(new LessonDTO(title, lastPublisher, DateOnly.FromDateTime(DateTime.Now))); var res = lessonController.CreateLesson(
new LessonDTO(title, lastPublisher, DateOnly.FromDateTime(DateTime.Now)));
if (res.GetType() == typeof(CreatedResult)) if (res.GetType() == typeof(CreatedResult))
{ {
Console.WriteLine("\nLeçon créée avec succès"); Console.WriteLine("\nLeçon créée avec succès");
@ -303,7 +314,6 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("\nErreur lors de la création de la leçon !"); Console.WriteLine("\nErreur lors de la création de la leçon !");
} }
} }
void AddSuccess() void AddSuccess()
@ -314,7 +324,8 @@ using (var context = new UserDbContext(options))
var inquiryId = Console.ReadLine(); var inquiryId = Console.ReadLine();
Console.WriteLine("Veuillez indiquer si l'enquête a été complété (true/false) :"); Console.WriteLine("Veuillez indiquer si l'enquête a été complété (true/false) :");
var isFinished = Console.ReadLine(); var isFinished = Console.ReadLine();
var res = successController.CreateSuccess(new SuccessDTO(int.Parse(userId), int.Parse(inquiryId), bool.Parse(isFinished))); var res = successController.CreateSuccess(new SuccessDTO(int.Parse(userId), int.Parse(inquiryId),
bool.Parse(isFinished)));
if (res.GetType() == typeof(CreatedResult)) if (res.GetType() == typeof(CreatedResult))
{ {
Console.WriteLine("\nSuccès créé avec succès"); Console.WriteLine("\nSuccès créé avec succès");
@ -323,7 +334,6 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("\nErreur lors de la création du succès !"); Console.WriteLine("\nErreur lors de la création du succès !");
} }
} }
void UpdateUser() void UpdateUser()
@ -346,7 +356,8 @@ using (var context = new UserDbContext(options))
var username = Console.ReadLine(); var username = Console.ReadLine();
Console.WriteLine("Veuillez saisir l'email :"); Console.WriteLine("Veuillez saisir l'email :");
var email = Console.ReadLine(); var email = Console.ReadLine();
var retour = userController.UpdateUser(id, new UserDTO(id, username, user.Password, email, user.IsAdmin)); var retour =
userController.UpdateUser(id, new UserDTO(id, username, user.Password, email, user.IsAdmin));
if (retour.GetType() == typeof(OkObjectResult)) if (retour.GetType() == typeof(OkObjectResult))
{ {
Console.WriteLine("Mise à jour effectué avec succès !"); Console.WriteLine("Mise à jour effectué avec succès !");
@ -361,7 +372,6 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("Une erreur est survenue lors de la mise à jour !"); Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
} }
} }
void UpdateInquiry() void UpdateInquiry()
@ -390,7 +400,8 @@ using (var context = new UserDbContext(options))
var database = Convert.ToInt32(Console.ReadLine()); var database = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Veuillez saisir un commentaire :"); Console.WriteLine("Veuillez saisir un commentaire :");
var inquiryTable = Convert.ToInt32(Console.ReadLine()); var inquiryTable = Convert.ToInt32(Console.ReadLine());
var retour = inquiryController.UpdateInquiry(id, new InquiryDTO(id, title, description, bool.Parse(isUser))); var retour =
inquiryController.UpdateInquiry(id, new InquiryDTO(id, title, description, bool.Parse(isUser)));
if (retour.GetType() == typeof(OkObjectResult)) if (retour.GetType() == typeof(OkObjectResult))
{ {
Console.WriteLine("Mise à jour effectué avec succès !"); Console.WriteLine("Mise à jour effectué avec succès !");
@ -405,7 +416,6 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("Une erreur est survenue lors de la mise à jour !"); Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
} }
} }
void UpdateParagraph() void UpdateParagraph()
@ -436,7 +446,8 @@ using (var context = new UserDbContext(options))
var comment = Console.ReadLine(); var comment = Console.ReadLine();
Console.WriteLine("Veuillez saisir l'id de la leçon :"); Console.WriteLine("Veuillez saisir l'id de la leçon :");
var lesson = Convert.ToInt32(Console.ReadLine()); var lesson = Convert.ToInt32(Console.ReadLine());
var retour = paragraphController.UpdateParagraph(id, new ParagraphDTO(id, title, content, info, query, comment, lesson)); var retour = paragraphController.UpdateParagraph(id,
new ParagraphDTO(id, title, content, info, query, comment, lesson));
if (retour.GetType() == typeof(OkObjectResult)) if (retour.GetType() == typeof(OkObjectResult))
{ {
Console.WriteLine("Mise à jour effectué avec succès !"); Console.WriteLine("Mise à jour effectué avec succès !");
@ -451,7 +462,6 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("Une erreur est survenue lors de la mise à jour !"); Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
} }
} }
void UpdateLesson() void UpdateLesson()
@ -474,7 +484,8 @@ using (var context = new UserDbContext(options))
var title = Console.ReadLine(); var title = Console.ReadLine();
Console.WriteLine("Veuillez saisir votre nom :"); Console.WriteLine("Veuillez saisir votre nom :");
var lastPublisher = Console.ReadLine(); var lastPublisher = Console.ReadLine();
var retour = lessonController.UpdateLesson(id, new LessonDTO(id, title, lastPublisher, DateOnly.FromDateTime(DateTime.Now))); var retour = lessonController.UpdateLesson(id,
new LessonDTO(id, title, lastPublisher, DateOnly.FromDateTime(DateTime.Now)));
if (retour.GetType() == typeof(OkObjectResult)) if (retour.GetType() == typeof(OkObjectResult))
{ {
Console.WriteLine("Mise à jour effectué avec succès !"); Console.WriteLine("Mise à jour effectué avec succès !");
@ -489,7 +500,6 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("Une erreur est survenue lors de la mise à jour !"); Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
} }
} }
void UpdateSuccess() void UpdateSuccess()
@ -514,7 +524,8 @@ using (var context = new UserDbContext(options))
var inquiryId = Console.ReadLine(); var inquiryId = 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(id,
new SuccessDTO(int.Parse(userId), int.Parse(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,7 +600,6 @@ using (var context = new UserDbContext(options))
{ {
Console.WriteLine("Erreur lors de la suppression !"); Console.WriteLine("Erreur lors de la suppression !");
} }
} }
void DeleteSuccess() void DeleteSuccess()
@ -608,7 +615,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 +753,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();

4
API_SQLuedo/TestConsoleEf/Program.cs
Unescape View File

@ -159,10 +159,10 @@ using (var db = new StubbedContext(options))
// Affichage de la solution de l'enquete sur les orang outan // Affichage de la solution de l'enquete sur les orang outan
Console.WriteLine("\nAffichage de la solution de l'enquete sur les orang outan"); Console.WriteLine("\nAffichage de la solution de l'enquete sur les orang outan");
var sol = await solutions.FirstOrDefaultAsync(s => s.Owner.Title == "L'enquête sur les orang outan"); var sol = await solutions.FirstOrDefaultAsync(s => s.Owner.Title == "L'enquête sur les orang outan");
Console.WriteLine(sol.MurdererFirstName); Console.WriteLine(sol.MurdererFirstName);
var inquirySolution = await inquiries.FirstOrDefaultAsync(i => i.Title == "L'enquête sur les orang outan"); var inquirySolution = await inquiries.FirstOrDefaultAsync(i => i.Title == "L'enquête sur les orang outan");
var i = inquirySolution.Id; var i = inquirySolution.Id;
foreach (var pptt in typeof(SolutionEntity).GetProperties() foreach (var pptt in typeof(SolutionEntity).GetProperties()

18
API_SQLuedo/TestEF/EntitiesTests/TestInquiryEntity.cs
Unescape View File

@ -18,7 +18,7 @@ public class TestInquiryEntity
Assert.Null(inquiry.Description); Assert.Null(inquiry.Description);
Assert.False(inquiry.IsUser); Assert.False(inquiry.IsUser);
} }
[Fact] [Fact]
public void TestConstructorWithOnlyId() public void TestConstructorWithOnlyId()
{ {
@ -28,24 +28,24 @@ public class TestInquiryEntity
Assert.Null(inquiry.Description); Assert.Null(inquiry.Description);
Assert.False(inquiry.IsUser); Assert.False(inquiry.IsUser);
} }
[Fact] [Fact]
public void TestConstructorWithoutId() public void TestConstructorWithoutId()
{ {
InquiryEntity inquiry = new InquiryEntity(_title,_description,_isUser); InquiryEntity inquiry = new InquiryEntity(_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);
Assert.True(inquiry.IsUser); Assert.True(inquiry.IsUser);
} }
[Fact] [Fact]
public void TestConstructorWithAllAttributes() public void TestConstructorWithAllAttributes()
{ {
InquiryEntity inquiry = new InquiryEntity(_id,_title,_description,_isUser); InquiryEntity inquiry = new InquiryEntity(_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);
Assert.True(inquiry.IsUser); Assert.True(inquiry.IsUser);
} }
} }

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

@ -13,40 +13,40 @@ public class TestInquiryTableEntity
public void TestDefaultConstructor() public void TestDefaultConstructor()
{ {
InquiryTableEntity tableEntity = new InquiryTableEntity(); InquiryTableEntity tableEntity = new InquiryTableEntity();
Assert.Equal(0,tableEntity.OwnerId); Assert.Equal(0, tableEntity.OwnerId);
Assert.Null(tableEntity.Owner); Assert.Null(tableEntity.Owner);
Assert.Null(tableEntity.DatabaseName); Assert.Null(tableEntity.DatabaseName);
Assert.Null(tableEntity.ConnectionInfo); Assert.Null(tableEntity.ConnectionInfo);
} }
[Fact] [Fact]
public void TestConstructorWithOnlyId() public void TestConstructorWithOnlyId()
{ {
InquiryTableEntity tableEntity = new InquiryTableEntity(_inquiryId); InquiryTableEntity tableEntity = new InquiryTableEntity(_inquiryId);
Assert.Equal(_inquiryId,tableEntity.OwnerId); Assert.Equal(_inquiryId, tableEntity.OwnerId);
Assert.Null(tableEntity.Owner); Assert.Null(tableEntity.Owner);
Assert.Null(tableEntity.DatabaseName); Assert.Null(tableEntity.DatabaseName);
Assert.Null(tableEntity.ConnectionInfo); Assert.Null(tableEntity.ConnectionInfo);
} }
[Fact] [Fact]
public void TestConstructorWithoutId() public void TestConstructorWithoutId()
{ {
InquiryTableEntity tableEntity = new InquiryTableEntity(_inquiry,_databaseName,_connectionInfo); InquiryTableEntity tableEntity = new InquiryTableEntity(_inquiry, _databaseName, _connectionInfo);
Assert.Equal(0,tableEntity.OwnerId); Assert.Equal(0, tableEntity.OwnerId);
Assert.Equal(_inquiry,tableEntity.Owner); Assert.Equal(_inquiry, tableEntity.Owner);
Assert.Equal(_databaseName,tableEntity.DatabaseName); Assert.Equal(_databaseName, tableEntity.DatabaseName);
Assert.Equal(_connectionInfo,tableEntity.ConnectionInfo); Assert.Equal(_connectionInfo, tableEntity.ConnectionInfo);
} }
[Fact] [Fact]
public void TestConstructorWithoutNavigationProperty() public void TestConstructorWithoutNavigationProperty()
{ {
InquiryTableEntity tableEntity = new InquiryTableEntity(_inquiryId,_databaseName,_connectionInfo); InquiryTableEntity tableEntity = new InquiryTableEntity(_inquiryId, _databaseName, _connectionInfo);
Assert.Equal(_inquiryId,tableEntity.OwnerId); Assert.Equal(_inquiryId, tableEntity.OwnerId);
Assert.Null(tableEntity.Owner); Assert.Null(tableEntity.Owner);
Assert.Equal(_databaseName,tableEntity.DatabaseName); Assert.Equal(_databaseName, tableEntity.DatabaseName);
Assert.Equal(_connectionInfo,tableEntity.ConnectionInfo); Assert.Equal(_connectionInfo, tableEntity.ConnectionInfo);
} }
} }

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

@ -19,24 +19,24 @@ public class TestLessonEntity
Assert.Null(lesson.LastPublisher); Assert.Null(lesson.LastPublisher);
Assert.Null(lesson.LastEdit); Assert.Null(lesson.LastEdit);
} }
[Fact] [Fact]
public void TestConstructorWithoutId() public void TestConstructorWithoutId()
{ {
LessonEntity lesson = new LessonEntity(_title,_lastPublisher,_lastEdit); LessonEntity lesson = new LessonEntity(_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()
{ {
LessonEntity lesson = new LessonEntity(_id,_title,_lastPublisher,_lastEdit); LessonEntity lesson = new LessonEntity(_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);
} }
} }

38
API_SQLuedo/TestEF/EntitiesTests/TestNotepadEntity.cs
Unescape View File

@ -15,35 +15,35 @@ public class TestNotepadEntity
public void TestDefaultConstructor() public void TestDefaultConstructor()
{ {
NotepadEntity notepad = new NotepadEntity(); NotepadEntity notepad = new NotepadEntity();
Assert.Equal(0,notepad.Id); Assert.Equal(0, notepad.Id);
Assert.Equal(0,notepad.UserId); Assert.Equal(0, notepad.UserId);
Assert.Null(notepad.User); Assert.Null(notepad.User);
Assert.Equal(0,notepad.InquiryId); Assert.Equal(0, notepad.InquiryId);
Assert.Null(notepad.Inquiry); Assert.Null(notepad.Inquiry);
Assert.Null(notepad.Notes); Assert.Null(notepad.Notes);
} }
[Fact] [Fact]
public void TestConstructorWithoutId() public void TestConstructorWithoutId()
{ {
NotepadEntity notepad = new NotepadEntity(_userId,_userEntity,_inquiryId,_inquiryEntity,_notes); NotepadEntity notepad = new NotepadEntity(_userId, _userEntity, _inquiryId, _inquiryEntity, _notes);
Assert.Equal(0,notepad.Id); Assert.Equal(0, notepad.Id);
Assert.Equal(_userId,notepad.UserId); Assert.Equal(_userId, notepad.UserId);
Assert.Equal(_userEntity,notepad.User); Assert.Equal(_userEntity, notepad.User);
Assert.Equal(_inquiryId,notepad.InquiryId); Assert.Equal(_inquiryId, notepad.InquiryId);
Assert.Equal(_inquiryEntity,notepad.Inquiry); Assert.Equal(_inquiryEntity, notepad.Inquiry);
Assert.Equal(_notes,notepad.Notes); Assert.Equal(_notes, notepad.Notes);
} }
[Fact] [Fact]
public void TestConstructorWithAllAttributes() public void TestConstructorWithAllAttributes()
{ {
NotepadEntity notepad = new NotepadEntity(_id,_userId,_userEntity,_inquiryId,_inquiryEntity,_notes); NotepadEntity notepad = new NotepadEntity(_id, _userId, _userEntity, _inquiryId, _inquiryEntity, _notes);
Assert.Equal(_id,notepad.Id); Assert.Equal(_id, notepad.Id);
Assert.Equal(_userId,notepad.UserId); Assert.Equal(_userId, notepad.UserId);
Assert.Equal(_userEntity,notepad.User); Assert.Equal(_userEntity, notepad.User);
Assert.Equal(_inquiryId,notepad.InquiryId); Assert.Equal(_inquiryId, notepad.InquiryId);
Assert.Equal(_inquiryEntity,notepad.Inquiry); Assert.Equal(_inquiryEntity, notepad.Inquiry);
Assert.Equal(_notes,notepad.Notes); Assert.Equal(_notes, notepad.Notes);
} }
} }

28
API_SQLuedo/TestEF/EntitiesTests/TestParagraphEntity.cs
Unescape View File

@ -22,29 +22,29 @@ public class TestParagraphEntity
Assert.Null(paragraph.Query); Assert.Null(paragraph.Query);
Assert.Null(paragraph.Comment); Assert.Null(paragraph.Comment);
} }
[Fact] [Fact]
public void TestConstructorWithoutId() public void TestConstructorWithoutId()
{ {
ParagraphEntity paragraph = new ParagraphEntity(_title,_content,_info,_query,_comment); ParagraphEntity paragraph = new ParagraphEntity(_title, _content, _info, _query, _comment);
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()
{ {
ParagraphEntity paragraph = new ParagraphEntity(_id,_title,_content,_info,_query,_comment,10); ParagraphEntity paragraph = new ParagraphEntity(_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);
} }
} }

24
API_SQLuedo/TestEF/EntitiesTests/TestSuccessEntity.cs
Unescape View File

@ -12,46 +12,46 @@ public class TestSuccessEntity
public void TestDefaultConstructor() public void TestDefaultConstructor()
{ {
SuccessEntity success = new SuccessEntity(); SuccessEntity success = new SuccessEntity();
Assert.Equal(0,success.UserId); Assert.Equal(0, success.UserId);
Assert.Null(success.User); Assert.Null(success.User);
Assert.Equal(0,success.InquiryId); Assert.Equal(0, success.InquiryId);
Assert.Null(success.Inquiry); Assert.Null(success.Inquiry);
Assert.False(success.IsFinished); Assert.False(success.IsFinished);
} }
[Fact] [Fact]
public void TestConstructorWithIds() public void TestConstructorWithIds()
{ {
SuccessEntity success = new SuccessEntity(_userId, _inquiryId, _isFinished); SuccessEntity success = new SuccessEntity(_userId, _inquiryId, _isFinished);
Assert.Equal(_userId,success.UserId); Assert.Equal(_userId, success.UserId);
Assert.Null(success.User); Assert.Null(success.User);
Assert.Equal(_inquiryId,success.InquiryId); Assert.Equal(_inquiryId, success.InquiryId);
Assert.Null(success.Inquiry); Assert.Null(success.Inquiry);
Assert.True(success.IsFinished); Assert.True(success.IsFinished);
} }
[Fact] [Fact]
public void TestConstructorWithNavigationProperties() public void TestConstructorWithNavigationProperties()
{ {
UserEntity user = new UserEntity(); UserEntity user = new UserEntity();
InquiryEntity inquiry = new InquiryEntity(); InquiryEntity inquiry = new InquiryEntity();
SuccessEntity success = new SuccessEntity(user, inquiry, _isFinished); SuccessEntity success = new SuccessEntity(user, inquiry, _isFinished);
Assert.Equal(0,success.UserId); Assert.Equal(0, success.UserId);
Assert.NotNull(success.User); Assert.NotNull(success.User);
Assert.Equal(0,success.InquiryId); Assert.Equal(0, success.InquiryId);
Assert.NotNull(success.Inquiry); Assert.NotNull(success.Inquiry);
Assert.True(success.IsFinished); Assert.True(success.IsFinished);
} }
[Fact] [Fact]
public void TestConstructorWithAllAttributes() public void TestConstructorWithAllAttributes()
{ {
UserEntity user = new UserEntity(); UserEntity user = new UserEntity();
InquiryEntity inquiry = new InquiryEntity(); InquiryEntity inquiry = new InquiryEntity();
SuccessEntity success = new SuccessEntity(_userId, user, _inquiryId, inquiry, _isFinished); SuccessEntity success = new SuccessEntity(_userId, user, _inquiryId, inquiry, _isFinished);
Assert.Equal(_userId,success.UserId); Assert.Equal(_userId, success.UserId);
Assert.NotNull(success.User); Assert.NotNull(success.User);
Assert.Equal(_inquiryId,success.InquiryId); Assert.Equal(_inquiryId, success.InquiryId);
Assert.NotNull(success.Inquiry); Assert.NotNull(success.Inquiry);
Assert.True(success.IsFinished); Assert.True(success.IsFinished);
} }

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

@ -9,11 +9,12 @@ namespace TestEF
private const string _password = "password"; private const string _password = "password";
private const bool _isAdmin = true; private const bool _isAdmin = true;
private const int _id = 42; private const int _id = 42;
[Fact] [Fact]
public void TestDefaultConstructor() public void TestDefaultConstructor()
{ {
UserEntity user = new UserEntity(); UserEntity user = new UserEntity();
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);
Assert.Null(user.Password); Assert.Null(user.Password);
@ -24,7 +25,7 @@ namespace TestEF
public void TestConstructorWithOnlyId() public void TestConstructorWithOnlyId()
{ {
UserEntity user = new UserEntity(_id); UserEntity user = new UserEntity(_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);
Assert.Null(user.Password); Assert.Null(user.Password);
@ -35,18 +36,18 @@ namespace TestEF
public void TestConstructorWithoutId() public void TestConstructorWithoutId()
{ {
UserEntity user = new UserEntity(_username, _password, _email, _isAdmin); UserEntity user = new UserEntity(_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()
{ {
UserEntity user = new UserEntity(_id, _username, _password, _email, _isAdmin); UserEntity user = new UserEntity(_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);

Write Preview
Loading…
Cancel
Save