[TransactionScopeAspect]//+++ public IResult Update(PostUpdateDto post) { /* * var post2 = new Post * { * Content = post.Content, * Title = post.Title, * Updated = DateTime.Now, * Id = post.Id, * UserId = post.UserId * };*/ _postDal.Update2(post); if (post.CategoryId != null) { string[] category = post.CategoryId.Split("*"); foreach (var item in category) { if (item != "") { var postCategory = new PostCategoryCreateDto { PostId = post.Id, CategoryId = item }; _postCategoryService.Add(postCategory); } } } //var postCategory2 = new PostCategory {PostId=post.Id,CategoryId=post.CategoryId, Id=post.PostCategoryId }; // _postCategoryService.Update(postCategory2); return(new SuccessResult(Messages.PostUpdated)); }
public void Update(int postId, PostUpdateDto postDto) { Post post = GetById(postId); post.content = postDto.content; post.editted = DateTime.Now; /* context.Posts.Update(post); */ /* context.Posts.SaveChanges(); */ }
public async Task <IResult> UpdateAsync(PostUpdateDto postUpdateDto, string modifiedByName) { var oldPost = await UnitOfWork.Posts.GetAsync(p => p.Id == postUpdateDto.Id); var post = Mapper.Map <PostUpdateDto, Post>(postUpdateDto, oldPost); post.ModifiedByName = modifiedByName; await UnitOfWork.Posts.UpdateAsync(post); await UnitOfWork.SaveAsync(); return(new Result(ResultStatus.Success, Messages.Post.Update(post.Title))); }
public ActionResult <PostReadDto> UpdatePost(int id, PostUpdateDto _PostUpdateDto) { var postItem = _repository.GetPostById(id); if (postItem == null) { return(NotFound()); } _mapper.Map(_PostUpdateDto, postItem); _repository.UpdatePost(postItem); _repository.SaveChanges(); return(Ok(_mapper.Map <PostReadDto>(postItem))); }
public IActionResult UpdatePost(int PostId, [FromBody] PostUpdateDto PostDto) { if (PostDto == null || PostId != PostDto.Id) { return(BadRequest(ModelState)); } var PostObj = _mapper.Map <Post>(PostDto); if (!_psRepo.UpdatePost(PostObj)) { ModelState.AddModelError("", $"Something went wrong when updating the record {PostObj.Id}"); return(StatusCode(500, ModelState)); } return(NoContent()); }
public ActionResult <PostOutDto> Update(string id, [FromBody] PostUpdateDto postInDto) { if (!ModelState.IsValid || postInDto == null) { return(BadRequest(new Message("Post not valid or null"))); } //Check if there exist a post with {id} var post = _postRepository.GetById(id); if (post == null) { return(NotFound(new Message("No such post with this id: " + id))); } //Check if post is being updated by its owner var tokenUser = HttpContext.User; if (!AuthorizationHelpers.IsAuthorizedUser(tokenUser, post.OwnerId)) { return(Unauthorized(new Message("Unauthorized user."))); } if (!string.IsNullOrWhiteSpace(postInDto.Title)) { post.Title = postInDto.Title; } if (!string.IsNullOrWhiteSpace(postInDto.Content)) { post.Content = postInDto.Content; } if (!string.IsNullOrWhiteSpace(postInDto.CategoryId)) { post.Content = postInDto.CategoryId; } //Save changes if (!_postRepository.Update(post)) { return(BadRequest(new Message("Error when updating post"))); } var postOutDto = _mapper.Map <PostOutDto>(post); return(postOutDto); }
public async Task <ActionResult> UpdatePost(int id, PostUpdateDto post) { var postModelFromRepo = await _repository.GetPostByIdAsync(id); if (postModelFromRepo == null) { return(NotFound()); } _mapper.Map(post, postModelFromRepo); _repository.UpdatePost(postModelFromRepo); await _repository.SaveChangesAsync(); return(NoContent()); }
public async Task <PostWithDetailDto> UpdateAsync(Guid id, PostUpdateDto input) { var post = await _postRepository.GetAsync(id); post.SetTitle(input.Title); post.Content = input.Content; post.Description = input.Description; var tagList = SplitTags(input.Tags); await RemoveOldTags(tagList, post); await AddNewTags(tagList, post); var newPost = await _postRepository.UpdateAsync(post); return(ObjectMapper.Map <Post, PostWithDetailDto>(newPost)); }
public ActionResult UpdatePost(int id, PostUpdateDto updateDto) { var post = _repository.GetBlogPostById(id); if (post == null) { return(NotFound()); } _mapper.Map(updateDto, post); _repository.UpdatePost(post); _repository.savechanges(); return(NoContent()); }
public ActionResult UpdatePost(int id, PostUpdateDto postUpdateDto) { var postModelFromRepo = _repository.GetPostById(id); if (postModelFromRepo == null) { return(NotFound()); } _mapper.Map(postUpdateDto, postModelFromRepo); _repository.UpdatePost(postModelFromRepo); _repository.SaveChanges(); return(NoContent()); }
public ActionResult <PostDto> UpdatePost(PostUpdateDto post, [FromHeader] int accountId, [FromHeader] string key) { if (!authService.Authorize(key)) { return(StatusCode(StatusCodes.Status401Unauthorized, "The user is not authorized!")); } if (userMockRepository.GetAccountByUserAccountID(post.UserId) == null) { return(StatusCode(StatusCodes.Status400BadRequest, "User with that id does not exist!")); } if (contentRepository.GetContentById(post.ContentId) == null) { return(StatusCode(StatusCodes.Status400BadRequest, "Content with that id does not exist!")); } if (post.UserId != accountId) { return(StatusCode(StatusCodes.Status403Forbidden, "Not allowed, user does not have permission for that action!")); } try { var oldPost = postRepository.GetPostById(post.PostId); if (oldPost == null) { return(NotFound()); } Post postEntity = mapper.Map <Post>(post); postEntity.DateOfPublication = oldPost.DateOfPublication; postEntity.ExpiryDate = oldPost.ExpiryDate; mapper.Map(postEntity, oldPost); postRepository.SaveChanges(); fakeLoggerRepository.Log(LogLevel.Information, contextAccessor.HttpContext.TraceIdentifier, "", "Post updated", null); return(Ok(mapper.Map <PostDto>(oldPost))); } catch (Exception) { fakeLoggerRepository.Log(LogLevel.Error, contextAccessor.HttpContext.TraceIdentifier, "", "Error with updating post", null); return(StatusCode(StatusCodes.Status500InternalServerError, "Update error")); } }
public Post Update(PostUpdateDto postUpdateDto) { if (IsPostExist(postUpdateDto.PostId)) { var post = new Post() { CategoryId = postUpdateDto.CategoryId, UserId = postUpdateDto.UserId, PostId = postUpdateDto.PostId, Content = postUpdateDto.Content, PublishDate = DateTime.Now, Title = CultureInfo.CurrentCulture.TextInfo.ToTitleCase(postUpdateDto.Title) }; return(_postDal.Update(post)); } throw new Exception("Bu id ye ait Post bulunamamıştır. Lütfen id bilgilerini kontrol ediniz"); }
public async Task <ActionResult <Post> > PutPost(int id, PostUpdateDto dto) { Post post = await _context.Posts.FindAsync(id); if (post == null) { return(NotFound()); } _mapper.Map(dto, post); _context.Entry(post).State = EntityState.Modified; await _context.SaveChangesAsync(); await BroadcastPostUpdated(id); return(Ok()); }
[HttpPost("update")]//++++ public async Task <IActionResult> Update([FromForm] PostUpdateDto post) { //eğer resim değiştirirse image ve imagename propları dolu olmak zorunda if (post.Image != null && post.ImageName != null) //resim değiştirmek isterse bu işlemler yapılacak. { var resimler = Path.Combine(_environment.WebRootPath, "postImage"); //dizin bilgisi System.IO.File.Delete(resimler + "\\" + post.ImageName); post.ImageName = $"{ Guid.NewGuid()}.jpg"; using (var fileStream = new FileStream(Path.Combine(resimler, post.ImageName), FileMode.Create)) { await post.Image.CopyToAsync(fileStream); } } var result = _postService.Update(post); if (result.Success) { return(Ok(result.Message)); } return(BadRequest(result.Message)); }
public async Task <ActionResult> Update([FromForm] PostUpdateDto PostUpdateDto) { return(await HandleExceptions(async() => { var role = User.Claims.FirstOrDefault(x => x.Type.Equals(ClaimsIdentity.DefaultRoleClaimType))?.Value; var userId = User.Claims.FirstOrDefault(x => x.Type.Equals(ClaimsIdentity.DefaultNameClaimType))?.Value; var authorId = await _postManager.GetPostAuthorIdAsync(PostUpdateDto.Id); if (role != "Admin" && Int32.Parse(userId) != authorId) { return Forbid("Access denied"); } if (ModelState.IsValid) { var hostRoot = _hostServices.GetHostPath(); await _postManager.UpdatePostAsync(PostUpdateDto, hostRoot); return Ok(); } return BadRequest("Model state is not valid"); })); }
public void Update2(PostUpdateDto postUpdateDto) { using (var context = new BlogDbContext()) { var entity = context.Posts.SingleOrDefault(w => w.Id == postUpdateDto.Id); if (postUpdateDto.Title != null) { entity.Title = postUpdateDto.Title; } if (postUpdateDto.Content != null) { entity.Content = postUpdateDto.Content; } if (postUpdateDto.ImageName != null) { entity.ImageName = postUpdateDto.ImageName; } if (postUpdateDto.Title != null) { entity.Title = postUpdateDto.Title; } if (postUpdateDto.isActive != null) { entity.IsActive = postUpdateDto.isActive; } if (postUpdateDto.isDeleted != null) { entity.IsDeleted = postUpdateDto.isDeleted; } entity.Updated = DateTime.Now; context.SaveChanges(); } }
public async Task <IActionResult> UpdatePost([FromRoute] Guid id, [FromBody] PostUpdateDto postToUpdate) { //model state validation is not required due to the [ApiController] attribute automatically returning UnprocessableEntity (see startup.cs) //when model binding fails var postFromRepo = await _postRepository.GetPostAsync(id); if (postFromRepo == null) { return(NotFound()); } //fetch the user id from the JWT via HttpContext. Then get the user from the repository. This is to ensure that an authorized user //is calling the API with a valid user id var user = await _userRepository.GetUserAsync(User.GetUserId()); //check if the user is an administrator or owner of the object var isAdmin = User?.IsAdministrator() ?? false; var userIsAdminOrOwner = isAdmin ? isAdmin : (user?.Id != postFromRepo.UserId ? false : true); if (!userIsAdminOrOwner) { //returning status code instead of Forbid() as forbid only works with authentication handlers return(StatusCode(403, new { Error = "You cannot modify other users submissions unless you are an administrator." })); } _mapper.Map(postToUpdate, postFromRepo); //map fields from PostUpdateDto to Post that was fetched from repository _postRepository.UpdatePost(postFromRepo); //Call to empty method. This is just for information and is not required if (!await _postRepository.SaveChangesAsync()) { throw new Exception($"Error updating Post {postFromRepo.Id} to the database"); } return(NoContent()); }
public async Task <IActionResult> EditPost(int id, PostUpdateDto postUpdateDto) { try { var postToUpdate = await _postService.GetPostById(id); if (postToUpdate == null) { throw new ArgumentNullException("Invalid request"); } else { _mapper.Map(postUpdateDto, postToUpdate); await _postService.UpdatePostInDatabase(postToUpdate); return(NoContent()); } } catch (Exception ex) { Console.WriteLine(ex.Message); return(StatusCode(StatusCodes.Status500InternalServerError)); } }
public Task <PostDto> UpdateAsync(PostUpdateDto updateDto) { throw new NotImplementedException(); }
public Task <PostWithDetailDto> UpdateAsync(Guid id, PostUpdateDto input) { return(_postAppService.UpdateAsync(id, input)); }
public void UpdatePost(PostUpdateDto postUpdateDto) { _postService.Update(postUpdateDto); }