Merge en cours de la branche filtrage sur master

API_SQLuedo/API/Controllers/InquiriesController.cs

@@ -1,39 +1,40 @@
-using Dto;
+using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using Shared;
+using Dto;
+using Model.OrderCriteria;
+using Services;
+using Asp.Versioning;
 
 namespace API.Controllers
 {
-    [Route("api/[controller]")]
+    [Route("api/v{version:apiVersion}/[controller]")]
     [Authorize]
+    [ApiVersion("1.0")]
     [ApiController]
-    public class InquiriesController()
+    public class InquiriesController : Controller
-        : ControllerBase
     {
-        private readonly IInquiryService<InquiryDTO> _inquiryService;
+        private IInquiryDataService _inquiryDataService;
-        private readonly ILogger<InquiriesController> _logger;
 
-        public InquiriesController(IInquiryService<InquiryDTO> inquiryService, ILogger<InquiriesController> logger) : this()
+        private readonly ILogger<InquiriesController> _logger;
+        public InquiriesController(IInquiryDataService inquiryDataService, ILogger<InquiriesController> logger)
         {
-            _inquiryService = inquiryService;
+            _inquiryDataService = inquiryDataService;
             _logger = logger;
         }
 
-        [HttpGet("inquiries/{page}/{number}")]
+        [HttpGet("inquiries/{page}/{number}/{orderCriteria}")]
         [ProducesResponseType(typeof(InquiryDTO), 200)]
         [ProducesResponseType(typeof(string), 204)]
-        public IActionResult GetInquiries(int page, int number)
+        public IActionResult GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria)
         {
-            var nbInquiry = _inquiryService.GetInquiries(page, number).Count();
+            var nbInquiry = _inquiryDataService.GetInquiries(page, number, orderCriteria).Count();
             if (nbInquiry == 0)
             {
-                _logger.LogError("[ERREUR] Aucune enquête trouvé.");
+                _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));
+            return Ok(_inquiryDataService.GetInquiries(page, number, orderCriteria));
         }
 
         [HttpGet("inquiry/id/{id}")]
