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");
}
