package store import ( "context" "database/sql" "encoding/json" "errors" "sort" "time" "github.com/google/uuid" "pageswiki/internal/db" ) var taskProductivityMigrations = []db.SQLMigration{{Version: 1, Name: "task_capture_work_and_reporting", Statements: []string{ `CREATE TABLE organizer_task_preferences(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,version INTEGER NOT NULL,data TEXT NOT NULL,next_digest_ms INTEGER NOT NULL DEFAULT 0,PRIMARY KEY(domain_uuid,owner_uuid))`, `CREATE INDEX organizer_digest_due ON organizer_task_preferences(next_digest_ms) WHERE next_digest_ms>0`, `CREATE TABLE organizer_capture_receipts(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,request_uuid TEXT NOT NULL,request_hash TEXT NOT NULL,item_uuid TEXT NOT NULL,PRIMARY KEY(domain_uuid,owner_uuid,request_uuid))`, `CREATE TABLE organizer_work_sessions(uuid TEXT PRIMARY KEY,domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,task_uuid TEXT NOT NULL,start_ms INTEGER NOT NULL,end_ms INTEGER NOT NULL DEFAULT 0,version INTEGER NOT NULL DEFAULT 1)`, `CREATE UNIQUE INDEX organizer_work_active ON organizer_work_sessions(owner_uuid) WHERE end_ms=0`, `CREATE INDEX organizer_work_period ON organizer_work_sessions(domain_uuid,owner_uuid,start_ms,uuid)`, `CREATE TABLE organizer_task_metrics(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,task_uuid TEXT NOT NULL,completed_ms INTEGER NOT NULL,estimate INTEGER NOT NULL,complexity INTEGER NOT NULL,PRIMARY KEY(domain_uuid,task_uuid))`, `CREATE INDEX organizer_task_completed ON organizer_task_metrics(domain_uuid,owner_uuid,completed_ms)`, `INSERT INTO organizer_task_metrics SELECT domain_uuid,owner_uuid,uuid,COALESCE(json_extract(data,'$.completed_at_ms'),0),COALESCE(json_extract(data,'$.estimate_minutes'),0),max(1,COALESCE(json_extract(data,'$.complexity'),1)) FROM organizer_items WHERE kind='task'`, `CREATE TABLE organizer_digest_deliveries(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,day TEXT NOT NULL,state TEXT NOT NULL,updated_ms INTEGER NOT NULL,PRIMARY KEY(domain_uuid,owner_uuid,day))`, }, Assertions: []string{ schemaColumns("organizer_task_preferences", "domain_uuid,owner_uuid,version,data,next_digest_ms"), schemaUnique("organizer_capture_receipts", "domain_uuid,owner_uuid,request_uuid"), schemaIndex("organizer_work_sessions", "organizer_work_period", "domain_uuid,owner_uuid,start_ms,uuid"), }}, {Version: 2, Name: "personal_dashboard_layout", Statements: []string{ `CREATE TABLE organizer_dashboard_layouts(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,version INTEGER NOT NULL,data TEXT NOT NULL,PRIMARY KEY(domain_uuid,owner_uuid))`, }, Assertions: []string{schemaColumns("organizer_dashboard_layouts", "domain_uuid,owner_uuid,version,data"), schemaUnique("organizer_dashboard_layouts", "domain_uuid,owner_uuid")}}, { Version: 3, Name: "work_corrections_and_audit", AddColumns: []db.SQLiteColumn{{Table: "organizer_work_sessions", Name: "cancelled_ms", Declaration: "INTEGER NOT NULL DEFAULT 0"}}, Statements: []string{`CREATE TABLE organizer_work_revisions(work_uuid TEXT NOT NULL,version INTEGER NOT NULL,domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,action TEXT NOT NULL,reason TEXT NOT NULL,changed_ms INTEGER NOT NULL,data TEXT NOT NULL,PRIMARY KEY(work_uuid,version))`, `CREATE INDEX organizer_work_owner_period ON organizer_work_sessions(owner_uuid,start_ms,uuid)`}, Assertions: []string{schemaColumns("organizer_work_sessions", "uuid,domain_uuid,owner_uuid,task_uuid,start_ms,end_ms,version,cancelled_ms"), schemaUnique("organizer_work_revisions", "work_uuid,version"), schemaUnique("organizer_dashboard_layouts", "domain_uuid,owner_uuid")}, }, { Version: 4, Name: "digest_attempts_and_retry_receipts", Statements: []string{ `ALTER TABLE organizer_digest_deliveries ADD COLUMN attempt_uuid TEXT NOT NULL DEFAULT ''`, `CREATE INDEX organizer_digest_delivery_state ON organizer_digest_deliveries(state,attempt_uuid)`, `CREATE TABLE organizer_digest_attempts(uuid TEXT PRIMARY KEY,domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,day TEXT NOT NULL,kind TEXT NOT NULL,state TEXT NOT NULL,preference_version INTEGER NOT NULL,timezone TEXT NOT NULL,reason TEXT NOT NULL DEFAULT '',created_ms INTEGER NOT NULL,updated_ms INTEGER NOT NULL)`, `CREATE INDEX organizer_digest_history ON organizer_digest_attempts(domain_uuid,owner_uuid,created_ms,uuid)`, `CREATE INDEX organizer_digest_pending ON organizer_digest_attempts(state,updated_ms,uuid)`, `CREATE TABLE organizer_digest_requests(uuid TEXT PRIMARY KEY,domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,day TEXT NOT NULL,expected_attempt TEXT NOT NULL,duplicate_ack INTEGER NOT NULL,created_ms INTEGER NOT NULL)`, `CREATE INDEX organizer_digest_request_day ON organizer_digest_requests(domain_uuid,owner_uuid,day)`, `UPDATE organizer_digest_deliveries SET attempt_uuid='legacy-'||lower(hex(randomblob(16)))`, `INSERT INTO organizer_digest_attempts SELECT attempt_uuid,domain_uuid,owner_uuid,day,'legacy',state,0,'','legacy',updated_ms,updated_ms FROM organizer_digest_deliveries`, }, Assertions: []string{ schemaColumns("organizer_work_sessions", "uuid,domain_uuid,owner_uuid,task_uuid,start_ms,end_ms,version,cancelled_ms"), schemaUnique("organizer_work_revisions", "work_uuid,version"), schemaUnique("organizer_dashboard_layouts", "domain_uuid,owner_uuid"), schemaColumns("organizer_digest_deliveries", "domain_uuid,owner_uuid,day,state,updated_ms,attempt_uuid"), schemaUnique("organizer_digest_deliveries", "domain_uuid,owner_uuid,day"), schemaColumns("organizer_digest_attempts", "uuid,domain_uuid,owner_uuid,day,kind,state,preference_version,timezone,reason,created_ms,updated_ms"), schemaUnique("organizer_digest_attempts", "uuid"), schemaIndex("organizer_digest_attempts", "organizer_digest_pending", "state,updated_ms,uuid"), schemaColumns("organizer_digest_requests", "uuid,domain_uuid,owner_uuid,day,expected_attempt,duplicate_ack,created_ms"), schemaUnique("organizer_digest_requests", "uuid"), }, }} type TaskPreferences struct { Version int64 `json:"version"` ProjectUUID string `json:"project_uuid"` WikiPrefix string `json:"wiki_prefix"` AssigneeUUID string `json:"assignee_uuid"` DueDays *int `json:"due_days"` StartDays *int `json:"start_days"` PlannedDays *int `json:"planned_days"` ReviewDays *int `json:"review_days"` Estimate int `json:"estimate_minutes"` Complexity int `json:"complexity"` NotifyDue bool `json:"notify_due"` NotifyPlanned bool `json:"notify_planned"` ReminderTime string `json:"reminder_time"` DigestEnabled bool `json:"digest_enabled"` DigestTime string `json:"digest_time"` Timezone string `json:"timezone"` } func (s *Store) TaskPreferences(ctx context.Context, domain, actor string) (TaskPreferences, error) { p := TaskPreferences{AssigneeUUID: actor, Complexity: 1, ReminderTime: "09:00", DigestTime: "09:00", Timezone: "UTC"} if err := taskActor(ctx, s.DB, domain, actor, false); err != nil { return p, err } var raw string err := s.DB.QueryRowContext(ctx, `SELECT data FROM organizer_task_preferences WHERE domain_uuid=? AND owner_uuid=?`, domain, actor).Scan(&raw) if errors.Is(err, sql.ErrNoRows) { return p, nil } if err != nil { return p, err } err = json.Unmarshal([]byte(raw), &p) return p, err } func nextTaskDigest(now time.Time, p TaskPreferences) (int64, error) { loc, err := time.LoadLocation(p.Timezone) if err != nil { return 0, ErrTaskInvalid } clock, err := time.Parse("15:04", p.DigestTime) if err != nil || clock.Format("15:04") != p.DigestTime { return 0, ErrTaskInvalid } if !p.DigestEnabled { return 0, nil } t := now.In(loc) candidate := time.Date(t.Year(), t.Month(), t.Day(), clock.Hour(), clock.Minute(), 0, 0, loc) if !candidate.After(now) { candidate = time.Date(t.Year(), t.Month(), t.Day()+1, clock.Hour(), clock.Minute(), 0, 0, loc) } return candidate.UnixMilli(), nil } func (s *Store) SaveTaskPreferences(ctx context.Context, domain, actor string, p TaskPreferences, now time.Time) (TaskPreferences, error) { if s.ReadOnly { return p, ErrReadOnly } if _, err := ExpandWikiPrefix(p.WikiPrefix, "subject", now); err != nil { return p, ErrTaskInvalid } // Older clients do not send this field. Preserve their default clock. if p.ReminderTime == "" { p.ReminderTime = "09:00" } clock, clockErr := time.Parse("15:04", p.ReminderTime) if clockErr != nil || clock.Format("15:04") != p.ReminderTime { return p, ErrTaskInvalid } for _, n := range []*int{p.DueDays, p.StartDays, p.PlannedDays, p.ReviewDays} { if n != nil && (*n < 0 || *n > 3650) { return p, ErrTaskInvalid } } if p.Estimate < 0 || p.Estimate > 10080 || p.Complexity < 1 || p.Complexity > 5 || p.Version < 0 { return p, ErrTaskInvalid } next, err := nextTaskDigest(now, p) if err != nil { return p, err } tx, err := s.DB.BeginTx(ctx, nil) if err != nil { return p, err } defer tx.Rollback() if err = taskProductivityWriter(ctx, tx, domain, actor); err != nil { return p, err } if err = validateTaskAssignee(ctx, tx, domain, p.AssigneeUUID); err != nil { return p, err } if p.ProjectUUID != "" { var yes bool if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM organizer_items WHERE domain_uuid=? AND owner_uuid=? AND uuid=? AND kind='project' AND archived=0)`, domain, actor, p.ProjectUUID).Scan(&yes); err != nil { return p, err } if !yes { return p, ErrTaskInvalid } } var current int64 err = tx.QueryRowContext(ctx, `SELECT version FROM organizer_task_preferences WHERE domain_uuid=? AND owner_uuid=?`, domain, actor).Scan(¤t) if err != nil && !errors.Is(err, sql.ErrNoRows) { return p, err } if current != p.Version { return p, ErrTaskConflict } p.Version++ raw, _ := json.Marshal(p) _, err = tx.ExecContext(ctx, `INSERT INTO organizer_task_preferences VALUES(?,?,?,?,?) ON CONFLICT(domain_uuid,owner_uuid) DO UPDATE SET version=excluded.version,data=excluded.data,next_digest_ms=excluded.next_digest_ms`, domain, actor, p.Version, string(raw), next) if err != nil { return p, err } return p, tx.Commit() } func taskProductivityWriter(ctx context.Context, tx *sql.Tx, domain, actor string) error { if _, err := tx.ExecContext(ctx, `UPDATE domain_memberships SET state=state WHERE domain_uuid=? AND principal_uuid=?`, domain, actor); err != nil { return err } if err := taskActor(ctx, tx, domain, actor, true); err != nil { return err } on, err := taskReminderExtensionEnabled(ctx, tx, domain) if err != nil { return err } if !on { return ErrAccessDenied } return nil } // Assignment is a private planning annotation, NOT a grant to read this task. func validateTaskAssignee(ctx context.Context, tx *sql.Tx, domain, assignee string) error { if assignee == "" { return nil } if _, err := uuid.Parse(assignee); err != nil { return ErrTaskInvalid } if err := taskActor(ctx, tx, domain, assignee, false); err != nil { return ErrTaskInvalid } return nil } func (s *Store) CapturedTask(ctx context.Context, domain, actor, request, hash string) (TaskRecord, error) { if err := taskActor(ctx, s.DB, domain, actor, false); err != nil { return TaskRecord{}, err } var stored, id string err := s.DB.QueryRowContext(ctx, `SELECT request_hash,item_uuid FROM organizer_capture_receipts WHERE domain_uuid=? AND owner_uuid=? AND request_uuid=?`, domain, actor, request).Scan(&stored, &id) if err != nil { return TaskRecord{}, err } if stored != hash { return TaskRecord{}, ErrTaskConflict } return s.GetTask(ctx, domain, actor, id) } func (s *Store) CaptureTask(ctx context.Context, domain, actor, request, hash string, item TaskRecord) (TaskRecord, error) { return s.CaptureTaskWithWiki(ctx, domain, actor, request, hash, item, "", "") } // CaptureTaskWithWiki commits the task, receipt and optional Wiki page together. // The HTTP caller must authorize read/create/write for the exact target path. func (s *Store) CaptureTaskWithWiki(ctx context.Context, domain, actor, request, hash string, item TaskRecord, target, body string) (TaskRecord, error) { if _, err := uuid.Parse(request); err != nil { return TaskRecord{}, ErrTaskInvalid } old, err := s.CapturedTask(ctx, domain, actor, request, hash) if err == nil { return old, nil } if !errors.Is(err, sql.ErrNoRows) { return old, err } item.UUID = request out, err := s.saveTask(ctx, domain, actor, item, 0, func(tx *sql.Tx, current *TaskRecord, _ TaskRecord) error { if target != "" { if e := s.createCapturedTaskWiki(ctx, tx, domain, actor, current, target, body); e != nil { return e } } _, e := tx.ExecContext(ctx, `INSERT INTO organizer_capture_receipts VALUES(?,?,?,?,?)`, domain, actor, request, hash, item.UUID) return e }) if err == nil && target != "" { s.InvalidatePathCaches() } if err != nil { if old, e := s.CapturedTask(ctx, domain, actor, request, hash); e == nil { return old, nil } } return out, err } type TaskWork struct { UUID string `json:"uuid"` TaskUUID string `json:"task_uuid"` StartMS int64 `json:"start_ms"` EndMS int64 `json:"end_ms"` Version int64 `json:"version"` CancelledMS int64 `json:"cancelled_ms,omitempty"` } func scanTaskWork(row interface{ Scan(...any) error }) (TaskWork, error) { var v TaskWork err := row.Scan(&v.UUID, &v.TaskUUID, &v.StartMS, &v.EndMS, &v.Version, &v.CancelledMS) return v, err } const taskWorkColumns = `uuid,task_uuid,start_ms,end_ms,version,cancelled_ms` func (s *Store) ActiveTaskWork(ctx context.Context, domain, actor string) (*TaskWork, error) { if err := taskActor(ctx, s.DB, domain, actor, false); err != nil { return nil, err } v, err := scanTaskWork(s.DB.QueryRowContext(ctx, `SELECT `+taskWorkColumns+` FROM organizer_work_sessions WHERE domain_uuid=? AND owner_uuid=? AND end_ms=0`, domain, actor)) if errors.Is(err, sql.ErrNoRows) { return nil, nil } return &v, err } func (s *Store) ChangeTaskWork(ctx context.Context, domain, actor, action string, v TaskWork, now time.Time, reasons ...string) (TaskWork, error) { if s.ReadOnly { return v, ErrReadOnly } if _, err := uuid.Parse(v.UUID); err != nil { return v, ErrTaskInvalid } tx, err := s.DB.BeginTx(ctx, nil) if err != nil { return v, err } defer tx.Rollback() if err = taskProductivityWriter(ctx, tx, domain, actor); err != nil { return v, err } old, err := scanTaskWork(tx.QueryRowContext(ctx, `SELECT `+taskWorkColumns+` FROM organizer_work_sessions WHERE uuid=? AND domain_uuid=? AND owner_uuid=?`, v.UUID, domain, actor)) if err != nil && !errors.Is(err, sql.ErrNoRows) { return v, err } if action == "correct" || action == "cancel" { if err != nil { return v, err } reason := "" if len(reasons) > 0 { reason = reasons[0] } return correctTaskWork(ctx, tx, domain, actor, action, reason, v, old, now) } switch action { case "start": if v.Version != 0 { return v, ErrTaskInvalid } if err == nil { if old.TaskUUID != v.TaskUUID { return v, ErrTaskConflict } return old, tx.Commit() } var yes bool if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM organizer_items WHERE domain_uuid=? AND owner_uuid=? AND uuid=? AND kind='task' AND archived=0 AND status NOT IN ('done','cancelled'))`, domain, actor, v.TaskUUID).Scan(&yes); err != nil { return v, err } if !yes { return v, sql.ErrNoRows } v.StartMS = now.UnixMilli() v.EndMS = 0 v.CancelledMS = 0 v.Version = 1 res, e := tx.ExecContext(ctx, `INSERT OR IGNORE INTO organizer_work_sessions(uuid,domain_uuid,owner_uuid,task_uuid,start_ms) VALUES(?,?,?,?,?)`, v.UUID, domain, actor, v.TaskUUID, v.StartMS) if e != nil { return v, e } n, _ := res.RowsAffected() if n != 1 { return v, ErrTaskConflict } case "stop": if err != nil { return v, err } if old.CancelledMS != 0 { return v, ErrTaskConflict } if old.EndMS > 0 { if v.Version == old.Version || v.Version == old.Version-1 { return old, tx.Commit() } return v, ErrTaskConflict } if old.Version != v.Version { return v, ErrTaskConflict } v = old v.EndMS = max(v.StartMS, now.UnixMilli()) v.Version++ _, err = tx.ExecContext(ctx, `UPDATE organizer_work_sessions SET end_ms=?,version=? WHERE uuid=?`, v.EndMS, v.Version, v.UUID) if err != nil { return v, err } default: return v, ErrTaskInvalid } if action == "stop" { if err = auditTaskWork(ctx, tx, domain, actor, "baseline", "", old, now); err != nil { return v, err } } if err = auditTaskWork(ctx, tx, domain, actor, action, "", v, now); err != nil { return v, err } return v, tx.Commit() } type TaskReportDay struct { Date string `json:"date"` Completed int `json:"completed"` Points int `json:"points"` Estimate int `json:"estimate_minutes"` WorkMS int64 `json:"work_ms"` FocusMS int64 `json:"focus_ms"` } type TaskReportItem struct { UUID string `json:"uuid"` Title string `json:"title"` ProjectUUID string `json:"project_uuid"` ProjectTitle string `json:"project_title"` WorkMS int64 `json:"work_ms"` Points int `json:"points"` Completed bool `json:"completed"` } type TaskReport struct { Days []TaskReportDay `json:"days"` Tasks []TaskReportItem `json:"tasks"` Sessions []TaskWork `json:"sessions"` Partial bool `json:"partial"` Timezone string `json:"timezone"` Projects []TaskReportProject `json:"projects"` } func (s *Store) TaskReport(ctx context.Context, domain, actor string, start, end, now time.Time) (TaskReport, error) { out := TaskReport{Days: []TaskReportDay{}, Tasks: []TaskReportItem{}, Sessions: []TaskWork{}, Timezone: start.Location().String()} if err := taskActor(ctx, s.DB, domain, actor, false); err != nil { return out, err } if !end.After(start) || end.Sub(start) > 367*24*time.Hour { return out, ErrTaskInvalid } days := map[string]int{} for day := start; day.Before(end); day = day.AddDate(0, 0, 1) { days[day.Format("2006-01-02")] = len(out.Days) out.Days = append(out.Days, TaskReportDay{Date: day.Format("2006-01-02")}) } byTask := map[string]int{} rows, err := s.DB.QueryContext(ctx, `SELECT m.completed_ms,m.estimate,m.complexity,m.task_uuid,COALESCE(i.title,''),COALESCE(i.project_uuid,''),COALESCE(p.title,'') FROM organizer_task_metrics m LEFT JOIN organizer_items i ON i.domain_uuid=m.domain_uuid AND i.owner_uuid=m.owner_uuid AND i.uuid=m.task_uuid LEFT JOIN organizer_items p ON p.uuid=i.project_uuid AND p.domain_uuid=m.domain_uuid AND p.owner_uuid=m.owner_uuid AND p.kind='project' WHERE m.domain_uuid=? AND m.owner_uuid=? AND m.completed_ms>=? AND m.completed_ms 10000 { out.Partial = true break } if index, ok := days[time.UnixMilli(ms).In(start.Location()).Format("2006-01-02")]; ok { d := &out.Days[index] d.Completed++ d.Estimate += estimate d.Points += 1 + ((estimate+29)/30)*max(1, complexity) byTask[id] = len(out.Tasks) out.Tasks = append(out.Tasks, TaskReportItem{UUID: id, Title: title, ProjectUUID: project, ProjectTitle: projectTitle, Completed: true, Points: 1 + ((estimate+29)/30)*max(1, complexity)}) } } err = rows.Err() rows.Close() if err != nil { return out, err } // Split intervals at local midnight; never assume a day is exactly 24h. addSpan := func(a, b int64, focus bool) int64 { a = max(a, start.UnixMilli()) b = min(b, end.UnixMilli(), now.UnixMilli()) if b <= a { return 0 } total := b - a for a < b { t := time.UnixMilli(a).In(start.Location()) next := time.Date(t.Year(), t.Month(), t.Day()+1, 0, 0, 0, 0, t.Location()).UnixMilli() stop := min(next, b) if index, ok := days[t.Format("2006-01-02")]; ok { if focus { out.Days[index].FocusMS += stop - a } else { out.Days[index].WorkMS += stop - a } } a = stop } return total } rows, err = s.DB.QueryContext(ctx, `SELECT w.uuid,w.task_uuid,w.start_ms,w.end_ms,w.version,COALESCE(i.title,''),COALESCE(i.project_uuid,''),COALESCE(p.title,'') FROM organizer_work_sessions w LEFT JOIN organizer_items i ON i.domain_uuid=w.domain_uuid AND i.owner_uuid=w.owner_uuid AND i.uuid=w.task_uuid LEFT JOIN organizer_items p ON p.uuid=i.project_uuid AND p.domain_uuid=w.domain_uuid AND p.owner_uuid=w.owner_uuid AND p.kind='project' WHERE w.cancelled_ms=0 AND w.domain_uuid=? AND w.owner_uuid=? AND w.start_ms?) ORDER BY w.start_ms DESC,w.uuid LIMIT 10001`, domain, actor, end.UnixMilli(), start.UnixMilli()) if err != nil { return out, err } n = 0 for rows.Next() { var v TaskWork var title, project, projectTitle string if err = rows.Scan(&v.UUID, &v.TaskUUID, &v.StartMS, &v.EndMS, &v.Version, &title, &project, &projectTitle); err != nil { rows.Close() return out, err } n++ if n > 10000 { out.Partial = true break } finish := v.EndMS if finish == 0 { finish = now.UnixMilli() } elapsed := addSpan(v.StartMS, finish, false) if elapsed == 0 { continue } out.Sessions = append(out.Sessions, v) index, ok := byTask[v.TaskUUID] if !ok { index = len(out.Tasks) byTask[v.TaskUUID] = index out.Tasks = append(out.Tasks, TaskReportItem{UUID: v.TaskUUID, Title: title, ProjectUUID: project, ProjectTitle: projectTitle}) } out.Tasks[index].WorkMS += elapsed } err = rows.Err() rows.Close() if err != nil { return out, err } rows, err = s.DB.QueryContext(ctx, `SELECT start_ms,end_ms FROM organizer_focus_spans WHERE domain_uuid=? AND owner_uuid=? AND start_ms>=? AND start_ms? AND phase='focus' ORDER BY start_ms,session_uuid,version LIMIT 10001`, domain, actor, start.Add(-180*time.Minute).UnixMilli(), end.UnixMilli(), start.UnixMilli()) if err != nil { return out, err } defer rows.Close() n = 0 for rows.Next() { var a, b int64 if err = rows.Scan(&a, &b); err != nil { return out, err } n++ if n > 10000 { out.Partial = true break } addSpan(a, b, true) } if err = rows.Err(); err != nil { return out, err } groups := map[string]*TaskReportProject{} for _, task := range out.Tasks { p := groups[task.ProjectUUID] if p == nil { p = &TaskReportProject{UUID: task.ProjectUUID, Title: task.ProjectTitle} groups[task.ProjectUUID] = p } if task.Completed { p.Completed++ } p.Points += task.Points p.WorkMS += task.WorkMS } out.Projects = []TaskReportProject{} for _, p := range groups { out.Projects = append(out.Projects, *p) } sort.Slice(out.Projects, func(i, j int) bool { if out.Projects[i].Title != out.Projects[j].Title { return out.Projects[i].Title < out.Projects[j].Title } return out.Projects[i].UUID < out.Projects[j].UUID }) return out, nil } type TaskReportProject struct { UUID string `json:"uuid"` Title string `json:"title"` Completed int `json:"completed"` Points int `json:"points"` WorkMS int64 `json:"work_ms"` }