Fusion de master dans UnitTests

API_SQLuedo/API/Controllers/InquiriesController.cs

@@ -1,73 +1,131 @@
-using Dto;
+using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
-using Microsoft.AspNetCore.Mvc;
+using Dto;
-using Shared;
+using Model.OrderCriteria;
-
+using Shared;
-namespace API.Controllers
+using Asp.Versioning;
-{
+
-    [Route("api/[controller]")]
+namespace API.Controllers
-    [Authorize]
+{
-    [ApiController]
+    [Route("api/v{version:apiVersion}/[controller]")]
-    public class InquiriesController()
+    [Authorize]
-        : ControllerBase
+    [ApiVersion("1.0")]
-    {
+    [ApiController]
-        private readonly IInquiryService<InquiryDTO> _inquiryService;
+    public class InquiriesController : Controller
-        private readonly ILogger<InquiriesController> _logger;
+    {
-
+        private IInquiryService<InquiryDTO> _inquiryDataService;
-        public InquiriesController(IInquiryService<InquiryDTO> inquiryService, ILogger<InquiriesController> logger) : this()
+
-        {
+        private readonly ILogger<InquiriesController> _logger;
-            _inquiryService = inquiryService;
+        public InquiriesController(IInquiryService<InquiryDTO> inquiryDataService, ILogger<InquiriesController> logger)
-            _logger = logger;
+        {
-        }
+            _inquiryDataService = inquiryDataService;
-
+            _logger = logger;
-        [HttpGet("inquiries/{page}/{number}")]
+        }
-        [ProducesResponseType(typeof(InquiryDTO), 200)]
+
-        [ProducesResponseType(typeof(string), 204)]
+        [HttpGet("inquiries/{page}/{number}/{orderCriteria}")]
-        public IActionResult GetInquiries(int page, int number)
+        [ProducesResponseType(typeof(InquiryDTO), 200)]
-        {
+        [ProducesResponseType(typeof(string), 204)]
-            var nbInquiry = _inquiryService.GetInquiries(page, number).Count();
+        public IActionResult GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria)
-            if (nbInquiry == 0)
+        {
-            {
+            var nbInquiry = _inquiryDataService.GetInquiries(page, number, orderCriteria).Count();
-                _logger.LogError("[ERREUR] Aucune enquête trouvé.");
+            if (nbInquiry == 0)
-                return StatusCode(204);
+            {
-            }
+                _logger.LogError("[ERREUR] Aucune enquête trouvée.");
-
+                return StatusCode(204);
-            _logger.LogInformation("[INFORMATION] {nb} Enquête(s) trouvée(s)", nbInquiry);
+            }
-            return Ok(_inquiryService.GetInquiries(page, number));
+            _logger.LogInformation("[INFORMATION] {nb} Enquête(s) trouvée(s)", nbInquiry);
-        }
+            return Ok(_inquiryDataService.GetInquiries(page, number, orderCriteria));
-
+        }
-        [HttpGet("inquiry/id/{id}")]
+
-        [ProducesResponseType(typeof(InquiryDTO), 200)]
+        [HttpGet("inquiry/{id:int}")]
-        [ProducesResponseType(typeof(string), 404)]
+        [ProducesResponseType(typeof(InquiryDTO), 200)]
-        public IActionResult GetInquiryById(int id)
+        [ProducesResponseType(typeof(string), 404)]
-        {
+        public IActionResult GetInquiryById(int id)
-            try
+        {
-            {
+            try
-                _logger.LogInformation("[INFORMATION] Enquête avec l'id {id} a été trouvé.", id);
+            {
-                return Ok(_inquiryService.GetInquiryById(id));
+                _logger.LogInformation("[INFORMATION] L'enquête avec l'id {id} a été trouvé.", id);
-            }
+                return Ok(_inquiryDataService.GetInquiryById(id));
-            catch (ArgumentException)
+            }
-            {
+            catch (ArgumentException)
-                _logger.LogError("[ERREUR] Aucune enquête trouvée avec l'id {id}.", id);
+            {
-                return NotFound();
+                _logger.LogError("[ERREUR] Aucune enquête trouvée avec l'id {id}.", id);
-            }
+                return NotFound();
-        }
+            }
-
+        }
-        [HttpGet("inquiry/title/{title}")]
+
-        [ProducesResponseType(typeof(InquiryDTO), 200)]
+        [HttpGet("inquiry/{title:alpha}")]
-        [ProducesResponseType(typeof(string), 404)]
+        [ProducesResponseType(typeof(InquiryDTO), 200)]
-        public IActionResult GetInquiryByTitle(string title)
+        [ProducesResponseType(typeof(string), 404)]
-        {
+        public IActionResult GetInquiryByTitle(string title)
-            try
+        {
-            {
+            try
-                _logger.LogInformation("[INFORMATION] Enquête avec le titre {title} a été trouvé.", title);
+            {
-                return Ok(_inquiryService.GetInquiryByTitle(title));
+                _logger.LogInformation("[INFORMATION] L'enquête avec le titre {title} a été trouvé.", title);
-            }
+                return Ok(_inquiryDataService.GetInquiryByTitle(title));
-            catch (ArgumentException)
+            }
-            {
+            catch (ArgumentException)
-                _logger.LogError("[ERREUR] Aucune enquête trouvée avec le titre {title}.", title);
+            {
-                return NotFound();
+                _logger.LogError("[ERREUR] Aucune enquête trouvée avec le titre {title}.", title);
-            }
+                return NotFound();
-        }
+            }
-    }
+        }
+
+        [HttpDelete("inquiry/{id}")]
+        [ProducesResponseType(typeof(InquiryDTO), 200)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult DeleteInquiry(int id)
+        {
+            var success = _inquiryDataService.DeleteInquiry(id);
+            if (success)
+            {
+                _logger.LogInformation("[INFORMATION] L'enquête avec l'id {id} a été supprimé.", id);
+                return Ok(_inquiryDataService.DeleteInquiry(id));
+            }
+            else
+            {
+                _logger.LogError("[ERREUR] Aucune enquête trouvée avec l'id {id}.", id);
+                return NotFound();
+            }
+
+        }
+
+        [HttpPost]
+        [ProducesResponseType(typeof(InquiryDTO), 201)]
+        [ProducesResponseType(typeof(string), 400)]
+        public IActionResult CreateInquiry([FromBody] InquiryDTO dto)
+        {
+            if (dto.Title == null || dto.Description == null)
+            {
+                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));
+        }
+
+        [HttpPut("inquiry/{id}")]
+        [ProducesResponseType(typeof(InquiryDTO), 200)]
+        [ProducesResponseType(typeof(string), 400)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult UpdateInquiry(int id, [FromBody] InquiryDTO inquiryDTO)
+        {
+            if (id != inquiryDTO.Id)
+            {
+                _logger.LogError("[ERREUR] Problème ID - La mise à jour de l'enquête avec l'id {id} a échouée.", id);
+                return BadRequest();
+            }
+            if (!ModelState.IsValid)
+            {
+                _logger.LogError("[ERREUR] Problème controlleur - La mise à jour de l'enquête avec l'id {id} a échouée.", id);
+                return BadRequest();
+            }
+            if (inquiryDTO != null)
+            {
+                _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));
+            }
+            _logger.LogError("[ERREUR] Aucune enquête trouvée avec l'id {id}.", id);
+            return NotFound();
+        }
+    }
 }

API_SQLuedo/API/Controllers/LessonsController.cs

@@ -0,0 +1,132 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Dto;
+using Model.OrderCriteria;
+using Shared;
+using Asp.Versioning;
+
+namespace API.Controllers
+{
+    [Route("api/v{version:apiVersion}/[controller]")]
+    [Authorize]
+    [ApiVersion("1.0")]
+    [ApiController]
+    public class LessonsController : Controller
+    {
+        private ILessonService<LessonDTO> _lessonDataService;
+
+        private readonly ILogger<LessonsController> _logger;
+
+        public LessonsController(ILessonService<LessonDTO> lessonDataService, ILogger<LessonsController> logger)
+        {
+            _lessonDataService = lessonDataService;
+            _logger = logger;
+        }
+
+        [HttpGet("lessons/{page}/{number}/{orderCriteria}")]
+        [ProducesResponseType(typeof(LessonDTO), 200)]
+        [ProducesResponseType(typeof(string), 204)]
+        public IActionResult GetLessons(int page, int number, LessonOrderCriteria orderCriteria)
+        {
+            var nbLesson = _lessonDataService.GetLessons(page, number, orderCriteria).Count();
+            if (nbLesson == 0)
+            {
+                _logger.LogError("[ERREUR] Aucune leçon trouvée.");
+                return StatusCode(204);
+            }
+            _logger.LogInformation("[INFORMATION] {nb} Leçon(s) trouvée(s)", nbLesson);
+            return Ok(_lessonDataService.GetLessons(page, number, orderCriteria));
+        }
+
+        [HttpGet("lesson/{id:int}")]
+        [ProducesResponseType(typeof(LessonDTO), 200)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult GetLessonById(int id)
+        {
+            try
+            {
+                _logger.LogInformation("[INFORMATION] La leçon avec l'id {id} a été trouvé.", id);
+                return Ok(_lessonDataService.GetLessonById(id));
+            }
+            catch (ArgumentException)
+            {
+                _logger.LogError("[ERREUR] Aucune leçon trouvée avec l'id {id}.", id);
+                return NotFound();
+            }
+        }
+
+        [HttpGet("lesson/{title:alpha}")]
+        [ProducesResponseType(typeof(LessonDTO), 200)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult GetLessonByTitle(string title)
+        {
+            try
+            {
+                _logger.LogInformation("[INFORMATION] La leçon avec le titre {title} a été trouvé.", title);
+                return Ok(_lessonDataService.GetLessonByTitle(title));
+            }
+            catch (ArgumentException)
+            {
+                _logger.LogError("[ERREUR] Aucune leçon trouvée avec le titre {title}.", title);
+                return NotFound();
+            }
+        }
+
+        [HttpDelete("lesson/{id}")]
+        [ProducesResponseType(typeof(LessonDTO), 200)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult DeleteLesson(int id)
+        {
+            var success = _lessonDataService.DeleteLesson(id);
+            if (success)
+            {
+                _logger.LogInformation("[INFORMATION] La leçon avec l'id {id} a été supprimé.", id);
+                return Ok(_lessonDataService.DeleteLesson(id));
+            }
+            else
+            {
+                _logger.LogError("[ERREUR] Aucune leçon trouvée avec l'id {id}.", id);
+                return NotFound();
+            }
+
+        }
+
+        [HttpPost]
+        [ProducesResponseType(typeof(LessonDTO), 201)]
+        [ProducesResponseType(typeof(string), 400)]
+        public IActionResult CreateLesson([FromBody] LessonDTO dto)
+        {
+            if (dto.Title == null || dto.LastPublisher == null)
+            {
+                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));
+        }
+
+        [HttpPut("lesson/{id}")]
+        [ProducesResponseType(typeof(LessonDTO), 200)]
+        [ProducesResponseType(typeof(string), 400)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult UpdateLesson(int id, [FromBody] LessonDTO lessonDTO)
+        {
+            if (id != lessonDTO.Id)
+            {
+                _logger.LogError("[ERREUR] Problème ID - La mise à jour de la leçon avec l'id {id} a échouée.", id);
+                return BadRequest();
+            }
+            if (!ModelState.IsValid)
+            {
+                _logger.LogError("[ERREUR] Problème controlleur - La mise à jour de la leçon avec l'id {id} a échouée.", id);
+                return BadRequest();
+            }
+            if (lessonDTO != null)
+            {
+                _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));
+            }
+            _logger.LogError("[ERREUR] Aucune leçon trouvée avec l'id {id}.", id);
+            return NotFound();
+        }
+    }
+}

API_SQLuedo/API/Controllers/ParagraphsController.cs

@@ -0,0 +1,130 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Dto;
+using Model.OrderCriteria;
+using Shared;
+using Asp.Versioning;
+
+namespace API.Controllers
+{
+    [Route("api/v{version:apiVersion}/[controller]")]
+    [Authorize]
+    [ApiVersion("1.0")]
+    [ApiController]
+    public class ParagraphsController : Controller
+    {
+        private IParagraphService<ParagraphDTO> _paragraphDataService;
+
+        private readonly ILogger<ParagraphsController> _logger;
+
+        public ParagraphsController(IParagraphService<ParagraphDTO> paragraphDataService, ILogger<ParagraphsController> logger)
+        {
+            _paragraphDataService = paragraphDataService;
+            _logger = logger;
+        }
+
+        [HttpGet("paragraphs/{page}/{number}/{orderCriteria}")]
+        [ProducesResponseType(typeof(ParagraphDTO), 200)]
+        [ProducesResponseType(typeof(string), 204)]
+        public IActionResult GetParagraphs(int page, int number, ParagraphOrderCriteria orderCriteria) 
+        {
+            var nbParagraph = ( _paragraphDataService.GetParagraphs(page, number, orderCriteria)).ToList().Count();
+            if(nbParagraph == 0) 
+            {
+                _logger.LogError("[ERREUR] Aucun paragraphe trouvé.");
+                return StatusCode(204);
+            }
+            _logger.LogInformation("[INFORMATION] {nb} Paragraphe(s) trouvé(s)", nbParagraph);
+            return Ok(_paragraphDataService.GetParagraphs(page, number, orderCriteria));
+        }
+
+        [HttpGet("paragraph/{id:int}")]
+        [ProducesResponseType(typeof(ParagraphDTO), 200)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult GetParagraphById(int id)
+        {
+            try
+            {
+                _logger.LogInformation("[INFORMATION] Le paragraphe avec l'id {id} a été trouvé.", id);
+                return Ok(_paragraphDataService.GetParagraphById(id));
+            } catch (ArgumentException) 
+            {
+                _logger.LogError("[ERREUR] Aucun paragraphe trouvé avec l'id {id}.", id);
+                return NotFound();
+            }
+        }
+
+        [HttpGet("paragraph/{title:alpha}")]
+        [ProducesResponseType(typeof(ParagraphDTO), 200)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult GetParagraphByTitle(string title)
+        {
+            try
+            {
+                _logger.LogInformation("[INFORMATION] Le paragraphe avec le titre {title} a été trouvé.", title);
+                return Ok(_paragraphDataService.GetParagraphByTitle(title));
+            }catch (ArgumentException) 
+            {
+                _logger.LogError("[ERREUR] Aucun paragraphe trouvé avec le titre {title}.", title);
+                return NotFound();
+            }
+            
+        }
+
+        [HttpDelete("paragraph/{id}")]
+        [ProducesResponseType(typeof(ParagraphDTO), 200)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult DeleteParagraph(int id)
+        {
+            var success = _paragraphDataService.DeleteParagraph(id);
+            if(success)
+            {
+                _logger.LogInformation("[INFORMATION] Le paragraphe avec l'id {id} a été supprimé.", id);
+                return Ok(_paragraphDataService.DeleteParagraph(id));
+            } else
+            {
+                _logger.LogError("[ERREUR] Aucun paragraphe trouvé avec l'id {id}.", id);
+                return NotFound();    
+            }
+            
+        }
+
+        [HttpPost]
+        [ProducesResponseType(typeof(ParagraphDTO), 201)]
+        [ProducesResponseType(typeof(string), 400)]
+        public IActionResult CreateParagraph([FromBody] ParagraphDTO dto)
+        {
+            if (dto.Title == null || dto.Content == null || dto.Info == null || dto.Query == null || dto.Comment == null)
+            {
+                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));
+        }
+
+        [HttpPut("paragraph/{id}")]
+        [ProducesResponseType(typeof(ParagraphDTO), 200)]
+        [ProducesResponseType(typeof(string), 400)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult UpdateParagraph(int id, [FromBody] ParagraphDTO paragraphDTO)
+        {
+            if(id !=  paragraphDTO.Id)
+            {
+                _logger.LogError("[ERREUR] Problème ID - La mise à jour du paragraphe avec l'id {id} a échouée.", id);
+                return BadRequest();
+            }
+            if(!ModelState.IsValid)
+            {
+                _logger.LogError("[ERREUR] Problème controlleur - La mise à jour du paragraphe avec l'id {id} a échouée.", id);
+                return BadRequest();
+            }
+            if(paragraphDTO != null) 
+            {
+                _logger.LogInformation("[INFORMATION] La mise à jour du paragraphe avec l'id {id} a été effectuée", id);
+                return Ok(_paragraphDataService.UpdateParagraph(id, paragraphDTO));
+            }
+            _logger.LogError("[ERREUR] Aucun paragraphe trouvé avec l'id {id}.", id);
+            return NotFound(); 
+        }
+    }
+}

API_SQLuedo/API/Controllers/SuccessesController.cs

@@ -0,0 +1,130 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Dto;
+using Model.OrderCriteria;
+using Shared;
+using Asp.Versioning;
+
+namespace API.Controllers
+{
+    [Route("api/v{version:apiVersion}/[controller]")]
+    [Authorize]
+    [ApiVersion("1.0")]
+    [ApiController]
+    public class SuccessesController : Controller
+    {
+        private ISuccessService<SuccessDTO> _successDataService;
+
+        private readonly ILogger<SuccessesController> _logger;
+
+        public SuccessesController(ISuccessService<SuccessDTO> successDataService, ILogger<SuccessesController> logger)
+        {
+            _successDataService = successDataService;
+            _logger = logger;
+        }
+
+        [HttpGet("successes/{page}/{number}/{orderCriteria}")]
+        [ProducesResponseType(typeof(SuccessDTO), 200)]
+        [ProducesResponseType(typeof(string), 204)]
+        public IActionResult GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria) 
+        {
+            var nbUser = (_successDataService.GetSuccesses(page, number, orderCriteria)).ToList().Count();
+            if(nbUser == 0) 
+            {
+                _logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
+                return StatusCode(204);
+            }
+            _logger.LogInformation("[INFORMATION] {nb} Utilisateur(s) trouvé(s)", nbUser);
+            return Ok(_successDataService.GetSuccesses(page, number, orderCriteria));
+        }
+
+        [HttpGet("success/user/{id:int}")]
+        [ProducesResponseType(typeof(SuccessDTO), 200)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult GetSuccessByUserId(int userId)
+        {
+            try
+            {
+                _logger.LogInformation("[INFORMATION] Le succès avec l'id de l'utilisateur {id} a été trouvé.", userId);
+                return Ok(_successDataService.GetSuccessByUserId(userId));
+            } catch (ArgumentException) 
+            {
+                _logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id de l'utilisateur {id}.", userId);
+                return NotFound();
+            }
+        }
+
+        [HttpGet("success/inquiry/{inquiryId:int}")]
+        [ProducesResponseType(typeof(SuccessDTO), 200)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult GetSuccessByInquiryId(int inquiryId)
+        {
+            try
+            {
+                _logger.LogInformation("[INFORMATION] Utilisateur avec l'id de l'enquête {inquiryId} a été trouvé.", inquiryId);
+                return Ok(_successDataService.GetSuccessByInquiryId(inquiryId));
+            }catch (ArgumentException) 
+            {
+                _logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id de l'enquête {inquiryId}.", inquiryId);
+                return NotFound();
+            }
+            
+        }
+
+        [HttpDelete("success/{id}")]
+        [ProducesResponseType(typeof(SuccessDTO), 200)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult DeleteSuccess(int id)
+        {
+            var success = _successDataService.DeleteSuccess(id);
+            if(success)
+            {
+                _logger.LogInformation("[INFORMATION] Le succès avec l'id {id} a été supprimé.", id);
+                return Ok(_successDataService.DeleteSuccess(id));
+            } else
+            {
+                _logger.LogError("[ERREUR] Aucun succès trouvé avec l'id {id}.", id);
+                return NotFound();    
+            }
+            
+        }
+
+        [HttpPost]
+        [ProducesResponseType(typeof(SuccessDTO), 201)]
+        [ProducesResponseType(typeof(string), 400)]
+        public IActionResult CreateSuccess([FromBody] SuccessDTO dto)
+        {
+            /*if (dto.UserId == null || dto.InquiryId == null)
+            {
+                return BadRequest();
+            }*/
+            _logger.LogInformation("[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}")]
+        [ProducesResponseType(typeof(SuccessDTO), 200)]
+        [ProducesResponseType(typeof(string), 400)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult UpdateSuccess(int id, [FromBody] SuccessDTO successDTO)
+        {
+            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);
+                return BadRequest();
+            }
+            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);
+                return BadRequest();
+            }
+            if(successDTO != null) 
+            {
+                _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));
+            }
+            _logger.LogError("[ERREUR] Aucun succès trouvé avec l'id de l'utilisateur {id}.", id);
+            return NotFound(); 
+        }
+    }
+}

API_SQLuedo/API/Controllers/UserController.cs

@@ -3,6 +3,7 @@ using Asp.Versioning;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Shared;
+using Model.OrderCriteria;
 
 namespace API.Controllers
 {
@@ -10,14 +11,14 @@ namespace API.Controllers
     [Authorize]
     [ApiVersion("1.0")]
     [ApiController]
-    public class UserController(ILogger<UserController> logger, IUserService<UserDTO> userService) : ControllerBase
+    public class UsersController(ILogger<UsersController> logger, IUserService<UserDTO> userService) : ControllerBase
     {
         [HttpGet("users/{page}/{number}")]
         [ProducesResponseType(typeof(UserDTO), 200)]
         [ProducesResponseType(typeof(string), 204)]
-        public IActionResult GetUsers(int page, int number)
+        public IActionResult GetUsers(int page, int number, UserOrderCriteria orderCriteria)
         {
-            var users = userService.GetUsers(page, number).ToList();
+            var users = userService.GetUsers(page, number, orderCriteria).ToList();
             if (users.Count == 0)
             {
                 logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
@@ -28,7 +29,7 @@ namespace API.Controllers
             return Ok(users);
         }
 
-        [HttpGet("user/id/{id}")]
+        [HttpGet("user/{id:int}")]
         [ProducesResponseType(typeof(UserDTO), 200)]
         [ProducesResponseType(typeof(string), 404)]
         public IActionResult GetUserById(int id)
@@ -45,7 +46,7 @@ namespace API.Controllers
             }
         }
 
-        [HttpGet("user/username/{username}")]
+        [HttpGet("user/{username:alpha}")]
         [ProducesResponseType(typeof(UserDTO), 200)]
         [ProducesResponseType(typeof(string), 404)]
         public IActionResult GetUserByUsername(string username)
@@ -62,7 +63,7 @@ namespace API.Controllers
             }
         }
 
