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.
This commit is contained in:
Anya Tokugawa committed 2026-09-27 14:44:43 +09:00
1 parent 288e6e94ac
commit c1175d389f
699 files changed
+110197 -4117

No files matched your search

+259
View File
@@ -0,0 +1,259 @@
package server
import (
"context"
"errors"
"html/template"
"net/http"
"net/url"
"path"
"strings"
"time"
"unicode"
"golang.org/x/net/html"
"pageswiki/internal/store"
)
type searchViewResult struct {
store.SearchResult
Name string
Href string
NameParts []searchTextPart
PathParts []searchTextPart
ExcerptParts []searchTextPart
PreviewHTML template.HTML
Updated string
}
type searchTextPart struct {
Text string
Match bool
}
// Highlight only creates text segments. html/template, not source text or
// SQLite markers, owns every markup tag in the rendered result.
func highlightSearchText(value, query string) []searchTextPart {
runes := []rune(value)
lower := []rune(strings.ToLower(value))
matched := make([]bool, len(runes))
for _, word := range strings.Fields(strings.ToLower(query)) {
needle := []rune(word)
for i := 0; len(needle) > 0 && i+len(needle) <= len(lower); i++ {
if string(lower[i:i+len(needle)]) == word {
for j := i; j < i+len(needle); j++ {
matched[j] = true
}
}
}
}
var parts []searchTextPart
for start := 0; start < len(runes); {
end := start + 1
for end < len(runes) && matched[end] == matched[start] {
end++
}
parts = append(parts, searchTextPart{Text: string(runes[start:end]), Match: matched[start]})
start = end
}
return parts
}
func searchExcerpt(raw, contentType, query string) string {
if strings.HasPrefix(strings.ToLower(contentType), "text/html") {
tokenizer := html.NewTokenizer(strings.NewReader(raw))
var text strings.Builder
skip := ""
for {
kind := tokenizer.Next()
if kind == html.ErrorToken {
break
}
token := tokenizer.Token()
if kind == html.StartTagToken && (token.Data == "script" || token.Data == "style") {
skip = token.Data
continue
}
if kind == html.EndTagToken && token.Data == skip {
skip = ""
continue
}
if skip != "" {
continue
}
if kind == html.TextToken {
text.WriteString(token.Data)
} else {
text.WriteByte(' ')
}
}
raw = text.String()
}
raw = strings.Map(func(r rune) rune {
if unicode.IsControl(r) && !unicode.IsSpace(r) {
return -1
}
return r
}, raw)
runes := []rune(strings.Join(strings.Fields(raw), " "))
if len(runes) <= 260 {
return string(runes)
}
start := 0
lower := []rune(strings.ToLower(string(runes)))
for _, term := range strings.Fields(strings.ToLower(query)) {
if index := strings.Index(string(lower), term); index >= 0 {
position := len([]rune(string(lower)[:index]))
start = max(0, position-80)
break
}
}
start = min(start, len(runes)-260)
result := string(runes[start : start+260])
if start > 0 {
result = "… " + result
}
if start+260 < len(runes) {
result += " …"
}
return result
}
func (s *Server) handleSearch(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet && r.Method != http.MethodHead {
w.Header().Set("Allow", "GET, HEAD")
http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
return
}
query := strings.TrimSpace(r.URL.Query().Get("q"))
if len(query) > 512 || len(strings.Fields(query)) > 16 {
http.Error(w, translate(s.getLocale(s.domainUUIDForRequest(r)), "search.query_too_long"), http.StatusBadRequest)
return
}
scope := strings.TrimSpace(r.URL.Query().Get("scope"))
localityKind := strings.ToLower(strings.TrimSpace(r.URL.Query().Get("locality")))
localityID := strings.TrimSpace(r.URL.Query().Get("locality_id"))
if localityKind != "" {
scope = "/"
if localityKind != "domain" {
node, err := s.store.CityNodeContext(r.Context(), s.domainUUIDForRequest(r), localityKind, localityID)
if err != nil || !canReadCityNode(node, s.pathReadFilter(r)) {
http.Error(w, "unknown City locality", http.StatusBadRequest)
return
}
scope = node.PathPrefix
}
}
if scope == "" {
scope = "/"
}
scope = path.Clean("/" + strings.TrimLeft(scope, "/"))
allowed := s.pathReadFilter(r)
if !allowed(scope) {
http.Error(w, "forbidden", http.StatusForbidden)
return
}
domain := s.domainUUIDForRequest(r)
location := s.getLocation(domain)
options, filters, err := parseSearchOptions(r.URL.Query(), location)
if err != nil {
s.renderSearchFailure(w, r, query, scope, localityKind, localityID, err)
return
}
performed := query != "" || options.HasFilters()
var results []searchViewResult
var cityResults []searchCityViewResult
if performed {
// City metadata and Page search share the original request budget. Do
// not build the full City graph or traverse its Page placements here.
ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
defer cancel()
city, err := s.store.SearchCityInDomain(ctx, domain, scope, query, 30, allowed, options)
if err != nil {
s.renderSearchFailure(w, r, query, scope, localityKind, localityID, err)
return
}
for _, result := range city {
cityResults = append(cityResults, citySearchResultView(result, query, location))
}
found, err := s.store.SearchPathsInDomainWithOptions(
ctx, domain, scope, query, 100, allowed, options,
)
if err != nil {
s.renderSearchFailure(w, r, query, scope, localityKind, localityID, err)
return
}
for _, result := range found {
entry := store.BrowserEntry{
Path: result.Path, Filename: result.Filename,
ContentType: result.ContentType, Size: int(result.Size),
DocumentHash: result.DocumentHash,
RevisionUUID: result.RevisionUUID,
}
name := path.Base(result.Filename)
if result.Filename == "" {
name = path.Base(result.Path)
}
results = append(results, searchViewResult{
SearchResult: result,
Name: name,
Href: (&url.URL{Path: result.Path}).EscapedPath(),
NameParts: highlightSearchText(name, query),
PathParts: highlightSearchText(result.Path, query),
ExcerptParts: highlightSearchText(searchExcerpt(result.Excerpt, result.ContentType, query), query),
PreviewHTML: template.HTML(s.entryPreviewHTML(entry, false)),
Updated: time.Unix(result.UpdatedAt, 0).In(location).Format("2006-01-02 15:04"),
})
}
}
if r.Context().Err() != nil {
return
}
s.renderWithContext(w, r, "search.gohtml", map[string]any{
"Query": query, "Scope": scope, "Results": results,
"CityResults": cityResults, "CityLimitReached": len(cityResults) >= 30,
"SearchPerformed": performed, "Filters": filters,
"ResetHref": "/v/search?" + searchBaseValues(query, scope, localityKind, localityID).Encode(),
"ScopeHref": (&url.URL{Path: scope}).EscapedPath(), "ResultLimitReached": len(results) >= 100,
"LocalityKind": localityKind, "LocalityID": localityID,
})
}
// The store has its own bounded search budget. A timeout there is retryable,
// while a canceled HTTP request should not trigger more configuration reads or
// template work. Never expose database details or the raw error in the page.
func (s *Server) renderSearchFailure(w http.ResponseWriter, r *http.Request, query, scope, localityKind, localityID string, err error) {
if r.Context().Err() != nil || errors.Is(err, context.Canceled) {
return
}
status := http.StatusInternalServerError
title, hint := "search.failed_title", "search.failed_hint"
if errors.Is(err, store.ErrInvalidSearchOptions) {
status = http.StatusBadRequest
title, hint = "search.invalid_filters_title", "search.invalid_filters_hint"
} else if errors.Is(err, context.DeadlineExceeded) {
status = http.StatusServiceUnavailable
title, hint = "search.timeout_title", "search.timeout_hint"
w.Header().Set("Retry-After", "5")
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.Header().Set("Cache-Control", "private, no-store")
w.WriteHeader(status)
if r.Method == http.MethodHead {
return
}
retry := searchRetryValues(r, query, scope, localityKind, localityID)
filters := searchFiltersFromValues(r.URL.Query())
filters.Timezone = s.getTimezoneName(s.domainUUIDForRequest(r))
filters.Open = true
s.renderWithContext(w, r, "search.gohtml", map[string]any{
"Query": query, "Scope": scope,
"ScopeHref": (&url.URL{Path: scope}).EscapedPath(),
"LocalityKind": localityKind, "LocalityID": localityID,
"SearchError": true, "SearchErrorTitle": title, "SearchErrorHint": hint,
"SearchPerformed": true, "Filters": filters,
"ResetHref": "/v/search?" + searchBaseValues(query, scope, localityKind, localityID).Encode(),
"RetryHref": "/v/search?" + retry.Encode(),
})
}