package store import ( "context" "database/sql" "encoding/base64" "encoding/json" "strings" "time" "unicode/utf8" "github.com/google/uuid" ) type TaskWorkRevision struct { Item TaskWork `json:"item"` Action string `json:"action"` Reason string `json:"reason"` ChangedMS int64 `json:"changed_ms"` } func auditTaskWork(ctx context.Context, tx *sql.Tx, domain, actor, action, reason string, v TaskWork, now time.Time) error { raw, err := json.Marshal(v) if err != nil { return err } // Legacy sessions acquire a baseline lazily. Never rewrite an earlier audit. query := `INSERT INTO organizer_work_revisions(work_uuid,version,domain_uuid,owner_uuid,action,reason,changed_ms,data) VALUES(?,?,?,?,?,?,?,?)` if action == "baseline" { query += ` ON CONFLICT(work_uuid,version) DO NOTHING` } _, err = tx.ExecContext(ctx, query, v.UUID, v.Version, domain, actor, action, reason, now.UnixMilli(), string(raw)) return err } func correctTaskWork(ctx context.Context, tx *sql.Tx, domain, actor, action, reason string, v, old TaskWork, now time.Time) (TaskWork, error) { reason = strings.TrimSpace(reason) if reason == "" || len(reason) > 500 || !utf8.ValidString(reason) || strings.ContainsAny(reason, "\x00\r\n") { return v, ErrTaskInvalid } if v.Version < 1 || old.EndMS == 0 || old.CancelledMS != 0 { return v, ErrTaskConflict } if old.Version != v.Version { return v, ErrTaskConflict } if v.TaskUUID != "" && v.TaskUUID != old.TaskUUID { return v, ErrTaskInvalid } result := old if action == "correct" { if v.StartMS <= 0 || v.EndMS <= v.StartMS || v.EndMS > now.UnixMilli() || v.EndMS-v.StartMS > int64(31*24*time.Hour/time.Millisecond) { return v, ErrTaskInvalid } // Adjacent spans are valid; double-counted elapsed time is not. Scope across // Domains like the existing one-active-session constraint, without disclosing them. var overlap bool err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM organizer_work_sessions WHERE owner_uuid=? AND uuid<>? AND cancelled_ms=0 AND start_ms?))`, actor, old.UUID, v.EndMS, v.StartMS).Scan(&overlap) if err != nil { return v, err } if overlap { return v, ErrTaskConflict } result.StartMS = v.StartMS result.EndMS = v.EndMS } else { result.CancelledMS = now.UnixMilli() } if err := auditTaskWork(ctx, tx, domain, actor, "baseline", "", old, now); err != nil { return v, err } result.Version++ updated, err := tx.ExecContext(ctx, `UPDATE organizer_work_sessions SET start_ms=?,end_ms=?,cancelled_ms=?,version=? WHERE uuid=? AND domain_uuid=? AND owner_uuid=? AND version=?`, result.StartMS, result.EndMS, result.CancelledMS, result.Version, old.UUID, domain, actor, old.Version) if err != nil { return v, err } if count, err := updated.RowsAffected(); err != nil { return v, err } else if count != 1 { return v, ErrTaskConflict } if err := auditTaskWork(ctx, tx, domain, actor, action, reason, result, now); err != nil { return v, err } return result, tx.Commit() } type TaskWorkEntry struct { TaskWork Title string `json:"title"` ProjectUUID string `json:"project_uuid"` } type TaskWorkPage struct { Items []TaskWorkEntry `json:"items"` Next string `json:"next"` } type workCursor struct { Start int64 `json:"start"` UUID string `json:"uuid"` } func (s *Store) TaskWorkHistory(ctx context.Context, domain, actor string, start, end time.Time, after string, limit int) (TaskWorkPage, error) { out := TaskWorkPage{Items: []TaskWorkEntry{}} 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 || limit < 1 || limit > 100 { return out, ErrTaskInvalid } query := `SELECT w.uuid,w.task_uuid,w.start_ms,w.end_ms,w.version,w.cancelled_ms,COALESCE(i.title,''),COALESCE(i.project_uuid,'') FROM organizer_work_sessions w LEFT JOIN organizer_items i ON i.uuid=w.task_uuid AND i.domain_uuid=w.domain_uuid AND i.owner_uuid=w.owner_uuid WHERE w.domain_uuid=? AND w.owner_uuid=? AND w.start_ms?)` args := []any{domain, actor, end.UnixMilli(), start.UnixMilli()} if after != "" { if len(after) > 256 { return out, ErrTaskInvalid } raw, err := base64.RawURLEncoding.DecodeString(after) var cursor workCursor if err != nil || json.Unmarshal(raw, &cursor) != nil || cursor.Start <= 0 { return out, ErrTaskInvalid } if id, err := uuid.Parse(cursor.UUID); err != nil || id.String() != cursor.UUID { return out, ErrTaskInvalid } query += ` AND (w.start_ms,w.uuid)<(?,?)` args = append(args, cursor.Start, cursor.UUID) } query += ` ORDER BY w.start_ms DESC,w.uuid DESC LIMIT ?` args = append(args, limit+1) rows, err := s.DB.QueryContext(ctx, query, args...) if err != nil { return out, err } defer rows.Close() for rows.Next() { var v TaskWorkEntry if err = rows.Scan(&v.UUID, &v.TaskUUID, &v.StartMS, &v.EndMS, &v.Version, &v.CancelledMS, &v.Title, &v.ProjectUUID); err != nil { return out, err } out.Items = append(out.Items, v) } if len(out.Items) > limit { out.Items = out.Items[:limit] last := out.Items[limit-1] raw, _ := json.Marshal(workCursor{Start: last.StartMS, UUID: last.UUID}) out.Next = base64.RawURLEncoding.EncodeToString(raw) } return out, rows.Err() } func (s *Store) TaskWorkRevisions(ctx context.Context, domain, actor, id string, before int64) ([]TaskWorkRevision, error) { out := []TaskWorkRevision{} if err := taskActor(ctx, s.DB, domain, actor, false); err != nil { return out, err } if before < 0 { return out, ErrTaskInvalid } current, err := scanTaskWork(s.DB.QueryRowContext(ctx, `SELECT `+taskWorkColumns+` FROM organizer_work_sessions WHERE uuid=? AND domain_uuid=? AND owner_uuid=?`, id, domain, actor)) if err != nil { return out, err } if before == 0 { before = current.Version + 1 } rows, err := s.DB.QueryContext(ctx, `SELECT action,reason,changed_ms,data FROM organizer_work_revisions WHERE work_uuid=? AND domain_uuid=? AND owner_uuid=? AND version current.Version { out = append(out, TaskWorkRevision{Item: current, Action: "baseline"}) } return out, rows.Err() }