-        [HttpDelete]
+        [HttpDelete("user/{id}")]
         [ProducesResponseType(typeof(UserDTO), 200)]
         [ProducesResponseType(typeof(string), 404)]
         public IActionResult DeleteUser(int id)
@@ -98,7 +99,7 @@ namespace API.Controllers
                 userService.CreateUser(dto.Username, dto.Password, dto.Email, dto.IsAdmin));
         }
 
-        [HttpPut]
+        [HttpPut("user/{id}")]
         [ProducesResponseType(typeof(UserDTO), 200)]
         [ProducesResponseType(typeof(string), 400)]
         [ProducesResponseType(typeof(string), 404)]

API_SQLuedo/API/Program.cs

@@ -20,10 +20,22 @@ builder.Services.AddControllers();
 // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
 builder.Services.AddEndpointsApiExplorer();
 builder.Services.AddSwaggerGen();
-builder.Services.AddScoped<IUserService<UserEntity>, UserDataService>();
+
-builder.Services.AddScoped<IUserService<UserDTO>, UserDataServiceApi>();
+builder.Services.AddScoped<IUserService<UserEntity>, DbDataManager.Service.UserDataService>();
-builder.Services.AddScoped<IInquiryService<InquiryEntity>, InquiryDataService>();
+builder.Services.AddScoped<IUserService<UserDTO>, Shared.UserDataService>();
-builder.Services.AddScoped<IInquiryService<InquiryDTO>, InquiryDataServiceApi>();
+
+builder.Services.AddScoped<IInquiryService<InquiryEntity>, DbDataManager.Service.InquiryDataService>();
+builder.Services.AddScoped<IInquiryService<InquiryDTO>, Shared.InquiryDataService>();
+
+builder.Services.AddScoped<IParagraphService<ParagraphEntity>, DbDataManager.Service.ParagraphDataService>();
+builder.Services.AddScoped<IParagraphService<ParagraphDTO>, Shared.ParagraphDataService>();
+
+builder.Services.AddScoped<ISuccessService<SuccessEntity>, DbDataManager.Service.SuccessDataService>();
+builder.Services.AddScoped<ISuccessService<SuccessDTO>, Shared.SuccessDataService>();
+
+builder.Services.AddScoped<ILessonService<LessonEntity>, DbDataManager.Service.LessonDataService>();
+builder.Services.AddScoped<ILessonService<LessonDTO>, Shared.LessonDataService>();
+
 builder.Services.AddDbContext<DbContext, UserDbContext>();
 builder.Services.AddDbContext<WebAPIDbContext>(options => options.UseInMemoryDatabase("appDb"));
 builder.Services.AddIdentityApiEndpoints<IdentityUser>().AddEntityFrameworkStores<WebAPIDbContext>();

API_SQLuedo/API/Service/InquiryDataServiceAPI.cs

@@ -1,19 +1,33 @@
-using Dto;
+using Entities;
-using Entities;
+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 IEnumerable<InquiryDTO> GetInquiries(int page, int number)
+    {
-    {
+        return inquiryService.CreateInquiry(title, description, isUser);
-        var inquiries = inquiryService.GetInquiries(page, number);
+    }
-        return inquiries.Select(i => i.FromEntityToDTO()).ToList();
+
-    }
+    public bool DeleteInquiry(int id)
-
+    {
-    public InquiryDTO GetInquiryById(int id) => inquiryService.GetInquiryById(id).FromEntityToDTO();
+        return inquiryService.DeleteInquiry(id);
-
+    }
-    public InquiryDTO GetInquiryByTitle(string title) => inquiryService.GetInquiryByTitle(title).FromEntityToDTO();
+
+    public IEnumerable<InquiryEntity> GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria)
+    {
+        var inquiries = inquiryService.GetInquiries(page, number, orderCriteria);
+        return inquiries.Select(i => i).ToList();
+    }
+
+    public InquiryEntity GetInquiryById(int id) => inquiryService.GetInquiryById(id);
+
+    public InquiryEntity GetInquiryByTitle(string title) => inquiryService.GetInquiryByTitle(title);
+
+    public InquiryEntity UpdateInquiry(int id, InquiryEntity inquiry)
+    {
+        return inquiryService.UpdateInquiry(id, inquiry);
+    }
 }

API_SQLuedo/API/Service/LessonDataServiceAPI.cs

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

API_SQLuedo/API/Service/ParagraphDataServiceAPI.cs

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

API_SQLuedo/API/Service/SuccessDataServiceAPI.cs

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

API_SQLuedo/API/Service/UserDataServiceAPI.cs

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

API_SQLuedo/API_SQLuedo.sln

@@ -25,6 +25,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Model", "Model\Model.csproj
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Shared", "Shared\Shared.csproj", "{9DC1D2DF-AC2B-4CF5-BB30-2FB6533BFF76}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestConsoleEf", "TestConsoleEf\TestConsoleEf.csproj", "{37378C7E-074C-4863-BFD0-60802303FEEB}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -75,6 +77,10 @@ Global
 		{9DC1D2DF-AC2B-4CF5-BB30-2FB6533BFF76}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{9DC1D2DF-AC2B-4CF5-BB30-2FB6533BFF76}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{9DC1D2DF-AC2B-4CF5-BB30-2FB6533BFF76}.Release|Any CPU.Build.0 = Release|Any CPU
+		{37378C7E-074C-4863-BFD0-60802303FEEB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{37378C7E-074C-4863-BFD0-60802303FEEB}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{37378C7E-074C-4863-BFD0-60802303FEEB}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{37378C7E-074C-4863-BFD0-60802303FEEB}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

API_SQLuedo/DbContextLib/UserDbContext.cs

@@ -8,15 +8,15 @@ namespace DbContextLib
     public class UserDbContext : IdentityDbContext<IdentityUser>
     {
         public DbSet<UserEntity> Users { get; set; }
-        public DbSet<BlackListEntity> BlackList { get; set; }
+        public DbSet<BlackListEntity> BlackLists { get; set; }
-        public DbSet<InquiryEntity> Inquiry { get; set; }
+        public DbSet<InquiryEntity> Inquiries { get; set; }
-        public DbSet<InquiryTableEntity> InquiryTable { get; set; }
+        public DbSet<InquiryTableEntity> InquiryTables { get; set; }
-        public DbSet<LessonEntity> Lesson { get; set; }
+        public DbSet<LessonEntity> Lessons { get; set; }
         public DbSet<ContentLessonEntity> ContentLessons { get; set; }
-        public DbSet<ParagraphEntity> Paragraph { get; set; }
+        public DbSet<ParagraphEntity> Paragraphs { get; set; }
         public DbSet<SolutionEntity> Solutions { get; set; }
-        public DbSet<SuccessEntity> Success { get; set; }
+        public DbSet<SuccessEntity> Successes { get; set; }
-        public DbSet<NotepadEntity> Notepad { get; set; }
+        public DbSet<NotepadEntity> Notepads { get; set; }
         public UserDbContext(DbContextOptions<UserDbContext> options) : base(options) { }
         protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
         {
@@ -30,7 +30,6 @@ namespace DbContextLib
         protected override void OnModelCreating(ModelBuilder modelBuilder)
         {
             modelBuilder.Entity<ContentLessonEntity>().HasKey(c => c.LessonId);
-            modelBuilder.Entity<ContentLessonEntity>().HasKey(c => c.LessonPartId);
             modelBuilder.Entity<SuccessEntity>().HasKey(s => s.UserId);
             modelBuilder.Entity<SuccessEntity>().HasKey(s => s.InquiryId);
             modelBuilder.Entity<InquiryEntity>().HasKey(s => s.Id);

API_SQLuedo/DbDataManager/Service/InquiryDataService.cs

@@ -1,23 +1,89 @@
-using Dto;
+using DbContextLib;
-using Entities;
+using Entities;
-using Shared;
+using Microsoft.EntityFrameworkCore;
-
+using Model.OrderCriteria;
-namespace DbDataManager.Service;
+using Shared;
-
+
-public class InquiryDataService : IInquiryService<InquiryEntity>
+namespace DbDataManager.Service;
-{
+
-    public IEnumerable<InquiryEntity> GetInquiries(int page, int number)
+public class InquiryDataService : IInquiryService<InquiryEntity>
-    {
+{
-        throw new NotImplementedException();
+    private UserDbContext DbContext { get; }
-    }
+
-
+    public InquiryDataService(UserDbContext context)
-    public InquiryEntity GetInquiryById(int id)
+    {
-    {
+        DbContext = context;
-        throw new NotImplementedException();
+        context.Database.EnsureCreated();
-    }
+    }
-
+
-    public InquiryEntity GetInquiryByTitle(string title)
+    public InquiryEntity GetInquiryById(int id)
-    {
+    {
-        throw new NotImplementedException();
+        var inquiryEntity = DbContext.Inquiries.FirstOrDefault(u => u.Id == id);
-    }
+        if (inquiryEntity == null)
+        {
+            throw new ArgumentException("Impossible de trouver l'enquête", nameof(id));
+        }
+
+        return inquiryEntity;
+    }
+
+    public InquiryEntity GetInquiryByTitle(string title)
+    {
+        var inquiryEntity = DbContext.Inquiries.FirstOrDefault(u => u.Title == title);
+        if (inquiryEntity == null)
+        {
+            throw new ArgumentException("Impossible de trouver l'enquête", nameof(title));
+        }
+
+        return inquiryEntity;
+    }
+
+    public IEnumerable<InquiryEntity> GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria)
+    {
+        return DbContext.Inquiries.Skip((page - 1) * number).Take(number).ToList()
+            .Select(u => u);
+    }
+
+    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 InquiryEntity UpdateInquiry(int id, InquiryEntity 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;
+        // 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,
+            Description = description,
+            IsUser = isUser,
+        };
+        DbContext.Inquiries.Add(newInquiryEntity);
+        DbContext.SaveChangesAsync();
+        return newInquiryEntity;
+    }
 }

API_SQLuedo/DbDataManager/Service/LessonDataService.cs

@@ -0,0 +1,89 @@
+using DbContextLib;
+using Entities;
+using Microsoft.EntityFrameworkCore;
+using Model.OrderCriteria;
+using Shared;
+
+namespace DbDataManager.Service;
+
+public class LessonDataService : ILessonService<LessonEntity>
+{
+    private UserDbContext DbContext { get; set; }
+
+    public LessonDataService(UserDbContext context)
+    {
+        DbContext = context;
+        context.Database.EnsureCreated();
+    }
+
+    public LessonEntity 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;
+    }
+
+    public LessonEntity 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;
+    }
+
+    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)
+    {
+        var lessonEntity = DbContext.Lessons.FirstOrDefault(u => u.Id == id);
+        if (lessonEntity == null)
+        {
+            return false;
+        }
+
+        DbContext.Lessons.Remove(lessonEntity);
+        DbContext.SaveChangesAsync();
+        return true;
+    }
+
+    public LessonEntity UpdateLesson(int id, LessonEntity lesson)
+    {
+        var updatingLesson = DbContext.Lessons.FirstOrDefault(u => u.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;
+        // Permet d'indiquer en Db que l'entité a été modifiée.
+        DbContext.Entry(updatingLesson).State = EntityState.Modified;
+        DbContext.SaveChangesAsync();
+        return updatingLesson;
+    }
+
+    public LessonEntity CreateLesson(string title, string lastPublisher, DateOnly? lastEdit)
+    {
+        var newLessonEntity = new LessonEntity()
+        {
+            Title = title,
+            LastPublisher = lastPublisher,
+            LastEdit = lastEdit,
+        };
+        DbContext.Lessons.Add(newLessonEntity);
+        DbContext.SaveChangesAsync();
+        return newLessonEntity;
+    }
+}

API_SQLuedo/DbDataManager/Service/ParagraphDataService.cs

@@ -0,0 +1,95 @@
+using DbContextLib;
+using Entities;
+using Microsoft.EntityFrameworkCore;
+using Model.OrderCriteria;
+using Shared;
+
+namespace DbDataManager.Service;
+
+public class ParagraphDataService : IParagraphService<ParagraphEntity>
+{
+    private UserDbContext DbContext { get; set; }
+
+    public ParagraphDataService(UserDbContext context)
+    {
+        DbContext = context;
+        context.Database.EnsureCreated();
+    }
+
+    public ParagraphEntity 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;
+    }
+
+    public ParagraphEntity 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;
+    }
+
+    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)
+    {
+        var paragraphEntity = DbContext.Paragraphs.FirstOrDefault(u => u.Id == id);
+        if (paragraphEntity == null)
+        {
+            return false;
+        }
+
+        DbContext.Paragraphs.Remove(paragraphEntity);
+        DbContext.SaveChangesAsync();
+        return true;
+    }
+
+    public ParagraphEntity UpdateParagraph(int id, ParagraphEntity paragraph)
+    {
+        var updatingParagraph = DbContext.Paragraphs.FirstOrDefault(u => u.Id == id);
+        if (updatingParagraph == null)
+        {
+            throw new ArgumentException("Impossible de trouver le paragraphe", nameof(id));
+        }
+
+        updatingParagraph.Title = paragraph.Title;
+        updatingParagraph.Content = paragraph.Content;
+        updatingParagraph.Info = paragraph.Info;
+        updatingParagraph.Query = paragraph.Query;
+        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();
+        return updatingParagraph;
+    }
+
+    public ParagraphEntity CreateParagraph(string title, string content, string info, string query, string comment, int lessonId)
+    {
+        var newParagraphEntity = new ParagraphEntity()
+        {
+            Title = title,
+            Content = content,
+            Info = info,
+            Query = query,
+            Comment = comment,
+            LessonId = lessonId
+        };
+        DbContext.Paragraphs.Add(newParagraphEntity);
+        DbContext.SaveChangesAsync();
+        return newParagraphEntity;
+    }
+}

API_SQLuedo/DbDataManager/Service/SuccessDataService.cs

@@ -0,0 +1,89 @@
+using DbContextLib;
+using Entities;
+using Microsoft.EntityFrameworkCore;
+using Model.OrderCriteria;
+using Shared;
+
+namespace DbDataManager.Service;
+
+public class SuccessDataService : ISuccessService<SuccessEntity>
+{
+    private UserDbContext DbContext { get; set; }
+
+    public SuccessDataService(UserDbContext context)
+    {
+        DbContext = context;
+        context.Database.EnsureCreated();
+    }
+
+    public SuccessEntity GetSuccessByUserId(int id)
+    {
+        var successEntity = DbContext.Successes.FirstOrDefault(u => u.UserId == id);
+        if (successEntity == null)
+        {
+            throw new ArgumentException("Impossible de trouver le succès avec l'user id", nameof(id));
+        }
+
+        return successEntity;
+    }
+
+    public SuccessEntity GetSuccessByInquiryId(int id)
+    {
+        var successEntity = DbContext.Successes.FirstOrDefault(u => u.InquiryId == id);
+        if (successEntity == null)
+        {
+            throw new ArgumentException("Impossible de trouver le succès avec l'inquiry id", nameof(id));
+        }
+
+        return successEntity;
+    }
+
+    public IEnumerable<SuccessEntity> GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria)
+    {
+        return DbContext.Successes.Skip((page - 1) * number).Take(number).ToList()
+            .Select(u => u);
+    }
+
+    public bool DeleteSuccess(int id)
+    {
+        var userEntity = DbContext.Successes.FirstOrDefault(u => u.UserId == id);
+        if (userEntity == null)
+        {
+            return false;
+        }
+
+        DbContext.Successes.Remove(userEntity);
+        DbContext.SaveChangesAsync();
+        return true;
+    }
+
+    public SuccessEntity UpdateSuccess(int id, SuccessEntity success)
+    {
+        var updatingSuccess = DbContext.Successes.FirstOrDefault(u => u.UserId == id);
+        if (updatingSuccess == null)
+        {
+            throw new ArgumentException("Impossible de trouver le succès avec l'user id", nameof(id));
+        }
+
+        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();
+        return updatingSuccess;
+    }
+
+    public SuccessEntity CreateSuccess(int userId, int inquiryId, bool isFinished)
+    {
+        var newSuccessEntity = new SuccessEntity()
+        {
+            UserId = userId,
+            InquiryId = inquiryId,
+            IsFinished = isFinished,
+        };
+        DbContext.Successes.Add(newSuccessEntity);
+        DbContext.SaveChangesAsync();
+        return newSuccessEntity;
+    }
+}

