public void UpdatePost(PostUpdateRequest req)
{
try
{
using (SqlConnection connection = new SqlConnection(connString))
{
connection.Open();
SqlCommand cmd = new SqlCommand("dbo.Posts_Update", connection);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@Id", req.Id);
cmd.Parameters.AddWithValue("@Title", req.Title);
cmd.Parameters.AddWithValue("@Body", req.Body);
cmd.ExecuteNonQuery();
connection.Close();
}
}
catch (Exception ex)
{
string err = ex.Message.ToString();
throw ex;
}
}
public MPost Update(int id, PostUpdateRequest request)
{
var post = ctx.Posts.Include(x => x.Category).Include(x => x.PostsTags).Where(x => x.Id == id).FirstOrDefault();
if (request.Tags.Count > 0)
{
var tags = ctx.PostTags.Where(x => x.PostId == id).ToList();
ctx.PostTags.RemoveRange(tags);
ctx.SaveChanges();
foreach (var tag in request.Tags)
{
ctx.PostTags.Add(new PostTag
{
PostId = id,
TagId = tag.Id
});
}
ctx.SaveChanges();
}
post.Title = request.Title;
post.Summary = request.Summary;
post.CreationDate = request.UpdatedDate;
post.CategoryId = request.CategoryId;
ctx.SaveChanges();
return(_mapper.Map <MPost>(post));
}
public async Task <IActionResult> Update([FromRoute] Guid postId, [FromBody] PostUpdateRequest request)
{
var userId = this.HttpContext.GetUserId();
if (!userId.HasValue)
{
return(this.BadRequest("The User Id is epsent"));
}
var userOwnsPost = await postService.UserOwnsPostAsync(postId, userId.Value);
if (!userOwnsPost)
{
return(this.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);
if (updated)
{
return(this.Ok(new Response <PostResponse>(this.mapper.Map <PostResponse>(post))));
}
return(this.NotFound());
}
public async Task <ApiResult <bool> > Update(PostUpdateRequest request)
{
var post = await _context.Posts.FindAsync(request.Id);
if (post == null)
{
return(new ApiErrorResult <bool>(SystemConstants.Message.CanNotFindIdMessage + "post table with Id: " + request.Id));
}
post.Title = request.Title;
post.Summary = request.Summary;
post.SeoTitle = request.SeoTitle;
if (request.ThumbnailImage == null)
{
await _context.SaveChangesAsync();
return(new ApiSuccessResult <bool>());
}
var thumbnailImage = await _context.PostImages.FirstOrDefaultAsync(x => x.IsDefault && x.PostId == request.Id);
thumbnailImage.FileSize = request.ThumbnailImage.Length;
thumbnailImage.ImagePath = await this.SaveFile(request.ThumbnailImage);
_context.PostImages.Update(thumbnailImage);
await _context.SaveChangesAsync();
return(new ApiSuccessResult <bool>());
}
public void PostUpdate(PostUpdateRequest model, int userId)
{
_data.ExecuteNonQuery("dbo.Posts_Update",
delegate(SqlParameterCollection col)
{
col.AddWithValue("@Id", model.Id);
col.AddWithValue("@Content", model.Content);
col.AddWithValue("@ModifiedBy", userId);
}, null);
}
public async Task <IActionResult> Update([FromForm] PostUpdateRequest request)
{
var result = await _postService.Update(request);
if (!result.IsSuccess)
{
return(BadRequest(result));
}
return(Ok(result));
}
public ActionResult <Model.Post> Update(string slug, [FromBody] PostUpdateRequest request)
{
var result = _service.Update(slug, request);
if (result == null)
{
return(BadRequest("Error finding or updating post"));
}
return(result);
}
public async Task <IActionResult> UpdateAsync(int id, [FromBody] PostUpdateRequest postUpdateRequest)
{
var post = await _postService.GetByIdAsync(id);
if (post == null)
{
return(NotFound());
}
var postUpdated = _mapper.Map(postUpdateRequest, post);
await _postService.UpdateAsync(postUpdated);
return(Ok(postUpdated));
}
public MPost Update(int id, PostUpdateRequest request)
{
var found = _posts.Where(i => i.PostId == id).FirstOrDefault();
MPost updatePost = new MPost
{
PostId = found.PostId,
AccountId = found.AccountId,
Content = found.Content,
PublishDate = found.PublishDate,
Title = found.Title
};
return(found);
}
public ActionResult <SuccessResponse> UpdatePost(PostUpdateRequest req)
{
ActionResult result = null;
try
{
_postService.UpdatePost(req);
SuccessResponse response = new SuccessResponse();
result = Ok(response);
}
catch (Exception ex)
{
result = StatusCode(500, new ErrorResponse(ex.Message.ToString()));
}
return(result);
}
public IActionResult Update([FromBody] PostUpdateRequest request)
{
try
{
var userId = _authenticationService.GetAuthenticatedUserId(User);
_postService.Update(request.PostId, request.Content, userId);
return(new ObjectResult(new
{
StatusCode = ResponseConstants.Success,
}));
}
catch (Exception)
{
return(new ObjectResult(new Result {
StatusCode = ResponseConstants.Unknown
}));
}
}
public BaseResponse PostUpdate([FromBody] PostUpdateRequest request)
{
return(HandleRequest(() =>
{
Logger.Info($"Post update from {request.From} to {request.To}.");
UpdateDto update = new UpdateDto
{
From = Version.ParseVersion(request.From),
To = Version.ParseVersion(request.To),
Path = request.Path,
Crc = request.Crc
};
Lobby.Instance.AddUpdate(update);
return new BaseResponse {
Ok = true
};
}));
}
public void Update_ValidIdPassed_ReturnsOk()
{
// Arrange
var testItem = new PostUpdateRequest()
{
Content = "Bananas",
Title = "Newss",
PublishDate = DateTime.Now,
AccountId = 1
};
// Act
var createdResponse = _controller.Update(1, testItem);
// Assert
Assert.IsType <OkObjectResult>(createdResponse.Result);
}
public Model.Post Update(string slug, PostUpdateRequest request)
{
//we validated the things but if there's still some kind of specific error just return a null
//we don't throw an Exception to save performance and keep simplicity of course it could be implemented in better ways
//in that case controller will receive a null and notify user about failure to execute update
try
{
var entity = _context.Posts.Where(p => p.Slug == slug).Include(p => p.PostTags).Single();
//check which post parameters were actually changed?
if (!string.IsNullOrWhiteSpace(request.Title) && request.Title != entity.Title)
{
entity.Title = request.Title;
//also need to create a new slug
entity.Slug = CreateSlug(request.Title);
bool valid = SlugValid(entity.Slug);
if (!valid)
{
throw new UserException("Post with this title already exists, choose another one");
}
}
if (!string.IsNullOrWhiteSpace(request.Description) && request.Description != entity.Description)
{
entity.Description = request.Description;
}
if (!string.IsNullOrWhiteSpace(request.Body) && request.Body != entity.Body)
{
entity.Body = request.Body;
}
entity.UpdatedAt = DateTime.Now.ToUniversalTime();
_context.SaveChanges();
return(_mapper.Map <Model.Post>(entity));
}
catch
{
return(null);
}
}
public ActionResult <Post> Update(string slug, PostUpdateRequest request)
{
var entity = _context.Posts.Where(w => w.slug == slug).FirstOrDefault();
if (entity == null)
{
return(NotFound());
}
_context.Posts.Attach(entity);
_context.Posts.Update(entity);
_mapper.Map(request, entity);
entity.updatedAt = DateTime.Now;
entity.slug = Helpers.Helper.GenerateSlug(request.title);
_context.SaveChanges();
var res = _context.Posts.Include("tagList.Tag").Where(w => w.PostID == entity.PostID).FirstOrDefault();
return(_mapper.Map <Post>(res));
}
public ActionResult <SuccessResponse> PostUpdate(PostUpdateRequest model)
{
int code = 200;
BaseResponse response = null;
try
{
int userId = _authService.GetCurrentUserId();
_service.PostUpdate(model, userId);
response = new SuccessResponse();
}
catch (Exception ex)
{
code = 500;
response = new ErrorResponse(ex.Message);
}
return(StatusCode(code, response));
}
public async Task Update()
{
try
{
if (selectedCategory != null && !string.IsNullOrWhiteSpace(PostSummary) && !string.IsNullOrWhiteSpace(PostTitle))
{
var request = new PostUpdateRequest
{
CategoryId = selectedCategory.Id,
UpdatedDate = DateTime.Now,
Summary = PostSummary,
Title = PostTitle,
Tags = new List <MTag>()
};
foreach (var item in Tags)
{
if (item.isChecked)
{
request.Tags.Add(item);
}
}
await _postApiService.Update <MPost>(Post.Id, request);
await Application.Current.MainPage.DisplayAlert("Post", "Updated", "Ok");
}
else
{
await Application.Current.MainPage.DisplayAlert("Info", "Fill all info", "Ok");
}
}
catch
{
await Application.Current.MainPage.DisplayAlert("Error", "Server error", "Ok");
}
}
public MPost Update(int id, PostUpdateRequest request) => _service.Update(id, request);
public async Task <ActionResult <PostResponse> > Update([FromBody] PostUpdateRequest post)
{
var response = await PostBusiness.Update((Post)post, User.Account());
return((PostResponse)response);
}
