API_SQLuedo/API/Controllers/SuccessesController.cs

@@ -26,8 +26,15 @@ namespace API.Controllers
         [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)
             {
@@ -44,6 +51,12 @@ namespace API.Controllers
         [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);
@@ -52,7 +65,7 @@ namespace API.Controllers
             catch (ArgumentException)
             {
                 _logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id de l'utilisateur {id}.", id);
-                return NotFound();
+                return NotFound("Aucun utilisateur trouvé avec l'id de l'utilisateur.");
             }
         }
 
@@ -61,6 +74,12 @@ namespace API.Controllers
         [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é.",
@@ -70,7 +89,7 @@ namespace API.Controllers
             catch (ArgumentException)
             {
                 _logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id de l'enquête {inquiryId}.", id);
-                return NotFound();
+                return NotFound("Aucune enquête trouvée avec l'id de l'enquête.");
             }
         }
 
@@ -79,6 +98,12 @@ namespace API.Controllers
         [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)
             {
@@ -94,32 +119,51 @@ namespace API.Controllers
 
         [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 == null || dto.InquiryId == null)
+            if (dto.UserId < 1 || dto.InquiryId < 1)
             {
-                return BadRequest();
+                _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),
+                return Created(nameof(GetSuccesses), s);
-                _successDataService.CreateSuccess(dto.UserId, dto.InquiryId, dto.IsFinished));
+            }
+            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)
+        public IActionResult UpdateSuccess(int idUser, int idInquiry, [FromBody] SuccessDto successDto)
+        {
+            if (idUser < 1 || idInquiry < 1)
             {
-            if (idUser != SuccessDto.UserId || idInquiry != SuccessDto.InquiryId)
+                _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);
+                    "[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(
@@ -128,15 +172,36 @@ namespace API.Controllers
                 return BadRequest();
             }
 
-            if (SuccessDto != null)
+            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(_successDataService.UpdateSuccess(idUser,idInquiry, SuccessDto));
+                return Ok(s);
+            }
+            catch (Exception e)
+            {
+                return HandleError(e);
+            }
         }
 
-            _logger.LogError("[ERREUR] Aucun succès trouvé avec l'id de l'utilisateur {id}.", idUser);
+        private IActionResult HandleError(Exception e)
-            return NotFound();
+        {
+            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/Service/SuccessDataServiceAPI.cs

@@ -14,14 +14,16 @@ public class SuccessDataServiceApi(ISuccessService<SuccessEntity> sucessService)
         return successesEntities.Select(e => e.FromEntityToDto()).ToList();
     }
 
-    public IEnumerable<SuccessDto> GetSuccessesByUserId(int id) => sucessService.GetSuccessesByUserId(id).Select(s => s.FromEntityToDto());
+    public IEnumerable<SuccessDto> GetSuccessesByUserId(int id) =>
+        sucessService.GetSuccessesByUserId(id).Select(s => s.FromEntityToDto());
 
-    public IEnumerable<SuccessDto> GetSuccessesByInquiryId(int id) => sucessService.GetSuccessesByInquiryId(id).Select(s => s.FromEntityToDto());
+    public IEnumerable<SuccessDto> GetSuccessesByInquiryId(int id) =>
+        sucessService.GetSuccessesByInquiryId(id).Select(s => s.FromEntityToDto());
 
     public bool DeleteSuccess(int idUser, int idInquiry) => sucessService.DeleteSuccess(idUser, idInquiry);
 
-    public SuccessDto UpdateSuccess(int idUser, int idInquiry, SuccessDto success) =>
+    public SuccessDto UpdateSuccess(int userId, int inquiryId, SuccessDto success) =>
-        sucessService.UpdateSuccess(idUser, idInquiry, success.FromDtoToEntity()).FromEntityToDto();
+        sucessService.UpdateSuccess(userId, inquiryId, success.FromDtoToEntity()).FromEntityToDto();
 
     public SuccessDto CreateSuccess(int userId, int inquiryId, bool isFinished) =>
         sucessService.CreateSuccess(userId, inquiryId, isFinished).FromEntityToDto();

API_SQLuedo/DbDataManager/Service/SuccessDataService.cs