API_SQLuedo/DbDataManager/Service/UserDataService.cs

@@ -1,12 +1,14 @@
 using DbContextLib;
 using Entities;
 using Microsoft.EntityFrameworkCore;
+using Model.OrderCriteria;
 using Shared;
 
 namespace DbDataManager.Service;
 
 public class UserDataService : IUserService<UserEntity>
 {
+
     private UserDbContext DbContext { get; set; }
 
     public UserDataService(UserDbContext context)
@@ -37,7 +39,7 @@ public class UserDataService : IUserService<UserEntity>
         return userEntity;
     }
 
-    public IEnumerable<UserEntity> GetUsers(int page, int number)
+    public IEnumerable<UserEntity> GetUsers(int page, int number, UserOrderCriteria orderCriteria)
     {
         return DbContext.Users.Skip((page - 1) * number).Take(number).ToList()
             .Select(u => u);

API_SQLuedo/Dto/BlackListDTO.cs

@@ -1,14 +1,13 @@
-namespace Dto
+namespace Dto;
+
+public class BlackListDTO
 {
-    public class BlackListDTO
+    public string Email { get; set; }
-    {
+    public DateOnly ExpirationDate { get; set; }
-        public string Email { get; set; }
-        public DateOnly ExpirationDate { get; set; }
 
-        public BlackListDTO(string email, DateOnly expirationDate)
+    public BlackListDTO(string email, DateOnly expirationDate)
-        {
+    {
-            Email = email;
+        Email = email;
-            ExpirationDate = expirationDate;
+        ExpirationDate = expirationDate;
-        }
     }
-}
+}

API_SQLuedo/Dto/ContentLessonDTO.cs

@@ -1,14 +1,28 @@
-namespace Dto
+namespace Dto;
+
+public abstract class ContentLessonDTO
 {
-    public class ContentLessonDTO
+    public int Id { get; set; }
-    {
+    public string ContentContent { get; set; }
-        public int LessonId { get; set; }
+    public string ContentTitle { get; set; }
-        public int LessonPartId { get; set; }
+    public int LessonId { get; set; }
 
-        public ContentLessonDTO(int lessonId, int lessonPartId)
+    protected ContentLessonDTO(int id, string contentContent, string contentTitle, int lessonId)
-        {
+    {
-            LessonId = lessonId;
+        Id = id;
-            LessonPartId = lessonPartId;
+        ContentContent = contentContent;
-        }
+        ContentTitle = contentTitle;
+        LessonId = lessonId;
     }
+
+    protected ContentLessonDTO(string contentContent, string contentTitle, int lessonId)
+    {
+        ContentContent = contentContent;
+        ContentTitle = contentTitle;
+        LessonId = lessonId;
+    }
+
+    protected ContentLessonDTO()
+    {
+    }
 }

API_SQLuedo/Dto/InquiryDTO.cs

@@ -1,26 +1,27 @@
-namespace Dto
+namespace Dto;
+
+public class InquiryDTO
 {
-    public class InquiryDTO
+    public int Id { get;}
-    {
-        public int Id { get;}
 
-        public string Title { get; set; }
+    public string Title { get; set; }
 
-        public string Description { get; set; }
+    public string Description { get; set; }
 
-        public bool IsUser { get; set; }
+    public bool IsUser { get; set; }
 
-        public int Database { get; set; }
+    public InquiryDTO(int id, string title, string description, bool isUser)
-        public int InquiryTable { get; set; }
+    {
+        Id = id;
+        Title = title;
+        Description = description;
+        IsUser = isUser;
+    }
 
-        public InquiryDTO(int id, string title, string description, bool isUser, int database, int inquiryTable)
+    public InquiryDTO(string title, string description, bool isUser)
-        {
+    {
-            Id = id;
+        Title = title;
-            Title = title;
+        Description = description;
-            Description = description;
+        IsUser = isUser;
-            IsUser = isUser;
-            Database = database;
-            InquiryTable = inquiryTable;
-        }
     }
-}
+}

API_SQLuedo/Dto/InquiryTableDTO.cs

@@ -1,19 +1,18 @@
-namespace Dto
+namespace Dto;
+
+public class InquiryTableDTO
 {
-    public class InquiryTableDTO
-    {
 
-        public int OwnerId { get; set; }
+    public int OwnerId { get; set; }
-        public string DatabaseName { get; set; }
+    public string DatabaseName { get; set; }
-        public string ConnectionInfo { get; set; }
+    public string ConnectionInfo { get; set; }
 
-        public InquiryTableDTO() { }
+    public InquiryTableDTO() { }
 
-        public InquiryTableDTO(int ownerId, string databaseName, string connectionInfo)
+    public InquiryTableDTO(int ownerId, string databaseName, string connectionInfo)
-        {
+    {
-            OwnerId = ownerId;
+        OwnerId = ownerId;
-            DatabaseName = databaseName;
+        DatabaseName = databaseName;
-            ConnectionInfo = connectionInfo;
+        ConnectionInfo = connectionInfo;
-        }
     }
-}
+}

API_SQLuedo/Dto/LessonDTO.cs

@@ -1,26 +1,26 @@
-namespace Dto
+namespace Dto;
+
+public class LessonDTO
 {
-    public class LessonDTO
+    public int Id { get; }
-    {
+    public string? Title { get; set; }
-        public int Id { get; }
+    public string? LastPublisher { get; set; }
-        public string? Title { get; set; }
+    public DateOnly? LastEdit { get; set; }
-        public string? LastPublisher { get; set; }
+    public ICollection<ContentLessonDTO> Content { get; set; } = new List<ContentLessonDTO>();
-        public DateOnly? LastEdit { get; set; }
 
-        public LessonDTO() { }
+    public LessonDTO() { }
-        public LessonDTO(int id, string title, string lastPublisher, DateOnly? lastEdit)
+    public LessonDTO(int id, string title, string lastPublisher, DateOnly? lastEdit)
-        {
+    {
-            Id = id;
+        Id = id;
-            Title = title;
+        Title = title;
-            LastPublisher = lastPublisher;
+        LastPublisher = lastPublisher;
-            LastEdit = lastEdit;
+        LastEdit = lastEdit;
-        }
+    }
 
-        public LessonDTO(string title, string lastPublisher, DateOnly? lastEdit)
+    public LessonDTO(string title, string lastPublisher, DateOnly? lastEdit)
-        {
+    {
-            Title = title;
+        Title = title;
-            LastPublisher = lastPublisher;
+        LastPublisher = lastPublisher;
-            LastEdit = lastEdit;
+        LastEdit = lastEdit;
-        }
     }
-}
+}

API_SQLuedo/Dto/NotepadDTO.cs

@@ -1,26 +1,25 @@
-namespace Dto
+namespace Dto;
+
+public class NotepadDTO
 {
-    public class NotepadDTO
+    public int Id { get; set; }
-    {
+    public int UserId { get; set; }
-        public int Id { get; set; }
+    public int InquiryId { get; set; }
-        public int UserId { get; set; }
+    public string Notes { get; set; }
-        public int InquiryId { get; set; }
-        public string Notes { get; set; }
 
-        public NotepadDTO() { }
+    public NotepadDTO() { }
 
-        public NotepadDTO(int id, int userId, int inquiryId, string notes)
+    public NotepadDTO(int id, int userId, int inquiryId, string notes)
-        {
+    {
-            Id = id;
+        Id = id;
-            UserId = userId;
+        UserId = userId;
-            InquiryId = inquiryId;
+        InquiryId = inquiryId;
-            Notes = notes;
+        Notes = notes;
-        }
+    }
-        public NotepadDTO(int userId, int inquiryId, string notes)
+    public NotepadDTO(int userId, int inquiryId, string notes)
-        {
+    {
-            UserId = userId;
+        UserId = userId;
-            InquiryId = inquiryId;
+        InquiryId = inquiryId;
-            Notes = notes;
+        Notes = notes;
-        }
     }
-}
+}

API_SQLuedo/Dto/ParagraphDTO.cs

@@ -1,32 +1,37 @@
-namespace Dto
+namespace Dto;
-{
-    public class ParagraphDTO
-    {
-        public int Id { get; }
-        public string Title { get; set; }
-        public string Content { get; set; }
-        public string Info { get; set; }
-        public string Query { get; set; }
-        public string Comment { get; set; }
 
-        public ParagraphDTO() { }
+public class ParagraphDTO : ContentLessonDTO
+{
+    public string Title { get; set; }
+    public string Content { get; set; }
+    public string Info { get; set; }
+    public string Query { get; set; }
+    public string Comment { get; set; }
 
-        public ParagraphDTO(int id, string title, string content, string info, string query, string comment)
+    public ParagraphDTO(string title, string content, string info, string query, string comment, int lessonId) :
-        {
+        base(content,
-            Id = id;
+            title, lessonId)
-            Title = title;
+    {
-            Content = content;
+        Title = title;
-            Info = info;
+        Content = content;
-            Query = query;
+        Info = info;
-            Comment = comment;
+        Query = query;
-        }
+        Comment = comment;
-        public ParagraphDTO(string title, string content, string info, string query, string comment)
-        {
-            Title = title;
-            Content = content;
-            Info = info;
-            Query = query;
-            Comment = comment;
-        }
     }
-}
+
+    public ParagraphDTO(int id, string title, string content, string info, string query, string comment, int lessonId) : 
+        base(id, content,
+            title, lessonId)
+    {
+        Id = id;
+        Title = title;
+        Content = content;
+        Info = info;
+        Query = query;
+        Comment = comment;
+    }
+
+    public ParagraphDTO() : base()
+    {
+    }
+}

API_SQLuedo/Dto/SolutionDTO.cs

@@ -1,30 +1,29 @@
-namespace Dto
+namespace Dto;
+
+public class SolutionDTO
 {
-    public class SolutionDTO
+    public int OwnerId { get; set; }
+    public string MurdererFirstName { get; set; }
+    public string MurdererLastName { get; set; }
+    public string MurderPlace { get; set; }
+    public string MurderWeapon { get; set; }
+    public string Explanation { get; set; }
+    public SolutionDTO() { }
+    public SolutionDTO(int ownerId, string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon, string explanation)
     {
-        public int OwnerId { get; set; }
+        OwnerId = ownerId;
-        public string MurdererFirstName { get; set; }
+        MurdererFirstName = murdererFirstName;
-        public string MurdererLastName { get; set; }
+        MurdererLastName = murdererLastName;
-        public string MurderPlace { get; set; }
+        MurderPlace = murderPlace;
-        public string MurderWeapon { get; set; }
+        MurderWeapon = murderWeapon;
-        public string Explanation { get; set; }
+        Explanation = explanation;
-        public SolutionDTO() { }
-        public SolutionDTO(int ownerId, string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon, string explanation)
-        {
-            OwnerId = ownerId;
-            MurdererFirstName = murdererFirstName;
-            MurdererLastName = murdererLastName;
-            MurderPlace = murderPlace;
-            MurderWeapon = murderWeapon;
-            Explanation = explanation;
-        }
-        public SolutionDTO(string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon, string explanation)
-        {
-            MurdererFirstName = murdererFirstName;
-            MurdererLastName = murdererLastName;
-            MurderPlace = murderPlace;
-            MurderWeapon = murderWeapon;
-            Explanation = explanation;
-        }
     }
-}
+    public SolutionDTO(string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon, string explanation)
+    {
+        MurdererFirstName = murdererFirstName;
+        MurdererLastName = murdererLastName;
+        MurderPlace = murderPlace;
+        MurderWeapon = murderWeapon;
+        Explanation = explanation;
+    }
+}

API_SQLuedo/Dto/SuccessDTO.cs

@@ -1,18 +1,17 @@
-namespace Dto
+namespace Dto;
+
+public class SuccessDTO
 {
-    public class SuccessDTO
+    public int UserId { get; set; }
-    {
+    public int InquiryId { get; set; }
-        public int UserId { get; set; }
+    public bool IsFinished { get; set; }
-        public int InquiryId { get; set; }
-        public bool IsFinished { get; set; }
 
-        public SuccessDTO() { }
+    public SuccessDTO() { }
 
-        public SuccessDTO(int userId, int inquiryId, bool isFinished)
+    public SuccessDTO(int userId, int inquiryId, bool isFinished)
-        {
+    {
-            UserId = userId;
+        UserId = userId;
-            InquiryId = inquiryId;
+        InquiryId = inquiryId;
-            IsFinished = isFinished;
+        IsFinished = isFinished;
-        }
     }
-}
+}

API_SQLuedo/Dto/UserDTO.cs

@@ -8,23 +8,23 @@
         public string Email { 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;
-            Username = username;
+        Username = username;
-            Password = password;
+        Password = password;
-            Email = email;
+        Email = email;
-            IsAdmin = isAdmin;
+        IsAdmin = isAdmin;
-        }
+    }
 
-        public UserDTO(string username, string password, string email, bool isAdmin)
+    public UserDTO(string username, string password, string email, bool isAdmin)
-        {
+    {
-            Username = username;
+        Username = username;
-            Password = password;
+        Password = password;
-            Email = email;
+        Email = email;
-            IsAdmin = isAdmin;
+        IsAdmin = isAdmin;
-        }
+    }
 
         public override string ToString()
         {

API_SQLuedo/EntityFramework/ContentLessonEntity.cs

@@ -3,22 +3,37 @@
 namespace Entities;
 
 [Table("ContentLesson")]
-public class ContentLessonEntity
+public abstract class ContentLessonEntity
 {
-    [ForeignKey(nameof(Lesson))]
+    public int Id { get; set; }
-    public int LessonId { get; set; }
+    public string ContentContent { get; set; }
-    public LessonEntity Lesson { get; set; }
+    public string ContentTitle { get; set; }
+    [ForeignKey(nameof(Lesson))] public int LessonId { get; set; }
+    public LessonEntity Lesson { get; set; } = null!;
 
-    [ForeignKey(nameof(Paragraph))]
+    protected ContentLessonEntity()
-    public int LessonPartId { get; set; }
+    {
-    public ParagraphEntity Paragraph { get; set; }
+    }
 
-    public ContentLessonEntity(){}
+    protected ContentLessonEntity(int id, string contentContent, string contentTitle)
-    public ContentLessonEntity(int lessonId, LessonEntity lesson, int lessonPartId, ParagraphEntity paragraph)
     {
+        Id = id;
+        ContentContent = contentContent;
+        ContentTitle = contentTitle;
+    }
+
+
+    protected ContentLessonEntity(int id, int lessonId, string contentContent, string contentTitle)
+    {
+        Id = id;
         LessonId = lessonId;
-        Lesson = lesson;
+        ContentContent = contentContent;
-        LessonPartId = lessonPartId;
+        ContentTitle = contentTitle;
-        Paragraph = paragraph;
+    }
+
+    protected ContentLessonEntity(string contentContent, string contentTitle)
+    {
+        ContentContent = contentContent;
+        ContentTitle = contentTitle;
     }
 }

API_SQLuedo/EntityFramework/InquiryEntity.cs

@@ -1,39 +1,37 @@
 using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
 
-namespace Entities
+namespace Entities;
+
+public class InquiryEntity
 {
-    public class InquiryEntity
+    [Key] public int Id { get; }
+    public string Title { get; set; }
+    public string Description { get; set; }
+    public bool IsUser { get; set; }
+
+    public InquiryEntity()
     {
-        public int Id { get; set; }
+    }
-        public string Title { get; set; }
-        public string Description { get; set; }
-        public bool IsUser { get; set; }
-        public InquiryTableEntity Database { get; set; }
-        public SolutionEntity InquiryTable { get; set; }
-        public InquiryEntity() { }
 
-        public InquiryEntity(int id)
+    public InquiryEntity(int id)
-        {
+    {
-            Id = id;
+        Id = id;
-        }
+    }
-        public InquiryEntity(int id, string title, string description, bool isUser, InquiryTableEntity database, SolutionEntity inquiryTable)
-        {
-            Id = id;
-            Title = title;
-            Description = description;
-            IsUser = isUser;
-            Database = database;
-            InquiryTable = inquiryTable;
-        }
 
-        public InquiryEntity(string title, string description, bool isUser, InquiryTableEntity database, SolutionEntity inquiryTable)
+    public InquiryEntity(string title, string description, bool isUser)
-        {
+    {
-            Id = 0;
+        Id = 0;
-            Title = title;
+        Title = title;
-            Description = description;
+        Description = description;
-            IsUser = isUser;
+        IsUser = isUser;
-            Database = database;
+    }
-            InquiryTable = inquiryTable;
+
-        }
+    public InquiryEntity(int id, string title, string description, bool isUser)
+    {
+        Id = id;
+        Title = title;
+        Description = description;
+        IsUser = isUser;
     }
-}
+}

API_SQLuedo/EntityFramework/LessonEntity.cs

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

API_SQLuedo/EntityFramework/ParagraphEntity.cs

@@ -3,33 +3,34 @@
 namespace Entities;
 
 [Table("Paragraph")]
-public class ParagraphEntity
+public class ParagraphEntity : ContentLessonEntity
 {
-    public int Id { get; set; }
+    // ID
+    // ContentContent
+    // ContentTitle
+    // LessonId
     public string Title { get; set; }
     public string Content { get; set; }
     public string Info { get; set; }
     public string Query { get; set; }
     public string Comment { get; set; }
 
-    public ParagraphEntity() { }
+    public ParagraphEntity()
-
-
-    public ParagraphEntity(int id)
     {
-        Id = id;
     }
 
-    public ParagraphEntity(int id, string title, string content, string info, string query, string comment)
+    public ParagraphEntity(int id, string title, string content, string info, string query,
+        string comment, int idLesson) : base(id, idLesson, content, title)
     {
-        Id = id;
         Title = title;
         Content = content;
         Info = info;
         Query = query;
         Comment = comment;
     }
-    public ParagraphEntity(string title, string content, string info, string query, string comment)
+
+    public ParagraphEntity(string title, string content, string info, string query, string comment) : base(content,
+        title)
     {
         Title = title;
         Content = content;

API_SQLuedo/EntityFramework/SolutionEntity.cs

@@ -16,13 +16,13 @@ public class SolutionEntity
     public string? MurdererLastName { get; set; }
     public string? MurderPlace { get; set; }
     public string? MurderWeapon { get; set; }
-    public string? Explanation { get; set; }
+    public string? Explaination { get; set; }
     public SolutionEntity() { }
     public SolutionEntity(int ownerId)
     {
         OwnerId = ownerId;
     }
-    public SolutionEntity(int ownerId, InquiryEntity? owner, string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon, string explanation)
+    public SolutionEntity(int ownerId, InquiryEntity? owner, string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon, string explaination)
     {
         OwnerId = ownerId;
         Owner = owner;
@@ -30,15 +30,24 @@ public class SolutionEntity
         MurdererLastName = murdererLastName;
         MurderPlace = murderPlace;
         MurderWeapon = murderWeapon;
-        Explanation = explanation;
+        Explaination = explaination;
     }
-    public SolutionEntity(InquiryEntity? owner, string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon, string explanation)
+    public SolutionEntity(InquiryEntity? owner, string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon, string explaination)
     {
         Owner = owner;
         MurdererFirstName = murdererFirstName;
         MurdererLastName = murdererLastName;
         MurderPlace = murderPlace;
         MurderWeapon = murderWeapon;
-        Explanation = explanation;
+        Explaination = explaination;
+    }
+    public SolutionEntity(int ownerId, string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon, string explanation)
+    {
+        OwnerId = ownerId;
+        MurdererFirstName = murdererFirstName;
+        MurdererLastName = murdererLastName;
+        MurderPlace = murderPlace;
+        MurderWeapon = murderWeapon;
+        Explaination = explanation;
     }
 }

API_SQLuedo/Model/BlackList.cs

@@ -1,14 +1,16 @@
-namespace ModelToEntities.Business
+namespace Model;
+
+public class BlackList
 {
-    public class BlackList
+    public string Email { get; set; }
-    {
+    public DateOnly ExpirationDate { get; set; }
-        public string Email { get; set; }
-        public DateOnly ExpirationDate { get; set; }
 
-        public BlackList(string email, DateOnly expirationDate)
+    public BlackList(string email, DateOnly expirationDate)
-        {
+    {
-            Email = email;
+        if (email is null or "")
-            ExpirationDate = expirationDate;
+            throw new ArgumentException("Email cannot be null or empty");
-        }
+        ArgumentOutOfRangeException.ThrowIfLessThan(expirationDate, DateOnly.FromDateTime(DateTime.Now));
+        Email = email;
+        ExpirationDate = expirationDate;
     }
-}
+}

API_SQLuedo/Model/ContentLesson.cs

@@ -1,14 +1,24 @@
-namespace ModelToEntities.Business
+namespace Model;
+
+public abstract class ContentLesson
 {
-    public  class ContentLesson
+    public int Id { get; set; }
+    public string ContentContent { get; set; }
+    public string ContentTitle { get; set; }
+
+    public int LessonId { get; set; }
+
+    protected ContentLesson(string contentContent, string contentTitle)
+    {
+        ContentContent = contentContent;
+        ContentTitle = contentTitle;
+    }
+
+    protected ContentLesson(int id, string contentContent, string contentTitle, int lessonId)
     {
-        public ContentLesson(int lessonId, int lessonPartId)
+        Id = id;
-        {
+        ContentContent = contentContent;
-            LessonId = lessonId;
+        ContentTitle = contentTitle;
-            LessonPartId = lessonPartId;
+        LessonId = lessonId;
-        }
-
-        public int LessonId { get; set; }
-        public int LessonPartId { get; set; }
     }
-}
+}

API_SQLuedo/Model/Inquiry.cs

@@ -1,24 +1,19 @@
-namespace ModelToEntities.Business
+namespace Model;
+
+public class Inquiry
 {
-    public class Inquiry
+    public int Id { get; set; }
-    {
+    public string Title { get; set; }
-        public int Id { get; set; }
+    public string Description { get; set; }
-        public string Title { get; set; }
+    public bool IsUser { get; set; }
-        public string Description { get; set; }
-        public bool IsUser { get; set; }
-        public int Database { get; set; }
-        public int InquiryTable { get; set; }
 
-        public Inquiry() { }
+    public Inquiry() { }
 
-        public Inquiry(int id, string title, string description, bool isUser, int database, int inquiryTable)
+    public Inquiry(int id, string title, string description, bool isUser)
-        {
+    {
-            Id = id;
+        Id = id;
-            Title = title;
+        Title = title;
-            Description = description;
+        Description = description;
-            IsUser = isUser;
+        IsUser = isUser;
-            Database = database;
-            InquiryTable = inquiryTable;
-        }
     }
-}
+}

API_SQLuedo/Model/InquiryTable.cs

@@ -1,18 +1,17 @@
-namespace ModelToEntities.Business
+namespace Model;
-{
-    public class InquiryTable
-    {
-        public int OwnerId { get; set; }
-        public string DatabaseName { get; set; }
-        public string ConnectionInfo { get; set; }
 
-        public InquiryTable() { }
+public class InquiryTable
-        public InquiryTable(int inquiryId, string databaseName, string connectionInfo)
+{
-        {
+    public int OwnerId { get; set; }
-            OwnerId = inquiryId;
+    public string DatabaseName { get; set; }
-            DatabaseName = databaseName;
+    public string ConnectionInfo { get; set; }
-            ConnectionInfo = connectionInfo;
-        }
 
+    public InquiryTable() { }
+    public InquiryTable(int inquiryId, string databaseName, string connectionInfo)
+    {
+        OwnerId = inquiryId;
+        DatabaseName = databaseName;
+        ConnectionInfo = connectionInfo;
     }
-}
+
+}

API_SQLuedo/Model/Lesson.cs

@@ -1,31 +1,25 @@
-namespace ModelToEntities.Business
+namespace Model;
-{
-    public class Lesson
-    {
-        public int Id { get; }
-        public string? Title { get; set; }
-        public string? LastPublisher { get; set; }
-        public DateOnly? LastEdit { get; set; }
 
-        public Lesson() { }
+public class Lesson
+{
+    public int Id { get; }
+    public string? Title { get; set; }
+    public string? LastPublisher { get; set; }
+    public DateOnly? LastEdit { get; set; }
+    public ICollection<ContentLesson> Content { get; set; } = new List<ContentLesson>();
 
-        public Lesson(int id)
+    public Lesson(int id, string title, string lastPublisher, DateOnly? lastEdit)
-        {
+    {
-            Id = id;
+        Id = id;
-        }
+        Title = title;
-        public Lesson(int id, string title, string lastPublisher, DateOnly? lastEdit)
+        LastPublisher = lastPublisher;
-        {
+        LastEdit = lastEdit;
-            Id = id;
+    }
-            Title = title;
-            LastPublisher = lastPublisher;
-            LastEdit = lastEdit;
-        }
 
-        public Lesson(string title, string lastPublisher, DateOnly? lastEdit)
+    public Lesson(string title, string lastPublisher, DateOnly? lastEdit)
-        {
+    {
-            Title = title;
+        Title = title;
-            LastPublisher = lastPublisher;
+        LastPublisher = lastPublisher;
-            LastEdit = lastEdit;
+        LastEdit = lastEdit;
-        }
     }
-}
+}

API_SQLuedo/Model/Notepad.cs

@@ -1,26 +1,25 @@
-namespace ModelToEntities.Business
+namespace Model;
+
+public class Notepad
 {
-    public class Notepad
+    public int Id { get; set; }
-    {
+    public int UserId { get; set; }
-        public int Id { get; set; }
+    public int InquiryId { get; set; }
-        public int UserId { get; set; }
+    public string Notes { get; set; }
-        public int InquiryId { 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)
-        {
+    {
-            Id = id;
+        Id = id;
-            UserId = userId;
+        UserId = userId;
-            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;
-            Notes = notes;
+        Notes = notes;
-        }
     }
-}
+}

API_SQLuedo/Model/OrderCriteria/InquiryOrderCriteria.cs

@@ -0,0 +1,6 @@
+namespace Model.OrderCriteria;
+
+public enum InquiryOrderCriteria
+{
+    None, ByTitle, ByDescription, ByIsUser
+}

API_SQLuedo/Model/OrderCriteria/LessonOrderCriteria.cs

@@ -0,0 +1,6 @@
+namespace Model.OrderCriteria;
+
+public enum LessonOrderCriteria
+{
+    None, ByTitle, ByLastPublisher, ByLastEdit
+}

API_SQLuedo/Model/OrderCriteria/ParagraphOrderCriteria.cs

@@ -0,0 +1,6 @@
+namespace Model.OrderCriteria;
+
+public enum ParagraphOrderCriteria
+{
+    None, ByTitle, ByContent, ByInfo, ByQuery, ByComment
+}

API_SQLuedo/Model/OrderCriteria/SuccessOrderCriteria.cs

@@ -0,0 +1,6 @@
+namespace Model.OrderCriteria;
+
+public enum SuccessOrderCriteria
+{
+    None, ByUserId, ByInquiryId, ByIsFinished
+}

API_SQLuedo/Model/OrderCriteria/UserOrderCriteria.cs

@@ -0,0 +1,6 @@
+namespace Model.OrderCriteria;
+
+public enum UserOrderCriteria
+{
+    None, ById, ByUsername, ByEmail, ByIsAdmin
+}

API_SQLuedo/Model/Paragraph.cs

@@ -1,37 +1,24 @@
-namespace ModelToEntities.Business
+namespace Model;
-{
-    public class Paragraph
-    {
-        public int Id { get;  }
-        public string? Title { get; set; }
-        public string? Content { get; set; }
-        public string? Info { get; set; }
-        public string? Query { get; set; }
-        public string? Comment { get; set; }
 
-        public Paragraph() { }
+public class Paragraph : ContentLesson
+{
+    public string Info { get; set; }
+    public string Query { get; set; }
+    public string Comment { get; set; }
 
-        public Paragraph(int id)
+    public Paragraph(string title, string content, string info, string query, string comment) : base(content,
-        {
+        title)
-            Id = id;
+    {
-        }
+        Info = info;
+        Query = query;
+        Comment = comment;
+    }
 
-        public Paragraph(int id, string title, string content, string info, string query, string comment)
+    public Paragraph(int id, string title, string content, string info, string query, string comment, int lessonId) :
-        {
+        base(id, content, title, lessonId)
-            Id = id;
+    {
-            Title = title;
+        Info = info;
-            Content = content;
+        Query = query;
-            Info = info;
+        Comment = comment;
-            Query = query;
-            Comment = comment;
-        }
-        public Paragraph(string title, string content, string info, string query, string comment)
-        {
-            Title = title;
-            Content = content;
-            Info = info;
-            Query = query;
-            Comment = comment;
-        }
     }
-}
+}

API_SQLuedo/Model/Solution.cs

@@ -1,30 +1,29 @@
-namespace ModelToEntities.Business
+namespace Model;
+
+public class Solution
 {
-    public class Solution
+    public int OwnerId { get; set; }
+    public string MurdererFirstName { get; set; }
+    public string MurdererLastName { get; set; }
+    public string MurderPlace { get; set; }
+    public string MurderWeapon { get; set; }
+    public string Explanation { get; set; }
+    public Solution() { }
+    public Solution(int ownerId, string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon, string explanation)
     {
-        public int OwnerId { get; set; }
+        OwnerId = ownerId;
-        public string MurdererFirstName { get; set; }
+        MurdererFirstName = murdererFirstName;
-        public string MurdererLastName { get; set; }
+        MurdererLastName = murdererLastName;
-        public string MurderPlace { get; set; }
+        MurderPlace = murderPlace;
-        public string MurderWeapon { get; set; }
+        MurderWeapon = murderWeapon;
-        public string Explanation { get; set; }
+        Explanation = explanation;
-        public Solution() { }
-        public Solution(int ownerId, string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon, string explanation)
-        {
-            OwnerId = ownerId;
-            MurdererFirstName = murdererFirstName;
-            MurdererLastName = murdererLastName;
-            MurderPlace = murderPlace;
-            MurderWeapon = murderWeapon;
-            Explanation = explanation;
-        }
-        public Solution(string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon, string explanation)
-        {
-            MurdererFirstName = murdererFirstName;
-            MurdererLastName = murdererLastName;
-            MurderPlace = murderPlace;
-            MurderWeapon = murderWeapon;
-            Explanation = explanation;
-        }
     }
-}
+    public Solution(string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon, string explanation)
+    {
+        MurdererFirstName = murdererFirstName;
+        MurdererLastName = murdererLastName;
+        MurderPlace = murderPlace;
+        MurderWeapon = murderWeapon;
+        Explanation = explanation;
+    }
+}

API_SQLuedo/Model/Success.cs

@@ -1,18 +1,17 @@
-namespace ModelToEntities.Business
+namespace Model;
+
+public class Success
 {
-    public class Success
+    public int UserId { get; set; }
-    {
+    public int InquiryId { get; set; }
-        public int UserId { get; set; }
+    public bool IsFinished { get; set; }
-        public int InquiryId { 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)
-        {
+    {
-            UserId = userId;
+        UserId = userId;
-            InquiryId = inquiryId;
+        InquiryId = inquiryId;
-            IsFinished = isFinished;
+        IsFinished = isFinished;
-        }
     }
-}
+}

API_SQLuedo/Model/User.cs

@@ -1,21 +1,20 @@
-namespace ModelToEntities.Business
+namespace Model;
+
+public class User
 {
-    public class User
+    public int Id { get; set; }
-    {
+    public string Username { get; set; }
-        public int Id { get; set; }
+    public string Password { get; set; }
-        public string Username { get; set; }
+    public string Email { get; set; }
-        public string Password { get; set; }
+    public bool IsAdmin { get; set; }
-        public string Email { 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;
-            Username = username;
+        Username = username;
-            Password = password;
+        Password = password;
-            Email = email;
+        Email = email;
-            IsAdmin = isAdmin;
+        IsAdmin = isAdmin;
-        }
     }
-}
+}

API_SQLuedo/Shared/IInquiryDataService.cs

@@ -0,0 +1,14 @@
+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);
+}

