示例#1
0
        public List<PostWrapped> Wrap(List<Guid> postIds, User currentUser = null)
        {
            var posts = new List<PostWrapped>();
            foreach (var postId in postIds)
            {
                var post = _postDao.GetPostById(postId);
                if (post != null)
                    posts.Add(new PostWrapped(post));
            }

            var authors = _membershipService.GetUsersByIds(posts.Select(x => x.Post.UserId).Distinct().ToList()).ToDictionary(x => x.Id, x => x);
            var subs = _subDao.GetSubsByIds(posts.Select(x => x.Post.SubId).Distinct().ToList()).ToDictionary(x => x.Id, x => x);

            var likes = currentUser != null ? _voteDao.GetVotesOnPostsByUser(currentUser.Id, postIds) : new Dictionary<Guid, VoteType>();

            foreach (var item in posts)
            {
                item.Author = authors.ContainsKey(item.Post.UserId) ? authors[item.Post.UserId] : null;
                item.Sub = subs.ContainsKey(item.Post.SubId) ? subs[item.Post.SubId] : null;
                if (currentUser != null)
                    item.CurrentUserVote = likes.ContainsKey(item.Post.Id) ? likes[item.Post.Id] : (VoteType?)null;
            }

            return posts;
        }
        public void Can_build_node_sorted()
        {
            // arrange
            var sub = new Sub();
            sub.Id = GuidUtil.NewSequentialId();
            sub.Name = "test";
            var author = new User();
            author.Id = GuidUtil.NewSequentialId();
            author.UserName = "******";
            var comments = ConvertTestNodesToComments(new List<TestNodeTreeSorted>
            {
                TestNodeTreeSorted.Create(10,
                    TestNodeTreeSorted.Create(5),
                    TestNodeTreeSorted.Create(4,
                        TestNodeTreeSorted.Create(2),
                        TestNodeTreeSorted.Create(20))),
                TestNodeTreeSorted.Create(9,
                    TestNodeTreeSorted.Create(3,
                        TestNodeTreeSorted.Create(1)),
                    TestNodeTreeSorted.Create(12))
            });
            foreach (var comment in comments)
            {
                comment.SubId = sub.Id;
                comment.AuthorUserId = author.Id;
            }
            SetupComments(comments);
            _membershipService.Setup(x => x.GetUsersByIds(It.IsAny<List<Guid>>())).Returns(new List<User> {author});
            _subDao.Setup(x => x.GetSubsByIds(It.IsAny<List<Guid>>())).Returns(new List<Sub> {sub});

            // act
            var tree = _commentTreeBuilder.GetCommentTree(Guid.Empty);
            var treeContext = _commentTreeContextBuilder.Build(tree,
                comments.ToDictionary(x => x.Id, x => (double) x.SortConfidence));
            var nodes = _commentNodeHierarchyBuilder.Build(tree, treeContext, null);

            //assert
            Assert.That(nodes, Has.Count.EqualTo(2));
            Assert.That(nodes[0].As<CommentNode>().Comment.Comment.SortConfidence, Is.EqualTo(10));
            Assert.That(nodes[0].As<CommentNode>().Children, Has.Count.EqualTo(2));
            Assert.That(nodes[0].As<CommentNode>().Children[0].As<CommentNode>().Comment.Comment.SortConfidence, Is.EqualTo(5));
            Assert.That(nodes[0].As<CommentNode>().Children[1].As<CommentNode>().Comment.Comment.SortConfidence, Is.EqualTo(4));
            Assert.That(nodes[0].As<CommentNode>().Children[1].Children, Has.Count.EqualTo(2));
            Assert.That(nodes[0].As<CommentNode>().Children[1].Children[0].As<CommentNode>().Comment.Comment.SortConfidence, Is.EqualTo(20));
            Assert.That(nodes[0].As<CommentNode>().Children[1].Children[1].As<CommentNode>().Comment.Comment.SortConfidence, Is.EqualTo(2));
            Assert.That(nodes[1].As<CommentNode>().Comment.Comment.SortConfidence, Is.EqualTo(9));
            Assert.That(nodes[1].As<CommentNode>().Children, Has.Count.EqualTo(2));
            Assert.That(nodes[1].As<CommentNode>().Children[0].As<CommentNode>().Comment.Comment.SortConfidence, Is.EqualTo(12));
            Assert.That(nodes[1].As<CommentNode>().Children[1].As<CommentNode>().Comment.Comment.SortConfidence, Is.EqualTo(3));
            Assert.That(nodes[1].As<CommentNode>().Children[1].Children, Has.Count.EqualTo(1));
            Assert.That(nodes[1].As<CommentNode>().Children[1].Children[0].As<CommentNode>().Comment.Comment.SortConfidence, Is.EqualTo(1));
        }