@@ -43,8 +44,8 @@ namespace API.Controllers
         {
             try
             {
-                _logger.LogInformation("[INFORMATION] Enquête avec l'id {id} a été trouvé.", id);
+                _logger.LogInformation("[INFORMATION] L'enquête avec l'id {id} a été trouvé.", id);
-                return Ok(_inquiryService.GetInquiryById(id));
+                return Ok(_inquiryDataService.GetInquiryById(id));
             }
             catch (ArgumentException)
             {
@@ -60,8 +61,8 @@ namespace API.Controllers
         {
             try
             {
-                _logger.LogInformation("[INFORMATION] Enquête avec le titre {title} a été trouvé.", title);
+                _logger.LogInformation("[INFORMATION] L'enquête avec le titre {title} a été trouvé.", title);
-                return Ok(_inquiryService.GetInquiryByTitle(title));
+                return Ok(_inquiryDataService.GetInquiryByTitle(title));
             }
             catch (ArgumentException)
             {
@@ -69,5 +70,62 @@ namespace API.Controllers
                 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]
+        [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/{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/{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]
+        [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/{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/{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]
+        [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/user/{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/inquiry/{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]
+        [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

@@ -62,7 +62,7 @@ namespace API.Controllers
             }
         }
 
-        [HttpDelete]
+        [HttpDelete("user/id/{id}")]
         [ProducesResponseType(typeof(UserDTO), 200)]
         [ProducesResponseType(typeof(string), 404)]
         public IActionResult DeleteUser(int id)

API_SQLuedo/API/Program.cs

@@ -20,10 +20,8 @@ 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<UserEntity>, DbDataManager.Service.UserDataService>();
-builder.Services.AddScoped<IUserService<UserDTO>, UserDataServiceApi>();
+builder.Services.AddScoped<IInquiryService<InquiryEntity>, DbDataManager.Service.InquiryDataService>();
-builder.Services.AddScoped<IInquiryService<InquiryEntity>, InquiryDataService>();
-builder.Services.AddScoped<IInquiryService<InquiryDTO>, InquiryDataServiceApi>();
 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,32 @@
-using Dto;
+using Entities;
-using Entities;
 using Shared;
-using Shared.Mapper;
 
 namespace API.Service;
 
-public class InquiryDataServiceApi(IInquiryService<InquiryEntity> inquiryService) : IInquiryService<InquiryDTO>
+public class InquiryDataServiceApi(IInquiryService<InquiryEntity> inquiryService) : IInquiryService<InquiryEntity>
 {
-    public IEnumerable<InquiryDTO> GetInquiries(int page, int number)
+    public InquiryEntity CreateInquiry(string title, string description, bool isUser, int tableId, int solutionId)
+    {
+        return inquiryService.CreateInquiry(title, description, isUser, tableId, solutionId);
+    }
+
+    public bool DeleteInquiry(int id)
+    {
+        return inquiryService.DeleteInquiry(id);
+    }
+
+    public IEnumerable<InquiryEntity> GetInquiries(int page, int number)
     {
         var inquiries = inquiryService.GetInquiries(page, number);
-        return inquiries.Select(i => i.FromEntityToDTO()).ToList();
+        return inquiries.Select(i => i).ToList();
     }
 
-    public InquiryDTO GetInquiryById(int id) => inquiryService.GetInquiryById(id).FromEntityToDTO();
+    public InquiryEntity GetInquiryById(int id) => inquiryService.GetInquiryById(id);
+
+    public InquiryEntity GetInquiryByTitle(string title) => inquiryService.GetInquiryByTitle(title);
 
-    public InquiryDTO GetInquiryByTitle(string title) => inquiryService.GetInquiryByTitle(title).FromEntityToDTO();
+    public InquiryEntity UpdateInquiry(int id, InquiryEntity inquiry)
+    {
+        return inquiryService.UpdateInquiry(id, inquiry);
+    }
 }

API_SQLuedo/API/Service/LessonDataServiceAPI.cs

@@ -0,0 +1,31 @@
+using Entities;
+using Model.OrderCriteria;
+using Shared;
+
+namespace API.Service;
+
+public class LessonDataServiceApi(ILessonService<LessonEntity> lessonService) : ILessonDataService<LessonEntity>
+{
+    public IEnumerable<LessonEntity> GetLessons(int page, int number)
+    {
+        var lessonsEntities = lessonService.GetLessons(page, number);
+        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);
+
+    public IEnumerable<LessonEntity> GetLessons(int page, int number, LessonOrderCriteria orderCriteria)
+    {
+        throw new NotImplementedException();
+    }
+}

API_SQLuedo/API/Service/UserDataServiceAPI.cs

@@ -1,27 +1,25 @@
-using Dto;
+using Entities;
-using Entities;
 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)
     {
         var usersEntities = userService.GetUsers(page, number);
-        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,11 +1,20 @@
-using Dto;
+using Entities;
-using Entities;
 using Shared;
 
 namespace DbDataManager.Service;
 
 public class InquiryDataService : IInquiryService<InquiryEntity>
 {
+    public InquiryEntity CreateInquiry(string title, string description, bool isUser, int tableId, int solutionId)
+    {
+        throw new NotImplementedException();
+    }
+
+    public bool DeleteInquiry(int id)
+    {
+        throw new NotImplementedException();
+    }
+
     public IEnumerable<InquiryEntity> GetInquiries(int page, int number)
     {
         throw new NotImplementedException();
@@ -20,4 +29,9 @@ public class InquiryDataService : IInquiryService<InquiryEntity>
     {
         throw new NotImplementedException();
     }
+
+    public InquiryEntity UpdateInquiry(int id, InquiryEntity inquiry)
+    {
+        throw new NotImplementedException();
+    }
 }

API_SQLuedo/DbDataManager/Service/LessonDataService.cs

@@ -0,0 +1,37 @@
+using Entities;
+using Shared;
+
+namespace DbDataManager.Service;
+
+public class LessonDataService : ILessonService<LessonEntity>
+{
+    public LessonEntity CreateLesson(string title, string lastPublisher, DateOnly? lastEdit)
+    {
+        throw new NotImplementedException();
+    }
+
+    public bool DeleteLesson(int id)
+    {
+        throw new NotImplementedException();
+    }
+
+    public LessonEntity GetLessonById(int id)
+    {
+        throw new NotImplementedException();
+    }
+
+    public LessonEntity GetLessonByTitle(string title)
+    {
+        throw new NotImplementedException();
+    }
+
+    public IEnumerable<LessonEntity> GetLessons(int page, int number)
+    {
+        throw new NotImplementedException();
+    }
+
+    public LessonEntity UpdateLesson(int id, LessonEntity lesson)
+    {
+        throw new NotImplementedException();
+    }
+}

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(string title, string content, string info, string query, string comment, int lessonId) :
+        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/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/IDataService.cs

@@ -0,0 +1,10 @@
+using Entities;
+using Model;
+using Dto;
+
+namespace Shared
+{
+    public interface IDataService
+    {
+    }
+}

API_SQLuedo/Shared/IInquiryDataService.cs

@@ -0,0 +1,14 @@
+using Dto;
+using Model.OrderCriteria;
+
+namespace Shared;
+
+public interface IInquiryDataService : IDataService
+{
+    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

@@ -5,4 +5,7 @@ public interface IInquiryService<TInquiry>
     public IEnumerable<TInquiry> GetInquiries(int page, int number);
     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,14 @@
+using Model.OrderCriteria;
+
+namespace Shared;
+
+public interface ILessonDataService<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/ILessonService.cs

@@ -0,0 +1,11 @@
+namespace Shared;
+
+public interface ILessonService<TLesson>
+{
+    public IEnumerable<TLesson> GetLessons(int page, int number);
+    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 : IDataService
+{
+    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/ISuccessDataService.cs

@@ -0,0 +1,14 @@
+using Dto;
+using Model.OrderCriteria;
+
+namespace Shared;
+
+public interface ISuccessDataService
+{
+    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/IUserDataService.cs

@@ -0,0 +1,14 @@
+using Dto;
+using Model.OrderCriteria;
+
+namespace Shared;
+
+public interface IUserDataService : IDataService
+{
+    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/InquiryDataService.cs

@@ -0,0 +1,100 @@
+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.Database = inquiry.Database.FromDTOToEntity();
+        //updatingInquiry.InquiryTable = inquiry.InquiryTable.FromDTOToEntity();
+        // Permet d'indiquer en Db que l'entité a été modifiée.
+        DbContext.Entry(updatingInquiry).State = EntityState.Modified;
+        DbContext.SaveChangesAsync();
+        return updatingInquiry.FromEntityToModel().FromModelToDTO();
+    }
+}

API_SQLuedo/Shared/LessonDataService.cs

@@ -0,0 +1,105 @@
+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.FromEntityToModel().FromModelToDTO();
+    }
+
+    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;
+        // Permet d'indiquer en Db que l'entité a été modifiée.
+        DbContext.Entry(updatingLesson).State = EntityState.Modified;
+        DbContext.SaveChangesAsync();
+        return updatingLesson.FromEntityToModel().FromModelToDTO();
+    }
+
+    public LessonDTO CreateLesson(string title, string lastPublisher, DateOnly? lastEdit)
+    {
+        var newLessonEntity = new LessonDTO()
+        {
+            Title = title,
+            LastPublisher = lastPublisher,
+            LastEdit = lastEdit,
+        };
+        DbContext.Lessons.Add(newLessonEntity.FromDTOToModel().FromModelToEntity());
+        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,117 @@
+using Entities;
+using Microsoft.EntityFrameworkCore;
+using Dto;
+using DbContextLib;
+using Model.OrderCriteria;
+using Shared.Mapper;
+
+namespace Services;
+
+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;
+        // Permet d'indiquer en Db que l'entité a été modifiée.
+        DbContext.Entry(updatingParagraph).State = EntityState.Modified;
+        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,105 @@
+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;
+        // Permet d'indiquer en Db que l'entité a été modifiée.
+        DbContext.Entry(updatingSuccess).State = EntityState.Modified;
+        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,123 @@
+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.FromEntityToModel().FromModelToDTO();
+
+        }
+
+        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.FromEntityToModel().FromModelToDTO();
+
+        }
+
+        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.FromEntityToModel().FromModelToDTO());
+        }
+
+        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;
+            // Permet d'indiquer en Db que l'entité a été modifiée.
+            DbContext.Entry(updatingUser).State = EntityState.Modified;
+            DbContext.SaveChangesAsync();
+            return updatingUser.FromEntityToModel().FromModelToDTO();
+
+        }
+
+        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.FromDTOToModel().FromModelToEntity());
+            DbContext.SaveChangesAsync();
+            return newUserEntity;
+
+        }
+    }
+}