API_SQLuedo/Shared/IInquiryService.cs

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

API_SQLuedo/Shared/ILessonDataService.cs

@@ -0,0 +1,15 @@
+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);
+    
+}

API_SQLuedo/Shared/ILessonService.cs

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

API_SQLuedo/Shared/IParagraphDataService.cs

@@ -0,0 +1,14 @@
+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);
+}

API_SQLuedo/Shared/IParagraphService.cs

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

API_SQLuedo/Shared/ISuccessDataService.cs

@@ -0,0 +1,14 @@
+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);
+}

API_SQLuedo/Shared/ISuccessService.cs

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

API_SQLuedo/Shared/IUserDataService.cs

@@ -0,0 +1,14 @@
+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);
+}

API_SQLuedo/Shared/IUserService.cs

@@ -1,8 +1,10 @@
-namespace Shared
+using Model.OrderCriteria;
+
+namespace Shared
 {
     public interface IUserService<TUser>
     {
-        public IEnumerable<TUser> GetUsers(int page, int number);
+        public IEnumerable<TUser> GetUsers(int page, int number, UserOrderCriteria orderCriteria);
         public TUser GetUserById(int id);
         public TUser GetUserByUsername(string username);
         public bool DeleteUser(int id);

API_SQLuedo/Shared/InquiryDataService.cs

@@ -0,0 +1,101 @@
+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();
+    }
+}

API_SQLuedo/Shared/LessonDataService.cs

@@ -0,0 +1,103 @@
+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;
+    }
+}

API_SQLuedo/Shared/Mapper/BlackListMapper.cs

@@ -1,37 +1,37 @@
 using Dto;
 using Entities;
