Merge pull request 'suppressionServiceInutile' (#37) from suppressionServiceInutile into master

Reviewed-on: #37

API_SQLuedo/API/Controllers/InquiriesController.cs

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

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

@@ -13,27 +13,29 @@ namespace API.Controllers
     [ApiController]
     public class ParagraphsController : Controller
     {
-        private IParagraphService<ParagraphDTO> _paragraphDataService;
+        private readonly IParagraphService<ParagraphDTO> _paragraphDataService;
 
         private readonly ILogger<ParagraphsController> _logger;
 
-        public ParagraphsController(IParagraphService<ParagraphDTO> paragraphDataService, ILogger<ParagraphsController> logger)
+        public ParagraphsController(IParagraphService<ParagraphDTO> paragraphDataService,
+            ILogger<ParagraphsController> logger)
         {
             _paragraphDataService = paragraphDataService;
             _logger = logger;
         }
 
-        [HttpGet("paragraphs/{page}/{number}/{orderCriteria}")]
+        [HttpGet("paragraphs/{page:int}/{number:int}/{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();
+            var nbParagraph = _paragraphDataService.GetParagraphs(page, number, orderCriteria).ToList().Count;
-            if(nbParagraph == 0) 
+            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));
         }
@@ -47,7 +49,8 @@ namespace API.Controllers
             {
                 _logger.LogInformation("[INFORMATION] Le paragraphe avec l'id {id} a été trouvé.", id);
                 return Ok(_paragraphDataService.GetParagraphById(id));
-            } catch (ArgumentException) 
+            }
+            catch (ArgumentException)
             {
                 _logger.LogError("[ERREUR] Aucun paragraphe trouvé avec l'id {id}.", id);
                 return NotFound();
@@ -63,30 +66,30 @@ namespace API.Controllers
             {
                 _logger.LogInformation("[INFORMATION] Le paragraphe avec le titre {title} a été trouvé.", title);
                 return Ok(_paragraphDataService.GetParagraphByTitle(title));
-            }catch (ArgumentException) 
+            }
+            catch (ArgumentException)
             {
                 _logger.LogError("[ERREUR] Aucun paragraphe trouvé avec le titre {title}.", title);
                 return NotFound();
             }
-            
         }
 
-        [HttpDelete("paragraph/{id}")]
+        [HttpDelete("paragraph/{id:int}")]
         [ProducesResponseType(typeof(ParagraphDTO), 200)]
         [ProducesResponseType(typeof(string), 404)]
         public IActionResult DeleteParagraph(int id)
         {
             var success = _paragraphDataService.DeleteParagraph(id);
-            if(success)
+            if (success)
             {
                 _logger.LogInformation("[INFORMATION] Le paragraphe avec l'id {id} a été supprimé.", id);
                 return Ok(_paragraphDataService.DeleteParagraph(id));
-            } else
+            }
+            else
             {
                 _logger.LogError("[ERREUR] Aucun paragraphe trouvé avec l'id {id}.", id);
                 return NotFound();
             }
-            
         }
 
         [HttpPost]
@@ -94,35 +97,45 @@ namespace API.Controllers
         [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)
+            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));
+            _logger.LogInformation(
+                "[INFORMATION] Un paragraphe a été créé : title - {title}, content - {content}, info - {info}, query - {query}, comment - {comment}",
+                dto.Title, dto.Content, dto.Info, dto.Query, dto.Comment);
+            return Created(nameof(GetParagraphs),
+                _paragraphDataService.CreateParagraph(dto.Title, dto.Content, dto.Info, dto.Query, dto.Comment,
+                    dto.LessonId));
         }
 