示例#3
0
        public List<CommentWrapped> Wrap(List<Guid> commentIds, User currentUser = null)
        {
            var result = new List<CommentWrapped>();
            foreach (var commentId in commentIds)
            {
                var comment = _commentDao.GetCommentById(commentId);
                if (comment != null)
                    result.Add(new CommentWrapped(comment));
            }

            var authors = _membershipService.GetUsersByIds(result.Select(x => x.Comment.AuthorUserId).Distinct().ToList()).ToDictionary(x => x.Id, x => x);
            var subs = _subDao.GetSubsByIds(result.Select(x => x.Comment.SubId).Distinct().ToList()).ToDictionary(x => x.Id, x => x);
            var posts = result.Select(x => x.Comment.PostId).Distinct().Select(x => _postDao.GetPostById(x)).Where(x => x != null).ToDictionary(x => x.Id, x => x);

            var userCanModInSubs = new List<Guid>();

            if (currentUser != null)
                foreach (var sub in subs.Values)
                    // TODO: Check for a specific permission "ban".
                    if (_permissionDao.CanUserModerateSub(currentUser.Id, sub.Id))
                        userCanModInSubs.Add(sub.Id);

            var likes = currentUser != null ? _voteDao.GetVotesOnCommentsByUser(currentUser.Id, commentIds) : new Dictionary<Guid, VoteType>();

            foreach (var item in result)
            {
                item.Author = authors.ContainsKey(item.Comment.AuthorUserId) ? authors[item.Comment.AuthorUserId] : null;
                item.CurrentUserVote = likes.ContainsKey(item.Comment.Id) ? likes[item.Comment.Id] : (VoteType?)null;
                item.Sub = subs.ContainsKey(item.Comment.SubId) ? subs[item.Comment.SubId] : null;
                item.Score = item.Comment.VoteUpCount - item.Comment.VoteDownCount;
                item.Post = posts.ContainsKey(item.Comment.PostId) ? posts[item.Comment.PostId] : null;

                var userCanMod = item.Sub != null && userCanModInSubs.Contains(item.Sub.Id);

                if ((item.Author != null && currentUser != null) && currentUser.Id == item.Author.Id)
                    item.CurrentUserIsAuthor = true;

                item.CanDelete = userCanMod || item.CurrentUserIsAuthor;
                item.CanEdit = item.CurrentUserIsAuthor;
            }

            return result;
        }
示例#4
0
        public List<SubWrapped> Wrap(List<Guid> subIds, User currentUser = null)
        {
            var subs = new List<SubWrapped>();
            foreach (var subId in subIds)
            {
                var sub = _subDao.GetSubById(subId);
                if (sub != null)
                    subs.Add(new SubWrapped(sub));
            }

            var subscribed = currentUser != null ? _subDao.GetSubscribedSubsForUser(currentUser.Id) : new List<Guid>();

            foreach (var item in subs)
            {
                if (currentUser != null)
                    item.IsSubscribed = subscribed.Contains(item.Sub.Id);
            }

            return subs;
        }
示例#5
0
 public CommentWrapped Wrap(Guid commentId, User currentUser = null)
 {
     return Wrap(new List<Guid> {commentId}, currentUser)[0];
 }