-using ModelToEntities.Business;
+using Model;
 
 namespace Shared.Mapper;
 
 public static class BlackListMapper
 {
-    public static BlackListDTO FromModelToDTO(BlackList model)
+    public static BlackListDTO FromModelToDTO(this BlackList model)
     {
         return new BlackListDTO(model.Email, model.ExpirationDate);
     }
 
-    public static BlackListDTO FromEntityToDTO(BlackListEntity ent)
+    public static BlackListDTO FromEntityToDTO(this BlackListEntity ent)
     {
         return new BlackListDTO(ent.Email, ent.ExpirationDate);
     }
 
-    public static BlackList FromDTOToModel(BlackListDTO dto)
+    public static BlackList FromDTOToModel(this BlackListDTO dto)
     {
         return new BlackList(dto.Email, dto.ExpirationDate);
     }
 
-    public static BlackList FromEntityToModel(BlackListEntity ent)
+    public static BlackList FromEntityToModel(this BlackListEntity ent)
     {
         return new BlackList(ent.Email, ent.ExpirationDate);
     }
 
-    public static BlackListEntity FromDTOToEntity(BlackListDTO dto)
+    public static BlackListEntity FromDTOToEntity(this BlackListDTO dto)
     {
         return new BlackListEntity(dto.Email, dto.ExpirationDate);
     }
 
-    public static BlackListEntity FromModelToEntity(BlackList model)
+    public static BlackListEntity FromModelToEntity(this BlackList model)
     {
         return new BlackListEntity(model.Email, model.ExpirationDate);
     }

API_SQLuedo/Shared/Mapper/ContentLessonMapper.cs

@@ -1,34 +0,0 @@
-using Dto;
-using Entities;
-using ModelToEntities.Business;
-
-namespace Shared.Mapper;
-
-public static class ContentLessonMapper
-{
-    public static ContentLesson FromDTOToModel(this ContentLessonDTO dto)
-    {
-        return new ContentLesson(dto.LessonId, dto.LessonPartId);
-    }
-
-    public static ContentLesson FromEntityToModel(this ContentLessonEntity ent)
-    {
-        return new ContentLesson(ent.LessonId, ent.LessonPartId);
-    }
-
-    public static ContentLessonDTO FromModelToDTO(this ContentLesson les)
-    {
-        return new ContentLessonDTO(les.LessonId, les.LessonPartId);
-    }
-
-    public static ContentLessonDTO FromEntityToDTO(this ContentLessonEntity ent)
-    {
-        return new ContentLessonDTO(ent.LessonId, ent.LessonPartId);
-    }
-
-    public static ContentLessonEntity FromModelToEntity(this ContentLesson les)
-    {
-        return new ContentLessonEntity(les.LessonId, new LessonEntity(les.LessonId), les.LessonPartId,
-            new ParagraphEntity(les.LessonPartId));
-    }
-}

API_SQLuedo/Shared/Mapper/InquiryMapper.cs

@@ -1,44 +1,39 @@
 using Dto;
 using Entities;
-using ModelToEntities.Business;
+using Model;
 
 namespace Shared.Mapper;
 
 public static class InquiryMapper
 {
-    public static Inquiry FromDTOToModel(this InquiryDTO InqDto)
+    public static Inquiry FromDTOToModel(this InquiryDTO inqDto)
     {
-        return new Inquiry(InqDto.Id, InqDto.Title, InqDto.Description, InqDto.IsUser, InqDto.Database,
+        return new Inquiry(inqDto.Id, inqDto.Title, inqDto.Description, inqDto.IsUser);
-            InqDto.InquiryTable);
     }
 
-    public static Inquiry FromEntityToModel(this InquiryEntity InqEntity)
+    public static Inquiry FromEntityToModel(this InquiryEntity inqEntity)
     {
-        return new Inquiry(InqEntity.Id, InqEntity.Title, InqEntity.Description, InqEntity.IsUser,
+        return new Inquiry(inqEntity.Id, inqEntity.Title, inqEntity.Description, inqEntity.IsUser);
-            InqEntity.Database.OwnerId, InqEntity.InquiryTable.OwnerId);
     }
 
 
-    public static InquiryEntity FromModelToEntity(this Inquiry Inq)
+    public static InquiryEntity FromModelToEntity(this Inquiry inq)
     {
-        return new InquiryEntity(Inq.Id, Inq.Title, Inq.Description, Inq.IsUser, new InquiryTableEntity(Inq.Database),
+        return new InquiryEntity(inq.Id, inq.Title, inq.Description, inq.IsUser);
-            new SolutionEntity(Inq.InquiryTable));
     }
 
-    public static InquiryEntity FromDTOToEntity(this InquiryDTO InqDto)
+    public static InquiryEntity FromDTOToEntity(this InquiryDTO inqDto)
     {
-        return new InquiryEntity(InqDto.Id, InqDto.Title, InqDto.Description, InqDto.IsUser,
+        return new InquiryEntity(inqDto.Id, inqDto.Title, inqDto.Description, inqDto.IsUser);
-            new InquiryTableEntity(InqDto.Database), new SolutionEntity(InqDto.InquiryTable));
     }
 
-    public static InquiryDTO FromModelToDTO(this Inquiry Inq)
+    public static InquiryDTO FromModelToDTO(this Inquiry inq)
     {
-        return new InquiryDTO(Inq.Id, Inq.Title, Inq.Description, Inq.IsUser, Inq.Database, Inq.InquiryTable);
+        return new InquiryDTO(inq.Id, inq.Title, inq.Description, inq.IsUser);
     }
 
-    public static InquiryDTO FromEntityToDTO(this InquiryEntity InqEntity)
+    public static InquiryDTO FromEntityToDTO(this InquiryEntity inqEntity)
     {
-        return new InquiryDTO(InqEntity.Id, InqEntity.Title, InqEntity.Description, InqEntity.IsUser,
+        return new InquiryDTO(inqEntity.Id, inqEntity.Title, inqEntity.Description, inqEntity.IsUser);
-            InqEntity.Database.OwnerId, InqEntity.InquiryTable.OwnerId);
     }
 }

API_SQLuedo/Shared/Mapper/InquiryTableMapper.cs

@@ -1,34 +1,34 @@
 using Dto;
 using Entities;
-using ModelToEntities.Business;
+using Model;
 
 namespace Shared.Mapper;
 
 public static class InquiryTableMapper
 {
-    public static InquiryTable FromDTOToModel(this InquiryTableDTO InqTDto)
+    public static InquiryTable FromDTOToModel(this InquiryTableDTO inqTDto)
     {
-        return new InquiryTable(InqTDto.OwnerId, InqTDto.ConnectionInfo, InqTDto.DatabaseName);
+        return new InquiryTable(inqTDto.OwnerId, inqTDto.ConnectionInfo, inqTDto.DatabaseName);
     }
 
-    public static InquiryTable FromEntityToModel(this InquiryTableEntity InqTEntity)
+    public static InquiryTable FromEntityToModel(this InquiryTableEntity inqTEntity)
     {
-        return new InquiryTable(InqTEntity.OwnerId, InqTEntity.ConnectionInfo, InqTEntity.DatabaseName);
+        return new InquiryTable(inqTEntity.OwnerId, inqTEntity.ConnectionInfo, inqTEntity.DatabaseName);
     }
 
-    public static InquiryTableDTO FromModelToDTO(this InquiryTable InqT)
+    public static InquiryTableDTO FromModelToDTO(this InquiryTable inqT)
     {
-        return new InquiryTableDTO(InqT.OwnerId, InqT.DatabaseName, InqT.ConnectionInfo);
+        return new InquiryTableDTO(inqT.OwnerId, inqT.DatabaseName, inqT.ConnectionInfo);
     }
 
-    public static InquiryTableDTO FromEntityToDTO(this InquiryTableEntity InqTEntity)
+    public static InquiryTableDTO FromEntityToDTO(this InquiryTableEntity inqTEntity)
     {
-        return new InquiryTableDTO(InqTEntity.OwnerId, InqTEntity.DatabaseName, InqTEntity.ConnectionInfo);
+        return new InquiryTableDTO(inqTEntity.OwnerId, inqTEntity.DatabaseName, inqTEntity.ConnectionInfo);
     }
 
-    public static InquiryTableEntity FromModelToEntity(this InquiryTable InqT)
+    public static InquiryTableEntity FromModelToEntity(this InquiryTable inqT)
     {
-        return new InquiryTableEntity(InqT.OwnerId, InqT.DatabaseName, InqT.ConnectionInfo);
+        return new InquiryTableEntity(inqT.OwnerId, inqT.DatabaseName, inqT.ConnectionInfo);
     }
 
     public static InquiryTableEntity FromDTOToEntity(this InquiryTableDTO dto)

API_SQLuedo/Shared/Mapper/LessonMapper.cs

@@ -1,37 +1,37 @@
 using Dto;
 using Entities;
-using ModelToEntities.Business;
+using Model;
 
 namespace Shared.Mapper;
 
 public static class LessonMapper
 {
-    public static LessonDTO FromModelToDTO(Lesson model)
+    public static LessonDTO FromModelToDTO(this Lesson model)
     {
         return new LessonDTO(model.Id, model.Title, model.LastPublisher, model.LastEdit);
     }
 
-    public static LessonDTO FromEntityToDTO(LessonEntity model)
+    public static LessonDTO FromEntityToDTO(this LessonEntity model)
     {
         return new LessonDTO(model.Id, model.Title, model.LastPublisher, model.LastEdit);
     }
 
-    public static LessonEntity FromModelToEntity(Lesson model)
+    public static LessonEntity FromModelToEntity(this Lesson model)
     {
         return new LessonEntity(model.Id, model.Title, model.LastPublisher, model.LastEdit);
     }
 
-    public static LessonEntity FromDTOToEntity(LessonDTO dto)
+    public static LessonEntity FromDTOToEntity(this LessonDTO dto)
     {
         return new LessonEntity(dto.Id, dto.Title, dto.LastPublisher, dto.LastEdit);
     }
 
-    public static Lesson FromDTOToModel(LessonDTO dto)
+    public static Lesson FromDTOToModel(this LessonDTO dto)
     {
         return new Lesson(dto.Id, dto.Title, dto.LastPublisher, dto.LastEdit);
     }
 
-    public static Lesson FromEntityToModel(LessonEntity entity)
+    public static Lesson FromEntityToModel(this LessonEntity entity)
     {
         return new Lesson(entity.Id, entity.Title, entity.LastPublisher, entity.LastEdit);
     }

API_SQLuedo/Shared/Mapper/NotepadMapper.cs

@@ -1,6 +1,6 @@
 using Dto;
 using Entities;
-using ModelToEntities.Business;
+using Model;
 
 namespace Shared.Mapper;
 

API_SQLuedo/Shared/Mapper/ParagraphMapper.cs

@@ -1,38 +1,42 @@
 using Dto;
 using Entities;
-using ModelToEntities.Business;
+using Model;
 
 namespace Shared.Mapper;
 
 public static class ParagraphMapper
 {
-    public static Paragraph FromDTOToModel(ParagraphDTO dto)
+    public static Paragraph FromDTOToModel(this ParagraphDTO dto)
     {
-        return new Paragraph(dto.Id, dto.Title, dto.Content, dto.Info, dto.Query, dto.Comment);
+        return new Paragraph(dto.ContentTitle, dto.ContentContent, dto.Info, dto.Query, dto.Comment);
     }
 
-    public static Paragraph FromEntityToModel(ParagraphEntity model)
+    public static Paragraph FromEntityToModel(this ParagraphEntity model)
     {
-        return new Paragraph(model.Id, model.Title, model.Content, model.Info, model.Query, model.Comment);
+        return new Paragraph(model.ContentTitle, model.ContentContent, model.Info, model.Query, model.Comment);
     }
 
-    public static ParagraphDTO FromEntityToDTO(ParagraphEntity model)
+    public static ParagraphDTO FromEntityToDTO(this ParagraphEntity model)
     {
-        return new ParagraphDTO(model.Id, model.Title, model.Content, model.Info, model.Query, model.Comment);
+        return new ParagraphDTO(model.Id, model.ContentTitle, model.ContentContent, model.Info, model.Query,
+            model.Comment, model.LessonId);
     }
 
-    public static ParagraphDTO FromModelToDTO(Paragraph model)
+    public static ParagraphDTO FromModelToDTO(this Paragraph model)
     {
-        return new ParagraphDTO(model.Id, model.Title, model.Content, model.Info, model.Query, model.Comment);
+        return new ParagraphDTO(model.Id, model.ContentTitle, model.ContentContent, model.Info, model.Query,
+            model.Comment, model.LessonId);
     }
 
-    public static ParagraphEntity FromDTOToEntity(ParagraphDTO dto)
+    public static ParagraphEntity FromDTOToEntity(this ParagraphDTO dto)
     {
-        return new ParagraphEntity(dto.Id, dto.Title, dto.Content, dto.Info, dto.Query, dto.Comment);
+        return new ParagraphEntity(dto.Id, dto.ContentTitle, dto.ContentContent, dto.Info, dto.Query, dto.Comment,
+            dto.LessonId);
     }
 
-    public static Paragraph FromModelToEntity(Paragraph model)
+    public static ParagraphEntity FromModelToEntity(this Paragraph model)
     {
-        return new Paragraph(model.Id, model.Title, model.Content, model.Info, model.Query, model.Comment);
+        return new ParagraphEntity(model.Id, model.ContentTitle, model.ContentContent, model.Info, model.Query,
+            model.Comment, model.LessonId);
     }
 }

API_SQLuedo/Shared/Mapper/SolutionMapper.cs

@@ -1,6 +1,6 @@
 using Dto;
 using Entities;
-using ModelToEntities.Business;
+using Model;
 
 namespace Shared.Mapper;
 
@@ -15,7 +15,7 @@ public static class SolutionMapper
     public static Solution FromEntityToModel(this SolutionEntity entity)
     {
         return new Solution(entity.OwnerId, entity.MurdererFirstName, entity.MurdererLastName, entity.MurderPlace,
-            entity.MurderWeapon, entity.Explanation);
+            entity.MurderWeapon, entity.Explaination);
     }
 
     public static SolutionDTO FromModelToDTO(this Solution model)
@@ -27,7 +27,7 @@ public static class SolutionMapper
     public static SolutionDTO FromEntityToDTO(this SolutionEntity entity)
     {
         return new SolutionDTO(entity.OwnerId, entity.MurdererFirstName, entity.MurdererLastName, entity.MurderPlace,
-            entity.MurderWeapon, entity.Explanation);
+            entity.MurderWeapon, entity.Explaination);
     }
 
     public static SolutionEntity FromModelToEntity(this Solution model)

API_SQLuedo/Shared/Mapper/SuccessMapper.cs

@@ -1,6 +1,6 @@
 using Dto;
 using Entities;
-using ModelToEntities.Business;
+using Model;
 
 namespace Shared.Mapper;
 

API_SQLuedo/Shared/Mapper/UserMapper.cs

@@ -1,6 +1,6 @@
 using Dto;
 using Entities;
-using ModelToEntities.Business;
+using Model;
 
 namespace Shared.Mapper;
 

API_SQLuedo/Shared/ParagraphDataService.cs

@@ -0,0 +1,116 @@
+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;
+    }
+}

API_SQLuedo/Shared/Shared.csproj

@@ -7,6 +7,7 @@
     </PropertyGroup>
 
     <ItemGroup>
+      <ProjectReference Include="..\DbContextLib\DbContextLib.csproj" />
       <ProjectReference Include="..\Dto\Dto.csproj" />
       <ProjectReference Include="..\EntityFramework\Entities.csproj" />
       <ProjectReference Include="..\Model\Model.csproj" />

API_SQLuedo/Shared/SuccessDataService.cs

@@ -0,0 +1,103 @@
+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;
+    }
+}

API_SQLuedo/Shared/UserDataService.cs

@@ -0,0 +1,121 @@
+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;
+
+        }
+    }
+}

API_SQLuedo/StubbedContextLib/StubbedContext.cs

@@ -1,4 +1,5 @@
-using System.Security.Cryptography;
+using System.Runtime.CompilerServices;
+using System.Security.Cryptography;
 using DbContextLib;
 using Entities;
 using Microsoft.AspNetCore.Cryptography.KeyDerivation;
@@ -46,5 +47,23 @@ public class StubbedContext : UserDbContext
                 prf: KeyDerivationPrf.HMACSHA256,
                 iterationCount: 100000,
                 numBytesRequested: 256 / 8)), "Victor.GABORIT@etu.uca.fr", true));
+        
+        modelBuilder.Entity<InquiryTableEntity>().HasData(
+            new InquiryTableEntity(1, "Inquiry1",
+                "Server=localhost;Database=Inquiry1;Trusted_Connection=True;MultipleActiveResultSets=true"),
+            new InquiryTableEntity(2, "Inquiry2",
+                "Server=localhost;Database=Inquiry2;Trusted_Connection=True;MultipleActiveResultSets=true"),
+            new InquiryTableEntity(3, "Inquiry3",
+                "Server=localhost;Database=Inquiry3;Trusted_Connection=True;MultipleActiveResultSets=true"));
+
+        modelBuilder.Entity<SolutionEntity>().HasData(
+            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(3, "Erwan", "Menager", "La salle de bain", "L'arachide", "Parce que c'est Erwan"));
+        
+        modelBuilder.Entity<InquiryEntity>().HasData(
+            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(3, "L'enquête sur les parapluies", "Il pleuvait", false));
     }
 }

API_SQLuedo/TestConsoleAPI/Program.cs

@@ -1,14 +1,14 @@
 // See https://aka.ms/new-console-template for more information
 
 using API.Controllers;
-using API.Service;
 using DbContextLib;
-using DbDataManager.Service;
 using Dto;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Data.Sqlite;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
+using Model.OrderCriteria;
+using Shared;
 
 var connection = new SqliteConnection("DataSource=:memory:");
 connection.Open();
@@ -16,17 +16,66 @@ var options = new DbContextOptionsBuilder<UserDbContext>()
                     .UseSqlite(connection)
                     .Options;
 using ILoggerFactory factory = new LoggerFactory();
