Add task capture, work reports, daily digests and private contacts
Build and publish container images / images (push) Successful in 16m37s

This commit is contained in:
Anya Tokugawa committed 2026-11-01 22:28:16 +09:00
1 parent 50b8b0323f
commit b4792bb175
50 files changed
+2678 -17

No files matched your search

+431
View File
@@ -0,0 +1,431 @@
package store
import (
"context"
"crypto/sha256"
"database/sql"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"net/mail"
"strings"
"time"
"unicode/utf8"
"github.com/google/uuid"
"pageswiki/internal/db"
)
var contactMigrations = []db.SQLMigration{{Version: 1, Name: "private_address_book", Statements: []string{
`CREATE TABLE organizer_contacts(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,uuid TEXT NOT NULL,uid TEXT NOT NULL,version INTEGER NOT NULL,name TEXT NOT NULL,search TEXT NOT NULL,data TEXT NOT NULL,hash TEXT NOT NULL,deleted INTEGER NOT NULL DEFAULT 0,PRIMARY KEY(domain_uuid,owner_uuid,uuid),UNIQUE(domain_uuid,owner_uuid,uid))`,
`CREATE INDEX organizer_contacts_owner ON organizer_contacts(domain_uuid,owner_uuid,deleted,uuid)`,
`CREATE TABLE organizer_contact_revisions(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,uuid TEXT NOT NULL,version INTEGER NOT NULL,hash TEXT NOT NULL,deleted INTEGER NOT NULL,created_ms INTEGER NOT NULL,PRIMARY KEY(domain_uuid,owner_uuid,uuid,version))`,
}, Assertions: []string{schemaColumns("organizer_contacts", "domain_uuid,owner_uuid,uuid,uid,version,name,search,data,hash,deleted"), schemaUnique("organizer_contacts", "domain_uuid,owner_uuid,uid")}}}
type Contact struct {
UUID string `json:"uuid"`
UID string `json:"uid"`
Version int64 `json:"version"`
Name string `json:"name"`
Emails []string `json:"emails"`
Phones []string `json:"phones"`
Organization string `json:"organization"`
Notes string `json:"notes"`
VCard string `json:"vcard,omitempty"`
Deleted bool `json:"deleted"`
}
// Preserve every unfolded property, including unsupported fields/parameters.
// Encoded legacy v2.1/QP and malformed data are rejected, never silently lost.
func cardLines(raw string) ([]string, error) {
if len(raw) > 65536 || !utf8.ValidString(raw) || strings.ContainsRune(raw, 0) {
return nil, ErrTaskInvalid
}
for _, c := range raw {
if c < 32 && c != '\r' && c != '\n' && c != '\t' || c == 127 {
return nil, ErrTaskInvalid
}
}
raw = strings.ReplaceAll(raw, "\r\n", "\n")
if strings.ContainsRune(raw, '\r') {
return nil, ErrTaskInvalid
}
var lines []string
for _, line := range strings.Split(strings.TrimSuffix(raw, "\n"), "\n") {
if strings.HasPrefix(line, " ") || strings.HasPrefix(line, "\t") {
if len(lines) == 0 {
return nil, ErrTaskInvalid
}
lines[len(lines)-1] += line[1:]
} else {
lines = append(lines, line)
}
}
if len(lines) < 4 || lines[0] != "BEGIN:VCARD" || lines[len(lines)-1] != "END:VCARD" {
return nil, ErrTaskInvalid
}
return lines, nil
}
func cardKey(line string) (string, string, error) {
quoted := false
colon := -1
for i, c := range line {
if c == '"' {
quoted = !quoted
}
if c == ':' && !quoted {
colon = i
break
}
}
if colon < 1 {
return "", "", ErrTaskInvalid
}
head := line[:colon]
key := strings.SplitN(head, ";", 2)[0]
if i := strings.LastIndex(key, "."); i >= 0 {
key = key[i+1:]
}
for _, c := range key {
if !(c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' || c == '-') {
return "", "", ErrTaskInvalid
}
}
upper := strings.ToUpper(head)
if strings.Contains(upper, "ENCODING=") || strings.Contains(upper, "CHARSET=") {
return "", "", ErrTaskInvalid
}
return strings.ToUpper(key), line[colon+1:], nil
}
func cardText(s string) string {
var b strings.Builder
for i := 0; i < len(s); i++ {
if s[i] == '\\' && i+1 < len(s) {
i++
if s[i] == 'n' || s[i] == 'N' {
b.WriteByte('\n')
continue
}
}
b.WriteByte(s[i])
}
return b.String()
}
func escapeCard(s string) string {
return strings.NewReplacer("\\", "\\\\", "\r\n", "\\n", "\n", "\\n", ";", "\\;", ",", "\\,").Replace(s)
}
func foldCard(lines []string) string {
var b strings.Builder
for _, line := range lines {
first := true
for len(line) > 0 {
n := 75
if !first {
b.WriteByte(' ')
n = 74
}
if len(line) < n {
n = len(line)
}
for n > 0 && n < len(line) && !utf8.RuneStart(line[n]) {
n--
}
b.WriteString(line[:n])
b.WriteString("\r\n")
line = line[n:]
first = false
}
}
return b.String()
}
func ParseContact(raw string) (Contact, error) {
c := Contact{Emails: []string{}, Phones: []string{}}
lines, err := cardLines(raw)
if err != nil {
return c, err
}
versions, names, uids := 0, 0, 0
for _, line := range lines[1 : len(lines)-1] {
key, value, e := cardKey(line)
if e != nil {
return c, e
}
value = cardText(value)
switch key {
case "VERSION":
versions++
if value != "4.0" && value != "3.0" {
return c, ErrTaskInvalid
}
case "BEGIN", "END":
return c, ErrTaskInvalid
case "UID":
uids++
c.UID = value
case "FN":
names++
if c.Name == "" {
c.Name = value
}
case "EMAIL":
c.Emails = append(c.Emails, value)
case "TEL":
c.Phones = append(c.Phones, strings.TrimPrefix(value, "tel:"))
case "ORG":
if c.Organization == "" {
c.Organization = value
}
case "NOTE":
if c.Notes == "" {
c.Notes = value
}
}
}
if versions != 1 || names < 1 || uids > 1 || len(c.Name) > 300 || len(c.UID) > 1024 || strings.TrimSpace(c.Name) == "" || len(c.Emails) > 30 || len(c.Phones) > 30 {
return c, ErrTaskInvalid
}
if lines[1] != "VERSION:4.0" && lines[1] != "VERSION:3.0" {
return c, ErrTaskInvalid
}
for _, value := range append([]string{c.Name, c.UID}, c.Emails...) {
if strings.ContainsAny(value, "\r\n\x00") {
return c, ErrTaskInvalid
}
}
for _, value := range c.Emails {
a, e := mail.ParseAddress(value)
if e != nil || a.Address != value {
return c, ErrTaskInvalid
}
}
if c.UID == "" {
sum := sha256.Sum256([]byte(raw))
c.UID = "urn:pageswiki:import:" + hex.EncodeToString(sum[:])
lines = append(lines[:len(lines)-1], "UID:"+c.UID, "END:VCARD")
}
c.VCard = foldCard(lines)
return c, nil
}
// Editing the visible fields retains other fields verbatim. Even repeated FN,
// ORG/NOTE and typed email/phone fields survive when that field is unchanged.
func buildContact(old Contact, c Contact) (Contact, error) {
if len(c.Name) > 300 || strings.TrimSpace(c.Name) == "" || len(c.Notes) > 16384 || len(c.Organization) > 1000 || len(c.Emails) > 30 || len(c.Phones) > 30 {
return c, ErrTaskInvalid
}
for _, value := range append(append([]string{c.Name, c.Organization}, c.Emails...), c.Phones...) {
if strings.ContainsAny(value, "\r\n\x00") {
return c, ErrTaskInvalid
}
}
for _, value := range c.Emails {
a, e := mail.ParseAddress(value)
if e != nil || a.Address != value {
return c, ErrTaskInvalid
}
}
lines := []string{"BEGIN:VCARD", "VERSION:4.0", "UID:urn:uuid:" + c.UUID, "END:VCARD"}
if old.VCard != "" {
var e error
lines, e = cardLines(old.VCard)
if e != nil {
return c, e
}
}
changes := map[string][]string{}
if old.VCard == "" || c.Name != old.Name {
changes["FN"] = []string{c.Name}
}
if c.Organization != old.Organization {
changes["ORG"] = []string{c.Organization}
}
if c.Notes != old.Notes {
changes["NOTE"] = []string{c.Notes}
}
if strings.Join(c.Emails, "\x00") != strings.Join(old.Emails, "\x00") {
changes["EMAIL"] = c.Emails
}
if strings.Join(c.Phones, "\x00") != strings.Join(old.Phones, "\x00") {
changes["TEL"] = c.Phones
}
out := []string{}
for _, line := range lines[:len(lines)-1] {
k, _, _ := cardKey(line)
if _, replace := changes[k]; !replace {
out = append(out, line)
}
}
for _, key := range []string{"FN", "ORG", "NOTE", "EMAIL", "TEL"} {
for _, value := range changes[key] {
if value != "" {
out = append(out, key+":"+escapeCard(value))
}
}
}
out = append(out, "END:VCARD")
parsed, e := ParseContact(foldCard(out))
parsed.UUID = c.UUID
parsed.Version = c.Version
parsed.Deleted = c.Deleted
return parsed, e
}
func contactEnabled(ctx context.Context, q interface {
QueryRowContext(context.Context, string, ...any) *sql.Row
}, domain string) error {
var raw string
err := q.QueryRowContext(ctx, `SELECT value FROM config WHERE domain_uuid=? AND key='system_extension_states'`, domain).Scan(&raw)
if errors.Is(err, sql.ErrNoRows) || err == nil && raw == "" {
return nil
}
if err != nil {
return err
}
states := map[string]bool{}
if json.Unmarshal([]byte(raw), &states) != nil {
return ErrAccessDenied
}
if on, ok := states["organizer.contacts"]; ok && !on {
return ErrAccessDenied
}
return nil
}
func (s *Store) Contacts(ctx context.Context, domain, actor, query, after string) ([]Contact, string, error) {
return s.ListContacts(ctx, domain, actor, query, after, false)
}
func (s *Store) ListContacts(ctx context.Context, domain, actor, query, after string, deleted bool) ([]Contact, string, error) {
if err := taskActor(ctx, s.DB, domain, actor, false); err != nil {
return nil, "", err
}
if err := contactEnabled(ctx, s.DB, domain); err != nil {
return nil, "", err
}
if len(query) > 200 {
return nil, "", ErrTaskInvalid
}
rows, err := s.DB.QueryContext(ctx, `SELECT data FROM organizer_contacts WHERE domain_uuid=? AND owner_uuid=? AND deleted=? AND uuid>? AND instr(search,?)>0 ORDER BY uuid LIMIT 101`, domain, actor, deleted, after, strings.ToLower(query))
if err != nil {
return nil, "", err
}
defer rows.Close()
out := []Contact{}
next := ""
for rows.Next() {
var raw string
if err = rows.Scan(&raw); err != nil {
return nil, "", err
}
var c Contact
if err = json.Unmarshal([]byte(raw), &c); err != nil {
return nil, "", err
}
if len(out) == 100 {
next = out[99].UUID
break
}
c.VCard = ""
out = append(out, c)
}
return out, next, rows.Err()
}
func (s *Store) Contact(ctx context.Context, domain, actor, id string) (Contact, error) {
var c Contact
if err := taskActor(ctx, s.DB, domain, actor, false); err != nil {
return c, err
}
if err := contactEnabled(ctx, s.DB, domain); err != nil {
return c, err
}
var raw string
err := s.DB.QueryRowContext(ctx, `SELECT data FROM organizer_contacts WHERE domain_uuid=? AND owner_uuid=? AND uuid=?`, domain, actor, id).Scan(&raw)
if err == nil {
err = json.Unmarshal([]byte(raw), &c)
}
return c, err
}
func (s *Store) SaveContact(ctx context.Context, domain, actor string, c Contact, rawImport bool) (Contact, error) {
if s.ReadOnly {
return c, ErrReadOnly
}
if id, e := uuid.Parse(c.UUID); e != nil || id.String() != c.UUID || c.Version < 0 {
return c, ErrTaskInvalid
}
tx, err := s.DB.BeginTx(ctx, nil)
if err != nil {
return c, err
}
defer tx.Rollback()
if _, err = tx.ExecContext(ctx, `UPDATE domain_memberships SET state=state WHERE domain_uuid=? AND principal_uuid=?`, domain, actor); err != nil {
return c, err
}
if err = taskActor(ctx, tx, domain, actor, true); err != nil {
return c, err
}
if err = contactEnabled(ctx, tx, domain); err != nil {
return c, err
}
var old Contact
var data string
err = tx.QueryRowContext(ctx, `SELECT data FROM organizer_contacts WHERE domain_uuid=? AND owner_uuid=? AND uuid=?`, domain, actor, c.UUID).Scan(&data)
if err == nil {
if err = json.Unmarshal([]byte(data), &old); err != nil {
return c, err
}
} else if !errors.Is(err, sql.ErrNoRows) {
return c, err
}
if c.Version != old.Version {
return c, ErrTaskConflict
}
if rawImport {
if c.Version != 0 {
return c, ErrTaskInvalid
}
parsed, e := ParseContact(c.VCard)
if e != nil {
return c, e
}
parsed.UUID = c.UUID
c = parsed
var existing string
err = tx.QueryRowContext(ctx, `SELECT data FROM organizer_contacts WHERE domain_uuid=? AND owner_uuid=? AND uid=?`, domain, actor, c.UID).Scan(&existing)
if err == nil {
var previous Contact
if json.Unmarshal([]byte(existing), &previous) != nil {
return c, ErrTaskInvalid
}
if previous.VCard != c.VCard || previous.Deleted {
return c, ErrTaskConflict
}
return previous, nil
}
if !errors.Is(err, sql.ErrNoRows) {
return c, err
}
} else {
c, err = buildContact(old, c)
if err != nil {
return c, err
}
}
c.Version++
b, err := json.Marshal(c)
if err != nil {
return c, err
}
hash := sha256.Sum256([]byte(c.VCard))
digest := hex.EncodeToString(hash[:])
if err = s.persistDocument(digest, c.VCard); err != nil {
return c, err
}
search := strings.ToLower(c.Name + "\n" + c.Organization + "\n" + strings.Join(c.Emails, "\n") + "\n" + strings.Join(c.Phones, "\n"))
_, err = tx.ExecContext(ctx, `INSERT INTO organizer_contacts(domain_uuid,owner_uuid,uuid,uid,version,name,search,data,hash,deleted) VALUES(?,?,?,?,?,?,?,?,?,?) ON CONFLICT(domain_uuid,owner_uuid,uuid) DO UPDATE SET version=excluded.version,name=excluded.name,search=excluded.search,data=excluded.data,hash=excluded.hash,deleted=excluded.deleted`, domain, actor, c.UUID, c.UID, c.Version, c.Name, search, string(b), digest, c.Deleted)
if err != nil {
return c, fmt.Errorf("save contact: %w", err)
}
_, err = tx.ExecContext(ctx, `INSERT INTO organizer_contact_revisions VALUES(?,?,?,?,?,?,?)`, domain, actor, c.UUID, c.Version, digest, c.Deleted, time.Now().UnixMilli())
if err != nil {
return c, err
}
return c, tx.Commit()
}
+5 -3
View File
@@ -12,9 +12,11 @@ import (
// Once released, add a new version; never edit an applied definition.
// Auth, City, tasks and calendars remain in their existing migration paths.
var managedStoreSchemas = map[string][]db.SQLMigration{
"cli-auth": cliAuthMigrations,
"profile-contacts": profileContactMigrations,
"event-jobs": eventJobMigrations,
"contacts": contactMigrations,
"task-productivity": taskProductivityMigrations,
"cli-auth": cliAuthMigrations,
"profile-contacts": profileContactMigrations,
"event-jobs": eventJobMigrations,
"projection-metadata": {{Version: 1, Name: "adopt_projection_metadata", Statements: []string{
`CREATE TABLE IF NOT EXISTS projection_metadata (
document_hash TEXT NOT NULL,kind TEXT NOT NULL,version INTEGER NOT NULL,
+22
View File
@@ -15,9 +15,31 @@ func newSchemaTestStore(t *testing.T) *Store {
t.Fatal(err)
}
t.Cleanup(func() { database.Close() })
// task-productivity follows the legacy task schema at application startup.
// Provide its source projection, not the component under test itself.
if _, err = database.Exec(`CREATE TABLE organizer_items(domain_uuid TEXT,owner_uuid TEXT,uuid TEXT,kind TEXT,data TEXT)`); err != nil {
t.Fatal(err)
}
return &Store{DB: database}
}
func TestTaskProductivityMigrationBackfillsOnce(t *testing.T) {
st := newSchemaTestStore(t)
if _, e := st.DB.Exec(`INSERT INTO organizer_items VALUES('d','u','t','task','{"completed_at_ms":123,"estimate_minutes":60}')`); e != nil {
t.Fatal(e)
}
for range 2 {
if e := st.ensureSchemaComponent("task-productivity"); e != nil {
t.Fatal(e)
}
}
var count, complexity int
var completed int64
if e := st.DB.QueryRow(`SELECT count(*),completed_ms,complexity FROM organizer_task_metrics`).Scan(&count, &completed, &complexity); e != nil || count != 1 || completed != 123 || complexity != 1 {
t.Fatal(count, completed, complexity, e)
}
}
func TestManagedSchemasFreshRepeatAndReadOnly(t *testing.T) {
for component := range managedStoreSchemas {
t.Run(component, func(t *testing.T) {
+3
View File
@@ -108,6 +108,9 @@ func NewWithDocumentRoot(
if err := st.EnsureTasksSchema(); err != nil {
panic(err)
}
if err := st.ensureSchemaComponent("contacts"); err != nil {
panic(err)
}
if err := st.EnsureBrowserNavigationSchema(); err != nil {
panic(err)
}
+180
View File
@@ -0,0 +1,180 @@
package store
import (
"context"
"database/sql"
"encoding/json"
"errors"
"time"
)
const TaskDigestEventType = "task.digest.deliver"
type TaskDigestDue struct {
Domain string
Owner string
}
type TaskDigestClaim struct {
TaskDigestDue
Day string
Version int64
Timezone 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
}
res, err = tx.ExecContext(ctx, `INSERT OR IGNORE INTO organizer_digest_deliveries VALUES(?,?,?,'sending',?)`, due.Domain, due.Owner, out.Day, now.UnixMilli())
if err != nil {
return out, err
}
n, _ = res.RowsAffected()
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 err := taskActor(ctx, s.DB, c.Domain, c.Owner, true); err != nil {
return "", err
}
var raw, email string
var version int64
err := s.DB.QueryRowContext(ctx, `SELECT f.data,f.version,p.email FROM organizer_task_preferences f JOIN principals p ON p.uuid=f.owner_uuid WHERE f.domain_uuid=? AND f.owner_uuid=?`, c.Domain, c.Owner).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
}
return email, nil
}
func (s *Store) FinishTaskDigest(ctx context.Context, c TaskDigestClaim, state string) error {
if state != "sent" && state != "uncertain" && state != "cancelled" {
return ErrTaskInvalid
}
_, err := s.DB.ExecContext(ctx, `UPDATE organizer_digest_deliveries SET state=?,updated_ms=? WHERE domain_uuid=? AND owner_uuid=? AND day=? AND state='sending'`, state, time.Now().UnixMilli(), c.Domain, c.Owner, c.Day)
return err
}
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
}
+458
View File
@@ -0,0 +1,458 @@
package store
import (
"context"
"database/sql"
"encoding/json"
"errors"
"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"),
}}}
type TaskPreferences struct {
Version int64 `json:"version"`
ProjectUUID string `json:"project_uuid"`
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"`
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, 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
}
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(&current)
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) {
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, _ *TaskRecord, _ TaskRecord) error {
_, e := tx.ExecContext(ctx, `INSERT INTO organizer_capture_receipts VALUES(?,?,?,?,?)`, domain, actor, request, hash, item.UUID)
return e
})
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"`
}
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)
return v, err
}
const taskWorkColumns = `uuid,task_uuid,start_ms,end_ms,version`
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) (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
}
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.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.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
}
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"`
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"`
}
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,'') 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 WHERE m.domain_uuid=? AND m.owner_uuid=? AND m.completed_ms>=? AND m.completed_ms<? ORDER BY m.completed_ms,m.task_uuid LIMIT 10001`, domain, actor, start.UnixMilli(), end.UnixMilli())
if err != nil {
return out, err
}
n := 0
for rows.Next() {
var ms int64
var estimate, complexity int
var id, title, project string
if err = rows.Scan(&ms, &estimate, &complexity, &id, &title, &project); err != nil {
rows.Close()
return out, err
}
n++
if n > 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, 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,'') 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 WHERE w.domain_uuid=? AND w.owner_uuid=? AND w.start_ms<? AND (w.end_ms=0 OR w.end_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 string
if err = rows.Scan(&v.UUID, &v.TaskUUID, &v.StartMS, &v.EndMS, &v.Version, &title, &project); 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})
}
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 end_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)
}
return out, rows.Err()
}
+22 -1
View File
@@ -36,6 +36,8 @@ type TaskRecord struct {
DueOn string `json:"due_on"`
PlannedOn string `json:"planned_on"`
ReviewOn string `json:"review_on"`
AssigneeUUID string `json:"assignee_uuid,omitempty"`
Complexity int `json:"complexity,omitempty"`
PageUUID string `json:"page_uuid"`
Archived bool `json:"archived"`
Version int64 `json:"version"`
@@ -96,7 +98,10 @@ func (s *Store) EnsureTasksSchema() error {
if err := s.ensureTaskBlocksSchema(); err != nil {
return err
}
return s.ensureTaskFocusSchema()
if err := s.ensureTaskFocusSchema(); err != nil {
return err
}
return s.ensureSchemaComponent("task-productivity")
}
func validTaskDate(v string) bool {
@@ -108,6 +113,9 @@ func validTaskDate(v string) bool {
}
func validateTask(item *TaskRecord) error {
if item.Complexity < 0 || item.Complexity > 5 {
return ErrTaskInvalid
}
if !validTaskNotesSubpath(item.NotesSubpath) || (item.Kind != "project" && item.NotesSubpath != "") {
return ErrTaskInvalid
}
@@ -188,6 +196,9 @@ func (s *Store) SaveTask(ctx context.Context, domain, actor string, item TaskRec
// prepare participates in the same writer transaction as the task head.
func (s *Store) saveTask(ctx context.Context, domain, actor string, item TaskRecord, expected int64, prepare func(*sql.Tx, *TaskRecord, TaskRecord) error) (TaskRecord, error) {
if s.ReadOnly {
return TaskRecord{}, ErrReadOnly
}
if err := validateTask(&item); err != nil {
return TaskRecord{}, err
}
@@ -266,6 +277,11 @@ func (s *Store) saveTask(ctx context.Context, domain, actor string, item TaskRec
if err = s.validateTaskParentTx(ctx, tx, domain, actor, item, old); err != nil {
return TaskRecord{}, err
}
if item.AssigneeUUID != old.AssigneeUUID {
if err = validateTaskAssignee(ctx, tx, domain, item.AssigneeUUID); err != nil {
return TaskRecord{}, err
}
}
// DAV identity and round-trip metadata are writable only through the DAV
// transaction callback, never through a generic JSON/UI update.
item.CalDAV = old.CalDAV
@@ -330,6 +346,11 @@ func (s *Store) saveTask(ctx context.Context, domain, actor string, item TaskRec
if err = s.syncTaskRemindersTx(ctx, tx, domain, actor, item); err != nil {
return TaskRecord{}, err
}
if item.Kind == "task" {
if _, err = tx.ExecContext(ctx, `INSERT INTO organizer_task_metrics VALUES(?,?,?,?,?,?) ON CONFLICT(domain_uuid,task_uuid) DO UPDATE SET completed_ms=excluded.completed_ms,estimate=excluded.estimate,complexity=excluded.complexity`, domain, actor, item.UUID, item.CompletedMS, item.Estimate, max(1, item.Complexity)); err != nil {
return TaskRecord{}, err
}
}
if err = tx.Commit(); err != nil {
return TaskRecord{}, err
}