@@ -42,23 +42,15 @@ public class SuccessDataService : ISuccessService<SuccessEntity>
 
     public IEnumerable<SuccessEntity> GetSuccessesByUserId(int id)
     {
+        UserIdIsValid(id);
         var successes = DbContext.Successes.Where(u => u.UserId == id);
-        if (successes == null)
-        {
-            throw new ArgumentException("Impossible de trouver le succès", nameof(id));
-        }
-
         return successes;
     }
 
     public IEnumerable<SuccessEntity> GetSuccessesByInquiryId(int id)
     {
+        InquiryIdIsValid(id);
         var successes = DbContext.Successes.Where(u => u.InquiryId == id);
-        if (successes == null)
-        {
-            throw new ArgumentException("Impossible de trouver le succès", nameof(id));
-        }
-
         return successes;
     }
 
@@ -69,6 +61,7 @@ public class SuccessDataService : ISuccessService<SuccessEntity>
         {
             return false;
         }
+
         DbContext.Successes.Remove(successEntity);
         DbContext.SaveChangesAsync();
         return true;
@@ -76,35 +69,61 @@ public class SuccessDataService : ISuccessService<SuccessEntity>
 
     public SuccessEntity UpdateSuccess(int idUser, int idInquiry, SuccessEntity success)
     {
-        var updatingSuccess = DbContext.Successes.FirstOrDefault(u => u.UserId == idUser && u.InquiryId == idInquiry);
+        AreValdIds(idUser, idInquiry);
-        if (updatingSuccess == null)
+
-        {
+        var updatingSuccess =
-            throw new ArgumentException("Impossible de trouver le succès", nameof(idUser));
+            DbContext.Successes.FirstOrDefaultAsync(u => u.UserId == idUser && u.InquiryId == idInquiry);
-        }
+        if (updatingSuccess.Result == null) throw new ArgumentException("success", nameof(idUser));
+
         /*foreach (var pptt in typeof(SuccessEntity).GetProperties().Where(p =>
                      p.CanWrite && p.Name != nameof(SuccessEntity.UserId) && p.Name != nameof(SuccessEntity.InquiryId)))
         {
             pptt.SetValue(updatingSuccess, pptt.GetValue(success));
         }*/
-        updatingSuccess.IsFinished = success.IsFinished;
+        updatingSuccess.Result.IsFinished = success.IsFinished;
         DbContext.SaveChangesAsync();
-        return updatingSuccess;
+        return updatingSuccess.Result;
     }
 
     public SuccessEntity CreateSuccess(int userId, int inquiryId, bool isFinished)
     {
-        var newSuccessEntity = new SuccessEntity()
+        AreValdIds(userId, inquiryId);
+
+        var newSuccessEntity = new SuccessEntity
         {
             UserId = userId,
             InquiryId = inquiryId,
             IsFinished = isFinished,
         };
-        var success = DbContext.Successes.Where(s => s.UserId == userId && s.InquiryId == inquiryId);
+
-        if (success == null)
+        var success = DbContext.Successes.FirstOrDefaultAsync(s => s.UserId == userId && s.InquiryId == inquiryId);
-        {
+        if (success.Result != null) throw new ArgumentException("success", nameof(userId));
         DbContext.Successes.Add(newSuccessEntity);
         DbContext.SaveChangesAsync();
-        }
         return newSuccessEntity;
     }
+
+    private void AreValdIds(int userId, int inquiryId)
+    {
+        UserIdIsValid(userId);
+        InquiryIdIsValid(inquiryId);
+    }
+
+    private void UserIdIsValid(int userId)
+    {
+        var user = DbContext.Users.FirstOrDefaultAsync(u => u.Id == userId);
+        if (user.Result == null)
+        {
+            throw new ArgumentException("userId");
+        }
+    }
+
+    private void InquiryIdIsValid(int inquiryId)
+    {
+        var inquiry = DbContext.Inquiries.FirstOrDefaultAsync(u => u.Id == inquiryId);
+        if (inquiry.Result == null)
+        {
+            throw new ArgumentException("inquiryId");
+        }
+    }
 }

API_SQLuedo/Dto/BlackListDTO.cs

@@ -5,7 +5,10 @@ public class BlackListDto
     public string Email { get; set; }
     public DateOnly ExpirationDate { get; set; }
 