-ILogger<UserController> logger = factory.CreateLogger<UserController>();
+ILogger<UsersController> userLogger = factory.CreateLogger<UsersController>();
+ILogger<InquiriesController> inquiryLogger = factory.CreateLogger<InquiriesController>();
+ILogger<ParagraphsController> paragraphLogger = factory.CreateLogger<ParagraphsController>();
+ILogger<LessonsController> lessonLogger = factory.CreateLogger<LessonsController>();
+ILogger<SuccessesController> successLogger = factory.CreateLogger<SuccessesController>();
+
 
 using (var context = new UserDbContext(options))
 {
-    var controller = new UserController(logger, new UserDataServiceApi(new UserDataService(context)));
+    var userController = new UsersController(userLogger, new UserDataService(context));
+    var inquiryController = new InquiriesController(new InquiryDataService(context), inquiryLogger);
+    var paragraphController = new ParagraphsController(new ParagraphDataService(context), paragraphLogger);
+    var lessonController = new LessonsController(new LessonDataService(context), lessonLogger);
+    var successController = new SuccessesController(new SuccessDataService(context), successLogger);
 
     void PrintUsers()
     {
         Console.WriteLine();
-        var users = controller.GetUsers(1, 10) as OkObjectResult;
+        var users = userController.GetUsers(1, 10, UserOrderCriteria.None) as OkObjectResult;
-        foreach(var item in users.Value as IEnumerable<UserDTO>)
+        foreach (var item in users.Value as IEnumerable<UserDTO>)
+        {
+            Console.WriteLine(item);
+        }
+    }
+
+    void PrintInquiries()
+    {
+        Console.WriteLine();
+        var inquiries = inquiryController.GetInquiries(1, 10, InquiryOrderCriteria.None) as OkObjectResult;
+        foreach (var item in inquiries.Value as IEnumerable<InquiryDTO>)
+        {
+            Console.WriteLine(item);
+        }
+    }
+
+    void PrintParagraphs()
+    {
+        Console.WriteLine();
+        var paragraphs = paragraphController.GetParagraphs(1, 10, ParagraphOrderCriteria.None) as OkObjectResult;
+        foreach (var item in paragraphs.Value as IEnumerable<ParagraphDTO>)
+        {
+            Console.WriteLine(item);
+        }
+    }
+
+    void PrintLessons()
+    {
+        Console.WriteLine();
+        var lessons = lessonController.GetLessons(1, 10, LessonOrderCriteria.None) as OkObjectResult;
+        foreach (var item in lessons.Value as IEnumerable<LessonDTO>)
+        {
+            Console.WriteLine(item);
+        }
+    }
+
+    void PrintSuccesses()
+    {
+        Console.WriteLine();
+        var successes = successController.GetSuccesses(1, 10, SuccessOrderCriteria.None) as OkObjectResult;
+        foreach (var item in successes.Value as IEnumerable<SuccessDTO>)
         {
             Console.WriteLine(item);
         }
@@ -36,26 +85,138 @@ using (var context = new UserDbContext(options))
     {
         Console.WriteLine("\nVeuillez saisir le pseudonyme de l'utilisateur recherché : ");
         var username = Console.ReadLine();
-        var user = controller.GetUserByUsername(username) as OkObjectResult;
+        var user = userController.GetUserByUsername(username) as OkObjectResult;
-        if(user == null)
+        if (user == null)
         {
             Console.WriteLine("Erreur, la requête n'a rien donné.");
             return;
         }
         Console.WriteLine(user.Value as UserDTO);
+
+    }
+
+    void SearchInquiryByTitle()
+    {
+        Console.WriteLine("\nVeuillez saisir le titre de l'enquête recherchée : ");
+        var title = Console.ReadLine();
+        var inquiry = inquiryController.GetInquiryByTitle(title) as OkObjectResult;
+        if (inquiry == null)
+        {
+            Console.WriteLine("Erreur, la requête n'a rien donné.");
+            return;
+        }
+        Console.WriteLine(inquiry.Value as InquiryDTO);
+    }
+
+    void SearchParagraphByTitle()
+    {
+        Console.WriteLine("\nVeuillez saisir le titre du paragraphe recherché : ");
+        var title = Console.ReadLine();
+        var paragraph = paragraphController.GetParagraphByTitle(title) as OkObjectResult;
+        if (paragraph == null)
+        {
+            Console.WriteLine("Erreur, la requête n'a rien donné.");
+            return;
+        }
+        Console.WriteLine(paragraph.Value as ParagraphDTO);
+
+    }
+
+    void SearchLessonByTitle()
+    {
+        Console.WriteLine("\nVeuillez saisir le titre de la leçon recherchée : ");
+        var title = Console.ReadLine();
+        var lesson = lessonController.GetLessonByTitle(title) as OkObjectResult;
+        if (lesson == null)
+        {
+            Console.WriteLine("Erreur, la requête n'a rien donné.");
+            return;
+        }
+        Console.WriteLine(lesson.Value as LessonDTO);
+
+    }
+
+    void SearchSuccessByUserId()
+    {
+        Console.WriteLine("\nVeuillez saisir l'identifiant de l'utilisateur du succès recherché : ");
+        var id = Console.ReadLine();
+        var success = successController.GetSuccessByUserId(int.Parse(id)) as OkObjectResult;
+        if (success == null)
+        {
+            Console.WriteLine("Erreur, la requête n'a rien donné.");
+            return;
+        }
+        Console.WriteLine(success.Value as SuccessDTO);
+
     }
 
     void SearchUserById()
     {
         Console.WriteLine("\nVeuillez saisir l'identifiant de l'utilisateur recherché : ");
         var id = Console.ReadLine();
-        var user = controller.GetUserById(int.Parse(id)) as OkObjectResult;
+        var user = userController.GetUserById(int.Parse(id)) as OkObjectResult;
         if (user == null)
         {
             Console.WriteLine("Erreur, la requête n'a rien donné.");
             return;
         }
         Console.WriteLine(user.Value as UserDTO);
+
+    }
+
+    void SearchInquiryById()
+    {
+        Console.WriteLine("\nVeuillez saisir l'identifiant de l'enquête recherchée : ");
+        var id = Console.ReadLine();
+        var inquiry = inquiryController.GetInquiryById(int.Parse(id)) as OkObjectResult;
+        if (inquiry == null)
+        {
+            Console.WriteLine("Erreur, la requête n'a rien donné.");
+            return;
+        }
+        Console.WriteLine(inquiry.Value as InquiryDTO);
+    }
+
+    void SearchParagraphById()
+    {
+        Console.WriteLine("\nVeuillez saisir l'identifiant du paragraphe recherché : ");
+        var id = Console.ReadLine();
+        var paragraph = paragraphController.GetParagraphById(int.Parse(id)) as OkObjectResult;
+        if (paragraph == null)
+        {
+            Console.WriteLine("Erreur, la requête n'a rien donné.");
+            return;
+        }
+        Console.WriteLine(paragraph.Value as ParagraphDTO);
+
+    }
+
+    void SearchSuccessByInquiryId()
+    {
+        Console.WriteLine("\nVeuillez saisir l'identifiant de l'enquête du succès recherché : ");
+        var id = Console.ReadLine();
+        var success = successController.GetSuccessByInquiryId(int.Parse(id)) as OkObjectResult;
+        if (success == null)
+        {
+            Console.WriteLine("Erreur, la requête n'a rien donné.");
+            return;
+        }
+        Console.WriteLine(success.Value as SuccessDTO);
+
+    }
+
+    void SearchLessonById()
+    {
+        Console.WriteLine("\nVeuillez saisir l'identifiant de la leçon recherchée : ");
+        var id = Console.ReadLine();
+        var lesson = lessonController.GetLessonById(int.Parse(id)) as OkObjectResult;
+        if (lesson == null)
+        {
+            Console.WriteLine("Erreur, la requête n'a rien donné.");
+            return;
+        }
+        Console.WriteLine(lesson.Value as LessonDTO);
+
     }
 
     void AddUser()
@@ -66,23 +227,115 @@ using (var context = new UserDbContext(options))
         var email = Console.ReadLine();
         Console.WriteLine("Veuillez saisir un mot de passe :");
         var mdp = Console.ReadLine();
-        var res = controller.CreateUser(new UserDTO(username, mdp, email, false));
+        var res = userController.CreateUser(new UserDTO(username, mdp, email, false));
-        if(res.GetType() == typeof(CreatedResult)) {
+        if (res.GetType() == typeof(CreatedResult))
+        {
             Console.WriteLine("\nUtilisateur créé avec succès");
-        } else
+        }
+        else
         {
             Console.WriteLine("\nErreur lors de la création de l'utilisateur !");
         }
+
+    }
+
+    void AddInquiry()
+    {
+        Console.WriteLine("Veuillez saisir le titre :");
+        var title = Console.ReadLine();
+        Console.WriteLine("Veuillez saisir une description :");
+        var description = Console.ReadLine();
+        Console.WriteLine("Veuillez saisir un isUser (false / true) :");
+        var isUser = Convert.ToBoolean(Console.ReadLine());
+        Console.WriteLine("Veuillez saisir l'id de la database :");
+        var database = Convert.ToInt32(Console.ReadLine());
+        Console.WriteLine("Veuillez saisir l'id de la solution :");
+        var solution = Convert.ToInt32(Console.ReadLine());
+        var res = inquiryController.CreateInquiry(new InquiryDTO(title, description, false));
+        if (res.GetType() == typeof(CreatedResult))
+        {
+            Console.WriteLine("\nEnquête créée avec succès");
+        }
+        else
+        {
+            Console.WriteLine("\nErreur lors de la création de l'enquête !");
+        }
+    }
+
+    void AddParagraph()
+    {
+        Console.WriteLine("Veuillez saisir le titre :");
+        var title = Console.ReadLine();
+        Console.WriteLine("Veuillez saisir un contenu :");
+        var content = Console.ReadLine();
+        Console.WriteLine("Veuillez saisir une information :");
+        var info = Console.ReadLine();
+        Console.WriteLine("Veuillez saisir une query :");
+        var query = Console.ReadLine();
+        Console.WriteLine("Veuillez saisir un commentaire :");
+        var comment = Console.ReadLine();
+        Console.WriteLine("Veuillez saisir l'id de la leçon :");
+        var lesson = Convert.ToInt32(Console.ReadLine());
+        var res = paragraphController.CreateParagraph(new ParagraphDTO(title, content, info, query, comment, lesson));
+        if (res.GetType() == typeof(CreatedResult))
+        {
+            Console.WriteLine("\nParagraphe créé avec succès");
+        }
+        else
+        {
+            Console.WriteLine("\nErreur lors de la création du paragraphe !");
+        }
+
+    }
+
+    void AddLesson()
+    {
+        Console.WriteLine("Veuillez saisir le titre :");
+        var title = Console.ReadLine();
+        Console.WriteLine("Veuillez saisir votre nom :");
+        var lastPublisher = Console.ReadLine();
+        var res = lessonController.CreateLesson(new LessonDTO(title, lastPublisher, DateOnly.FromDateTime(DateTime.Now)));
+        if (res.GetType() == typeof(CreatedResult))
+        {
+            Console.WriteLine("\nLeçon créée avec succès");
+        }
+        else
+        {
+            Console.WriteLine("\nErreur lors de la création de la leçon !");
+        }
+
+    }
+
+    void AddSuccess()
+    {
+        Console.WriteLine("Veuillez saisir l'identifiant de l'utilisateur lié au succès :");
+        var userId = Console.ReadLine();
+        Console.WriteLine("Veuillez saisir l'identifiant de l'enquête lié au succès :");
+        var inquiryId = Console.ReadLine();
+        Console.WriteLine("Veuillez indiquer si l'enquête a été complété (true/false) :");
+        var isFinished = Console.ReadLine();
+        var res = successController.CreateSuccess(new SuccessDTO(int.Parse(userId), int.Parse(inquiryId), bool.Parse(isFinished)));
+        if (res.GetType() == typeof(CreatedResult))
+        {
+            Console.WriteLine("\nSuccès créé avec succès");
+        }
+        else
+        {
+            Console.WriteLine("\nErreur lors de la création du succès !");
+        }
+
     }
 
     void UpdateUser()
     {
         Console.WriteLine("Quel est l'identifiant de l'utilisateur à mettre à jour ?");
         var id = int.Parse(Console.ReadLine());
-        var res = (controller.GetUserById(id));
+        var res = (userController.GetUserById(id));
-        if (res.GetType() == typeof(OkObjectResult)) {
+        if (res.GetType() == typeof(OkObjectResult))
+        {
             var user = (res as OkObjectResult).Value as UserDTO;
-            if (user == null) {
+            if (user == null)
+            {
                 Console.WriteLine("Erreur, un problème est survenu");
                 return;
             }
@@ -93,27 +346,245 @@ using (var context = new UserDbContext(options))
                 var username = Console.ReadLine();
                 Console.WriteLine("Veuillez saisir l'email :");
                 var email = Console.ReadLine();
-                var retour = controller.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 !");
-                } else
+                }
+                else
                 {
                     Console.WriteLine("Une erreur est survenue lors de la mise à jour.");
                 }
             }
-        } 
+        }
-        else {
+        else
+        {
             Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
         }
+
+    }
+
+    void UpdateInquiry()
+    {
+        Console.WriteLine("Quel est l'identifiant de l'enquête à mettre à jour ?");
+        var id = int.Parse(Console.ReadLine());
+        var res = (inquiryController.GetInquiryById(id));
+        if (res.GetType() == typeof(OkObjectResult))
+        {
+            var user = (res as OkObjectResult).Value as InquiryDTO;
+            if (user == null)
+            {
+                Console.WriteLine("Erreur, un problème est survenu");
+                return;
+            }
+            else
+            {
+                Console.WriteLine("Enquête trouvée !\n");
+                Console.WriteLine("Veuillez saisir le titre :");
+                var title = Console.ReadLine();
+                Console.WriteLine("Veuillez saisir la description :");
+                var description = Console.ReadLine();
+                Console.WriteLine("Veuillez indiquer si l'enquête est accessible aux visiteurs (0/1) :");
+                var isUser = Console.ReadLine();
+                Console.WriteLine("Veuillez saisir un commentaire :");
+                var database = Convert.ToInt32(Console.ReadLine());
+                Console.WriteLine("Veuillez saisir un commentaire :");
+                var inquiryTable = Convert.ToInt32(Console.ReadLine());
+                var retour = inquiryController.UpdateInquiry(id, new InquiryDTO(id, title, description, bool.Parse(isUser)));
+                if (retour.GetType() == typeof(OkObjectResult))
+                {
+                    Console.WriteLine("Mise à jour effectué avec succès !");
+                }
+                else
+                {
+                    Console.WriteLine("Une erreur est survenue lors de la mise à jour.");
+                }
+            }
+        }
+        else
+        {
+            Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
+        }
+
+    }
+
+    void UpdateParagraph()
+    {
+        Console.WriteLine("Quel est l'identifiant du paragraphe à mettre à jour ?");
+        var id = int.Parse(Console.ReadLine());
+        var res = (paragraphController.GetParagraphById(id));
+        if (res.GetType() == typeof(OkObjectResult))
+        {
+            var paragraph = (res as OkObjectResult).Value as ParagraphDTO;
+            if (paragraph == null)
+            {
+                Console.WriteLine("Erreur, un problème est survenu");
+                return;
+            }
+            else
+            {
+                Console.WriteLine("Paragraphe trouvé !\n");
+                Console.WriteLine("Veuillez saisir le titre :");
+                var title = Console.ReadLine();
+                Console.WriteLine("Veuillez saisir un contenu :");
+                var content = Console.ReadLine();
+                Console.WriteLine("Veuillez saisir une information :");
+                var info = Console.ReadLine();
+                Console.WriteLine("Veuillez saisir une query :");
+                var query = Console.ReadLine();
+                Console.WriteLine("Veuillez saisir un commentaire :");
+                var comment = Console.ReadLine();
+                Console.WriteLine("Veuillez saisir l'id de la leçon :");
+                var lesson = Convert.ToInt32(Console.ReadLine());
+                var retour = paragraphController.UpdateParagraph(id, new ParagraphDTO(id, title, content, info, query, comment, lesson));
+                if (retour.GetType() == typeof(OkObjectResult))
+                {
+                    Console.WriteLine("Mise à jour effectué avec succès !");
+                }
+                else
+                {
+                    Console.WriteLine("Une erreur est survenue lors de la mise à jour.");
+                }
+            }
+        }
+        else
+        {
+            Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
+        }
+
+    }
+
+    void UpdateLesson()
+    {
+        Console.WriteLine("Quel est l'identifiant de la leçon à mettre à jour ?");
+        var id = int.Parse(Console.ReadLine());
+        var res = (lessonController.GetLessonById(id));
+        if (res.GetType() == typeof(OkObjectResult))
+        {
+            var lesson = (res as OkObjectResult).Value as LessonDTO;
+            if (lesson == null)
+            {
+                Console.WriteLine("Erreur, un problème est survenu");
+                return;
+            }
+            else
+            {
+                Console.WriteLine("Leçon trouvée !\n");
+                Console.WriteLine("Veuillez saisir le titre :");
+                var title = Console.ReadLine();
+                Console.WriteLine("Veuillez saisir votre nom :");
+                var lastPublisher = Console.ReadLine();
+                var retour = lessonController.UpdateLesson(id, new LessonDTO(id, title, lastPublisher, DateOnly.FromDateTime(DateTime.Now)));
+                if (retour.GetType() == typeof(OkObjectResult))
+                {
+                    Console.WriteLine("Mise à jour effectué avec succès !");
+                }
+                else
+                {
+                    Console.WriteLine("Une erreur est survenue lors de la mise à jour.");
+                }
+            }
+        }
+        else
+        {
+            Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
+        }
+
+    }
+
+    void UpdateSuccess()
+    {
+        Console.WriteLine("Quel est l'identifiant de l'utilisateur lié au succès à mettre à jour ?");
+        var id = int.Parse(Console.ReadLine());
+        var res = (successController.GetSuccessByUserId(id));
+        if (res.GetType() == typeof(OkObjectResult))
+        {
+            var lesson = (res as OkObjectResult).Value as SuccessDTO;
+            if (lesson == null)
+            {
+                Console.WriteLine("Erreur, un problème est survenu");
+                return;
+            }
+            else
+            {
+                Console.WriteLine("Succès trouvé !\n");
+                Console.WriteLine("Veuillez saisir l'identifiant de l'utilisateur lié au succès :");
+                var userId = Console.ReadLine();
+                Console.WriteLine("Veuillez saisir l'identifiant de l'enquête lié au succès :");
+                var inquiryId = Console.ReadLine();
+                Console.WriteLine("Veuillez saisir si l'enquête est terminée (0/1) :");
+                var isFinished = Console.ReadLine();
+                var retour = successController.UpdateSuccess(id, new SuccessDTO(int.Parse(userId), int.Parse(inquiryId), bool.Parse(isFinished)));
+                if (retour.GetType() == typeof(OkObjectResult))
+                {
+                    Console.WriteLine("Mise à jour effectué avec succès !");
+                }
+                else
+                {
+                    Console.WriteLine("Une erreur est survenue lors de la mise à jour.");
+                }
+            }
+        }
+        else
+        {
+            Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
+        }
+
     }
 
     void DeleteUser()
     {
         Console.WriteLine("Quel est l'identifiant de lutilisateur à supprimer ?");
         var id = int.Parse(Console.ReadLine());
-        var res = controller.DeleteUser(id);
+        var res = userController.DeleteUser(id);
-        if(res.GetType() == typeof(OkObjectResult))
+        if (res.GetType() == typeof(OkObjectResult))
+        {
+            Console.WriteLine("La suppression a été effectuée avec succès !");
+        }
+        else
+        {
+            Console.WriteLine("Erreur lors de la suppression !");
+        }
+
+    }
+
+    void DeleteInquiry()
+    {
+        Console.WriteLine("Quel est l'identifiant de l'enquête à supprimer ?");
+        var id = int.Parse(Console.ReadLine());
+        var res = inquiryController.DeleteInquiry(id);
+        if (res.GetType() == typeof(OkObjectResult))
+        {
+            Console.WriteLine("La suppression a été effectuée avec succès !");
+        }
+        else
+        {
+            Console.WriteLine("Erreur lors de la suppression !");
+        }
+    }
+
+    void DeleteParagraph()
+    {
+        Console.WriteLine("Quel est l'identifiant du paragraphe à supprimer ?");
+        var id = int.Parse(Console.ReadLine());
+        var res = paragraphController.DeleteParagraph(id);
+        if (res.GetType() == typeof(OkObjectResult))
+        {
+            Console.WriteLine("La suppression a été effectuée avec succès !");
+        }
+        else
+        {
+            Console.WriteLine("Erreur lors de la suppression !");
+        }
+
+    }
+
+    void DeleteLesson()
+    {
+        Console.WriteLine("Quel est l'identifiant de la leçon à supprimer ?");
+        var id = int.Parse(Console.ReadLine());
+        var res = lessonController.DeleteLesson(id);
+        if (res.GetType() == typeof(OkObjectResult))
         {
             Console.WriteLine("La suppression a été effectuée avec succès !");
         }
@@ -121,13 +592,29 @@ using (var context = new UserDbContext(options))
         {
             Console.WriteLine("Erreur lors de la suppression !");
         }
+
     }
 
+    void DeleteSuccess()
+    {
+        Console.WriteLine("Quel est l'identifiant de l'utilisateur lié au succès à supprimer ?");
+        var id = int.Parse(Console.ReadLine());
+        var res = successController.DeleteSuccess(id);
+        if (res.GetType() == typeof(OkObjectResult))
+        {
+            Console.WriteLine("La suppression a été effectuée avec succès !");
+        }
+        else
+        {
+            Console.WriteLine("Erreur lors de la suppression !");
+        }
+
+    }
 
-    void Menu()
+    void MenuUsers()
     {
         Console.WriteLine("|------------------------------------------------|");
-        Console.WriteLine("|                       Menu                     |");
+        Console.WriteLine("|                  MenuUsers                     |");
         Console.WriteLine("|------------------------------------------------|");
         Console.WriteLine("| t - Effectuer des tests automatiques           |");
         Console.WriteLine("| 1 - Afficher les utilisateurs                  |");
@@ -140,33 +627,122 @@ using (var context = new UserDbContext(options))
         Console.WriteLine("|------------------------------------------------|");
     }
 
-    Menu();
+    void MenuInquiries()
+    {
+        Console.WriteLine("|------------------------------------------------|");
+        Console.WriteLine("|                  MenuInquiries                 |");
+        Console.WriteLine("|------------------------------------------------|");
+        Console.WriteLine("| 1 - Afficher les enquêtes                      |");
+        Console.WriteLine("| 2 - Rechercher une enquête avec son titre      |");
+        Console.WriteLine("| 3 - Rechercher une enquête avec son ID         |");
+        Console.WriteLine("| 4 - Ajouter une enquête                        |");
+        Console.WriteLine("| 5 - Mettre à jour une enquête                  |");
+        Console.WriteLine("| 6 - Supprimer une enquête                      |");
+        Console.WriteLine("| q - Quitter                                    |");
+        Console.WriteLine("|------------------------------------------------|");
+    }
+
+    void MenuParagraphs()
+    {
+        Console.WriteLine("|------------------------------------------------|");
+        Console.WriteLine("|                  MenuParagraphs                |");
+        Console.WriteLine("|------------------------------------------------|");
+        Console.WriteLine("| 1 - Afficher les paragraphes                   |");
+        Console.WriteLine("| 2 - Rechercher un paragraphe avec son titre    |");
+        Console.WriteLine("| 3 - Rechercher un paragraphe avec son ID       |");
+        Console.WriteLine("| 4 - Ajouter un paragraphe                      |");
+        Console.WriteLine("| 5 - Mettre à jour un paragraphe                |");
+        Console.WriteLine("| 6 - Supprimer un paragraphe                    |");
+        Console.WriteLine("| q - Quitter                                    |");
+        Console.WriteLine("|------------------------------------------------|");
+    }
+
+    void MenuLessons()
+    {
+        Console.WriteLine("|------------------------------------------------|");
+        Console.WriteLine("|                  MenuLessons                   |");
+        Console.WriteLine("|------------------------------------------------|");
+        Console.WriteLine("| 1 - Afficher les leçons                        |");
+        Console.WriteLine("| 2 - Rechercher une leçon avec son titre        |");
+        Console.WriteLine("| 3 - Rechercher une leçon avec son ID           |");
+        Console.WriteLine("| 4 - Ajouter une leçon                          |");
+        Console.WriteLine("| 5 - Mettre à jour une leçon                    |");
+        Console.WriteLine("| 6 - Supprimer une leçon                        |");
+        Console.WriteLine("| q - Quitter                                    |");
+        Console.WriteLine("|------------------------------------------------|");
+    }
+
+    void MenuSuccesses()
+    {
+        Console.WriteLine("|------------------------------------------------|");
+        Console.WriteLine("|                  MenuSuccesses                 |");
+        Console.WriteLine("|------------------------------------------------|");
+        Console.WriteLine("| 1 - Afficher les succès                        |");
+        Console.WriteLine("| 2 - Rechercher un succès avec son userId       |");
+        Console.WriteLine("| 3 - Rechercher un succès avec son inquiryId    |");
+        Console.WriteLine("| 4 - Ajouter un succès                          |");
+        Console.WriteLine("| 5 - Mettre à jour un succès                    |");
+        Console.WriteLine("| 6 - Supprimer un succès                        |");
+        Console.WriteLine("| q - Quitter                                    |");
+        Console.WriteLine("|------------------------------------------------|");
+    }
+
+    MenuUsers();
+    //MenuInquiries();
+    //MenuParagraphs();
+    //MenuLessons();
+    //MenuSuccesses();
     Console.WriteLine("\nSaisie :");
     var saisie = Console.ReadLine();
 
