Files
pages/internal/server/tasks_handler.go
T
Anya Tokugawa 0d8997972c
Build and publish container images / images (push) Failing after 6m19s
feat: add private RSS reader and read-only FreshRSS integration
2026-11-08 03:35:02 +09:00

397 lines
11 KiB
Go

package server
import (
"context"
"database/sql"
"encoding/json"
"errors"
"io"
"log"
"net/http"
"path"
"strconv"
"strings"
"time"
"github.com/google/uuid"
"pageswiki/internal/store"
)
const tasksAPI = "/_/api/v1/extension/organizer.tasks/"
func taskRoute(p string) bool {
if feedRoute(p) {
return true
}
if p == "/v/plan/dashboard" {
return true
}
if contactRoute(p) {
return true
}
return strings.HasPrefix(p, tasksAPI) || p == strings.TrimSuffix(taskDAVRoot, "/") || strings.HasPrefix(p, taskDAVRoot) || p == "/v/plan/today" || p == "/v/plan/tasks" || strings.HasPrefix(p, "/v/plan/tasks/") || p == "/v/plan/projects" || strings.HasPrefix(p, "/v/plan/project/") || strings.HasPrefix(p, "/v/plan/task/")
}
func (s *Server) registerTaskRoutes() {
s.mux.HandleFunc("/v/feeds", s.handleFeeds)
s.mux.HandleFunc(feedsAPI, s.handleFeeds)
s.mux.HandleFunc("/v/plan/dashboard", s.handleOrganizerDashboard)
s.mux.HandleFunc(contactDAV, s.handleContactDAV)
s.mux.HandleFunc(strings.TrimSuffix(contactDAV, "/"), s.handleContactDAV)
s.mux.HandleFunc("/.well-known/carddav", s.handleContactDAV)
s.mux.HandleFunc(contactsAPI, s.handleContacts)
s.mux.HandleFunc("/v/plan/contacts", s.handleContacts)
for _, p := range []string{"/v/plan/today", "/v/plan/tasks", "/v/plan/tasks/", "/v/plan/projects", "/v/plan/project/", "/v/plan/task/"} {
s.mux.HandleFunc(p, s.handleTaskPage)
}
s.mux.HandleFunc(tasksAPI, s.handleTasksAPI)
s.mux.HandleFunc(taskDAVRoot, s.handleTaskDAV)
// Several DAV clients strip trailing slashes. Avoid ServeMux's 301,
// which can turn PROPFIND into GET in their HTTP redirect handling.
s.mux.HandleFunc(strings.TrimSuffix(taskDAVRoot, "/"), s.handleTaskDAV)
}
func taskError(w http.ResponseWriter, err error) {
status, code := 500, "internal"
switch {
case errors.Is(err, sql.ErrNoRows):
status, code = 404, "not_found"
case errors.Is(err, store.ErrAccessDenied):
status, code = 403, "forbidden"
case errors.Is(err, store.ErrTaskInvalid):
status, code = 422, "invalid"
case errors.Is(err, store.ErrTaskConflict):
status, code = 412, "conflict"
case errors.Is(err, store.ErrTaskDAVIdentity):
status, code = 409, "uid_conflict"
case errors.Is(err, store.ErrTaskDAVRelocated):
status, code = 409, "task_collection_relocated"
case errors.Is(err, store.ErrTaskDAVLimit):
status, code = 507, "limit"
case errors.Is(err, store.ErrTaskNoteExists):
status, code = 409, "note_exists"
case errors.Is(err, context.DeadlineExceeded):
status, code = 503, "busy"
}
if status >= 500 {
log.Printf("task operation failed: %v", err)
}
writeEventJSON(w, status, map[string]string{"error": code})
}
func (s *Server) taskReady(w http.ResponseWriter, r *http.Request) (string, bool, bool) {
w.Header().Set("Cache-Control", "private, no-store")
if !s.systemExtensionEnabled(s.domainUUIDForRequest(r), "organizer.tasks") {
http.NotFound(w, r)
return "", false, false
}
actor, active := s.calendarActor(r)
if actor == "" {
s.authRequired(w, r)
return "", false, false
}
return actor, active, true
}
func (s *Server) handleTaskPage(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" && r.Method != "HEAD" {
w.WriteHeader(405)
return
}
actor, active, ok := s.taskReady(w, r)
if !ok {
return
}
domain := s.domainUUIDForRequest(r)
if r.URL.Path == "/v/plan/tasks/work" {
s.renderWithContext(w, r, "task_work_history.gohtml", map[string]any{"TaskWritable": active, "Timezone": s.getTimezoneName(domain)})
return
}
if r.URL.Path == "/v/plan/tasks/report" || r.URL.Path == "/v/plan/tasks/settings" {
s.handleTaskProductivityPage(w, r, active)
return
}
if strings.HasPrefix(r.URL.Path, "/v/plan/tasks/schedule") {
s.handleTaskSchedulePage(w, r, actor)
return
}
today := time.Now().In(s.getLocation(domain)).Format("2006-01-02")
selectedDate := today
view, id := "today", ""
switch r.URL.Path {
case "/v/plan/today":
case "/v/plan/tasks":
view = "all"
case "/v/plan/projects":
view = "projects"
case "/v/plan/task/-/new":
view = "new"
default:
if strings.HasPrefix(r.URL.Path, "/v/plan/tasks/") {
view = strings.TrimPrefix(r.URL.Path, "/v/plan/tasks/")
if strings.HasPrefix(view, "day/") {
d, err := time.Parse("2006/01/02", strings.TrimPrefix(view, "day/"))
if err != nil || d.Year() < 1 || d.Format("2006/01/02") != strings.TrimPrefix(view, "day/") {
http.NotFound(w, r)
return
}
selectedDate, view = d.Format("2006-01-02"), "day"
}
switch view {
case "inbox", "backlog", "someday", "review", "done", "archived", "carryover", "day":
case "tomorrow":
selectedDate = time.Now().In(s.getLocation(domain)).AddDate(0, 0, 1).Format("2006-01-02")
view = "day"
default:
http.NotFound(w, r)
return
}
} else {
id = path.Base(r.URL.Path)
if _, err := uuid.Parse(id); err != nil {
http.NotFound(w, r)
return
}
item, err := s.store.GetTask(r.Context(), domain, actor, id)
if err != nil {
taskError(w, err)
return
}
view = "detail"
if strings.HasPrefix(r.URL.Path, "/v/plan/project/") {
view = "project"
}
if (item.Kind == "project") != (view == "project") {
http.NotFound(w, r)
return
}
if r.URL.Path != "/v/plan/"+item.Kind+"/"+id {
http.NotFound(w, r)
return
}
}
}
// Also validate current membership for an empty list / new-item screen.
if _, _, err := s.store.ListTasks(r.Context(), domain, actor, store.TaskQuery{Kind: "task", View: "all", Today: today, Limit: 1}); err != nil {
taskError(w, err)
return
}
s.renderWithContext(w, r, "tasks.gohtml", map[string]any{"Title": "Tasks", "TaskView": view, "TaskID": id, "TaskToday": today, "TaskSelectedDate": selectedDate, "TaskTimezone": s.getTimezoneName(domain), "TaskWritable": active, "Path": r.URL.Path})
}
// Resolve a currently readable alias, rather than trusting a stored path. A Wiki
// rename therefore follows the stable UUID; revoked/deleted links disappear.
func (s *Server) taskPagePath(r *http.Request, id string) string {
if id == "" {
return ""
}
rows, err := s.store.DB.QueryContext(r.Context(), `SELECT path FROM paths WHERE domain_uuid=? AND object_uuid=? ORDER BY length(path),path LIMIT 100`, s.domainUUIDForRequest(r), id)
if err != nil {
return ""
}
paths := []string{}
for rows.Next() {
var p string
if rows.Scan(&p) == nil {
paths = append(paths, p)
}
}
rows.Close()
allows := s.pathReadFilter(r)
for _, p := range paths {
if allows(p) {
return p
}
}
return ""
}
func (s *Server) taskResponse(w http.ResponseWriter, r *http.Request, item store.TaskRecord, status int) {
w.Header().Set("ETag", `"`+strconv.FormatInt(item.Version, 10)+`"`)
writeEventJSON(w, status, map[string]any{"item": item, "page_path": s.taskPagePath(r, item.PageUUID)})
}
func (s *Server) handleTasksAPI(w http.ResponseWriter, r *http.Request) {
actor, active, ok := s.taskReady(w, r)
if !ok {
return
}
ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
defer cancel()
r = r.WithContext(ctx)
domain := s.domainUUIDForRequest(r)
parts := strings.Split(strings.TrimPrefix(r.URL.Path, tasksAPI), "/")
if parts[0] == "digest-history" {
s.handleTaskDigestHistory(w, r, actor, active, parts)
return
}
if parts[0] == "work-history" {
s.handleTaskWorkHistory(w, r, actor, parts)
return
}
if len(parts) == 1 && (parts[0] == "dashboard" || parts[0] == "progress" || parts[0] == "calendar-capture" || parts[0] == "capture" || parts[0] == "preferences" || parts[0] == "work" || parts[0] == "report") {
s.handleTaskProductivity(w, r, actor, active, parts[0])
return
}
if len(parts) == 1 && parts[0] == "schedule" {
s.handleTaskScheduleAPI(w, r, actor)
return
}
if len(parts) == 1 && parts[0] == "today" {
s.handleTaskToday(w, r, actor)
return
}
if parts[0] == "dav-credentials" {
s.handleTaskDAVCredentials(w, r, actor, parts)
return
}
if parts[0] == "focus" {
s.handleTaskFocus(w, r, actor, active, parts)
return
}
if parts[0] == "blocks" || parts[0] == "calendars" {
s.handleTaskPlanning(w, r, actor, active, parts)
return
}
if len(parts) < 1 || parts[0] != "items" || len(parts) > 3 {
http.NotFound(w, r)
return
}
id := ""
if len(parts) > 1 {
id = parts[1]
if _, err := uuid.Parse(id); err != nil {
http.NotFound(w, r)
return
}
}
if len(parts) == 3 {
if parts[2] == "note" {
s.handleTaskNote(w, r, actor, active, id)
return
}
if parts[2] != "history" || r.Method != "GET" {
http.NotFound(w, r)
return
}
h, err := s.store.TaskHistory(ctx, domain, actor, id)
if err != nil {
taskError(w, err)
return
}
writeEventJSON(w, 200, map[string]any{"items": h})
return
}
if r.Method == "GET" {
if id != "" {
item, err := s.store.GetTask(ctx, domain, actor, id)
if err != nil {
taskError(w, err)
return
}
s.taskResponse(w, r, item, 200)
return
}
q := r.URL.Query()
kind, view := q.Get("kind"), q.Get("view")
if kind == "" {
kind = "task"
}
if view == "" {
view = "all"
}
limit, _ := strconv.Atoi(q.Get("limit"))
today := time.Now().In(s.getLocation(domain)).Format("2006-01-02")
selected := today
if view == "day" {
selected = q.Get("date")
}
hierarchy := q.Get("hierarchy") == "1"
items, next, err := s.store.ListTasks(ctx, domain, actor, store.TaskQuery{Kind: kind, View: view, Project: q.Get("project"), Parent: q.Get("parent"), Search: q.Get("q"), Today: selected, Before: q.Get("before"), Limit: limit, Hierarchy: hierarchy})
if err != nil {
taskError(w, err)
return
}
parents := []store.TaskRecord{}
if hierarchy {
parents, err = s.store.TaskContextParents(ctx, domain, actor, items)
if err != nil {
taskError(w, err)
return
}
}
writeEventJSON(w, 200, map[string]any{"items": items, "parents": parents, "next": next, "today": today})
return
}
if (r.Method != "POST" || id != "") && (r.Method != "PUT" || id == "") {
w.Header().Set("Allow", "GET, POST, PUT")
w.WriteHeader(405)
return
}
if !active {
taskError(w, store.ErrAccessDenied)
return
}
var body struct {
store.TaskRecord
PagePath *string `json:"page_path"`
}
d := json.NewDecoder(http.MaxBytesReader(w, r.Body, 98304))
d.DisallowUnknownFields()
if err := d.Decode(&body); err != nil {
taskError(w, store.ErrTaskInvalid)
return
}
if d.Decode(&struct{}{}) != io.EOF {
taskError(w, store.ErrTaskInvalid)
return
}
expected := int64(0)
if id != "" {
tag := r.Header.Get("If-Match")
if tag == "" {
writeEventJSON(w, 428, map[string]string{"error": "precondition"})
return
}
expected, _ = strconv.ParseInt(strings.Trim(tag, `"`), 10, 64)
if expected < 1 || tag != `"`+strconv.FormatInt(expected, 10)+`"` || body.UUID != id {
taskError(w, store.ErrTaskInvalid)
return
}
}
if body.PagePath != nil {
p := strings.TrimSpace(*body.PagePath)
body.PageUUID = ""
if p != "" {
if !strings.HasPrefix(p, "/") || path.Clean(p) != p || !s.pathReadFilter(r)(p) {
taskError(w, store.ErrAccessDenied)
return
}
var err error
body.PageUUID, err = s.store.ResolvePathInDomain(domain, p)
if err != nil {
taskError(w, store.ErrTaskInvalid)
return
}
}
} else if body.PageUUID != "" {
old, err := s.store.GetTask(ctx, domain, actor, body.UUID)
if err != nil || old.PageUUID != body.PageUUID {
if s.taskPagePath(r, body.PageUUID) == "" {
taskError(w, store.ErrAccessDenied)
return
}
}
}
item, err := s.store.SaveTask(ctx, domain, actor, body.TaskRecord, expected)
if err != nil {
taskError(w, err)
return
}
status := 200
if id == "" {
status = 201
}
s.taskResponse(w, r, item, status)
}