-        [HttpPut("paragraph/{id}")]
+        [HttpPut("paragraph/{id:int}")]
         [ProducesResponseType(typeof(ParagraphDTO), 200)]
         [ProducesResponseType(typeof(string), 400)]
         [ProducesResponseType(typeof(string), 404)]
         public IActionResult UpdateParagraph(int id, [FromBody] ParagraphDTO paragraphDTO)
         {
-            if(id !=  paragraphDTO.Id)
+            if (id != paragraphDTO.Id)
             {
                 _logger.LogError("[ERREUR] Problème ID - La mise à jour du paragraphe avec l'id {id} a échouée.", id);
                 return BadRequest();
             }
-            if(!ModelState.IsValid)
+
+            if (!ModelState.IsValid)
             {
-                _logger.LogError("[ERREUR] Problème controlleur - La mise à jour du paragraphe avec l'id {id} a échouée.", id);
+                _logger.LogError(
+                    "[ERREUR] Problème controlleur - La mise à jour du paragraphe avec l'id {id} a échouée.", id);
                 return BadRequest();
             }
-            if(paragraphDTO != null) 
+
+            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

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

API_SQLuedo/API/Controllers/UserController.cs

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

API_SQLuedo/API/Program.cs

@@ -6,9 +6,7 @@ using DbDataManager.Service;
 using Dto;
 using Entities;
 using Microsoft.AspNetCore.Identity;
-using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.DependencyInjection;
 using Microsoft.OpenApi.Models;
 using Shared;
 
@@ -21,20 +19,20 @@ builder.Services.AddControllers();
 builder.Services.AddEndpointsApiExplorer();
 builder.Services.AddSwaggerGen();
 
-builder.Services.AddScoped<IUserService<UserEntity>, DbDataManager.Service.UserDataService>();
+builder.Services.AddScoped<IUserService<UserEntity>, UserDataService>();
-builder.Services.AddScoped<IUserService<UserDTO>, Shared.UserDataService>();
+builder.Services.AddScoped<IUserService<UserDTO>, UserDataServiceApi>();
 
-builder.Services.AddScoped<IInquiryService<InquiryEntity>, DbDataManager.Service.InquiryDataService>();
+builder.Services.AddScoped<IInquiryService<InquiryEntity>, InquiryDataService>();
-builder.Services.AddScoped<IInquiryService<InquiryDTO>, Shared.InquiryDataService>();
+builder.Services.AddScoped<IInquiryService<InquiryDTO>, InquiryDataServiceApi>();
 
-builder.Services.AddScoped<IParagraphService<ParagraphEntity>, DbDataManager.Service.ParagraphDataService>();
+builder.Services.AddScoped<IParagraphService<ParagraphEntity>, ParagraphDataService>();
-builder.Services.AddScoped<IParagraphService<ParagraphDTO>, Shared.ParagraphDataService>();
+builder.Services.AddScoped<IParagraphService<ParagraphDTO>, ParagraphDataServiceApi>();
 
-builder.Services.AddScoped<ISuccessService<SuccessEntity>, DbDataManager.Service.SuccessDataService>();
+builder.Services.AddScoped<ISuccessService<SuccessEntity>, SuccessDataService>();
-builder.Services.AddScoped<ISuccessService<SuccessDTO>, Shared.SuccessDataService>();
+builder.Services.AddScoped<ISuccessService<SuccessDTO>, SuccessDataServiceApi>();
 
-builder.Services.AddScoped<ILessonService<LessonEntity>, DbDataManager.Service.LessonDataService>();
+builder.Services.AddScoped<ILessonService<LessonEntity>, LessonDataService>();
-builder.Services.AddScoped<ILessonService<LessonDTO>, Shared.LessonDataService>();
+builder.Services.AddScoped<ILessonService<LessonDTO>, LessonDataServiceApi>();
 
 builder.Services.AddDbContext<DbContext, UserDbContext>();
 builder.Services.AddDbContext<WebAPIDbContext>(options => options.UseInMemoryDatabase("appDb"));
@@ -72,11 +70,11 @@ builder.Services.AddSwaggerGen(option =>
             {
                 Reference = new OpenApiReference
                 {
-                    Type=ReferenceType.SecurityScheme,
+                    Type = ReferenceType.SecurityScheme,
-                    Id="Bearer"
+                    Id = "Bearer"
                 }
             },
-            new string[]{}
+            new string[] { }
         }
     });
 });

API_SQLuedo/API/Service/InquiryDataServiceAPI.cs

@@ -1,14 +1,21 @@
-using Entities;
+using Dto;
+using Entities;
 using Model.OrderCriteria;
 using Shared;
+using Shared.Mapper;
 
 namespace API.Service;
 
-public class InquiryDataServiceApi(IInquiryService<InquiryEntity> inquiryService) : IInquiryService<InquiryEntity>
+public class InquiryDataServiceApi(IInquiryService<InquiryEntity> inquiryService) : IInquiryService<InquiryDTO>
 {
-    public InquiryEntity CreateInquiry(string title, string description, bool isUser)
+    public InquiryDTO UpdateInquiry(int id, InquiryDTO inquiry)
     {
-        return inquiryService.CreateInquiry(title, description, isUser);
+        return inquiryService.UpdateInquiry(id, inquiry.FromDTOToEntity()).FromEntityToDTO();
+    }
+
+    public InquiryDTO CreateInquiry(string title, string description, bool isUser)
+    {
+        return inquiryService.CreateInquiry(title, description, isUser).FromEntityToDTO();
     }
 
     public bool DeleteInquiry(int id)
@@ -16,18 +23,13 @@ public class InquiryDataServiceApi(IInquiryService<InquiryEntity> inquiryService
         return inquiryService.DeleteInquiry(id);
     }
 
-    public IEnumerable<InquiryEntity> GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria)
+    public IEnumerable<InquiryDTO> GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria)
     {
         var inquiries = inquiryService.GetInquiries(page, number, orderCriteria);
-        return inquiries.Select(i => i).ToList();
+        return inquiries.Select(i => i.FromEntityToDTO()).ToList();
     }
 
-    public InquiryEntity GetInquiryById(int id) => inquiryService.GetInquiryById(id);
+    public InquiryDTO GetInquiryById(int id) => inquiryService.GetInquiryById(id).FromEntityToDTO();
 
-    public InquiryEntity GetInquiryByTitle(string title) => inquiryService.GetInquiryByTitle(title);
+    public InquiryDTO GetInquiryByTitle(string title) => inquiryService.GetInquiryByTitle(title).FromEntityToDTO();
-
-    public InquiryEntity UpdateInquiry(int id, InquiryEntity inquiry)
-    {
-        return inquiryService.UpdateInquiry(id, inquiry);
-    }
 }

API_SQLuedo/API/Service/LessonDataServiceAPI.cs

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

API_SQLuedo/API/Service/ParagraphDataServiceAPI.cs

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

API_SQLuedo/API/Service/SuccessDataServiceAPI.cs

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

API_SQLuedo/API/Service/UserDataServiceAPI.cs

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

API_SQLuedo/API/WebAPIDbContext.cs

@@ -6,6 +6,8 @@ namespace API
 {
     public class WebAPIDbContext : IdentityDbContext<IdentityUser>
     {
-        public WebAPIDbContext(DbContextOptions<WebAPIDbContext> options) : base(options) { }
+        public WebAPIDbContext(DbContextOptions<WebAPIDbContext> options) : base(options)
+        {
+        }
     }
 }

API_SQLuedo/DbContextLib/UserDbContext.cs

@@ -17,13 +17,18 @@ namespace DbContextLib
         public DbSet<SolutionEntity> Solutions { get; set; }
         public DbSet<SuccessEntity> Successes { get; set; }
         public DbSet<NotepadEntity> Notepads { get; set; }
