GoBlog/posts.go

package main

import (
	"context"
	"errors"
	"fmt"
	"html/template"
	"net/http"
	"reflect"
	"strconv"
	"strings"
	"sync"

	"github.com/go-chi/chi/v5"
	"github.com/vcraescu/go-paginator"
)

var errPostNotFound = errors.New("post not found")

type post struct {
	Path       string
	Content    string
	Published  string
	Updated    string
	Parameters map[string][]string
	Blog       string
	Section    string
	Status     postStatus
	Priority   int
	// Not persisted
	Slug          string
	RenderedTitle string
	renderCache   map[bool]template.HTML
	renderMutex   sync.RWMutex
}

type postStatus string

const (
	statusNil       postStatus = ""
	statusPublished postStatus = "published"
	statusDraft     postStatus = "draft"
	statusPrivate   postStatus = "private"
	statusUnlisted  postStatus = "unlisted"
)

func (a *goBlog) servePost(w http.ResponseWriter, r *http.Request) {
	p, err := a.getPost(r.URL.Path)
	if err == errPostNotFound {
		a.serve404(w, r)
		return
	} else if err != nil {
		a.serveError(w, r, err.Error(), http.StatusInternalServerError)
		return
	}
	if asRequest, ok := r.Context().Value(asRequestKey).(bool); ok && asRequest {
		if r.URL.Path == a.getRelativePath(p.Blog, "") {
			a.serveActivityStreams(p.Blog, w, r)
			return
		}
		a.serveActivityStreamsPost(p, w)
		return
	}
	canonical := p.firstParameter("original")
	if canonical == "" {
		canonical = a.fullPostURL(p)
	}
	template := templatePost
	if p.Path == a.getRelativePath(p.Blog, "") {
		template = templateStaticHome
	}
	w.Header().Add("Link", fmt.Sprintf("<%s>; rel=shortlink", a.shortPostURL(p)))
	a.render(w, r, template, &renderData{
		BlogString: p.Blog,
		Canonical:  canonical,
		Data:       p,
	})
}

func (a *goBlog) redirectToRandomPost(rw http.ResponseWriter, r *http.Request) {
	randomPath, err := a.getRandomPostPath(r.Context().Value(blogKey).(string))
	if err != nil {
		a.serveError(rw, r, err.Error(), http.StatusInternalServerError)
		return
	}
	http.Redirect(rw, r, randomPath, http.StatusFound)
}

type postPaginationAdapter struct {
	config *postsRequestConfig
	nums   int64
	a      *goBlog
}

func (p *postPaginationAdapter) Nums() (int64, error) {
	if p.nums == 0 {
		nums, _ := p.a.db.countPosts(p.config)
		p.nums = int64(nums)
	}
	return p.nums, nil
}

func (p *postPaginationAdapter) Slice(offset, length int, data interface{}) error {
	modifiedConfig := *p.config
	modifiedConfig.offset = offset
	modifiedConfig.limit = length

	posts, err := p.a.getPosts(&modifiedConfig)
	reflect.ValueOf(data).Elem().Set(reflect.ValueOf(&posts).Elem())
	return err
}

func (a *goBlog) serveHome(w http.ResponseWriter, r *http.Request) {
	blog := r.Context().Value(blogKey).(string)
	if asRequest, ok := r.Context().Value(asRequestKey).(bool); ok && asRequest {
		a.serveActivityStreams(blog, w, r)
		return
	}
	a.serveIndex(w, r.WithContext(context.WithValue(r.Context(), indexConfigKey, &indexConfig{
		path: a.getRelativePath(blog, ""),
	})))
}

func (a *goBlog) serveDrafts(w http.ResponseWriter, r *http.Request) {
	blog := r.Context().Value(blogKey).(string)
	a.serveIndex(w, r.WithContext(context.WithValue(r.Context(), indexConfigKey, &indexConfig{
		path:   a.getRelativePath(blog, "/editor/drafts"),
		title:  a.ts.GetTemplateStringVariant(a.cfg.Blogs[blog].Lang, "drafts"),
		status: statusDraft,
	})))
}

func (a *goBlog) servePrivate(w http.ResponseWriter, r *http.Request) {
	blog := r.Context().Value(blogKey).(string)
	a.serveIndex(w, r.WithContext(context.WithValue(r.Context(), indexConfigKey, &indexConfig{
		path:   a.getRelativePath(blog, "/editor/private"),
		title:  a.ts.GetTemplateStringVariant(a.cfg.Blogs[blog].Lang, "privateposts"),
		status: statusPrivate,
	})))
}

func (a *goBlog) serveUnlisted(w http.ResponseWriter, r *http.Request) {
	blog := r.Context().Value(blogKey).(string)
	a.serveIndex(w, r.WithContext(context.WithValue(r.Context(), indexConfigKey, &indexConfig{
		path:   a.getRelativePath(blog, "/editor/unlisted"),
		title:  a.ts.GetTemplateStringVariant(a.cfg.Blogs[blog].Lang, "unlistedposts"),
		status: statusUnlisted,
	})))
}

