170cd11f9c
* Add a "Report" link to the footer of forums.
* Allow some non-admin users to view a private forum and its threads.
* Moderators and approved followers can see it
* Note: the endpoint to follow a forum won't let a user invite themselves
to a private forum. Currently there is no way to approve a user except
by also adding them as a moderator.
* Explore and Newest tabs can show these private forums if viewable.
370 lines
9.9 KiB
Go
370 lines
9.9 KiB
Go
package models
|
|
|
|
import (
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
"code.nonshy.com/nonshy/website/pkg/config"
|
|
"code.nonshy.com/nonshy/website/pkg/log"
|
|
)
|
|
|
|
// RecentPost drives the "Forums / Newest" page - carrying all forum comments
|
|
// on all threads sorted by date.
|
|
type RecentPost struct {
|
|
CommentID uint64
|
|
ThreadID uint64
|
|
ForumID uint64
|
|
UpdatedAt time.Time
|
|
Thread *Thread
|
|
Comment *Comment
|
|
Forum *Forum
|
|
}
|
|
|
|
// PaginateRecentPosts returns all of the comments on a forum paginated.
|
|
func PaginateRecentPosts(user *User, categories []string, subscribed, allComments bool, pager *Pagination) ([]*RecentPost, error) {
|
|
var (
|
|
result = []*RecentPost{}
|
|
blockedUserIDs = BlockedUserIDs(user)
|
|
|
|
// Separate the WHERE clauses that involve forums/threads from the ones
|
|
// that involve comments. Rationale: if the user is getting a de-duplicated
|
|
// thread view, we'll end up running two queries - one to get all threads and
|
|
// another to get the latest comments, and the WHERE clauses need to be separate.
|
|
wheres = []string{}
|
|
placeholders = []interface{}{}
|
|
comment_wheres = []string{"table_name = 'threads'"}
|
|
comment_ph = []interface{}{}
|
|
)
|
|
|
|
if len(categories) > 0 {
|
|
wheres = append(wheres, "forums.category IN ?")
|
|
placeholders = append(placeholders, categories)
|
|
}
|
|
|
|
// Hide explicit forum if user hasn't opted into it.
|
|
if !user.Explicit && !user.IsAdmin {
|
|
wheres = append(wheres, "forums.explicit = false")
|
|
}
|
|
|
|
// Private forums.
|
|
if !user.IsAdmin {
|
|
wheres = append(wheres, `
|
|
(
|
|
forums.private IS NOT TRUE
|
|
OR EXISTS (
|
|
SELECT 1
|
|
FROM forum_memberships
|
|
WHERE forum_id = forums.id
|
|
AND user_id = ?
|
|
AND (
|
|
is_moderator IS TRUE
|
|
OR approved IS TRUE
|
|
)
|
|
)
|
|
)`,
|
|
)
|
|
placeholders = append(placeholders, user.ID)
|
|
}
|
|
|
|
// Forums I follow?
|
|
if subscribed {
|
|
wheres = append(wheres, `
|
|
EXISTS (
|
|
SELECT 1
|
|
FROM forum_memberships
|
|
WHERE user_id = ?
|
|
AND forum_id = forums.id
|
|
)
|
|
`)
|
|
placeholders = append(placeholders, user.ID)
|
|
}
|
|
|
|
// Blocked users?
|
|
if len(blockedUserIDs) > 0 {
|
|
comment_wheres = append(comment_wheres, "comments.user_id NOT IN ?")
|
|
comment_ph = append(comment_ph, blockedUserIDs)
|
|
}
|
|
|
|
// Don't show comments from banned or disabled accounts.
|
|
comment_wheres = append(comment_wheres, `
|
|
EXISTS (
|
|
SELECT 1
|
|
FROM users
|
|
WHERE users.id = comments.user_id
|
|
AND users.status = 'active'
|
|
)
|
|
`)
|
|
|
|
// Get the page of recent forum comment IDs of all time.
|
|
var scan NewestForumPostsScanner
|
|
|
|
// Deduplicate forum threads: if one thread is BLOWING UP with replies, we should only
|
|
// mention the thread once and show the newest comment so it doesn't spam the whole page.
|
|
if config.Current.Database.IsPostgres && !allComments {
|
|
// Note: only Postgres supports this function (SELECT DISTINCT ON).
|
|
if res, err := ScanLatestForumCommentsPerThread(wheres, comment_wheres, placeholders, comment_ph, pager); err != nil {
|
|
return nil, err
|
|
} else {
|
|
scan = res
|
|
}
|
|
} else {
|
|
// SQLite/non-Postgres doesn't support DISTINCT ON, this is the old query which
|
|
// shows objectively all comments and a popular thread may dominate the page.
|
|
if res, err := ScanLatestForumCommentsAll(wheres, comment_wheres, placeholders, comment_ph, pager); err != nil {
|
|
return nil, err
|
|
} else {
|
|
scan = res
|
|
}
|
|
}
|
|
|
|
// Ingest the results.
|
|
var (
|
|
commentIDs = []uint64{} // collect distinct IDs
|
|
threadIDs = []uint64{}
|
|
forumIDs = []uint64{}
|
|
seenComments = map[uint64]interface{}{} // deduplication
|
|
seenThreads = map[uint64]interface{}{}
|
|
seenForums = map[uint64]interface{}{}
|
|
mapCommentRC = map[uint64]*RecentPost{} // map commentID to result
|
|
)
|
|
for _, row := range scan {
|
|
// Upsert the result set.
|
|
var rp *RecentPost
|
|
if existing, ok := mapCommentRC[row.CommentID]; ok {
|
|
rp = existing
|
|
} else {
|
|
rp = &RecentPost{
|
|
CommentID: row.CommentID,
|
|
}
|
|
mapCommentRC[row.CommentID] = rp
|
|
result = append(result, rp)
|
|
}
|
|
|
|
// Got a thread ID?
|
|
if row.ThreadID != nil {
|
|
rp.ThreadID = *row.ThreadID
|
|
if _, ok := seenThreads[rp.ThreadID]; !ok {
|
|
seenThreads[rp.ThreadID] = nil
|
|
threadIDs = append(threadIDs, rp.ThreadID)
|
|
}
|
|
|
|
}
|
|
|
|
// Got a forum ID?
|
|
if row.ForumID != nil {
|
|
rp.ForumID = *row.ForumID
|
|
if _, ok := seenForums[rp.ForumID]; !ok {
|
|
seenForums[rp.ForumID] = nil
|
|
forumIDs = append(forumIDs, rp.ForumID)
|
|
}
|
|
}
|
|
|
|
// Collect distinct comment IDs.
|
|
if _, ok := seenComments[rp.CommentID]; !ok {
|
|
seenComments[rp.CommentID] = nil
|
|
commentIDs = append(commentIDs, rp.CommentID)
|
|
}
|
|
}
|
|
|
|
// Load all of the distinct comments, threads and forums.
|
|
var (
|
|
comments = map[uint64]*Comment{}
|
|
threads = map[uint64]*Thread{}
|
|
forums = map[uint64]*Forum{}
|
|
)
|
|
|
|
if len(commentIDs) > 0 {
|
|
comments, _ = GetComments(commentIDs)
|
|
}
|
|
if len(threadIDs) > 0 {
|
|
threads, _ = GetThreadsAsUser(user, threadIDs)
|
|
}
|
|
if len(forumIDs) > 0 {
|
|
forums, _ = GetForums(forumIDs)
|
|
}
|
|
|
|
// Collect comments so we can inject UserRelationships in efficiently.
|
|
var (
|
|
coms = []*Comment{}
|
|
thrs = []*Thread{}
|
|
)
|
|
|
|
// Merge all the objects back in.
|
|
for _, rc := range result {
|
|
if com, ok := comments[rc.CommentID]; ok {
|
|
rc.Comment = com
|
|
coms = append(coms, com)
|
|
}
|
|
|
|
if thr, ok := threads[rc.ThreadID]; ok {
|
|
rc.Thread = thr
|
|
thrs = append(thrs, thr)
|
|
} else {
|
|
log.Error("RecentPosts: didn't find thread ID %d in map!", rc.ThreadID)
|
|
|
|
// Create a dummy placeholder Thread (e.g.: the thread originator has been
|
|
// banned or disabled, but the thread summary is shown on the new comment view)
|
|
rc.Thread = &Thread{
|
|
Comment: Comment{
|
|
Message: "[unavailable]",
|
|
},
|
|
}
|
|
}
|
|
|
|
// Is the new comment unavailable? (e.g. blocked, banned, disabled)
|
|
if rc.Comment == nil {
|
|
rc.Comment = &Comment{
|
|
Message: "[unavailable]",
|
|
}
|
|
}
|
|
|
|
if f, ok := forums[rc.ForumID]; ok {
|
|
rc.Forum = f
|
|
}
|
|
}
|
|
|
|
// Inject user relationships into all comment users now.
|
|
SetUserRelationshipsInComments(user, coms)
|
|
SetUserRelationshipsInThreads(user, thrs)
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// NewestForumPosts collects the IDs of the latest forum posts.
|
|
type NewestForumPosts struct {
|
|
CommentID uint64
|
|
ThreadID *uint64
|
|
ForumID *uint64
|
|
UpdatedAt time.Time
|
|
}
|
|
|
|
type NewestForumPostsScanner []NewestForumPosts
|
|
|
|
// ScanLatestForumCommentsAll returns a scan of Newest forum posts containing ALL comments, which may
|
|
// include runs of 'duplicate' forum threads if a given thread was commented on rapidly. This is the classic
|
|
// 'Newest' tab behavior, showing just ALL forum comments by newest.
|
|
func ScanLatestForumCommentsAll(wheres, comment_wheres []string, placeholders, comment_ph []interface{}, pager *Pagination) (NewestForumPostsScanner, error) {
|
|
var scan NewestForumPostsScanner
|
|
|
|
// This one is all one joined query so join the wheres/placeholders.
|
|
wheres = append(wheres, comment_wheres...)
|
|
placeholders = append(placeholders, comment_ph...)
|
|
|
|
// SQLite/non-Postgres doesn't support DISTINCT ON, this is the old query which
|
|
// shows objectively all comments and a popular thread may dominate the page.
|
|
query := DB.Table("comments").Select(
|
|
`comments.id AS comment_id,
|
|
threads.id AS thread_id,
|
|
forums.id AS forum_id,
|
|
comments.updated_at AS updated_at`,
|
|
).Joins(
|
|
"LEFT OUTER JOIN threads ON (table_name = 'threads' AND table_id = threads.id)",
|
|
).Joins(
|
|
"LEFT OUTER JOIN forums ON (threads.forum_id = forums.id)",
|
|
).Where(
|
|
strings.Join(wheres, " AND "),
|
|
placeholders...,
|
|
).Order("comments.updated_at desc")
|
|
query.Model(&Comment{}).Count(&pager.Total)
|
|
|
|
// Execute the query.
|
|
query = query.Offset(pager.GetOffset()).Limit(pager.PerPage).Find(&scan)
|
|
return scan, query.Error
|
|
}
|
|
|
|
// ScanLatestForumCommentsPerThread returns a scan of Newest forum posts, deduplicated by thread.
|
|
// Each thread ID will only appear once in the result, paired with the newest comment in that
|
|
// thread.
|
|
func ScanLatestForumCommentsPerThread(wheres, comment_wheres []string, placeholders, comment_ph []interface{}, pager *Pagination) (NewestForumPostsScanner, error) {
|
|
var (
|
|
result NewestForumPostsScanner
|
|
threadIDs = []uint64{}
|
|
|
|
// Query for ALL thread IDs (in forums the user can see).
|
|
query = DB.Table(
|
|
"threads",
|
|
).Select(`
|
|
DISTINCT ON (threads.id)
|
|
threads.forum_id,
|
|
threads.id AS thread_id,
|
|
threads.updated_at AS updated_at
|
|
`).Joins(
|
|
"JOIN forums ON (threads.forum_id = forums.id)",
|
|
).Where(
|
|
strings.Join(wheres, " AND "),
|
|
placeholders...,
|
|
).Order(
|
|
"threads.id",
|
|
)
|
|
)
|
|
|
|
query = query.Find(&result)
|
|
if query.Error != nil {
|
|
return result, query.Error
|
|
}
|
|
pager.Total = int64(len(result))
|
|
|
|
// Reorder the result by timestamp.
|
|
sort.Slice(result, func(i, j int) bool {
|
|
return result[i].UpdatedAt.After(result[j].UpdatedAt)
|
|
})
|
|
|
|
// Subslice the result per the user's pagination setting.
|
|
var (
|
|
start = pager.GetOffset()
|
|
stop = start + pager.PerPage
|
|
)
|
|
if start > len(result) {
|
|
return NewestForumPostsScanner{}, nil
|
|
} else if stop > len(result) {
|
|
stop = len(result)
|
|
}
|
|
result = result[start:stop]
|
|
|
|
// Map the thread IDs to their result row.
|
|
var threadMap = map[uint64]int{}
|
|
for i, row := range result {
|
|
threadIDs = append(threadIDs, *row.ThreadID)
|
|
threadMap[*row.ThreadID] = i
|
|
}
|
|
|
|
// With these thread IDs, select the newest comments.
|
|
type scanner struct {
|
|
ThreadID uint64
|
|
CommentID uint64
|
|
}
|
|
var scan []scanner
|
|
err := DB.Table(
|
|
"comments",
|
|
).Select(
|
|
"table_id AS thread_id, id AS comment_id",
|
|
).Where(
|
|
`table_name='threads' AND table_id IN ?
|
|
AND updated_at = (SELECT MAX(updated_at)
|
|
FROM comments c2
|
|
WHERE c2.table_name=comments.table_name
|
|
AND c2.table_id=comments.table_id
|
|
)`,
|
|
threadIDs,
|
|
).Where(
|
|
strings.Join(comment_wheres, " AND "),
|
|
comment_ph...,
|
|
).Order(
|
|
"updated_at desc",
|
|
).Scan(&scan)
|
|
if err.Error != nil {
|
|
log.Error("Getting most recent post IDs: %s", err.Error)
|
|
return result, err.Error
|
|
}
|
|
|
|
// Populate the comment IDs back in.
|
|
for _, row := range scan {
|
|
if idx, ok := threadMap[row.ThreadID]; ok {
|
|
result[idx].CommentID = row.CommentID
|
|
}
|
|
}
|
|
|
|
return result, query.Error
|
|
}
|