public async Task <ServiceResponse <GetCommentDto> > Update(UpdateCommentDto updateCommentDto)
{
ServiceResponse <GetCommentDto> response = new ServiceResponse <GetCommentDto>();
User user = await _context.Users.FirstOrDefaultAsync(u => u.Id == GetUserId());
Comment comment = await _context.Comments.Include(c => c.CommentedUser).FirstOrDefaultAsync(s => s.Id == updateCommentDto.CommentId);
if (user.Id != comment.CommentedUserId)
{
response.Data = null;
response.Message = "You are not authorized to make comment";
response.Success = false;
return(response);
}
comment.CommentText = updateCommentDto.CommentText;
comment.MaxGrade = updateCommentDto.MaxGrade;
comment.Grade = updateCommentDto.Grade;
_context.Comments.Update(comment);
await _context.SaveChangesAsync();
response.Data = _mapper.Map <GetCommentDto>(comment);
response.Data.FileEndpoint = "Comment/File/" + comment.Id;
response.Data.HasFile = comment.FileAttachmentAvailability;
response.Data.FileName = comment.FileAttachmentAvailability ? comment.FilePath.Split('/').Last() : "";
return(response);
}
public async Task <IActionResult> PutComment(long id, UpdateCommentDto updateCommentDto)
{
if (id != updateCommentDto.Id)
{
return(BadRequest());
}
var commentEntity = CommentMapper.mapFromUpdateDto(updateCommentDto);
_context.Entry(commentEntity).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CommentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task UpdateComment(UpdateCommentDto input)
{
var comment = await _commentRepository.GetByIdAsync(input.Id);
comment.Content = input.Content;
comment.ModifiedDate = DateTime.Now;
await _commentRepository.UpdateAsync(comment);
}
private async Task <CommentDto> UpdateCommentAsync(Guid id, Comment comment, UpdateCommentDto input)
{
comment.SetText(input.Text);
comment = await _commentRepository.UpdateAsync(comment);
return(ObjectMapper.Map <Comment, CommentDto>(comment));
}
public virtual async Task <CommentWithDetailsDto> UpdateAsync(Guid id, UpdateCommentDto input)
{
return(await RequestAsync <CommentWithDetailsDto>(nameof(UpdateAsync), new ClientProxyRequestTypeValue
{
{ typeof(Guid), id },
{ typeof(UpdateCommentDto), input }
}));
}
public async Task <CommentViewModel> UpdateCommentAsync(Comment comment, UpdateCommentDto updateCommentDto)
{
comment.Content = updateCommentDto.Content;
await _commentRepository.UpdateAsync(comment);
return(_mapper.Map <CommentViewModel>(comment));
}
public async Task <Result> Update(UpdateCommentDto updateCommentDto)
{
var comment = await FirstOrDefaultAsync(c => c.Id == updateCommentDto.Id);
_mapper.Map(updateCommentDto, comment);
await Context.SaveChangesAsync();
return(Result.SuccessFull());
}
public async Task <Comment> Put(Guid id, [FromBody] UpdateCommentDto comment)
{
var updateCommentViewModel = new UpdateCommentViewModel()
{
CommentId = id, Text = comment.Text
};
return(await _commentService.UpdateCommentAsync(updateCommentViewModel));
}
public static Comment mapFromUpdateDto(UpdateCommentDto updateComment)
{
Comment result = new Comment();
result.Id = updateComment.Id;
result.Important = updateComment.Important;
result.Text = updateComment.Text;
return(result);
}
public async Task <IActionResult> UpdateComment(UpdateCommentDto updateComment)
{
Comment comment = await _repository.GetComment(updateComment.Id);
comment.Content = updateComment.Content;
comment.ModifiedOn = DateTime.UtcNow;
_repository.Add(comment);
return(Ok(await _repository.SaveAll()));
}
public async Task <CommentDto> UpdateAsync(Guid id, UpdateCommentDto input)
{
var comment = await _commentRepository.GetAsync(id);
comment.SetText(input.Text);
comment = await _commentRepository.UpdateAsync(comment);
return(ObjectMapper.Map <Comment, CommentDto>(comment));
}
public int UpdateComment(int id, UpdateCommentDto updateCommentDto)
{
var comment = GetCommentEntity(id);
comment.Value = updateCommentDto.Value ?? comment.Value;
comment.NewsId = updateCommentDto.NewsId ?? comment.NewsId;
comment.UserId = updateCommentDto.UserId ?? comment.UserId;
_db.SaveChanges();
return(comment.Id);
}
public async Task <CommentDto> UpdateAsync(Guid id, UpdateCommentDto input)
{
var comment = await _commentRepository.GetAsync(id);
if (CurrentUser.Id != comment.CreatorId)
{
return(await UpdateAsAdminAsync(id, comment, input));
}
return(await UpdateCommentAsync(id, comment, input));
}
public async void Comments_PUT_Returns_404()
{
UpdateCommentDto updatedComment = new UpdateCommentDto()
{
Text = string.Empty
};
var response = await this.HttpClient.PutAsync($"/api/v1/comments/{Guid.NewGuid()}", new StringContent(JsonConvert.SerializeObject(updatedComment), Encoding.UTF8, "application/json"));
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
}
public void Execute(UpdateCommentDto request)
{
var comment = Context.Comments.Find(request.Id);
if (comment == null || comment.IsDeleted)
{
throw new EntityNotFoundException();
}
comment.Text = request.Text;
Context.SaveChanges();
}
public async Task <IActionResult> Update(Guid id, [FromBody] UpdateCommentDto updateCommentDto)
{
updateCommentDto.Id = id;
var result = await _unitOfWork.CommentService.Update(updateCommentDto);
if (!result.Success)
{
return(result.ApiResult);
}
return(NoContent());
}
public async Task <IActionResult> UpdateComment(string postId, string id, [FromBody] UpdateCommentDto updateCommentDto)
{
var result = await Mediator.Send(new UpdateCommentCommand
{
UpdateCommentDto = updateCommentDto,
PostId = postId,
Id = id,
UserId = AuthorizedUserId
});
return(Ok(result));
}
public async Task <CommentWithDetailsDto> UpdateAsync(Guid id, UpdateCommentDto input)
{
var comment = await _commentRepository.GetAsync(id);
await AuthorizationService.CheckAsync(comment, CommonOperations.Update);
comment.SetText(input.Text);
comment = await _commentRepository.UpdateAsync(comment);
return(ObjectMapper.Map <Comment, CommentWithDetailsDto>(comment));
}
public async void Comments_PUT_Returns_200()
{
UpdateCommentDto updatedComment = new UpdateCommentDto()
{
Text = string.Empty
};
Post post = await CreatePost();
Comment createComment = await CreateComment(post);
var response = await this.HttpClient.PutAsync($"/api/v1/comments/{createComment.Id}", new StringContent(JsonConvert.SerializeObject(updatedComment), Encoding.UTF8, "application/json"));
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
}
public IActionResult UpdateComment(int id, [FromBody] UpdateCommentDto updatedComment)
{
try
{
if (_user != null || _admin != null)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var commentStore = new CommentEntity();
var dbResult = new List <CommentEntity>();
if (_admin != null)
{
var result = _ctx.GetCommentsByAvatar(admin: _admin.Id);
commentStore = dbResult.Where(c => c.Id == id).FirstOrDefault();
}
else
{
if (updatedComment.FlaggedCommentMessages != null)
{
dbResult = _ctx.GetAllComment().Result.ToList();
}
else
{
dbResult = _ctx.GetCommentsByAvatar(_user.Id).ToList();
}
}
commentStore = dbResult.Where(c => c.Id == id).FirstOrDefault();
updatedComment.LastUpdatedOn = DateTime.Now;
_mapper.Map(updatedComment, commentStore);
if (_ctx.UpdateContent(commentStore))
{
return(Ok($"Comment with ID: {id} has been updated."));
}
return(BadRequest("No update was made"));
}
return(Unauthorized(Message("unautherized")));
}
catch (Exception ex)
{
_logger.LogError($"Unable to Update comment: {id}.", ex);
return(StatusCode(500, "There was an expection found at UpdateComment."));
}
}
public IActionResult Put(string id, [FromBody] UpdateCommentDto obj)
{
obj.Id = id;
try
{
_updateComment.Execute(obj);
return(NoContent());
}
catch (EntityNotFoundException)
{
return(NotFound());
}
catch
{
return(StatusCode(500));
}
}
public async Task <CommentDto> UpdateMyCommentAsync(long commentId, UpdateCommentDto updateComment)
{
var commentEntity = await _context
.Comments
.Include(c => c.CreatedBy)
.Where(c => c.Id == commentId)
.SingleOrDefaultAsync();
ThrowNotFoundIfNull(commentEntity);
ThrowForbiddenIfNotCreatedByCurrentUser(commentEntity);
_mapper.Map(updateComment, commentEntity);
await _context.SaveChangesAsync();
return(_mapper.Map <CommentDto>(commentEntity));
}
public async Task <IActionResult> DeleteComment(UpdateCommentDto dto)
{
var comment = await _repos.GetById(dto.Id);
if (comment == null)
{
return(BadRequest("No such comment"));
}
if (!string.IsNullOrEmpty(dto.Description))
{
comment.Description = dto.Description;
}
if (await _repos.Update(comment))
{
return(Ok("Updated comment"));
}
return(StatusCode(500));
}
public async Task <IActionResult> Update([FromRoute] string commentId,
[FromBody] UpdateCommentDto updateCommentDto)
{
Comment comment = await _mediator.Send(new GetCommentEntityQuery(commentId));
AuthorizationResult authorizationResult =
await _authorizationService.AuthorizeAsync(User, comment, PolicyConstants.UpdateCommentRolePolicy);
if (!authorizationResult.Succeeded)
{
return(ActionResults.UnauthorizedResult(User.Identity.IsAuthenticated));
}
return(Ok(new Response <CommentViewModel>
{
Data = await _mediator.Send(new UpdateCommentCommand(comment, updateCommentDto)),
}));
}
public async Task Update(string postId, string id, UpdateCommentDto dto)
{
User user = await _sessionService.GetUser();
Validate("modify", dto.Content, user);
Comment comment = await _commentRepository.GetById(id);
if (comment == null)
{
_logger.LogWarning($"Comment {id} does not exist");
throw HttpError.NotFound($"Comment {id} does not exist");
}
if (comment.PostId != postId)
{
throw HttpError.NotFound("");
}
if (comment.AuthorId != user.Id)
{
_logger.LogWarning($"Comment {id} does not belong to user");
throw HttpError.Forbidden($"Comment {id} does not belong to user");
}
comment.Content = dto.Content;
comment.LastUpdateTime = DateTime.Now;
bool success = await _commentRepository.Update(comment);
if (!success)
{
_logger.LogWarning("Error during update comment");
throw HttpError.InternalServerError("");
}
}
public Task <CommentDto> UpdateMyComment([FromRoute] long commentId, [FromBody] UpdateCommentDto updateComment)
{
return(_commentService.UpdateMyCommentAsync(commentId, updateComment));
}
public Task <CommentWithDetailsDto> UpdateAsync(Guid id, UpdateCommentDto input)
{
return(_commentAppService.UpdateAsync(id, input));
}
public ActionResult <IdDto> UpdateComment(int id, [FromBody] UpdateCommentDto updateCommentDto)
{
return(new OkObjectResult(new { Id = _commentService.UpdateComment(id, updateCommentDto) }));
}
public async Task Update(Guid id, UpdateCommentDto commentDto)
{
await _commentAppService.UpdateAsync(id, commentDto);
}
public async Task <IActionResult> Update([FromRoute] string postId, string id, [FromBody] UpdateCommentDto dto)
{
await _commentService.Update(postId, id, dto);
return(NoContent());
}
