Files
pages/internal/store/task_digest.go
T
Anya Tokugawa e65ca56f92
Build and publish container images / images (push) Successful in 12m27s
feat: add audited work records and controlled digest retries
2026-11-08 02:35:29 +09:00

205 lines
6.7 KiB
Go

package store
import (
"context"
"database/sql"
"encoding/json"
"errors"
"time"
"github.com/google/uuid"
)
const TaskDigestEventType = "task.digest.deliver"
type TaskDigestDue struct {
Domain string
Owner string
}
type TaskDigestClaim struct {
TaskDigestDue
Day string
Version int64
Timezone string
AttemptUUID string
}
func (s *Store) EnsureTaskDigestEvent() error {
if s.ReadOnly {
return ErrReadOnly
}
now := time.Now().UnixMilli()
_, err := s.DB.Exec(`INSERT OR IGNORE INTO event_definitions(uuid,name,event_type,event_key,payload,schedule_kind,interval_seconds,next_run_at_ms,enabled,priority,max_attempts,created_at_ms,updated_at_ms) VALUES('builtin.task.digest','Daily task email',?,'local','{}','interval',60,?,1,-2,1,?,?)`, TaskDigestEventType, now, now, now)
return err
}
func (s *Store) DueTaskDigests(ctx context.Context, now time.Time) ([]TaskDigestDue, error) {
rows, err := s.DB.QueryContext(ctx, `SELECT domain_uuid,owner_uuid FROM organizer_task_preferences WHERE next_digest_ms>0 AND next_digest_ms<=? ORDER BY next_digest_ms,domain_uuid,owner_uuid LIMIT 20`, now.UnixMilli())
if err != nil {
return nil, err
}
defer rows.Close()
out := []TaskDigestDue{}
for rows.Next() {
var v TaskDigestDue
if err = rows.Scan(&v.Domain, &v.Owner); err != nil {
return nil, err
}
out = append(out, v)
}
return out, rows.Err()
}
// Claim before SMTP: an ambiguous delivery is never automatically sent twice.
// An interrupted claim stays visible as "sending" for operator review.
func (s *Store) ClaimTaskDigest(ctx context.Context, due TaskDigestDue, now time.Time) (TaskDigestClaim, error) {
out := TaskDigestClaim{TaskDigestDue: due}
if s.ReadOnly {
return out, ErrReadOnly
}
tx, err := s.DB.BeginTx(ctx, nil)
if err != nil {
return out, err
}
defer tx.Rollback()
res, err := tx.ExecContext(ctx, `UPDATE organizer_task_preferences SET next_digest_ms=next_digest_ms WHERE domain_uuid=? AND owner_uuid=? AND next_digest_ms>0 AND next_digest_ms<=?`, due.Domain, due.Owner, now.UnixMilli())
if err != nil {
return out, err
}
n, _ := res.RowsAffected()
if n != 1 {
return out, sql.ErrNoRows
}
var raw string
if err = tx.QueryRowContext(ctx, `SELECT data FROM organizer_task_preferences WHERE domain_uuid=? AND owner_uuid=?`, due.Domain, due.Owner).Scan(&raw); err != nil {
return out, err
}
var p TaskPreferences
if err = json.Unmarshal([]byte(raw), &p); err != nil {
return out, err
}
loc, err := time.LoadLocation(p.Timezone)
if err != nil {
return out, err
}
out.Day = now.In(loc).Format("2006-01-02")
out.Timezone = p.Timezone
out.Version = p.Version
allowed := taskActor(ctx, tx, due.Domain, due.Owner, true)
on, e := taskReminderExtensionEnabled(ctx, tx, due.Domain)
if e != nil {
return out, e
}
if allowed != nil && !errors.Is(allowed, ErrAccessDenied) {
return out, allowed
}
if allowed != nil || !on || !p.DigestEnabled {
// An opted-in schedule resumes after a domain or extension is restored.
next, e := nextTaskDigest(now, p)
if e != nil {
return out, e
}
_, err = tx.ExecContext(ctx, `UPDATE organizer_task_preferences SET next_digest_ms=? WHERE domain_uuid=? AND owner_uuid=?`, next, due.Domain, due.Owner)
if err != nil {
return out, err
}
if err = tx.Commit(); err != nil {
return out, err
}
return out, sql.ErrNoRows
}
// Missed days are not replayed. Run once for today's due time; if the
// configured hour has not arrived, move the cursor there without sending.
clock, _ := time.Parse("15:04", p.DigestTime)
local := now.In(loc)
today := time.Date(local.Year(), local.Month(), local.Day(), clock.Hour(), clock.Minute(), 0, 0, loc)
next, err := nextTaskDigest(now, p)
if err != nil {
return out, err
}
_, err = tx.ExecContext(ctx, `UPDATE organizer_task_preferences SET next_digest_ms=? WHERE domain_uuid=? AND owner_uuid=?`, next, due.Domain, due.Owner)
if err != nil {
return out, err
}
if today.After(now) {
if err = tx.Commit(); err != nil {
return out, err
}
return out, sql.ErrNoRows
}
out.AttemptUUID = uuid.NewString()
res, err = tx.ExecContext(ctx, `INSERT OR IGNORE INTO organizer_digest_deliveries(domain_uuid,owner_uuid,day,state,updated_ms,attempt_uuid) VALUES(?,?,?,'sending',?,?)`, due.Domain, due.Owner, out.Day, now.UnixMilli(), out.AttemptUUID)
if err != nil {
return out, err
}
n, _ = res.RowsAffected()
if n == 1 {
if err = insertDigestAttempt(ctx, tx, out, "scheduled", "sending", now); err != nil {
return out, err
}
}
if err = tx.Commit(); err != nil {
return out, err
}
if n != 1 {
return out, sql.ErrNoRows
}
return out, nil
}
func (s *Store) TaskDigestRecipient(ctx context.Context, c TaskDigestClaim) (string, error) {
if s.ReadOnly {
return "", ErrReadOnly
}
tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
if err != nil {
return "", err
}
defer tx.Rollback()
if err := taskActor(ctx, tx, c.Domain, c.Owner, true); err != nil {
return "", err
}
var raw, email string
var version int64
err = tx.QueryRowContext(ctx, `SELECT f.data,f.version,p.email FROM organizer_task_preferences f JOIN principals p ON p.uuid=f.owner_uuid JOIN organizer_digest_deliveries d ON d.domain_uuid=f.domain_uuid AND d.owner_uuid=f.owner_uuid JOIN organizer_digest_attempts a ON a.uuid=d.attempt_uuid WHERE f.domain_uuid=? AND f.owner_uuid=? AND d.day=? AND d.attempt_uuid=? AND d.state='sending' AND a.state='sending' AND a.updated_ms>?`, c.Domain, c.Owner, c.Day, c.AttemptUUID, time.Now().Add(-2*time.Minute).UnixMilli()).Scan(&raw, &version, &email)
if err != nil {
return "", err
}
var p TaskPreferences
if json.Unmarshal([]byte(raw), &p) != nil || !p.DigestEnabled || version != c.Version {
return "", ErrAccessDenied
}
loc, err := time.LoadLocation(c.Timezone)
if err != nil || time.Now().In(loc).Format("2006-01-02") != c.Day {
return "", ErrAccessDenied
}
on, err := taskReminderExtensionEnabled(ctx, tx, c.Domain)
if err != nil {
return "", err
}
if !on {
return "", ErrAccessDenied
}
return email, tx.Commit()
}
func (s *Store) FinishTaskDigest(ctx context.Context, c TaskDigestClaim, state string) error {
return s.FinishTaskDigestReason(ctx, c, state, "", time.Now())
}
func (s *Store) LastTaskDigest(ctx context.Context, domain, actor string) (map[string]any, error) {
if err := taskActor(ctx, s.DB, domain, actor, false); err != nil {
return nil, err
}
var day, state string
var ms int64
err := s.DB.QueryRowContext(ctx, `SELECT day,state,updated_ms FROM organizer_digest_deliveries WHERE domain_uuid=? AND owner_uuid=? ORDER BY day DESC LIMIT 1`, domain, actor).Scan(&day, &state, &ms)
if errors.Is(err, sql.ErrNoRows) {
return nil, nil
}
if err != nil {
return nil, err
}
return map[string]any{"day": day, "state": state, "updated_at_ms": ms}, nil
}