-        public UserDbContext(DbContextOptions<UserDbContext> options) : base(options) { }
+
+        public UserDbContext(DbContextOptions<UserDbContext> options) : base(options)
+        {
+        }
+
         protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
         {
             if (!optionsBuilder.IsConfigured)
             {
                 optionsBuilder.UseNpgsql("Host=localhost;Database=SQLuedo;Username=admin;Password=motdepasse");
             }
+
             base.OnConfiguring(optionsBuilder);
         }
 

API_SQLuedo/DbDataManager/DbDataManager.csproj

@@ -4,7 +4,7 @@
     <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
-    <RootNamespace>ModelToEntities</RootNamespace>
+    <RootNamespace>DbDataManager</RootNamespace>
   </PropertyGroup>
 
   <ItemGroup>

API_SQLuedo/DbDataManager/Service/InquiryDataService.cs

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

API_SQLuedo/DbDataManager/Service/LessonDataService.cs

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

API_SQLuedo/DbDataManager/Service/ParagraphDataService.cs

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

API_SQLuedo/DbDataManager/Service/SuccessDataService.cs

@@ -16,43 +16,61 @@ public class SuccessDataService : ISuccessService<SuccessEntity>
         context.Database.EnsureCreated();
     }
 
-    public SuccessEntity GetSuccessByUserId(int id)
+    public IEnumerable<SuccessEntity> GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria)
     {
-        var successEntity = DbContext.Successes.FirstOrDefault(u => u.UserId == id);
+        IQueryable<SuccessEntity> query = DbContext.Successes.Skip((page - 1) * number).Take(number);
-        if (successEntity == null)
+        switch (orderCriteria)
         {
-            throw new ArgumentException("Impossible de trouver le succès avec l'user id", nameof(id));
+            case SuccessOrderCriteria.None:
+                break;
+            case SuccessOrderCriteria.ByUserId:
+                query = query.OrderBy(s => s.UserId);
+                break;
+            case SuccessOrderCriteria.ByInquiryId:
+                query = query.OrderBy(s => s.InquiryId);
+                break;
+            case SuccessOrderCriteria.ByIsFinished:
+                query = query.OrderBy(s => s.IsFinished);
+                break;
+            default:
+                break;
         }
 
-        return successEntity;
+        var successes = query.ToList();
+        return successes;
     }
 
-    public SuccessEntity GetSuccessByInquiryId(int id)
+    public SuccessEntity GetSuccessByUserId(int id)
     {
-        var successEntity = DbContext.Successes.FirstOrDefault(u => u.InquiryId == id);
+        var userEntity = DbContext.Successes.FirstOrDefault(u => u.UserId == id);
-        if (successEntity == null)
+        if (userEntity == null)
         {
-            throw new ArgumentException("Impossible de trouver le succès avec l'inquiry id", nameof(id));
+            throw new ArgumentException("Impossible de trouver le succès", nameof(id));
         }
 
-        return successEntity;
+        return userEntity;
     }
 
-    public IEnumerable<SuccessEntity> GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria)
+    public SuccessEntity GetSuccessByInquiryId(int id)
     {
-        return DbContext.Successes.Skip((page - 1) * number).Take(number).ToList()
+        var userEntity = DbContext.Successes.FirstOrDefault(u => u.InquiryId == id);
-            .Select(u => u);
+        if (userEntity == null)
+        {
+            throw new ArgumentException("Impossible de trouver le succès", nameof(id));
+        }
+
+        return userEntity;
     }
 
     public bool DeleteSuccess(int id)
     {
-        var userEntity = DbContext.Successes.FirstOrDefault(u => u.UserId == id);
+        var successEntity = DbContext.Successes.FirstOrDefault(u => u.UserId == id);
-        if (userEntity == null)
+        if (successEntity == null)
         {
             return false;
         }
 
-        DbContext.Successes.Remove(userEntity);
+        DbContext.Successes.Remove(successEntity);
         DbContext.SaveChangesAsync();
         return true;
     }
@@ -62,14 +80,15 @@ public class SuccessDataService : ISuccessService<SuccessEntity>
         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));
+            throw new ArgumentException("Impossible de trouver le succès", nameof(id));
+        }
+
+        foreach (var pptt in typeof(SuccessEntity).GetProperties().Where(p =>
+                     p.CanWrite && p.Name != nameof(SuccessEntity.UserId) && p.Name != nameof(SuccessEntity.InquiryId)))
+        {
+            pptt.SetValue(updatingSuccess, pptt.GetValue(success));
         }
 
-        updatingSuccess.UserId = success.UserId;
-        updatingSuccess.InquiryId = success.InquiryId;
-        updatingSuccess.IsFinished = success.IsFinished;
-        // Permet d'indiquer en Db que l'entité a été modifiée.
-        DbContext.Entry(updatingSuccess).State = EntityState.Modified;
         DbContext.SaveChangesAsync();
         return updatingSuccess;
     }

API_SQLuedo/DbDataManager/Service/UserDataService.cs

@@ -1,6 +1,5 @@
 using DbContextLib;
 using Entities;
-using Microsoft.EntityFrameworkCore;
 using Model.OrderCriteria;
 using Shared;
 
