Files
pages/internal/store/task_dav.go
T
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
2026-09-27 14:44:43 +09:00

217 lines
9.3 KiB
Go

package store
import (
"context"
"database/sql"
"encoding/json"
"errors"
"strings"
)
// TaskDAVData is retained in the canonical task revision, not just a cache.
// Generic SaveTask preserves it; only SaveTaskDAV can replace it.
type TaskDAVData struct {
Name string `json:"name"`
UID string `json:"uid"`
Data string `json:"data"`
}
var ErrTaskDAVLimit = errors.New("task DAV collection exceeds response limit")
var ErrTaskDAVIdentity = errors.New("task DAV UID or resource name already exists")
var ErrTaskDAVRelocated = errors.New("task DAV resource moved to a project collection; rediscover collections")
func (s *Store) ensureTaskDAVSchema() error {
for _, q := range []string{
`CREATE TABLE IF NOT EXISTS organizer_dav_collections(domain_uuid TEXT NOT NULL,path TEXT NOT NULL,owner_uuid TEXT NOT NULL,project_uuid TEXT NOT NULL,PRIMARY KEY(domain_uuid,path),UNIQUE(domain_uuid,project_uuid))`,
`CREATE TABLE IF NOT EXISTS organizer_dav_resources(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,item_uuid TEXT NOT NULL,name TEXT NOT NULL,uid TEXT NOT NULL,PRIMARY KEY(domain_uuid,item_uuid),UNIQUE(domain_uuid,owner_uuid,name),UNIQUE(domain_uuid,owner_uuid,uid))`,
`CREATE TABLE IF NOT EXISTS organizer_dav_legacy_hrefs(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,name TEXT NOT NULL,item_uuid TEXT NOT NULL,PRIMARY KEY(domain_uuid,owner_uuid,name))`,
`CREATE TABLE IF NOT EXISTS organizer_dav_default_lists(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,title TEXT NOT NULL,updated_at_ms INTEGER NOT NULL,PRIMARY KEY(domain_uuid,owner_uuid))`,
`CREATE TABLE IF NOT EXISTS organizer_dav_credentials(id TEXT PRIMARY KEY,domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,label TEXT NOT NULL,secret_hash TEXT NOT NULL,write_access INTEGER NOT NULL,created_ms INTEGER NOT NULL,expires_ms INTEGER NOT NULL)`,
`CREATE INDEX IF NOT EXISTS organizer_dav_credentials_owner ON organizer_dav_credentials(domain_uuid,owner_uuid)`,
`CREATE TABLE IF NOT EXISTS organizer_dav_scopes(credential_id TEXT PRIMARY KEY,scope TEXT NOT NULL CHECK(scope IN ('tasks','calendar','all')))`,
`CREATE TABLE IF NOT EXISTS organizer_dav_compat(credential_id TEXT PRIMARY KEY)`,
`CREATE TRIGGER IF NOT EXISTS organizer_dav_compat_delete AFTER DELETE ON organizer_dav_credentials BEGIN DELETE FROM organizer_dav_compat WHERE credential_id=OLD.id; END`,
`CREATE TRIGGER IF NOT EXISTS organizer_dav_scopes_delete AFTER DELETE ON organizer_dav_credentials BEGIN DELETE FROM organizer_dav_scopes WHERE credential_id=OLD.id; END`,
} {
if _, err := s.DB.Exec(q); err != nil {
return err
}
}
// Both tables are derived indexes. Rebuild atomically, including archived
// identities, so an upgrade never exposes projects in the default list or
// leaves old hrefs writable after moving them to project collections.
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
for _, q := range []string{
// Keep upgrade tombstones: a stale client must not recreate an already
// relocated task in the default list. These are migration metadata, not
// a live alias that could delete/update a different collection.
`INSERT OR IGNORE INTO organizer_dav_legacy_hrefs(domain_uuid,owner_uuid,name,item_uuid) SELECT r.domain_uuid,r.owner_uuid,r.name,r.item_uuid FROM organizer_dav_resources r JOIN organizer_items i ON i.domain_uuid=r.domain_uuid AND i.uuid=r.item_uuid WHERE i.project_uuid<>'' AND instr(r.name,char(0))=0`,
`DELETE FROM organizer_dav_resources`,
`DELETE FROM organizer_dav_collections`,
`INSERT INTO organizer_dav_collections(domain_uuid,path,owner_uuid,project_uuid) SELECT domain_uuid,COALESCE(NULLIF(json_extract(data,'$.dav_collection'),''),'tasks/projects/'||uuid),owner_uuid,uuid FROM organizer_items WHERE kind='project'`,
`INSERT INTO organizer_dav_resources(domain_uuid,owner_uuid,item_uuid,name,uid) SELECT domain_uuid,owner_uuid,uuid,CASE WHEN project_uuid='' THEN '' ELSE char(0)||project_uuid||char(0) END||COALESCE(json_extract(data,'$.caldav.name'),uuid||'.ics'),CASE WHEN project_uuid='' THEN '' ELSE char(0)||project_uuid||char(0) END||COALESCE(json_extract(data,'$.caldav.uid'),uuid) FROM organizer_items WHERE kind='task'`,
} {
if _, err = tx.Exec(q); err != nil {
return err
}
}
return tx.Commit()
}
func syncTaskDAVTx(ctx context.Context, tx *sql.Tx, domain, actor string, item TaskRecord) error {
if item.Kind == "project" {
_, err := tx.ExecContext(ctx, `INSERT INTO organizer_dav_collections(domain_uuid,path,owner_uuid,project_uuid) VALUES(?,?,?,?) ON CONFLICT(domain_uuid,project_uuid) DO NOTHING`, domain, item.TaskDAVCollectionPath(), actor, item.UUID)
return err
}
if item.Kind != "task" {
return nil
}
name, uid := item.UUID+".ics", item.UUID
if item.CalDAV != nil {
name, uid = item.CalDAV.Name, item.CalDAV.UID
}
project, err := taskDAVProjectTx(ctx, tx, domain, actor, item.ProjectUUID)
if err != nil {
return err
}
name, uid = taskDAVIndexKey(project, name), taskDAVIndexKey(project, uid)
var collision bool
if err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM organizer_dav_resources WHERE domain_uuid=? AND owner_uuid=? AND item_uuid<>? AND (name=? OR uid=?))`, domain, actor, item.UUID, name, uid).Scan(&collision); err != nil {
return err
}
if collision {
return ErrTaskDAVIdentity
}
_, err = tx.ExecContext(ctx, `INSERT INTO organizer_dav_resources(domain_uuid,owner_uuid,item_uuid,name,uid) VALUES(?,?,?,?,?) ON CONFLICT(domain_uuid,item_uuid) DO UPDATE SET name=excluded.name,uid=excluded.uid`, domain, actor, item.UUID, name, uid)
return err
}
func (s *Store) TaskDAVByName(ctx context.Context, domain, actor, name string, project ...string) (TaskRecord, error) {
if err := taskActor(ctx, s.DB, domain, actor, false); err != nil {
return TaskRecord{}, err
}
var id string
if len(project) == 1 {
name = taskDAVIndexKey(project[0], name)
}
if err := s.DB.QueryRowContext(ctx, `SELECT item_uuid FROM organizer_dav_resources WHERE domain_uuid=? AND owner_uuid=? AND name=?`, domain, actor, name).Scan(&id); err != nil {
return TaskRecord{}, err
}
return s.GetTask(ctx, domain, actor, id)
}
// A complete bounded snapshot, including completed tasks. Never silently return
// a partial collection: synchronizers would mistake omitted resources for deletes.
func (s *Store) TaskDAVList(ctx context.Context, domain, actor string, project ...string) ([]TaskRecord, error) {
if err := taskActor(ctx, s.DB, domain, actor, false); err != nil {
return nil, err
}
p := ""
if len(project) == 1 {
p = project[0]
}
query := `SELECT data FROM organizer_items i WHERE domain_uuid=? AND owner_uuid=? AND kind='task' AND archived=0`
args := []any{domain, actor}
if p != "" {
query += ` AND project_uuid=?`
args = append(args, p)
} else {
query += ` AND project_uuid=''`
}
rows, err := s.DB.QueryContext(ctx, query+` ORDER BY created_at_ms DESC,uuid DESC LIMIT 10001`, args...)
if err != nil {
return nil, err
}
defer rows.Close()
out := []TaskRecord{}
size := 0
for rows.Next() {
var raw string
if err = rows.Scan(&raw); err != nil {
return nil, err
}
size += len(raw)
if len(out) >= 10000 || size > 32<<20 {
return nil, ErrTaskDAVLimit
}
var item TaskRecord
if err = json.Unmarshal([]byte(raw), &item); err != nil {
return nil, err
}
out = append(out, item)
}
return out, rows.Err()
}
func (s *Store) SaveTaskDAV(ctx context.Context, domain, actor string, item TaskRecord, expected int64, data *TaskDAVData, credential string, collectionProject ...string) (TaskRecord, error) {
return s.saveTask(ctx, domain, actor, item, expected, func(tx *sql.Tx, v *TaskRecord, old TaskRecord) error {
if credential != "" {
if err := taskDAVCredentialAllowed(ctx, tx, domain, actor, credential, true); err != nil {
return err
}
}
if v.Kind != "task" {
return ErrTaskInvalid
}
if len(collectionProject) == 1 {
p, err := taskDAVProjectTx(ctx, tx, domain, actor, v.ProjectUUID)
if err != nil {
return err
}
if p != collectionProject[0] {
return ErrTaskConflict
}
if p != "" {
var active bool
if err := tx.QueryRowContext(ctx, `SELECT archived=0 FROM organizer_items WHERE domain_uuid=? AND owner_uuid=? AND uuid=?`, domain, actor, p).Scan(&active); err != nil {
return err
}
if !active {
return ErrAccessDenied
}
}
}
if data != nil {
if !ValidTaskDAVName(data.Name) || data.UID == "" || len(data.UID) > 512 || strings.ContainsAny(data.UID, "\r\n\x00") || len(data.Data) > 32768 {
return ErrTaskInvalid
}
if old.Version > 0 {
name, uid := old.UUID+".ics", old.UUID
if old.CalDAV != nil {
name, uid = old.CalDAV.Name, old.CalDAV.UID
}
if data.Name != name || data.UID != uid {
return ErrTaskDAVIdentity
}
} else if v.ProjectUUID == "" {
var relocated bool
if err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM organizer_dav_legacy_hrefs WHERE domain_uuid=? AND owner_uuid=? AND name=?)`, domain, actor, data.Name).Scan(&relocated); err != nil {
return err
}
if relocated {
return ErrTaskDAVRelocated
}
}
copy := *data
v.CalDAV = &copy
}
return nil
})
}
func ValidTaskDAVName(name string) bool {
if len(name) > 128 || len(name) < 5 || !strings.HasSuffix(name, ".ics") {
return false
}
for _, c := range name {
if !(c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' || strings.ContainsRune("._-", c)) {
return false
}
}
return name != "..ics"
}