440 lines
12 KiB
Go
440 lines
12 KiB
Go
package website
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"math"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"git.handmade.network/hmn/hmn/src/db"
|
|
"git.handmade.network/hmn/hmn/src/hmnurl"
|
|
"git.handmade.network/hmn/hmn/src/models"
|
|
"git.handmade.network/hmn/hmn/src/oops"
|
|
"git.handmade.network/hmn/hmn/src/templates"
|
|
"github.com/jackc/pgx/v4/pgxpool"
|
|
)
|
|
|
|
type forumCategoryData struct {
|
|
templates.BaseData
|
|
|
|
CategoryUrl string
|
|
Threads []templates.ThreadListItem
|
|
Pagination templates.Pagination
|
|
Subcategories []forumSubcategoryData
|
|
}
|
|
|
|
type forumSubcategoryData struct {
|
|
Name string
|
|
Url string
|
|
Threads []templates.ThreadListItem
|
|
TotalThreads int
|
|
}
|
|
|
|
func ForumCategory(c *RequestContext) ResponseData {
|
|
const threadsPerPage = 25
|
|
|
|
// TODO(asaf): Consider making this more robust.
|
|
// Right now this code allows for weird urls like:
|
|
// "/forums/asdf/wip" which doesn't verify the lineage and displays the wip forums
|
|
// "/forums/wip///" which fetches the main forums page because it happens to have a blank slug
|
|
// "/forums/wip/" which fetches the main forums page because Split returns an extra blank string
|
|
// "/forums/wip/1" this one fetches the wip forums because the regex matches the `/1` as part of the page group
|
|
// "/forums/wip/1/" 404 - doesn't match the regex
|
|
// "/forums/" 404 - doesn't match the regex
|
|
catPath := c.PathParams["cats"]
|
|
catSlugs := strings.Split(catPath, "/")
|
|
currentCatId := fetchCatIdFromSlugs(c.Context(), c.Conn, catSlugs, c.CurrentProject.ID)
|
|
// TODO(asaf): 404 if we can't find our cat.
|
|
categoryUrls := GetProjectCategoryUrls(c.Context(), c.Conn, c.CurrentProject.ID)
|
|
|
|
c.Perf.StartBlock("SQL", "Fetch count of page threads")
|
|
numThreads, err := db.QueryInt(c.Context(), c.Conn,
|
|
`
|
|
SELECT COUNT(*)
|
|
FROM handmade_thread AS thread
|
|
WHERE
|
|
thread.category_id = $1
|
|
AND NOT thread.deleted
|
|
`,
|
|
currentCatId,
|
|
)
|
|
if err != nil {
|
|
panic(oops.New(err, "failed to get count of threads"))
|
|
}
|
|
c.Perf.EndBlock()
|
|
|
|
numPages := int(math.Ceil(float64(numThreads) / threadsPerPage))
|
|
|
|
page := 1
|
|
pageString, hasPage := c.PathParams["page"]
|
|
if hasPage && pageString != "" {
|
|
if pageParsed, err := strconv.Atoi(pageString); err == nil {
|
|
page = pageParsed
|
|
} else {
|
|
return c.Redirect("/feed", http.StatusSeeOther) // TODO
|
|
}
|
|
}
|
|
if page < 1 || numPages < page {
|
|
return c.Redirect("/feed", http.StatusSeeOther) // TODO
|
|
}
|
|
|
|
howManyThreadsToSkip := (page - 1) * threadsPerPage
|
|
|
|
var currentUserId *int
|
|
if c.CurrentUser != nil {
|
|
currentUserId = &c.CurrentUser.ID
|
|
}
|
|
|
|
c.Perf.StartBlock("SQL", "Fetch page threads")
|
|
type threadQueryResult struct {
|
|
Thread models.Thread `db:"thread"`
|
|
FirstPost models.Post `db:"firstpost"`
|
|
LastPost models.Post `db:"lastpost"`
|
|
FirstUser *models.User `db:"firstuser"`
|
|
LastUser *models.User `db:"lastuser"`
|
|
ThreadLastReadTime *time.Time `db:"tlri.lastread"`
|
|
CatLastReadTime *time.Time `db:"clri.lastread"`
|
|
}
|
|
itMainThreads, err := db.Query(c.Context(), c.Conn, threadQueryResult{},
|
|
`
|
|
SELECT $columns
|
|
FROM
|
|
handmade_thread AS thread
|
|
JOIN handmade_post AS firstpost ON thread.first_id = firstpost.id
|
|
JOIN handmade_post AS lastpost ON thread.last_id = lastpost.id
|
|
LEFT JOIN auth_user AS firstuser ON firstpost.author_id = firstuser.id
|
|
LEFT JOIN auth_user AS lastuser ON lastpost.author_id = lastuser.id
|
|
LEFT JOIN handmade_threadlastreadinfo AS tlri ON (
|
|
tlri.thread_id = thread.id
|
|
AND tlri.user_id = $2
|
|
)
|
|
LEFT JOIN handmade_categorylastreadinfo AS clri ON (
|
|
clri.category_id = $1
|
|
AND clri.user_id = $2
|
|
)
|
|
WHERE
|
|
thread.category_id = $1
|
|
AND NOT thread.deleted
|
|
ORDER BY lastpost.postdate DESC
|
|
LIMIT $3 OFFSET $4
|
|
`,
|
|
currentCatId,
|
|
currentUserId,
|
|
threadsPerPage,
|
|
howManyThreadsToSkip,
|
|
)
|
|
if err != nil {
|
|
panic(oops.New(err, "failed to fetch threads"))
|
|
}
|
|
c.Perf.EndBlock()
|
|
defer itMainThreads.Close()
|
|
|
|
makeThreadListItem := func(row *threadQueryResult) templates.ThreadListItem {
|
|
hasRead := false
|
|
if row.ThreadLastReadTime != nil && row.ThreadLastReadTime.After(row.LastPost.PostDate) {
|
|
hasRead = true
|
|
} else if row.CatLastReadTime != nil && row.CatLastReadTime.After(row.LastPost.PostDate) {
|
|
hasRead = true
|
|
}
|
|
|
|
return templates.ThreadListItem{
|
|
Title: row.Thread.Title,
|
|
// TODO(asaf): Use thread.category_id instead of currentCatId. At the moment this is generating wrong urls for threads in subcats.
|
|
Url: ThreadUrl(row.Thread, models.CatKindForum, categoryUrls[currentCatId]),
|
|
|
|
FirstUser: templates.UserToTemplate(row.FirstUser),
|
|
FirstDate: row.FirstPost.PostDate,
|
|
LastUser: templates.UserToTemplate(row.LastUser),
|
|
LastDate: row.LastPost.PostDate,
|
|
|
|
Unread: !hasRead,
|
|
}
|
|
}
|
|
|
|
var threads []templates.ThreadListItem
|
|
for _, irow := range itMainThreads.ToSlice() {
|
|
row := irow.(*threadQueryResult)
|
|
threads = append(threads, makeThreadListItem(row))
|
|
}
|
|
|
|
// ---------------------
|
|
// Subcategory things
|
|
// ---------------------
|
|
|
|
var subcats []forumSubcategoryData
|
|
if page == 1 {
|
|
c.Perf.StartBlock("SQL", "Fetch subcategories")
|
|
type subcatQueryResult struct {
|
|
Cat models.Category `db:"cat"`
|
|
}
|
|
itSubcats, err := db.Query(c.Context(), c.Conn, subcatQueryResult{},
|
|
`
|
|
SELECT $columns
|
|
FROM
|
|
handmade_category AS cat
|
|
WHERE
|
|
cat.parent_id = $1
|
|
`,
|
|
currentCatId,
|
|
)
|
|
if err != nil {
|
|
panic(oops.New(err, "failed to fetch subcategories"))
|
|
}
|
|
defer itSubcats.Close()
|
|
c.Perf.EndBlock()
|
|
|
|
for _, irow := range itSubcats.ToSlice() {
|
|
catRow := irow.(*subcatQueryResult)
|
|
|
|
c.Perf.StartBlock("SQL", "Fetch count of subcategory threads")
|
|
// TODO(asaf): [PERF] [MINOR] Consider replacing querying count per subcat with a single query for all cats with GROUP BY.
|
|
numThreads, err := db.QueryInt(c.Context(), c.Conn,
|
|
`
|
|
SELECT COUNT(*)
|
|
FROM handmade_thread AS thread
|
|
WHERE
|
|
thread.category_id = $1
|
|
AND NOT thread.deleted
|
|
`,
|
|
catRow.Cat.ID,
|
|
)
|
|
if err != nil {
|
|
panic(oops.New(err, "failed to get count of threads"))
|
|
}
|
|
c.Perf.EndBlock()
|
|
|
|
c.Perf.StartBlock("SQL", "Fetch subcategory threads")
|
|
// TODO(asaf): [PERF] [MINOR] Consider batching these.
|
|
itThreads, err := db.Query(c.Context(), c.Conn, threadQueryResult{},
|
|
`
|
|
SELECT $columns
|
|
FROM
|
|
handmade_thread AS thread
|
|
JOIN handmade_post AS firstpost ON thread.first_id = firstpost.id
|
|
JOIN handmade_post AS lastpost ON thread.last_id = lastpost.id
|
|
LEFT JOIN auth_user AS firstuser ON firstpost.author_id = firstuser.id
|
|
LEFT JOIN auth_user AS lastuser ON lastpost.author_id = lastuser.id
|
|
LEFT JOIN handmade_threadlastreadinfo AS tlri ON (
|
|
tlri.thread_id = thread.id
|
|
AND tlri.user_id = $2
|
|
)
|
|
LEFT JOIN handmade_categorylastreadinfo AS clri ON (
|
|
clri.category_id = $1
|
|
AND clri.user_id = $2
|
|
)
|
|
WHERE
|
|
thread.category_id = $1
|
|
AND NOT thread.deleted
|
|
ORDER BY lastpost.postdate DESC
|
|
LIMIT 3
|
|
`,
|
|
catRow.Cat.ID,
|
|
currentUserId,
|
|
)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
defer itThreads.Close()
|
|
c.Perf.EndBlock()
|
|
|
|
var threads []templates.ThreadListItem
|
|
for _, irow := range itThreads.ToSlice() {
|
|
threadRow := irow.(*threadQueryResult)
|
|
threads = append(threads, makeThreadListItem(threadRow))
|
|
}
|
|
|
|
subcats = append(subcats, forumSubcategoryData{
|
|
Name: *catRow.Cat.Name,
|
|
Url: categoryUrls[catRow.Cat.ID],
|
|
Threads: threads,
|
|
TotalThreads: numThreads,
|
|
})
|
|
}
|
|
}
|
|
|
|
// ---------------------
|
|
// Template assembly
|
|
// ---------------------
|
|
|
|
baseData := getBaseData(c)
|
|
baseData.Title = c.CurrentProject.Name + " Forums"
|
|
baseData.Breadcrumbs = []templates.Breadcrumb{
|
|
{
|
|
Name: c.CurrentProject.Name,
|
|
Url: hmnurl.ProjectUrl("/", nil, c.CurrentProject.Slug),
|
|
},
|
|
{
|
|
Name: "Forums",
|
|
Url: categoryUrls[currentCatId],
|
|
Current: true,
|
|
},
|
|
}
|
|
|
|
var res ResponseData
|
|
err = res.WriteTemplate("forum_category.html", forumCategoryData{
|
|
BaseData: baseData,
|
|
CategoryUrl: categoryUrls[currentCatId],
|
|
Threads: threads,
|
|
Pagination: templates.Pagination{
|
|
Current: page,
|
|
Total: numPages,
|
|
|
|
FirstUrl: categoryUrls[currentCatId],
|
|
LastUrl: fmt.Sprintf("%s/%d", categoryUrls[currentCatId], numPages),
|
|
NextUrl: fmt.Sprintf("%s/%d", categoryUrls[currentCatId], page+1),
|
|
PreviousUrl: fmt.Sprintf("%s/%d", categoryUrls[currentCatId], page-1),
|
|
},
|
|
Subcategories: subcats,
|
|
}, c.Perf)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
return res
|
|
}
|
|
|
|
type forumThreadData struct {
|
|
templates.BaseData
|
|
Thread templates.Thread
|
|
Posts []templates.Post
|
|
}
|
|
|
|
func ForumThread(c *RequestContext) ResponseData {
|
|
const postsPerPage = 15
|
|
// TODO(asaf): Verify that the requested thread is not deleted, and only fetch non-deleted posts.
|
|
|
|
threadId, err := strconv.Atoi(c.PathParams["threadid"])
|
|
if err != nil {
|
|
return FourOhFour(c)
|
|
}
|
|
|
|
c.Perf.StartBlock("SQL", "Fetch current thread")
|
|
type threadQueryResult struct {
|
|
Thread models.Thread `db:"thread"`
|
|
}
|
|
irow, err := db.QueryOne(c.Context(), c.Conn, threadQueryResult{},
|
|
`
|
|
SELECT $columns
|
|
FROM handmade_thread AS thread
|
|
WHERE thread.id = $1
|
|
`,
|
|
threadId,
|
|
)
|
|
c.Perf.EndBlock()
|
|
if err != nil {
|
|
if errors.Is(err, db.ErrNoMatchingRows) {
|
|
return FourOhFour(c)
|
|
} else {
|
|
panic(err)
|
|
}
|
|
}
|
|
thread := irow.(*threadQueryResult).Thread
|
|
|
|
categoryUrls := GetProjectCategoryUrls(c.Context(), c.Conn, c.CurrentProject.ID)
|
|
|
|
page, numPages, ok := getPageInfo(c.PathParams["page"], 100, postsPerPage) // TODO: Not 100
|
|
if !ok {
|
|
urlNoPage := ThreadUrl(thread, models.CatKindForum, categoryUrls[thread.CategoryID])
|
|
return c.Redirect(urlNoPage, http.StatusSeeOther)
|
|
}
|
|
_ = numPages // TODO
|
|
|
|
c.Perf.StartBlock("SQL", "Fetch posts")
|
|
type postsQueryResult struct {
|
|
Post models.Post `db:"post"`
|
|
Content string `db:"ver.text_parsed"`
|
|
Author *models.User `db:"author"`
|
|
}
|
|
itPosts, err := db.Query(c.Context(), c.Conn, postsQueryResult{},
|
|
`
|
|
SELECT $columns
|
|
FROM
|
|
handmade_post AS post
|
|
JOIN handmade_postversion AS ver ON post.current_id = ver.id
|
|
LEFT JOIN auth_user AS author ON post.author_id = author.id
|
|
WHERE
|
|
post.thread_id = $1
|
|
ORDER BY postdate
|
|
LIMIT $2 OFFSET $3
|
|
`,
|
|
thread.ID,
|
|
postsPerPage,
|
|
(page-1)*postsPerPage,
|
|
)
|
|
c.Perf.EndBlock()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
defer itPosts.Close()
|
|
|
|
var posts []templates.Post
|
|
for _, irow := range itPosts.ToSlice() {
|
|
row := irow.(*postsQueryResult)
|
|
posts = append(posts, templates.PostToTemplateWithContent(&row.Post, row.Author, row.Content))
|
|
}
|
|
|
|
baseData := getBaseData(c)
|
|
// TODO(asaf): Replace page title with thread title
|
|
// TODO(asaf): Set breadcrumbs
|
|
|
|
var res ResponseData
|
|
err = res.WriteTemplate("forum_thread.html", forumThreadData{
|
|
BaseData: baseData,
|
|
Thread: templates.ThreadToTemplate(&thread),
|
|
Posts: posts,
|
|
}, c.Perf)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
return res
|
|
}
|
|
|
|
func fetchCatIdFromSlugs(ctx context.Context, conn *pgxpool.Pool, catSlugs []string, projectId int) int {
|
|
if len(catSlugs) == 1 {
|
|
var err error
|
|
currentCatId, err := db.QueryInt(ctx, conn,
|
|
`
|
|
SELECT cat.id
|
|
FROM
|
|
handmade_category AS cat
|
|
JOIN handmade_project AS proj ON proj.forum_id = cat.id
|
|
WHERE
|
|
proj.id = $1
|
|
AND cat.kind = $2
|
|
`,
|
|
projectId,
|
|
models.CatKindForum,
|
|
)
|
|
if err != nil {
|
|
panic(oops.New(err, "failed to get root category id"))
|
|
}
|
|
|
|
return currentCatId
|
|
} else {
|
|
var err error
|
|
currentCatId, err := db.QueryInt(ctx, conn,
|
|
`
|
|
SELECT id
|
|
FROM handmade_category
|
|
WHERE
|
|
slug = $1
|
|
AND kind = $2
|
|
AND project_id = $3
|
|
`,
|
|
catSlugs[len(catSlugs)-1],
|
|
models.CatKindForum,
|
|
projectId,
|
|
)
|
|
if err != nil {
|
|
panic(oops.New(err, "failed to get current category id"))
|
|
}
|
|
|
|
return currentCatId
|
|
}
|
|
}
|