@@ -8,7 +7,6 @@ namespace DbDataManager.Service;
 
 public class UserDataService : IUserService<UserEntity>
 {
-
     private UserDbContext DbContext { get; set; }
 
     public UserDataService(UserDbContext context)
@@ -41,8 +39,29 @@ public class UserDataService : IUserService<UserEntity>
 
     public IEnumerable<UserEntity> GetUsers(int page, int number, UserOrderCriteria orderCriteria)
     {
-        return DbContext.Users.Skip((page - 1) * number).Take(number).ToList()
+        IQueryable<UserEntity> query = DbContext.Users.Skip((page - 1) * number).Take(number);
-            .Select(u => u);
+        switch (orderCriteria)
+        {
+            case UserOrderCriteria.None:
+                break;
+            case UserOrderCriteria.ById:
+                query = query.OrderBy(s => s.Id);
+                break;
+            case UserOrderCriteria.ByUsername:
+                query = query.OrderBy(s => s.Username);
+                break;
+            case UserOrderCriteria.ByEmail:
+                query = query.OrderBy(s => s.Email);
+                break;
+            case UserOrderCriteria.ByIsAdmin:
+                query = query.OrderBy(s => s.IsAdmin);
+                break;
+            default:
+                break;
+        }
+
+        var users = query.ToList();
+        return users;
     }
 
     public bool DeleteUser(int id)
@@ -66,19 +85,19 @@ public class UserDataService : IUserService<UserEntity>
             throw new ArgumentException("Impossible de trouver l'utilisateur", nameof(id));
         }
 
-        updatingUser.Username = user.Username;
+        foreach (var pptt in typeof(UserEntity).GetProperties()
-        updatingUser.Password = user.Password;
+                     .Where(p => p.CanWrite && p.Name != nameof(UserEntity.Id)))
-        updatingUser.Email = user.Email;
+        {
-        updatingUser.IsAdmin = user.IsAdmin;
+            pptt.SetValue(updatingUser, pptt.GetValue(user));
-        // Permet d'indiquer en Db que l'entité a été modifiée.
+        }
-        DbContext.Entry(updatingUser).State = EntityState.Modified;
+
         DbContext.SaveChangesAsync();
         return updatingUser;
     }
 
     public UserEntity CreateUser(string username, string password, string email, bool isAdmin)
     {
-        var newUserEntity = new UserEntity()
+        var newUserEntity = new UserEntity
         {
             Username = username,
             Password = password,

API_SQLuedo/Dto/InquiryDTO.cs

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

API_SQLuedo/Dto/InquiryTableDTO.cs

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

API_SQLuedo/Dto/LessonDTO.cs

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

API_SQLuedo/Dto/NotepadDTO.cs

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

API_SQLuedo/Dto/SolutionDTO.cs

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

API_SQLuedo/Dto/SuccessDTO.cs

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

API_SQLuedo/Dto/UserDTO.cs

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

API_SQLuedo/EntityFramework/BlackListEntity.cs

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

API_SQLuedo/EntityFramework/InquiryTableEntity.cs

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

API_SQLuedo/EntityFramework/LessonEntity.cs

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

API_SQLuedo/EntityFramework/NotepadEntity.cs

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

API_SQLuedo/EntityFramework/SolutionEntity.cs

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

API_SQLuedo/EntityFramework/SuccessEntity.cs

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

API_SQLuedo/Model/Inquiry.cs

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

API_SQLuedo/Model/InquiryTable.cs

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

API_SQLuedo/Model/Notepad.cs

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

API_SQLuedo/Model/OrderCriteria/InquiryOrderCriteria.cs

@@ -2,5 +2,8 @@ namespace Model.OrderCriteria;
 
 public enum InquiryOrderCriteria
 {
-    None, ByTitle, ByDescription, ByIsUser
+    None,
+    ByTitle,
+    ByDescription,
+    ByIsUser
 }

API_SQLuedo/Model/OrderCriteria/LessonOrderCriteria.cs

@@ -2,5 +2,8 @@ namespace Model.OrderCriteria;
 
 public enum LessonOrderCriteria
 {
-    None, ByTitle, ByLastPublisher, ByLastEdit
+    None,
+    ByTitle,
+    ByLastPublisher,
+    ByLastEdit
 }

API_SQLuedo/Model/OrderCriteria/ParagraphOrderCriteria.cs

@@ -2,5 +2,10 @@ namespace Model.OrderCriteria;
 
 public enum ParagraphOrderCriteria
 {
-    None, ByTitle, ByContent, ByInfo, ByQuery, ByComment
+    None,
+    ByTitle,
+    ByContent,
+    ByInfo,
+    ByQuery,
+    ByComment
 }

API_SQLuedo/Model/OrderCriteria/SuccessOrderCriteria.cs

@@ -2,5 +2,8 @@ namespace Model.OrderCriteria;
 
 public enum SuccessOrderCriteria
 {
-    None, ByUserId, ByInquiryId, ByIsFinished
+    None,
+    ByUserId,
+    ByInquiryId,
+    ByIsFinished
 }

API_SQLuedo/Model/OrderCriteria/UserOrderCriteria.cs

@@ -2,5 +2,9 @@ namespace Model.OrderCriteria;
 
 public enum UserOrderCriteria
 {
-    None, ById, ByUsername, ByEmail, ByIsAdmin
+    None,
+    ById,
+    ByUsername,
+    ByEmail,
+    ByIsAdmin
 }

API_SQLuedo/Model/Solution.cs

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

API_SQLuedo/Model/Success.cs

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

API_SQLuedo/Model/User.cs

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

API_SQLuedo/Shared/IInquiryDataService.cs

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

API_SQLuedo/Shared/ILessonDataService.cs

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

API_SQLuedo/Shared/IParagraphDataService.cs

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

API_SQLuedo/Shared/IParagraphService.cs

@@ -9,6 +9,8 @@ namespace Shared
         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);
+
+        public TParagraph CreateParagraph(string title, string content, string info, string query, string comment,
+            int lessonId);
     }
 }

API_SQLuedo/Shared/ISuccessDataService.cs

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

API_SQLuedo/Shared/IUserDataService.cs

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

API_SQLuedo/Shared/InquiryDataService.cs

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

API_SQLuedo/Shared/LessonDataService.cs

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