-    while (saisie != "q") {
+    while (saisie != "q")
+    {
         switch (saisie)
         {
             case "1":
-                PrintUsers(); 
+                PrintUsers();
+                //PrintInquiries();
+                //PrintParagraphs();
+                //PrintLessons();
+                //PrintSuccesses();
                 break;
             case "2":
                 SearchUserByUsername();
+                //SearchInquiryByTitle();
+                //SearchParagraphByTitle();
+                //SearchLessonByTitle();
+                //SearchSuccessByUserId();
                 break;
             case "3":
                 SearchUserById();
+                //SearchInquiryById();
+                //SearchParagraphById();
+                //SearchLessonById();
+                //SearchSuccessByInquiryId();
                 break;
             case "4":
                 AddUser();
+                //AddInquiry();
+                //AddParagraph();
+                //AddLesson();
+                //AddSuccess();
                 break;
             case "5":
                 UpdateUser();
+                //UpdateInquiry();
+                //UpdateParagraph();
+                //UpdateLesson();
+                //UpdateSuccess();
                 break;
             case "6":
                 DeleteUser();
+                //DeleteInquiry();
+                //DeleteParagraph();
+                //DeleteLesson();
+                //UpdateSuccess();
                 break;
             case "t":
-                AutoTests();
+                AutoTestsUsers();
                 break;
             default:
                 break;
@@ -174,25 +750,30 @@ using (var context = new UserDbContext(options))
         Console.WriteLine("\nAppuyez sur n'importe quelle touche pour continuer...");
         Console.ReadKey();
         Console.Clear();
-        Menu();
+        MenuUsers();
+        //MenuInquiries();
+        //MenuParagraphs();
+        //MenuLessons();
+        //MenuSuccesses();
         Console.WriteLine("\nSaisie :");
         saisie = Console.ReadLine();
     }
 
-    void AutoTests()
+    void AutoTestsUsers()
     {
         // Affichage des utilisateurs
         Console.WriteLine("\n##########################################################\n");
         Console.WriteLine("Affichages des utilisateurs stubbés dans le contexte :\n");
-        var res = controller.GetUsers(1, 10) as OkObjectResult;
+        var res = userController.GetUsers(1, 10, UserOrderCriteria.None);
-        if(res == null)
+        if (res == null)
         {
             Console.WriteLine("\nErreur lors de l'acquisition de la liste des utilisateurs");
         }
         else
         {
-            var users = res.Value as IEnumerable<UserDTO>;
+            var users = res as IEnumerable<UserDTO>;
-            if(users == null) { 
+            if (users == null)
+            {
                 Console.WriteLine("\nErreur, les ustilisateurs n'ont pas été trouvés !");
             }
             else
@@ -204,14 +785,14 @@ using (var context = new UserDbContext(options))
         // Recherche d'utilisateur par ID
         Console.WriteLine("\n##########################################################\n");
         Console.WriteLine("Affichage de l'utilisateur ayant pour identifiant 1 :\n");
-        var res1 = controller.GetUserById(1) as OkObjectResult;
+        var res1 = userController.GetUserById(1);
         if (res1 == null)
         {
             Console.WriteLine("\nErreur lors de l'acquisition de l'utilisateur !");
         }
         else
         {
-            var user = res1.Value as UserDTO;
+            var user = res1;
             if (user == null)
             {
                 Console.WriteLine("\nErreur, l'utilisateur n'existe pas !");
@@ -225,14 +806,14 @@ using (var context = new UserDbContext(options))
         // Recherche d'utilisateur par pseudonyme
         Console.WriteLine("\n##########################################################\n");
         Console.WriteLine("Affichage de l'utilisateur ayant pour username johnny :\n");
-        var res2 = controller.GetUserByUsername("johnny") as OkObjectResult;
+        var res2 = userController.GetUserByUsername("johnny");
         if (res2 == null)
         {
             Console.WriteLine("\nErreur lors de l'acquisition de l'utilisateur !");
         }
         else
         {
-            var user1 = res2.Value as UserDTO;
+            var user1 = res2;
             if (user1 == null)
             {
                 Console.WriteLine("\nErreur, l'utilisateur n'existe pas !");
@@ -248,7 +829,7 @@ using (var context = new UserDbContext(options))
         Console.WriteLine("Création de l'utilisateur :\n");
         var user2 = new UserDTO("JohnDoe", "motdepasse", "johndoe@gmail.com", false);
         Console.WriteLine(user2);
-        var res3 = controller.CreateUser(user2) as CreatedResult;
+        var res3 = userController.CreateUser(user2);
         if (res3 == null)
         {
             Console.WriteLine("\nErreur lors de la création de l'utilisateur !");
@@ -265,8 +846,7 @@ using (var context = new UserDbContext(options))
         // Mise à jour d'un utilisateur
         Console.WriteLine("\n##########################################################\n");
         Console.WriteLine("Mise à jour de l'adresse email de l'utilisateur :\n");
-        user2 = ((controller.GetUserByUsername("JohnDoe") as OkObjectResult).Value as UserDTO);
+        if (userController.GetUserByUsername("JohnDoe") == null)
-        if (user2 == null)
         {
             Console.WriteLine("\nErreur lors de la récupération de l'utilisateur !");
         }
@@ -275,7 +855,7 @@ using (var context = new UserDbContext(options))
             Console.WriteLine(user2);
             Console.WriteLine("\nNouvelle adresse : John.DOE@etu.uca.fr");
             var user3 = new UserDTO(user2.Id, user2.Username, user2.Password, "John.DOE@etu.uca.fr", user2.IsAdmin);
-            var res4 = controller.UpdateUser(user2.Id, user3) as OkObjectResult;
+            var res4 = userController.UpdateUser(1, user3);
             if (res4 == null)
             {
                 Console.WriteLine("\nErreur lors de la mise à jour de l'utilisateur !");
@@ -293,15 +873,14 @@ using (var context = new UserDbContext(options))
         // Suppression d'un utilisateur
         Console.WriteLine("\n##########################################################\n");
         Console.WriteLine("Suppression de l'utilisateur JohnDoe:\n");
-        user2 = ((controller.GetUserByUsername("JohnDoe") as OkObjectResult).Value as UserDTO);
+        if (userController.GetUserByUsername("JohnDoe") == null)
-        if (user2 == null)
         {
             Console.WriteLine("\nErreur lors de la récupération de l'utilisateur !");
         }
         else
         {
             Console.WriteLine(user2);
-            var res5 = controller.DeleteUser(user2.Id) as OkObjectResult;
+            var res5 = userController.DeleteUser(user2.Id);
             if (res5 == null)
             {
                 Console.WriteLine("\nErreur lors de la suppression de l'utilisateur !");

API_SQLuedo/TestConsoleEf/Program.cs

@@ -0,0 +1,251 @@
+using System.Security.Cryptography;
+using DbContextLib;
+using Entities;
+using Microsoft.AspNetCore.Cryptography.KeyDerivation;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using StubbedContextLib;
+
+var connection = new SqliteConnection("DataSource=:memory:");
+connection.Open();
+var options = new DbContextOptionsBuilder<UserDbContext>()
+    .UseSqlite(connection)
+    .Options;
+
+
+// Partie sur les utilisateurs
+using (var db = new StubbedContext(options))
+{
+    await db.Database.EnsureCreatedAsync();
+
+    // Test sur les utilisateurs
+    var users = db.Users;
+
+    // Affichage de tous les utilisateurs
+    Console.WriteLine("Affichage des noms des utilisateurs");
+    foreach (var user in users)
+    {
+        Console.WriteLine(user.Username);
+    }
+
+    // Affichage des utilisateurs filtrés
+    Console.WriteLine("\nAffichage des utilisateurs contenant e");
+    var filteredUsers = users.Where(u => u.Username.Contains("e"));
+    foreach (var user in filteredUsers)
+    {
+        Console.WriteLine(user.Username);
+    }
+
+    // Affichage des utilisateurs triés
+    Console.WriteLine("\nAffichage des utilisateurs triés selon leur nom");
+    var orderedUsers = users.OrderBy(u => u.Username);
+    foreach (var user in orderedUsers)
+    {
+        Console.WriteLine(user.Username);
+    }
+
+    // Ajout d'un utilisateur
+    Console.WriteLine("\nAjout du nouvel utilisateur");
+    var newUser = new UserEntity("le nouveau du groupe", Convert.ToBase64String(KeyDerivation.Pbkdf2(
+        password: "motdepasse",
+        salt: RandomNumberGenerator.GetBytes(128 / 8),
+        prf: KeyDerivationPrf.HMACSHA256,
+        iterationCount: 100000,
+        numBytesRequested: 256 / 8)), "Efff.fffff@etu.uca.fr", true);
+    if (!users.Any(u => u.Username == newUser.Username))
+    {
+        users.Add(newUser);
+        await db.SaveChangesAsync();
+    }
+}
+
+using (var db = new StubbedContext(options))
+{
+    await db.Database.EnsureCreatedAsync();
+
+    var users = db.Users;
+    // Affichage du nouvel utilisateur
+    Console.WriteLine("\nAffichage du nouvel utilisateur");
+    var u = await users.FirstOrDefaultAsync(u => u.Username == "le nouveau du groupe");
+    foreach (var pptt in typeof(UserEntity).GetProperties().Where(p => p.CanWrite && p.Name != nameof(UserEntity.Id)))
+    {
+        Console.WriteLine(pptt.GetValue(u));
+    }
+
+    if (u != null)
+    {
+        // Suppression du nouvel utilisateur
+        Console.WriteLine("\nSuppression du nouvel utilisateur");
+        db.Users.Remove(u);
+        await db.SaveChangesAsync();
+    }
+}
+
+using (var db = new StubbedContext(options))
+{
+    await db.Database.EnsureCreatedAsync();
+
+    var users = db.Users;
+    // Affichage des utilisateurs après suppression
+    Console.WriteLine("\nAffichage des utilisateurs après suppression");
+    foreach (var user in users)
+    {
+        Console.WriteLine(user.Username);
+    }
+
+    // Modification d'un utilisateur
+    Console.WriteLine("\nModification de l'utilisateur clement");
+    var userToModify = await users.FirstOrDefaultAsync(u => u.Username == "clement");
+    if (userToModify != null)
+    {
+        userToModify.Username = "clement modifié";
+        await db.SaveChangesAsync();
+    }
+}
+
+using (var db = new StubbedContext(options))
+{
+    await db.Database.EnsureCreatedAsync();
+
+    var users = db.Users;
+    // Affichage des utilisateurs après modification
+    var userToModify = await users.FirstOrDefaultAsync(u => u.Username == "clement modifié");
+    if (userToModify != null)
+    {
+        Console.WriteLine("\nAffichage de l'utilisateur après modification");
+        Console.WriteLine(userToModify.Username);
+        // Rollback
+        userToModify = await users.FirstOrDefaultAsync(u => u.Username == "clement modifié");
+        if (userToModify != null)
+        {
+            userToModify.Username = "clement";
+            await db.SaveChangesAsync();
+        }
+    }
+}
+
+// Partie sur les enquetes
+using (var db = new StubbedContext(options))
+{
+    await db.Database.EnsureCreatedAsync();
+
+    // Test sur les enquetes
+    var inquiries = db.Inquiries;
+
+    // Affichage de toutes les enquetes
+    Console.WriteLine("\nAffichage des noms des enquetes");
+    foreach (var inquiry in inquiries)
+    {
+        Console.WriteLine(inquiry.Title);
+    }
+
+    // Affichage des enquetes filtrées
+    Console.WriteLine("\nAffichage des enquetes contenant o");
+    var filteredInquiries = inquiries.Where(i => i.Title.Contains("o"));
+    foreach (var inquiry in filteredInquiries)
+    {
+        Console.WriteLine(inquiry.Title);
+    }
+
+    // Affichage des enquetes triées
+    Console.WriteLine("\nAffichage des enquetes triées selon leur nom");
+    var orderedInquiries = inquiries.OrderBy(i => i.Title);
+    foreach (var inquiry in orderedInquiries)
+    {
+        Console.WriteLine(inquiry.Title);
+    }
+
+    var solutions = db.Solutions;
+
+    // Affichage 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");
+    Console.WriteLine(sol.MurdererFirstName);
+    
+    var inquirySolution = await inquiries.FirstOrDefaultAsync(i => i.Title == "L'enquête sur les orang outan");
+    var i = inquirySolution.Id;
+    foreach (var pptt in typeof(SolutionEntity).GetProperties()
+                 .Where(p => p.CanWrite && p.Name != nameof(SolutionEntity.Owner)))
+    {
+        Console.WriteLine(pptt.GetValue(i));
+    }
+
+    // Ajout d'une enquete
+    Console.WriteLine("\nAjout de la nouvelle enquete");
+    var newInquiry = new InquiryEntity(
+        "La nouvelle enquete",
+        "La description de la nouvelle enquete",
+        true);
+    if (!inquiries.Any(inquiry => inquiry.Title == newInquiry.Title))
+    {
+        inquiries.Add(newInquiry);
+        await db.SaveChangesAsync();
+    }
+}
+
+using (var db = new StubbedContext(options))
+{
+    await db.Database.EnsureCreatedAsync();
+
+    var inquiries = db.Inquiries;
+    // Affichage de la nouvelle enquete
+    Console.WriteLine("\nAffichage de la nouvelle enquete");
+    var i = await inquiries.FirstOrDefaultAsync(i => i.Title == "La nouvelle enquete");
+    foreach (var pptt in typeof(InquiryEntity).GetProperties()
+                 .Where(p => p.CanWrite && p.Name != nameof(InquiryEntity.Id)))
+    {
+        Console.WriteLine(pptt.GetValue(i));
+    }
+
+    if (i != null)
+    {
+        // Suppression de la nouvelle enquete
+        Console.WriteLine("\nSuppression de la nouvelle enquete");
+        db.Inquiries.Remove(i);
+        await db.SaveChangesAsync();
+    }
+}
+
+using (var db = new StubbedContext(options))
+{
+    await db.Database.EnsureCreatedAsync();
+
+    var inquiries = db.Inquiries;
+    // Affichage des utilisateurs après suppression
+    Console.WriteLine("\nAffichage des utilisateurs après suppression");
+    foreach (var inquiry in inquiries)
+    {
+        Console.WriteLine(inquiry.Title);
+    }
+
+    // Modification d'une enquete
+    Console.WriteLine("\nModification de l'enquete L'enquête de la carotte");
+    var inquiryToModify = await inquiries.FirstOrDefaultAsync(i => i.Title == "L'enquête de la carotte");
+    if (inquiryToModify != null)
+    {
+        inquiryToModify.Title = "L'enquête de la carotte modifiée";
+        await db.SaveChangesAsync();
+    }
+}
+
+using (var db = new StubbedContext(options))
+{
+    await db.Database.EnsureCreatedAsync();
+
+    var inquiries = db.Inquiries;
+    // Affichage des enquetes après modification
+    var inquiryToModify = await inquiries.FirstOrDefaultAsync(i => i.Title == "L'enquête de la carotte modifiée");
+    if (inquiryToModify != null)
+    {
+        Console.WriteLine("\nAffichage de l'enquete après modification");
+        Console.WriteLine(inquiryToModify.Title);
+        // Rollback
+        inquiryToModify = await inquiries.FirstOrDefaultAsync(i => i.Title == "L'enquête de la carotte modifiée");
+        if (inquiryToModify != null)
+        {
+            inquiryToModify.Title = "L'enquête de la carotte";
+            await db.SaveChangesAsync();
+        }
+    }
+}

API_SQLuedo/TestConsoleEf/TestConsoleEf.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\EntityFramework\Entities.csproj" />
+      <ProjectReference Include="..\Model\Model.csproj" />
+      <ProjectReference Include="..\StubbedContextLib\StubbedContextLib.csproj" />
+    </ItemGroup>
+
+</Project>

API_SQLuedo/TestEF/EntitiesTests/ConcreteContentLessonEntity.cs

@@ -0,0 +1,21 @@
+using Entities;
+
+namespace TestEF.EntitiesTests;
+
+public class ConcreteContentLessonEntity : ContentLessonEntity
+{
+    public ConcreteContentLessonEntity(int id, string contentContent, string contentTitle)
+        : base(id, contentContent, contentTitle)
+    {
+    }
+
+    public ConcreteContentLessonEntity(int id, int lessonId, string contentContent, string contentTitle)
+        : base(id, lessonId, contentContent, contentTitle)
+    {
+    }
+
+    public ConcreteContentLessonEntity(string contentContent, string contentTitle)
+        : base(contentContent, contentTitle)
+    {
+    }
+}

API_SQLuedo/TestEF/EntitiesTests/TestBlackListEntity.cs

@@ -0,0 +1,54 @@
+using Model;
+
+namespace TestEF.EntitiesTests;
+
+public class TestBlackListEntity
+{
+    [Fact]
+    public void Constructor_ShouldSetProperties_WhenCalledWithTwoParameters()
+    {
+        // Arrange
+        string email = "test@example.com";
+        DateOnly expirationDate = DateOnly.FromDateTime(DateTime.Now.AddDays(10));
+
+        // Act
+        var blackList = new BlackList(email, expirationDate);
+
+        // Assert
+        Assert.Equal(email, blackList.Email);
+        Assert.Equal(expirationDate, blackList.ExpirationDate);
+    }
+
+    [Fact]
+    public void Constructor_ShouldThrowArgumentException_WhenEmailIsEmpty()
+    {
+        // Arrange
+        string email = string.Empty;
+        DateOnly expirationDate = DateOnly.FromDateTime(DateTime.Now.AddDays(10));
+
+        // Act & Assert
+        Assert.Throws<ArgumentException>(() => new BlackList(email, expirationDate));
+    }
+
+    [Fact]
+    public void Constructor_ShouldThrowArgumentException_WhenEmailIsNull()
+    {
+        // Arrange
+        string email = null;
+        DateOnly expirationDate = DateOnly.FromDateTime(DateTime.Now.AddDays(10));
+
+        // Act & Assert
+        Assert.Throws<ArgumentException>(() => new BlackList(email, expirationDate));
+    }
+
+    [Fact]
+    public void Constructor_ShouldThrowArgumentOutOfRangeException_WhenExpirationDateIsInThePast()
+    {
+        // Arrange
+        string email = "test@example.com";
+        DateOnly expirationDate = DateOnly.FromDateTime(DateTime.Now.AddDays(-1));
+
+        // Act & Assert
+        Assert.Throws<ArgumentOutOfRangeException>(() => new BlackList(email, expirationDate));
+    }
+}

API_SQLuedo/TestEF/EntitiesTests/TestContentLessonEntity.cs

@@ -0,0 +1,55 @@
+namespace TestEF.EntitiesTests;
+
+public class TestContentLessonEntity
+{
+    [Fact]
+    public void Constructor_ShouldSetProperties_WhenCalledWithTwoParameters()
+    {
+        // Arrange
+        const string contentContent = "Content";
+        const string contentTitle = "Title";
+
+        // Act
+        var concreteContentLessonEntity = new ConcreteContentLessonEntity(contentContent, contentTitle);
+
+        // Assert
+        Assert.Equal(contentContent, concreteContentLessonEntity.ContentContent);
+        Assert.Equal(contentTitle, concreteContentLessonEntity.ContentTitle);
+    }
+
+    [Fact]
+    public void Constructor_ShouldSetProperties_WhenCalledWithThreeParameters()
+    {
+        // Arrange
+        const int id = 1;
+        const string contentContent = "Content";
+        const string contentTitle = "Title";
+
+        // Act
+        var concreteContentLessonEntity = new ConcreteContentLessonEntity(id, contentContent, contentTitle);
+
+        // Assert
+        Assert.Equal(id, concreteContentLessonEntity.Id);
+        Assert.Equal(contentContent, concreteContentLessonEntity.ContentContent);
+        Assert.Equal(contentTitle, concreteContentLessonEntity.ContentTitle);
+    }
+
+    [Fact]
+    public void Constructor_ShouldSetProperties_WhenCalledWithFourParameters()
+    {
+        // Arrange
+        const int id = 1;
+        const int lessonId = 2;
+        const string contentContent = "Content";
+        const string contentTitle = "Title";
+
+        // Act
+        var concreteContentLessonEntity = new ConcreteContentLessonEntity(id, lessonId, contentContent, contentTitle);
+
+        // Assert
+        Assert.Equal(id, concreteContentLessonEntity.Id);
+        Assert.Equal(lessonId, concreteContentLessonEntity.LessonId);
+        Assert.Equal(contentContent, concreteContentLessonEntity.ContentContent);
+        Assert.Equal(contentTitle, concreteContentLessonEntity.ContentTitle);
+    }
+}

API_SQLuedo/TestEF/EntitiesTests/TestInquiryEntity.cs

@@ -0,0 +1,51 @@
+using Entities;
+
+namespace TestEF.EntitiesTests;
+
+public class TestInquiryEntity
+{
+    private const int _id = 42;
+    private const string _title = "Title";
+    private const string _description = "_description";
+    private const bool _isUser = true;
+
+    [Fact]
+    public void TestDefaultConstructor()
+    {
+        InquiryEntity inquiry = new InquiryEntity();
+        Assert.Equal(0, inquiry.Id);
+        Assert.Null(inquiry.Title);
+        Assert.Null(inquiry.Description);
+        Assert.False(inquiry.IsUser);
+    }
+    
+    [Fact]
+    public void TestConstructorWithOnlyId()
+    {
+        InquiryEntity inquiry = new InquiryEntity(_id);
+        Assert.Equal(_id, inquiry.Id);
+        Assert.Null(inquiry.Title);
+        Assert.Null(inquiry.Description);
+        Assert.False(inquiry.IsUser);
+    }
+    
+    [Fact]
+    public void TestConstructorWithoutId()
+    {
+        InquiryEntity inquiry = new InquiryEntity(_title,_description,_isUser);
+        Assert.Equal(0, inquiry.Id);
+        Assert.Equal(_title,inquiry.Title);
+        Assert.Equal(_description,inquiry.Description);
+        Assert.True(inquiry.IsUser);
+    }
+    
+    [Fact]
+    public void TestConstructorWithAllAttributes()
+    {
+        InquiryEntity inquiry = new InquiryEntity(_id,_title,_description,_isUser);
+        Assert.Equal(_id, inquiry.Id);
+        Assert.Equal(_title,inquiry.Title);
+        Assert.Equal(_description,inquiry.Description);
+        Assert.True(inquiry.IsUser);
+    }
+}

API_SQLuedo/TestEF/EntitiesTests/TestInquiryTableEntity.cs

@@ -0,0 +1,52 @@
+using Entities;
+
+namespace TestEF;
+
+public class TestInquiryTableEntity
+{
+    private const int _inquiryId = 42;
+    private static InquiryEntity _inquiry = new InquiryEntity();
+    private const string _databaseName = "Database";
+    private const string _connectionInfo = "Connection";
+
+    [Fact]
+    public void TestDefaultConstructor()
+    {
+        InquiryTableEntity tableEntity = new InquiryTableEntity();
+        Assert.Equal(0,tableEntity.OwnerId);
+        Assert.Null(tableEntity.Owner);
+        Assert.Null(tableEntity.DatabaseName);
+        Assert.Null(tableEntity.ConnectionInfo);
+    }
+    
+    [Fact]
+    public void TestConstructorWithOnlyId()
+    {
+        InquiryTableEntity tableEntity = new InquiryTableEntity(_inquiryId);
+        Assert.Equal(_inquiryId,tableEntity.OwnerId);
+        Assert.Null(tableEntity.Owner);
+        Assert.Null(tableEntity.DatabaseName);
+        Assert.Null(tableEntity.ConnectionInfo);
+    }
+    
+    
+    [Fact]
+    public void TestConstructorWithoutId()
+    {
+        InquiryTableEntity tableEntity = new InquiryTableEntity(_inquiry,_databaseName,_connectionInfo);
+        Assert.Equal(0,tableEntity.OwnerId);
+        Assert.Equal(_inquiry,tableEntity.Owner);
+        Assert.Equal(_databaseName,tableEntity.DatabaseName);
+        Assert.Equal(_connectionInfo,tableEntity.ConnectionInfo);
+    }
+    
+    [Fact]
+    public void TestConstructorWithoutNavigationProperty()
+    {
+        InquiryTableEntity tableEntity = new InquiryTableEntity(_inquiryId,_databaseName,_connectionInfo);
+        Assert.Equal(_inquiryId,tableEntity.OwnerId);
+        Assert.Null(tableEntity.Owner);
+        Assert.Equal(_databaseName,tableEntity.DatabaseName);
+        Assert.Equal(_connectionInfo,tableEntity.ConnectionInfo);
+    }
+}

API_SQLuedo/TestEF/EntitiesTests/TestLessonEntity.cs

@@ -0,0 +1,42 @@
+using Entities;
+using Microsoft.VisualBasic;
+
+namespace TestEF;
+
+public class TestLessonEntity
+{
+    private const int _id = 42;
+    private const string _title = "Title";
+    private const string _lastPublisher = "Last Publisher";
+    private static DateOnly _lastEdit = new DateOnly();
+
+    [Fact]
+    public void TestDefaultConstructor()
+    {
+        LessonEntity lesson = new LessonEntity();
+        Assert.Equal(0, lesson.Id);
+        Assert.Null(lesson.Title);
+        Assert.Null(lesson.LastPublisher);
+        Assert.Null(lesson.LastEdit);
+    }
+    
+    [Fact]
+    public void TestConstructorWithoutId()
+    {
+        LessonEntity lesson = new LessonEntity(_title,_lastPublisher,_lastEdit);
+        Assert.Equal(0, lesson.Id);
+        Assert.Equal(_title,lesson.Title);
+        Assert.Equal(_lastPublisher,lesson.LastPublisher);
+        Assert.Equal(_lastEdit,lesson.LastEdit);
+    }
+    
+    [Fact]
+    public void TestConstructorWithAllAttributes()
+    {
+        LessonEntity lesson = new LessonEntity(_id,_title,_lastPublisher,_lastEdit);
+        Assert.Equal(_id, lesson.Id);
+        Assert.Equal(_title,lesson.Title);
+        Assert.Equal(_lastPublisher,lesson.LastPublisher);
+        Assert.Equal(_lastEdit,lesson.LastEdit);
+    }
+}

API_SQLuedo/TestEF/EntitiesTests/TestNotepadEntity.cs

@@ -0,0 +1,49 @@
+using Entities;
+
+namespace TestEF;
+
+public class TestNotepadEntity
+{
+    private const int _id = 42;
+    private const int _userId = 42;
+    private static UserEntity _userEntity = new UserEntity();
+    private const int _inquiryId = 42;
+    private static InquiryEntity _inquiryEntity = new InquiryEntity();
+    private const string _notes = "This is some notes example";
+
+    [Fact]
+    public void TestDefaultConstructor()
+    {
+        NotepadEntity notepad = new NotepadEntity();
+        Assert.Equal(0,notepad.Id);
+        Assert.Equal(0,notepad.UserId);
+        Assert.Null(notepad.User);
+        Assert.Equal(0,notepad.InquiryId);
+        Assert.Null(notepad.Inquiry);
+        Assert.Null(notepad.Notes);
+    }
+    
+    [Fact]
+    public void TestConstructorWithoutId()
+    {
+        NotepadEntity notepad = new NotepadEntity(_userId,_userEntity,_inquiryId,_inquiryEntity,_notes);
+        Assert.Equal(0,notepad.Id);
+        Assert.Equal(_userId,notepad.UserId);
+        Assert.Equal(_userEntity,notepad.User);
+        Assert.Equal(_inquiryId,notepad.InquiryId);
+        Assert.Equal(_inquiryEntity,notepad.Inquiry);
+        Assert.Equal(_notes,notepad.Notes);
+    }
+    
+    [Fact]
+    public void TestConstructorWithAllAttributes()
+    {
+        NotepadEntity notepad = new NotepadEntity(_id,_userId,_userEntity,_inquiryId,_inquiryEntity,_notes);
+        Assert.Equal(_id,notepad.Id);
+        Assert.Equal(_userId,notepad.UserId);
+        Assert.Equal(_userEntity,notepad.User);
+        Assert.Equal(_inquiryId,notepad.InquiryId);
+        Assert.Equal(_inquiryEntity,notepad.Inquiry);
+        Assert.Equal(_notes,notepad.Notes);
+    }
+}

API_SQLuedo/TestEF/EntitiesTests/TestParagraphEntity.cs

@@ -0,0 +1,50 @@
+using Entities;
+
+namespace TestEF;
+
+public class TestParagraphEntity
+{
+    private const int _id = 42;
+    private const string _title = "Title";
+    private const string _info = "Info";
+    private const string _content = "Content";
+    private const string _query = "Query";
+    private const string _comment = "Comment";
+
+    [Fact]
+    public void TestDefaultConstructor()
+    {
+        ParagraphEntity paragraph = new ParagraphEntity();
+        Assert.Equal(0, paragraph.Id);
+        Assert.Null(paragraph.Title);
+        Assert.Null(paragraph.Info);
+        Assert.Null(paragraph.Content);
+        Assert.Null(paragraph.Query);
+        Assert.Null(paragraph.Comment);
+    }
+    
+    [Fact]
+    public void TestConstructorWithoutId()
+    {
+        ParagraphEntity paragraph = new ParagraphEntity(_title,_content,_info,_query,_comment);
+        Assert.Equal(0, paragraph.Id);
+        Assert.Equal(_title,paragraph.Title);
+        Assert.Equal(_info,paragraph.Info);
+        Assert.Equal(_content,paragraph.Content);
+        Assert.Equal(_query,paragraph.Query);
+        Assert.Equal(_comment,paragraph.Comment);
+    }
+    
+    [Fact]
+    public void TestConstructorWithAllAttributes()
+    {
+        ParagraphEntity paragraph = new ParagraphEntity(_id,_title,_content,_info,_query,_comment,10);
+        Assert.Equal(_id, paragraph.Id);
+        Assert.Equal(_title,paragraph.Title);
+        Assert.Equal(_info,paragraph.Info);
+        Assert.Equal(_content,paragraph.Content);
+        Assert.Equal(_query,paragraph.Query);
+        Assert.Equal(_comment,paragraph.Comment);
+        Assert.Equal(10, paragraph.LessonId);
+    }
+}

API_SQLuedo/TestEF/EntitiesTests/TestSolutionEntity.cs

@@ -0,0 +1,92 @@
+using Entities;
+
+namespace TestEF;
+
+public class TestSolutionEntity
+{
+    private const string _murdererFirstName = "John";
+    private const string _murdererLastName = "Doe";
+    private const string _murderPlace = "WhiteHouse";
+    private const string _murderWeapon = "Nuclear Bomb";
+    private const string _explaination = "This is an explaination";
+    private const int _inquiryId = 42;
+    private static InquiryEntity _inquiry = new InquiryEntity();
+
+    [Fact]
+    public void TestDefaultConstructor()
+    {
+        SolutionEntity solution = new SolutionEntity();
+        Assert.Equal(0, solution.OwnerId);
+        Assert.Null(solution.Owner);
+        Assert.Null(solution.MurdererFirstName);
+        Assert.Null(solution.MurdererLastName);
+        Assert.Null(solution.MurderPlace);
+        Assert.Null(solution.MurderWeapon);
+        Assert.Null(solution.Explaination);
+    }
+
+    [Fact]
+    public void TestConstructorWithOnlyId()
+    {
+        SolutionEntity solution = new SolutionEntity(_inquiryId);
+        Assert.Equal(_inquiryId, solution.OwnerId);
+        Assert.Null(solution.Owner);
+        Assert.Null(solution.MurdererFirstName);
+        Assert.Null(solution.MurdererLastName);
+        Assert.Null(solution.MurderPlace);
+        Assert.Null(solution.MurderWeapon);
+        Assert.Null(solution.Explaination);
+    }
+
+    [Fact]
+    public void TestConstructorWithoutOwnerId()
+    {
+        SolutionEntity solution = new SolutionEntity(_inquiry, _murdererFirstName, _murdererLastName, _murderPlace,
+            _murderWeapon, _explaination);
+        Assert.Equal(0, solution.OwnerId);
+        Assert.Equal(_inquiry, solution.Owner);
+        Assert.Equal(_murdererFirstName, solution.MurdererFirstName);
+        Assert.Equal(_murdererLastName, solution.MurdererLastName);
+        Assert.Equal(_murderPlace, solution.MurderPlace);
+        Assert.Equal(_murderWeapon, solution.MurderWeapon);
+        Assert.Equal(_explaination, solution.Explaination);
+    }
+
+    [Fact]
+    public void TestConstructorWithAllAttributes()
+    {
+        SolutionEntity solution = new SolutionEntity(_inquiryId, _inquiry, _murdererFirstName, _murdererLastName,
+            _murderPlace, _murderWeapon, _explaination);
+        Assert.Equal(_inquiryId, solution.OwnerId);
+        Assert.Equal(_inquiry, solution.Owner);
+        Assert.Equal(_murdererFirstName, solution.MurdererFirstName);
+        Assert.Equal(_murdererLastName, solution.MurdererLastName);
+        Assert.Equal(_murderPlace, solution.MurderPlace);
+        Assert.Equal(_murderWeapon, solution.MurderWeapon);
+        Assert.Equal(_explaination, solution.Explaination);
+    }
+
+    [Fact]
+    public void Constructor_ShouldSetProperties_WhenCalledWithSixParameters()
+    {
+        // Arrange
+        const int ownerId = 1;
+        const string murdererFirstName = "John";
+        const string murdererLastName = "Doe";
+        const string murderPlace = "WhiteHouse";
+        const string murderWeapon = "Nuclear Bomb";
+        const string explanation = "This is an explanation";
+
+        // Act
+        var solutionEntity = new SolutionEntity(ownerId, murdererFirstName, murdererLastName, murderPlace, murderWeapon,
+            explanation);
+
+        // Assert
+        Assert.Equal(ownerId, solutionEntity.OwnerId);
+        Assert.Equal(murdererFirstName, solutionEntity.MurdererFirstName);
+        Assert.Equal(murdererLastName, solutionEntity.MurdererLastName);
+        Assert.Equal(murderPlace, solutionEntity.MurderPlace);
+        Assert.Equal(murderWeapon, solutionEntity.MurderWeapon);
+        Assert.Equal(explanation, solutionEntity.Explaination);
+    }
+}

API_SQLuedo/TestEF/EntitiesTests/TestSuccessEntity.cs

@@ -0,0 +1,58 @@
+using Entities;
+
+namespace TestEF;
+
+public class TestSuccessEntity
+{
+    private const int _userId = 42;
+    private const int _inquiryId = 7;
+    private const bool _isFinished = true;
+
+    [Fact]
+    public void TestDefaultConstructor()
+    {
+        SuccessEntity success = new SuccessEntity();
+        Assert.Equal(0,success.UserId);
+        Assert.Null(success.User);
+        Assert.Equal(0,success.InquiryId);
+        Assert.Null(success.Inquiry);
+        Assert.False(success.IsFinished);
+    }
+    
+    [Fact]
+    public void TestConstructorWithIds()
+    {
+        SuccessEntity success = new SuccessEntity(_userId, _inquiryId, _isFinished);
+        Assert.Equal(_userId,success.UserId);
+        Assert.Null(success.User);
+        Assert.Equal(_inquiryId,success.InquiryId);
+        Assert.Null(success.Inquiry);
+        Assert.True(success.IsFinished);
+    }
+    
+    [Fact]
+    public void TestConstructorWithNavigationProperties()
+    {
+        UserEntity user = new UserEntity();
+        InquiryEntity inquiry = new InquiryEntity();
+        SuccessEntity success = new SuccessEntity(user, inquiry, _isFinished);
+        Assert.Equal(0,success.UserId);
+        Assert.NotNull(success.User);
+        Assert.Equal(0,success.InquiryId);
+        Assert.NotNull(success.Inquiry);
+        Assert.True(success.IsFinished);
+    }
+    
+    [Fact]
+    public void TestConstructorWithAllAttributes()
+    {
+        UserEntity user = new UserEntity();
+        InquiryEntity inquiry = new InquiryEntity();
+        SuccessEntity success = new SuccessEntity(_userId, user,  _inquiryId, inquiry, _isFinished);
+        Assert.Equal(_userId,success.UserId);
+        Assert.NotNull(success.User);
+        Assert.Equal(_inquiryId,success.InquiryId);
+        Assert.NotNull(success.Inquiry);
+        Assert.True(success.IsFinished);
+    }
+}

API_SQLuedo/TestEF/EntitiesTests/TestUserEntity.cs

@@ -0,0 +1,56 @@
+using Entities;
+
+namespace TestEF
+{
+    public class TestUserEntity
+    {
+        private const string _username = "username";
+        private const string _email = "example@email.com";
+        private const string _password = "password";
+        private const bool _isAdmin = true;
+        private const int _id = 42;
+        [Fact]
+        public void TestDefaultConstructor()
+        {
+            UserEntity user = new UserEntity();
+            Assert.Equal(0,user.Id);
+            Assert.Null(user.Username);
+            Assert.Null(user.Email);
+            Assert.Null(user.Password);
+            Assert.False(user.IsAdmin);
+        }
+
+        [Fact]
+        public void TestConstructorWithOnlyId()
+        {
+            UserEntity user = new UserEntity(_id);
+            Assert.Equal(_id,user.Id);
+            Assert.Null(user.Username);
+            Assert.Null(user.Email);
+            Assert.Null(user.Password);
+            Assert.False(user.IsAdmin);
+        }
+
+        [Fact]
+        public void TestConstructorWithoutId()
+        {
+            UserEntity user = new UserEntity(_username, _password, _email, _isAdmin);
+            Assert.Equal(0,user.Id);
+            Assert.Equal(_username, user.Username);
+            Assert.Equal(_email, user.Email);
+            Assert.Equal(_password, user.Password);
+            Assert.True(user.IsAdmin);
+        }
+        
+        [Fact]
+        public void TestConstructorWithoutAllAttributes()
+        {
+            UserEntity user = new UserEntity(_id, _username, _password, _email, _isAdmin);
+            Assert.Equal(_id,user.Id);
+            Assert.Equal(_username, user.Username);
+            Assert.Equal(_email, user.Email);
+            Assert.Equal(_password, user.Password);
+            Assert.True(user.IsAdmin);
+        }
+    }
+}

API_SQLuedo/TestEF/TestEF.csproj

@@ -34,4 +34,11 @@
     </PackageReference>
   </ItemGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="..\DbContextLib\DbContextLib.csproj" />
+    <ProjectReference Include="..\DbDataManager\DbDataManager.csproj" />
+    <ProjectReference Include="..\EntityFramework\Entities.csproj" />
+    <ProjectReference Include="..\StubbedContextLib\StubbedContextLib.csproj" />
+  </ItemGroup>
+
 </Project>

API_SQLuedo/TestEF/UnitTest1.cs

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