Merge pull request 'merge' (#32) from merge into master

Reviewed-on: #32

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 IInquiryDataService _inquiryDataService;
-        public InquiriesController(IInquiryService<InquiryDTO> inquiryService, ILogger<InquiriesController> logger) : this()
+
-        {
+        private readonly ILogger<InquiriesController> _logger;
-            _inquiryService = inquiryService;
+        public InquiriesController(IInquiryDataService 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}")]
-        [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}")]
-        [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 || dto.Database == null || dto.InquiryTable == null)
+            {
+                return BadRequest();
+            }
+            _logger.LogInformation("[INFORMATION] Une enquête a été créé : title - {title}, description - {description}, isUser - {isUser}, database - {database}, inquiryTable - {inquiryTable}", dto.Title, dto.Description, dto.IsUser, dto.Database, dto.InquiryTable);
+            return Created(nameof(GetInquiries), _inquiryDataService.CreateInquiry(dto.Title, dto.Description, dto.IsUser, dto.Database, dto.InquiryTable));
+        }
+
+        [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 ILessonDataService _lessonDataService;
+
+        private readonly ILogger<LessonsController> _logger;
+
+        public LessonsController(ILessonDataService 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}")]
+        [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}")]
+        [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 IParagraphDataService _paragraphDataService;
+
+        private readonly ILogger<ParagraphsController> _logger;
+
+        public ParagraphsController(IParagraphDataService 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}")]
+        [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}")]
+        [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 ISuccessDataService _successDataService;
+
+        private readonly ILogger<SuccessesController> _logger;
+
+        public SuccessesController(ISuccessDataService 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/{id}")]
+        [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/{inquiryId}")]
+        [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
 {
@@ -15,9 +16,9 @@ namespace API.Controllers
         [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}")]
         [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}")]
         [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, int tableId, int solutionId)
-    public IEnumerable<InquiryDTO> GetInquiries(int page, int number)
+    {
-    {
+        return inquiryService.CreateInquiry(title, description, isUser, tableId, solutionId);
-        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/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)
         {

API_SQLuedo/DbDataManager/Service/InquiryDataService.cs

@@ -1,23 +1,93 @@
-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; set; }
-    }
+
-
+    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;
+        updatingInquiry.IdInquiryTable = inquiry.IdInquiryTable;
+        updatingInquiry.IdDatabase = inquiry.IdDatabase;
+        // 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, int tableId, int solutionId)
+    {
+        var newInquiryEntity = new InquiryEntity()
+        {
+            Title = title,
+            Description = description,
+            IsUser = isUser,
+            IdDatabase = tableId,
+            IdInquiryTable = solutionId,
+        };
+        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/ContentLessonDTO.cs

@@ -14,4 +14,15 @@ public abstract class ContentLessonDTO
         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

@@ -22,4 +22,13 @@ public class InquiryDTO
         Database = database;
         InquiryTable = inquiryTable;
     }
+
+    public InquiryDTO(string title, string description, bool isUser, int database, int inquiryTable)
+    {
+        Title = title;
+        Description = description;
+        IsUser = isUser;
+        Database = database;
+        InquiryTable = inquiryTable;
+    }
 }

API_SQLuedo/Dto/ParagraphDTO.cs

@@ -2,16 +2,36 @@
 
 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, int lessonId) :
+    public ParagraphDTO(string title, string content, string info, string query, string comment, int lessonId) :
-        base(id, content,
+        base(content,
             title, lessonId)
     {
+        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/EntityFramework/LessonEntity.cs

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

API_SQLuedo/EntityFramework/ParagraphEntity.cs

@@ -9,6 +9,8 @@ public class ParagraphEntity : ContentLessonEntity
     // 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; }
@@ -20,6 +22,8 @@ public class ParagraphEntity : ContentLessonEntity
     public ParagraphEntity(int id, string title, string content, string info, string query,
         string comment, int idLesson) : base(id, idLesson, content, title)
     {
+        Title = title;
+        Content = content;
         Info = info;
         Query = query;
         Comment = comment;
@@ -28,8 +32,15 @@ public class ParagraphEntity : ContentLessonEntity
     public ParagraphEntity(string title, string content, string info, string query, string comment) : base(content,
         title)
     {
+        Title = title;
+        Content = content;
         Info = info;
         Query = query;
         Comment = comment;
-    }
+    }
+
+    public object FromEntityToModel()
+    {
+        throw new NotImplementedException();
+    }
 }

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/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, int tableId, int solutionId);
+}

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, int tableId, int solutionId);
 }

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,98 @@
+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, int tableId, int solutionId)
+    {
+        var newInquiryEntity = new InquiryDTO(title, description, isUser, tableId, solutionId);
+        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;
+        updatingInquiry.IdDatabase = inquiry.Database;
+        updatingInquiry.IdInquiryTable = inquiry.InquiryTable;
+        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

@@ -6,32 +6,32 @@ 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/LessonMapper.cs

@@ -6,32 +6,32 @@ 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/ParagraphMapper.cs

@@ -6,35 +6,35 @@ namespace Shared.Mapper;
 
 public static class ParagraphMapper
 {
-    public static Paragraph FromDTOToModel(ParagraphDTO dto)
+    public static Paragraph FromDTOToModel(this ParagraphDTO dto)
     {
         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.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.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.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.ContentTitle, dto.ContentContent, dto.Info, dto.Query, dto.Comment,
             dto.LessonId);
     }
 
-    public static ParagraphEntity FromModelToEntity(Paragraph model)
+    public static ParagraphEntity FromModelToEntity(this Paragraph model)
     {
         return new ParagraphEntity(model.Id, model.ContentTitle, model.ContentContent, model.Info, model.Query,
             model.Comment, model.LessonId);

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/TestConsoleAPI/Program.cs

@@ -5,10 +5,12 @@ using API.Service;
 using DbContextLib;
 using DbDataManager.Service;
 using Dto;
+using Entities;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Data.Sqlite;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
+using Shared;
 
 var connection = new SqliteConnection("DataSource=:memory:");
 connection.Open();
@@ -20,12 +22,13 @@ ILogger<UserController> logger = factory.CreateLogger<UserController>();
 
 using (var context = new UserDbContext(options))
 {
-    var controller = new UserController(logger, new UserDataServiceApi(new UserDataService(context)));
+    IUserService<UserEntity> service;
+    var controller = new UserController(logger, null);
 
     void PrintUsers()
     {
         Console.WriteLine();
-        var users = controller.GetUsers(1, 10) as OkObjectResult;
+        var users = controller.GetUsers(1, 10, Model.OrderCriteria.UserOrderCriteria.None) as OkObjectResult;
         foreach(var item in users.Value as IEnumerable<UserDTO>)
         {
             Console.WriteLine(item);
@@ -184,7 +187,7 @@ using (var context = new UserDbContext(options))
         // 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 = controller.GetUsers(1, 10, Model.OrderCriteria.UserOrderCriteria.None) as OkObjectResult;
         if(res == null)
         {
             Console.WriteLine("\nErreur lors de l'acquisition de la liste des utilisateurs");

API_SQLuedo/TestConsoleEf/Program.cs

@@ -130,7 +130,7 @@ using (var db = new StubbedContext(options))
     await db.Database.EnsureCreatedAsync();
 
     // Test sur les enquetes
-    var inquiries = db.Inquiry;
+    var inquiries = db.Inquiries;
 
     // Affichage de toutes les enquetes
     Console.WriteLine("\nAffichage des noms des enquetes");
@@ -190,7 +190,7 @@ using (var db = new StubbedContext(options))
 {
     await db.Database.EnsureCreatedAsync();
 
-    var inquiries = db.Inquiry;
+    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");
@@ -204,7 +204,7 @@ using (var db = new StubbedContext(options))
     {
         // Suppression de la nouvelle enquete
         Console.WriteLine("\nSuppression de la nouvelle enquete");
-        db.Inquiry.Remove(i);
+        db.Inquiries.Remove(i);
         await db.SaveChangesAsync();
     }
 }
@@ -213,7 +213,7 @@ using (var db = new StubbedContext(options))
 {
     await db.Database.EnsureCreatedAsync();
 
-    var inquiries = db.Inquiry;
+    var inquiries = db.Inquiries;
     // Affichage des utilisateurs après suppression
     Console.WriteLine("\nAffichage des utilisateurs après suppression");
     foreach (var inquiry in inquiries)
@@ -235,7 +235,7 @@ using (var db = new StubbedContext(options))
 {
     await db.Database.EnsureCreatedAsync();
 
-    var inquiries = db.Inquiry;
+    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)