API_SQLuedo/Shared/ParagraphDataService.cs

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

API_SQLuedo/Shared/SuccessDataService.cs

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

API_SQLuedo/Shared/UserDataService.cs

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

API_SQLuedo/TestAPI/UnitTest1.cs

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

API_SQLuedo/TestConsoleAPI/Program.cs

@@ -1,20 +1,25 @@
 // See https://aka.ms/new-console-template for more information
 
 using API.Controllers;
+using API.Service;
 using DbContextLib;
+using DbDataManager.Service;
 using Dto;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Data.Sqlite;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Model.OrderCriteria;
-using Shared;
+using Service_LessonDataService = DbDataManager.Service.LessonDataService;
+using Service_ParagraphDataService = DbDataManager.Service.ParagraphDataService;
+using Service_SuccessDataService = DbDataManager.Service.SuccessDataService;
+using Service_UserDataService = DbDataManager.Service.UserDataService;
 
 var connection = new SqliteConnection("DataSource=:memory:");
 connection.Open();
 var options = new DbContextOptionsBuilder<UserDbContext>()
-                    .UseSqlite(connection)
+    .UseSqlite(connection)
-                    .Options;
+    .Options;
 using ILoggerFactory factory = new LoggerFactory();
 ILogger<UsersController> userLogger = factory.CreateLogger<UsersController>();
 ILogger<InquiriesController> inquiryLogger = factory.CreateLogger<InquiriesController>();
@@ -25,11 +30,16 @@ ILogger<SuccessesController> successLogger = factory.CreateLogger<SuccessesContr
 
 using (var context = new UserDbContext(options))
 {
-    var userController = new UsersController(userLogger, new UserDataService(context));
+    var userController = new UsersController(userLogger, new UserDataServiceApi(new Service_UserDataService(context)));
-    var inquiryController = new InquiriesController(new InquiryDataService(context), inquiryLogger);
+    var inquiryController =
-    var paragraphController = new ParagraphsController(new ParagraphDataService(context), paragraphLogger);
+        new InquiriesController(new InquiryDataServiceApi(new InquiryDataService(context)), inquiryLogger);
-    var lessonController = new LessonsController(new LessonDataService(context), lessonLogger);
+    var paragraphController =
-    var successController = new SuccessesController(new SuccessDataService(context), successLogger);
+        new ParagraphsController(new ParagraphDataServiceApi(new Service_ParagraphDataService(context)),
+            paragraphLogger);
+    var lessonController =
+        new LessonsController(new LessonDataServiceApi(new Service_LessonDataService(context)), lessonLogger);
+    var successController = new SuccessesController(new SuccessDataServiceApi(new Service_SuccessDataService(context)),
+        successLogger);
 
     void PrintUsers()
     {
@@ -91,8 +101,8 @@ using (var context = new UserDbContext(options))
             Console.WriteLine("Erreur, la requête n'a rien donné.");
             return;
         }
-        Console.WriteLine(user.Value as UserDTO);
 
+        Console.WriteLine(user.Value as UserDTO);
     }
 
     void SearchInquiryByTitle()
@@ -105,6 +115,7 @@ using (var context = new UserDbContext(options))
             Console.WriteLine("Erreur, la requête n'a rien donné.");
             return;
         }
+
         Console.WriteLine(inquiry.Value as InquiryDTO);
     }
 
@@ -118,8 +129,8 @@ using (var context = new UserDbContext(options))
             Console.WriteLine("Erreur, la requête n'a rien donné.");
             return;
         }
-        Console.WriteLine(paragraph.Value as ParagraphDTO);
 
+        Console.WriteLine(paragraph.Value as ParagraphDTO);
     }
 
     void SearchLessonByTitle()
@@ -132,8 +143,8 @@ using (var context = new UserDbContext(options))
             Console.WriteLine("Erreur, la requête n'a rien donné.");
             return;
         }
-        Console.WriteLine(lesson.Value as LessonDTO);
 
+        Console.WriteLine(lesson.Value as LessonDTO);
     }
 
     void SearchSuccessByUserId()
@@ -146,8 +157,8 @@ using (var context = new UserDbContext(options))
             Console.WriteLine("Erreur, la requête n'a rien donné.");
             return;
         }
-        Console.WriteLine(success.Value as SuccessDTO);
 
+        Console.WriteLine(success.Value as SuccessDTO);
     }
 
     void SearchUserById()
@@ -160,8 +171,8 @@ using (var context = new UserDbContext(options))
             Console.WriteLine("Erreur, la requête n'a rien donné.");
             return;
         }
-        Console.WriteLine(user.Value as UserDTO);
 
+        Console.WriteLine(user.Value as UserDTO);
     }
 
     void SearchInquiryById()
@@ -174,6 +185,7 @@ using (var context = new UserDbContext(options))
             Console.WriteLine("Erreur, la requête n'a rien donné.");
             return;
         }
+
         Console.WriteLine(inquiry.Value as InquiryDTO);
     }
 
@@ -187,8 +199,8 @@ using (var context = new UserDbContext(options))
             Console.WriteLine("Erreur, la requête n'a rien donné.");
             return;
         }
-        Console.WriteLine(paragraph.Value as ParagraphDTO);
 
+        Console.WriteLine(paragraph.Value as ParagraphDTO);
     }
 
     void SearchSuccessByInquiryId()
@@ -201,8 +213,8 @@ using (var context = new UserDbContext(options))
             Console.WriteLine("Erreur, la requête n'a rien donné.");
             return;
         }
-        Console.WriteLine(success.Value as SuccessDTO);
 
+        Console.WriteLine(success.Value as SuccessDTO);
     }
 
     void SearchLessonById()
