public IActionResult UpdateComment(int cardId, int commentId, [FromBody] CommentForUpdateDto comment) { if (comment == null) { return(BadRequest()); } if (!ModelState.IsValid) { return(BadRequest()); } if (!_cardRepository.CardExists(cardId)) { return(NotFound()); } var commentEntity = _cardRepository.GetComment(cardId, commentId); if (commentEntity == null) { return(NotFound()); } Mapper.Map(comment, commentEntity); if (!_cardRepository.Save()) { return(StatusCode(500, "A problem happened while handling your request")); } return(NoContent()); }
public async Task <ActionResult <Comment> > EditComment(long commentId, CommentForUpdateDto commentForUpdateDto) { UserComment userComment = await _context.UserComments.FirstOrDefaultAsync(uc => uc.CommentId == commentId); if (userComment == null) { return(BadRequest("No comment with the given Id was found")); } if (userComment.UserId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value)) { return(Unauthorized()); } if (commentId != commentForUpdateDto.Id) { return(BadRequest("A mismatch between the Id of the comment to update and the Id of the updated comment was found")); } if (!CommentExists(commentId)) { return(NotFound()); } var comment = await _context.Comments.FirstOrDefaultAsync(c => c.Id == commentId); comment.CommentText = commentForUpdateDto.CommentText; await _context.SaveChangesAsync(); return(Ok()); }
public async Task <IActionResult> UpdateCommentForPost(Guid postId, Guid id, [FromBody] CommentForUpdateDto comment) { if (comment == null) { _logger.LogError("CommentForUpdateDto object sent from client is null."); return(BadRequest("CommentForUpdateDto object is null")); } var post = await _context.Posts.GetPostAsync(postId, trackChanges : false); if (post == null) { _logger.LogInfo($"Post with id: {postId} doesn't exist in the database."); return(NotFound()); } var commentEntity = await _context.Comments.GetCommentAsync(postId, id, trackChanges : true); if (commentEntity == null) { _logger.LogInfo($"Comment with id: {id} doesn't exist in the database."); return(NotFound()); } _mapper.Map(comment, commentEntity); await _context.SaveAsync(); return(NoContent()); }
public async Task <IActionResult> UpdateComment(int userId, int commentId, CommentForUpdateDto commentForUpdateDto) { if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value)) { return(Unauthorized()); } var commentFromRepo = await _recipeRepo.GetComment(commentId); if (commentFromRepo == null) { return(NotFound($"Comment {commentId} not found")); } if (commentFromRepo.CommenterId != userId) { return(Unauthorized()); } var postFromRepo = await _recipeRepo.GetPost(commentFromRepo.PostId); var commentToUpdate = _mapper.Map(commentForUpdateDto, commentFromRepo); var commentToReturn = _mapper.Map <Comment>(commentToUpdate); // var commentToReturn = _mapper.Map<CommentsForReturnedDto>(commentToUpdate); if (await _recipeRepo.SaveAll()) { var postToReturn = _mapper.Map <PostsForDetailedDto>(postFromRepo); return(CreatedAtRoute("GetPost", new { userId = userId, id = postFromRepo.PostId }, postToReturn)); } throw new Exception("Updating the comment failed on save"); }
public IActionResult UpdateComment(int userId, int blogId, int postId, int commentId, [FromBody] CommentForUpdateDto comment) { if (!_weblogDataRepository.UserExists(userId) || !_weblogDataRepository.BlogExists(blogId) || !_weblogDataRepository.PostExists(postId)) { return(NotFound()); } var commentFromRepo = _weblogDataRepository.GetComment(commentId); if (commentFromRepo is null) { return(NotFound()); } var emailAddress = comment.Credentials.EmailAddress; var password = comment.Credentials.Password; if (!_weblogDataRepository.Authorized(commentFromRepo.UserId, emailAddress, password)) { return(Unauthorized()); } _mapper.Map(comment, commentFromRepo); _weblogDataRepository.UpdateComment(commentFromRepo); _weblogDataRepository.Save(); return(NoContent()); }
public async Task <int> UpdateComment(Comment comment, CommentForUpdateDto dto) { comment.Description = dto.Description ?? comment.Description; _dbLogService.LogOnUpdateOfAnEntity(comment); return(await _context.SaveChangesAsync()); }
public void Update_Comment() { var controller = new CommentsController(new CommentRepositoryMock()); var commentForUpdate = new CommentForUpdateDto() { Content = "There is an issue with this item!" }; var result = controller.Put(CommentRepositoryMock.TestComment.Id, commentForUpdate); var okResult = result.Should().BeOfType <NoContentResult>().Subject; }
public IActionResult PartiallyUpdateComment(int commentId, int id, [FromBody] JsonPatchDocument <CommentForUpdateDto> patchDoc) { if (patchDoc == null) { return(BadRequest()); } var comment = CommentsDataStore.Current.Comments.FirstOrDefault(c => c.Id == commentId); if (comment == null) { return(NotFound()); } var commentFromStore = comment.Replies.FirstOrDefault(c => c.Id == id); if (commentFromStore == null) { return(NotFound()); } var commentToPatch = new CommentForUpdateDto() { Name = commentFromStore.Name, Description = commentFromStore.Description }; patchDoc.ApplyTo(commentToPatch, ModelState); if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (commentToPatch.Description == commentToPatch.Name) { ModelState.AddModelError("Description", "The provided description should be different from the name."); } TryValidateModel(commentToPatch); if (!ModelState.IsValid) { return(BadRequest(ModelState)); } commentFromStore.Name = commentToPatch.Name; commentFromStore.Description = commentToPatch.Description; return(NoContent()); }
public IActionResult Put(int id, [FromBody] CommentForUpdateDto commentForUpdate) { var comment = _commentRepository.Get(id); if (comment == null) { return(NotFound("Comment not found")); } comment.Content = commentForUpdate.Content != null ? commentForUpdate.Content : comment.Content; _commentRepository.Update(comment); if (!_commentRepository.Save()) { return(BadRequest("Could not update comment")); } return(NoContent()); }
public async void UpdateComment_FailsOnSave_ReturnsException() { // Arrange int commentId = 2; int userId = 2; var commentForUpdate = new CommentForUpdateDto { Text = "My newly updated comment" }; var commentFromRepo = GetFakeCommentsList().SingleOrDefault(x => x.CommentId == commentId); _repoMock.Setup(x => x.GetComment(commentId)).ReturnsAsync(commentFromRepo); _repoMock.Setup(x => x.SaveAll()).ReturnsAsync(false); // Act Exception ex = await Assert.ThrowsAsync <Exception>(() => _postsController.UpdateComment(userId, commentId, commentForUpdate)); // Assert Assert.Equal("Updating the comment failed on save", ex.Message); }
public void UpdateComment_CommenterIdUserIdMismatch_ReturnsUnauthorized() { int commentId = 1; int userId = 2; var commentForUpdate = new CommentForUpdateDto { Text = "My newly updated comment" }; var commentFromRepo = GetFakeCommentsList().SingleOrDefault(x => x.CommentId == commentId); _repoMock.Setup(x => x.GetComment(commentId)).ReturnsAsync(commentFromRepo); _repoMock.Setup(x => x.SaveAll()).ReturnsAsync(true); // Act var result = _postsController.UpdateComment(userId, commentId, commentForUpdate).Result; // Assert var okResult = Assert.IsType <UnauthorizedResult>(result); }
public async Task <IActionResult> UpdateUser(int userId, int id, int postId, CommentForUpdateDto commentForUpdateDto) { if (userId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value)) { return(Unauthorized()); } var commentrepo = await _repo.getcommentForuser(id, postId, userId); if (commentrepo == null) { return(Unauthorized()); } var CommentFromRepo = await _repo.getComment(id, postId); _mapper.Map(commentForUpdateDto, CommentFromRepo); if (await _repo.SaveAll()) { return(NoContent()); } throw new Exception($"field to update post {id}"); }
public async void LogOnUpdateOfEntity_UpdateComment_ShouldReturnUpdatedCommentLog() { var options = new DbContextOptionsBuilder <AppDbContext>() .UseInMemoryDatabase($"TechTaskTestDatabase {Guid.NewGuid()}") .Options; using (var context = new AppDbContext(options)) { var commentToAdd = new Comment { Id = 3, Description = "Description", TasksId = 3, UserId = Guid.NewGuid() }; context.Comments.Add(commentToAdd); await context.SaveChangesAsync(); var dbLog = new DbLogService(context); await dbLog.LogOnCreationOfEntityAsync(commentToAdd); var dto = new CommentForUpdateDto { Description = "New description" }; dbLog.LogOnUpdateOfAnEntity(commentToAdd); await context.SaveChangesAsync(); } using (var context = new AppDbContext(options)) { var logFromDb = await context.UpdateLogs .SingleAsync(u => u.Name == "Updated Comment"); logFromDb.Value.Should().Be(("3").ToLowerInvariant()); } }
public void UpdateComment_Authorized_SuccessfullyUpdatedComment() { int commentId = 2; int userId = 2; var commentForUpdate = new CommentForUpdateDto { Text = "My newly updated comment" }; var commentFromRepo = GetFakeCommentsList().SingleOrDefault(x => x.CommentId == commentId); var postFromRepo = GetFakePostList().SingleOrDefault(x => x.PostId == commentFromRepo.PostId); _repoMock.Setup(x => x.GetComment(commentId)).ReturnsAsync(commentFromRepo); _repoMock.Setup(x => x.SaveAll()).ReturnsAsync(true); _repoMock.Setup(x => x.GetPost(commentFromRepo.PostId)).ReturnsAsync(postFromRepo); // Act var result = _postsController.UpdateComment(userId, commentId, commentForUpdate).Result as CreatedAtRouteResult; // Assert var okResult = Assert.IsType <CreatedAtRouteResult>(result); var updatedComment = Assert.IsType <PostsForDetailedDto>(result.Value); }
public void UpdateComment_CommentNotFound_ReturnsNotFound() { int commentId = 12; int userId = 2; var commentForUpdate = new CommentForUpdateDto { Text = "My newly updated comment" }; var commentFromRepo = GetFakeCommentsList().SingleOrDefault(x => x.CommentId == commentId); // var postFromRepo = GetFakePostList().SingleOrDefault(x => x.PostId == commentFromRepo.PostId); _repoMock.Setup(x => x.GetComment(commentId)).ReturnsAsync(commentFromRepo); _repoMock.Setup(x => x.SaveAll()).ReturnsAsync(true); // Act var result = _postsController.UpdateComment(userId, commentId, commentForUpdate).Result; // Assert var okResult = Assert.IsType <NotFoundObjectResult>(result); Assert.Equal("Comment 12 not found", okResult.Value); }
public async Task <IActionResult> UpdateComment(int postId, int commentId, [FromBody] CommentForUpdateDto commentForUpdateDto) { var commentToUpdate = await _repository.Comment.GetCommentAsync(commentId); if (commentToUpdate == null) { return(BadRequest()); } //TODO: fix this //The instance of entity type cannot be tracked because another instance with the same key value for { 'Id'} is already being tracked //var userFromDb = await _userManager.GetUserAsync(this.User); //if (commentToUpdate.CommentedById != userFromDb.Id) // return Unauthorized(); commentToUpdate.Content = commentForUpdateDto.Content; _repository.Comment.UpdateComment(commentToUpdate); await _repository.SaveAsync(); return(NoContent()); }
public IActionResult Put(int commentId, CommentForUpdateDto commentForUpdateDto) { var comment = _commentService.GetById(commentId); if (comment.IsSuccessful) { comment.Data.Description = commentForUpdateDto.Description; IResult result = _commentService.Update(comment.Data); if (result.IsSuccessful) { var channelId = HttpContext.RequestServices.GetService <IPhotoService>().GetById(comment.Data.PhotoId).Data.ChannelId; this.RemoveCacheByContains(comment.Data.UserId + "/user-photos"); this.RemoveCacheByContains(comment.Data.UserId + "/user-comment-photos"); this.RemoveCacheByContains(comment.Data.UserId + "/like-photos"); this.RemoveCacheByContains(channelId + "/channel-photos"); this.RemoveCache(); return(Ok(result.Message)); } return(this.ServerError(result.Message)); } return(NotFound()); }
public async Task <CommentDetailsDto> UpdateComment([FromRoute] int teamId, [FromRoute] int taskId, [FromRoute] int commentId, [FromBody] CommentForUpdateDto dto) { dto.CommentId = commentId; dto.TaskId = taskId; return(await _mediator.Send(new UpdateCommentCommand { CommentForUpdateDto = dto })); }