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.
148 lines
4.7 KiB
Go
148 lines
4.7 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
var ErrTaskDAVCollectionExists = errors.New("DAV collection already exists")
|
|
|
|
// Native projects derive their stable collection URI from their canonical UUID.
|
|
// Explicit MKCALENDAR paths keep their original identity. The reserved tasks/
|
|
// namespace cannot shadow a VEVENT calendar (including an external source).
|
|
func (v TaskRecord) TaskDAVCollectionPath() string {
|
|
if v.DAVCollection != "" {
|
|
return v.DAVCollection
|
|
}
|
|
return "tasks/projects/" + v.UUID
|
|
}
|
|
|
|
// Collection metadata lives in a normal, revisioned project document. This
|
|
// table is only its routing/uniqueness index, rebuilt from canonical heads.
|
|
func (s *Store) CreateTaskDAVCollection(ctx context.Context, domain, actor, path, title, credential string) (TaskRecord, error) {
|
|
id, err := uuid.Parse(path)
|
|
if err != nil || id.String() != path {
|
|
return TaskRecord{}, ErrTaskInvalid
|
|
}
|
|
item := TaskRecord{UUID: uuid.NewString(), Kind: "project", Title: title, Status: "todo", Bucket: "inbox"}
|
|
return s.saveTask(ctx, domain, actor, item, 0, func(tx *sql.Tx, v *TaskRecord, old TaskRecord) error {
|
|
if credential != "" {
|
|
if err := taskDAVCredentialAllowed(ctx, tx, domain, actor, credential, true); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
var exists bool
|
|
if err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM organizer_dav_collections WHERE domain_uuid=? AND path=?)`, domain, path).Scan(&exists); err != nil {
|
|
return err
|
|
}
|
|
if exists {
|
|
return ErrTaskDAVCollectionExists
|
|
}
|
|
// Never shadow even a private calendar owned by another principal. Only
|
|
// inspect directory existence; do not read calendar metadata or events.
|
|
if s.DocumentRoot != "" {
|
|
_, err := os.Stat(filepath.Join(s.DocumentRoot, "calendars", domain, path))
|
|
if err == nil {
|
|
return ErrTaskDAVCollectionExists
|
|
}
|
|
if !os.IsNotExist(err) {
|
|
return err
|
|
}
|
|
}
|
|
var count int
|
|
if err := tx.QueryRowContext(ctx, `SELECT count(*) FROM organizer_dav_collections WHERE domain_uuid=? AND owner_uuid=?`, domain, actor).Scan(&count); err != nil {
|
|
return err
|
|
}
|
|
if count >= 256 {
|
|
return ErrTaskDAVLimit
|
|
}
|
|
v.DAVCollection = path
|
|
return nil
|
|
})
|
|
}
|
|
|
|
func (s *Store) IsTaskDAVCollection(ctx context.Context, domain, path string) (bool, error) {
|
|
var found bool
|
|
err := s.DB.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM organizer_dav_collections WHERE domain_uuid=? AND path=?)`, domain, path).Scan(&found)
|
|
return found, err
|
|
}
|
|
|
|
func (s *Store) TaskDAVCollection(ctx context.Context, domain, actor, path string) (TaskRecord, error) {
|
|
var project string
|
|
if err := s.DB.QueryRowContext(ctx, `SELECT project_uuid FROM organizer_dav_collections WHERE domain_uuid=? AND owner_uuid=? AND path=?`, domain, actor, path).Scan(&project); err != nil {
|
|
return TaskRecord{}, err
|
|
}
|
|
v, err := s.GetTask(ctx, domain, actor, project)
|
|
if err == nil && v.Archived {
|
|
return TaskRecord{}, sql.ErrNoRows
|
|
}
|
|
return v, err
|
|
}
|
|
|
|
func (s *Store) TaskDAVCollections(ctx context.Context, domain, actor string) ([]TaskRecord, error) {
|
|
if err := taskActor(ctx, s.DB, domain, actor, false); err != nil {
|
|
return nil, err
|
|
}
|
|
rows, err := s.DB.QueryContext(ctx, `SELECT i.uuid FROM organizer_dav_collections c JOIN organizer_items i ON i.domain_uuid=c.domain_uuid AND i.uuid=c.project_uuid AND i.owner_uuid=c.owner_uuid WHERE c.domain_uuid=? AND c.owner_uuid=? AND i.archived=0 ORDER BY c.path LIMIT 257`, domain, actor)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var ids []string
|
|
for rows.Next() {
|
|
var id string
|
|
if err = rows.Scan(&id); err != nil {
|
|
rows.Close()
|
|
return nil, err
|
|
}
|
|
ids = append(ids, id)
|
|
}
|
|
err = rows.Err()
|
|
rows.Close()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(ids) > 256 {
|
|
return nil, ErrTaskDAVLimit
|
|
}
|
|
items := make([]TaskRecord, 0, len(ids))
|
|
for _, id := range ids {
|
|
v, err := s.GetTask(ctx, domain, actor, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if !v.Archived {
|
|
items = append(items, v)
|
|
}
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
func taskDAVIndexKey(project, value string) string {
|
|
if project == "" {
|
|
return value
|
|
}
|
|
// A NUL prefix cannot occur in an accepted UID/name, avoiding collisions
|
|
// between default-list UIDs and collection-qualified index keys.
|
|
return "\x00" + project + "\x00" + value
|
|
}
|
|
|
|
func taskDAVProjectTx(ctx context.Context, tx *sql.Tx, domain, actor, project string) (string, error) {
|
|
if project == "" {
|
|
return "", nil
|
|
}
|
|
var found bool
|
|
err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM organizer_dav_collections WHERE domain_uuid=? AND owner_uuid=? AND project_uuid=?)`, domain, actor, project).Scan(&found)
|
|
if found {
|
|
return project, err
|
|
}
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return "", sql.ErrNoRows
|
|
}
|