public override async Task <UpdateBlogResponse> UpdateBlog(UpdateBlogRequest request, ServerCallContext context)
{
var blogId = request.Blog.Id;
var filter = new FilterDefinitionBuilder <BsonDocument>().Eq("_id", new ObjectId(blogId));
var result = mongoCollection.Find(filter).FirstOrDefault();
if (result == null)
{
throw new RpcException(new Status(StatusCode.NotFound, $"The blog id {blogId} wasn't find"));
}
var doc = new BsonDocument("author_id", request.Blog.AuthorId)
.Add("title", request.Blog.Title)
.Add("content", request.Blog.Content);
mongoCollection.ReplaceOne(filter, doc);
var blog = new Blog.Blog()
{
AuthorId = doc.GetValue("author_id").AsString,
Title = doc.GetValue("title").AsString,
Content = doc.GetValue("content").AsString
};
blog.Id = blogId;
return(new UpdateBlogResponse()
{
Blog = blog
});
}
public async Task Update_ShouldUpdateBlogUrl()
{
// Arrange
var client = _factory.CreateClient();
var initialBlog = await CreateRandomBlog(client);
var updateRequest = new UpdateBlogRequest
{
// not a real url but just something random.. we don't have any validation for now
Url = Guid.NewGuid().ToString()
};
// Act
var response = await client.PutAsync($"/v1/blogs/{initialBlog.Id}", new JsonContent <UpdateBlogRequest>(updateRequest));
response.EnsureSuccessStatusCode();
// Assert
var getResponse = await client.GetAsync($"/v1/blogs/{initialBlog.Id}");
var actual = await getResponse.Content.ReadAsJsonAsync <Blog>();
Assert.Equal(updateRequest.Url, actual.Url);
}
public async Task <IActionResult> PutBlog(string slug, UpdateBlogRequest blogUpdateRequest)
{
try
{
Blog blog = await _context.Blog.Include("Tags").Where(b => b.Slug == slug).FirstOrDefaultAsync();
blog.Title = blogUpdateRequest.BlogPost.Title;
_context.Entry(blog).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(Created($"api/posts/{blog.Slug}", new SingleBlogPostResponse(blog)));
}
catch (DbUpdateConcurrencyException)
{
return(BadRequest(new ClientErrorResponse("Couldn't update blog.")));
}
catch (NullReferenceException)
{
return(UnprocessableEntity(new ClientErrorResponse("One or more attributes are invalid")));
}
catch (Exception e)
{
return(BadRequest(new ClientErrorResponse(e.Message)));
}
}
public async Task <IActionResult> OnPostAsync()
{
var updateRequest = new UpdateBlogRequest(Blog.Id, Blog.Title, Blog.Content, Blog.Description, Blog.ImageUrl);
await _blogService.UpdateBlog(updateRequest);
return(RedirectToPage("/Admin/ManageBlogs"));
}
public async Task <Blog> UpdateBlogAsync(string blogId, UpdateBlogRequest blogRequest)
{
var blog = await this.GetBlogAsync(blogId);
if (blog == null)
{
throw new NotFoundException($"Not found blog by id ={blogId}");
}
if (blogRequest.Text.Length >= 2000)
{
throw new RequestException("Blog has length more 2000 symbols.");
}
var blogResult = _mapper.Map <UpdateBlogRequest, Blog>(blogRequest);
blogResult.UpdatedOn = DateTime.Now;
var blogUpdate = await _repository.Update(blogId.ToString(), blogResult);
if (!blogUpdate)
{
throw new ResponseException("Blog has not update", 500);
}
return(blogResult);
}
public override async Task <UpdateBlogResponse> UpdateBlog(UpdateBlogRequest request, ServerCallContext context)
{
var blogId = request.Blog.Id;
var filter = new FilterDefinitionBuilder <BsonDocument>().Eq("_id", new ObjectId(blogId));
var doc = (await mongoCollection.FindAsync(filter)).FirstOrDefault();
if (doc == null)
{
throw new RpcException(new Status(StatusCode.NotFound, $"Blog with id={blogId} was not found"));
}
var updatedDoc = new BsonDocument("author_id", request.Blog.AuthorId)
.Add("title", request.Blog.Title)
.Add("content", request.Blog.Content);
try
{
//await mongoCollection.UpdateOneAsync(filter, updatedDoc);
await mongoCollection.ReplaceOneAsync(filter, updatedDoc);
return(new UpdateBlogResponse
{
Blog = new Blog.Blog
{
Id = blogId,
AuthorId = updatedDoc.GetValue("author_id").AsString,
Title = updatedDoc.GetValue("title").AsString,
Content = updatedDoc.GetValue("content").AsString
}
});
}
catch (Exception ex)
{
throw new RpcException(new Status(StatusCode.Internal, ex.Message));
}
}
public IActionResult update(UpdateBlogRequest request)
{
UpdateBlogUseCase updateBlogUseCase = new UpdateBlogUseCase(_BlogsRepository, _UsersRepository);
UseCaseBaseOutput <SingleBlogResponse> useCaseBaseOutput = updateBlogUseCase.Process(request);
if (useCaseBaseOutput.httpStatus != StatusCodes.Status200OK)
{
return(StatusCode(useCaseBaseOutput.httpStatus, "failed to update blog please try again later"));
}
return(StatusCode(useCaseBaseOutput.httpStatus, useCaseBaseOutput.value));
}
public async Task <ActionResult> UpdateBlog(string blogId, [FromBody] UpdateBlogRequest blockRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _blockService.UpdateBlogAsync(blogId, blockRequest);
return(NoContent());
}
private Blog Map(UpdateBlogRequest blogRequest)
{
Blog blog = new Blog();
blog.Id = blogRequest.Id;
blog.Body = blogRequest.Body;
blog.Tags = blogRequest.Tags;
blog.Title = blogRequest.Title;
blog.Description = blogRequest.Description;
return(blog);
}
public UseCaseBaseOutput <SingleBlogResponse> Process(UpdateBlogRequest request)
{
if (!_UserRepository.isUserLogInByToken(request.token, request.ipAddress))
{
return(new UseCaseBaseOutput <SingleBlogResponse>(new SingleBlogResponse(), StatusCodes.Status401Unauthorized));
}
User user = _UserRepository.getLogInUserInformation(request.token, request.ipAddress);
Blog blog = _BlogsRepository.fetchSingleBlog(request.blogId);
if (blog == null)
{
return(new UseCaseBaseOutput <SingleBlogResponse>(new SingleBlogResponse(), StatusCodes.Status500InternalServerError));
}
Blog updatedBlog = new Blog();
if (user.id == blog.ownerUserId || user.type == UserTypes.ADMIN)
{
updatedBlog.base64Image = request.blog.base64Image;
updatedBlog.content = request.blog.content;
updatedBlog.title = request.blog.title;
updatedBlog.id = blog.id;
updatedBlog.ownerUserId = blog.ownerUserId;
updatedBlog.updatedDate = DateTime.Now;
}
else
{
updatedBlog.base64Image = blog.base64Image;
updatedBlog.content = blog.content + Environment.NewLine + request.blog.content;
updatedBlog.title = blog.title;
updatedBlog.id = blog.id;
updatedBlog.ownerUserId = blog.ownerUserId;
updatedBlog.updatedDate = DateTime.Now;
}
Blog afterUpdateBlog = _BlogsRepository.updateBlog(request.blogId, updatedBlog);
if (afterUpdateBlog.id != updatedBlog.id || afterUpdateBlog == null)
{
return(new UseCaseBaseOutput <SingleBlogResponse>(new SingleBlogResponse(), StatusCodes.Status500InternalServerError));
}
return(new UseCaseBaseOutput <SingleBlogResponse>(new SingleBlogResponse {
id = afterUpdateBlog.id,
title = afterUpdateBlog.title,
content = afterUpdateBlog.content,
base64Image = afterUpdateBlog.base64Image,
updatedDate = afterUpdateBlog.updatedDate.ToString("MMMM dd, yyyy"),
creatorName = _UserRepository.getUserName(afterUpdateBlog.ownerUserId)
}, StatusCodes.Status200OK));
}
public async Task <IActionResult> Update(Guid id, [FromBody] UpdateBlogRequest updateRequest, CancellationToken cancellationToken)
{
var existingBlog = await _dbContext.Blogs
.FirstOrDefaultAsync(b => b.Id == id, cancellationToken);
if (existingBlog == null)
{
return(NotFound("Blog not found"));
}
existingBlog.UpdateUrl(updateRequest.Url);
await _dbContext.SaveChangesAsync(cancellationToken);
return(NoContent());
}
public async Task <UpdateBlogResponse> Put(Guid id, [FromBody] UpdateBlogRequest request)
{
return(await _updateItemHandler.ProcessAsync(request.SetBlogId(id)));
}
public object Put(UpdateBlogRequest request)
{
return(this._BlogManager.UpdateBlog(Map(request)));
}
public async Task UpdateBlog(UpdateBlogRequest updateBlogRequest)
{
await _blogRepository.UpdateBlog(updateBlogRequest.Id, updateBlogRequest.Title, updateBlogRequest.Content,
updateBlogRequest.Description, updateBlogRequest.ImageUrl);
}
