コード例 #1
0
        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));
        }
コード例 #2
0
        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)));
        }
コード例 #3
0
        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))) }));
        }
コード例 #4
0
        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();
                }
            }
        }
コード例 #5
0
        /// <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);
        }