public async Task <IActionResult> Put([FromBody] UpdatePost command) { command.BlogId = BlogId; await _mediator.SendAndPublishAsync <UpdatePost, Post>(command); return(new NoContentResult()); }
public async Task <TypedResult <PostDTO> > Update(UpdatePost post) { try { if (post.Id.Equals(Guid.Empty)) { throw new InvalidOperationException(ErrorMessages.ID_IS_REQUIRED); } Post existsRecord = await postRepo.FindById( post.Id, includes : $"{nameof(PostCategory)},{nameof(Address)},{nameof(Address)}.{nameof(RegionCity)}" ); if (existsRecord == null) { throw new InvalidOperationException(ErrorMessages.THIS_RECORD_DOES_NOT_EXISTS); } existsRecord = _mapper.Map <UpdatePost, Post>(post, existsRecord); Post result = await postRepo.Update(existsRecord); return(new TypedResult <PostDTO>(_mapper.Map <PostDTO>(result))); } catch (Exception ex) { return(new TypedResult <PostDTO>(ex)); } }
public bool UpdatePost(UpdatePost model) { try { using (var ctx = new ApplicationDbContext()) { var entity = ctx .Posts .SingleOrDefault(e => e.Id == model.Id && e.OwnerId == _userId); entity.Content = model.Content; entity.Edited = true; return(ctx.SaveChanges() == 1); } } catch (NullReferenceException) { return(false); } catch (ArgumentNullException) { return(false); } }
public async Task <IActionResult> UpdateAsync([FromBody] UpdatePost updatedPost, string adminComment = "") { try { if (!updatedPost.Author.IsAuthor(User)) { return(Unauthorized()); } if (User.IsAdmin()) { await _postService.UpdateByAdminAsync(updatedPost.Id, updatedPost.Title, updatedPost.Content, User.GetUserId(), adminComment); } await _postService.UpdateAsync(updatedPost.Id, updatedPost.Title, updatedPost.Content); return(Ok()); } catch (Exception e) { _logger.LogError($"Returning exception: {e.Message}"); return(Json(new ExceptionDto { Error = e.Message })); } }
public void Setup() { _post = PostFactories.Post(); _command = PostFactories.UpdatePostCommand(); _validatorMock = new Mock <IValidator <UpdatePost> >(); _validatorMock.Setup(x => x.Validate(_command)).Returns(new ValidationResult()); _post.Update(_command, _validatorMock.Object); _event = _post.Events.OfType <PostUpdated>().Single(); }
public async Task <IActionResult> Put(int id, [FromBody] UpdatePost model) { var entity = model.MapEntity(model, await _postService.GetAuthorId(model.AuthorUsername)); entity.Id = id; var createdResult = await _postService.UpdatePostAsync(entity); return(new JsonResult(createdResult)); }
public async Task <IActionResult> Put([FromBody] UpdatePost model) { var result = await postServices.Update(model); if (result.Status) { return(Ok(result)); } return(BadRequest(result)); }
public IActionResult UpdatePost([FromBody] JObject data, string UpdatePostAction) { string ConnStr = GetDbConnString(); UpdatePost updatePost = data["UpdatePostData"].ToObject <UpdatePost>(); string Sql = ""; var Variables = new { NewPostContent = "", PostGuid = "", DisableSharing = "", DisableComments = "" }; if (UpdatePostAction == "UpdatePost") { Sql = @"Update SM_Posts set PostContent = @NewPostContent where PostGuid = @PostGuid"; Variables = new { NewPostContent = updatePost.PostContent, PostGuid = updatePost.PostGuid, DisableSharing = "", DisableComments = "" }; } else if (UpdatePostAction == "DisableSharing") { Sql = @"Update SM_posts set DisableSharing = @DisableSharing where PostGuid = @PostGuid"; Variables = new { NewPostContent = "", PostGuid = updatePost.PostGuid, DisableSharing = updatePost.DisableSharing, DisableComments = "" }; } else if (UpdatePostAction == "DisableComments") { Sql = @"Update SM_posts set DisableComments = @DisableComments where PostGuid = @PostGuid"; Variables = new { NewPostContent = "", PostGuid = updatePost.PostGuid, DisableSharing = "", DisableComments = updatePost.DisableComments }; } using (IDbConnection db = new SqlConnection(ConnStr)) { int result = db.Execute(Sql, Variables); } return(Ok()); }
public async Task <IActionResult> Put([FromBody] UpdatePost model) { Guid userId = HttpContext.CurrentUserId(); var result = await postServices.Update(userId, model); if (result.Status) { return(Ok(result)); } return(BadRequest(result)); }
public void Validate_ValidUpdatePost_SuccessfullyValidates() { var update = new UpdatePost { Content = "This is a test" }; var context = new ValidationContext(update); var result = Validator.TryValidateObject(update, context, null, true); Assert.True(result); }
public async Task <IActionResult> EditComment(UpdatePost updatepost) { var post = await dc.Posts.FirstOrDefaultAsync(a => a.Id == updatepost.Id); post.Title = updatepost.newTitle; post.Description = updatepost.newDescription; dc.Posts.Update(post); await dc.SaveChangesAsync(); return(Ok(post)); }
public void Validate_UpdatePost_MustHaveContent() { var update = new UpdatePost(); var context = new ValidationContext(update) { MemberName = nameof(update.Content) }; var result = Validator.TryValidateProperty(update.Content, context, null); Assert.False(result); }
public static PostUpdated ToEvent(this UpdatePost command) { return(new PostUpdated { AggregateRootId = command.AggregateRootId, Title = command.Title, Slug = command.Slug, Excerpt = command.Excerpt, Content = command.Content, Tags = command.Tags, Type = command.Type, Status = command.Status }); }
public async Task <IActionResult> UpdatePost([FromForm] UpdatePost input) { try { await _postAppService.UpdatePost(input); return(Ok("Created Tenant")); } catch (Exception e) { Console.WriteLine(e); throw; } }
public async Task <int> UpdatePostAsync(UpdatePost updatePost) { int affectedRows; var query = $@"UPDATE juniro.posts SET Description = '{updatePost.Description}', PostTtile = '{updatePost.PostTtile}' WHERE Id = {updatePost.Id} AND UserId = '{updatePost.UserId}';"; using (var connection = new MySqlConnection(_connectionString)) { affectedRows = await connection.ExecuteAsync(query, new { updatePost }); } return(affectedRows); }
public async Task UpdatePost_NotExistingCategory_ShouldReturnBadRequest() { var id = GuidHelper.GetGuidFromInt(1); var command = new UpdatePost { CategoryId = GuidHelper.GetGuidFromInt(123), Title = " title ", Content = " content ", }; var payload = GetPayload(command); var response = await Client.PutAsync($"{BaseUrl}/{id}", payload); response.StatusCode.Should().Be(HttpStatusCode.BadRequest); }
public void HandleAsync_ShouldInvokeSpecificMethods() { var command = new UpdatePost { ResourceId = Guid.NewGuid(), Title = "title", Content = "content", CategoryId = Guid.NewGuid() }; _handler.Invoking(async x => await x.HandleAsync(command)) .Should() .NotThrow(); _postService.Verify(x => x.UpdateAsync(command.ResourceId, command.Title, command.Content, command.CategoryId), Times.Once); _eventPublisher.Verify(x => x.PublishAsync(It.IsAny <PostUpdated>()), Times.Once); }
public async Task UpdatePost(UpdatePost input) { var post = await _postRepository.GetByIdAsync(input.Id); post.Title = input.Title; post.ShortDescription = input.ShortDescription; post.Content = input.Content; post.CategoryId = input.CategoryId; if (input.ImageFile != null) { var imagePath = await _blobService.InsertFile(input.ImageFile); post.ImagePath = imagePath; } await _postRepository.UpdateAsync(post); }
public IHttpActionResult Put(UpdatePost post) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var service = CreatePostService(); if (service == null) { return(BadRequest()); } if (!service.UpdatePost(post)) { return(InternalServerError()); } return(Ok()); }
IEnumerator RestNetworkUpdate() { string playerId = PlayerPrefs.GetString(PrefKeys.playerID); int bestScore = PlayerPrefs.GetInt(PrefKeys.bestScore); string playerName = PlayerPrefs.GetString(PrefKeys.playerName); UpdatePost updateBody = new UpdatePost(playerId, playerName, bestScore); string body = JsonUtility.ToJson(updateBody); string updateEndpoint = "https://el6rwisdci.execute-api.us-east-1.amazonaws.com/dev/score"; using (UnityWebRequest webRequest = UnityWebRequest.Post(updateEndpoint, body)) { webRequest.SetRequestHeader("Content-Type", "application/json"); byte[] bodyRaw = System.Text.Encoding.UTF8.GetBytes(body); webRequest.uploadHandler = (UploadHandler) new UploadHandlerRaw(bodyRaw); webRequest.downloadHandler = (DownloadHandler) new DownloadHandlerBuffer(); webRequest.SetRequestHeader("Content-Type", "application/json"); yield return(webRequest.SendWebRequest()); Debug.Log(webRequest.downloadHandler.text); } }
public async Task <Post> Handle(UpdatePost request, CancellationToken cancellationToken) { try { var result = this.context.Posts.FirstOrDefaultAsync(p => p.Id == request.Id); var post = result.Result; post.Title = request.Title != null ? request.Title : post.Title; post.Body = request.Body != null ? request.Body : post.Body; post.Date = request.Date != null ? request.Date : post.Date; await context.SaveChangesAsync(); return(await result); } catch (Exception) { return(await Task.FromResult(new Post {})); } }
public async Task <IActionResult> Update([FromRoute] Guid postId, [FromBody] UpdatePost postToUpdate) { var userOwnsPost = await _postService.UserOwnsPostAsync(postId, this.HttpContext.GetUserId()); if (userOwnsPost == false) { return(BadRequest(new { Error = "You are not allowed to update this post." })); } var post = new Post { Id = postId, Name = postToUpdate.Name }; if (await _postService.UpdatePostAsync(post)) { return(Ok(_mapper.Map <PostResponse>(post))); } return(NotFound()); }
public async Task UpdatedPostShouldBeUpdated() { var response = await CreateNewPost(); var post = await GetPostAsync(response.Headers.Location.ToString()); string updatedPostTitle = GetRandomTextAsync(); string updatedPostContent = GetRandomTextAsync(); var postUpdatePayload = new UpdatePost { Id = post.Id, Author = post.Author.Id, Title = updatedPostTitle, Content = updatedPostContent }; var payload = GetPayload(postUpdatePayload); await Client.PutAsync("posts", payload); var updatedPost = await GetPostAsync(response.Headers.Location.ToString()); Assert.Equal(updatedPostContent, updatedPost.Content); }
public async Task Update_EverythingOk_UpdatesPost() { var oldPost = new Post(); var update = new UpdatePost(); var post = new Post { Content = "Content" }; const string userId = "User id"; A.CallTo(() => User.Is(post.UserId)).Returns(true); A.CallTo(() => User.Id()).Returns(userId); A.CallTo(() => PostRepository.Read(1)).Returns(oldPost); A.CallTo(() => Mapper.Map(update, oldPost)) .Returns(post); await PostService.Update(1, update); A.CallTo(() => PostRepository.Update(A <Post> .That.Matches(p => p.Content == post.Content && p.UserId == userId ))).MustHaveHappenedOnceExactly(); }
public async Task UpdatePost_ExistingPost_ShouldSuccess() { var id = GuidHelper.GetGuidFromInt(1); var command = new UpdatePost { CategoryId = GuidHelper.GetGuidFromInt(1), Title = " title ", Content = " content ", }; var payload = GetPayload(command); var response = await Client.PutAsync($"{BaseUrl}/{id}", payload); response.StatusCode.Should().Be(HttpStatusCode.NoContent); var result = await GetResourceAsync <PostDto>($"{BaseUrl}/{id}"); result.Response.StatusCode.Should().Be(HttpStatusCode.OK); result.Data.Title.Should().Be("title"); result.Data.Content.Should().Be("content"); result.Data.CategoryId.Should().Be(GuidHelper.GetGuidFromInt(1)); }
public async Task Setup() { _post = PostFactories.Post(); _command = PostFactories.UpdatePostCommand(); _validatorMock = new Mock <IValidator <UpdatePost> >(); _validatorMock.Setup(x => x.Validate(_command)).Returns(new ValidationResult()); _postRepositoryMock = new Mock <IPostRepository>(); _postRepositoryMock .Setup(x => x.GetByIdAsync(_command.BlogId, _command.AggregateRootId)) .ReturnsAsync(_post); _postRepositoryMock .Setup(x => x.UpdateAsync(It.IsAny <Post>())) .Callback <Post>(p => _updatedPost = p) .Returns(Task.CompletedTask); _commandHandler = new UpdatePostHandler(_postRepositoryMock.Object, _validatorMock.Object); _result = await _commandHandler.HandleAsync(_command); _event = _updatedPost.Events.OfType <PostUpdated>().Single(); }
public async Task Update_Unauthorized_DoesNotUpdatePost() { var oldPost = new Post(); var update = new UpdatePost(); var post = new Post { Content = "Content" }; const string userId = "User id"; A.CallTo(() => User.Is(post.UserId)).Returns(false); A.CallTo(() => User.Id()).Returns(userId); A.CallTo(() => PostRepository.Read(1)).Returns(oldPost); A.CallTo(() => Mapper.Map(update, oldPost)) .Returns(post); var newPost = await PostService.Update(1, update); A.CallTo(() => PostRepository.Update(A <Post> .That.Matches(p => p.Content == post.Content && p.UserId == userId ))).MustNotHaveHappened(); Assert.Null(newPost); }
public async Task <UpdatePostResponse> Put(UpdatePost request) { var user = GetUser(); var post = await AssertPostAsync(request.Id); AssertCanPostToOrganization(Db, request.OrganizationId, user, out var org, out var orgMember); AssertCanPostTypeToOrganization(request.Type, org, orgMember, user); AssertCanUpdatePost(post, user, orgMember); if (post.Content != request.Content) { post.ContentHtml = await Markdown.TransformAsync(request.Content, user.GetGitHubToken()); } if (!user.IsOrganizationModerator(orgMember)) { request.Labels = post.Labels; } post.PopulateWith(request); post.ModifiedBy = user.UserName; post.Modified = DateTime.Now; post.Rank = 0; if (Request.Files.Length > 0) { post.ImageUrl = Request.Files[0].UploadToImgur(AppSettings.GetString("oauth.imgur.ClientId"), nameof(post.ImageUrl), minWidth: 200, minHeight: 200, maxWidth: 4000, maxHeight: 4000); } await Db.UpdateAsync(post); ClearPostCaches(); return(new UpdatePostResponse()); }
public async Task <Post> Update(int postId, UpdatePost update) { var oldPost = await _postRepository.Read(postId); if (oldPost == null) { _logger.LogWarning($"Post {postId} does not exist"); return(null); } _logger.LogInformation($"Updating post {JsonConvert.SerializeObject(update)}"); if (!_userService.Is(oldPost.UserId)) { _logger.LogWarning("User not authorized"); return(null); } var post = _mapper.Map(update, oldPost); post.UserId = _userService.Id(); await _postRepository.Update(post); return(post); }
public void Map_FromUpdatePostToPost_MapsAllPropertiesFromSourceAndUpdatesUpdatedAt() { var yesterday = DateTime.Today.AddDays(-1); var oldPost = new Post { Id = 1, UserId = "User id", Content = "This is an old description", CreatedAt = yesterday, UpdatedAt = yesterday }; var update = new UpdatePost { Content = "This is an updated description" }; var post = Mapper.Map(update, oldPost); Assert.Equal(oldPost.Id, post.Id); Assert.Equal(oldPost.UserId, post.UserId); Assert.Equal(update.Content, post.Content); Assert.Equal(yesterday, post.CreatedAt); Assert.True(yesterday < post.UpdatedAt, "oldPost.UpdatedAt < post.UpdatedAt"); }