217 lines
7.8 KiB
Go
217 lines
7.8 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.sqlBackend == storePostgreSQL {
|
|
return s.ensureNativeBuiltinEvent("builtin.task.digest", "Daily task email", TaskDigestEventType, 60, -2, 1)
|
|
}
|
|
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',`+s.sqlParam(1)+`,'local','{}','interval',60,`+s.sqlParam(2)+`,1,-2,1,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`)`, TaskDigestEventType, now, now, now)
|
|
return err
|
|
}
|
|
|
|
func (s *Store) DueTaskDigests(ctx context.Context, now time.Time) (result []TaskDigestDue, resultErr error) {
|
|
defer func() { resultErr = s.sqlError("task digest", resultErr) }()
|
|
rows, err := s.DB.QueryContext(ctx, `SELECT domain_uuid,owner_uuid FROM organizer_task_preferences WHERE next_digest_ms>0 AND next_digest_ms<=`+s.sqlParam(1)+` 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) (result TaskDigestClaim, resultErr error) {
|
|
defer func() { resultErr = s.sqlError("task digest", resultErr) }()
|
|
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
|
|
defer cancel()
|
|
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()
|
|
if err = s.lockTaskWriter(ctx, tx); err != nil {
|
|
return out, err
|
|
}
|
|
res, err := tx.ExecContext(ctx, `UPDATE organizer_task_preferences SET next_digest_ms=next_digest_ms WHERE domain_uuid=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` AND next_digest_ms>0 AND next_digest_ms<=`+s.sqlParam(3), 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=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2), 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 := s.taskActor(ctx, tx, due.Domain, due.Owner, true)
|
|
on, e := s.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=`+s.sqlParam(1)+` WHERE domain_uuid=`+s.sqlParam(2)+` AND owner_uuid=`+s.sqlParam(3), 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=`+s.sqlParam(1)+` WHERE domain_uuid=`+s.sqlParam(2)+` AND owner_uuid=`+s.sqlParam(3), 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 INTO organizer_digest_deliveries(domain_uuid,owner_uuid,day,state,updated_ms,attempt_uuid) VALUES(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,'sending',`+s.sqlParam(4)+`,`+s.sqlParam(5)+`) ON CONFLICT(domain_uuid,owner_uuid,day) DO NOTHING`, due.Domain, due.Owner, out.Day, now.UnixMilli(), out.AttemptUUID)
|
|
if err != nil {
|
|
return out, err
|
|
}
|
|
n, _ = res.RowsAffected()
|
|
if n == 1 {
|
|
if err = s.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) (result string, resultErr error) {
|
|
defer func() { resultErr = s.sqlError("task digest", resultErr) }()
|
|
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 := s.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=`+s.sqlParam(1)+` AND f.owner_uuid=`+s.sqlParam(2)+` AND d.day=`+s.sqlParam(3)+` AND d.attempt_uuid=`+s.sqlParam(4)+` AND d.state='sending' AND a.state='sending' AND a.updated_ms>`+s.sqlParam(5), 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 := s.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) (result map[string]any, resultErr error) {
|
|
defer func() { resultErr = s.sqlError("task digest", resultErr) }()
|
|
if err := s.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=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` 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
|
|
}
|