Ajout des bonnes routes des controller

API_SQLuedo/API/Controllers/BlackListController.cs

@@ -1,13 +1,18 @@
+using Asp.Versioning;
 using Dto;
-using Entities;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Model.OrderCriteria;
 using Shared;
-using Shared.Mapper;
 
 namespace API.Controllers;
 
-public class BlackListController(ILogger<UsersController> logger, IBlackListService<BlackListDto> blackListService) : ControllerBase
+[Route("api/v{version:apiVersion}/[controller]")]
+[Authorize]
+[ApiVersion("1.0")]
+[ApiController]
+public class BlackListController(ILogger<UsersController> logger, IBlackListService<BlackListDto> blackListService)
+    : ControllerBase
 {
     [HttpGet("user/ban/{page:int}/{number:int}")]
     [ProducesResponseType(typeof(IEnumerable<BlackListDto>), 200)]
@@ -46,6 +51,7 @@ public class BlackListController(ILogger<UsersController> logger, IBlackListServ
             logger.LogInformation("[INFORMATION] Utilisateur banni avec l'email {email} a été trouvé.", email);
             return Ok(res);
         }
+
         logger.LogError("[ERREUR] Aucun utilisateur banni trouvé avec l'email {email}.", email);
         return NotFound("Utilisateur non trouvé !");
     }
