Files
pages/internal/server/public_navigation.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

488 lines
16 KiB
Go

package server
import (
"context"
"html"
"html/template"
"net/http"
"net/url"
"path"
"sort"
"strconv"
"strings"
"pageswiki/internal/store"
)
type publicNavigationKey struct{}
type publicNavigationSnapshot struct {
pages map[string]store.Revision
paths []string
branches map[string]bool
}
func publicNavigationFor(r *http.Request) *publicNavigationSnapshot {
v, _ := r.Context().Value(publicNavigationKey{}).(*publicNavigationSnapshot)
return v
}
func (p *publicNavigationSnapshot) allows(target string) bool { _, ok := p.pages[target]; return ok }
func (p *publicNavigationSnapshot) href(target string) string {
if p.allows(target) {
return cityPageHref(target)
}
return cityPageHref("/v/tree" + strings.TrimRight(target, "/"))
}
func (s *Server) withPublicNavigation(r *http.Request) (*http.Request, error) {
pages, err := s.publicNavigation(r.Context(), s.domainUUIDForRequest(r))
if err != nil {
return r, err
}
return s.withPublishedNavigation(r, pages)
}
func (s *Server) withPublishedNavigation(r *http.Request, pages []store.PublishedNavigationPage) (*http.Request, error) {
p := &publicNavigationSnapshot{pages: map[string]store.Revision{}, branches: map[string]bool{}}
priority := map[string]int{}
for i, lang := range s.revisionLanguageCandidates(r) {
priority[lang] = i + 1
}
for _, e := range pages {
if strings.Count(e.Path, "/") > 128 {
return r, store.ErrNavigationBudget
}
old, ok := p.pages[e.Path]
rank := priority[e.Revision.Language]
if rank == 0 {
rank = 10000
}
oldRank := priority[old.Language]
if oldRank == 0 {
oldRank = 10000
}
if !ok || rank < oldRank {
p.pages[e.Path] = e.Revision
}
if !ok {
p.paths = append(p.paths, e.Path)
for at := e.Path; ; at = path.Dir(at) {
p.branches[at] = true
if len(p.branches) > store.MaxNavigationEntries {
return r, store.ErrNavigationBudget
}
if at == "/" {
break
}
}
}
}
r = r.WithContext(context.WithValue(r.Context(), anonymousProjectionKey{}, true))
return r.WithContext(context.WithValue(r.Context(), publicNavigationKey{}, p)), nil
}
func publicNavigationRoute(target string) bool {
return target == "/v/children" || target == "/v/tree" || strings.HasPrefix(target, "/v/tree/") || target == "/v/browser" || strings.HasPrefix(target, "/v/browser/") || target == "/v/city" || target == "/_/api/v1/city/map"
}
func (s *Server) servePublicNavigation(w http.ResponseWriter, r *http.Request) bool {
if !publicNavigationRoute(r.URL.Path) {
return false
}
r, err := s.withPublicNavigation(r)
if err != nil {
http.Error(w, "navigation unavailable", 503)
return true
}
s.renderPublicNavigationRoute(w, r)
return true
}
func (s *Server) renderPublicNavigationRoute(w http.ResponseWriter, r *http.Request) {
p := publicNavigationFor(r)
privateCityResponse(w)
w.Header().Add("Vary", "Accept-Language")
switch {
case r.URL.Path == "/v/children":
args := parseChildrenMacroArgs("", r.URL.Query().Get("path"))
args.Excludes = splitExcludePatterns(r.URL.Query().Get("exclude"))
args.View = r.URL.Query().Get("view")
args.Offset, _ = strconv.Atoi(r.URL.Query().Get("offset"))
args.Limit, _ = strconv.Atoi(r.URL.Query().Get("limit"))
if args.Limit <= 0 || args.Limit > 400 {
args.Limit = 120
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
if r.Method != "HEAD" {
_, _ = w.Write([]byte(s.renderPublicChildren(r, args)))
}
case r.URL.Path == "/_/api/v1/city/map":
city, err := s.publicCityProjection(r)
if err != nil {
http.Error(w, "navigation unavailable", 503)
return
}
writeEventJSON(w, 200, city)
case r.URL.Path == "/v/city":
s.render(w, "city_map.gohtml", map[string]any{"Context": s.BuildRequestContext(r), "Locale": s.getLocale(s.domainUUIDForRequest(r)), "PublicNavigation": true, "CanPlan": false})
default:
prefix := "/v/tree"
directory := strings.HasPrefix(r.URL.Path, "/v/browser")
if directory {
prefix = "/v/browser"
}
scope := path.Clean("/" + strings.TrimPrefix(r.URL.Path, prefix))
if scope != "/" && !p.branches[scope] {
http.NotFound(w, r)
return
}
s.renderPublicDirectory(w, r, scope, directory)
}
}
func publicFolderHref(scope string) string {
return cityPageHref("/v/browser" + strings.TrimRight(scope, "/"))
}
func (s *Server) publicNavigationData(r *http.Request, scope string) map[string]any {
p := publicNavigationFor(r)
data := map[string]any{"Context": s.BuildRequestContext(r), "Locale": s.getLocale(s.domainUUIDForRequest(r)), "Path": scope, "PublicBreadcrumbs": publicBreadcrumbs(p, scope), "PublicFolderHref": publicFolderHref(scope), "PublicTreeHref": cityPageHref("/v/tree" + strings.TrimRight(scope, "/")), "PublicHasChildren": p.hasChildren(scope)}
if p.allows(scope) {
data["PublicPageHref"] = p.href(scope)
}
if scope != "/" {
data["PublicParentHref"] = publicFolderHref(path.Dir(scope))
}
return data
}
func (s *Server) renderPublicDirectory(w http.ResponseWriter, r *http.Request, scope string, directory bool) {
data := s.publicNavigationData(r, scope)
data["Directory"] = directory
if directory {
args := childrenMacroArgs{TargetPath: scope, Limit: 120, View: "list"}
args.Excludes = splitExcludePatterns(r.URL.Query().Get("exclude"))
if limit, _ := strconv.Atoi(r.URL.Query().Get("limit")); limit > 0 && limit <= 400 {
args.Limit = limit
}
args.Offset, _ = strconv.Atoi(r.URL.Query().Get("offset"))
if args.Offset < 0 || args.Offset > store.MaxNavigationEntries {
args.Offset = 0
}
data["PublicChildren"] = template.HTML(s.renderPublicChildren(r, args))
query := url.Values{"path": {scope}, "offset": {strconv.Itoa(args.Offset)}, "limit": {strconv.Itoa(args.Limit)}}
if len(args.Excludes) > 0 {
query.Set("exclude", strings.Join(args.Excludes, ","))
}
data["PublicChildrenSource"] = "/v/children?" + query.Encode()
if args.Offset > 0 {
query.Del("path")
query.Set("offset", strconv.Itoa(max(0, args.Offset-args.Limit)))
data["PublicPreviousBatch"] = publicFolderHref(scope) + "?" + query.Encode()
}
} else {
data["Nodes"] = publicTreeNodes(publicNavigationFor(r), scope)
}
privateCityResponse(w)
w.Header().Add("Vary", "Accept-Language")
s.render(w, "public_tree.gohtml", data)
}
func (p *publicNavigationSnapshot) hasChildren(scope string) bool {
prefix := strings.TrimRight(scope, "/") + "/"
for _, item := range p.paths {
if item != scope && strings.HasPrefix(item, prefix) {
return true
}
}
return false
}
type publicNavigationLink struct{ Name, Href string }
func publicBreadcrumbs(p *publicNavigationSnapshot, target string) []publicNavigationLink {
links := []publicNavigationLink{}
for at := target; ; at = path.Dir(at) {
if p.branches[at] {
name := path.Base(at)
if at == "/" {
name = "/"
}
links = append(links, publicNavigationLink{name, p.href(at)})
}
if at == "/" {
break
}
}
for i, j := 0, len(links)-1; i < j; i, j = i+1, j-1 {
links[i], links[j] = links[j], links[i]
}
return links
}
type publicTreeNode struct {
Name, Path, Href, FolderHref string
Depth int
IsDir bool
HasChildren bool
}
func publicTreeNodes(p *publicNavigationSnapshot, scope string) []publicTreeNode {
keys := []string{}
for item := range p.branches {
if item != scope && strings.HasPrefix(item, strings.TrimRight(scope, "/")+"/") {
keys = append(keys, item)
}
}
// Compare path components, not raw bytes: /a/x must precede /a-b.
// Tree collapse/keyboard navigation requires contiguous descendants.
order := make(map[string]string, len(keys))
for _, item := range keys {
order[item] = strings.ReplaceAll(item, "/", "\x00")
}
sort.Slice(keys, func(i, j int) bool { return order[keys[i]] < order[keys[j]] })
nodes := []publicTreeNode{}
parents := map[string]bool{}
for _, item := range keys {
parents[path.Dir(item)] = true
}
for _, item := range keys {
nodes = append(nodes, publicTreeNode{Name: path.Base(item), Path: item, Href: p.href(item), FolderHref: publicFolderHref(item), Depth: strings.Count(strings.TrimPrefix(item, strings.TrimRight(scope, "/")+"/"), "/"), IsDir: !p.allows(item), HasChildren: parents[item]})
}
return nodes
}
func (s *Server) renderPublicChildren(r *http.Request, args childrenMacroArgs) string {
p := publicNavigationFor(r)
if p == nil {
return ""
}
scope := path.Clean(args.TargetPath)
prefix := strings.TrimRight(scope, "/") + "/"
children := map[string]bool{}
hasChildren := map[string]bool{}
for _, item := range p.paths {
if !strings.HasPrefix(item, prefix) || item == scope || isExcludedPath(item, args.Excludes) {
continue
}
child := prefix + strings.Split(strings.TrimPrefix(item, prefix), "/")[0]
if !isExcludedPath(child, args.Excludes) {
children[child] = true
if item != child {
hasChildren[child] = true
}
}
}
keys := []string{}
for child := range children {
keys = append(keys, child)
}
sort.Strings(keys)
start := args.Offset
if start < 0 {
start = 0
}
if start > len(keys) {
start = len(keys)
}
limit := args.Limit
if limit <= 0 || limit > 400 {
limit = 120
}
end := min(start+limit, len(keys))
var out strings.Builder
browseLabel := translate(s.getLocale(s.domainUUIDForRequest(r)), "public.navigation.browse")
class := "public-children-list"
if args.View == "icon" {
class = "public-children-icons"
} else if args.View == "detail" {
class = "public-children-details"
}
out.WriteString(`<ul class="` + class + `">`)
for _, child := range keys[start:end] {
icon := "📄"
if !p.allows(child) {
icon = "📁"
}
out.WriteString(`<li><a class="public-child-link" href="` + html.EscapeString(p.href(child)) + `"><span aria-hidden="true">` + icon + `</span><span>` + html.EscapeString(path.Base(child)) + `</span></a>`)
if hasChildren[child] {
out.WriteString(`<a class="public-child-folder" href="` + html.EscapeString(publicFolderHref(child)) + `" aria-label="` + html.EscapeString(browseLabel+": "+path.Base(child)) + `" title="` + html.EscapeString(browseLabel) + `">▤</a>`)
}
if args.View == "detail" {
out.WriteString(` <small>` + html.EscapeString(child) + `</small>`)
}
out.WriteString(`</li>`)
}
out.WriteString(`</ul>`)
if len(keys) == 0 {
out.WriteString(`<p class="muted">` + html.EscapeString(translate(s.getLocale(s.domainUUIDForRequest(r)), "public.navigation.empty")) + `</p>`)
}
args.TargetPath = scope
args.Limit = limit
if end < len(keys) {
query := url.Values{"path": {scope}, "view": {args.View}, "offset": {strconv.Itoa(end)}, "limit": {strconv.Itoa(limit)}}
if len(args.Excludes) > 0 {
query.Set("exclude", strings.Join(args.Excludes, ","))
}
// The link works without JavaScript; enhanced views replace it with
// automatic lazy continuation. The next URL never counts private rows.
out.WriteString(`<div class="children-next" data-children-next="` + html.EscapeString("/v/children?"+query.Encode()) + `">`)
query.Del("path")
out.WriteString(`<a href="` + html.EscapeString(publicFolderHref(scope)+"?"+query.Encode()) + `">` + html.EscapeString(translate(s.getLocale(s.domainUUIDForRequest(r)), "public.navigation.next_batch")) + `</a></div>`)
}
return out.String()
}
func (s *Server) expandPublicMacro(r *http.Request, macro, currentPath string) string {
p := publicNavigationFor(r)
if p == nil {
return macro
}
if strings.HasPrefix(macro, "{{children") {
match := childrenMacroRe.FindStringSubmatch(macro)
if len(match) < 2 {
return macro
}
args := parseChildrenMacroArgs(match[1], currentPath)
fallback := `<a href="` + html.EscapeString(publicFolderHref(args.TargetPath)) + `">` + html.EscapeString(translate(s.getLocale(s.domainUUIDForRequest(r)), "public.navigation.browse")) + `</a>`
return strings.Replace(s.expandChildrenMacros(macro, currentPath), `<div class="children-loading" role="status">Loading…</div>`, fallback, 1)
}
if macro == "{{city-breadcrumbs}}" {
var out strings.Builder
out.WriteString(`<nav>`)
for _, link := range publicBreadcrumbs(p, currentPath) {
out.WriteString(`<a href="` + html.EscapeString(link.Href) + `">` + html.EscapeString(link.Name) + `</a> / `)
}
out.WriteString(`</nav>`)
return out.String()
}
if macro == "{{city}}" {
return `<a href="/v/city">` + html.EscapeString(translate(s.getLocale(s.domainUUIDForRequest(r)), "city.map")) + `</a>`
}
match := cityMacroRe.FindStringSubmatch(macro)
if len(match) > 1 && (match[1] == "quartier" || match[1] == "street" || match[1] == "spot" || match[1] == "spot-pages") {
city, err := s.publicCityProjection(r)
if err != nil {
return macro
}
within := func(scope string) bool {
return currentPath == scope || strings.HasPrefix(currentPath, strings.TrimRight(scope, "/")+"/")
}
link := func(href, label string) string {
return `<a href="` + html.EscapeString(href) + `">` + html.EscapeString(label) + `</a>`
}
for _, q := range city.Quartiers {
if !within(q.PathPrefix) {
continue
}
if match[1] == "quartier" {
return link(q.DetailHref, q.Title)
}
for _, st := range q.Streets {
if !within(st.PathPrefix) {
continue
}
if match[1] == "street" {
return link(st.DetailHref, st.Title)
}
for _, sp := range st.Spots {
has := within(sp.PathPrefix)
for _, page := range sp.Pages {
if page.Path == currentPath {
has = true
}
}
if !has {
continue
}
if match[1] == "spot" {
return link(sp.DetailHref, sp.Title)
}
var out strings.Builder
out.WriteString(`<ul>`)
for _, page := range sp.Pages {
out.WriteString(`<li>` + link(cityPageHref(page.Path), page.Label) + `</li>`)
}
out.WriteString(`</ul>`)
return out.String()
}
}
}
return `<span>—</span>`
}
return macro
}
func (s *Server) publicCityProjection(r *http.Request) (store.CityMap, error) {
p := publicNavigationFor(r)
city, err := s.navigationCity(r.Context(), s.domainUUIDForRequest(r))
if err != nil {
return city, err
}
// The hierarchy comes from actual topology, but labels/links/counts only
// disclose approved semantic Paths. A private parent's custom prose is not
// published merely because it contains an approved descendant.
visible := map[string]bool{}
for item := range p.branches {
visible[item] = true
}
for _, q := range city.Quartiers {
for _, st := range q.Streets {
for _, sp := range st.Spots {
for _, page := range sp.Pages {
if p.allows(page.Path) && strings.HasPrefix(page.Path, strings.TrimRight(st.PathPrefix, "/")+"/") && strings.HasSuffix(sp.PathPrefix, "/_undefined") {
visible[sp.PathPrefix] = true
}
}
}
}
}
city = filterCityProjection(city, func(item string) bool { return visible[item] })
city.Relations = []store.CitySpotRelation{}
for qi := range city.Quartiers {
q := &city.Quartiers[qi]
q.Name = path.Base(q.PathPrefix)
q.Title = q.Name
q.Description = ""
q.State = "active"
q.SortKey = 0
q.DetailHref = "/v/city?quartier=" + url.QueryEscape(q.UUID)
for si := range q.Streets {
st := &q.Streets[si]
st.Name = path.Base(st.PathPrefix)
st.Title = st.Name
st.Description = ""
st.State = "active"
st.SortKey = 0
st.DetailHref = "/v/city?street=" + url.QueryEscape(st.UUID)
for pi := range st.Spots {
sp := &st.Spots[pi]
sp.Name = path.Base(sp.PathPrefix)
sp.Title = sp.Name
sp.Summary = ""
sp.State = "active"
sp.SortKey = 0
sp.DetailHref = "/v/city?spot=" + url.QueryEscape(sp.UUID)
sp.PortalPath = ""
sp.PortalPageUUID = ""
pages := []store.CityPagePlacement{}
seen := map[string]bool{}
for _, page := range sp.Pages {
if !p.allows(page.Path) {
continue
}
page = store.CityPagePlacement{Path: page.Path, PageUUID: p.pages[page.Path].ObjectUUID, Label: path.Base(page.Path), EdgeType: "primary"}
pages = append(pages, page)
seen[page.PageUUID] = true
if sp.PortalPath == "" || page.Path == sp.PathPrefix {
sp.PortalPath = page.Path
sp.PortalPageUUID = page.PageUUID
}
}
sp.Pages = pages
sp.PageCount = len(seen)
}
}
}
return city, nil
}