public ActionResult User(string userName)
{
ViewBag.NavigationKey = "overview";
var model = BuildUserModel(userName);
var latestComments = _commentDao.GetCommentsForUser(model.User.Id,
sortBy: CommentSortBy.New,
timeFilter: CommentsTimeFilter.All,
skip: 0,
take: 3);
model.Comments = new PagedList <CommentWrapped>(
_commentWrapper.Wrap(latestComments, _userContext.CurrentUser),
0,
5,
true);
var latestPosts = _postDao.GetPosts(
userId: model.User.Id,
sortby: PostsSortBy.New,
timeFilter: PostsTimeFilter.All,
nsfw: _userContext.CurrentNsfw,
skip: 0,
take: 3);
model.Posts = new PagedList <PostWrapped>(
_postWrapper.Wrap(latestPosts, _userContext.CurrentUser),
0,
5,
true);
return(View(model));
}
public ActionResult ReportedPosts(string subName)
{
ViewBag.ManageNavigationKey = "reportedposts";
if (string.IsNullOrEmpty(subName))
{
throw new NotFoundException();
}
var sub = _subDao.GetSubByName(subName);
if (sub == null)
{
throw new NotFoundException();
}
if (!_permissionDao.CanUserManageSubPosts(_userContext.CurrentUser, sub.Id))
{
throw new UnauthorizedException();
}
var postIds = _postDao.GetReportedPosts(new List <Guid> {
sub.Id
}, take: 30);
var model = new ReportedPostsViewModel();
model.Sub = sub;
model.Posts = new PagedList <PostWrapped>(_postWrapper.Wrap(postIds, _userContext.CurrentUser), 0, 30, postIds.HasMore);
return(View(model));
}
public ActionResult Unmoderated(string subName)
{
if (string.IsNullOrEmpty(subName))
{
throw new NotFoundException();
}
var sub = _subDao.GetSubByName(subName);
if (sub == null)
{
throw new NotFoundException();
}
var postIds = _postDao.GetUnmoderatedPosts(new List <Guid> {
sub.Id
}, take: 30);
var model = new SubPostsModel();
model.Sub = _subWrapper.Wrap(sub.Id, _userContext.CurrentUser);
model.SortBy = PostsSortBy.New;
model.Posts = new PagedList <PostWrapped>(_postWrapper.Wrap(postIds, _userContext.CurrentUser), 0, 30, postIds.HasMore);
return(View(model));
}
public List <MessageWrapped> Wrap(List <Guid> messageIds, User currentUser)
{
if (currentUser == null)
{
throw new Exception("You must provide a user.");
}
var messages = new List <MessageWrapped>();
foreach (var messageId in messageIds)
{
var message = _messageDao.GetMessageById(messageId);
if (message != null)
{
messages.Add(new MessageWrapped(message));
}
}
var users = new Dictionary <Guid, User>();
var subs = new Dictionary <Guid, Sub>();
var comments = _commentWrapper.Wrap(
messages.Where(x => x.Message.CommentId.HasValue)
.Select(x => x.Message.CommentId.Value)
.Distinct()
.ToList(), currentUser)
.ToDictionary(x => x.Comment.Id, x => x);
var posts = _postWrapper.Wrap(
messages.Where(x => x.Message.PostId.HasValue)
.Select(x => x.Message.PostId.Value)
.Distinct()
.ToList(), currentUser)
.ToDictionary(x => x.Post.Id, x => x);
foreach (var message in messages)
{
if (!users.ContainsKey(message.Message.AuthorId))
{
users.Add(message.Message.AuthorId, null);
}
if (message.Message.ToUser.HasValue && !users.ContainsKey(message.Message.ToUser.Value))
{
users.Add(message.Message.ToUser.Value, null);
}
if (message.Message.FromSub.HasValue && !subs.ContainsKey(message.Message.FromSub.Value))
{
subs.Add(message.Message.FromSub.Value, null);
}
if (message.Message.ToSub.HasValue && !subs.ContainsKey(message.Message.ToSub.Value))
{
subs.Add(message.Message.ToSub.Value, null);
}
}
var subsCanModerate = new HashSet <Guid>();
foreach (var sub in subs.Keys)
{
if (_permissionDao.CanUserManageSubMail(currentUser, sub))
{
subsCanModerate.Add(sub);
}
}
foreach (var userId in users.Keys.ToList())
{
users[userId] = _membershipService.GetUserById(userId);
}
foreach (var subId in subs.Keys.ToList())
{
subs[subId] = _subDao.GetSubById(subId);
}
foreach (var message in messages)
{
message.Author = users[message.Message.AuthorId];
message.FromSub = message.Message.FromSub.HasValue ? subs[message.Message.FromSub.Value] : null;
message.ToUser = message.Message.ToUser.HasValue ? users[message.Message.ToUser.Value] : null;
message.ToSub = message.Message.ToSub.HasValue ? subs[message.Message.ToSub.Value] : null;
if (message.ToUser != null && message.ToUser.Id == currentUser.Id)
{
// this was a message to the current user, so the current user can reply to it.
message.CanReply = true;
}
else if (message.ToSub != null && subsCanModerate.Contains(message.ToSub.Id))
{
// this message was sent to a sub, and this user is a moderator with the correct permissions to reply.
message.CanReply = true;
}
if (message.Author.Id == currentUser.Id)
{
message.UserIsSender = true;
}
else if (message.ToUser != null && message.ToUser.Id == currentUser.Id)
{
message.UserIsRecipiant = true;
}
else if (message.ToSub != null && subsCanModerate.Contains(message.ToSub.Id))
{
message.UserIsRecipiant = true;
}
if (message.ToUser != null && message.ToUser.Id == currentUser.Id)
{
message.CanMarkRead = true;
}
else if (message.ToSub != null && subsCanModerate.Contains(message.ToSub.Id))
{
message.CanMarkRead = true;
}
if (message.CanMarkRead)
{
message.IsUnread = message.Message.IsNew;
}
// add any comment or post this message represents (comment reply, mention, etc)
if (message.Message.PostId.HasValue && posts.ContainsKey((message.Message.PostId.Value)))
{
message.Post = posts[message.Message.PostId.Value];
}
if (message.Message.CommentId.HasValue && comments.ContainsKey((message.Message.CommentId.Value)))
{
message.Comment = comments[message.Message.CommentId.Value];
}
}
return(messages);
}
public ActionResult SearchSub(string subName, string query, PostsSearchSortBy?sort, PostsTimeFilter?time, int?pageNumber, int?pageSize)
{
if (string.IsNullOrEmpty(subName))
{
return(Redirect(Url.Subs()));
}
if (sort == null)
{
sort = PostsSearchSortBy.Relevance;
}
if (time == null)
{
time = PostsTimeFilter.All;
}
var sub = _subDao.GetSubByName(subName);
if (sub == null)
{
return(Redirect(Url.Subs(subName)));
}
if (pageNumber == null || pageNumber < 1)
{
pageNumber = 1;
}
if (pageSize == null)
{
pageSize = 25;
}
if (pageSize > 100)
{
pageSize = 100;
}
if (pageSize < 1)
{
pageSize = 1;
}
var model = new SearchResultsModel();
model.Query = query;
model.SortBy = sort.Value;
model.TimeFilter = time.Value;
model.ResultType = SearchResultType.Post;
model.LimitingToSub = _subWrapper.Wrap(sub.Id, _userContext.CurrentUser);
var postIds = _postDao.QueryPosts(query,
model.LimitingToSub.Sub.Id,
sortBy: sort.Value,
timeFilter: time.Value,
nsfw: _userContext.CurrentNsfw,
skip: ((pageNumber - 1) * pageSize),
take: pageSize);
if (!string.IsNullOrEmpty(model.Query))
{
model.Posts = new PagedList <PostWrapped>(
_postWrapper.Wrap(postIds, _userContext.CurrentUser),
pageNumber.Value,
pageSize.Value,
postIds.HasMore);
}
return(View("Search", model));
}
