Files
pages/internal/server/public_periodical_view.go
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
2026-09-27 14:44:43 +09:00

336 lines
11 KiB
Go

package server
import (
"context"
"encoding/xml"
stdhtml "html"
"html/template"
"io"
"net/http"
"net/url"
"path"
"strconv"
"strings"
"time"
"golang.org/x/net/html"
"pageswiki/internal/store"
)
func publicPeriodicalArticlePath(target string) bool {
parts := strings.Split(strings.TrimPrefix(target, "/"), "/")
if len(parts) != 3 && len(parts) != 4 {
return false
}
date := strings.Join(parts[:3], "-")
d, err := time.Parse("2006-01-02", date)
return err == nil && d.Year() > 0 && path.Clean(target) == target && !strings.ContainsAny(target, "\\?#") && (len(parts) == 3 || parts[3] != "")
}
func projectedArticleHref(prefix, target string) string {
if !strings.HasPrefix(target, strings.TrimSuffix(prefix, "/")+"/") {
return ""
}
relative := strings.TrimPrefix(target, strings.TrimSuffix(prefix, "/"))
if publicPeriodicalArticlePath(relative) {
return cityPageHref(relative)
}
return ""
}
func (s *Server) renderPublicPeriodical(w http.ResponseWriter, r *http.Request, kind, month, selected, sourceHost string, projection *store.PeriodicalProjection, entries []store.PeriodicalEntry, revisions map[string]store.Revision, article, feed bool) {
domain := s.domainUUIDForRequest(r)
site := s.getWikiName(domain)
items := make([]periodicalItem, 0, len(entries))
for _, e := range entries {
items = append(items, periodicalItem{PeriodicalEntry: e, Href: projectedArticleHref(projection.Prefix, e.Path)})
}
if feed {
s.renderPeriodicalRSS(w, r, site, sourceHost, projection.Source, items, revisions)
return
}
data := map[string]any{"Context": s.BuildRequestContext(r), "Locale": s.getLocale(domain), "Title": site, "Kind": kind, "SiteTitle": site, "BasePath": "/", "FilterAction": "/v/" + kind}
articleIndex := -1
if article {
sourcePath := strings.TrimSuffix(projection.Prefix, "/") + r.URL.Path
for i := range items {
if items[i].Path == sourcePath {
articleIndex = i
break
}
}
if articleIndex < 0 {
http.NotFound(w, r)
return
}
item := items[articleIndex]
v := revisions[item.Path]
// Recheck the exact current public revision before opening its bytes.
current, err := s.store.AnonymousRevision(r.Context(), projection.Source, item.Path, []string{v.Language})
if err != nil || current.UUID != v.UUID {
http.NotFound(w, r)
return
}
reader, err := s.store.OpenDocument(v.DocumentHash)
if err != nil {
http.Error(w, "published document unavailable", 503)
return
}
body, err := io.ReadAll(io.LimitReader(reader, maxProjectionInput+1))
reader.Close()
if err != nil {
http.Error(w, "published document unavailable", 503)
return
}
sourceRequest := r.Clone(r.Context())
sourceRequest.Host = sourceHost
sourceRequest, err = s.withPublicNavigation(sourceRequest)
if err != nil {
http.Error(w, "publication unavailable", 503)
return
}
if strings.HasPrefix(v.ContentType, "text/html") {
_, data["Description"] = socialHTML(string(body))
safe := s.safeHTMLProjection(sourceRequest, string(body), item.Path, true)
data["HTML"] = template.HTML(projectedPeriodicalHTML(safe, item.Path, sourceHost, items, ""))
} else if strings.HasPrefix(v.ContentType, "text/") {
data["Text"] = string(body)
} else {
http.Error(w, "unsupported article type", 415)
return
}
data["PublicMediaOrigin"] = s.socialOrigin(sourceRequest)
data["Article"] = item
data["Title"] = item.Title
data["Canonical"] = s.socialOrigin(r) + item.Href
month, selected = item.Date[:7], item.Date
if articleIndex > 0 {
data["Newer"] = items[articleIndex-1]
}
if articleIndex+1 < len(items) {
data["Older"] = items[articleIndex+1]
}
}
filterMonth := month != "" || kind == "diary"
if month == "" {
month = time.Now().In(s.getLocation(projection.Source)).Format("2006-01")
}
first, _ := time.Parse("2006-01", month)
counts := map[string]int{}
filtered, inMonth := []periodicalItem{}, []periodicalItem{}
for _, item := range items {
if strings.HasPrefix(item.Date, month+"-") {
counts[item.Date]++
if len(inMonth) < 31 && (articleIndex < 0 || item.Path != items[articleIndex].Path) {
inMonth = append(inMonth, item)
}
}
if selected != "" && item.Date != selected {
continue
}
if filterMonth && !strings.HasPrefix(item.Date, month+"-") {
continue
}
filtered = append(filtered, item)
}
offset, _ := strconv.Atoi(r.URL.Query().Get("offset"))
offset = max(0, min(offset, len(filtered)))
end := min(offset+20, len(filtered))
data["Entries"] = filtered[offset:end]
pageLink := func(n int) string {
q := r.URL.Query()
q.Set("offset", strconv.Itoa(n))
return periodicalURL(r.URL.Path, q)
}
if offset > 0 {
data["Previous"] = pageLink(max(0, offset-20))
}
if end < len(filtered) {
data["Next"] = pageLink(end)
}
days := []periodicalDay{}
for i := 0; i < int(first.Weekday()); i++ {
days = append(days, periodicalDay{})
}
for d := first; d.Month() == first.Month(); d = d.AddDate(0, 0, 1) {
date := d.Format("2006-01-02")
days = append(days, periodicalDay{Number: d.Day(), Count: counts[date], Selected: date == selected, Href: periodicalDatePath(kind, month, date)})
}
monthLink := func(delta int) string {
d := first.AddDate(0, delta, 0)
if d.Year() < 1 || d.Year() > 9999 {
d = first
}
return periodicalDatePath(kind, d.Format("2006-01"), "")
}
data["Days"], data["Month"], data["MonthEntries"] = days, month, inMonth
data["PreviousMonth"], data["NextMonth"] = monthLink(-1), monthLink(1)
data["FilterMonth"] = month
if r.URL.Path == "/" && kind == "blog" {
data["FilterMonth"] = ""
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
s.render(w, "public_periodical.gohtml", data)
}
// Rewrite only already-sanitized links. Known public articles stay on the blog;
// all other source-relative links retain their original source-domain meaning.
func projectedPeriodicalHTML(body, sourcePath, sourceHost string, items []periodicalItem, absoluteOrigin string) string {
doc, err := html.Parse(strings.NewReader(body))
if err != nil {
return ""
}
local := map[string]string{}
for _, item := range items {
local[item.Path] = item.Href
}
base := &url.URL{Scheme: "https", Host: sourceHost, Path: sourcePath}
var visit func(*html.Node)
visit = func(n *html.Node) {
for i := range n.Attr {
a := &n.Attr[i]
if a.Key != "href" && a.Key != "src" {
continue
}
if strings.HasPrefix(a.Val, "#") {
if absoluteOrigin != "" {
a.Val = absoluteOrigin + local[sourcePath] + a.Val
}
continue
}
u, err := url.Parse(a.Val)
if err != nil {
continue
}
u = base.ResolveReference(u)
if a.Key == "href" && u.Host == sourceHost && local[u.Path] != "" {
mapped, _ := url.Parse(local[u.Path])
mapped.RawQuery = u.RawQuery
mapped.Fragment = u.Fragment
a.Val = mapped.String()
if absoluteOrigin != "" {
a.Val = absoluteOrigin + a.Val
}
} else {
a.Val = u.String()
}
}
for c := n.FirstChild; c != nil; c = c.NextSibling {
visit(c)
}
}
visit(doc)
var out strings.Builder
var emit func(*html.Node)
emit = func(n *html.Node) {
if n.Type == html.ElementNode && n.Data == "body" {
for c := n.FirstChild; c != nil; c = c.NextSibling {
_ = html.Render(&out, c)
}
return
}
for c := n.FirstChild; c != nil; c = c.NextSibling {
emit(c)
}
}
emit(doc)
return out.String()
}
type periodicalRSSItem struct {
Title string `xml:"title"`
Link string `xml:"link"`
GUID string `xml:"guid"`
Date string `xml:"pubDate"`
Content periodicalRSSContent `xml:"content:encoded"`
}
type periodicalRSSContent struct {
HTML string `xml:",cdata"`
}
type periodicalRSS struct {
XMLName xml.Name `xml:"rss"`
Version string `xml:"version,attr"`
ContentNamespace string `xml:"xmlns:content,attr"`
Channel struct {
Title string `xml:"title"`
Link string `xml:"link"`
Description string `xml:"description"`
Items []periodicalRSSItem `xml:"item"`
} `xml:"channel"`
}
func (s *Server) renderPeriodicalRSS(w http.ResponseWriter, r *http.Request, site, sourceHost, sourceDomain string, items []periodicalItem, revisions map[string]store.Revision) {
origin := s.socialOrigin(r)
if origin == "" {
http.Error(w, "feed origin unavailable", 503)
return
}
w.Header().Set("Content-Type", "application/rss+xml; charset=utf-8")
w.Header().Set("X-Content-Type-Options", "nosniff")
if r.Method == "HEAD" {
return
}
ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
defer cancel()
sourceRequest := r.Clone(ctx)
sourceRequest.Host = sourceHost
sourceRequest, err := s.withPublicNavigation(sourceRequest)
if err != nil {
http.Error(w, "publication unavailable", 503)
return
}
feed := periodicalRSS{Version: "2.0", ContentNamespace: "http://purl.org/rss/1.0/modules/content/"}
feed.Channel.Title = site
feed.Channel.Link = origin + "/"
feed.Channel.Description = site
contentBytes := 0
for _, item := range items[:min(20, len(items))] {
v := revisions[item.Path]
current, err := s.store.AnonymousRevision(ctx, sourceDomain, item.Path, []string{v.Language})
if err != nil || current.UUID != v.UUID {
http.Error(w, "publication changed; retry", 503)
return
}
reader, err := s.store.OpenDocument(v.DocumentHash)
if err != nil {
http.Error(w, "published document unavailable", 503)
return
}
raw, err := io.ReadAll(io.LimitReader(reader, maxProjectionInput+1))
reader.Close()
if err != nil || len(raw) > maxProjectionInput {
http.Error(w, "feed document exceeds rendering budget", 503)
return
}
content := ""
if strings.HasPrefix(v.ContentType, "text/html") {
content = projectedPeriodicalHTML(s.safeHTMLProjection(sourceRequest, string(raw), item.Path, true), item.Path, sourceHost, items, origin)
} else if strings.HasPrefix(v.ContentType, "text/") {
content = "<pre>" + stdhtml.EscapeString(string(raw)) + "</pre>"
}
if ctx.Err() != nil {
http.Error(w, "feed rendering timed out", 503)
return
}
contentBytes += len(content)
if contentBytes > 8<<20 {
http.Error(w, "feed exceeds rendering budget", 503)
return
}
link := origin + item.Href
feed.Channel.Items = append(feed.Channel.Items, periodicalRSSItem{Title: item.Title, Link: link, GUID: link, Date: time.UnixMilli(v.CreatedAtMS).UTC().Format(time.RFC1123Z), Content: periodicalRSSContent{HTML: content}})
}
body, err := xml.Marshal(feed)
if err != nil {
http.Error(w, "feed unavailable", 503)
return
}
w.Header().Set("Content-Type", "application/rss+xml; charset=utf-8")
w.Header().Set("X-Content-Type-Options", "nosniff")
if r.Method == "HEAD" {
return
}
_, _ = io.WriteString(w, xml.Header)
_, _ = w.Write(body)
}