resolution d'erreurs dans testConsoleAPI

API_SQLuedo/API/Controllers/InquiriesController.cs

@@ -13,41 +13,39 @@ namespace API.Controllers
     [ApiController]
     public class InquiriesController : Controller
     {
-        private readonly IInquiryService<InquiryDTO> _inquiryDataService;
+        private IdataService<UserDTO, LessonDTO, InquiryDTO, ParagraphDTO, SuccessDTO> _dataService;
 
         private readonly ILogger<InquiriesController> _logger;
-
+        public InquiriesController(IdataService<UserDTO, LessonDTO, InquiryDTO, ParagraphDTO, SuccessDTO> dataService, ILogger<InquiriesController> logger)
-        public InquiriesController(IInquiryService<InquiryDTO> inquiryDataService, ILogger<InquiriesController> logger)
         {
-            _inquiryDataService = inquiryDataService;
+            _dataService = dataService;
             _logger = logger;
         }
 
         [HttpGet("inquiries/{page:int}/{number:int}/{orderCriteria}")]
         [ProducesResponseType(typeof(InquiryDTO), 200)]
         [ProducesResponseType(typeof(string), 204)]
-        public IActionResult GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria)
+        public async Task<IActionResult> GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria)
         {
-            var nbInquiry = _inquiryDataService.GetInquiries(page, number, orderCriteria).Count();
+            var inquiries = ( await _dataService.inquiryService.GetItems(page, number, orderCriteria)).ToList();
-            if (nbInquiry == 0)
+            if (inquiries.Count() == 0)
             {
                 _logger.LogError("[ERREUR] Aucune enquête trouvée.");
                 return StatusCode(204);
             }
-
+            _logger.LogInformation("[INFORMATION] {nb} Enquête(s) trouvée(s)", inquiries.Count);
-            _logger.LogInformation("[INFORMATION] {nb} Enquête(s) trouvée(s)", nbInquiry);
+            return Ok(inquiries);
-            return Ok(_inquiryDataService.GetInquiries(page, number, orderCriteria));
         }
 
         [HttpGet("inquiry/{id:int}")]
         [ProducesResponseType(typeof(InquiryDTO), 200)]
         [ProducesResponseType(typeof(string), 404)]
