Files
pages/internal/store/periodicals.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

385 lines
17 KiB
Go

package store
import (
"context"
"database/sql"
"encoding/json"
"errors"
"github.com/google/uuid"
"path"
"strings"
"time"
"unicode"
)
var ErrPeriodicalInvalid = errors.New("invalid diary/blog entry")
var ErrPeriodicalConflict = errors.New("entry changed")
var ErrPeriodicalDisabled = errors.New("extension is disabled")
func PeriodicalKind(kind string) bool { return kind == "diary" || kind == "blog" }
// Article content remains an ordinary Page. Metadata follows its UUID on rename.
type PeriodicalEntry struct {
PageUUID string `json:"page_uuid"`
Path string `json:"path"`
Title string `json:"title"`
Date string `json:"date"`
Category string `json:"category"`
Timezone string `json:"timezone"`
Owner string `json:"owner_uuid"`
Version int64 `json:"version"`
Remove bool `json:"remove,omitempty"`
}
func (s *Store) EnsurePeriodicalSchema() error {
for _, query := range []string{
`CREATE TABLE IF NOT EXISTS periodical_settings(domain_uuid TEXT NOT NULL,kind TEXT NOT NULL CHECK(kind IN ('diary','blog')),enabled INTEGER NOT NULL DEFAULT 0,PRIMARY KEY(domain_uuid,kind))`,
`CREATE TABLE IF NOT EXISTS periodical_entries(domain_uuid TEXT NOT NULL,kind TEXT NOT NULL CHECK(kind IN ('diary','blog')),page_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,local_date TEXT NOT NULL,title TEXT NOT NULL,category TEXT NOT NULL DEFAULT '',timezone TEXT NOT NULL,version INTEGER NOT NULL DEFAULT 1,PRIMARY KEY(domain_uuid,kind,page_uuid))`,
`CREATE INDEX IF NOT EXISTS idx_periodical_date ON periodical_entries(domain_uuid,kind,local_date DESC,page_uuid)`,
`DROP INDEX IF EXISTS idx_diary_owner_date`,
`CREATE TABLE IF NOT EXISTS periodical_prefixes(domain_uuid TEXT NOT NULL,kind TEXT NOT NULL CHECK(kind IN ('diary','blog')),prefix TEXT NOT NULL,PRIMARY KEY(domain_uuid,kind))`,
`CREATE TABLE IF NOT EXISTS periodical_events(id INTEGER PRIMARY KEY AUTOINCREMENT,domain_uuid TEXT NOT NULL,kind TEXT NOT NULL,page_uuid TEXT NOT NULL,actor_uuid TEXT NOT NULL,operation TEXT NOT NULL,version INTEGER NOT NULL,created_at_ms INTEGER NOT NULL)`,
`CREATE INDEX IF NOT EXISTS idx_periodical_event_page ON periodical_events(domain_uuid,kind,page_uuid,version DESC)`,
`CREATE TABLE IF NOT EXISTS periodical_posts(domain_uuid TEXT NOT NULL,kind TEXT NOT NULL,actor_uuid TEXT NOT NULL,request_id TEXT NOT NULL,digest TEXT NOT NULL,page_uuid TEXT NOT NULL,PRIMARY KEY(domain_uuid,kind,actor_uuid,request_id))`,
`CREATE TABLE IF NOT EXISTS domain_entry_settings(domain_uuid TEXT PRIMARY KEY,settings_json TEXT NOT NULL)`,
`CREATE TABLE IF NOT EXISTS periodical_projections(domain_uuid TEXT NOT NULL,kind TEXT NOT NULL,source_uuid TEXT NOT NULL,prefix TEXT NOT NULL,PRIMARY KEY(domain_uuid,kind))`,
} {
if _, err := s.DB.Exec(query); err != nil {
return err
}
}
return nil
}
func (s *Store) PeriodicalEnabled(ctx context.Context, domain, kind string) (bool, error) {
var enabled bool
err := s.DB.QueryRowContext(ctx, `SELECT enabled FROM periodical_settings WHERE domain_uuid=? AND kind=?`, domain, kind).Scan(&enabled)
if errors.Is(err, sql.ErrNoRows) {
return false, nil
}
return enabled, err
}
// PeriodicalPath is shared by settings validation and the new-article planner.
// It never normalizes traversal or silently replaces a caller's keyword.
func PeriodicalPath(prefix, date, keyword string) (string, error) {
if !strings.HasPrefix(prefix, "/") || path.Clean(prefix) != prefix || len(prefix) > 3500 || strings.ContainsAny(prefix, "\\?#%") || strings.IndexFunc(prefix+keyword, unicode.IsControl) >= 0 {
return "", ErrPeriodicalInvalid
}
for _, reserved := range []string{"/_", "/-", "/v", "/e", "/:"} {
if prefix == reserved || strings.HasPrefix(prefix, reserved+"/") {
return "", ErrPeriodicalInvalid
}
}
d, err := time.Parse("2006-01-02", date)
if err != nil || d.Year() < 1 || d.Year() > 9999 || d.Format("2006-01-02") != date || len(keyword) > 240 || keyword != strings.TrimSpace(keyword) || keyword == "." || keyword == ".." || strings.ContainsAny(keyword, "/\\?#%") {
return "", ErrPeriodicalInvalid
}
return path.Join(prefix, d.Format("2006/01/02"), keyword), nil
}
func (s *Store) PeriodicalPrefix(ctx context.Context, domain, kind string) (string, error) {
if !PeriodicalKind(kind) {
return "", ErrPeriodicalInvalid
}
var prefix string
err := s.DB.QueryRowContext(ctx, `SELECT prefix FROM periodical_prefixes WHERE domain_uuid=? AND kind=?`, domain, kind).Scan(&prefix)
if errors.Is(err, sql.ErrNoRows) {
return "/" + kind, nil
}
return prefix, err
}
func (s *Store) ChangePeriodical(ctx context.Context, domain, actor, kind string, enabled *bool, entry *PeriodicalEntry, prefixes ...string) error {
return s.changePeriodical(ctx, domain, actor, kind, enabled, entry, prefixes, nil)
}
type PeriodicalPost struct {
Title string `json:"title"`
Date string `json:"date"`
Category string `json:"category"`
Keyword string `json:"keyword"`
Body string `json:"body"`
RequestID string `json:"request_id"`
Timezone string `json:"-"`
Path string `json:"-"`
PageUUID string `json:"-"`
}
// Body is canonical HTML produced by the server. The Page, Revision, binding,
// article metadata and retry receipt become visible in one transaction.
func (s *Store) CreatePeriodical(ctx context.Context, domain, actor, kind string, post *PeriodicalPost) error {
if post == nil || len(post.Body) > 256<<10 || strings.TrimSpace(post.Body) == "" {
return ErrPeriodicalInvalid
}
if _, err := uuid.Parse(post.RequestID); err != nil {
return ErrPeriodicalInvalid
}
if strings.TrimSpace(post.Title) == "" || len(post.Title) > 240 || len(post.Category) > 80 || strings.ContainsAny(post.Title+post.Category, "\x00\r\n") {
return ErrPeriodicalInvalid
}
if _, err := time.LoadLocation(post.Timezone); err != nil {
return ErrPeriodicalInvalid
}
s.revisionWriteMu.Lock()
defer s.revisionWriteMu.Unlock()
entry := &PeriodicalEntry{Title: post.Title, Date: post.Date, Category: post.Category, Timezone: post.Timezone}
return s.changePeriodical(ctx, domain, actor, kind, nil, entry, nil, post)
}
func (s *Store) changePeriodical(ctx context.Context, domain, actor, kind string, enabled *bool, entry *PeriodicalEntry, prefixes []string, post *PeriodicalPost) error {
if !PeriodicalKind(kind) || (enabled == nil) == (entry == nil) {
return ErrPeriodicalInvalid
}
if len(prefixes) > 1 || (len(prefixes) > 0 && enabled == nil) {
return ErrPeriodicalInvalid
}
if len(prefixes) == 1 {
if _, err := PeriodicalPath(prefixes[0], "2000-01-01", ""); err != nil {
return err
}
}
ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
tx, err := s.DB.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
// Reserve writer before all authorization, configuration and binding checks.
if _, err = tx.ExecContext(ctx, `INSERT INTO periodical_settings(domain_uuid,kind) VALUES(?,?) ON CONFLICT(domain_uuid,kind) DO UPDATE SET enabled=enabled`, domain, kind); err != nil {
return err
}
var active, admin bool
err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM principals p JOIN domain_memberships m ON m.principal_uuid=p.uuid JOIN domains d ON d.uuid=m.domain_uuid AND d.enabled=1 WHERE p.uuid=? AND p.state='active' AND m.domain_uuid=? AND m.state='active')`, actor, domain).Scan(&active)
if err != nil {
return err
}
if !active {
return ErrAccessDenied
}
err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM groups g JOIN group_members gm ON gm.group_uuid=g.uuid JOIN domain_memberships m ON m.uuid=gm.membership_uuid AND m.domain_uuid=g.domain_uuid WHERE g.domain_uuid=? AND g.builtin_key='domain_admin' AND g.state='active' AND gm.member_role IN ('owner','manager') AND m.principal_uuid=? AND m.state='active')`, domain, actor).Scan(&admin)
if err != nil {
return err
}
operation, pageUUID, version := "settings", "", int64(0)
if enabled != nil {
var controlled bool
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM domain_entry_settings WHERE domain_uuid=?)`, domain).Scan(&controlled); err != nil {
return err
}
if controlled {
return ErrAccessDenied
}
if !admin {
return ErrAccessDenied
}
if _, err = tx.ExecContext(ctx, `UPDATE periodical_settings SET enabled=? WHERE domain_uuid=? AND kind=?`, *enabled, domain, kind); err != nil {
return err
}
if len(prefixes) == 1 {
if _, err = tx.ExecContext(ctx, `INSERT INTO periodical_prefixes(domain_uuid,kind,prefix) VALUES(?,?,?) ON CONFLICT(domain_uuid,kind) DO UPDATE SET prefix=excluded.prefix`, domain, kind, prefixes[0]); err != nil {
return err
}
}
} else {
var projected bool
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM periodical_projections WHERE domain_uuid=? AND kind=?)`, domain, kind).Scan(&projected); err != nil {
return err
}
if projected {
return ErrAccessDenied
}
var on bool
if err = tx.QueryRowContext(ctx, `SELECT enabled FROM periodical_settings WHERE domain_uuid=? AND kind=?`, domain, kind).Scan(&on); err != nil {
return err
}
if !on {
return ErrPeriodicalDisabled
}
e := entry
if post != nil {
var local bool
if err = tx.QueryRowContext(ctx, `SELECT COALESCE(placement,'local')='local' FROM domains WHERE uuid=? AND enabled=1`, domain).Scan(&local); err != nil {
return err
}
if !local {
return ErrAccessDenied
}
prefix := "/" + kind
err = tx.QueryRowContext(ctx, `SELECT prefix FROM periodical_prefixes WHERE domain_uuid=? AND kind=?`, domain, kind).Scan(&prefix)
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return err
}
e.Path, err = PeriodicalPath(prefix, e.Date, post.Keyword)
if err != nil {
return err
}
post.Path = e.Path
}
if !strings.HasPrefix(e.Path, "/") || path.Clean(e.Path) != e.Path || len(e.Path) > 4096 || strings.ContainsAny(e.Path, "\\\x00\r\n") || e.Version < 0 {
return ErrPeriodicalInvalid
}
if post == nil {
if err = tx.QueryRowContext(ctx, `SELECT p.object_uuid FROM paths p JOIN objects o ON o.uuid=p.object_uuid AND o.kind='page' WHERE p.domain_uuid=? AND p.path=?`, domain, e.Path).Scan(&pageUUID); err != nil {
return err
}
if (e.Version > 0 && e.PageUUID != pageUUID) || (e.PageUUID != "" && e.PageUUID != pageUUID) {
return ErrPeriodicalConflict
}
}
capabilities := []string{"write"}
if post != nil {
capabilities = append(capabilities, "create")
}
for _, capability := range capabilities {
basis := authorizeGrantFrom(tx, AuthorizationRequest{DomainUUID: domain, PrincipalUUID: actor, Capability: capability, TargetType: "path", TargetID: e.Path}, false)
if basis != nil && !errors.Is(basis, ErrAccessDenied) {
return basis
}
// Match the existing semantic editor's own-user Wiki authority; the
// authenticated identity and Locality caps still come from this tx.
if errors.Is(basis, ErrAccessDenied) {
var own bool
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM principal_identities WHERE principal_uuid=? AND provider_type='password' AND (?='/u/'||subject OR substr(?,1,length('/u/'||subject||'/'))='/u/'||subject||'/'))`, actor, e.Path, e.Path).Scan(&own); err != nil {
return err
}
if own {
basis = nil
}
}
caps, err := loadLocalityAccess(tx, domain, actor)
if err != nil {
return err
}
if !caps.decide(e.Path, capability, basis == nil) {
return ErrAccessDenied
}
}
if post != nil {
encoded, _ := json.Marshal([]string{post.Path, post.Title, post.Date, post.Category, post.Keyword, post.Body})
digest := revisionHash(string(encoded))
var oldDigest, oldPage string
err = tx.QueryRowContext(ctx, `SELECT digest,page_uuid FROM periodical_posts WHERE domain_uuid=? AND kind=? AND actor_uuid=? AND request_id=?`, domain, kind, actor, post.RequestID).Scan(&oldDigest, &oldPage)
if err == nil {
var live bool
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM paths p JOIN periodical_entries e ON e.domain_uuid=p.domain_uuid AND e.page_uuid=p.object_uuid AND e.kind=? WHERE p.domain_uuid=? AND p.path=? AND p.object_uuid=?)`, kind, domain, e.Path, oldPage).Scan(&live); err != nil {
return err
}
if digest != oldDigest || !live {
return ErrPeriodicalConflict
}
post.PageUUID = oldPage
return tx.Commit()
}
if !errors.Is(err, sql.ErrNoRows) {
return err
}
var exists bool
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM paths WHERE domain_uuid=? AND path=?)`, domain, e.Path).Scan(&exists); err != nil {
return err
}
if exists {
return ErrPeriodicalConflict
}
pageUUID = uuid.NewString()
if _, err = tx.ExecContext(ctx, `INSERT INTO objects(uuid,kind,created_at) VALUES(?,'page',strftime('%s','now'))`, pageUUID); err != nil {
return err
}
if _, err = tx.ExecContext(ctx, `INSERT INTO object_origins(object_uuid,domain_uuid,created_at) VALUES(?,?,strftime('%s','now'))`, pageUUID, domain); err != nil {
return err
}
if _, err = tx.ExecContext(ctx, `INSERT INTO paths(domain_uuid,path,object_uuid,created_at) VALUES(?,?,?,strftime('%s','now'))`, domain, e.Path, pageUUID); err != nil {
return err
}
body, hashes, err := freezeEmbeddedAssetsFrom(tx, pageUUID, []byte(post.Body), "text/html; charset=utf-8")
if err != nil {
return err
}
now := time.Now()
rev := &Revision{UUID: uuid.NewString(), ObjectUUID: pageUUID, Body: string(body), DocumentHash: revisionHash(string(body)), Language: "und", ContentType: "text/html; charset=utf-8", CreatedAt: now.Unix(), CreatedAtMS: now.UnixMilli()}
if err = s.persistDocument(rev.DocumentHash, rev.Body); err != nil {
return err
}
if err = insertRevision(tx, rev, hashes); err != nil {
return err
}
if _, err = tx.ExecContext(ctx, `INSERT INTO periodical_posts(domain_uuid,kind,actor_uuid,request_id,digest,page_uuid) VALUES(?,?,?,?,?,?)`, domain, kind, actor, post.RequestID, digest, pageUUID); err != nil {
return err
}
post.PageUUID = pageUUID
}
var oldVersion int64
var owner, oldTimezone string
err = tx.QueryRowContext(ctx, `SELECT version,owner_uuid,timezone FROM periodical_entries WHERE domain_uuid=? AND kind=? AND page_uuid=?`, domain, kind, pageUUID).Scan(&oldVersion, &owner, &oldTimezone)
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return err
}
if oldVersion != e.Version || (e.Remove && oldVersion == 0) {
return ErrPeriodicalConflict
}
version = oldVersion + 1
if oldVersion == 0 {
if err = tx.QueryRowContext(ctx, `SELECT COALESCE(MAX(version),0)+1 FROM periodical_events WHERE domain_uuid=? AND kind=? AND page_uuid=?`, domain, kind, pageUUID).Scan(&version); err != nil {
return err
}
}
if e.Remove {
operation = "removed"
_, err = tx.ExecContext(ctx, `DELETE FROM periodical_entries WHERE domain_uuid=? AND kind=? AND page_uuid=?`, domain, kind, pageUUID)
} else {
operation = "registered"
if oldVersion > 0 {
e.Timezone = oldTimezone
}
e.Title = strings.TrimSpace(e.Title)
e.Category = strings.TrimSpace(e.Category)
date, parseErr := time.Parse("2006-01-02", e.Date)
if parseErr != nil || date.Format("2006-01-02") != e.Date || date.Year() < 1 || date.Year() > 9999 || len(e.Title) == 0 || len(e.Title) > 240 || len(e.Category) > 80 || strings.ContainsAny(e.Title+e.Category, "\x00\r\n") {
return ErrPeriodicalInvalid
}
if _, err = time.LoadLocation(e.Timezone); err != nil {
return ErrPeriodicalInvalid
}
if owner == "" {
owner = actor
}
_, err = tx.ExecContext(ctx, `INSERT INTO periodical_entries(domain_uuid,kind,page_uuid,owner_uuid,local_date,title,category,timezone,version) VALUES(?,?,?,?,?,?,?,?,?) ON CONFLICT(domain_uuid,kind,page_uuid) DO UPDATE SET local_date=excluded.local_date,title=excluded.title,category=excluded.category,timezone=excluded.timezone,version=excluded.version`, domain, kind, pageUUID, owner, e.Date, e.Title, e.Category, e.Timezone, version)
}
if err != nil {
return err
}
}
if _, err = tx.ExecContext(ctx, `INSERT INTO periodical_events(domain_uuid,kind,page_uuid,actor_uuid,operation,version,created_at_ms) VALUES(?,?,?,?,?,?,?)`, domain, kind, pageUUID, actor, operation, version, time.Now().UnixMilli()); err != nil {
return err
}
return tx.Commit()
}
// Bounded metadata-only scan; callers filter permissions before counts/paging.
// All aliases are retained until filtering, so a private alias cannot hide an
// otherwise readable Page. No canonical HTML is loaded to build an index.
func (s *Store) ListPeriodicalEntries(ctx context.Context, domain, kind string) ([]PeriodicalEntry, error) {
ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()
rows, err := s.DB.QueryContext(ctx, `SELECT e.page_uuid,p.path,e.title,e.local_date,e.category,e.timezone,e.owner_uuid,e.version FROM periodical_entries e JOIN paths p ON p.object_uuid=e.page_uuid AND p.domain_uuid=e.domain_uuid JOIN objects o ON o.uuid=e.page_uuid AND o.kind='page' WHERE e.domain_uuid=? AND e.kind=? ORDER BY e.local_date DESC,e.page_uuid,p.path LIMIT 5001`, domain, kind)
if err != nil {
return nil, err
}
defer rows.Close()
out := []PeriodicalEntry{}
bytes := 0
for rows.Next() {
var e PeriodicalEntry
if err = rows.Scan(&e.PageUUID, &e.Path, &e.Title, &e.Date, &e.Category, &e.Timezone, &e.Owner, &e.Version); err != nil {
return nil, err
}
out = append(out, e)
bytes += len(e.Path) + len(e.Title) + len(e.Category) + len(e.Timezone) + len(e.Owner) + len(e.PageUUID) + len(e.Date)
if len(out) > 5000 || bytes > 4<<20 {
return nil, ErrNavigationBudget
}
}
return out, rows.Err()
}