public async Task <IActionResult> Update([FromRoute] Guid postId, [FromBody] UpdatePostRequest postRequest)
{
var ifUserOwnsPost = await _postService.UserOwnsPostAsync(postId, HttpContext.GetUserId());
if (!ifUserOwnsPost)
{
return(Unauthorized(
new
{
error = "You don't own the post"
}));
}
var post = await _postService.GetPostByIdAsync(postId);
post.Name = postRequest.Name;
var isUpdated = await _postService.UpdatePostAsync(post);
if (isUpdated)
{
return(Ok(post));
}
return(NotFound());
}
public async Task <int> UpdatePost(UpdatePostRequest request, ApplicationUser applicationUser)
{
Post post = await _context.Posts.FindAsync(request.PostID);
if (post == null)
{
throw new Exception("Bai post khong ton tai");
}
// Kiểm tra user có sở hữu bài post không
post = _context.Posts.Where(x => x.PostID == request.PostID).FirstOrDefault();
if (post.Id != applicationUser.Id)
{
throw new Exception("Ban khong so huu bai post do do khong update duoc");
}
post.Content = request.Content;
post.Title = request.Title;
post.Caption = request.Caption;
//if (post.ImageFileName != request.ImageFileName.FileName)
//{
//}
// Thực hiện xoá bài post và lưu
_context.Update(post);
var result = await _context.SaveChangesAsync();
return(result);
}
public async Task <IActionResult> Update([FromQuery] Guid postId, [FromBody] UpdatePostRequest request)
{
var userOwnsPost = await _postService.UserOwnsPostAsync(postId, HttpContext.GetUserId());
if (!userOwnsPost)
{
return(BadRequest(new { Error = "You do not own this post." }));
}
var post = await _postService.GetPostByIdAsync(postId);
post.Name = request.Name;
var updated = await _postService.UpdatePostAsync(post);
var postResponse = new PostResponse
{
Id = post.Id,
Name = post.Name
};
if (updated)
{
return(Ok(new Response <PostResponse>(postResponse)));
}
return(NotFound());
}
public async Task <BaseResponseDto <bool> > Handle(UpdatePostRequest request, CancellationToken cancellationToken)
{
BaseResponseDto <bool> response = new BaseResponseDto <bool>();
try
{
var post = await _repositoryWrapper.Post.Find(request.Id);
if (post != null)
{
post.Body = request.Body;
post.Title = request.Title;
_repositoryWrapper.Post.Update(post);
if (await _repositoryWrapper.SaveChangesAsync())
{
response.Data = true;
}
else
{
response.Errors.Add("Veri tabanı kayıt esnasında bir sorun oluştu.");
}
}
else
{
response.Errors.Add("Böyle bir post bulunamadı.");
}
}
catch (Exception ex)
{
_logger.LogError(ex, ex.InnerException.Message);
response.Errors.Add(ex.InnerException.Message);
response.Errors.Add("Post güncellenirken bir hata oluştu.");
}
return(response);
}
public async Task <IActionResult> EditAsync([FromRoute] int id, [FromBody] UpdatePostRequest model)
{
if (CurrentUser == null)
{
return(BadRequest(new { ErrorMessage = "Unauthorized" }));
}
if (!model.AuthorId.Equals(CurrentUser.Id))
{
return(BadRequest(new { ErrorMessage = "You are not an author of the post." }));
}
var post = await _postsService.GetPostAsync(id);
var updatedModel = _mapper.Map(model, post);
// TODO Fix if possible
updatedModel.Author = CurrentUser;
// - - -
_postsService.Update(updatedModel);
var tags = _mapper.Map <List <Tag> >(model.Tags);
await _postsTagsRelationsService.AddTagsToExistingPost(post.Id, post.PostsTagsRelations.ToList(), tags);
var postModel = await _postsService.GetPostAsync(id);
var mappedPost = _mapper.Map <PostViewResponse>(postModel);
return(Ok(mappedPost));
}
public async Task <Response> UpdateAsync(string slug, UpdatePostRequest request)
{
var query = _context.Posts.AsQueryable();
query = ApplyInclude(query);
var post = await query.SingleOrDefaultAsync(i => i.Slug == slug);
if (post == null)
{
return(null);
}
_context.Posts.Attach(post);
_context.Posts.Update(post);
_mapper.Map(request.BlogPost, post);
_context.Update(post);
await _context.SaveChangesAsync();
var response = _mapper.Map <PostModel>(post);
return(new PostResponse
{
BlogPost = response
});
}
public async Task <IActionResult> Update([FromRoute] Guid postId, [FromBody] UpdatePostRequest request)
{
var userOwnsPost = await _postService.UserOwnsPostAsync(postId, HttpContext.GetUserId());
if (!userOwnsPost)
{
return(BadRequest(new { error = "You do now own this post." }));
}
IdentityUser author = await _userManager.FindByIdAsync(HttpContext.GetUserId());
var post = await _postService.GetPostByIdAsync((postId));
post.Title = request.Title;
post.UserId = HttpContext.GetUserId();
post.Author = author.UserName;
post.Date = request.Date;
post.Image = request.Image;
post.Content = request.Content;
post.Tags = request.Tags;
var updated = await _postService.UpdatePostAsync(post);
if (updated)
{
return(Ok());
}
return(NotFound());
}
public async Task <IActionResult> Update([FromRoute] Guid postId, [FromBody] UpdatePostRequest request)
{
var userOwnsPost = await _postService.UserOwnsPost(postId, HttpContext.GetUserId());
if (!userOwnsPost)
{
return(BadRequest(new
{
error = "Você não tem permissão para atualizar este post."
}));
}
var post = await _postService.GetPostById(postId);
//atualizando o nome que veio do Body da request
post.Name = request.Name;
var updated = await _postService.UpdatePost(post);
if (!updated)
{
return(NotFound());
}
return(Ok(post));
}
public async Task <ActionResult <UpdatePostResponse> > UpdatePost([FromBody] UpdatePostRequest formData, string id)
{
var context = HttpContext.User.Identity.Name;
var result = await _postHandler.UpdatePost(formData, id, context);
switch (result.StatusCode)
{
case ContractsService.StatusCode.PermissionDenied:
return(BadRequest(result.ErrorMessage));
case ContractsService.StatusCode.NotFound:
return(BadRequest(result.ErrorMessage));
case ContractsService.StatusCode.InvalidArgument:
return(BadRequest(result.ErrorMessage));
case ContractsService.StatusCode.Internal:
return(BadRequest(result.ErrorMessage));
case ContractsService.StatusCode.Ok:
return(result);
default:
return(BadRequest("Unknown error"));
}
}
public async Task <IActionResult> Update([FromRoute] Guid postId, [FromBody] UpdatePostRequest request)
{
var post = await _postService
.GetPostByIdAsync(postId)
.ConfigureAwait(false);
if (post == null)
{
return(NotFound());
}
post.Title = request?.Title;
post.Content = request?.Content;
post.Attachments = request?.Attachments;
var updated = await _postService
.UpdatePostAsync(post)
.ConfigureAwait(false);
if (!updated)
{
return(NotFound());
}
var postResponse = new Response <PostResponse>(
_mapper.Map <PostResponse>(post));
return(Ok(postResponse));
}
public async Task <IActionResult> Update([FromRoute] Guid postId, [FromBody] UpdatePostRequest updateRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var isUserOwnerOfPost = await _postRepository.IsUserOwnerOfPostAsync(postId, HttpContext.GetUserId());
if (!isUserOwnerOfPost)
{
return(BadRequest(new { error = $"User can not update post {postId}" }));
}
var post = await _postRepository.GetPostByIdAsync(postId);
var updated = await _postRepository.UpdatePostAsync(_mapper.Map(updateRequest, post));
if (updated)
{
return(Ok(_mapper.Map <PostResponse>(post)));
}
return(NotFound());
}
/// <inheritdoc />
Task <ApiResponse <PostResponse> > ITweetbookAPI.UpdateAsync(Guid id, UpdatePostRequest request)
{
var arguments = new object[] { id, request };
var func = requestBuilder.BuildRestResultFuncForMethod("UpdateAsync", new Type[] { typeof(Guid), typeof(UpdatePostRequest) });
return((Task <ApiResponse <PostResponse> >)func(Client, arguments));
}
public async Task <IActionResult> UpdatePost([FromBody] UpdatePostRequest request)
{
var post = await _ctx.Posts.Include(p => p.Author)
.FirstOrDefaultAsync(p => p.Id == request.PostId);
if (post.Author.Email != _userHelper.Email)
{
return(Forbid());
}
post.Species = await _ctx.Species.FirstAsync(s => s.Id == request.Species.Id);
post.Breed = await _ctx.Breeds.FirstAsync(b => b.Id == request.Breed.Id);
post.Color = await _ctx.Colors.FirstAsync(s => s.Id == request.Color.Id);
post.PostType = request.PostType;
post.Size = request.Size;
post.Content = request.Content;
post.LostTime = request.LostTime;
post.Location = request.Location;
if (request.ImageSource != null)
{
post.ImageSource = request.ImageSource;
_fileHelper.SaveFile(post.Id, post.ImageSource, ObjectType.Post);
}
_ctx.Posts.Update(post);
await _ctx.SaveChangesAsync();
return(Ok());
}
public Task <string> AddPostAsync(string blogid, string username, string password, Post post, bool publish)
{
EnsureUser(username, password);
return(TryExecuteAsync(async() =>
{
var cids = await GetCatIds(post.categories);
if (cids.Length == 0)
{
throw new ArgumentOutOfRangeException(nameof(post.categories));
}
var req = new UpdatePostRequest
{
Title = post.title,
Slug = post.wp_slug ?? ToSlug(post.title),
EditorContent = post.description,
Tags = post.mt_keywords?.Split(','),
CategoryIds = cids,
ContentLanguageCode = "en-us",
IsPublished = publish,
EnableComment = true,
IsFeedIncluded = true,
ExposedToSiteMap = true,
PublishDate = DateTime.UtcNow
};
var p = await _postManageService.CreateAsync(req);
return p.Id.ToString();
}));
}
public async Task <IActionResult> Update([FromRoute] Guid postId, [FromBody] UpdatePostRequest postRequest)
{
var userOwnsPost = await _postService.UserOwnsPostAsync(postId, HttpContext.GetUserId());
if (!userOwnsPost)
{
return(BadRequest(new { Error = "Yo do not own this post" }));
}
var post = await _postService.GetPostByIdAsync(postId);
post.Name = postRequest.Name;
var updated = await _postService.UpdatePostAsync(post);
if (updated)
{
return(Ok(new Response <PostResponse>(_mapper.Map <PostResponse>(post))));
}
/*return Ok(new PostResponse
* {
* Name = post.Name,
* Id = post.Id,
* UserId = post.UserId,
* Tags = post.Tags.Select(t => new TagResponse {Name = t.TagName})
* });*/
return(NotFound());
}
public async Task <IActionResult> Update(UpdatePostRequest contract, CancellationToken cancellationToken)
{
if (!ModelState.IsValid)
{
return(BadRequest(new ResponseMessage {
Message = "One or more validation errors occurred."
}));
}
var user = (SimpleBlogAPI.Entities.User)HttpContext.Items["User"];
var post = _mapper.Map <PostDTO>(contract);
post.UserId = user.Id;
bool result = await _postService.Update(post, cancellationToken);
if (!result)
{
return(BadRequest(new ResponseMessage {
Message = "Post hasn't been updated."
}));
}
return(Ok(new ResponseMessage {
Message = "Post has been updated."
}));
}
public IActionResult Update([FromRoute] string noteId, [FromBody] UpdatePostRequest request)
{
if (request == null)
{
return(BadRequest());
}
var userOwnsPost = _noteService.UserOwnsNoteAsync(noteId, HttpContext.GetUserId());
if (!userOwnsPost)
{
return(BadRequest(new { error = "Post not found" }));
}
//var note=new Note{Id=noteId,Tag=request.Tag,Title=request.Title,Post=request.Post};
var note = _noteService.GetNoteById(noteId);
if (note == null)
{
return(NotFound());
}
note.Tag = request.Tag;
note.Title = request.Title;
note.Post = request.Post;
var updateSuccess = _noteService.UpdateNote(note);
if (!updateSuccess)
{
return(NotFound());
}
return(Ok(note));
}
public async Task <IActionResult> Update([FromRoute] Guid postId, [FromBody] UpdatePostRequest postRequest)
{
var userOwnsPost = await this.postService.UserOwnsPostAsync(HttpContext.GetUserId(), postId);
if (!userOwnsPost)
{
return(BadRequest(new { error = "You do not own this post" }));
}
var post = await this.postService.GetAsync(postId);
post.Name = postRequest.Name;
post.Tags = postRequest.Tags.Select(tagName => new PostTag {
TagName = tagName, PostId = post.Id
}).ToList();
if (!await this.postService.UpdateAsync(post))
{
return(NotFound());
}
return(Ok(new PostResponse
{
Id = post.Id,
Name = post.Name,
Tags = post.Tags.Select(postTag => postTag.TagName)
}));
}
public ActionResult <UpdatePostResponse> Update([FromBody] UpdatePostRequest request)
{
request.CommanderID = User.GetUserId();
var result = _postService.Update(request);
return(result);
}
/// <summary>
/// This method updates post.
/// </summary>
/// <param name="request">UpdatePostRequest.</param>
/// <param name="postId">PostId.</param>
/// <param name="context">CurrentUserId.</param>
/// <returns>UpdatePostResponse.</returns>
public async Task <UpdatePostResponse> UpdatePost(UpdatePostRequest request, string postId, string context)
{
var user = await _userManager.GetUser(context);
if (!request.IsValid())
{
return(new UpdatePostResponse()
{
StatusCode = StatusCode.InvalidArgument, ErrorMessage = "Empty argument provided",
});
}
var post = await _postManager.GetPostById(postId);
if (post == null)
{
return(new UpdatePostResponse()
{
StatusCode = StatusCode.NotFound, ErrorMessage = "Post not found",
});
}
if (post.Author.Id != user.Id)
{
return(new UpdatePostResponse()
{
StatusCode = StatusCode.PermissionDenied, ErrorMessage = "Unauthorized user to update post",
});
}
Post updatedPost = new Post()
{
Id = post.Id, Title = request.Title, Body = request.Body, Author = post.Author,
CreatedAt = post.CreatedAt, UpdatedAt = DateTime.Now, Likes = post.Likes,
};
var updated = await _postManager.UpdatePost(updatedPost);
if (!updated)
{
return(new UpdatePostResponse()
{
StatusCode = StatusCode.Internal, ErrorMessage = "Internal Error! Couldn't update post",
});
}
var singleCached = await _cacheProcessor.UpdatePostStringAsync(updatedPost.Id, updatedPost);
var cached = await _cacheProcessor.UpdateUserPostStringAsync(user.Id, updatedPost);
if (!cached || !singleCached)
{
return(new UpdatePostResponse()
{
StatusCode = StatusCode.Internal, ErrorMessage = "Internal Error! Couldn't Cache post"
});
}
return(new UpdatePostResponse()
{
StatusCode = StatusCode.Ok, Post = ConvertToPostResponse(updatedPost),
});
}
public async Task <IActionResult> Update([FromRoute] Guid postId, [FromBody] UpdatePostRequest postRequest)
{
var userOwnsPost = await _postService.UserOwnsPostAsync(postId, HttpContext.GetUserId());
if (!userOwnsPost)
{
return(BadRequest(new
{
error = "You do not own this post"
}));
}
var post = await _postService.GetPostByIdAsync(postId);
post.Name = postRequest.Name;
var updated = await _postService.UpdatePostAsync(post);
if (updated)
{
return(Ok(new Response <PostResponse>(
_mapper.Map <PostResponse>(post))));
}
return(NotFound());
}
public async Task <IActionResult> Update([FromRoute] Guid id, [FromBody] UpdatePostRequest newPost)
{
string userId = HttpContext.GetUserId();
var userOwnsPost = await service.UserOwnsPostAsync(id, userId);
if (!userOwnsPost)
{
return(BadRequest(error: new { error = "You don't own this post." }));
}
Post updatedPost = new Post {
Id = id, Name = newPost.Name, UserId = userId,
Tags = newPost.Tags.Select(x => new Tag {
Name = x.Name, CreatedBy = x.CreatedBy
}).ToList()
};
var result = await service.UpdatePost(updatedPost);
if (result)
{
return(Ok(newPost));
}
return(NotFound());
}
public async Task <ActionResult> Update(Guid id, [FromBody] UpdatePostRequest postUpdateDto)
{
var command = new Features.Posts.Update.UpdatePostRequest()
{
Post = new Post()
{
Content = postUpdateDto.Content,
Id = id,
Title = postUpdateDto.Title,
},
};
var response = await _mediator.Send(command);
if (response.IsFailed)
{
return(WebApiResponses.GetErrorResponse(response));
}
var routeUrl = Url.RouteUrl(new UrlRouteContext()
{
Host = Request.Host.Host,
Protocol = Request.Scheme,
RouteName = "GetPostById",
Values = new { Id = id },
});
Response.Headers.Add("Location", routeUrl);
return(NoContent());
}
public async Task <IActionResult> Update([FromRoute] Guid postId, [FromBody] UpdatePostRequest request)
{
var userOwnsPost = await _postservice.UserOwnsPostAsync(postId, HttpContext.GetUserId());
if (!userOwnsPost)
{
return(BadRequest(error: new { error = "Bu post size ait değil" }));
}
var post = await _postservice.GetPostByIdAsync(postId);
post.Name = request.Name;
var updated = await _postservice.UpdatePostAsync(post);
if (updated)
{
return(Ok(post));
}
return(NotFound());
}
public async Task <IActionResult> UpdatePost([FromForm] UpdatePostRequest request)
{
var response = await mediator.Send(request);
logger.LogResponse($"User #{HttpContext.GetCurrentUserId()} updated post #{response.Post?.Id}", response.Error);
return(response.IsSucceeded ? (IActionResult)Ok(response) : BadRequest(response));
}
public IActionResult Create([FromBody] UpdatePostRequest updatePostRequest)
{
if (!ModelState.IsValid)
{
return(UnprocessableEntity(updatePostRequest));
}
return(Ok(updatePostRequest));
}
//Update
public async Task <PostResponse> UpdatePost(int id, UpdatePostRequest model)
{
var post = await GetPost(id);
_mapper.Map(model, post);
_context.Posts.Update(post);
await _context.SaveChangesAsync();
return(_mapper.Map <PostResponse>(post));
}
public ActionResult <PostResponse> Update([FromRoute] int id, [FromBody] UpdatePostRequest update)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var post = _posts.Update(id, update);
return(new PostResponse(post));
}
public async Task UpdateAsync(int id, UpdatePostRequest updatePostRequest)
{
var dbPost = await this.context.Posts.FindAsync(id);
if (dbPost == null)
{
throw new ResourceNotFoundException();
}
this.mapper.Map(updatePostRequest, dbPost);
await this.context.SaveChangesAsync();
}
public bool EditPost(UpdatePostRequest request)
{
var updatingPost = _postsRepository.Get(request.PostId);
if (updatingPost != null && (updatingPost.StatusId == (int)PostStatuses.Rejected || updatingPost.StatusId == (int)PostStatuses.Created))
{
updatingPost.Text = request.Text;
return(_postsRepository.Update(updatingPost));
}
return(false);
}
