feat: add audited work records and controlled digest retries
Build and publish container images / images (push) Successful in 12m27s

This commit is contained in:
Anya Tokugawa committed 2026-11-08 02:35:29 +09:00
1 parent 6e0aecdfb3
commit e65ca56f92
33 files changed
+2262 -114

No files matched your search

+2
View File
@@ -108,6 +108,8 @@ func organizerSection(path string) string {
}
func init() {
translations["en"]["task.work_history"] = "Work history"
translations["ja"]["task.work_history"] = "作業記録"
for lang, entries := range map[string]map[string]string{
"en": {"organizer.title": "Organizer", "organizer.dashboard": "Dashboard", "organizer.settings": "Personal settings", "organizer.contacts": "Contacts", "organizer.private": "Preferences apply only to you in this Domain. System administration is separate.", "organizer.calendar_defaults": "Default calendars", "organizer.open": "Open"},
"ja": {"organizer.title": "オーガナイザー", "organizer.dashboard": "ダッシュボード", "organizer.settings": "個人設定", "organizer.contacts": "連絡先", "organizer.private": "このドメイン内の自分だけに適用する設定です。システムの管理設定とは別です。", "organizer.calendar_defaults": "既定のカレンダー", "organizer.open": "開く"},
+96 -53
View File
@@ -38,67 +38,110 @@ func sendTaskDigestSMTP(ctx context.Context, config store.AuthProviderConfig, re
func (s *Server) deliverTaskDigests(ctx context.Context, job *store.EventJob) error {
ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
defer cancel()
if _, err := s.store.MaintainTaskDigests(ctx, time.Now()); err != nil {
return err
}
queued, err := s.store.QueuedTaskDigests(ctx)
if err != nil {
return err
}
due, err := s.store.DueTaskDigests(ctx, time.Now())
if err != nil {
return err
}
sent, uncertain := 0, 0
for _, candidate := range due {
sent, uncertain, checked := 0, 0, 0
deliver := func(claim store.TaskDigestClaim) error {
state, reason := s.deliverTaskDigest(ctx, claim)
if state == "sent" {
sent++
}
if state == "uncertain" {
uncertain++
}
checked++
finish, stop := context.WithTimeout(context.Background(), 2*time.Second)
defer stop()
err := s.store.FinishTaskDigestReason(finish, claim, state, reason, time.Now())
// A reclaimed generation cannot complete a newer attempt.
if errors.Is(err, store.ErrTaskConflict) {
return nil
}
return err
}
// Alternate automatic delivery and manual retries within the shared time
// budget, so a retry backlog cannot monopolize scheduled deliveries.
for i := 0; i < max(len(due), len(queued)); i++ {
for _, manual := range []bool{false, true} {
if ctx.Err() != nil {
break
}
var claim store.TaskDigestClaim
var e error
if manual {
if i >= len(queued) {
continue
}
claim, e = s.store.ClaimQueuedTaskDigest(ctx, queued[i], time.Now())
} else {
if i >= len(due) {
continue
}
claim, e = s.store.ClaimTaskDigest(ctx, due[i], time.Now())
}
if errors.Is(e, sql.ErrNoRows) {
continue
}
if e != nil {
return e
}
if e = deliver(claim); e != nil {
return e
}
}
if ctx.Err() != nil {
break
}
claim, e := s.store.ClaimTaskDigest(ctx, candidate, time.Now())
if errors.Is(e, sql.ErrNoRows) {
continue
}
if e != nil {
return e
}
state := "cancelled"
if s.systemExtensionEnabled(claim.Domain, "organizer.tasks") {
config, e := s.store.AuthProviderConfig(claim.Domain, "smtp")
if e == nil && config.Enabled {
items, next, e := s.store.ListTasks(ctx, claim.Domain, claim.Owner, store.TaskQuery{Kind: "task", View: "today", Today: claim.Day, Limit: 100})
if e == nil {
var body strings.Builder
host, _ := s.store.GetDomainEffectiveHost(claim.Domain)
base := ""
if host != "" && !strings.ContainsAny(host, "/\\\r\n\t @") {
base = "https://" + host
}
fmt.Fprintf(&body, "Tasks / やることリスト — %s (%s)\n\n", claim.Day, claim.Timezone)
if len(items) == 0 {
body.WriteString("No tasks due or planned today. / 今日の対象タスクはありません。\n")
}
for _, item := range items {
fmt.Fprintf(&body, "- %s\n due/期限: %s | planned/予定: %s | estimate/見積: %d min\n %s/v/plan/task/%s\n", item.Title, item.DueOn, item.PlannedOn, item.Estimate, base, item.UUID)
}
if next != "" {
body.WriteString("\nFirst 100 items only. / 最初の100件です。続きはタスク画面で確認してください。\n")
}
// Check consent and current account email immediately before send.
if recipient, e := s.store.TaskDigestRecipient(ctx, claim); e == nil {
state = "uncertain"
if e = sendTaskDigestSMTP(ctx, config, recipient, claim.Day, body.String()); e == nil {
state = "sent"
sent++
} else {
uncertain++
}
}
}
}
}
// Persist delivery outcome even if the scheduler context was cancelled.
finish, stop := context.WithTimeout(context.Background(), 2*time.Second)
e = s.store.FinishTaskDigest(finish, claim, state)
stop()
if e != nil {
return e
}
}
if len(due) > 0 {
s.addEventProgressLog(ctx, job, fmt.Sprintf("task digest checked=%d sent=%d uncertain=%d", len(due), sent, uncertain))
if checked > 0 {
s.addEventProgressLog(ctx, job, fmt.Sprintf("task digest checked=%d sent=%d uncertain=%d", checked, sent, uncertain))
}
return nil
}
func (s *Server) deliverTaskDigest(ctx context.Context, claim store.TaskDigestClaim) (string, string) {
if !s.systemExtensionEnabled(claim.Domain, "organizer.tasks") {
return "cancelled", "extension_disabled"
}
config, err := s.store.AuthProviderConfig(claim.Domain, "smtp")
if err != nil || !config.Enabled {
return "cancelled", "smtp_unavailable"
}
items, next, err := s.store.ListTasks(ctx, claim.Domain, claim.Owner, store.TaskQuery{Kind: "task", View: "today", Today: claim.Day, Limit: 100})
if err != nil {
return "cancelled", "tasks_unavailable"
}
var body strings.Builder
host, _ := s.store.GetDomainEffectiveHost(claim.Domain)
base := ""
if host != "" && !strings.ContainsAny(host, "/\\\r\n\t @") {
base = "https://" + host
}
fmt.Fprintf(&body, "Tasks / やることリスト — %s (%s)\n\n", claim.Day, claim.Timezone)
if len(items) == 0 {
body.WriteString("No tasks due or planned today. / 今日の対象タスクはありません。\n")
}
for _, item := range items {
fmt.Fprintf(&body, "- %s\n due/期限: %s | planned/予定: %s | estimate/見積: %d min\n %s/v/plan/task/%s\n", item.Title, item.DueOn, item.PlannedOn, item.Estimate, base, item.UUID)
}
if next != "" {
body.WriteString("\nFirst 100 items only. / 最初の100件です。続きはタスク画面で確認してください。\n")
}
recipient, err := s.store.TaskDigestRecipient(ctx, claim)
if err != nil {
return "cancelled", "consent_changed"
}
if err = sendTaskDigestSMTP(ctx, config, recipient, claim.Day, body.String()); err != nil {
return "uncertain", "transport_uncertain"
}
return "sent", ""
}
+82
View File
@@ -0,0 +1,82 @@
package server
import (
"database/sql"
"errors"
"net/http"
"strconv"
"time"
"pageswiki/internal/store"
)
func (s *Server) handleTaskDigestHistory(w http.ResponseWriter, r *http.Request, actor string, active bool, parts []string) {
domain := s.domainUUIDForRequest(r)
if len(parts) == 1 && r.Method == "GET" {
limit := 50
if raw := r.URL.Query().Get("limit"); raw != "" {
v, e := strconv.Atoi(raw)
if e != nil {
taskError(w, store.ErrTaskInvalid)
return
}
limit = v
}
result, err := s.store.TaskDigestHistory(r.Context(), domain, actor, r.URL.Query().Get("after"), limit, time.Now())
if err != nil {
taskError(w, err)
return
}
writeEventJSON(w, 200, result)
return
}
if len(parts) == 2 && parts[1] == "retry" && r.Method == "POST" {
if !active {
taskError(w, store.ErrAccessDenied)
return
}
var input store.TaskDigestRetry
if !taskJSON(w, r, &input) {
return
}
if id, err := s.store.TaskDigestRetryReceipt(r.Context(), domain, actor, input); err == nil {
writeEventJSON(w, 202, map[string]string{"request_id": id})
return
} else if !errors.Is(err, sql.ErrNoRows) {
taskError(w, err)
return
}
principal, err := s.store.PrincipalForSession(domain, s.authTokenFromRequest(r))
if err != nil {
taskError(w, store.ErrAccessDenied)
return
}
if _, err = smtpMailbox(principal.Email); err != nil {
writeEventJSON(w, 422, map[string]string{"error": "email_required"})
return
}
config, err := s.store.AuthProviderConfig(domain, "smtp")
if err != nil || !config.Enabled {
writeEventJSON(w, 422, map[string]string{"error": "smtp_unavailable"})
return
}
id, err := s.store.QueueTaskDigestRetry(r.Context(), domain, actor, input, time.Now())
if err != nil {
taskError(w, err)
return
}
writeEventJSON(w, 202, map[string]string{"request_id": id})
return
}
if len(parts) == 1 {
w.Header().Set("Allow", "GET")
w.WriteHeader(405)
return
}
if len(parts) == 2 && parts[1] == "retry" {
w.Header().Set("Allow", "POST")
w.WriteHeader(405)
return
}
http.NotFound(w, r)
}
+447
View File
@@ -0,0 +1,447 @@
package server
import (
"context"
"database/sql"
"encoding/json"
"errors"
"net/http"
"net/http/httptest"
"os"
"os/exec"
"strings"
"sync"
"testing"
"time"
"github.com/google/uuid"
"pageswiki/internal/store"
)
func digestHistoryFixture(t *testing.T) (*Server, string, string, string, time.Time, store.TaskDigestClaim) {
t.Helper()
s, token, domain, actor := taskFixture(t)
ctx := context.Background()
now := time.Now().UTC()
p := store.TaskPreferences{Complexity: 1, DigestEnabled: true, DigestTime: "00:00", Timezone: "UTC"}
if _, err := s.store.SaveTaskPreferences(ctx, domain, actor, p, now.Add(-24*time.Hour)); err != nil {
t.Fatal(err)
}
if _, err := s.store.DB.Exec(`UPDATE principals SET email='reader@example.test' WHERE uuid=?`, actor); err != nil {
t.Fatal(err)
}
if err := s.store.SetAuthProviderConfig(domain, store.AuthProviderConfig{Kind: "smtp", Enabled: true, SMTPAddress: "127.0.0.1:1", SMTPFrom: "wiki@example.test"}); err != nil {
t.Fatal(err)
}
c, err := s.store.ClaimTaskDigest(ctx, store.TaskDigestDue{Domain: domain, Owner: actor}, now)
if err != nil {
t.Fatal(err)
}
return s, token, domain, actor, now, c
}
func TestTaskDigestHistoryRetryGenerationAndConsent(t *testing.T) {
s, token, domain, actor, now, c := digestHistoryFixture(t)
ctx := context.Background()
if recipient, err := s.store.TaskDigestRecipient(ctx, c); err != nil || recipient != "reader@example.test" {
t.Fatal(recipient, err)
}
input := store.TaskDigestRetry{RequestID: uuid.NewString(), Day: c.Day, ExpectedAttempt: c.AttemptUUID}
post := func(v store.TaskDigestRetry) int {
return taskRequest(s, token, "POST", "digest-history/retry", v, "").Code
}
if got := post(input); got != 412 {
t.Fatal("retried active delivery", got)
}
if err := s.store.FinishTaskDigest(ctx, c, "sent"); err != nil {
t.Fatal(err)
}
if got := post(input); got != 422 {
t.Fatal("missing duplicate acknowledgment", got)
}
input.DuplicateAcknowledged = true
var wg sync.WaitGroup
results := make(chan int, 2)
for range 2 {
wg.Add(1)
go func() { defer wg.Done(); results <- post(input) }()
}
wg.Wait()
close(results)
for code := range results {
if code != 202 {
t.Fatal("idempotent retry", code)
}
}
q, err := s.store.QueuedTaskDigests(ctx)
if err != nil || len(q) != 1 || q[0].AttemptUUID != input.RequestID {
t.Fatal(q, err)
}
if err = s.store.SetAuthProviderConfig(domain, store.AuthProviderConfig{Kind: "smtp", Enabled: false, SMTPAddress: "127.0.0.1:1", SMTPFrom: "wiki@example.test"}); err != nil {
t.Fatal(err)
}
if got := post(input); got != 202 {
t.Fatal("accepted receipt lost after SMTP disabled", got)
}
if err = s.store.SetAuthProviderConfig(domain, store.AuthProviderConfig{Kind: "smtp", Enabled: true, SMTPAddress: "127.0.0.1:1", SMTPFrom: "wiki@example.test"}); err != nil {
t.Fatal(err)
}
changed := input
changed.DuplicateAcknowledged = false
if got := post(changed); got != 412 {
t.Fatal("changed replay", got)
}
changed = input
changed.RequestID = uuid.NewString()
if got := post(changed); got != 412 {
t.Fatal("second queued request", got)
}
newClaim, err := s.store.ClaimQueuedTaskDigest(ctx, q[0], now)
if err != nil {
t.Fatal(err)
}
if _, err = s.store.ClaimQueuedTaskDigest(ctx, q[0], now); !errors.Is(err, sql.ErrNoRows) {
t.Fatal("double claim", err)
}
if err = s.store.FinishTaskDigest(ctx, c, "cancelled"); !errors.Is(err, store.ErrTaskConflict) {
t.Fatal("old generation finished new attempt", err)
}
if _, err = s.store.TaskDigestRecipient(ctx, c); err == nil {
t.Fatal("old generation can send")
}
if _, err = s.store.TaskDigestRecipient(ctx, newClaim); err != nil {
t.Fatal(err)
}
p, err := s.store.TaskPreferences(ctx, domain, actor)
if err != nil {
t.Fatal(err)
}
p.DigestEnabled = false
if _, err = s.store.SaveTaskPreferences(ctx, domain, actor, p, now); err != nil {
t.Fatal(err)
}
if _, err = s.store.TaskDigestRecipient(ctx, newClaim); err == nil {
t.Fatal("opt out ignored")
}
if err = s.store.FinishTaskDigestReason(ctx, newClaim, "cancelled", "consent_changed", now); err != nil {
t.Fatal(err)
}
w := taskRequest(s, token, "GET", "digest-history?limit=1", nil, "")
if w.Code != 200 {
t.Fatal(w.Code, w.Body)
}
var page store.TaskDigestHistory
if err = json.Unmarshal(w.Body.Bytes(), &page); err != nil || len(page.Items) != 1 || page.Next == "" || page.Retries != 1 || page.Current.UUID != input.RequestID {
t.Fatal(page, err)
}
w = taskRequest(s, token, "GET", "digest-history?limit=1&after="+page.Next, nil, "")
if w.Code != 200 {
t.Fatal(w.Code, w.Body)
}
for _, suffix := range []string{"?limit=101", "?after=bad", "?limit=NaN"} {
if w = taskRequest(s, token, "GET", "digest-history"+suffix, nil, ""); w.Code != 422 {
t.Fatal(suffix, w.Code)
}
}
if strings.Contains(w.Body.String(), "reader@example.test") {
t.Fatal("email in history")
}
}
func TestTaskDigestHistoryQueueExpiryAndPermissions(t *testing.T) {
for _, change := range []string{"preference", "extension", "suspended", "tomorrow"} {
t.Run(change, func(t *testing.T) {
s, _, domain, actor, now, c := digestHistoryFixture(t)
ctx := context.Background()
if err := s.store.FinishTaskDigest(ctx, c, "cancelled"); err != nil {
t.Fatal(err)
}
input := store.TaskDigestRetry{RequestID: uuid.NewString(), Day: c.Day, ExpectedAttempt: c.AttemptUUID}
if _, err := s.store.QueueTaskDigestRetry(ctx, domain, actor, input, now); err != nil {
t.Fatal(err)
}
q, err := s.store.QueuedTaskDigests(ctx)
if err != nil {
t.Fatal(err)
}
switch change {
case "preference":
p, e := s.store.TaskPreferences(ctx, domain, actor)
if e != nil {
t.Fatal(e)
}
p.Estimate++
_, err = s.store.SaveTaskPreferences(ctx, domain, actor, p, now)
case "extension":
err = s.store.SetConfigInDomain(domain, "system_extension_states", `{"organizer.tasks":false}`)
case "suspended":
_, err = s.store.DB.Exec(`UPDATE domain_memberships SET state='suspended' WHERE domain_uuid=? AND principal_uuid=?`, domain, actor)
case "tomorrow":
now = now.Add(24 * time.Hour)
}
if err != nil {
t.Fatal(err)
}
if _, err = s.store.ClaimQueuedTaskDigest(ctx, q[0], now); !errors.Is(err, sql.ErrNoRows) {
t.Fatal("cancelled queue returned live claim", err)
}
var state string
if err = s.store.DB.QueryRow(`SELECT state FROM organizer_digest_attempts WHERE uuid=?`, input.RequestID).Scan(&state); err != nil || state != "cancelled" {
t.Fatal(state, err)
}
})
}
s, token, domain, actor, now, c := digestHistoryFixture(t)
ctx := context.Background()
if err := s.store.FinishTaskDigest(ctx, c, "cancelled"); err != nil {
t.Fatal(err)
}
other, err := s.store.CreatePasswordAccount(domain, "digest-other", "a long test password", "Other", "")
if err != nil {
t.Fatal(err)
}
otherToken, err := s.store.CreateAuthSession(domain, other.UUID)
if err != nil {
t.Fatal(err)
}
w := taskRequest(s, otherToken, "GET", "digest-history", nil, "")
if w.Code != 200 || !strings.Contains(w.Body.String(), `"items":[]`) {
t.Fatal("history privacy", w.Code, w.Body)
}
input := store.TaskDigestRetry{RequestID: uuid.NewString(), Day: c.Day, ExpectedAttempt: c.AttemptUUID}
if _, err = s.store.QueueTaskDigestRetry(ctx, domain, other.UUID, input, now); err == nil {
t.Fatal("retried other's mail")
}
if err = s.store.SetPrincipalState(domain, actor, "readonly"); err != nil {
t.Fatal(err)
}
token, err = s.store.CreateAuthSession(domain, actor)
if err != nil {
t.Fatal(err)
}
if w = taskRequest(s, token, "POST", "digest-history/retry", input, ""); w.Code != 403 {
t.Fatal(w.Code, w.Body)
}
if w = taskRequest(s, token, "GET", "digest-history", nil, ""); w.Code != 200 {
t.Fatal(w.Code, w.Body)
}
if w = taskRequest(s, "", "GET", "digest-history", nil, ""); w.Code == 200 {
t.Fatal("anonymous history")
}
}
func TestTaskDigestHistoryRetentionAndStaleWorker(t *testing.T) {
s, _, domain, actor, now, c := digestHistoryFixture(t)
ctx := context.Background()
// Keep synthetic stale-worker time within the same date even near midnight.
now = time.Date(now.Year(), now.Month(), now.Day(), 12, 0, 0, 0, time.UTC)
if _, err := s.store.DB.Exec(`UPDATE organizer_digest_attempts SET updated_ms=? WHERE uuid=?`, now.UnixMilli(), c.AttemptUUID); err != nil {
t.Fatal(err)
}
if _, err := s.store.MaintainTaskDigests(ctx, now.Add(11*time.Minute)); err != nil {
t.Fatal(err)
}
page, err := s.store.TaskDigestHistory(ctx, domain, actor, "", 50, now)
if err != nil || page.Current.State != "uncertain" {
t.Fatal(page, err)
}
input := store.TaskDigestRetry{RequestID: uuid.NewString(), Day: c.Day, ExpectedAttempt: c.AttemptUUID, DuplicateAcknowledged: true}
if _, err = s.store.QueueTaskDigestRetry(ctx, domain, actor, input, now.Add(12*time.Minute)); err != nil {
t.Fatal(err)
}
q, err := s.store.QueuedTaskDigests(ctx)
if err != nil {
t.Fatal(err)
}
claim, err := s.store.ClaimQueuedTaskDigest(ctx, q[0], now.Add(12*time.Minute))
if err != nil {
t.Fatal(err)
}
if err = s.store.FinishTaskDigest(ctx, c, "sent"); !errors.Is(err, store.ErrTaskConflict) {
t.Fatal("stale completion", err)
}
if err = s.store.FinishTaskDigestReason(ctx, claim, "sent", "", now.Add(12*time.Minute)); err != nil {
t.Fatal(err)
}
deleted, err := s.store.MaintainTaskDigests(ctx, now.Add(91*24*time.Hour))
if err != nil || deleted != 2 {
t.Fatal("retention", deleted, err)
}
var reservations, receipts int
if err = s.store.DB.QueryRow(`SELECT count(*) FROM organizer_digest_deliveries WHERE domain_uuid=? AND owner_uuid=?`, domain, actor).Scan(&reservations); err != nil {
t.Fatal(err)
}
if err = s.store.DB.QueryRow(`SELECT count(*) FROM organizer_digest_requests WHERE domain_uuid=? AND owner_uuid=?`, domain, actor).Scan(&receipts); err != nil || reservations != 1 || receipts != 1 {
t.Fatal("deduplication lost", reservations, receipts, err)
}
// Even an old request replay after retention returns its receipt without requeueing.
if id, err := s.store.QueueTaskDigestRetry(ctx, domain, actor, input, now.Add(91*24*time.Hour)); err != nil || id != input.RequestID {
t.Fatal(id, err)
}
q, err = s.store.QueuedTaskDigests(ctx)
if err != nil || len(q) != 0 {
t.Fatal("retention resurrected mail", q, err)
}
if _, err = s.store.DB.Exec(`UPDATE organizer_task_preferences SET next_digest_ms=? WHERE domain_uuid=? AND owner_uuid=?`, now.Add(-time.Minute).UnixMilli(), domain, actor); err != nil {
t.Fatal(err)
}
if _, err = s.store.ClaimTaskDigest(ctx, store.TaskDigestDue{Domain: domain, Owner: actor}, now); !errors.Is(err, sql.ErrNoRows) {
t.Fatal("reservation lost", err)
}
}
func TestTaskDigestHistorySMTPWorker(t *testing.T) {
s, _, domain, actor, now, c := digestHistoryFixture(t)
ctx := context.Background()
if err := s.store.FinishTaskDigest(ctx, c, "cancelled"); err != nil {
t.Fatal(err)
}
input := store.TaskDigestRetry{RequestID: uuid.NewString(), Day: c.Day, ExpectedAttempt: c.AttemptUUID}
if _, err := s.store.QueueTaskDigestRetry(ctx, domain, actor, input, now); err != nil {
t.Fatal(err)
}
address, _, done := fakeSMTP(t, "", false)
if err := s.store.SetAuthProviderConfig(domain, store.AuthProviderConfig{Kind: "smtp", Enabled: true, SMTPAddress: address, SMTPFrom: "wiki@example.test"}); err != nil {
t.Fatal(err)
}
if err := s.deliverTaskDigests(ctx, &store.EventJob{}); err != nil {
t.Fatal(err)
}
delivery := <-done
if !strings.Contains(delivery.message, "Subject: PagesWiki tasks "+c.Day) {
t.Fatal("message missing")
}
page, err := s.store.TaskDigestHistory(ctx, domain, actor, "", 50, now)
if err != nil || page.Current.State != "sent" || len(page.Items) != 2 {
t.Fatal(page, err)
}
if err := s.deliverTaskDigests(ctx, &store.EventJob{}); err != nil {
t.Fatal(err)
}
}
func TestTaskDigestHistoryLimitsAndAtomicQueue(t *testing.T) {
s, _, domain, actor, now, c := digestHistoryFixture(t)
ctx := context.Background()
if err := s.store.FinishTaskDigest(ctx, c, "cancelled"); err != nil {
t.Fatal(err)
}
input := store.TaskDigestRetry{RequestID: uuid.NewString(), Day: c.Day, ExpectedAttempt: c.AttemptUUID}
if _, err := s.store.DB.Exec(`CREATE TRIGGER fail_digest_queue BEFORE INSERT ON organizer_digest_attempts WHEN NEW.kind='manual' BEGIN SELECT RAISE(ABORT,'test queue failure'); END`); err != nil {
t.Fatal(err)
}
if _, err := s.store.QueueTaskDigestRetry(ctx, domain, actor, input, now); err == nil {
t.Fatal("injected failure ignored")
}
var count int
if err := s.store.DB.QueryRow(`SELECT count(*) FROM organizer_digest_requests`).Scan(&count); err != nil || count != 0 {
t.Fatal("partial receipt", count, err)
}
if _, err := s.store.DB.Exec(`DROP TRIGGER fail_digest_queue`); err != nil {
t.Fatal(err)
}
for i := 0; i < 5; i++ {
input.RequestID = uuid.NewString()
if _, err := s.store.QueueTaskDigestRetry(ctx, domain, actor, input, now); err != nil {
t.Fatal(i, err)
}
q, err := s.store.QueuedTaskDigests(ctx)
if err != nil || len(q) != 1 {
t.Fatal(q, err)
}
claim, err := s.store.ClaimQueuedTaskDigest(ctx, q[0], now)
if err != nil {
t.Fatal(err)
}
if err = s.store.FinishTaskDigest(ctx, claim, "cancelled"); err != nil {
t.Fatal(err)
}
input.ExpectedAttempt = claim.AttemptUUID
}
input.RequestID = uuid.NewString()
if _, err := s.store.QueueTaskDigestRetry(ctx, domain, actor, input, now); !errors.Is(err, store.ErrTaskConflict) {
t.Fatal("retry cap", err)
}
input.Day = now.AddDate(0, 0, -1).Format("2006-01-02")
if _, err := s.store.QueueTaskDigestRetry(ctx, domain, actor, input, now); !errors.Is(err, store.ErrTaskInvalid) {
t.Fatal("past day accepted", err)
}
// A bounded retention pass leaves queued rows and durable guards untouched.
_, err := s.store.DB.Exec(`WITH RECURSIVE n(i) AS (VALUES(1) UNION ALL SELECT i+1 FROM n WHERE i<501) INSERT INTO organizer_digest_attempts SELECT 'old-'||i,'d','u','2000-01-01','scheduled','sent',1,'UTC','',1,1 FROM n`)
if err != nil {
t.Fatal(err)
}
deleted, err := s.store.MaintainTaskDigests(ctx, now)
if err != nil || deleted != 500 {
t.Fatal("unbounded retention", deleted, err)
}
if err = s.store.DB.QueryRow(`SELECT count(*) FROM organizer_digest_attempts WHERE uuid LIKE 'old-%'`).Scan(&count); err != nil || count != 1 {
t.Fatal(count, err)
}
var integrity string
if err = s.store.DB.QueryRow(`PRAGMA integrity_check`).Scan(&integrity); err != nil || integrity != "ok" {
t.Fatal(integrity, err)
}
}
func TestTaskDigestHistoryChromium(t *testing.T) {
if os.Getenv("PAGESWIKI_BROWSER_TEST") != "1" {
t.Skip("opt-in Chromium")
}
s, token, domain, actor, now, c := digestHistoryFixture(t)
s.store.BackgroundJobsDisabled = true
s = New(s.store)
if err := s.store.FinishTaskDigest(context.Background(), c, "uncertain"); err != nil {
t.Fatal(err)
}
address, _, done := fakeSMTP(t, "", false)
if err := s.store.SetAuthProviderConfig(domain, store.AuthProviderConfig{Kind: "smtp", Enabled: true, SMTPAddress: address, SMTPFrom: "wiki@example.test"}); err != nil {
t.Fatal(err)
}
script, err := os.ReadFile("internal/server/testdata/task-digest-history.js")
if err != nil {
t.Fatal(err)
}
handler := s.handler()
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
r.Host = "localhost"
r.Header.Set("Authorization", "Bearer "+token)
if r.URL.Path == "/fixture" {
w.Header().Set("Content-Type", "text/html; charset=utf-8")
_, _ = w.Write([]byte("<!doctype html><body style='margin:0'><script>" + string(script) + "</script></body>"))
return
}
if r.URL.Path == "/fixture/tick" && r.Method == "POST" {
if e := s.deliverTaskDigests(r.Context(), &store.EventJob{}); e != nil {
http.Error(w, "worker failed", 500)
return
}
w.WriteHeader(204)
return
}
handler.ServeHTTP(w, r)
}))
defer server.Close()
ctx, cancel := context.WithTimeout(context.Background(), 55*time.Second)
defer cancel()
width := os.Getenv("DIGEST_HISTORY_WIDTH")
if width == "" {
width = "1440"
}
args := []string{"internal/server/testdata/vim-browser-smoke.mjs", server.URL + "/fixture", t.TempDir(), os.Getenv("DIGEST_HISTORY_SCREENSHOT"), width, "850"}
if out, err := exec.CommandContext(ctx, "node", args...).CombinedOutput(); err != nil {
t.Fatalf("browser: %v\n%s", err, out)
}
select {
case delivery := <-done:
if !strings.Contains(delivery.message, "Subject: PagesWiki tasks "+c.Day) {
t.Fatal("mail missing")
}
case <-ctx.Done():
t.Fatal("SMTP not observed")
}
page, err := s.store.TaskDigestHistory(context.Background(), domain, actor, "", 50, now)
if err != nil || page.Retries != 1 || len(page.Items) != 2 || page.Current.State != "sent" {
t.Fatal(page, err)
}
}
+14 -1
View File
@@ -301,11 +301,24 @@ func (s *Server) handleTaskProductivity(w http.ResponseWriter, r *http.Request,
var input struct {
store.TaskWork
Action string `json:"action"`
Reason string `json:"reason"`
Start string `json:"start"`
End string `json:"end"`
}
if !taskJSON(w, r, &input) {
return
}
v, err := s.store.ChangeTaskWork(r.Context(), domain, actor, input.Action, input.TaskWork, time.Now())
if input.Action == "correct" && (input.Start != "" || input.End != "") {
a, e1 := parseWorkInstant(input.Start, s.getLocation(domain))
b, e2 := parseWorkInstant(input.End, s.getLocation(domain))
if e1 != nil || e2 != nil {
taskError(w, store.ErrTaskInvalid)
return
}
input.StartMS = a.UnixMilli()
input.EndMS = b.UnixMilli()
}
v, err := s.store.ChangeTaskWork(r.Context(), domain, actor, input.Action, input.TaskWork, time.Now(), input.Reason)
if err != nil {
taskError(w, err)
return
@@ -222,6 +222,9 @@ func TestTaskWorkReportSplitsMidnightAndCompletion(t *testing.T) {
if err != nil || report.Days[0].Points != 7 || report.Days[0].Completed != 1 {
t.Fatal("points", report, err)
}
if len(report.Projects) != 1 || report.Projects[0].UUID != "" || report.Projects[0].Points != 7 || report.Projects[0].Completed != 1 {
t.Fatal("unassigned project totals", report.Projects)
}
item.Status = "todo"
if _, err = s.store.SaveTask(ctx, domain, actor, item, item.Version); err != nil {
t.Fatal(err)
+95
View File
@@ -0,0 +1,95 @@
package server
import (
"net/http"
"pageswiki/internal/store"
"strconv"
"time"
)
func parseWorkInstant(raw string, loc *time.Location) (time.Time, error) {
if v, err := time.Parse(time.RFC3339Nano, raw); err == nil {
return v, nil
}
for _, format := range []string{"2006-01-02T15:04:05", "2006-01-02T15:04"} {
v, err := time.ParseInLocation(format, raw, loc)
if err != nil || v.Format(format) != raw {
continue
}
// A repeated wall time needs an explicit offset. Do not silently choose
// the earlier/later occurrence when a browser datetime-local cannot express it.
for _, delta := range []time.Duration{-24 * time.Hour, -2 * time.Hour, -time.Hour, -30 * time.Minute, 30 * time.Minute, time.Hour, 2 * time.Hour, 24 * time.Hour} {
if v.Add(delta).In(loc).Format(format) == raw {
return time.Time{}, store.ErrTaskInvalid
}
}
return v, nil
}
return time.Time{}, store.ErrTaskInvalid
}
func (s *Server) handleTaskWorkHistory(w http.ResponseWriter, r *http.Request, actor string, parts []string) {
if r.Method != "GET" {
w.Header().Set("Allow", "GET")
w.WriteHeader(405)
return
}
domain := s.domainUUIDForRequest(r)
if len(parts) == 2 && parts[1] != "" {
var before int64
if raw := r.URL.Query().Get("before"); raw != "" {
var err error
before, err = strconv.ParseInt(raw, 10, 64)
if err != nil || before < 0 {
taskError(w, store.ErrTaskInvalid)
return
}
}
items, err := s.store.TaskWorkRevisions(r.Context(), domain, actor, parts[1], before)
if err != nil {
taskError(w, err)
return
}
var next int64
if len(items) == 100 {
next = items[len(items)-1].Item.Version
}
writeEventJSON(w, 200, map[string]any{"items": items, "next": next})
return
}
if len(parts) != 1 {
http.NotFound(w, r)
return
}
now := time.Now().In(s.getLocation(domain))
end := time.Date(now.Year(), now.Month(), now.Day()+1, 0, 0, 0, 0, now.Location())
start := end.AddDate(0, 0, -30)
for _, v := range []struct {
key string
target *time.Time
}{{"from", &start}, {"to", &end}} {
if raw := r.URL.Query().Get(v.key); raw != "" {
date, err := time.ParseInLocation("2006-01-02", raw, now.Location())
if err != nil || date.Format("2006-01-02") != raw {
taskError(w, store.ErrTaskInvalid)
return
}
*v.target = date
}
}
limit := 50
if raw := r.URL.Query().Get("limit"); raw != "" {
var err error
limit, err = strconv.Atoi(raw)
if err != nil {
taskError(w, store.ErrTaskInvalid)
return
}
}
result, err := s.store.TaskWorkHistory(r.Context(), domain, actor, start, end, r.URL.Query().Get("after"), limit)
if err != nil {
taskError(w, err)
return
}
writeEventJSON(w, 200, map[string]any{"items": result.Items, "next": result.Next, "from": start.Format("2006-01-02"), "to": end.Format("2006-01-02"), "timezone": now.Location().String()})
}
+343
View File
@@ -0,0 +1,343 @@
package server
import (
"context"
"encoding/json"
"errors"
"net/http"
"net/http/httptest"
"net/url"
"os"
"os/exec"
"strings"
"sync"
"testing"
"time"
"github.com/google/uuid"
"pageswiki/internal/store"
)
func recordedWork(t *testing.T, s *Server, domain, actor, task string, start time.Time) store.TaskWork {
t.Helper()
v, err := s.store.ChangeTaskWork(context.Background(), domain, actor, "start", store.TaskWork{UUID: uuid.NewString(), TaskUUID: task, CancelledMS: 99}, start)
if err != nil || v.CancelledMS != 0 {
t.Fatal(v, err)
}
v, err = s.store.ChangeTaskWork(context.Background(), domain, actor, "stop", v, start.Add(time.Hour))
if err != nil {
t.Fatal(err)
}
return v
}
func TestWorkHistoryCorrectionCancellationAndReports(t *testing.T) {
s, token, domain, actor := taskFixture(t)
ctx := context.Background()
project, err := s.store.SaveTask(ctx, domain, actor, newTaskRecord("project", "Project A"), 0)
if err != nil {
t.Fatal(err)
}
item := newTaskRecord("task", "Audited work")
item.ProjectUUID = project.UUID
item, err = s.store.SaveTask(ctx, domain, actor, item, 0)
if err != nil {
t.Fatal(err)
}
start := time.Date(2026, 1, 2, 12, 0, 0, 0, time.UTC)
first := recordedWork(t, s, domain, actor, item.UUID, start)
second := recordedWork(t, s, domain, actor, item.UUID, start.Add(2*time.Hour))
post := func(v store.TaskWork, action, reason string) int {
return taskRequest(s, token, "POST", "work", map[string]any{"uuid": v.UUID, "task_uuid": v.TaskUUID, "version": v.Version, "action": action, "reason": reason, "start_ms": v.StartMS, "end_ms": v.EndMS}, "").Code
}
if got := post(first, "correct", ""); got != 422 {
t.Fatal("missing reason", got)
}
bad := first
bad.EndMS = second.EndMS
if got := post(bad, "correct", "overlap"); got != 412 {
t.Fatal("overlap", got)
}
bad = first
bad.EndMS = bad.StartMS
if got := post(bad, "correct", "empty"); got != 422 {
t.Fatal("empty interval", got)
}
first.EndMS = start.Add(2 * time.Hour).UnixMilli() // adjacency is valid
if got := post(first, "correct", "Finished later"); got != 200 {
t.Fatal("correct", got)
}
if got := post(first, "correct", "stale mutation"); got != 412 {
t.Fatal("stale version", got)
}
first.Version++
report, err := s.store.TaskReport(ctx, domain, actor, start.Add(-time.Hour), start.Add(5*time.Hour), time.Now())
if err != nil || len(report.Projects) != 1 || report.Projects[0].Title != "Project A" || report.Projects[0].WorkMS != 3*3600000 {
t.Fatal(report, err)
}
if got := post(first, "cancel", "Duplicate recording"); got != 200 {
t.Fatal("cancel", got)
}
report, err = s.store.TaskReport(ctx, domain, actor, start.Add(-time.Hour), start.Add(5*time.Hour), time.Now())
if err != nil || report.Projects[0].WorkMS != 3600000 {
t.Fatal("cancelled counted", report, err)
}
audit, err := s.store.TaskWorkRevisions(ctx, domain, actor, first.UUID, 0)
if err != nil || len(audit) != 4 || audit[0].Action != "cancel" || audit[1].Action != "correct" || audit[2].Action != "stop" || audit[3].Action != "start" || audit[2].Item.EndMS != start.Add(time.Hour).UnixMilli() {
t.Fatal(audit, err)
}
page, err := s.store.TaskWorkHistory(ctx, domain, actor, start.Add(-time.Hour), start.Add(5*time.Hour), "", 1)
if err != nil || len(page.Items) != 1 || page.Items[0].UUID != second.UUID || page.Next == "" {
t.Fatal(page, err)
}
page, err = s.store.TaskWorkHistory(ctx, domain, actor, start.Add(-time.Hour), start.Add(5*time.Hour), page.Next, 1)
if err != nil || len(page.Items) != 1 || page.Items[0].UUID != first.UUID || page.Items[0].CancelledMS == 0 || page.Next != "" {
t.Fatal(page, err)
}
for _, query := range []string{"limit=101", "after=bad", "from=2026-01-02&to=2026-01-01", "from=2020-01-01&to=2026-01-01"} {
if w := taskRequest(s, token, "GET", "work-history?"+query, nil, ""); w.Code != 422 {
t.Fatal(query, w.Code, w.Body)
}
}
if w := taskRequest(s, token, "GET", "work-history/"+first.UUID+"?before=3", nil, ""); w.Code != 200 {
t.Fatal(w.Code, w.Body)
}
if w := taskRequest(s, token, "POST", "work-history", nil, ""); w.Code != 405 {
t.Fatal(w.Code, w.Body)
}
stranger, err := s.store.CreatePasswordAccount(domain, "history-stranger", "a long test password", "Stranger", "")
if err != nil {
t.Fatal(err)
}
strangerToken, err := s.store.CreateAuthSession(domain, stranger.UUID)
if err != nil {
t.Fatal(err)
}
if w := taskRequest(s, strangerToken, "GET", "work-history/"+first.UUID, nil, ""); w.Code != 404 {
t.Fatal("history leaked", w.Code, w.Body)
}
if w := taskRequest(s, strangerToken, "GET", "work-history?from=2026-01-01&to=2026-01-04", nil, ""); w.Code != 200 || !strings.Contains(w.Body.String(), `"items":[]`) {
t.Fatal("list leaked", w.Code, w.Body)
}
if err = s.store.SetPrincipalState(domain, actor, "readonly"); err != nil {
t.Fatal(err)
}
token, err = s.store.CreateAuthSession(domain, actor)
if err != nil {
t.Fatal(err)
}
if got := post(second, "cancel", "No permission"); got != 403 {
t.Fatal("readonly mutation", got)
}
if err = s.store.SetConfigInDomain(domain, "system_extension_states", `{"organizer.tasks":false}`); err != nil {
t.Fatal(err)
}
if w := taskRequest(s, token, "GET", "work-history", nil, ""); w.Code != 404 {
t.Fatal("disabled extension", w.Code)
}
}
func TestWorkInstantTimezone(t *testing.T) {
for _, tc := range []struct {
zone, input string
valid bool
}{{"Asia/Tokyo", "2026-01-02T12:30", true}, {"America/New_York", "2026-03-08T02:30", false}, {"America/New_York", "2026-11-01T01:30", false}, {"America/New_York", "2026-11-01T01:30:00-04:00", true}, {"Australia/Lord_Howe", "2026-04-05T01:45", false}, {"UTC", "bad", false}} {
loc, err := time.LoadLocation(tc.zone)
if err != nil {
t.Fatal(err)
}
_, err = parseWorkInstant(tc.input, loc)
if (err == nil) != tc.valid {
t.Fatal(tc, err)
}
}
}
func TestWorkHistoryFencingAndAtomicAudit(t *testing.T) {
s, _, domain, actor := taskFixture(t)
ctx := context.Background()
item, err := s.store.SaveTask(ctx, domain, actor, newTaskRecord("task", "Fenced work"), 0)
if err != nil {
t.Fatal(err)
}
start := time.Now().Add(-10 * time.Hour)
v := recordedWork(t, s, domain, actor, item.UUID, start)
// Simulate a pre-upgrade session: capture its old value, never invent older versions.
if _, err = s.store.DB.Exec(`DELETE FROM organizer_work_revisions WHERE work_uuid=?`, v.UUID); err != nil {
t.Fatal(err)
}
if _, err = s.store.DB.Exec(`CREATE TRIGGER fail_work_audit BEFORE INSERT ON organizer_work_revisions WHEN NEW.action='correct' BEGIN SELECT RAISE(ABORT,'test audit unavailable'); END`); err != nil {
t.Fatal(err)
}
edit := v
edit.EndMS += 60000
if _, err = s.store.ChangeTaskWork(ctx, domain, actor, "correct", edit, time.Now(), "must rollback"); err == nil {
t.Fatal("audit failure accepted")
}
var version int64
if err = s.store.DB.QueryRow(`SELECT version FROM organizer_work_sessions WHERE uuid=?`, v.UUID).Scan(&version); err != nil || version != 2 {
t.Fatal("partial mutation", version, err)
}
if _, err = s.store.DB.Exec(`DROP TRIGGER fail_work_audit`); err != nil {
t.Fatal(err)
}
// Two concurrent corrections must not overwrite one another.
var wg sync.WaitGroup
results := make(chan error, 2)
for range 2 {
wg.Add(1)
go func() {
defer wg.Done()
_, e := s.store.ChangeTaskWork(ctx, domain, actor, "correct", edit, time.Now(), "racing correction")
results <- e
}()
}
wg.Wait()
close(results)
wins, conflicts := 0, 0
for err := range results {
if err == nil {
wins++
} else if errors.Is(err, store.ErrTaskConflict) {
conflicts++
} else {
t.Fatal(err)
}
}
if wins != 1 || conflicts != 1 {
t.Fatal(wins, conflicts)
}
history, err := s.store.TaskWorkRevisions(ctx, domain, actor, v.UUID, 0)
if err != nil || len(history) != 2 || history[1].Action != "baseline" || history[1].Item.EndMS != v.EndMS {
t.Fatal(history, err)
}
// Cross-Domain intervals belong to the same person, but never appear in this list.
d, err := s.store.GetDomainByUUID(domain)
if err != nil {
t.Fatal(err)
}
if err = s.store.CreateDomain(d.CampusUUID, "work-other", "Other", "work-other", "local", "", "", true); err != nil {
t.Fatal(err)
}
domains, err := s.store.ListDomains()
if err != nil {
t.Fatal(err)
}
other := ""
for _, d := range domains {
if d.Name == "work-other" {
other = d.UUID
}
}
if other == "" {
t.Fatal("missing domain")
}
if _, err = s.store.DB.Exec(`INSERT OR IGNORE INTO domain_memberships(uuid,domain_uuid,principal_uuid,state,created_at_ms) VALUES(?,?,?,'active',0)`, uuid.NewString(), other, actor); err != nil {
t.Fatal(err)
}
otherTask, err := s.store.SaveTask(ctx, other, actor, newTaskRecord("task", "Private other work"), 0)
if err != nil {
t.Fatal(err)
}
foreign := recordedWork(t, s, other, actor, otherTask.UUID, start.Add(2*time.Hour))
edit = history[0].Item
edit.EndMS = foreign.EndMS
if _, err = s.store.ChangeTaskWork(ctx, domain, actor, "correct", edit, time.Now(), "overlaps other domain"); !errors.Is(err, store.ErrTaskConflict) {
t.Fatal(err)
}
if _, err = s.store.TaskWorkRevisions(ctx, domain, actor, foreign.UUID, 0); err == nil {
t.Fatal("cross-domain audit leaked")
}
page, err := s.store.TaskWorkHistory(ctx, domain, actor, start.Add(-time.Hour), time.Now(), "", 50)
if err != nil || len(page.Items) != 1 {
t.Fatal(page, err)
}
active, err := s.store.ChangeTaskWork(ctx, domain, actor, "start", store.TaskWork{UUID: uuid.NewString(), TaskUUID: item.UUID}, start.Add(5*time.Hour))
if err != nil {
t.Fatal(err)
}
for _, action := range []string{"correct", "cancel"} {
if _, err = s.store.ChangeTaskWork(ctx, domain, actor, action, active, time.Now(), "active recording"); !errors.Is(err, store.ErrTaskConflict) {
t.Fatal(action, err)
}
}
if _, err = s.store.DB.Exec(`UPDATE domain_memberships SET state='suspended' WHERE domain_uuid=? AND principal_uuid=?`, domain, actor); err != nil {
t.Fatal(err)
}
if _, err = s.store.ChangeTaskWork(ctx, domain, actor, "cancel", history[0].Item, time.Now(), "revoked"); !errors.Is(err, store.ErrAccessDenied) {
t.Fatal("revocation not fenced", err)
}
}
func TestWorkHistoryChromium(t *testing.T) {
if os.Getenv("PAGESWIKI_BROWSER_TEST") != "1" {
t.Skip("opt-in Chromium")
}
s, token, domain, actor := taskFixture(t)
s.store.BackgroundJobsDisabled = true
s = New(s.store)
item, err := s.store.SaveTask(context.Background(), domain, actor, newTaskRecord("task", "Browser work record"), 0)
if err != nil {
t.Fatal(err)
}
v := recordedWork(t, s, domain, actor, item.UUID, time.Now().Add(-3*time.Hour))
script, err := os.ReadFile("internal/server/testdata/task-work-history.js")
if err != nil {
t.Fatal(err)
}
handler := s.handler()
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
r.Host = "localhost"
r.Header.Set("Authorization", "Bearer "+token)
if r.URL.Path == "/fixture" {
w.Header().Set("Content-Type", "text/html; charset=utf-8")
_, _ = w.Write([]byte("<!doctype html><body style='margin:0'><script>" + string(script) + "</script></body>"))
return
}
handler.ServeHTTP(w, r)
}))
defer server.Close()
ctx, cancel := context.WithTimeout(context.Background(), 55*time.Second)
defer cancel()
width := os.Getenv("WORK_HISTORY_WIDTH")
if width == "" {
width = "1440"
}
args := []string{"internal/server/testdata/vim-browser-smoke.mjs", server.URL + "/fixture", t.TempDir(), os.Getenv("WORK_HISTORY_SCREENSHOT"), width, "850"}
if out, err := exec.CommandContext(ctx, "node", args...).CombinedOutput(); err != nil {
t.Fatalf("browser: %v\n%s", err, out)
}
history, err := s.store.TaskWorkRevisions(context.Background(), domain, actor, v.UUID, 0)
if err != nil || len(history) != 4 || history[0].Action != "cancel" || history[1].Action != "correct" {
t.Fatal(history, err)
}
}
func TestWorkHistoryLocalTimestampAPI(t *testing.T) {
s, token, domain, actor := taskFixture(t)
ctx := context.Background()
item, err := s.store.SaveTask(ctx, domain, actor, newTaskRecord("task", "Timestamp"), 0)
if err != nil {
t.Fatal(err)
}
start := time.Date(2026, 1, 2, 12, 0, 0, 123000000, time.UTC)
v := recordedWork(t, s, domain, actor, item.UUID, start)
input := map[string]any{"uuid": v.UUID, "version": v.Version, "action": "correct", "reason": "API timestamp", "start": start.Format(time.RFC3339Nano), "end": start.Add(90 * time.Minute).Format(time.RFC3339Nano)}
w := taskRequest(s, token, "POST", "work", input, "")
if w.Code != 200 {
t.Fatal(w.Code, w.Body)
}
var result struct {
Item store.TaskWork `json:"item"`
}
if err = json.Unmarshal(w.Body.Bytes(), &result); err != nil {
t.Fatal(err)
}
page, err := s.store.TaskWorkHistory(ctx, domain, actor, start.Add(-time.Hour), start.Add(3*time.Hour), "", 50)
if err != nil || page.Items[0].StartMS != start.UnixMilli() {
t.Fatal(page, err)
}
if w = taskRequest(s, token, "GET", "work-history?"+url.Values{"from": {"2026-01-02"}, "to": {"2026-01-03"}}.Encode(), nil, ""); w.Code != 200 {
t.Fatal(w.Code, w.Body)
}
}
+12
View File
@@ -98,6 +98,10 @@ func (s *Server) handleTaskPage(w http.ResponseWriter, r *http.Request) {
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
@@ -212,6 +216,14 @@ func (s *Server) handleTasksAPI(w http.ResponseWriter, r *http.Request) {
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
+28
View File
@@ -0,0 +1,28 @@
(async()=>{
const assert=(ok,msg)=>{if(!ok)throw Error(msg);},delay=ms=>new Promise(r=>setTimeout(r,ms));
const wait=async check=>{for(let n=0;n<240;n++){if(check())return;await delay(25);}throw Error('Timed out: '+check);};
const frame=document.createElement('iframe');frame.style='display:block;width:100%;height:100vh;border:0';document.body.append(frame);
try{
await new Promise(resolve=>{frame.onload=resolve;frame.src='/-/sys/config?panel=organizer';});
const w=frame.contentWindow,d=frame.contentDocument;await wait(()=>d.querySelector('#task-digest-history details'));
const root=d.getElementById('task-digest-history'),details=root.querySelector('details');
assert(!details.open,'History not lazy');assert(!w.performance.getEntriesByType('resource').some(x=>x.name.includes('/digest-history')),'History eagerly fetched');
details.open=true;await wait(()=>root.querySelector('.digest-retry form'));
const form=root.querySelector('.digest-retry form'),ack=form.querySelector('input');
assert(ack.required&&!ack.checked,'Uncertain delivery must require confirmation');assert(!form.checkValidity(),'Unchecked acknowledgment valid');ack.checked=true;
const original=w.fetch,requests=[];let lose=true;
w.fetch=async(url,options)=>{if(String(url).endsWith('/digest-history/retry')){requests.push(JSON.parse(options.body));const response=await original(url,options);if(lose){lose=false;await response.text();throw new TypeError('Simulated lost response');}return response;}return original(url,options);};
form.requestSubmit();await wait(()=>root.querySelector('[role=status]').textContent&&!form.querySelector('button').disabled);
assert(root.contains(form),'Lost response removed retry controls');form.requestSubmit();
await wait(()=>!root.querySelector('.digest-retry form')&&!root.querySelector('.productivity-controls button').disabled);
assert(requests.length===2&&requests[0].request_id===requests[1].request_id,'Retry generated a second request ID');
assert(root.querySelectorAll('tbody tr').length===2,'Duplicate attempt created');
const tick=await fetch('/fixture/tick',{method:'POST'});assert(tick.ok,'Worker failed');
root.querySelector('.productivity-controls button').click();await wait(()=>root.querySelector('.digest-retry form'));
assert(root.querySelector('.digest-retry input').required,'Sent retry must require confirmation');
assert(root.textContent.includes('メールサーバー受付済み')||root.textContent.includes('Accepted by mail server'),'Sent status missing');
assert(!root.textContent.includes('reader@example.test'),'Recipient leaked in history');
assert(d.documentElement.scrollWidth<=w.innerWidth,'Settings overflow viewport');
details.scrollIntoView({block:'start'});document.body.dataset.vimReady='1';
}catch(error){const out=document.createElement('pre');out.id='error';out.textContent=error.stack;document.body.append(out);}
})();
+34
View File
@@ -0,0 +1,34 @@
(async()=>{
const assert=(ok,msg)=>{if(!ok)throw Error(msg);},delay=ms=>new Promise(r=>setTimeout(r,ms));
const wait=async check=>{for(let n=0;n<200;n++){if(check())return;await delay(25);}throw Error('Timed out: '+check);};
const frame=document.createElement('iframe');frame.style='display:block;width:100%;height:100vh;border:0';document.body.append(frame);
try{
await new Promise(resolve=>{frame.onload=resolve;frame.src='/v/plan/dashboard';});
await wait(()=>frame.contentDocument.querySelector('.productivity-table tbody tr'));
const reportTable=frame.contentDocument.querySelector('.productivity-table');
assert(reportTable.querySelectorAll('thead th').length===4,'Project aggregate table missing');
assert(reportTable.querySelector('tbody tr').lastElementChild.textContent==='1.00','Project duration incorrect');
const historyLink=frame.contentDocument.querySelector('a[href="/v/plan/tasks/work"]');assert(historyLink,'Dashboard history link missing');
await new Promise(resolve=>{frame.onload=resolve;historyLink.click();});
const w=frame.contentWindow,d=frame.contentDocument;
await wait(()=>d.querySelector('.work-history-table tbody button'));
assert(d.documentElement.scrollWidth<=w.innerWidth,'History overflows viewport');
d.querySelector('.work-history-table tbody button').click();
let form=d.querySelector('.work-history-edit');assert(form,'Inline correction missing');
const inputs=form.querySelectorAll('input');inputs[2].value='Browser correction';
form.requestSubmit();await wait(()=>!d.querySelector('.work-history-edit')&&!d.getElementById('work-history-list').inert);
d.querySelector('#work-history-list details').open=true;await wait(()=>d.querySelector('#work-history-list details strong'));
assert(d.querySelector('#work-history-list details').textContent.includes('Browser correction'),'Audit missing');
const originalFetch=w.fetch;w.fetch=async(url,options)=>options?.method==='POST'?new w.Response(JSON.stringify({error:'conflict'}),{status:412}):originalFetch(url,options);
d.querySelector('.work-history-table tbody button').click();form=d.querySelector('.work-history-edit');form.querySelector('input[type=text]').value='Retain my input';form.requestSubmit();
await wait(()=>form.querySelector('[role=status]').textContent);assert(form.querySelector('input[type=text]').value==='Retain my input','Conflict discarded input');
w.fetch=originalFetch;w.confirm=()=>true;form.querySelector('button[type=button]').click();
d.querySelectorAll('.work-history-table tbody tr:first-child button')[1].click();form=d.querySelector('.work-history-edit');form.querySelector('input').value='Browser cancellation';form.requestSubmit();await wait(()=>!d.querySelector('.work-history-edit')&&!d.getElementById('work-history-list').inert);
assert(!d.querySelector('.work-history-table tbody tr:first-child button'),'Cancelled work remains editable');
d.querySelector('#work-history-list details').open=true;await wait(()=>d.querySelector('#work-history-list details strong'));
assert(d.querySelector('#work-history-list details').textContent.includes('Browser cancellation'),'Cancellation audit missing');
const report=await (await fetch('/_/api/v1/extension/organizer.tasks/report')).json();assert(report.days.every(day=>day.work_ms===0),'Cancelled time remains in report');
assert(d.documentElement.scrollWidth<=w.innerWidth,'Expanded history overflows viewport');
document.body.dataset.vimReady='1';
}catch(error){const out=document.createElement('pre');out.id='error';out.textContent=error.stack;document.body.append(out);}
})();