package server
import (
"context"
"database/sql"
"encoding/xml"
"errors"
"io"
"mime"
"net/http"
"net/url"
"strings"
"time"
"github.com/google/uuid"
mw "pageswiki/internal/server/middleware"
"pageswiki/internal/store"
)
const taskDAVRoot = calendarDAV + "tasks/"
const taskDAVCollection = taskDAVRoot + "default/"
func taskDAVName(item store.TaskRecord) string {
if item.CalDAV != nil {
return item.CalDAV.Name
}
return item.UUID + ".ics"
}
func taskDAVError(w http.ResponseWriter, status int, condition, message string) {
w.Header().Set("Content-Type", "application/xml; charset=utf-8")
w.WriteHeader(status)
io.WriteString(w, ``+xmlText(message)+``)
}
func taskDAVCollectionRow() davResponse {
return davResponse{href: taskDAVCollection, props: map[xml.Name]string{
{Space: davNS, Local: "displayname"}: store.DefaultTaskDAVTitle,
{Space: davNS, Local: "resourcetype"}: "",
{Space: calNS, Local: "supported-calendar-component-set"}: ``,
{Space: calNS, Local: "supported-calendar-data"}: ``,
{Space: calNS, Local: "max-resource-size"}: "32768",
{Space: davNS, Local: "supported-report-set"}: ``,
}}
}
func taskDAVRow(item store.TaskRecord, prefixes ...string) (davResponse, error) {
prefix := taskDAVCollection
if len(prefixes) == 1 {
prefix = prefixes[0]
}
data, tag, e := taskICAL(item)
return davResponse{href: prefix + taskDAVName(item), props: map[xml.Name]string{
{Space: davNS, Local: "resourcetype"}: "", {Space: davNS, Local: "getetag"}: xmlText(tag), {Space: davNS, Local: "getcontenttype"}: "text/calendar; charset=utf-8", {Space: calNS, Local: "calendar-data"}: xmlText(data),
{Space: davNS, Local: "getlastmodified"}: time.UnixMilli(item.UpdatedMS).UTC().Format(http.TimeFormat),
}}, e
}
func (s *Server) handleTaskDAV(w http.ResponseWriter, r *http.Request) {
if rest, ok := strings.CutPrefix(r.URL.Path, taskDAVRoot+"projects/"); ok {
id := strings.Split(rest, "/")[0]
parsed, err := uuid.Parse(id)
if err != nil || parsed.String() != id {
http.NotFound(w, r)
return
}
s.handleTaskDAVAt(w, r, "tasks/projects/"+id)
return
}
s.handleTaskDAVAt(w, r, "")
}
func (s *Server) handleTaskDAVAt(w http.ResponseWriter, r *http.Request, collectionPath string) {
if collectionPath != "" {
mw.SetDAVTaskTarget(r, strings.TrimSuffix(r.URL.Path, "/") != calendarDAV+collectionPath)
}
w.Header().Set("Cache-Control", "private, no-store")
domain := s.domainUUIDForRequest(r)
if !s.systemExtensionEnabled(domain, "organizer.tasks") {
http.NotFound(w, r)
return
}
ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
defer cancel()
r = r.WithContext(ctx)
actor, write, credential := "", false, ""
if len(r.Header.Values("Authorization")) == 1 {
if user, pass, ok := r.BasicAuth(); ok {
var err error
actor, write, err = s.store.AuthenticateTaskDAV(ctx, domain, user, pass)
if err != nil {
actor = ""
mw.SetDAVAuthOutcome(r, "basic_rejected")
} else {
mw.SetDAVAuthOutcome(r, "basic_accepted")
}
credential = user
} else {
actor, write = s.calendarActor(r)
mw.SetDAVAuthOutcome(r, "invalid_authorization")
if actor != "" {
mw.SetDAVAuthOutcome(r, "session_accepted")
}
}
} else if len(r.Header.Values("Authorization")) == 0 {
actor, write = s.calendarActor(r)
mw.SetDAVAuthOutcome(r, "missing")
if actor != "" {
mw.SetDAVAuthOutcome(r, "session_accepted")
}
} else {
mw.SetDAVAuthOutcome(r, "multiple_authorization")
}
if actor == "" {
w.Header().Set("WWW-Authenticate", `Basic realm="PagesWiki task CalDAV", charset="UTF-8"`)
w.WriteHeader(401)
return
}
s.setDAVCapabilities(w, r, actor, credential)
prefix, project, title := taskDAVCollection, "", store.DefaultTaskDAVTitle
if collectionPath != "" {
v, err := s.store.TaskDAVCollection(ctx, domain, actor, collectionPath)
if err != nil {
taskError(w, err)
return
}
prefix, project, title = calendarDAV+collectionPath+"/", v.UUID, v.Title
} else {
var err error
title, err = s.store.TaskDAVDefaultTitle(ctx, domain, actor)
if err != nil {
taskError(w, err)
return
}
}
w.Header().Set("Allow", "OPTIONS, PROPFIND, REPORT, GET, HEAD, PUT, DELETE")
if collectionPath == "" && strings.TrimSuffix(r.URL.Path, "/") == strings.TrimSuffix(taskDAVCollection, "/") {
w.Header().Set("Allow", "OPTIONS, PROPFIND, PROPPATCH, REPORT, GET, HEAD, PUT, DELETE")
}
if r.Method == "OPTIONS" {
w.WriteHeader(204)
return
}
root := collectionPath == "" && strings.TrimSuffix(r.URL.Path, "/") == strings.TrimSuffix(taskDAVRoot, "/")
collection := strings.TrimSuffix(r.URL.Path, "/") == strings.TrimSuffix(prefix, "/")
name := strings.TrimPrefix(r.URL.Path, prefix)
if !root && !collection && (!strings.HasPrefix(r.URL.Path, prefix) || !store.ValidTaskDAVName(name)) {
http.NotFound(w, r)
return
}
if r.Method == "PROPFIND" || r.Method == "REPORT" {
s.handleTaskDAVListing(w, r, domain, actor, root, collection, name, write, prefix, project, title)
return
}
if r.Method == "PROPPATCH" && collection && project == "" {
if !write {
taskError(w, store.ErrAccessDenied)
return
}
s.handleTaskDAVDefaultProperties(w, r, domain, actor, credential)
return
}
if root || collection {
w.WriteHeader(405)
return
}
item, err := s.store.TaskDAVByName(ctx, domain, actor, name, project)
exists := err == nil && !item.Archived
if err != nil && !errors.Is(err, sql.ErrNoRows) {
taskError(w, err)
return
}
if r.Method == "GET" || r.Method == "HEAD" {
if !exists {
http.NotFound(w, r)
return
}
data, tag, e := taskICAL(item)
if e != nil {
taskError(w, e)
return
}
w.Header().Set("ETag", tag)
w.Header().Set("Content-Type", "text/calendar; charset=utf-8")
if r.Header.Get("If-None-Match") == tag || r.Header.Get("If-None-Match") == "*" {
w.WriteHeader(304)
return
}
if r.Method == "GET" {
io.WriteString(w, data)
}
return
}
if r.Method != "PUT" && r.Method != "DELETE" {
w.WriteHeader(405)
return
}
if !write {
taskError(w, store.ErrAccessDenied)
return
}
mutate := func(v store.TaskRecord) store.TaskRecord { v.Archived = true; return v }
var data *store.TaskDAVData
if r.Method == "PUT" {
contentType, _, e := mime.ParseMediaType(r.Header.Get("Content-Type"))
if e != nil || contentType != "text/calendar" {
w.WriteHeader(415)
return
}
raw, e := io.ReadAll(http.MaxBytesReader(w, r.Body, 32768))
if e != nil {
w.WriteHeader(413)
return
}
cal, e := parseTaskICAL(string(raw))
if e != nil {
taskDAVError(w, 403, "valid-calendar-data", e.Error())
return
}
uid, _ := cal.Children[0].Props.Text("UID")
encoded, e := encodeTaskICAL(cal)
if e != nil {
taskError(w, e)
return
}
data = &store.TaskDAVData{Name: name, UID: uid, Data: encoded}
mutate = func(v store.TaskRecord) store.TaskRecord {
v = taskFromICAL(cal, v)
v.Archived = false
return v
}
}
unconditional := r.Header.Get("If-Match") == "" && r.Header.Get("If-None-Match") == ""
// Accept unconditional client writes as last-committed-writer-wins, without
// weakening the store's CAS transaction. Rebase only DAV fields on each
// retry; never overwrite newer Web-only metadata with a stale task record.
originalID := item.UUID
for attempt := 0; attempt < 8; attempt++ {
if !taskDAVWritePreconditions(w, r, item, exists) {
return
}
if r.Method == "DELETE" && !exists {
http.NotFound(w, r)
return
}
candidate := item
if candidate.UUID == "" {
candidate = store.TaskRecord{UUID: uuid.NewString(), Kind: "task", Bucket: "inbox", ProjectUUID: project}
}
saved, e := s.store.SaveTaskDAV(ctx, domain, actor, mutate(candidate), item.Version, data, credential, project)
if e == nil {
if r.Method == "PUT" {
w.Header().Set("Location", prefix+taskDAVName(saved))
}
// The representation is normalized: no PUT ETag (RFC 9110).
if r.Method == "PUT" && !exists {
w.WriteHeader(201)
} else {
w.WriteHeader(204)
}
return
}
if unconditional && (errors.Is(e, store.ErrTaskConflict) || item.UUID == "" && errors.Is(e, store.ErrTaskDAVIdentity)) {
fresh, readErr := s.store.TaskDAVByName(ctx, domain, actor, name, project)
if readErr == nil && (originalID == "" || fresh.UUID == originalID) {
item, exists = fresh, !fresh.Archived
originalID = fresh.UUID
continue
}
if readErr != nil && !errors.Is(readErr, sql.ErrNoRows) {
taskError(w, readErr)
return
}
// A concurrent move must not recreate a task in its old collection.
}
if errors.Is(e, store.ErrTaskDAVIdentity) {
taskDAVError(w, 403, "no-uid-conflict", "UID and resource identity must be unique and immutable")
return
}
taskError(w, e)
return
}
http.Error(w, "concurrent task updates; retry synchronization", http.StatusConflict)
}
func taskDAVWritePreconditions(w http.ResponseWriter, r *http.Request, item store.TaskRecord, exists bool) bool {
match, none := r.Header.Get("If-Match"), r.Header.Get("If-None-Match")
if match == "" && none == "" {
return true
}
tag := ""
if exists {
var err error
_, tag, err = taskICAL(item)
if err != nil {
taskError(w, err)
return false
}
}
matches := func(value string, weak bool) bool {
for _, v := range strings.Split(value, ",") {
v = strings.TrimSpace(v)
if weak {
v = strings.TrimPrefix(v, "W/")
}
if exists && (v == "*" || v == tag) {
return true
}
}
return false
}
if match != "" && !matches(match, false) || none != "" && matches(none, true) {
w.WriteHeader(http.StatusPreconditionFailed)
return false
}
return true
}
func (s *Server) handleTaskDAVListing(w http.ResponseWriter, r *http.Request, domain, actor string, root, collection bool, name string, writable bool, prefix, project, title string) {
depth := r.Header.Get("Depth")
if r.Method == "REPORT" && depth == "" {
depth = "0"
}
if depth != "0" && depth != "1" {
taskDAVError(w, 403, "supported-filter", "Depth 0 or 1 required")
return
}
n, e := readDAV(w, r)
if e != nil {
http.Error(w, "invalid XML", 400)
return
}
var req []davNode
if p := n.child(davNS, "prop"); p != nil {
req = p.Children
}
for _, p := range req {
if !taskDAVFullProperty(p) {
taskDAVError(w, 403, "supported-calendar-data", "property projections unsupported")
return
}
}
rows := []davResponse{}
collectionRow := taskDAVCollectionRow()
collectionRow.href = prefix
collectionRow.props[xml.Name{Space: davNS, Local: "displayname"}] = xmlText(title)
collectionRow.props[xml.Name{Space: davNS, Local: "current-user-privilege-set"}] = davPrivileges(writable)
collectionRow.props[xml.Name{Space: davNS, Local: "current-user-principal"}] = "" + taskDAVRoot + ""
if r.Method == "PROPFIND" {
if n.XMLName.Local != "" && (n.XMLName.Space != davNS || n.XMLName.Local != "propfind") {
w.WriteHeader(400)
return
}
if root {
rows = append(rows, davResponse{href: taskDAVRoot, props: map[xml.Name]string{
{Space: davNS, Local: "displayname"}: "PagesWiki Task Home", {Space: davNS, Local: "resourcetype"}: "",
{Space: davNS, Local: "current-user-principal"}: "" + taskDAVRoot + "", {Space: davNS, Local: "principal-URL"}: "" + taskDAVRoot + "", {Space: calNS, Local: "calendar-home-set"}: "" + taskDAVRoot + "",
}})
if depth == "1" {
rows = append(rows, collectionRow)
if !s.appendTaskDAVCollections(w, r, domain, actor, writable, &rows) {
return
}
}
} else if collection {
rows = append(rows, collectionRow)
if depth == "1" {
items, err := s.store.TaskDAVList(r.Context(), domain, actor, project)
if err != nil {
taskError(w, err)
return
}
for _, item := range items {
if err := r.Context().Err(); err != nil {
taskError(w, err)
return
}
row, err := taskDAVRow(item, prefix)
if err != nil {
taskError(w, err)
return
}
rows = append(rows, row)
}
}
} else {
item, err := s.store.TaskDAVByName(r.Context(), domain, actor, name, project)
if err != nil {
taskError(w, err)
return
}
if item.Archived {
http.NotFound(w, r)
return
}
row, err := taskDAVRow(item, prefix)
if err != nil {
taskError(w, err)
return
}
rows = append(rows, row)
}
writeDAV(w, rows, req)
return
}
if !collection || n.XMLName.Space != calNS {
w.WriteHeader(405)
return
}
if len(req) == 0 {
http.Error(w, "explicit properties required", 400)
return
}
seen := map[xml.Name]int{}
for _, child := range n.Children {
seen[child.XMLName]++
allowed := child.XMLName.Space == davNS && child.XMLName.Local == "prop" || n.XMLName.Local == "calendar-query" && child.XMLName.Space == calNS && child.XMLName.Local == "filter" || n.XMLName.Local == "calendar-multiget" && child.XMLName.Space == davNS && child.XMLName.Local == "href"
if !allowed || child.XMLName.Local != "href" && seen[child.XMLName] > 1 {
taskDAVError(w, 403, "supported-filter", "unsupported report element")
return
}
}
switch n.XMLName.Local {
case "calendar-query":
filter := n.child(calNS, "filter")
if !taskDAVSimpleFilter(filter) {
taskDAVError(w, 403, "supported-filter", "only VCALENDAR/VTODO component filters supported; time-range and property filters are not supported")
return
}
items, err := s.store.TaskDAVList(r.Context(), domain, actor, project)
if err != nil {
taskError(w, err)
return
}
for _, item := range items {
if err := r.Context().Err(); err != nil {
taskError(w, err)
return
}
row, err := taskDAVRow(item, prefix)
if err != nil {
taskError(w, err)
return
}
rows = append(rows, row)
}
case "calendar-multiget":
count := 0
for _, child := range n.Children {
if child.XMLName.Space != davNS || child.XMLName.Local != "href" {
continue
}
count++
if count > 200 {
taskError(w, store.ErrTaskDAVLimit)
return
}
href := strings.TrimSpace(child.Text)
u, err := url.Parse(href)
if err != nil || u.User != nil || u.RawQuery != "" || u.Fragment != "" || (u.Host != "" && !strings.EqualFold(u.Host, r.Host)) || !strings.HasPrefix(u.Path, prefix) || !store.ValidTaskDAVName(strings.TrimPrefix(u.Path, prefix)) {
rows = append(rows, davResponse{href: href, status: 404})
continue
}
item, err := s.store.TaskDAVByName(r.Context(), domain, actor, strings.TrimPrefix(u.Path, prefix), project)
if errors.Is(err, sql.ErrNoRows) || err == nil && item.Archived {
rows = append(rows, davResponse{href: u.Path, status: 404})
continue
}
if err != nil {
taskError(w, err)
return
}
row, err := taskDAVRow(item, prefix)
if err != nil {
taskError(w, err)
return
}
rows = append(rows, row)
}
default:
taskDAVError(w, 403, "supported-filter", "unsupported report")
return
}
writeDAV(w, rows, req)
}
// An explicit VCALENDAR/allprop/allcomp request is the complete resource, not
// a partial projection. go-webdav (including chroncal) uses this representation.
// Keep partial property selection, expansion and recurrence limits unsupported.
func taskDAVFullProperty(p davNode) bool {
if p.XMLName.Space != calNS || p.XMLName.Local != "calendar-data" {
return len(p.Children) == 0 && taskDAVAttrCount(p) == 0
}
for _, a := range p.Attrs {
if a.Name.Space == "xmlns" || a.Name.Space == "" && a.Name.Local == "xmlns" {
continue
}
if a.Name.Space != "" || !(a.Name.Local == "content-type" && a.Value == "text/calendar" || a.Name.Local == "version" && a.Value == "2.0") {
return false
}
}
if len(p.Children) == 0 {
return true
}
if len(p.Children) != 1 {
return false
}
c := p.Children[0]
if c.XMLName.Space != calNS || c.XMLName.Local != "comp" || c.attr("name") != "VCALENDAR" || taskDAVAttrCount(c) != 1 || len(c.Children) != 2 {
return false
}
seen := map[string]bool{}
for _, n := range c.Children {
if n.XMLName.Space != calNS || (n.XMLName.Local != "allprop" && n.XMLName.Local != "allcomp") || len(n.Children) != 0 || taskDAVAttrCount(n) != 0 || seen[n.XMLName.Local] {
return false
}
seen[n.XMLName.Local] = true
}
return true
}
func taskDAVSimpleFilter(n *davNode) bool {
if n == nil || len(n.Children) != 1 || taskDAVAttrCount(*n) != 0 {
return false
}
c := n.Children[0]
if c.XMLName.Space != calNS || c.XMLName.Local != "comp-filter" || c.attr("name") != "VCALENDAR" || taskDAVAttrCount(c) != 1 {
return false
}
if len(c.Children) == 0 {
return true
}
if len(c.Children) != 1 {
return false
}
v := c.Children[0]
return v.XMLName.Space == calNS && v.XMLName.Local == "comp-filter" && v.attr("name") == "VTODO" && taskDAVAttrCount(v) == 1 && len(v.Children) == 0
}
func taskDAVAttrCount(n davNode) int {
count := 0
for _, a := range n.Attrs {
if a.Name.Space != "xmlns" && !(a.Name.Space == "" && a.Name.Local == "xmlns") {
count++
}
}
return count
}