示例#6
0
 public PostWrapped Wrap(Guid postId, User currentUser = null)
 {
     return Wrap(new List<Guid> {postId}, currentUser)[0];
 }
        public List<ICommentNode> Build(CommentTree tree, CommentTreeContext treeContext, User currentUser)
        {
            var wrapped = _commentWrapper.Wrap(treeContext.Comments, currentUser).ToDictionary(x => x.Comment.Id, x => new CommentNode(x));
            var final = new List<ICommentNode>();
            var walked = new List<Guid>();

            // lets mark any comments as collapsed if needed
            foreach (var comment in wrapped.Values)
            {
                // TODO: make this configurable per-user
                int minimumScore = 0;
                if ((comment.Comment.Author != null && currentUser != null) && currentUser.Id == comment.Comment.Author.Id)
                {
                    // the current user is the author, don't collapse!
                    comment.Collapsed = false;
                }
                else if (comment.Comment.Score < minimumScore)
                {
                    // too many down votes to show to the user
                    comment.Collapsed = true;
                }
                else
                {
                    // the current user is not the author, and we have enough upvotes to display,
                    // don't collapse
                    comment.Collapsed = false;
                }
            }

            foreach (var comment in wrapped.Values)
            {
                comment.NumberOfChildren = treeContext.CommentsChildrenCount[comment.Comment.Comment.Id];

                CommentNode parent = null;

                if (comment.Comment.Comment.ParentId.HasValue)
                    parent = wrapped.ContainsKey(comment.Comment.Comment.ParentId.Value)
                        ? wrapped[comment.Comment.Comment.ParentId.Value]
                        : null;

                if (comment.Comment.Comment.ParentId.HasValue && treeContext.Comments.Contains(comment.Comment.Comment.ParentId.Value))
                    comment.IsParentVisible = true;

                if (parent != null && comment.Comment.CurrentUserIsAuthor)
                {
                    // this comment is the current user, so lets walk the parents
                    // and uncollapse any comments which may be collapsed
                    var ancestor = parent;
                    while (ancestor != null && !walked.Contains(ancestor.Comment.Comment.Id))
                    {
                        ancestor.Collapsed = false;
                        walked.Add(ancestor.Comment.Comment.Id);
                        ancestor = (ancestor.Comment.Comment.ParentId.HasValue && wrapped.ContainsKey(comment.Comment.Comment.ParentId.Value))
                            ? wrapped[comment.Comment.Comment.ParentId.Value]
                            : null;
                    }
                }

                if (treeContext.MoreRecursion.Contains(comment.Comment.Comment.Id))
                    comment.Children.Add(new MoreRecursionNode(comment.Comment));

                if (parent != null)
                {
                    comment.Parent = comment.Comment;
                    parent.Children.Add(comment);
                }
                else
                {
                    if (comment.Comment.Comment.ParentId.HasValue)
                    {
                        // we don't have a parent here, but this comment does have a parent.
                        // we need to get it
                        comment.Parent = _commentWrapper.Wrap(comment.Comment.Comment.ParentId.Value);
                    }
                    final.Add(comment);
                }
            }

            foreach (var visibleId in wrapped.Keys)
            {
                // this item is already scheduled to have a new link to see all the children
                if (treeContext.MoreRecursion.Contains(visibleId)) continue;

                var children = tree.Tree.ContainsKey(visibleId) ? tree.Tree[visibleId] : new List<Guid>();
                var missingChildren = children.Where(x => !treeContext.Comments.Contains(x)).ToList();

                if (missingChildren.Count > 0)
                {
                    var visibleChildren = children.Where(x => treeContext.Comments.Contains(x)).ToList();
                    var visibleCount = visibleChildren.Sum(x => (treeContext.CommentsChildrenCount[x]) + 1);
                    var missingCount = treeContext.CommentsChildrenCount[visibleId] - visibleCount;
                    var missingDepth = (tree.Depth.ContainsKey(visibleId) ? tree.Depth[visibleId] : 0) + 1 -
                                       treeContext.OffsetDepth;

                    var moreChildren = new MoreChildren();
                    moreChildren.ChildComments.AddRange(missingChildren);
                    moreChildren.MissingCount = missingCount;
                    moreChildren.PostId = tree.PostId;
                    moreChildren.Sort = treeContext.Sort;
                    moreChildren.Depth = missingDepth;
                    wrapped[visibleId].Children.Add(moreChildren);
                }
            }

            if (treeContext.TopLevelCandidates.Count > 0)
            {
                var moreChildren = new MoreChildren();
                moreChildren.ChildComments.AddRange(treeContext.TopLevelCandidates);
                moreChildren.MissingCount = moreChildren.ChildComments.Sum(x => (treeContext.CommentsChildrenCount.ContainsKey(x) ? treeContext.CommentsChildrenCount[x] : 0) + 1);
                moreChildren.PostId = tree.PostId;
                moreChildren.Sort = treeContext.Sort;
                moreChildren.Depth = 0;
                final.Add(moreChildren);
            }

            return final;
        }
示例#8
0
        /// <summary>
        /// Validate the user (update or insert)
        /// </summary>
        /// <param name="user"></param>
        /// <returns></returns>
        public UserValidationResult ValidateUser(User user)
        {
            var result = UserValidationResult.Success;

            if (!IsUserNameValid(user.UserName))
                result |= result | UserValidationResult.InvalidUserName;
            if (!IsEmailValid(user.Email))
                result |= UserValidationResult.InvalidEmail;

            if (result != UserValidationResult.Success) return result;

            if (!CanChangedEmail(user.Id, user.Email))
                result |= UserValidationResult.EmailInUse;

            if (user.Id == Guid.Empty)
            {
                // we are inserting this user, let's see if any user has this username
                if (GetUserByUserName(user.UserName) != null)
                    result |= UserValidationResult.UserNameInUse;
            }
            else
            {
                // we are updating the user, make sure the user name wasn't changed
                var dbUser = GetUserByUserName(user.UserName);
                if (dbUser != null)
                    if (dbUser.Id != user.Id)
                        result |= UserValidationResult.CantChangeUsername;
            }

            return result;
        }
示例#9
0
        public bool UpdateUser(User user)
        {
            if (user.Id == Guid.Empty)
                throw new Exception("You cannot update a user that doesn't have a user id");

            return _conn.Perform(conn => conn.Update(user) == 1);
        }
示例#10
0
        public bool InsertUser(User user)
        {
            if (user.Id != Guid.Empty)
                throw new Exception("You cannot insert a user with an existing user id");

            user.Id = GuidUtil.NewSequentialId();
            user.CreatedDate = Common.CurrentTime();
            return _conn.Perform(conn => conn.Insert(user) == 1);
        }
示例#11
0
 public SubWrapped Wrap(Guid subId, User currentUser = null)
 {
     return Wrap(new List<Guid> {subId})[0];
 }