func (a *goBlog) serveDate(w http.ResponseWriter, r *http.Request) {
	var year, month, day int
	if ys := chi.URLParam(r, "year"); ys != "" && ys != "x" {
		year, _ = strconv.Atoi(ys)
	}
	if ms := chi.URLParam(r, "month"); ms != "" && ms != "x" {
		month, _ = strconv.Atoi(ms)
	}
	if ds := chi.URLParam(r, "day"); ds != "" {
		day, _ = strconv.Atoi(ds)
	}
	if year == 0 && month == 0 && day == 0 {
		a.serve404(w, r)
		return
	}
	var title, dPath strings.Builder
	if year != 0 {
		ys := fmt.Sprintf("%0004d", year)
		title.WriteString(ys)
		dPath.WriteString(ys)
	} else {
		title.WriteString("XXXX")
		dPath.WriteString("x")
	}
	if month != 0 {
		title.WriteString(fmt.Sprintf("-%02d", month))
		dPath.WriteString(fmt.Sprintf("/%02d", month))
	} else if day != 0 {
		title.WriteString("-XX")
		dPath.WriteString("/x")
	}
	if day != 0 {
		title.WriteString(fmt.Sprintf("-%02d", day))
		dPath.WriteString(fmt.Sprintf("/%02d", day))
	}
	a.serveIndex(w, r.WithContext(context.WithValue(r.Context(), indexConfigKey, &indexConfig{
		path:  a.getRelativePath(r.Context().Value(blogKey).(string), dPath.String()),
		year:  year,
		month: month,
		day:   day,
		title: title.String(),
	})))
}

type indexConfig struct {
	blog             string
	path             string
	section          *configSection
	tax              *configTaxonomy
	taxValue         string
	parameter        string
	year, month, day int
	title            string
	description      string
	summaryTemplate  string
	status           postStatus
}

const defaultPhotosPath = "/photos"

const indexConfigKey contextKey = "indexConfig"

func (a *goBlog) serveIndex(w http.ResponseWriter, r *http.Request) {
	ic := r.Context().Value(indexConfigKey).(*indexConfig)
	blog := ic.blog
	if blog == "" {
		blog, _ = r.Context().Value(blogKey).(string)
	}
	search := chi.URLParam(r, "search")
	if search != "" {
		// Decode and sanitize search
		search = cleanHTMLText(searchDecode(search))
	}
	pageNoString := chi.URLParam(r, "page")
	pageNo, _ := strconv.Atoi(pageNoString)
	var sections []string
	if ic.section != nil {
		sections = []string{ic.section.Name}
	} else {
		for sectionKey := range a.cfg.Blogs[blog].Sections {
			sections = append(sections, sectionKey)
		}
	}
	status := ic.status
	if status == statusNil {
		status = statusPublished
	}
	p := paginator.New(&postPaginationAdapter{config: &postsRequestConfig{
		blog:           blog,
		sections:       sections,
		taxonomy:       ic.tax,
		taxonomyValue:  ic.taxValue,
		parameter:      ic.parameter,
		search:         search,
		publishedYear:  ic.year,
		publishedMonth: ic.month,
		publishedDay:   ic.day,
		status:         status,
		priorityOrder:  true,
	}, a: a}, a.cfg.Blogs[blog].Pagination)
	p.SetPage(pageNo)
	var posts []*post
	err := p.Results(&posts)
	if err != nil {
		a.serveError(w, r, err.Error(), http.StatusInternalServerError)
		return
	}
	// Meta
	title := ic.title
	description := ic.description
	if ic.tax != nil {
		title = fmt.Sprintf("%s: %s", ic.tax.Title, ic.taxValue)
	} else if ic.section != nil {
		title = ic.section.Title
		description = ic.section.Description
	} else if search != "" {
		title = fmt.Sprintf("%s: %s", a.cfg.Blogs[blog].Search.Title, search)
	}
	// Check if feed
	if ft := feedType(chi.URLParam(r, "feed")); ft != noFeed {
		a.generateFeed(blog, ft, w, r, posts, title, description)
		return
	}
	// Path
	path := ic.path
	if strings.Contains(path, searchPlaceholder) {
		path = strings.ReplaceAll(path, searchPlaceholder, searchEncode(search))
	}
	// Navigation
	var hasPrev, hasNext bool
	var prevPage, nextPage int
	var prevPath, nextPath string
	hasPrev, _ = p.HasPrev()
	if hasPrev {
		prevPage, _ = p.PrevPage()
	} else {
		prevPage, _ = p.Page()
	}
	if prevPage < 2 {
		prevPath = path
	} else {
		prevPath = fmt.Sprintf("%s/page/%d", strings.TrimSuffix(path, "/"), prevPage)
	}
	hasNext, _ = p.HasNext()
	if hasNext {
		nextPage, _ = p.NextPage()
	} else {
		nextPage, _ = p.Page()
	}
	nextPath = fmt.Sprintf("%s/page/%d", strings.TrimSuffix(path, "/"), nextPage)
	summaryTemplate := ic.summaryTemplate
	if summaryTemplate == "" {
		summaryTemplate = templateSummary
	}
	a.render(w, r, templateIndex, &renderData{
		BlogString: blog,
		Canonical:  a.getFullAddress(path),
		Data: map[string]interface{}{
			"Title":           title,
			"Description":     description,
			"Posts":           posts,
			"HasPrev":         hasPrev,
			"HasNext":         hasNext,
			"First":           path,
			"Prev":            prevPath,
			"Next":            nextPath,
			"SummaryTemplate": summaryTemplate,
		},
	})
}