-    public BlackListDto() {}
+    public BlackListDto()
+    {
+    }
+
     public BlackListDto(string email, DateOnly expirationDate)
     {
         Email = email;

API_SQLuedo/Dto/InquiryDTO.cs

@@ -10,7 +10,10 @@ public class InquiryDto : IEquatable<InquiryDto>
 
     public bool IsUser { get; set; }
 
-    public InquiryDto(){}
+    public InquiryDto()
+    {
+    }
+
     public InquiryDto(int id, string title, string description, bool isUser)
     {
         Id = id;

API_SQLuedo/Dto/LessonDTO.cs

@@ -51,6 +51,7 @@ public class LessonDto : IEquatable<LessonDto>
 
         return this.Equals(right as LessonDto);
     }
+
     public bool Equals(LessonDto other)
     {
         return (this.Id == other.Id);

API_SQLuedo/Dto/ParagraphDTO.cs

@@ -59,6 +59,7 @@ public class ParagraphDto : ContentLessonDto, IEquatable<ParagraphDto>
 
         return this.Equals(right as ParagraphDto);
     }
+
     public bool Equals(ParagraphDto other)
     {
         return (this.Id == other.Id);

API_SQLuedo/Dto/SuccessDTO.cs

@@ -41,6 +41,7 @@ public class SuccessDto : IEquatable<SuccessDto>
 
         return this.Equals(right as SuccessDto);
     }
+
     public bool Equals(SuccessDto other)
     {
         return (this.UserId == other.UserId && this.InquiryId == other.InquiryId);

API_SQLuedo/Dto/UserDTO.cs

@@ -53,6 +53,7 @@
 
             return this.Equals(right as UserDto);
         }
+
         public bool Equals(UserDto other)
         {
             return (this.Id == other.Id);

API_SQLuedo/Shared/Mapper/LessonMapper.cs

@@ -26,6 +26,7 @@ public static class LessonMapper
             LastEdit = model.LastEdit
         };
     }
+
     public static LessonEntity FromDtoToEntity(this LessonDto dto)
     {
         return new LessonEntity

API_SQLuedo/StubbedContextLib/StubbedContext.cs

@@ -155,6 +155,28 @@ public class StubbedContext : UserDbContext
                 Title = "L'enquête sur les parapluies",
                 Description = "Il pleuvait",
                 IsUser = false
-            });
+            }
+        );
+
+        builder.Entity<SuccessEntity>().HasData(
+            new SuccessEntity
+            {
+                UserId = 1,
+                InquiryId = 1,
+                IsFinished = true
+            },
+            new SuccessEntity
+            {
+                UserId = 2,
+                InquiryId = 2,
+                IsFinished = false
+            },
+            new SuccessEntity
+            {
+                UserId = 3,
+                InquiryId = 3,
+                IsFinished = true
+            }
+        );
     }
 }

API_SQLuedo/TestEF/Dto/TestSolutionDTO.cs

@@ -22,10 +22,12 @@ public class TestSolutionDto
         Assert.Null(solution.MurderWeapon);
         Assert.Null(solution.Explanation);
     }
+
     [Fact]
     public void TestConstructorWithoutOwnerId()
     {
-        SolutionDto solution = new SolutionDto(MurdererFirstName,MurdererLastName,MurderPlace,MurderWeapon, Explaination);
+        SolutionDto solution =
+            new SolutionDto(MurdererFirstName, MurdererLastName, MurderPlace, MurderWeapon, Explaination);
         Assert.Equal(0, solution.OwnerId);
         Assert.Equal(MurdererFirstName, solution.MurdererFirstName);
         Assert.Equal(MurdererLastName, solution.MurdererLastName);
@@ -37,7 +39,8 @@ public class TestSolutionDto
     [Fact]
     public void TestConstructorWithAllAttributes()
     {
-        SolutionDto solution = new SolutionDto(InquiryId,MurdererFirstName,MurdererLastName,MurderPlace,MurderWeapon, Explaination);
+        SolutionDto solution = new SolutionDto(InquiryId, MurdererFirstName, MurdererLastName, MurderPlace,
+            MurderWeapon, Explaination);
         Assert.Equal(InquiryId, solution.OwnerId);
         Assert.Equal(MurdererFirstName, solution.MurdererFirstName);
         Assert.Equal(MurdererLastName, solution.MurdererLastName);