public async Task <IActionResult> Edit(string id)
{
var entity = await _postManager.FindByIdAsync(id);
if (entity == null)
{
return(NotFound());
}
var model = entity.ToModel();
PrepareViewModel(model, entity);
return(View(model));
}
public async Task <IViewComponentResult> InvokeAsync(string postId)
{
if (string.IsNullOrEmpty(postId))
{
return(Content("Not found."));
}
var post = await _postManager.FindByIdAsync(postId);
if (post == null)
{
return(Content("Not found."));
}
var postViewModel = post.ToModel();
postViewModel.EnableComment = postViewModel.EnableComment && _commentsSettings.EnableComments;
var comments = await _commentManager.GetCommentsByPostId(postId, true);
var commentModels = comments.Select(t => t.ToModel(post.EnableComment && _commentsSettings.EnableComments && _commentsSettings.CommentNestingEnabled)).ToList();
var results = commentModels.Format();
var form = new CommentFormViewModel()
{
PostId = post.Id
};
LoadLastCommentFormUser(form);
return(View(new Tuple <PostViewModel, IList <CommentViewModel>, CommentFormViewModel>(postViewModel, results, form)));
}
public async Task <IActionResult> AddComment(CommentFormViewModel model)
{
if (!_commentsSettings.EnableComments)
{
return(Json(new { result = false, message = "Comment Not Allowed! " })); //ReturnCommentResult(null, new { result = false });
}
if (string.IsNullOrEmpty(model.PostId))
{
return(Json(new { result = false, message = "Error" })); //return ReturnCommentResult(null, new { result = false });
}
var post = await _postManager.FindByIdAsync(model.PostId);
if (post == null)
{
return(Json(new { result = false, message = "Error" }));
}
if (ModelState.IsValid)
{
var comment = new Comment()
{
Author = model.Author,
Content = model.Content,
Website = model.Website,
Email = model.Email,
ParentId = model.ParentId,
PostId = post.Id,
};
var httpFeatures = HttpContext.Features.Get <IHttpConnectionFeature>();
comment.IP = httpFeatures.LocalIpAddress == null ? null : httpFeatures.LocalIpAddress.ToString();
comment.IsApproved = !_commentsSettings.EnableCommentsModeration;
if (_commentsSettings.TrustAuthenticatedUsers)
{
bool isTrust = await _commentManager.IsTrustUserAsync(comment.Email);
comment.IsApproved = isTrust;
}
await _commentManager.CreateAsync(comment);
await _postManager.IncreaseCommentsCountAsync(post.Id);
SaveCommentFormUser(new LastCommentFormUserInfo()
{
Author = model.Author, Email = model.Email, Website = model.Website
});
return(Json(new { result = true, commentId = comment.Id, parentId = comment.ParentId, url = Url.RouteUrl("Comment", new { commentId = comment.Id }) }));
//return ReturnCommentResult(post, new { result = true, comment = comment.ToModel() });
}
return(Json(new { result = false, message = string.Join(" ", ModelState.Values.SelectMany(t => t.Errors.Select(e => e.ErrorMessage))) }));
}
protected async Task PrepareViewModel(CommentViewModel model, Comment entity)
{
if (entity.Post != null)
{
model.Post = entity.Post.ToModel();
}
else
{
var post = await _postManager.FindByIdAsync(model.PostId);
if (post != null)
{
model.Post = post.ToModel();
}
}
}
/// <summary>
/// metaWeblog.editPost method
/// </summary>
/// <param name="postId">
/// post guid in string format
/// </param>
/// <param name="userName">
/// login username
/// </param>
/// <param name="password">
/// login password
/// </param>
/// <param name="sentPost">
/// struct with post details
/// </param>
/// <param name="publish">
/// mark as published?
/// </param>
/// <returns>
/// 1 if successful
/// </returns>
internal async Task <bool> EditPost(string postId, string userName, string password, MWAPost sentPost, bool publish)
{
var currentUser = await GetVerifyUserAsync(userName, password);
//if (!_permissionChecker.IsValid(currentUser, PermissionKeys.PostEdit))
//{
// throw new MetaWeblogException("11", "User authentication failed");
//}
var post = await _postManager.FindByIdAsync(postId);
string author = String.IsNullOrEmpty(sentPost.author) ? userName : sentPost.author;
var authorUser = await _userManager.FindByEmailAsync(author);
if (authorUser != null)
{
post.UserId = authorUser.Id;
}
post.Title = sentPost.title;
post.Content = sentPost.description;
post.IsDraft = !publish;
post.Slug = sentPost.slug;
post.Description = sentPost.excerpt;
if (sentPost.postDate != new DateTime())
{
post.PublishedTime = sentPost.postDate;
}
if (sentPost.commentPolicy != string.Empty)
{
post.EnableComment = sentPost.commentPolicy == "1";
}
post.Categories.Clear();
foreach (var item in sentPost.categories.Where(c => c != null && c.Trim() != string.Empty))
{
Category cat;
if (LookupCategoryGuidByName(item, out cat))
{
post.Categories.Add(new PostCategory()
{
CategoryId = cat.Id, PostId = post.Id
});
}
else
{
// Allowing new categories to be added. (This breaks spec, but is supported via WLW)
var newcat = new Category()
{
Name = item,
DisplayOrder = 1,
};
post.Categories.Add(new PostCategory()
{
Category = newcat, PostId = post.Id
});
}
}
post.Tags.Clear();
foreach (var item in sentPost.tags.Where(item => item != null && item.Trim() != string.Empty))
{
var tag = await _tagsManager.CreateOrUpdateAsync(item);
post.Tags.Add(new PostTags()
{
TagsId = tag.Id, PostId = post.Id
});
}
await _postManager.UpdateAsync(post);
return(true);
}
