376 lines
11 KiB
Go
376 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 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(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/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 len(parts) == 1 && (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)
|
|
}
|