Files
pages/internal/server/calendar_handler.go
2026-11-15 05:47:14 +09:00

477 lines
13 KiB
Go
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package server
import (
"context"
"encoding/base64"
"encoding/json"
"errors"
"net/http"
"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 = s.store.NewCalendarRepository(context.Background())
})
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
}
active, e := s.store.ActiveDomainMember(r.Context(), domain, id)
if e != nil || !active {
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
}