@@ -215,8 +227,8 @@ using (var context = new UserDbContext(options))
             Console.WriteLine("Erreur, la requête n'a rien donné.");
             return;
         }
-        Console.WriteLine(lesson.Value as LessonDTO);
 
+        Console.WriteLine(lesson.Value as LessonDTO);
     }
 
     void AddUser()
@@ -236,7 +248,6 @@ using (var context = new UserDbContext(options))
         {
             Console.WriteLine("\nErreur lors de la création de l'utilisateur !");
         }
-
     }
 
     void AddInquiry()
@@ -285,7 +296,6 @@ using (var context = new UserDbContext(options))
         {
             Console.WriteLine("\nErreur lors de la création du paragraphe !");
         }
-
     }
 
     void AddLesson()
@@ -294,7 +304,8 @@ using (var context = new UserDbContext(options))
         var title = Console.ReadLine();
         Console.WriteLine("Veuillez saisir votre nom :");
         var lastPublisher = Console.ReadLine();
-        var res = lessonController.CreateLesson(new LessonDTO(title, lastPublisher, DateOnly.FromDateTime(DateTime.Now)));
+        var res = lessonController.CreateLesson(
+            new LessonDTO(title, lastPublisher, DateOnly.FromDateTime(DateTime.Now)));
         if (res.GetType() == typeof(CreatedResult))
         {
             Console.WriteLine("\nLeçon créée avec succès");
@@ -303,7 +314,6 @@ using (var context = new UserDbContext(options))
         {
             Console.WriteLine("\nErreur lors de la création de la leçon !");
         }
-
     }
 
     void AddSuccess()
@@ -314,7 +324,8 @@ using (var context = new UserDbContext(options))
         var inquiryId = Console.ReadLine();
         Console.WriteLine("Veuillez indiquer si l'enquête a été complété (true/false) :");
         var isFinished = Console.ReadLine();
-        var res = successController.CreateSuccess(new SuccessDTO(int.Parse(userId), int.Parse(inquiryId), bool.Parse(isFinished)));
+        var res = successController.CreateSuccess(new SuccessDTO(int.Parse(userId), int.Parse(inquiryId),
+            bool.Parse(isFinished)));
         if (res.GetType() == typeof(CreatedResult))
         {
             Console.WriteLine("\nSuccès créé avec succès");
@@ -323,7 +334,6 @@ using (var context = new UserDbContext(options))
         {
             Console.WriteLine("\nErreur lors de la création du succès !");
         }
-
     }
 
     void UpdateUser()
@@ -346,7 +356,8 @@ using (var context = new UserDbContext(options))
                 var username = Console.ReadLine();
                 Console.WriteLine("Veuillez saisir l'email :");
                 var email = Console.ReadLine();
-                var retour = userController.UpdateUser(id, new UserDTO(id, username, user.Password, email, user.IsAdmin));
+                var retour =
+                    userController.UpdateUser(id, new UserDTO(id, username, user.Password, email, user.IsAdmin));
                 if (retour.GetType() == typeof(OkObjectResult))
                 {
                     Console.WriteLine("Mise à jour effectué avec succès !");
@@ -361,7 +372,6 @@ using (var context = new UserDbContext(options))
         {
             Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
         }
-
     }
 
     void UpdateInquiry()
@@ -390,7 +400,8 @@ using (var context = new UserDbContext(options))
                 var database = Convert.ToInt32(Console.ReadLine());
                 Console.WriteLine("Veuillez saisir un commentaire :");
                 var inquiryTable = Convert.ToInt32(Console.ReadLine());
-                var retour = inquiryController.UpdateInquiry(id, new InquiryDTO(id, title, description, bool.Parse(isUser)));
+                var retour =
+                    inquiryController.UpdateInquiry(id, new InquiryDTO(id, title, description, bool.Parse(isUser)));
                 if (retour.GetType() == typeof(OkObjectResult))
                 {
                     Console.WriteLine("Mise à jour effectué avec succès !");
@@ -405,7 +416,6 @@ using (var context = new UserDbContext(options))
         {
             Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
         }
-
     }
 
     void UpdateParagraph()
@@ -436,7 +446,8 @@ using (var context = new UserDbContext(options))
                 var comment = Console.ReadLine();
                 Console.WriteLine("Veuillez saisir l'id de la leçon :");
                 var lesson = Convert.ToInt32(Console.ReadLine());
-                var retour = paragraphController.UpdateParagraph(id, new ParagraphDTO(id, title, content, info, query, comment, lesson));
+                var retour = paragraphController.UpdateParagraph(id,
+                    new ParagraphDTO(id, title, content, info, query, comment, lesson));
                 if (retour.GetType() == typeof(OkObjectResult))
                 {
                     Console.WriteLine("Mise à jour effectué avec succès !");
@@ -451,7 +462,6 @@ using (var context = new UserDbContext(options))
         {
             Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
         }
-
     }
 
     void UpdateLesson()
@@ -474,7 +484,8 @@ using (var context = new UserDbContext(options))
                 var title = Console.ReadLine();
                 Console.WriteLine("Veuillez saisir votre nom :");
                 var lastPublisher = Console.ReadLine();
-                var retour = lessonController.UpdateLesson(id, new LessonDTO(id, title, lastPublisher, DateOnly.FromDateTime(DateTime.Now)));
+                var retour = lessonController.UpdateLesson(id,
+                    new LessonDTO(id, title, lastPublisher, DateOnly.FromDateTime(DateTime.Now)));
                 if (retour.GetType() == typeof(OkObjectResult))
                 {
                     Console.WriteLine("Mise à jour effectué avec succès !");
@@ -489,7 +500,6 @@ using (var context = new UserDbContext(options))
         {
             Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
         }
-
     }
 
     void UpdateSuccess()
