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

+484
View File
@@ -0,0 +1,484 @@
package server
import (
"encoding/base64"
"encoding/json"
"errors"
"net/http"
"path/filepath"
"strings"
"time"
"github.com/google/uuid"
"pageswiki/internal/calendar"
)
const calendarAPI = "/_/api/v1/extension/organizer.calendar/"
const calendarDAV = "/_/api/v1/caldav/"
const davCredentialsAPI = "/_/api/v1/caldav-credentials"
func calendarRoute(path string) bool {
return path == "/v/plan" || strings.HasPrefix(path, "/v/plan/") || strings.HasPrefix(path, "/v/event/") || path == "/v/calendar" || strings.HasPrefix(path, calendarAPI) || strings.HasPrefix(path, calendarDAV) || path == strings.TrimSuffix(calendarDAV, "/") || path == davCredentialsAPI || strings.HasPrefix(path, davCredentialsAPI+"/")
}
func (s *Server) registerCalendarRoutes() {
for _, p := range []string{"/v/plan", "/v/plan/", "/v/event/", "/v/calendar"} {
s.mux.HandleFunc(p, s.handleCalendarPage)
}
s.mux.HandleFunc(calendarAPI, s.handleCalendarAPI)
s.mux.HandleFunc(calendarDAV, s.handleCalendarDAV)
s.mux.HandleFunc(strings.TrimSuffix(calendarDAV, "/"), s.handleCalendarDAV)
s.mux.HandleFunc(davCredentialsAPI, s.handleDAVCredentials)
s.mux.HandleFunc(davCredentialsAPI+"/", s.handleDAVCredentials)
}
func (s *Server) calendars() (*calendar.Repository, error) {
s.calendarOnce.Do(func() {
if s.store.DocumentRoot == "" {
s.calendarErr = errors.New("calendar storage unavailable")
return
}
s.calendarRepo, s.calendarErr = calendar.New(filepath.Join(s.store.DocumentRoot, "calendars"), s.store.DB)
if s.calendarErr == nil {
s.calendarRepo.PublicAllowed = func(domain string) bool {
var allowed bool
err := s.store.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM locality_publication_policies p JOIN domains d ON d.uuid=p.domain_uuid AND d.enabled=1 JOIN config c ON c.domain_uuid=p.domain_uuid AND c.key='authorization_mode' AND c.value='enforcing' WHERE p.domain_uuid=? AND p.node_kind='domain' AND p.node_uuid=p.domain_uuid AND p.policy='public')`, domain).Scan(&allowed)
return err == nil && allowed
}
}
})
return s.calendarRepo, s.calendarErr
}
func (s *Server) calendarActor(r *http.Request) (string, bool) {
p, e := s.store.PrincipalForSession(s.domainUUIDForRequest(r), s.authTokenFromRequest(r))
if e != nil {
return "", false
}
return p.UUID, p.State == "active"
}
func (s *Server) calendarReady(w http.ResponseWriter, r *http.Request) (*calendar.Repository, bool) {
if !s.systemExtensionEnabled(s.domainUUIDForRequest(r), "organizer.calendar") {
http.NotFound(w, r)
return nil, false
}
repo, e := s.calendars()
if e != nil {
http.Error(w, "calendar storage unavailable", 503)
return nil, false
}
return repo, true
}
func calendarError(w http.ResponseWriter, e error) {
status := 500
message := "calendar operation failed"
switch {
case errors.Is(e, calendar.ErrMissing):
status = 404
message = "calendar or event not found"
case errors.Is(e, calendar.ErrForbidden):
status = 403
message = e.Error()
case errors.Is(e, calendar.ErrConflict):
status = 412
message = "The calendar changed. Reload before saving."
case errors.Is(e, calendar.ErrPreconditionRequired):
status = 428
message = "If-Match required"
case errors.Is(e, calendar.ErrNameTaken):
status = 409
message = e.Error()
case errors.Is(e, calendar.ErrInvalid):
status = 422
message = e.Error()
case errors.Is(e, calendar.ErrLimit):
status = 507
message = e.Error()
}
writeEventJSON(w, status, map[string]string{"error": message})
}
func calendarHref(id, uid string) string {
return calendarDAV + id + "/" + base64.RawURLEncoding.EncodeToString([]byte(uid)) + ".ics"
}
func calendarUID(filename string) (string, error) {
if !strings.HasSuffix(filename, ".ics") {
return "", calendar.ErrMissing
}
b, e := base64.RawURLEncoding.DecodeString(strings.TrimSuffix(filename, ".ics"))
if e != nil || len(b) == 0 || len(b) > 512 {
return "", calendar.ErrMissing
}
return string(b), nil
}
func decodeCalendarJSON(w http.ResponseWriter, r *http.Request, dst any) bool {
d := json.NewDecoder(http.MaxBytesReader(w, r.Body, calendar.MaxResource))
d.DisallowUnknownFields()
if e := d.Decode(dst); e != nil {
http.Error(w, "invalid JSON", 400)
return false
}
return true
}
func (s *Server) handleCalendarAPI(w http.ResponseWriter, r *http.Request) {
repo, ok := s.calendarReady(w, r)
if !ok {
return
}
domain := s.domainUUIDForRequest(r)
actor, active := s.calendarActor(r)
path := strings.Trim(strings.TrimPrefix(r.URL.Path, calendarAPI), "/")
parts := strings.Split(path, "/")
if path == "upcoming" {
s.handleCalendarUpcoming(w, r, repo, domain, actor)
return
}
if len(parts) == 3 && parts[0] == "calendars" && parts[2] == "source" {
s.handleCalendarSource(w, r, repo, domain, parts[1], actor, active)
return
}
if path == "preferences" {
if actor == "" {
calendarError(w, calendar.ErrForbidden)
return
}
if r.Method != "PUT" {
w.WriteHeader(405)
return
}
var body struct {
Calendars []string `json:"calendars"`
}
if !decodeCalendarJSON(w, r, &body) {
return
}
if err := repo.SaveDefaults(r.Context(), domain, actor, body.Calendars); err != nil {
calendarError(w, err)
return
}
writeEventJSON(w, 200, map[string]any{"calendars": body.Calendars})
return
}
if path == "event" && r.Method == "GET" {
cs, e := repo.List(domain, actor)
if e != nil {
calendarError(w, e)
return
}
if len(cs) > 256 {
calendarError(w, calendar.ErrLimit)
return
}
var found *calendar.Event
id := ""
for _, c := range cs {
v, e := repo.Event(r.Context(), domain, c.ID, actor, r.URL.Query().Get("uid"))
if errors.Is(e, calendar.ErrMissing) {
continue
}
if e != nil {
calendarError(w, e)
return
}
if found != nil {
writeEventJSON(w, 409, map[string]string{"error": "UID exists in multiple calendars; select a calendar"})
return
}
found = &v
id = c.ID
}
if found == nil {
calendarError(w, calendar.ErrMissing)
return
}
writeEventJSON(w, 200, map[string]any{"calendar": id, "event": found})
return
}
if path == "calendars" {
switch r.Method {
case "GET":
cs, e := repo.List(domain, actor)
if e != nil {
calendarError(w, e)
return
}
for i := range cs {
cs[i].Months = nil
if cs[i].Source != nil {
source := *cs[i].Source
source.HasCredential = source.Credential != ""
source.Credential = ""
source.Resources = nil
cs[i].Source = &source
}
if cs[i].Owner != actor {
cs[i].Source = nil // source URLs may contain private subscription tokens
role := cs[i].Members[actor]
cs[i].Members = map[string]string{}
if actor != "" && role != "" {
cs[i].Members[actor] = role
}
}
}
defaults, e := repo.Defaults(domain, actor)
if e != nil {
calendarError(w, e)
return
}
writeEventJSON(w, 200, map[string]any{"calendars": cs, "actor": actor, "active": active, "public_allowed": repo.PublicAllowed(domain), "defaults": defaults})
case "POST":
if !active {
calendarError(w, calendar.ErrForbidden)
return
}
var body struct {
Name string `json:"name"`
PrettyName *string `json:"pretty_name"`
}
if !decodeCalendarJSON(w, r, &body) {
return
}
var pretty []string
if body.PrettyName != nil {
if !calendar.ValidPrettyName(*body.PrettyName) {
writeEventJSON(w, 422, map[string]string{"error": "pretty_name: use letters, numbers, - or _ (1–120 UTF-8 bytes; no commas, spaces or UUIDs)"})
return
}
pretty = []string{*body.PrettyName}
}
c, e := repo.Create(r.Context(), domain, actor, body.Name, pretty...)
if e != nil {
calendarError(w, e)
return
}
writeEventJSON(w, 201, c)
default:
w.Header().Set("Allow", "GET, POST")
w.WriteHeader(405)
}
return
}
if len(parts) == 3 && parts[0] == "calendars" && parts[2] == "settings" {
if r.Method != "PUT" && r.Method != "DELETE" {
w.Header().Set("Allow", "PUT, DELETE")
w.WriteHeader(405)
return
}
if !active {
calendarError(w, calendar.ErrForbidden)
return
}
c, err := repo.Get(domain, parts[1], actor)
if err != nil {
calendarError(w, err)
return
}
if c.Owner != actor {
calendarError(w, calendar.ErrForbidden)
return
}
if r.Method == "DELETE" {
var body struct {
Version string `json:"version"`
}
if !decodeCalendarJSON(w, r, &body) {
return
}
if body.Version == "" || body.Version != c.Version {
calendarError(w, calendar.ErrConflict)
return
}
if err := s.store.CancelEventJobsByTypeKey(calendarSyncType, domain+":"+c.ID); err != nil {
calendarError(w, err)
return
}
if err := repo.Delete(r.Context(), domain, c.ID, actor, body.Version); err != nil {
calendarError(w, err)
return
}
w.WriteHeader(http.StatusNoContent)
return
}
var body struct {
Name string `json:"name"`
Public bool `json:"public"`
Members map[string]string `json:"members"`
Version string `json:"version"`
PrettyName *string `json:"pretty_name"`
}
if !decodeCalendarJSON(w, r, &body) {
return
}
// Only existing local-domain users may be collaborators.
members := map[string]string{}
for id, role := range body.Members {
if _, e := uuid.Parse(id); e != nil {
p, e := s.store.PrincipalByUsername(domain, id)
if e != nil {
http.Error(w, "unknown collaborator", 400)
return
}
id = p.UUID
}
var count int
e := s.store.DB.QueryRowContext(r.Context(), `SELECT COUNT(*) FROM domain_memberships WHERE domain_uuid=? AND principal_uuid=? AND state='active'`, domain, id).Scan(&count)
if e != nil || count != 1 {
http.Error(w, "unknown collaborator", 400)
return
}
members[id] = role
}
body.Members = members
var pretty []string
if body.PrettyName != nil {
if !calendar.ValidPrettyName(*body.PrettyName) {
writeEventJSON(w, 422, map[string]string{"error": "pretty_name: use letters, numbers, - or _ (1–120 UTF-8 bytes; no commas, spaces or UUIDs)"})
return
}
pretty = []string{*body.PrettyName}
}
c, e := repo.Settings(r.Context(), domain, parts[1], actor, body.Version, body.Name, body.Public, body.Members, pretty...)
if e != nil {
calendarError(w, e)
return
}
c.Months = nil
if c.Source != nil {
c.Source.HasCredential = c.Source.Credential != ""
c.Source.Credential = ""
c.Source.Resources = nil
}
writeEventJSON(w, 200, c)
return
}
if len(parts) == 3 && parts[0] == "calendars" && parts[2] == "events" {
if r.Method == "GET" {
uid := r.URL.Query().Get("uid")
if resource := r.URL.Query().Get("resource"); resource != "" {
c, err := repo.Get(domain, parts[1], actor)
if err != nil {
calendarError(w, err)
return
}
uid, err = calendar.DAVUID(c, resource)
if err != nil {
calendarError(w, err)
return
}
}
v, e := repo.Event(r.Context(), domain, parts[1], actor, uid)
if e != nil {
calendarError(w, e)
return
}
writeEventJSON(w, 200, v)
return
}
if r.Method != "POST" {
w.WriteHeader(405)
return
}
if !active {
calendarError(w, calendar.ErrForbidden)
return
}
var body struct {
UID string `json:"uid"`
Summary string `json:"summary"`
Description string `json:"description"`
Location string `json:"location"`
Start time.Time `json:"start"`
End time.Time `json:"end"`
AllDay bool `json:"all_day"`
ETag string `json:"etag"`
}
if !decodeCalendarJSON(w, r, &body) {
return
}
old := ""
match := "*"
status := 201
if body.UID != "" {
v, e := repo.Event(r.Context(), domain, parts[1], actor, body.UID)
if e != nil {
calendarError(w, e)
return
}
old = v.Data
match = body.ETag
status = 200
} else {
body.UID = uuid.NewString()
}
v, e := calendar.Build(old, calendar.Event{UID: body.UID, Summary: body.Summary, Description: body.Description, Location: body.Location, Start: body.Start, End: body.End, AllDay: body.AllDay})
if e != nil {
calendarError(w, e)
return
}
v, e = repo.Change(r.Context(), domain, parts[1], actor, body.UID, match, &v)
if e != nil {
calendarError(w, e)
return
}
w.Header().Set("Location", calendarHref(parts[1], v.UID))
w.Header().Set("ETag", v.ETag)
writeEventJSON(w, status, v)
return
}
http.NotFound(w, r)
}
func (s *Server) handleCalendarPage(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" && r.Method != "HEAD" {
w.WriteHeader(405)
return
}
if _, ok := s.calendarReady(w, r); !ok {
return
}
if r.URL.Path == "/v/calendar" {
http.Redirect(w, r, "/v/plan", 302)
return
}
actor, _ := s.calendarActor(r)
edit := strings.HasPrefix(r.URL.Path, "/v/event/") || strings.HasSuffix(r.URL.Path, "/new")
if edit && actor == "" {
s.authRequired(w, r)
return
}
// The client parses only these URI shapes; malformed dates must be real 404s.
if !validCalendarViewPath(r.URL.Path) {
http.NotFound(w, r)
return
}
s.renderWithContext(w, r, "calendar.gohtml", map[string]any{"Title": "Calendar", "CalendarActor": actor, "CalendarTimezone": s.getTimezoneName(s.domainUUIDForRequest(r)), "Path": r.URL.Path})
}
func validCalendarViewPath(path string) bool {
if path == "/v/plan" || path == "/v/plan/" || path == "/v/event/new" {
return true
}
if strings.HasPrefix(path, "/v/plan/event/") {
return len(strings.TrimPrefix(path, "/v/plan/event/")) > 0
}
if strings.HasPrefix(path, "/v/event/") {
return strings.HasSuffix(path, "/edit") && len(strings.TrimSuffix(strings.TrimPrefix(path, "/v/event/"), "/edit")) > 0
}
if !strings.HasPrefix(path, "/v/plan/cal/") {
return false
}
p := strings.Split(strings.TrimPrefix(path, "/v/plan/cal/"), "/")
if len(p) == 5 && p[3] == "week" && p[4] == "list" {
p = p[:3]
}
if len(p) > 4 || len(p) < 1 {
return false
}
if len(p) == 4 {
switch p[3] {
case "week", "timeline", "events", "new":
default:
return false
}
p = p[:3]
}
layout := []string{"2006", "2006/01", "2006/01/02"}[len(p)-1]
v := strings.Join(p, "/")
t, e := time.Parse(layout, v)
return e == nil && t.Year() > 0 && t.Year() < 9999 && t.Format(layout) == v
}