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) }