@@ -58,7 +64,8 @@ public class BlackListController(ILogger<UsersController> logger, IBlackListServ
         var success = blackListService.BanUser(username);
         if (success)
         {
-            logger.LogInformation("[INFORMATION] L'utilisateur avec le pseudo {username} a été banni pour 2 ans.", username);
+            logger.LogInformation("[INFORMATION] L'utilisateur avec le pseudo {username} a été banni pour 2 ans.",
+                username);
             return Ok();
         }
         else

API_SQLuedo/API/Controllers/InquiriesController.cs

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

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

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

API_SQLuedo/API/Controllers/SuccessesController.cs

@@ -5,203 +5,202 @@ using Model.OrderCriteria;
 using Shared;
 using Asp.Versioning;
 
-namespace API.Controllers
+namespace API.Controllers;
+
+[Route("api/v{version:apiVersion}/[controller]")]
+[Authorize]
+[ApiVersion("1.0")]
+[ApiController]
+public class SuccessesController : Controller
 {
-    [Route("api/v{version:apiVersion}/[controller]")]
+    private readonly ISuccessService<SuccessDto> _successDataService;
-    [Authorize]
+
-    [ApiVersion("1.0")]
+    private readonly ILogger<SuccessesController> _logger;
-    [ApiController]
+
-    public class SuccessesController : Controller
+    public SuccessesController(ISuccessService<SuccessDto> successDataService, ILogger<SuccessesController> logger)
+    {
+        _successDataService = successDataService;
+        _logger = logger;
+    }
+
+    [HttpGet("successes/{page:int}/{number:int}/{orderCriteria}")]
+    [ProducesResponseType(typeof(SuccessDto), 200)]
+    [ProducesResponseType(typeof(string), 204)]
+    [ProducesResponseType(typeof(string), 400)]
+    public IActionResult GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria)
+    {
+        if (page < 1 || number < 1)
+        {
+            _logger.LogError("[ERREUR] La page ou le nombre de succès est inférieur à 1.");
+            return BadRequest("La page ou le nombre de succès est inférieur à 1.");
+        }
+
+        var nbUser = _successDataService.GetSuccesses(page, number, orderCriteria).ToList().Count;
+        if (nbUser == 0)
+        {
+            _logger.LogError("[ERREUR] Aucun Succès trouvé.");
+            return StatusCode(204);
+        }
+
+        _logger.LogInformation("[INFORMATION] {nb} Succès(s) trouvé(s)", nbUser);
+        return Ok(_successDataService.GetSuccesses(page, number, orderCriteria));
+    }
+
+    [HttpGet("success/user/{id:int}")]
+    [ProducesResponseType(typeof(SuccessDto), 200)]
+    [ProducesResponseType(typeof(string), 404)]
+    public IActionResult GetSuccessByUserId(int id)
+    {
+        if (id < 1)
+        {
+            _logger.LogError("[ERREUR] L'id de l'utilisateur est inférieur à 1.");
+            return BadRequest("L'id de l'utilisateur est inférieur à 1.");
+        }
+
+        try
+        {
+            _logger.LogInformation("[INFORMATION] Le succès avec l'id de l'utilisateur {id} a été trouvé.", id);
+            return Ok(_successDataService.GetSuccessesByUserId(id));
+        }
+        catch (ArgumentException)
+        {
+            _logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id de l'utilisateur {id}.", id);
+            return NotFound("Aucun utilisateur trouvé avec l'id de l'utilisateur.");
+        }
+    }
+
+    [HttpGet("success/inquiry/{id:int}")]
+    [ProducesResponseType(typeof(SuccessDto), 200)]
+    [ProducesResponseType(typeof(string), 404)]
+    public IActionResult GetSuccessByInquiryId(int id)
+    {
+        if (id < 1)
+        {
+            _logger.LogError("[ERREUR] L'id de l'enquête doit être inférieur à 1.");
+            return BadRequest("L'id de l'enquête doit être inférieur à 1.");
+        }
+
+        try
+        {
+            _logger.LogInformation("[INFORMATION] Utilisateur avec l'id de l'enquête {inquiryId} a été trouvé.",
+                id);
+            return Ok(_successDataService.GetSuccessesByInquiryId(id));
+        }
+        catch (ArgumentException)
+        {
+            _logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id de l'enquête {inquiryId}.", id);
+            return NotFound("Aucune enquête trouvée avec l'id de l'enquête.");
+        }
+    }
+
+    [HttpDelete("success/{idUser:int}/{idInquiry:int}")]
+    [ProducesResponseType(typeof(SuccessDto), 200)]
+    [ProducesResponseType(typeof(string), 404)]
+    public IActionResult DeleteSuccess(int idUser, int idInquiry)
+    {
+        if (idUser < 1 || idInquiry < 1)
+        {
+            _logger.LogInformation("[INFORMATION] L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
+            return BadRequest("L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
+        }
+
+        var success = _successDataService.DeleteSuccess(idUser, idInquiry);
+        if (success)
+        {
+            _logger.LogInformation("[INFORMATION] Le succès avec l'id {id} a été supprimé.", idUser);
+            return Ok(success);
+        }
+        else
+        {
+            _logger.LogError("[ERREUR] Aucun succès trouvé avec l'id {id}.", idUser);
+            return NotFound();
+        }
+    }
+
+    [HttpPost]
+    [ProducesResponseType(typeof(SuccessDto), 201)]
+    [ProducesResponseType(typeof(string), 409)]
+    [ProducesResponseType(typeof(string), 404)]
+    [ProducesResponseType(typeof(string), 400)]
+    public IActionResult CreateSuccess([FromBody] SuccessDto dto)
+    {
+        if (dto.UserId < 1 || dto.InquiryId < 1)
+        {
+            _logger.LogError("[ERREUR] L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
+            return BadRequest("L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
+        }
+
+        try
+        {
+            var s = _successDataService.CreateSuccess(dto.UserId, dto.InquiryId, dto.IsFinished);
+            _logger.LogInformation(
+                "[INFORMATION] Un succès a été créé : userId - {userId}, inquiryId - {inquiryId}, isFinished - {isFinished}",
+                dto.UserId, dto.InquiryId, dto.IsFinished);
+            return Created(nameof(GetSuccesses), s);
+        }
+        catch (Exception e)
+        {
+            return HandleError(e);
+        }
+    }
+
+    [HttpPut("success/{idUser:int}/{idInquiry:int}")]
+    [ProducesResponseType(typeof(SuccessDto), 200)]
+    [ProducesResponseType(typeof(string), 400)]
+    [ProducesResponseType(typeof(string), 404)]
+    public IActionResult UpdateSuccess(int idUser, int idInquiry, [FromBody] SuccessDto successDto)
+    {
+        if (idUser < 1 || idInquiry < 1)
+        {
+            _logger.LogError("[ERREUR] L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
+            return BadRequest("L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
+        }
+
+        if (idUser != successDto.UserId || idInquiry != successDto.InquiryId)
+        {
+            _logger.LogError(
+                "[ERREUR] Problème ID - La mise à jour du succès avec l'id de l'utilisateur {id} a échouée.",
+                idUser);
+            return BadRequest();
+        }
+
+        if (!ModelState.IsValid)
+        {
+            _logger.LogError(
+                "[ERREUR] Problème controlleur - La mise à jour du succès avec l'id de l'utilisateur {id} a échouée.",
+                idUser);
+            return BadRequest();
+        }
+
+        try
+        {
+            var s = _successDataService.UpdateSuccess(idUser, idInquiry, successDto);
+            _logger.LogInformation(
+                "[INFORMATION] La mise à jour du succès avec l'id de l'utilisateur {id} a été effectuée", idUser);
+            return Ok(s);
+        }
+        catch (Exception e)
+        {
+            return HandleError(e);
+        }
+    }
+
+    private IActionResult HandleError(Exception e)
     {
-        private readonly ISuccessService<SuccessDto> _successDataService;
+        switch (e.Message)
-
+        {
-        private readonly ILogger<SuccessesController> _logger;
+            case { } msg when msg.Contains("userId"):
-
+                _logger.LogError("[ERREUR] Impossible de trouver l'utilisateur pour la manipulation du succès");
-        public SuccessesController(ISuccessService<SuccessDto> successDataService, ILogger<SuccessesController> logger)
+                return NotFound("Impossible de trouver l'utilisateur pour la manipulation du succès");
-        {
+            case { } msg when msg.Contains("inquiryId"):
-            _successDataService = successDataService;
+                _logger.LogError("[ERREUR] Impossible de trouver l'enquête pour la manipulation du succès");
-            _logger = logger;
+                return NotFound("Impossible de trouver l'enquête pour la manipulation du succès");
-        }
+            case { } msg when msg.Contains("success"):
-
+                _logger.LogError("[ERREUR] Impossible de manipuler le succès car il n'existe pas");
-        [HttpGet("successes/{page:int}/{number:int}/{orderCriteria}")]
+                return Conflict("Impossible de manipuler le succès car il n'existe pas");
-        [ProducesResponseType(typeof(SuccessDto), 200)]
+            default:
-        [ProducesResponseType(typeof(string), 204)]
+                _logger.LogError("[ERREUR] Erreur inattendue, impossible de manipuler le succès");
-        [ProducesResponseType(typeof(string), 400)]
+                return BadRequest("Erreur inattendue, impossible de manipuler le succès");
-        public IActionResult GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria)
-        {
-            if (page < 1 || number < 1)
-            {
-                _logger.LogError("[ERREUR] La page ou le nombre de succès est inférieur à 1.");
-                return BadRequest("La page ou le nombre de succès est inférieur à 1.");
-            }
-
-            var nbUser = _successDataService.GetSuccesses(page, number, orderCriteria).ToList().Count;
-            if (nbUser == 0)
-            {
-                _logger.LogError("[ERREUR] Aucun Succès trouvé.");
-                return StatusCode(204);
-            }
-
-            _logger.LogInformation("[INFORMATION] {nb} Succès(s) trouvé(s)", nbUser);
-            return Ok(_successDataService.GetSuccesses(page, number, orderCriteria));
-        }
-
-        [HttpGet("success/user/{id:int}")]
-        [ProducesResponseType(typeof(SuccessDto), 200)]
-        [ProducesResponseType(typeof(string), 404)]
-        public IActionResult GetSuccessByUserId(int id)
-        {
-            if (id < 1)
-            {
-                _logger.LogError("[ERREUR] L'id de l'utilisateur est inférieur à 1.");
-                return BadRequest("L'id de l'utilisateur est inférieur à 1.");
-            }
-
-            try
-            {
-                _logger.LogInformation("[INFORMATION] Le succès avec l'id de l'utilisateur {id} a été trouvé.", id);
-                return Ok(_successDataService.GetSuccessesByUserId(id));
-            }
-            catch (ArgumentException)
-            {
-                _logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id de l'utilisateur {id}.", id);
-                return NotFound("Aucun utilisateur trouvé avec l'id de l'utilisateur.");
-            }
-        }
-
-        [HttpGet("success/inquiry/{id:int}")]
-        [ProducesResponseType(typeof(SuccessDto), 200)]
-        [ProducesResponseType(typeof(string), 404)]
-        public IActionResult GetSuccessByInquiryId(int id)
-        {
-            if (id < 1)
-            {
-                _logger.LogError("[ERREUR] L'id de l'enquête doit être inférieur à 1.");
-                return BadRequest("L'id de l'enquête doit être inférieur à 1.");
-            }
-
-            try
-            {
-                _logger.LogInformation("[INFORMATION] Utilisateur avec l'id de l'enquête {inquiryId} a été trouvé.",
-                    id);
-                return Ok(_successDataService.GetSuccessesByInquiryId(id));
-            }
-            catch (ArgumentException)
-            {
-                _logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id de l'enquête {inquiryId}.", id);
-                return NotFound("Aucune enquête trouvée avec l'id de l'enquête.");
-            }
-        }
-
-        [HttpDelete("success/{idUser:int}/{idInquiry:int}")]
-        [ProducesResponseType(typeof(SuccessDto), 200)]
-        [ProducesResponseType(typeof(string), 404)]
-        public IActionResult DeleteSuccess(int idUser, int idInquiry)
-        {
-            if (idUser < 1 || idInquiry < 1)
-            {
-                _logger.LogInformation("[INFORMATION] L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
-                return BadRequest("L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
-            }
-
-            var success = _successDataService.DeleteSuccess(idUser, idInquiry);
-            if (success)
-            {
-                _logger.LogInformation("[INFORMATION] Le succès avec l'id {id} a été supprimé.", idUser);
-                return Ok(success);
-            }
-            else
-            {
-                _logger.LogError("[ERREUR] Aucun succès trouvé avec l'id {id}.", idUser);
-                return NotFound();
-            }
-        }
-
-        [HttpPost]
-        [ProducesResponseType(typeof(SuccessDto), 201)]
-        [ProducesResponseType(typeof(string), 409)]
-        [ProducesResponseType(typeof(string), 404)]
-        [ProducesResponseType(typeof(string), 400)]
-        public IActionResult CreateSuccess([FromBody] SuccessDto dto)
-        {
-            if (dto.UserId < 1 || dto.InquiryId < 1)
-            {
-                _logger.LogError("[ERREUR] L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
-                return BadRequest("L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
-            }
-
-            try
-            {
-                var s = _successDataService.CreateSuccess(dto.UserId, dto.InquiryId, dto.IsFinished);
-                _logger.LogInformation(
-                    "[INFORMATION] Un succès a été créé : userId - {userId}, inquiryId - {inquiryId}, isFinished - {isFinished}",
-                    dto.UserId, dto.InquiryId, dto.IsFinished);
-                return Created(nameof(GetSuccesses), s);
-            }
-            catch (Exception e)
-            {
-                return HandleError(e);
-            }
-        }
-
-        [HttpPut("success/{idUser:int}/{idInquiry:int}")]
-        [ProducesResponseType(typeof(SuccessDto), 200)]
-        [ProducesResponseType(typeof(string), 400)]
-        [ProducesResponseType(typeof(string), 404)]
-        public IActionResult UpdateSuccess(int idUser, int idInquiry, [FromBody] SuccessDto successDto)
-        {
-            if (idUser < 1 || idInquiry < 1)
-            {
-                _logger.LogError("[ERREUR] L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
-                return BadRequest("L'id de l'utilisateur ou de l'enquête doit être supérieur à 1.");
-            }
-
-            if (idUser != successDto.UserId || idInquiry != successDto.InquiryId)
-            {
-                _logger.LogError(
-                    "[ERREUR] Problème ID - La mise à jour du succès avec l'id de l'utilisateur {id} a échouée.",
-                    idUser);
-                return BadRequest();
-            }
-
-            if (!ModelState.IsValid)
-            {
-                _logger.LogError(
-                    "[ERREUR] Problème controlleur - La mise à jour du succès avec l'id de l'utilisateur {id} a échouée.",
-                    idUser);
-                return BadRequest();
-            }
-
-            try
-            {
-                var s = _successDataService.UpdateSuccess(idUser, idInquiry, successDto);
-                _logger.LogInformation(
-                    "[INFORMATION] La mise à jour du succès avec l'id de l'utilisateur {id} a été effectuée", idUser);
-                return Ok(s);
-            }
-            catch (Exception e)
-            {
-                return HandleError(e);
-            }
-        }
-
-        private IActionResult HandleError(Exception e)
-        {
-            switch (e.Message)
-            {
-                case { } msg when msg.Contains("userId"):
-                    _logger.LogError("[ERREUR] Impossible de trouver l'utilisateur pour la manipulation du succès");
-                    return NotFound("Impossible de trouver l'utilisateur pour la manipulation du succès");
-                case { } msg when msg.Contains("inquiryId"):
-                    _logger.LogError("[ERREUR] Impossible de trouver l'enquête pour la manipulation du succès");
-                    return NotFound("Impossible de trouver l'enquête pour la manipulation du succès");
-                case { } msg when msg.Contains("success"):
-                    _logger.LogError("[ERREUR] Impossible de manipuler le succès car il n'existe pas");
-                    return Conflict("Impossible de manipuler le succès car il n'existe pas");
-                default:
-                    _logger.LogError("[ERREUR] Erreur inattendue, impossible de manipuler le succès");
-                    return BadRequest("Erreur inattendue, impossible de manipuler le succès");
-            }
         }
     }
 }

API_SQLuedo/API/Controllers/UserController.cs

@@ -5,194 +5,193 @@ using Microsoft.AspNetCore.Mvc;
 using Shared;
 using Model.OrderCriteria;
 
-namespace API.Controllers
+namespace API.Controllers;
+
+[Route("api/v{version:apiVersion}/[controller]")]
+[Authorize]
+[ApiVersion("1.0")]
+[ApiController]
+public class UsersController(ILogger<UsersController> logger, IUserService<UserDto> userService) : ControllerBase
 {
-    [Route("api/v{version:apiVersion}/[controller]")]
+    [HttpGet("users/{page:int}/{number:int}")]
-    [Authorize]
+    [ProducesResponseType(typeof(UserDto), 200)]
-    [ApiVersion("1.0")]
+    [ProducesResponseType(typeof(string), 204)]
-    [ApiController]
+    public IActionResult GetUsers(int page, int number, UserOrderCriteria orderCriteria)
-    public class UsersController(ILogger<UsersController> logger, IUserService<UserDto> userService) : ControllerBase
+    {
+        var users = userService.GetUsers(page, number, orderCriteria).ToList();
+        if (users.Count == 0)
+        {
+            logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
+            return StatusCode(204);
+        }
+
+        logger.LogInformation("[INFORMATION] {nb} Utilisateur(s) trouvé(s)", users.Count);
+        return Ok(users);
+    }
+        
+    [HttpGet("users/not-admin/{page:int}/{number:int}")]
+    [ProducesResponseType(typeof(UserDto), 200)]
+    [ProducesResponseType(typeof(string), 204)]
+    public IActionResult GetNotAdminUsers(int page, int number, UserOrderCriteria orderCriteria)
+    {
+        var users = userService.GetNotAdminUsers(page, number, orderCriteria).ToList();
+        if (users.Count == 0)
+        {
+            logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
+            return StatusCode(204);
+        }
+
+        logger.LogInformation("[INFORMATION] {nb} Utilisateur(s) trouvé(s)", users.Count);
+        return Ok(users);
+    }
+        
+    [HttpGet("users/number")]
+    [ProducesResponseType(typeof(UserDto), 200)]
+    [ProducesResponseType(typeof(string), 204)]
+    public IActionResult GetNumberOfUsers()
     {
-        [HttpGet("users/{page:int}/{number:int}")]
+        var users = userService.GetNumberOfUsers();
-        [ProducesResponseType(typeof(UserDto), 200)]
+        if (users == 0)
-        [ProducesResponseType(typeof(string), 204)]
+        {
-        public IActionResult GetUsers(int page, int number, UserOrderCriteria orderCriteria)
+            logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
-        {
+            return StatusCode(204);
-            var users = userService.GetUsers(page, number, orderCriteria).ToList();
+        }
-            if (users.Count == 0)
+
-            {
+        logger.LogInformation("[INFORMATION] {users} Utilisateur(s) trouvé(s)", users);
-                logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
+        return Ok(new KeyValuePair<string,int>("nbUsers", users));
-                return StatusCode(204);
+    }
-            }
+
-
+    [HttpGet("user/{id:int}")]
-            logger.LogInformation("[INFORMATION] {nb} Utilisateur(s) trouvé(s)", users.Count);
+    [ProducesResponseType(typeof(UserDto), 200)]
-            return Ok(users);
+    [ProducesResponseType(typeof(string), 404)]
-        }
+    public IActionResult GetUserById(int id)
-        
+    {
-        [HttpGet("users/not-admin/{page:int}/{number:int}")]
+        try
-        [ProducesResponseType(typeof(UserDto), 200)]
+        {
-        [ProducesResponseType(typeof(string), 204)]
+            logger.LogInformation("[INFORMATION] Utilisateur avec l'id {id} a été trouvé.", id);
-        public IActionResult GetNotAdminUsers(int page, int number, UserOrderCriteria orderCriteria)
+            return Ok(userService.GetUserById(id));
-        {
+        }
-            var users = userService.GetNotAdminUsers(page, number, orderCriteria).ToList();
+        catch (ArgumentException)
-            if (users.Count == 0)
+        {
-            {
+            logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id {id}.", id);
-                logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
+            return NotFound();
-                return StatusCode(204);
+        }
-            }
+    }
-
+
-            logger.LogInformation("[INFORMATION] {nb} Utilisateur(s) trouvé(s)", users.Count);
+    [HttpGet("user/{username:alpha}")]
-            return Ok(users);
+    [ProducesResponseType(typeof(UserDto), 200)]
-        }
+    [ProducesResponseType(typeof(string), 404)]
-        
+    public IActionResult GetUserByUsername(string username)
-        [HttpGet("users/number")]
+    {
-        [ProducesResponseType(typeof(UserDto), 200)]
+        try
-        [ProducesResponseType(typeof(string), 204)]
+        {
-        public IActionResult GetNumberOfUsers()
+            logger.LogInformation("[INFORMATION] Utilisateur avec l'username {username} a été trouvé.", username);
-        {
+            return Ok(userService.GetUserByUsername(username));
-            var users = userService.GetNumberOfUsers();
+        }
-            if (users == 0)
+        catch (ArgumentException)
-            {
+        {
-                logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
+            logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'username {username}.", username);
-                return StatusCode(204);
+            return NotFound("Utilisateur non trouvé !");
-            }
+        }
-
+    }
-            logger.LogInformation("[INFORMATION] {users} Utilisateur(s) trouvé(s)", users);
+    [HttpGet("user/email/{email}")]
-            return Ok(new KeyValuePair<string,int>("nbUsers", users));
+    [ProducesResponseType(typeof(UserDto), 200)]
-        }
+    [ProducesResponseType(typeof(string), 404)]
-
+    public IActionResult GetByEmail(string email)
-        [HttpGet("user/{id:int}")]
+    {
-        [ProducesResponseType(typeof(UserDto), 200)]
+        try
-        [ProducesResponseType(typeof(string), 404)]
+        {
-        public IActionResult GetUserById(int id)
+            logger.LogInformation("[INFORMATION] Utilisateur avec l'username {email} a été trouvé.", email);
-        {
+            return Ok(userService.GetUserByEmail(email));
-            try
+        }
-            {
+        catch (ArgumentException)
-                logger.LogInformation("[INFORMATION] Utilisateur avec l'id {id} a été trouvé.", id);
+        {
-                return Ok(userService.GetUserById(id));
+            logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'username {email}.", email);
-            }
+            return NotFound();
-            catch (ArgumentException)
+        }
-            {
+    }
-                logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id {id}.", id);
-                return NotFound();
-            }
-        }
-
-        [HttpGet("user/{username:alpha}")]
-        [ProducesResponseType(typeof(UserDto), 200)]
-        [ProducesResponseType(typeof(string), 404)]
-        public IActionResult GetUserByUsername(string username)
-        {
-            try
-            {
-                logger.LogInformation("[INFORMATION] Utilisateur avec l'username {username} a été trouvé.", username);
-                return Ok(userService.GetUserByUsername(username));
-            }
-            catch (ArgumentException)
-            {
-                logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'username {username}.", username);
-                return NotFound("Utilisateur non trouvé !");
-            }
-        }
-        [HttpGet("user/email/{email}")]
-        [ProducesResponseType(typeof(UserDto), 200)]
-        [ProducesResponseType(typeof(string), 404)]
-        public IActionResult GetByEmail(string email)
-        {
-            try
-            {
-                logger.LogInformation("[INFORMATION] Utilisateur avec l'username {email} a été trouvé.", email);
-                return Ok(userService.GetUserByEmail(email));
-            }
-            catch (ArgumentException)
-            {
-                logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'username {email}.", email);
-                return NotFound();
-            }
-        }
-
-        [HttpDelete("user/{id:int}")]
-        [ProducesResponseType(typeof(UserDto), 200)]
-        [ProducesResponseType(typeof(string), 404)]
-        public IActionResult DeleteUser(int id)
-        {
-            var success = userService.DeleteUser(id);
-            if (success)
-            {
-                logger.LogInformation("[INFORMATION] L'utilisateur avec l'id {id} a été supprimé.", id);
-                return Ok();
-            }
-            else
-            {
-                logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id {id}.", id);
-                return NotFound();
-            }
-        }
-        
-        [HttpDelete("user/username/{username:alpha}")]
-        [ProducesResponseType(typeof(UserDto), 200)]
-        [ProducesResponseType(typeof(string), 404)]
-        public IActionResult DeleteUserByUsername(string username)
-        {
-            var success = userService.DeleteUserByUsername(username);
-            if (success)
-            {
-                logger.LogInformation("[INFORMATION] L'utilisateur avec le pseudo {username} a été supprimé.", username);
-                return Ok();
-            }
-            else
-            {
-                logger.LogError("[ERREUR] Aucun utilisateur trouvé avec le pseudo {username}.", username);
-                return NotFound();
-            }
-        }
-
-        [HttpPost]
-        [ProducesResponseType(typeof(UserDto), 201)]
-        [ProducesResponseType(typeof(string), 400)]
-        public 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));
-        }
-
-        [HttpPut("user/{id:int}")]
-        [ProducesResponseType(typeof(UserDto), 200)]
-        [ProducesResponseType(typeof(string), 400)]
-        [ProducesResponseType(typeof(string), 404)]
-        public IActionResult UpdateUser(int id, [FromBody] UserDto UserDto)
-        {
-            if (id != UserDto.Id)
-            {
-                logger.LogError("[ERREUR] Problème ID - La mise à jour de l'utilisateur avec l'id {id} a échouée.", id);
-                return BadRequest();
-            }
-
-            if (!ModelState.IsValid)
-            {
-                logger.LogError(
-                    "[ERREUR] Problème controller - La mise à jour de l'utilisateur avec l'id {id} a échouée.", id);
-                return BadRequest();
-            }
-
-            if (UserDto != null)
-            {
-                logger.LogInformation("[INFORMATION] La mise à jour de l'utilisateur avec l'id {id} a été effectuée",
-                    id);
-                return Ok(userService.UpdateUser(id, UserDto));
-            }
 
+    [HttpDelete("user/{id:int}")]
+    [ProducesResponseType(typeof(UserDto), 200)]
+    [ProducesResponseType(typeof(string), 404)]
+    public IActionResult DeleteUser(int id)
+    {
+        var success = userService.DeleteUser(id);
+        if (success)
+        {
+            logger.LogInformation("[INFORMATION] L'utilisateur avec l'id {id} a été supprimé.", id);
+            return Ok();
+        }
+        else
+        {
             logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id {id}.", id);
             return NotFound();
         }
     }
+        
+    [HttpDelete("user/username/{username:alpha}")]
+    [ProducesResponseType(typeof(UserDto), 200)]
+    [ProducesResponseType(typeof(string), 404)]
+    public IActionResult DeleteUserByUsername(string username)
+    {
+        var success = userService.DeleteUserByUsername(username);
+        if (success)
+        {
+            logger.LogInformation("[INFORMATION] L'utilisateur avec le pseudo {username} a été supprimé.", username);
+            return Ok();
+        }
+        else
+        {
+            logger.LogError("[ERREUR] Aucun utilisateur trouvé avec le pseudo {username}.", username);
+            return NotFound();
+        }
+    }
+
+    [HttpPost]
+    [ProducesResponseType(typeof(UserDto), 201)]
+    [ProducesResponseType(typeof(string), 400)]
+    public 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));
+    }
+
+    [HttpPut("user/{id:int}")]
+    [ProducesResponseType(typeof(UserDto), 200)]
+    [ProducesResponseType(typeof(string), 400)]
+    [ProducesResponseType(typeof(string), 404)]
+    public IActionResult UpdateUser(int id, [FromBody] UserDto UserDto)
+    {
+        if (id != UserDto.Id)
+        {
+            logger.LogError("[ERREUR] Problème ID - La mise à jour de l'utilisateur avec l'id {id} a échouée.", id);
+            return BadRequest();
+        }
+
+        if (!ModelState.IsValid)
+        {
+            logger.LogError(
+                "[ERREUR] Problème controller - La mise à jour de l'utilisateur avec l'id {id} a échouée.", id);
+            return BadRequest();
+        }
+
+        if (UserDto != null)
+        {
+            logger.LogInformation("[INFORMATION] La mise à jour de l'utilisateur avec l'id {id} a été effectuée",
+                id);
+            return Ok(userService.UpdateUser(id, UserDto));
+        }
+
+        logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id {id}.", id);
+        return NotFound();
+    }
 }