diff --git a/docs/openapi.yaml b/docs/openapi.yaml index 197f089..d01dd3d 100644 --- a/docs/openapi.yaml +++ b/docs/openapi.yaml @@ -2693,6 +2693,34 @@ paths: type: array items: { $ref: "#/components/schemas/Task" } + /api/v1/all-tasks: + get: + tags: [views] + summary: Every open task, for the "All tasks" view. + description: | + Every open, top-level task in every active (not archived) project you can + see. Sub-tasks are left out: they show as their parent's count, as they do + in a project. + + Flat rather than grouped. The client groups by project group and project, + and it already holds both lists with their names, colours and order. + + At most 2000 tasks are returned. `truncated` is true when there were more, + so a client can say that the list is not complete rather than showing a + shorter one as if it were. + responses: + "200": + description: OK + content: + application/json: + schema: + type: object + properties: + tasks: + type: array + items: { $ref: "#/components/schemas/Task" } + truncated: { type: boolean } + /api/v1/search: get: tags: [views] diff --git a/internal/httpapi/calendar_test.go b/internal/httpapi/calendar_test.go index 97f5b21..3b30370 100644 --- a/internal/httpapi/calendar_test.go +++ b/internal/httpapi/calendar_test.go @@ -141,16 +141,25 @@ func TestAuthorizeWithoutAClientSaysSo(t *testing.T) { // The whole path, minus the consent screen: sync fetches the list, refreshes the // events of what was chosen, and the grid endpoint answers with them. func TestSyncFetchesTheChosenCalendarsAndTheGridReadsThem(t *testing.T) { + // A week from today, not a fixed date: verdande only keeps a window around now, + // and a fixture pinned to August aged out of it in November and turned this + // test red with "events = 0" — which reads like the sync broke. + day := time.Now().AddDate(0, 0, 7) + on := day.Format("2006-01-02") + next := day.AddDate(0, 0, 1).Format("2006-01-02") + grid := "/api/v1/calendar/events?from=" + day.AddDate(0, 0, -10).Format("2006-01-02") + + "&to=" + day.AddDate(0, 0, 10).Format("2006-01-02") + g := newFakeCalendarGoogle(t) g.events["fam"] = []map[string]any{ {"id": "e1", "summary": "Bestyrelsesmøde", "htmlLink": "https://calendar.google.com/e1", - "start": map[string]string{"dateTime": "2026-08-20T14:00:00+02:00"}, - "end": map[string]string{"dateTime": "2026-08-20T15:30:00+02:00"}}, + "start": map[string]string{"dateTime": on + "T14:00:00+01:00"}, + "end": map[string]string{"dateTime": on + "T15:30:00+01:00"}}, } g.events["kw@nolimit.dk"] = []map[string]any{ {"id": "e2", "summary": "Skal ikke med", - "start": map[string]string{"date": "2026-08-21"}, - "end": map[string]string{"date": "2026-08-22"}}, + "start": map[string]string{"date": next}, + "end": map[string]string{"date": day.AddDate(0, 0, 2).Format("2006-01-02")}}, } ts, user := connectedCalendar(t, g, nil) @@ -209,8 +218,7 @@ func TestSyncFetchesTheChosenCalendarsAndTheGridReadsThem(t *testing.T) { t.Fatalf("events = %v, want 1 — only the chosen calendar", body["events"]) } - resp, body = ts.do(t, "GET", - "/api/v1/calendar/events?from=2026-08-01&to=2026-08-31", nil) + resp, body = ts.do(t, "GET", grid, nil) if resp.StatusCode != http.StatusOK { t.Fatalf("events: status %d, body %v", resp.StatusCode, body) } @@ -219,7 +227,7 @@ func TestSyncFetchesTheChosenCalendarsAndTheGridReadsThem(t *testing.T) { t.Fatalf("got %d events, want 1: %v", len(events), body["events"]) } event := events[0].(map[string]any) - if event["summary"] != "Bestyrelsesmøde" || event["start_day"] != "2026-08-20" { + if event["summary"] != "Bestyrelsesmøde" || event["start_day"] != on { t.Errorf("the event came back as %v", event) } // The calendar's colour rides along, or the chip has to ask for it per row. @@ -235,7 +243,7 @@ func TestSyncFetchesTheChosenCalendarsAndTheGridReadsThem(t *testing.T) { // And it is one person's calendar. Somebody else on the same instance sees // nothing of it. other := ts.newUser(t, "andreas@example.dk", "Andreas") - _, body = other.do(t, "GET", "/api/v1/calendar/events?from=2026-08-01&to=2026-08-31", nil) + _, body = other.do(t, "GET", grid, nil) if events, _ := body["events"].([]any); len(events) != 0 { t.Errorf("somebody else's calendar was visible: %v", body["events"]) } diff --git a/internal/httpapi/edition_test.go b/internal/httpapi/edition_test.go index a3f0135..9c8fd9b 100644 --- a/internal/httpapi/edition_test.go +++ b/internal/httpapi/edition_test.go @@ -64,6 +64,7 @@ func TestNotesEditionServesOnlyItsOwnRoutes(t *testing.T) { "DELETE /caldav/{userID}/{projectID}/{taskFile}", "GET /.well-known/caldav", "GET /api/v1/ai/plan", + "GET /api/v1/all-tasks", "GET /api/v1/delegated", "GET /api/v1/export/projects.zip", "GET /api/v1/export/projects/{projectID}.csv", diff --git a/internal/httpapi/server.go b/internal/httpapi/server.go index 7624811..367ca89 100644 --- a/internal/httpapi/server.go +++ b/internal/httpapi/server.go @@ -645,6 +645,7 @@ func New(cfg *config.Config, db *store.DB, log *slog.Logger, web fs.FS) *Server }) r.Get("/upcoming", s.handleUpcoming) r.Get("/delegated", s.handleDelegated) + r.Get("/all-tasks", s.handleAllTasks) } r.Get("/people", s.handlePeople) r.Get("/search", s.handleSearch) diff --git a/internal/httpapi/views_handlers.go b/internal/httpapi/views_handlers.go index 6aaa023..d969b47 100644 --- a/internal/httpapi/views_handlers.go +++ b/internal/httpapi/views_handlers.go @@ -184,6 +184,46 @@ func (s *Server) handleDelegated(w http.ResponseWriter, r *http.Request) { writeJSON(w, http.StatusOK, map[string]any{"people": out}) } +// allTasksCap is how many rows "Alle opgaver" will send. Far above what one +// person has open; it exists so an account with tens of thousands of imported +// tasks gets a slow page rather than an unbounded response. When it is reached the +// response says so, because a list that quietly stops is a list that lies about +// what is left. +const allTasksCap = 2000 + +// handleAllTasks is "Alle opgaver": every open task in every active project the +// caller can see, top level only — a sub-task is shown as its parent's count, the +// way a project shows it, rather than as a second loose row. +// +// Flat, not grouped. The grouping is by project group and project, and the client +// already holds both lists with their names, colours and order; a server-side +// grouping would be a second copy of the sidebar's order to keep in step with the +// first. +func (s *Server) handleAllTasks(w http.ResponseWriter, r *http.Request) { + user := userFrom(r.Context()) + + tasks, err := s.db.ListTasks(r.Context(), user.ID, store.TaskFilter{ + TopLevelOnly: true, + ActiveProjectsOnly: true, + // One past the cap, so "exactly the cap" and "more than the cap" can be told + // apart. + Limit: allTasksCap + 1, + }) + if err != nil { + s.internal(w, r, "all tasks", err) + return + } + + truncated := len(tasks) > allTasksCap + if truncated { + tasks = tasks[:allTasksCap] + } + writeJSON(w, http.StatusOK, map[string]any{ + "tasks": toTaskList(tasks), + "truncated": truncated, + }) +} + // sortByName orders the groups the way a list of people reads. Insertion sort: // this is a handful of entries, and it keeps the package free of a dependency on // sort just for this. diff --git a/internal/httpapi/views_test.go b/internal/httpapi/views_test.go index 371ef5e..f39a589 100644 --- a/internal/httpapi/views_test.go +++ b/internal/httpapi/views_test.go @@ -200,3 +200,70 @@ func TestPeopleIsWhoYouShareWorkWith(t *testing.T) { t.Errorf("a stranger is listed: %v", seen) } } + +// "Alle opgaver" is every open task the caller can act on, and the test names +// each thing that must stay out — because a list of everything passes any check +// that only asks whether the right task is in it. +func TestAllTasksIsEveryOpenTopLevelTaskInActiveProjects(t *testing.T) { + ts := newTestServer(t) + ts.bootstrap(t) + + _, a := ts.do(t, "POST", "/api/v1/projects", map[string]any{"name": "Have"}) + _, b := ts.do(t, "POST", "/api/v1/projects", map[string]any{"name": "Hus"}) + _, gone := ts.do(t, "POST", "/api/v1/projects", map[string]any{"name": "Gammelt"}) + + _, parent := ts.do(t, "POST", "/api/v1/tasks", map[string]any{ + "content": "slå græs", "project_id": a["id"], + }) + ts.do(t, "POST", "/api/v1/tasks", map[string]any{ + "content": "find benzin", "project_id": a["id"], "parent_id": parent["id"], + }) + ts.do(t, "POST", "/api/v1/tasks", map[string]any{ + "content": "mal døren", "project_id": b["id"], + }) + _, done := ts.do(t, "POST", "/api/v1/tasks", map[string]any{ + "content": "skift pære", "project_id": b["id"], + }) + ts.do(t, "POST", "/api/v1/tasks/"+done["id"].(string)+"/complete", nil) + ts.do(t, "POST", "/api/v1/tasks", map[string]any{ + "content": "glemt opgave", "project_id": gone["id"], + }) + if resp, body := ts.do(t, "PATCH", "/api/v1/projects/"+gone["id"].(string), + map[string]any{"archived": true}); resp.StatusCode != http.StatusOK { + t.Fatalf("archive: %d %v", resp.StatusCode, body) + } + + // Somebody else's task, in a project the caller is not in. + other := ts.newUser(t, "tredje@example.dk", "Tredje") + _, theirs := other.do(t, "POST", "/api/v1/projects", map[string]any{"name": "Deres"}) + other.do(t, "POST", "/api/v1/tasks", map[string]any{ + "content": "deres opgave", "project_id": theirs["id"], + }) + + resp, body := ts.do(t, "GET", "/api/v1/all-tasks", nil) + if resp.StatusCode != http.StatusOK { + t.Fatalf("all-tasks: %d %v", resp.StatusCode, body) + } + if body["truncated"] != false { + t.Errorf("truncated = %v on five tasks", body["truncated"]) + } + + got := map[string]bool{} + for _, raw := range body["tasks"].([]any) { + got[raw.(map[string]any)["content"].(string)] = true + } + want := map[string]bool{"slå græs": true, "mal døren": true} + for c := range want { + if !got[c] { + t.Errorf("missing %q: %v", c, got) + } + } + for _, c := range []string{"find benzin", "skift pære", "glemt opgave", "deres opgave"} { + if got[c] { + t.Errorf("%q should not be in Alle opgaver: %v", c, got) + } + } + if len(got) != len(want) { + t.Errorf("got %d tasks, want %d: %v", len(got), len(want), got) + } +} diff --git a/internal/store/tasks.go b/internal/store/tasks.go index a6ddc15..708677b 100644 --- a/internal/store/tasks.go +++ b/internal/store/tasks.go @@ -69,7 +69,12 @@ type TaskFilter struct { // TopLevelOnly excludes sub-tasks, which a project view wants because it // renders them nested under their parents rather than as separate rows. TopLevelOnly bool - AssigneeID string + // ActiveProjectsOnly leaves out tasks in archived projects. An archived + // project is one somebody put away; its open tasks are not work that is + // waiting, and a view of "everything I have to do" that fills up with them is + // a view that has to be read past. + ActiveProjectsOnly bool + AssigneeID string // DelegatedBy is the other side of AssigneeID: assigned, but not to this // person. A second field rather than a magic value in AssigneeID, because the // two are different questions — "what is on my plate" and "what have I handed @@ -140,6 +145,9 @@ func (db *DB) ListTasks(ctx context.Context, userID string, f TaskFilter) ([]Tas if f.TopLevelOnly { where = append(where, `t.parent_id IS NULL`) } + if f.ActiveProjectsOnly { + where = append(where, `p.archived = 0`) + } if f.AssigneeID != "" { where = append(where, `t.assignee_id = ?`) args = append(args, f.AssigneeID)