Files
pages/internal/store/task_dav.go
T
2026-11-15 05:47:14 +09:00

222 lines
10 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'`,
// Deleted identities remain reserved after an index rebuild. A stale
// client PUT must not silently resurrect a deliberately removed task.
`INSERT INTO organizer_dav_resources(domain_uuid,owner_uuid,item_uuid,name,uid) SELECT domain_uuid,owner_uuid,item_uuid,dav_name,dav_uid FROM organizer_task_deletions`,
} {
if _, err = tx.Exec(q); err != nil {
return err
}
}
return tx.Commit()
}
func (s *Store) 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(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`) 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 := s.taskDAVProjectTx(ctx, tx, domain, actor, item.ProjectUUID)
if err != nil {
return err
}
name, uid = s.taskDAVIndexKey(project, name), s.taskDAVIndexKey(project, uid)
var collision bool
if err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM organizer_dav_resources WHERE domain_uuid=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` AND item_uuid<>`+s.sqlParam(3)+` AND (name=`+s.sqlParam(4)+` OR uid=`+s.sqlParam(5)+`))`, 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(`+s.sqlParam(1)+`,`+s.sqlParam(2)+`,`+s.sqlParam(3)+`,`+s.sqlParam(4)+`,`+s.sqlParam(5)+`) 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 := s.taskActor(ctx, s.DB, domain, actor, false); err != nil {
return TaskRecord{}, err
}
var id string
p := ""
if len(project) == 1 {
p = project[0]
}
name = s.taskDAVIndexKey(p, name)
if err := s.DB.QueryRowContext(ctx, `SELECT item_uuid FROM organizer_dav_resources WHERE domain_uuid=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` AND name=`+s.sqlParam(3)+``, 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 := s.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=` + s.sqlParam(1) + ` AND owner_uuid=` + s.sqlParam(2) + ` AND kind='task' AND archived=0`
args := []any{domain, actor}
if p != "" {
query += ` AND project_uuid=` + s.sqlParam(len(args)+1) + ``
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 := s.taskDAVCredentialAllowed(ctx, tx, domain, actor, credential, true); err != nil {
return err
}
}
if v.Kind != "task" {
return ErrTaskInvalid
}
if len(collectionProject) == 1 {
p, err := s.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=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` AND uuid=`+s.sqlParam(3)+``, 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=`+s.sqlParam(1)+` AND owner_uuid=`+s.sqlParam(2)+` AND name=`+s.sqlParam(3)+`)`, 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"
}