Add task capture, work reports, daily digests and private contacts
Build and publish container images / images (push) Successful in 16m37s
Build and publish container images / images (push) Successful in 16m37s
This commit is contained in:
1 parent
50b8b0323f
commit
b4792bb175
50 files changed
+2678
-17
No files matched your search
@@ -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()
|
||||
}
|
||||
@@ -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,
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
@@ -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(¤t)
|
||||
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
@@ -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
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user