@@ -514,7 +524,8 @@ using (var context = new UserDbContext(options))
                 var inquiryId = Console.ReadLine();
                 Console.WriteLine("Veuillez saisir si l'enquête est terminée (0/1) :");
                 var isFinished = Console.ReadLine();
-                var retour = successController.UpdateSuccess(id, new SuccessDTO(int.Parse(userId), int.Parse(inquiryId), bool.Parse(isFinished)));
+                var retour = successController.UpdateSuccess(id,
+                    new SuccessDTO(int.Parse(userId), int.Parse(inquiryId), bool.Parse(isFinished)));
                 if (retour.GetType() == typeof(OkObjectResult))
                 {
                     Console.WriteLine("Mise à jour effectué avec succès !");
@@ -529,7 +540,6 @@ using (var context = new UserDbContext(options))
         {
             Console.WriteLine("Une erreur est survenue lors de la mise à jour !");
         }
-
     }
 
     void DeleteUser()
@@ -545,7 +555,6 @@ using (var context = new UserDbContext(options))
         {
             Console.WriteLine("Erreur lors de la suppression !");
         }
-
     }
 
     void DeleteInquiry()
@@ -576,7 +585,6 @@ using (var context = new UserDbContext(options))
         {
             Console.WriteLine("Erreur lors de la suppression !");
         }
-
     }
 
     void DeleteLesson()
@@ -592,7 +600,6 @@ using (var context = new UserDbContext(options))
         {
             Console.WriteLine("Erreur lors de la suppression !");
         }
-
     }
 
     void DeleteSuccess()
@@ -608,7 +615,6 @@ using (var context = new UserDbContext(options))
         {
             Console.WriteLine("Erreur lors de la suppression !");
         }
-
     }
 
     void MenuUsers()
@@ -747,6 +753,7 @@ using (var context = new UserDbContext(options))
             default:
                 break;
         }
+
         Console.WriteLine("\nAppuyez sur n'importe quelle touche pour continuer...");
         Console.ReadKey();
         Console.Clear();

API_SQLuedo/TestEF/EntitiesTests/TestInquiryEntity.cs

@@ -32,20 +32,20 @@ public class TestInquiryEntity
     [Fact]
     public void TestConstructorWithoutId()
     {
-        InquiryEntity inquiry = new InquiryEntity(_title,_description,_isUser);
+        InquiryEntity inquiry = new InquiryEntity(_title, _description, _isUser);
         Assert.Equal(0, inquiry.Id);
-        Assert.Equal(_title,inquiry.Title);
+        Assert.Equal(_title, inquiry.Title);
-        Assert.Equal(_description,inquiry.Description);
+        Assert.Equal(_description, inquiry.Description);
         Assert.True(inquiry.IsUser);
     }
 
     [Fact]
     public void TestConstructorWithAllAttributes()
     {
-        InquiryEntity inquiry = new InquiryEntity(_id,_title,_description,_isUser);
+        InquiryEntity inquiry = new InquiryEntity(_id, _title, _description, _isUser);
         Assert.Equal(_id, inquiry.Id);
-        Assert.Equal(_title,inquiry.Title);
+        Assert.Equal(_title, inquiry.Title);
-        Assert.Equal(_description,inquiry.Description);
+        Assert.Equal(_description, inquiry.Description);
         Assert.True(inquiry.IsUser);
     }
 }

API_SQLuedo/TestEF/EntitiesTests/TestInquiryTableEntity.cs

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

API_SQLuedo/TestEF/EntitiesTests/TestLessonEntity.cs

@@ -23,20 +23,20 @@ public class TestLessonEntity
     [Fact]
     public void TestConstructorWithoutId()
     {
-        LessonEntity lesson = new LessonEntity(_title,_lastPublisher,_lastEdit);
+        LessonEntity lesson = new LessonEntity(_title, _lastPublisher, _lastEdit);
         Assert.Equal(0, lesson.Id);
-        Assert.Equal(_title,lesson.Title);
+        Assert.Equal(_title, lesson.Title);
-        Assert.Equal(_lastPublisher,lesson.LastPublisher);
+        Assert.Equal(_lastPublisher, lesson.LastPublisher);
-        Assert.Equal(_lastEdit,lesson.LastEdit);
+        Assert.Equal(_lastEdit, lesson.LastEdit);
     }
 
     [Fact]
     public void TestConstructorWithAllAttributes()
     {
-        LessonEntity lesson = new LessonEntity(_id,_title,_lastPublisher,_lastEdit);
+        LessonEntity lesson = new LessonEntity(_id, _title, _lastPublisher, _lastEdit);
         Assert.Equal(_id, lesson.Id);
-        Assert.Equal(_title,lesson.Title);
+        Assert.Equal(_title, lesson.Title);
-        Assert.Equal(_lastPublisher,lesson.LastPublisher);
+        Assert.Equal(_lastPublisher, lesson.LastPublisher);
-        Assert.Equal(_lastEdit,lesson.LastEdit);
+        Assert.Equal(_lastEdit, lesson.LastEdit);
     }
 }

API_SQLuedo/TestEF/EntitiesTests/TestNotepadEntity.cs

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

API_SQLuedo/TestEF/EntitiesTests/TestParagraphEntity.cs