-        public IActionResult GetInquiryById(int id)
+        public async Task<IActionResult> GetInquiryById(int id)
         {
             try
             {
                 _logger.LogInformation("[INFORMATION] L'enquête avec l'id {id} a été trouvé.", id);
-                return Ok(_inquiryDataService.GetInquiryById(id));
+                return Ok( await _dataService.inquiryService.GetItems(1, 1, null, InquiryOrderCriteria.ById.ToString().Substring(2),id));
             }
             catch (ArgumentException)
             {
@@ -59,12 +57,12 @@ namespace API.Controllers
         [HttpGet("inquiry/{title:alpha}")]
         [ProducesResponseType(typeof(InquiryDTO), 200)]
         [ProducesResponseType(typeof(string), 404)]
-        public IActionResult GetInquiryByTitle(string title)
+        public async Task<IActionResult> GetInquiryByTitle(string title)
         {
             try
             {
                 _logger.LogInformation("[INFORMATION] L'enquête avec le titre {title} a été trouvé.", title);
-                return Ok(_inquiryDataService.GetInquiryByTitle(title));
+                return Ok( await _dataService.inquiryService.GetItems(1, 1, null, InquiryOrderCriteria.ByTitle.ToString().Substring(2), title));
             }
             catch (ArgumentException)
             {
@@ -76,13 +74,13 @@ namespace API.Controllers
         [HttpDelete("inquiry/{id:int}")]
         [ProducesResponseType(typeof(InquiryDTO), 200)]
         [ProducesResponseType(typeof(string), 404)]
-        public IActionResult DeleteInquiry(int id)
+        public async Task<IActionResult> DeleteInquiry(int id)
         {
-            var success = _inquiryDataService.DeleteInquiry(id);
+            var success = await _dataService.inquiryService.DeleteItem(id);
             if (success)
             {
                 _logger.LogInformation("[INFORMATION] L'enquête avec l'id {id} a été supprimé.", id);
-                return Ok(_inquiryDataService.DeleteInquiry(id));
+                return Ok(_dataService.inquiryService.DeleteItem(id));
             }
             else
             {
@@ -94,25 +92,21 @@ namespace API.Controllers
         [HttpPost]
         [ProducesResponseType(typeof(InquiryDTO), 201)]
         [ProducesResponseType(typeof(string), 400)]
-        public IActionResult CreateInquiry([FromBody] InquiryDTO dto)
+        public async Task<IActionResult> CreateInquiry([FromBody] InquiryDTO dto)
         {
             if (dto.Title == null || dto.Description == null)
             {
                 return BadRequest();
             }
-
+            _logger.LogInformation("[INFORMATION] Une enquête a été créé : title - {title}, description - {description}, isUser - {isUser}", dto.Title, dto.Description, dto.IsUser);
-            _logger.LogInformation(
+            return Created(nameof(GetInquiries), await _dataService.inquiryService.AddItem(dto));
-                "[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:int}")]
         [ProducesResponseType(typeof(InquiryDTO), 200)]
         [ProducesResponseType(typeof(string), 400)]
         [ProducesResponseType(typeof(string), 404)]
-        public IActionResult UpdateInquiry(int id, [FromBody] InquiryDTO inquiryDTO)
+        public async Task<IActionResult> UpdateInquiry(int id, [FromBody] InquiryDTO inquiryDTO)
         {
             if (id != inquiryDTO.Id)
             {
@@ -130,7 +124,7 @@ namespace API.Controllers
             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));
+                return Ok( await _dataService.inquiryService.UpdateItem<InquiryDTO>(id, inquiryDTO));
             }
 
             _logger.LogError("[ERREUR] Aucune enquête trouvée avec l'id {id}.", id);

API_SQLuedo/API/Controllers/LessonsController.cs

@@ -13,22 +13,22 @@ namespace API.Controllers
     [ApiController]
     public class LessonsController : Controller
     {
-        private readonly ILessonService<LessonDTO> _lessonDataService;
+        private IdataService<UserDTO, LessonDTO, InquiryDTO, ParagraphDTO, SuccessDTO> _dataService;
 
         private readonly ILogger<LessonsController> _logger;
 
-        public LessonsController(ILessonService<LessonDTO> lessonDataService, ILogger<LessonsController> logger)
+        public LessonsController(IdataService<UserDTO, LessonDTO, InquiryDTO, ParagraphDTO, SuccessDTO> dataService, ILogger<LessonsController> logger)
         {
-            _lessonDataService = lessonDataService;
+            _dataService = dataService;
             _logger = logger;
         }
 
         [HttpGet("lessons/{page:int}/{number:int}/{orderCriteria}")]
         [ProducesResponseType(typeof(LessonDTO), 200)]
         [ProducesResponseType(typeof(string), 204)]
-        public IActionResult GetLessons(int page, int number, LessonOrderCriteria orderCriteria)
+        public async Task<IActionResult> GetLessons(int page, int number, LessonOrderCriteria orderCriteria)
         {
-            var nbLesson = _lessonDataService.GetLessons(page, number, orderCriteria).Count();
+            var nbLesson =  (await _dataService.lessonService.GetItems(page, number, orderCriteria)).Count();
             if (nbLesson == 0)
             {
                 _logger.LogError("[ERREUR] Aucune leçon trouvée.");
@@ -36,18 +36,18 @@ namespace API.Controllers
             }
 
             _logger.LogInformation("[INFORMATION] {nb} Leçon(s) trouvée(s)", nbLesson);
-            return Ok(_lessonDataService.GetLessons(page, number, orderCriteria));
+            return Ok(_dataService.lessonService.GetLessons(page, number, orderCriteria));
         }
 
         [HttpGet("lesson/{id:int}")]
         [ProducesResponseType(typeof(LessonDTO), 200)]
         [ProducesResponseType(typeof(string), 404)]
-        public IActionResult GetLessonById(int id)
+        public async Task<IActionResult> GetLessonById(int id)
         {
             try
             {
                 _logger.LogInformation("[INFORMATION] La leçon avec l'id {id} a été trouvé.", id);
-                return Ok(_lessonDataService.GetLessonById(id));
+                return Ok( await _dataService.lessonService.GetItems(1, 1, null, LessonOrderCriteria.ById.ToString().Substring(2), id));
             }
             catch (ArgumentException)
             {
@@ -59,12 +59,12 @@ namespace API.Controllers
         [HttpGet("lesson/{title:alpha}")]
         [ProducesResponseType(typeof(LessonDTO), 200)]
         [ProducesResponseType(typeof(string), 404)]
-        public IActionResult GetLessonByTitle(string title)
+        public async Task<IActionResult> GetLessonByTitle(string title)
         {
             try
             {
                 _logger.LogInformation("[INFORMATION] La leçon avec le titre {title} a été trouvé.", title);
-                return Ok(_lessonDataService.GetLessonByTitle(title));
+                return Ok(await _dataService.lessonService.GetItems(1, 1, null, LessonOrderCriteria.ByTitle.ToString().Substring(2), title));
             }
             catch (ArgumentException)
             {
@@ -76,13 +76,13 @@ namespace API.Controllers
         [HttpDelete("lesson/{id:int}")]
         [ProducesResponseType(typeof(LessonDTO), 200)]
         [ProducesResponseType(typeof(string), 404)]
-        public IActionResult DeleteLesson(int id)
+        public async Task<IActionResult> DeleteLesson(int id)
         {
-            var success = _lessonDataService.DeleteLesson(id);
+            var success = await _dataService.lessonService.DeleteItem(id);
             if (success)
             {
                 _logger.LogInformation("[INFORMATION] La leçon avec l'id {id} a été supprimé.", id);
-                return Ok(_lessonDataService.DeleteLesson(id));
+                return Ok();
             }
             else
             {
@@ -94,25 +94,21 @@ namespace API.Controllers
         [HttpPost]
         [ProducesResponseType(typeof(LessonDTO), 201)]
         [ProducesResponseType(typeof(string), 400)]
-        public IActionResult CreateLesson([FromBody] LessonDTO dto)
+        public async Task<IActionResult> CreateLesson([FromBody] LessonDTO dto)
         {
             if (dto.Title == null || dto.LastPublisher == null)
             {
                 return BadRequest();
             }
-
+            _logger.LogInformation("[INFORMATION] Une leçon a été créé : title - {title}, lastPublisher - {publisher}, lastEdit - {lastEdit}", dto.Title, dto.LastPublisher, dto.LastEdit);
-            _logger.LogInformation(
+            return Created(nameof(GetLessons), await _dataService.lessonService.AddItem(dto));
-                "[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:int}")]
         [ProducesResponseType(typeof(LessonDTO), 200)]
         [ProducesResponseType(typeof(string), 400)]
         [ProducesResponseType(typeof(string), 404)]
-        public IActionResult UpdateLesson(int id, [FromBody] LessonDTO lessonDTO)
+        public async Task<IActionResult> UpdateLesson(int id, [FromBody] LessonDTO lessonDTO)
         {
             if (id != lessonDTO.Id)
             {
@@ -130,7 +126,7 @@ namespace API.Controllers
             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));
+                return Ok(await _dataService.lessonService.UpdateItem<LessonDTO>(id, lessonDTO));
             }
 
             _logger.LogError("[ERREUR] Aucune leçon trouvée avec l'id {id}.", id);

API_SQLuedo/API/Controllers/UserController.cs

@@ -11,14 +11,14 @@ namespace API.Controllers
     [Authorize]
     [ApiVersion("1.0")]
     [ApiController]
-    public class UsersController(ILogger<UsersController> logger, IUserService<UserDTO> userService) : ControllerBase
+    public class UsersController(ILogger<UsersController> logger, IdataService<UserDTO, LessonDTO, InquiryDTO, ParagraphDTO, SuccessDTO> _dataService) : ControllerBase
     {
-        [HttpGet("users/{page:int}/{number:int}")]
+        [HttpGet("users/{page}/{number}")]
         [ProducesResponseType(typeof(UserDTO), 200)]
         [ProducesResponseType(typeof(string), 204)]
-        public IActionResult GetUsers(int page, int number, UserOrderCriteria orderCriteria)
+        public async Task<IActionResult> GetUsers(int page, int number, UserOrderCriteria orderCriteria)
         {
-            var users = userService.GetUsers(page, number, orderCriteria).ToList();
+            var users =  (await _dataService.userService.GetItems(page, number, orderCriteria)).ToList();
             if (users.Count == 0)
             {
                 logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
@@ -32,12 +32,12 @@ namespace API.Controllers
         [HttpGet("user/{id:int}")]
         [ProducesResponseType(typeof(UserDTO), 200)]
         [ProducesResponseType(typeof(string), 404)]
-        public IActionResult GetUserById(int id)
+        public async Task<IActionResult> GetUserById(int id)
         {
             try
             {
                 logger.LogInformation("[INFORMATION] Utilisateur avec l'id {id} a été trouvé.", id);
-                return Ok(userService.GetUserById(id));
+                return Ok( await _dataService.userService.GetItems(1, 1, null, UserOrderCriteria.ById.ToString().Substring(2), id));
             }
             catch (ArgumentException)
             {
@@ -49,12 +49,12 @@ namespace API.Controllers
         [HttpGet("user/{username:alpha}")]
         [ProducesResponseType(typeof(UserDTO), 200)]
         [ProducesResponseType(typeof(string), 404)]
-        public IActionResult GetUserByUsername(string username)
+        public async Task<IActionResult> GetUserByUsername(string username)
         {
             try
             {
                 logger.LogInformation("[INFORMATION] Utilisateur avec l'username {username} a été trouvé.", username);
-                return Ok(userService.GetUserByUsername(username));
+                return Ok( await _dataService.userService.GetItems(1, 1, null, UserOrderCriteria.ByUsername.ToString().Substring(2) , username));
             }
             catch (ArgumentException)
             {
@@ -63,12 +63,12 @@ namespace API.Controllers
             }
         }
 
-        [HttpDelete("user/{id:int}")]
+        [HttpDelete("user/{id}")]
         [ProducesResponseType(typeof(UserDTO), 200)]
         [ProducesResponseType(typeof(string), 404)]
-        public IActionResult DeleteUser(int id)
+        public async Task<IActionResult> DeleteUser(int id)
         {
-            var success = userService.DeleteUser(id);
+            var success = await _dataService.userService.DeleteItem(id);
             if (success)
             {
                 logger.LogInformation("[INFORMATION] L'utilisateur avec l'id {id} a été supprimé.", id);
@@ -84,26 +84,24 @@ namespace API.Controllers
         [HttpPost]
         [ProducesResponseType(typeof(UserDTO), 201)]
         [ProducesResponseType(typeof(string), 400)]
-        public IActionResult CreateUser([FromBody] UserDTO dto)
+        public async Task<IActionResult> CreateUser([FromBody] UserDTO dto)
         {
             if (dto.Username == null || dto.Password == null || dto.Email == null)
             {
                 return BadRequest();
             }
-
-            // return Ok(userService.CreateUser(username, password, email, isAdmin));
             logger.LogInformation(
                 "[INFORMATION] Un utilisateur a été créé : username - {username}, password - {password}, email - {email}, isAdmin - {isAdmin}",
                 dto.Username, dto.Password, dto.Email, dto.IsAdmin);
             return Created(nameof(GetUsers),
-                userService.CreateUser(dto.Username, dto.Password, dto.Email, dto.IsAdmin));
+                await _dataService.userService.AddItem(dto));
         }
 
-        [HttpPut("user/{id:int}")]
+        [HttpPut("user/{id}")]
         [ProducesResponseType(typeof(UserDTO), 200)]
         [ProducesResponseType(typeof(string), 400)]
         [ProducesResponseType(typeof(string), 404)]
-        public IActionResult UpdateUser(int id, [FromBody] UserDTO userDto)
+        public async Task<IActionResult> UpdateUser(int id, [FromBody] UserDTO userDto)
         {
             if (id != userDto.Id)
             {
@@ -122,7 +120,7 @@ namespace API.Controllers
             {
                 logger.LogInformation("[INFORMATION] La mise à jour de l'utilsiateur avec l'id {id} a été effectuée",
                     id);
-                return Ok(userService.UpdateUser(id, userDto));
+                return Ok(await _dataService.userService.UpdateItem<UserDTO>(id, userDto));
             }
 
             logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id {id}.", id);

API_SQLuedo/API/Program.cs

@@ -19,6 +19,10 @@ builder.Services.AddControllers();
 builder.Services.AddEndpointsApiExplorer();
 builder.Services.AddSwaggerGen();
 
+//builder.Services.AddScoped<IUserService<UserEntity>, DbDataManager.Service.UserDataService>();
+//builder.Services.AddScoped<IUserDataService, Shared.UserDataService>();
+builder.Services.AddScoped<IdataService<UserDTO, LessonDTO, InquiryDTO, ParagraphDTO, SuccessDTO>, DataService<UserDTO, LessonDTO, InquiryDTO, ParagraphDTO, SuccessDTO>>();
+
 builder.Services.AddScoped<IUserService<UserEntity>, UserDataService>();
 builder.Services.AddScoped<IUserService<UserDTO>, UserDataServiceApi>();
 

API_SQLuedo/API/Service/InquiryDataServiceAPI.cs

@@ -8,6 +8,11 @@ namespace API.Service;
 
 public class InquiryDataServiceApi(IInquiryService<InquiryEntity> inquiryService) : IInquiryService<InquiryDTO>
 {
+    public async Task<InquiryDTO?> AddItem(InquiryDTO? item)
+    {
+        var inquiry = await inquiryService.AddItem(item.FromDTOToEntity());
+        return inquiry.FromEntityToDTO();
+    }
     public InquiryDTO UpdateInquiry(int id, InquiryDTO inquiry)
     {
         return inquiryService.UpdateInquiry(id, inquiry.FromDTOToEntity()).FromEntityToDTO();
@@ -22,14 +27,32 @@ public class InquiryDataServiceApi(IInquiryService<InquiryEntity> inquiryService
     {
         return inquiryService.DeleteInquiry(id);
     }
-
+    public Task<bool> DeleteItem(int id)
+    {
+        return inquiryService.DeleteItem(id);
+    }
     public IEnumerable<InquiryDTO> GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria)
     {
         var inquiries = inquiryService.GetInquiries(page, number, orderCriteria);
         return inquiries.Select(i => i.FromEntityToDTO()).ToList();
     }
-
     public InquiryDTO GetInquiryById(int id) => inquiryService.GetInquiryById(id).FromEntityToDTO();
 
+    public async Task<IEnumerable<InquiryDTO>> GetItems(int page, int count, object? orderCriteria = null, string? filter = null, object? valueFilter = null)
+    {
+       var inquiries = await inquiryService.GetItems(page, count, orderCriteria, filter, valueFilter);
+        return inquiries.ToList().Select(i => i.FromEntityToDTO());
+    }
+
+    public InquiryEntity UpdateInquiry(int id, InquiryEntity inquiry)
+    {
+        return inquiryService.UpdateInquiry(id, inquiry);
+    }
+
+    public async Task<InquiryDTO> UpdateItem<TDto>(int? id, TDto? newItem) where TDto : class
+    {
+        var inquiry = await inquiryService.UpdateItem<TDto>(id, newItem);
+        return inquiry.FromEntityToDTO();
+    }
     public InquiryDTO GetInquiryByTitle(string title) => inquiryService.GetInquiryByTitle(title).FromEntityToDTO();
 }

API_SQLuedo/API/Service/LessonDataServiceAPI.cs

@@ -22,10 +22,34 @@ public class LessonDataServiceApi(ILessonService<LessonEntity> lessonService) :
 
     public LessonDTO UpdateLesson(int id, LessonDTO lesson) =>
         lessonService.UpdateLesson(id, lesson.FromDTOToEntity()).FromEntityToDTO();
-
     public LessonDTO UpdateLesson(int id, LessonEntity lesson) =>
         lessonService.UpdateLesson(id, lesson).FromEntityToDTO();
 
     public LessonDTO CreateLesson(string title, string lastPublisher, DateOnly? lastEdit) =>
         lessonService.CreateLesson(title, lastPublisher, lastEdit).FromEntityToDTO();
+
+    public async Task<LessonDTO?> AddItem(LessonDTO? item)
+    {
+        var lesson = await lessonService.AddItem(item.FromDTOToEntity());
+        return lesson.FromEntityToDTO();
+    }
+
+    public async Task<bool> DeleteItem(int id)
+    {
+        var succes = await lessonService.DeleteItem(id);
+        return succes;
+    }
+
+    public async Task<LessonDTO> UpdateItem<TDto>(int? id, TDto? newItem) where TDto : class
+    {
+        var lesson = await lessonService.UpdateItem(id, newItem);
+        return lesson.FromEntityToDTO();
+    }
+
+    public async Task<IEnumerable<LessonDTO>> GetItems(int page, int count, object? orderCriteria = null, string? filter = null, object? valueFilter = null)
+    {
+        var lessons = await lessonService.GetItems(page, count, orderCriteria, filter, valueFilter);
+        return lessons.ToList().Select(l => l.FromEntityToDTO());
+
+    }
 }

API_SQLuedo/API/Service/UserDataServiceAPI.cs

@@ -22,7 +22,30 @@ public class UserDataServiceApi(IUserService<UserEntity> userService) : IUserSer
 
     public UserDTO UpdateUser(int id, UserDTO user) =>
         userService.UpdateUser(id, user.FromDTOToEntity()).FromEntityToDTO();
-
     public UserDTO CreateUser(string username, string password, string email, bool isAdmin) =>
         userService.CreateUser(username, password, email, isAdmin).FromEntityToDTO();
+
+    public async Task<UserDTO?> AddItem(UserDTO item)
+    {
+        var user = await userService.AddItem(item.FromDTOToEntity());
+        return user.FromEntityToDTO();
+    }
+
+    public async Task<bool> DeleteItem(int id)
+    {
+        var sucess = await userService.DeleteItem(id);
+        return sucess;
+    }
+
+    public async Task<UserDTO> UpdateItem<TDto>(int? id, TDto? newItem) where TDto : class
+    {
+        var user = await userService.UpdateItem<TDto>(id, newItem);
+        return user.FromEntityToDTO();
+    }
+
+    public async Task<IEnumerable<UserDTO>> GetItems(int page, int count, object? orderCriteria = null, string? filter = null, object? valueFilter = null)
+    {
+        var usersEntities = await userService.GetItems(page, count, orderCriteria, filter, valueFilter);
+        return usersEntities.Select(e => e.FromEntityToDTO()).ToList();
+    }
 }

API_SQLuedo/DbContextLib/UserDbContext.cs

@@ -16,11 +16,8 @@ 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)
+        public UserDbContext() : base() { }
-        {
-        }
-
         protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
         {
             if (!optionsBuilder.IsConfigured)

API_SQLuedo/DbDataManager/Service/InquiryDataService.cs

@@ -1,8 +1,10 @@
 using DbContextLib;
+using Dto;
 using Entities;
 using Microsoft.EntityFrameworkCore;
 using Model.OrderCriteria;
 using Shared;
+using Shared.ModelToEntities;
 
 namespace DbDataManager.Service;
 
@@ -100,4 +102,40 @@ public class InquiryDataService : IInquiryService<InquiryEntity>
         DbContext.SaveChangesAsync();
         return updatingInquiry;
     }
+/*    public InquiryEntity CreateInquiry(string title, string description, bool isUser)
+    {
+        var newInquiryEntity = new InquiryEntity()
+        {
+            Title = title,
+            Description = description,
+            IsUser = isUser
+        };
+        DbContext.Inquiries.Add(newInquiryEntity);
+        DbContext.SaveChangesAsync();
+        return newInquiryEntity;
+    }*/
+
+    public Task<InquiryEntity?> AddItem(InquiryEntity? item)
+    {
+        var inquiry = DbContext.CreateItemAsync<InquiryEntity>(item);
+        return inquiry;
+    }
+
+    public Task<bool> DeleteItem(int id)
+    {
+        var success = DbContext.DeleteItemAsync<InquiryEntity>(id);
+        return success;
+    }
+
+    public Task<InquiryEntity> UpdateItem<TDto>(int? id, TDto? newItem) where TDto : class
+    {
+        var inquiry = DbContext.UpdateItemAsync<InquiryEntity, TDto>(id, newItem);
+        return inquiry;
+    }
+
+    public async Task<IEnumerable<InquiryEntity>> GetItems(int page, int count, object? orderCriteria = null, string? filter = null, object? valueFilter = null)
+    {
+        var inquiries = await DbContext.GetItemsWithFilter<InquiryEntity>(page, count, orderCriteria, filter, valueFilter);
+        return inquiries;
+    }
 }

API_SQLuedo/DbDataManager/Service/LessonDataService.cs

@@ -1,11 +1,12 @@
+
 using DbContextLib;
 using Entities;
 using Microsoft.EntityFrameworkCore;
 using Model.OrderCriteria;
 using Shared;
+using Shared.ModelToEntities;
 
 namespace DbDataManager.Service;
-
 public class LessonDataService : ILessonService<LessonEntity>
 {
     private UserDbContext DbContext { get; set; }
@@ -105,4 +106,40 @@ public class LessonDataService : ILessonService<LessonEntity>
         DbContext.SaveChangesAsync();
         return newLessonEntity;
     }
+
+    public async Task<LessonEntity?> AddItem(LessonEntity? item)
+    {
+        using (var context = DbContext = new UserDbContext()) 
+        {
+            var lesson = await context.CreateItemAsync<LessonEntity>(item);
+            return item;
+        }
+    }
+
+    public async Task<bool> DeleteItem(int id)
+    {
+        using (var context = DbContext = new UserDbContext())
+        {
+            var succes = await context.DeleteItemAsync<LessonEntity>(id);
+            return succes;
+        }
+    }
+
+    public async Task<LessonEntity> UpdateItem<TDto>(int? id, TDto? newItem) where TDto : class
+    {
+        using (var context = DbContext = new UserDbContext())
+        {
+            var lesson = await context.UpdateItemAsync<LessonEntity, TDto>(id, newItem);
+            return lesson;
+        }
+    }
+
+    public async Task<IEnumerable<LessonEntity>> GetItems(int page, int count, object? orderCriteria = null, string? filter = null, object? valueFilter = null)
+    {
+        using (var context = DbContext = new UserDbContext())
+        {
+            var lessons = await context.GetItemsWithFilter<LessonEntity>(page, count, orderCriteria, filter, valueFilter);
+            return lessons;
+        }
+    }
 }

API_SQLuedo/DbDataManager/Service/UserDataService.cs

@@ -1,7 +1,9 @@
 using DbContextLib;
+using Dto;
 using Entities;
 using Model.OrderCriteria;
 using Shared;
+using Shared.ModelToEntities;
 
 namespace DbDataManager.Service;
 
@@ -108,4 +110,39 @@ public class UserDataService : IUserService<UserEntity>
         DbContext.SaveChangesAsync();
         return newUserEntity;
     }
+
+    public Task<UserEntity?> AddItem(UserEntity? item)
+    {
+        using(var context = new UserDbContext())
+        {
+            var user = context.CreateItemAsync(item);
+            return user;
+        }
+
+    }
+
+    public Task<bool> DeleteItem(int id)
+    {
+        using (var context = new UserDbContext())
+        {
+            var user = context.DeleteItemAsync<UserEntity>(id);
+            return user;
+        }
+    }
+
+    public Task<UserEntity> UpdateItem<TDto>(int? id, TDto? newItem) where TDto : class
+    {
+        var user = DbContext.UpdateItemAsync<UserEntity, TDto>(id, newItem);
+        return user;
+    }
+
+    public async Task<IEnumerable<UserEntity>> GetItems(int page, int count, object? orderCriteria = null, string? filter = null, object? valueFilter = null)
+    {
+        var user = (await DbContext.GetItemsWithFilter<UserEntity>(page, count, orderCriteria, filter, valueFilter));
+        if(user == null)
+        {
+            throw new ArgumentNullException("il n'y a pas de donnée");
+        }
+        return user;
+    }
 }

API_SQLuedo/Dto/ContentLessonDTO.cs

@@ -7,6 +7,10 @@ public abstract class ContentLessonDTO
     public string ContentTitle { get; set; }
     public int LessonId { get; set; }
 
+    protected ContentLessonDTO()
+    {
+    }
+
     protected ContentLessonDTO(int id, string contentContent, string contentTitle, int lessonId)
     {
         Id = id;
@@ -22,7 +26,5 @@ public abstract class ContentLessonDTO
         LessonId = lessonId;
     }
 
-    protected ContentLessonDTO()
+
-    {
-    }
 }

API_SQLuedo/Dto/InquiryDTO.cs

@@ -2,15 +2,14 @@
 
 public class InquiryDTO
 {
-    public int Id { get; }
+    public int Id { get; set; }
 
     public string Title { get; set; }
 
     public string Description { get; set; }
 
     public bool IsUser { get; set; }
-
+    public InquiryDTO() { }
-    public InquiryDTO(){}
     public InquiryDTO(int id, string title, string description, bool isUser)
     {
         Id = id;

API_SQLuedo/Model/OrderCriteria/InquiryOrderCriteria.cs

@@ -5,5 +5,6 @@ public enum InquiryOrderCriteria
     None,
     ByTitle,
     ByDescription,
-    ByIsUser
+    ByIsUser,
+    ById
 }

API_SQLuedo/Model/OrderCriteria/LessonOrderCriteria.cs

@@ -5,5 +5,6 @@ public enum LessonOrderCriteria
     None,
     ByTitle,
     ByLastPublisher,
-    ByLastEdit
+    ByLastEdit,
+    ById,
 }

API_SQLuedo/Shared/DataService.cs

@@ -0,0 +1,33 @@
+using DbContextLib;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Shared
+{
+    public class DataService<TUser, Tlesson, TInquiry, TParagraphe, TSucesss> : IdataService<TUser, Tlesson, TInquiry, TParagraphe, TSucesss> where TUser : class where TInquiry : class where Tlesson : class
+    {
+        private UserDbContext _dbContext;
+        public DataService(UserDbContext userDbContext, IUserService<TUser> userService, ILessonService<Tlesson> lessonService, IInquiryService<TInquiry> inquiryService, IParagraphService<TParagraphe> paragrapheService, ISuccessService<TSucesss> sucessService) 
+        {
+            this._dbContext = userDbContext;
+
+            this.inquiryService = inquiryService;
+            this.lessonService = lessonService;
+            this.paragraphService = paragrapheService;
+            this.successDataService = sucessService;
+            this.userService = userService;
+        }
+        public IUserService<TUser> userService { get; }
+
+        public IInquiryService<TInquiry> inquiryService { get; }
+
+        public ILessonService<Tlesson> lessonService { get; }
+
+    public IParagraphService<TParagraphe> paragraphService { get; }
+
+    public ISuccessService<TSucesss> successDataService { get; }
+}
+}

API_SQLuedo/Shared/Extensions.cs

@@ -0,0 +1,130 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Shared
+{
+    using DbContextLib;
+    using Microsoft.EntityFrameworkCore;
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Linq.Expressions;
+    using System.Text;
+    using System.Threading.Tasks;
+
+    namespace ModelToEntities
+    {
+        public static class Extensions
+        {
+            public static Task<T?> CreateItemAsync<T>(this DbContext context, T? item) where T : class
+            {
+                if (item == null || context.Set<T>().Contains(item))
+                {
+                    return Task.FromResult<T?>(null);
+                }
+
+                context.Set<T>().Add(item);
+                context.SaveChangesAsync();
+
+                return Task.FromResult<T?>(item);
+            }
+            public static Task<bool> DeleteItemAsync<T>(this DbContext context, int? id) where T : class
+            {
+                if (id == null)
+                {
+                    return Task.FromResult(false);
+                }
+
+                var entity = context.Set<T>().Find(id);
+                if (entity == null)
+                {
+                    return Task.FromResult(false);
+                }
+
+                context.Set<T>().Remove(entity);
+                context.SaveChanges();
+
+                return Task.FromResult(true);
+            }
+            public static Task<T?> UpdateItemAsync<T, TDto>(this DbContext context, int? id, TDto dto)
+            where T : class
+            where TDto : class
+            {
+                var entity = context.Set<T>().Find(id);
+                if (entity == null)
+                {
+                    throw new ArgumentException("Impossible de trouver l'entité", nameof(id));
+                }
+                var primaryKey = context.Model.FindEntityType(typeof(T)).FindPrimaryKey();
+                var primaryKeyPropertyName = primaryKey.Properties.Select(x => x.Name).Single();
+
+                var propertiesToUpdate = typeof(TDto).GetProperties()
+                                                      .Where(p => p.CanRead && p.CanWrite && p.Name != primaryKeyPropertyName);
+
+                foreach (var property in propertiesToUpdate)
+                {
+                    var value = property.GetValue(dto);
+                    typeof(T).GetProperty(property.Name)?.SetValue(entity, value);
+                }
+
+                context.Entry(entity).State = EntityState.Modified; // Permet d'indiquer en Db que l'entité a été modifiée.
+                context.SaveChanges();
+
+                return Task.FromResult<T?>(entity);
+            }
+            public static Task<IEnumerable<T?>> GetItemsWithFilter<T>(this DbContext context,
+                int page, int count, object orderCriteria, string? filter = null, object? valueProperty = null) where T : class
+            {
+                IQueryable<T> query = context.Set<T>().Skip((page - 1) * count).Take(count);
+
+                if (valueProperty != null && !string.IsNullOrEmpty(filter))
+                {
+                    var idProp = typeof(T).GetProperty(filter);
+                    if (idProp != null)
+                    {
+                        var parameter = Expression.Parameter(typeof(T), "entity");
+                        var propertyAccess = Expression.Property(parameter, idProp);
+                        var constant = Expression.Constant(valueProperty);
+                        var equality = Expression.Equal(propertyAccess, constant);
+                        var lambda = Expression.Lambda<Func<T, bool>>(equality, parameter);
+                        var filteredEntity = context.Set<T>().FirstOrDefault(lambda);
+                        if (filteredEntity != null)
+                        {
+                            return Task.FromResult<IEnumerable<T?>>(new List<T?> { filteredEntity });
+                        }
+                    }
+                    return Task.FromResult<IEnumerable<T?>>(null);
+                }
+                if (orderCriteria != null && orderCriteria.ToString() != "None")
+                {
+                    // Ordonnancement
+                    var propertyName = orderCriteria.ToString();
+                    if (propertyName.StartsWith("By"))
+                    {
+                        propertyName = propertyName.Substring(2);
+                    }
+                    var parameterExpression = Expression.Parameter(typeof(T), "entity");
+                    var propertyExpression = Expression.Property(parameterExpression, propertyName);
+                    var lambdaExpression = Expression.Lambda<Func<T, object>>(Expression.Convert(propertyExpression, typeof(object)), parameterExpression);
+
+                    // Utilisation de la méthode OrderBy
+                    var orderedQuery = Expression.Call(
+                        typeof(Queryable),
+                        "OrderBy",
+                        new Type[] { typeof(T), typeof(object) },
+                        query.Expression,
+                        lambdaExpression
+                    );
+
+                    query = query.Provider.CreateQuery<T>(orderedQuery);
+                }
+                var orderingItem = query.ToList();
+                return Task.FromResult<IEnumerable<T?>>(orderingItem);
+            }
+        }
+    }
+
+}

API_SQLuedo/Shared/IGenericDataService.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Shared
+{
+    public interface IGenericDataService<T> where T : class
+    {
+        public Task<T?> AddItem(T? item);
+        public Task<bool> DeleteItem(int id);
+        public Task<T> UpdateItem<TDto>(int? id, TDto? newItem) where TDto : class;
+        public Task<IEnumerable<T>> GetItems(int page, int count, object? orderCriteria = null, string? filter = null, object? valueFilter = null);
+
+    }
+}

API_SQLuedo/Shared/IInquiryService.cs

@@ -2,7 +2,7 @@
 
 namespace Shared;
 
-public interface IInquiryService<TInquiry>
+public interface IInquiryService<TInquiry> : IGenericDataService<TInquiry> where TInquiry : class
 {
     public IEnumerable<TInquiry> GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria);
     public TInquiry GetInquiryById(int id);

API_SQLuedo/Shared/ILessonService.cs

@@ -2,7 +2,7 @@
 
 namespace Shared;
 
-public interface ILessonService<TLesson>
+public interface ILessonService<TLesson> : IGenericDataService<TLesson> where TLesson : class
 {
     public IEnumerable<TLesson> GetLessons(int page, int number, LessonOrderCriteria orderCriteria);
     public TLesson GetLessonById(int id);

API_SQLuedo/Shared/IUserService.cs

@@ -2,7 +2,7 @@
 
 namespace Shared
 {
-    public interface IUserService<TUser>
+    public interface IUserService<TUser> : IGenericDataService<TUser> where TUser : class
     {
         public IEnumerable<TUser> GetUsers(int page, int number, UserOrderCriteria orderCriteria);
         public TUser GetUserById(int id);

API_SQLuedo/Shared/IdataService.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Shared
+{
+    public interface IdataService<TUser, Tlesson, TInquiry, TParagraphe, TSucesss> where TUser : class where TInquiry : class where Tlesson : class
+    {
+        IUserService<TUser> userService { get; }
+        IInquiryService<TInquiry> inquiryService { get; }
+        ILessonService<Tlesson> lessonService { get; }
+        IParagraphService<TParagraphe> paragraphService { get; }
+        ISuccessService<TSucesss> successDataService { get; }
+
+
+    }
+}

API_SQLuedo/StubbedContextLib/StubbedContext.cs

@@ -11,6 +11,7 @@ public class StubbedContext : UserDbContext
     public StubbedContext(DbContextOptions<UserDbContext> options) : base(options)
     {
     }
+    public StubbedContext() : base() { }
 
     protected override void OnModelCreating(ModelBuilder modelBuilder)
     {

API_SQLuedo/TestConsoleAPI/Program.cs

@@ -5,11 +5,13 @@ using API.Service;
 using DbContextLib;
 using DbDataManager.Service;
 using Dto;
+using Entities;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Data.Sqlite;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Model.OrderCriteria;
+using Shared;
 using Service_LessonDataService = DbDataManager.Service.LessonDataService;
 using Service_ParagraphDataService = DbDataManager.Service.ParagraphDataService;
 using Service_SuccessDataService = DbDataManager.Service.SuccessDataService;
@@ -30,31 +32,29 @@ ILogger<SuccessesController> successLogger = factory.CreateLogger<SuccessesContr
 
 using (var context = new UserDbContext(options))
 {
-    var userController = new UsersController(userLogger, new UserDataServiceApi(new Service_UserDataService(context)));
+    var userController = new UsersController(userLogger, new DataService<UserDTO, LessonDTO, InquiryDTO, ParagraphDTO, SuccessDTO>(context, new UserDataServiceApi(new Service_UserDataService(context)), new LessonDataServiceApi(new Service_LessonDataService(context)), new InquiryDataServiceApi(new InquiryDataService(context)), new ParagraphDataServiceApi(new Service_ParagraphDataService(context)), new SuccessDataServiceApi(new Service_SuccessDataService(context))));
-    var inquiryController =
+    var inquiryController = new InquiriesController(new DataService<UserDTO, LessonDTO, InquiryDTO, ParagraphDTO, SuccessDTO>(context, new UserDataServiceApi(new Service_UserDataService(context)), new LessonDataServiceApi(new Service_LessonDataService(context)), new InquiryDataServiceApi(new InquiryDataService(context)), new ParagraphDataServiceApi(new Service_ParagraphDataService(context)), new SuccessDataServiceApi(new Service_SuccessDataService(context))), inquiryLogger);
-        new InquiriesController(new InquiryDataServiceApi(new InquiryDataService(context)), inquiryLogger);
     var paragraphController =
         new ParagraphsController(new ParagraphDataServiceApi(new Service_ParagraphDataService(context)),
             paragraphLogger);
-    var lessonController =
+    var lessonController = new LessonsController(new DataService<UserDTO, LessonDTO, InquiryDTO, ParagraphDTO, SuccessDTO>(context, new UserDataServiceApi(new Service_UserDataService(context)), new LessonDataServiceApi(new Service_LessonDataService(context)), new InquiryDataServiceApi(new InquiryDataService(context)), new ParagraphDataServiceApi(new Service_ParagraphDataService(context)), new SuccessDataServiceApi(new Service_SuccessDataService(context))), lessonLogger);
-        new LessonsController(new LessonDataServiceApi(new Service_LessonDataService(context)), lessonLogger);
     var successController = new SuccessesController(new SuccessDataServiceApi(new Service_SuccessDataService(context)),
     successLogger);
 
-    void PrintUsers()
+    async void PrintUsers()
     {
         Console.WriteLine();
-        var users = userController.GetUsers(1, 10, UserOrderCriteria.None) as OkObjectResult;
+        var users = await userController.GetUsers(1, 10, UserOrderCriteria.None) as OkObjectResult;
         foreach (var item in users.Value as IEnumerable<UserDTO>)
         {
             Console.WriteLine(item);
         }
     }
 
-    void PrintInquiries()
+    async void PrintInquiries()
     {
         Console.WriteLine();
-        var inquiries = inquiryController.GetInquiries(1, 10, InquiryOrderCriteria.None) as OkObjectResult;
+        var inquiries = await inquiryController.GetInquiries(1, 10, InquiryOrderCriteria.None) as OkObjectResult;
         foreach (var item in inquiries.Value as IEnumerable<InquiryDTO>)
         {
             Console.WriteLine(item);
@@ -71,10 +71,10 @@ using (var context = new UserDbContext(options))
         }
     }
 
-    void PrintLessons()
+    async void PrintLessons()
     {
         Console.WriteLine();
-        var lessons = lessonController.GetLessons(1, 10, LessonOrderCriteria.None) as OkObjectResult;
+        var lessons = await lessonController.GetLessons(1, 10, LessonOrderCriteria.None) as OkObjectResult;
         foreach (var item in lessons.Value as IEnumerable<LessonDTO>)
         {
             Console.WriteLine(item);
@@ -91,11 +91,12 @@ using (var context = new UserDbContext(options))
         }
     }
 
-    void SearchUserByUsername()
+    async void SearchUserByUsername()
     {
         Console.WriteLine("\nVeuillez saisir le pseudonyme de l'utilisateur recherché : ");
         var username = Console.ReadLine();
-        var user = userController.GetUserByUsername(username) as OkObjectResult;
+        //var user = userController.GetUserByUsername(username) as OkObjectResult;
+        var user = await userController.GetUserByUsername(username) as OkObjectResult;
         if (user == null)
         {
             Console.WriteLine("Erreur, la requête n'a rien donné.");
@@ -105,11 +106,11 @@ using (var context = new UserDbContext(options))
         Console.WriteLine(user.Value as UserDTO);
     }
 
-    void SearchInquiryByTitle()
+    async void SearchInquiryByTitle()
     {
         Console.WriteLine("\nVeuillez saisir le titre de l'enquête recherchée : ");
         var title = Console.ReadLine();
-        var inquiry = inquiryController.GetInquiryByTitle(title) as OkObjectResult;
+        var inquiry = await inquiryController.GetInquiryByTitle(title) as OkObjectResult;
         if (inquiry == null)
         {
             Console.WriteLine("Erreur, la requête n'a rien donné.");
@@ -133,11 +134,11 @@ using (var context = new UserDbContext(options))
         Console.WriteLine(paragraph.Value as ParagraphDTO);
     }
 
-    void SearchLessonByTitle()
+    async void SearchLessonByTitle()
     {
         Console.WriteLine("\nVeuillez saisir le titre de la leçon recherchée : ");
         var title = Console.ReadLine();
-        var lesson = lessonController.GetLessonByTitle(title) as OkObjectResult;
+        var lesson = await lessonController.GetLessonByTitle(title) as OkObjectResult;
         if (lesson == null)
         {
             Console.WriteLine("Erreur, la requête n'a rien donné.");
@@ -161,11 +162,11 @@ using (var context = new UserDbContext(options))
         Console.WriteLine(success.Value as SuccessDTO);
     }
 
-    void SearchUserById()
+    async void SearchUserById()
     {
         Console.WriteLine("\nVeuillez saisir l'identifiant de l'utilisateur recherché : ");
         var id = Console.ReadLine();
-        var user = userController.GetUserById(int.Parse(id)) as OkObjectResult;
+        var user = await userController.GetUserById(int.Parse(id)) as OkObjectResult;
         if (user == null)
         {
             Console.WriteLine("Erreur, la requête n'a rien donné.");
@@ -175,11 +176,11 @@ using (var context = new UserDbContext(options))
         Console.WriteLine(user.Value as UserDTO);
     }
 
-    void SearchInquiryById()
+    async void SearchInquiryById()
     {
         Console.WriteLine("\nVeuillez saisir l'identifiant de l'enquête recherchée : ");
         var id = Console.ReadLine();
-        var inquiry = inquiryController.GetInquiryById(int.Parse(id)) as OkObjectResult;
+        var inquiry = await inquiryController.GetInquiryById(int.Parse(id)) as OkObjectResult;
         if (inquiry == null)
         {
             Console.WriteLine("Erreur, la requête n'a rien donné.");
@@ -217,11 +218,11 @@ using (var context = new UserDbContext(options))
         Console.WriteLine(success.Value as SuccessDTO);
     }
 
-    void SearchLessonById()
+    async void SearchLessonById()
     {
         Console.WriteLine("\nVeuillez saisir l'identifiant de la leçon recherchée : ");
         var id = Console.ReadLine();
-        var lesson = lessonController.GetLessonById(int.Parse(id)) as OkObjectResult;
+        var lesson = await lessonController.GetLessonById(int.Parse(id)) as OkObjectResult;
         if (lesson == null)
         {
             Console.WriteLine("Erreur, la requête n'a rien donné.");
@@ -336,14 +337,14 @@ using (var context = new UserDbContext(options))
         }
     }
 
-    void UpdateUser()
+    async void UpdateUser()
     {
         Console.WriteLine("Quel est l'identifiant de l'utilisateur à mettre à jour ?");
         var id = int.Parse(Console.ReadLine());
         var res = (userController.GetUserById(id));
         if (res.GetType() == typeof(OkObjectResult))
         {
-            var user = (res as OkObjectResult).Value as UserDTO;
+            var user = (await res as OkObjectResult).Value as UserDTO;
             if (user == null)
             {
                 Console.WriteLine("Erreur, un problème est survenu");
@@ -374,14 +375,14 @@ using (var context = new UserDbContext(options))
         }
     }
 
-    void UpdateInquiry()
+    async void UpdateInquiry()
     {
         Console.WriteLine("Quel est l'identifiant de l'enquête à mettre à jour ?");
         var id = int.Parse(Console.ReadLine());
         var res = (inquiryController.GetInquiryById(id));
         if (res.GetType() == typeof(OkObjectResult))
         {
-            var user = (res as OkObjectResult).Value as InquiryDTO;
+            var user = ( await res as OkObjectResult).Value as InquiryDTO;
             if (user == null)
             {
                 Console.WriteLine("Erreur, un problème est survenu");
@@ -464,14 +465,14 @@ using (var context = new UserDbContext(options))
         }
     }
 
-    void UpdateLesson()
+    async void UpdateLesson()
     {
         Console.WriteLine("Quel est l'identifiant de la leçon à mettre à jour ?");
         var id = int.Parse(Console.ReadLine());
         var res = (lessonController.GetLessonById(id));
         if (res.GetType() == typeof(OkObjectResult))
         {
-            var lesson = (res as OkObjectResult).Value as LessonDTO;
+            var lesson = (await res as OkObjectResult).Value as LessonDTO;
             if (lesson == null)
             {
                 Console.WriteLine("Erreur, un problème est survenu");