@@ -26,25 +26,25 @@ public class TestParagraphEntity
     [Fact]
     public void TestConstructorWithoutId()
     {
-        ParagraphEntity paragraph = new ParagraphEntity(_title,_content,_info,_query,_comment);
+        ParagraphEntity paragraph = new ParagraphEntity(_title, _content, _info, _query, _comment);
         Assert.Equal(0, paragraph.Id);
-        Assert.Equal(_title,paragraph.Title);
+        Assert.Equal(_title, paragraph.Title);
-        Assert.Equal(_info,paragraph.Info);
+        Assert.Equal(_info, paragraph.Info);
-        Assert.Equal(_content,paragraph.Content);
+        Assert.Equal(_content, paragraph.Content);
-        Assert.Equal(_query,paragraph.Query);
+        Assert.Equal(_query, paragraph.Query);
-        Assert.Equal(_comment,paragraph.Comment);
+        Assert.Equal(_comment, paragraph.Comment);
     }
 
     [Fact]
     public void TestConstructorWithAllAttributes()
     {
-        ParagraphEntity paragraph = new ParagraphEntity(_id,_title,_content,_info,_query,_comment,10);
+        ParagraphEntity paragraph = new ParagraphEntity(_id, _title, _content, _info, _query, _comment, 10);
         Assert.Equal(_id, paragraph.Id);
-        Assert.Equal(_title,paragraph.Title);
+        Assert.Equal(_title, paragraph.Title);
-        Assert.Equal(_info,paragraph.Info);
+        Assert.Equal(_info, paragraph.Info);
-        Assert.Equal(_content,paragraph.Content);
+        Assert.Equal(_content, paragraph.Content);
-        Assert.Equal(_query,paragraph.Query);
+        Assert.Equal(_query, paragraph.Query);
-        Assert.Equal(_comment,paragraph.Comment);
+        Assert.Equal(_comment, paragraph.Comment);
         Assert.Equal(10, paragraph.LessonId);
     }
 }

API_SQLuedo/TestEF/EntitiesTests/TestSuccessEntity.cs

@@ -12,9 +12,9 @@ public class TestSuccessEntity
     public void TestDefaultConstructor()
     {
         SuccessEntity success = new SuccessEntity();
-        Assert.Equal(0,success.UserId);
+        Assert.Equal(0, success.UserId);
         Assert.Null(success.User);
-        Assert.Equal(0,success.InquiryId);
+        Assert.Equal(0, success.InquiryId);
         Assert.Null(success.Inquiry);
         Assert.False(success.IsFinished);
     }
@@ -23,9 +23,9 @@ public class TestSuccessEntity
     public void TestConstructorWithIds()
     {
         SuccessEntity success = new SuccessEntity(_userId, _inquiryId, _isFinished);
-        Assert.Equal(_userId,success.UserId);
+        Assert.Equal(_userId, success.UserId);
         Assert.Null(success.User);
-        Assert.Equal(_inquiryId,success.InquiryId);
+        Assert.Equal(_inquiryId, success.InquiryId);
         Assert.Null(success.Inquiry);
         Assert.True(success.IsFinished);
     }
@@ -36,9 +36,9 @@ public class TestSuccessEntity
         UserEntity user = new UserEntity();
         InquiryEntity inquiry = new InquiryEntity();
         SuccessEntity success = new SuccessEntity(user, inquiry, _isFinished);
-        Assert.Equal(0,success.UserId);
+        Assert.Equal(0, success.UserId);
         Assert.NotNull(success.User);
-        Assert.Equal(0,success.InquiryId);
+        Assert.Equal(0, success.InquiryId);
         Assert.NotNull(success.Inquiry);
         Assert.True(success.IsFinished);
     }
@@ -48,10 +48,10 @@ public class TestSuccessEntity
     {
         UserEntity user = new UserEntity();
         InquiryEntity inquiry = new InquiryEntity();
-        SuccessEntity success = new SuccessEntity(_userId, user,  _inquiryId, inquiry, _isFinished);
+        SuccessEntity success = new SuccessEntity(_userId, user, _inquiryId, inquiry, _isFinished);
-        Assert.Equal(_userId,success.UserId);
+        Assert.Equal(_userId, success.UserId);
         Assert.NotNull(success.User);
-        Assert.Equal(_inquiryId,success.InquiryId);
+        Assert.Equal(_inquiryId, success.InquiryId);
         Assert.NotNull(success.Inquiry);
         Assert.True(success.IsFinished);
     }

API_SQLuedo/TestEF/EntitiesTests/TestUserEntity.cs

@@ -9,11 +9,12 @@ namespace TestEF
         private const string _password = "password";
         private const bool _isAdmin = true;
         private const int _id = 42;
+
         [Fact]
         public void TestDefaultConstructor()
         {
             UserEntity user = new UserEntity();
-            Assert.Equal(0,user.Id);
+            Assert.Equal(0, user.Id);
             Assert.Null(user.Username);
             Assert.Null(user.Email);
             Assert.Null(user.Password);
@@ -24,7 +25,7 @@ namespace TestEF
         public void TestConstructorWithOnlyId()
         {
             UserEntity user = new UserEntity(_id);
-            Assert.Equal(_id,user.Id);
+            Assert.Equal(_id, user.Id);
             Assert.Null(user.Username);
             Assert.Null(user.Email);
             Assert.Null(user.Password);
@@ -35,7 +36,7 @@ namespace TestEF
         public void TestConstructorWithoutId()
         {
             UserEntity user = new UserEntity(_username, _password, _email, _isAdmin);
-            Assert.Equal(0,user.Id);
+            Assert.Equal(0, user.Id);
             Assert.Equal(_username, user.Username);
             Assert.Equal(_email, user.Email);
             Assert.Equal(_password, user.Password);
@@ -46,7 +47,7 @@ namespace TestEF
         public void TestConstructorWithoutAllAttributes()
         {
             UserEntity user = new UserEntity(_id, _username, _password, _email, _isAdmin);
-            Assert.Equal(_id,user.Id);
+            Assert.Equal(_id, user.Id);
             Assert.Equal(_username, user.Username);
             Assert.Equal(_email, user.Email);
             Assert.Equal(_password, user.Password);