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

180 lines
6.7 KiB
Go

package store
import (
"context"
"database/sql"
"encoding/json"
"errors"
"time"
)
var ErrManifestCapability = errors.New("all approved Campus instances must announce manifest v2 support before saving entry settings")
func (s *Store) CampusLegacyManifestPeers() (map[string]int, error) {
rows, err := s.DB.Query(`SELECT i.campus_uuid,count(*) FROM federation_instances i LEFT JOIN federation_instance_capabilities c ON c.instance_uuid=i.uuid WHERE i.status='approved' AND COALESCE(c.manifest_version,1)<2 GROUP BY i.campus_uuid`)
if err != nil {
return nil, err
}
defer rows.Close()
out := map[string]int{}
for rows.Next() {
var id string
var n int
if err = rows.Scan(&id, &n); err != nil {
return nil, err
}
out[id] = n
}
return out, rows.Err()
}
// A deliberately narrow allowlist; never federate arbitrary config or secrets.
type DomainEntrySettings struct {
Layout string `json:"layout"`
DiaryEnabled bool `json:"diary_enabled"`
DiaryPrefix string `json:"diary_prefix"`
BlogEnabled bool `json:"blog_enabled"`
BlogPrefix string `json:"blog_prefix"`
}
func (e DomainEntrySettings) valid() bool {
switch e.Layout {
case "classic", "search", "directory", "diary", "blog":
default:
return false
}
if e.Layout == "diary" && !e.DiaryEnabled || e.Layout == "blog" && !e.BlogEnabled {
return false
}
for _, prefix := range []string{e.DiaryPrefix, e.BlogPrefix} {
if _, err := PeriodicalPath(prefix, "2000-01-01", ""); err != nil {
return false
}
}
return true
}
func (s *Store) ListDomainEntrySettings() (map[string]DomainEntrySettings, error) {
rows, err := s.DB.Query(`SELECT domain_uuid,settings_json FROM domain_entry_settings`)
if err != nil {
return nil, err
}
defer rows.Close()
out := map[string]DomainEntrySettings{}
for rows.Next() {
var id, raw string
if err = rows.Scan(&id, &raw); err != nil {
return nil, err
}
var e DomainEntrySettings
if err = json.Unmarshal([]byte(raw), &e); err != nil {
return nil, err
}
out[id] = e
}
return out, rows.Err()
}
func (s *Store) DomainEntryControlled(domain string) (bool, error) {
var exists bool
err := s.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM domain_entry_settings WHERE domain_uuid=?)`, domain).Scan(&exists)
return exists, err
}
// Populate the dialog with effective local values before control is first enabled.
// One metadata query avoids issuing five config reads for every Domain row.
func (s *Store) DomainEntryOptions() (map[string]DomainEntrySettings, error) {
entries, err := s.ListDomainEntrySettings()
if err != nil {
return nil, err
}
rows, err := s.DB.Query(`SELECT d.uuid,COALESCE(c.value,'classic'),COALESCE(ds.enabled,0),COALESCE(dp.prefix,'/diary'),COALESCE(bs.enabled,0),COALESCE(bp.prefix,'/blog') FROM domains d LEFT JOIN config c ON c.domain_uuid=d.uuid AND c.key='home_layout' LEFT JOIN periodical_settings ds ON ds.domain_uuid=d.uuid AND ds.kind='diary' LEFT JOIN periodical_settings bs ON bs.domain_uuid=d.uuid AND bs.kind='blog' LEFT JOIN periodical_prefixes dp ON dp.domain_uuid=d.uuid AND dp.kind='diary' LEFT JOIN periodical_prefixes bp ON bp.domain_uuid=d.uuid AND bp.kind='blog'`)
if err != nil {
return nil, err
}
defer rows.Close()
for rows.Next() {
var id string
var e DomainEntrySettings
if err = rows.Scan(&id, &e.Layout, &e.DiaryEnabled, &e.DiaryPrefix, &e.BlogEnabled, &e.BlogPrefix); err != nil {
return nil, err
}
if _, ok := entries[id]; !ok {
entries[id] = e
}
}
return entries, rows.Err()
}
func saveDomainEntryTx(tx *sql.Tx, domain string, e DomainEntrySettings, apply bool) error {
if !e.valid() {
return ErrPeriodicalInvalid
}
raw, _ := json.Marshal(e)
if _, err := tx.Exec(`INSERT INTO domain_entry_settings(domain_uuid,settings_json) VALUES(?,?) ON CONFLICT(domain_uuid) DO UPDATE SET settings_json=excluded.settings_json`, domain, string(raw)); err != nil {
return err
}
if !apply {
return nil
}
if _, err := tx.Exec(`INSERT INTO config(domain_uuid,key,value,updated_at) VALUES(?,'home_layout',?,strftime('%s','now')) ON CONFLICT(domain_uuid,key) DO UPDATE SET value=excluded.value,updated_at=excluded.updated_at`, domain, e.Layout); err != nil {
return err
}
for _, item := range []struct {
kind, prefix string
enabled bool
}{{"diary", e.DiaryPrefix, e.DiaryEnabled}, {"blog", e.BlogPrefix, e.BlogEnabled}} {
if _, err := tx.Exec(`INSERT INTO periodical_settings(domain_uuid,kind,enabled) VALUES(?,?,?) ON CONFLICT(domain_uuid,kind) DO UPDATE SET enabled=excluded.enabled`, domain, item.kind, item.enabled); err != nil {
return err
}
if _, err := tx.Exec(`INSERT INTO periodical_prefixes(domain_uuid,kind,prefix) VALUES(?,?,?) ON CONFLICT(domain_uuid,kind) DO UPDATE SET prefix=excluded.prefix`, domain, item.kind, item.prefix); err != nil {
return err
}
}
return nil
}
func (s *Store) SetDomainEntry(ctx context.Context, id int64, actor string, e DomainEntrySettings) error {
if !e.valid() {
return ErrPeriodicalInvalid
}
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()
if _, err = tx.ExecContext(ctx, `UPDATE domains SET title=title WHERE id=?`, id); err != nil {
return err
}
var domain, campus, mode, placement string
if err = tx.QueryRowContext(ctx, `SELECT d.uuid,d.campus_uuid,c.authority_mode,d.placement FROM domains d JOIN campuses c ON c.uuid=d.campus_uuid WHERE d.id=?`, id).Scan(&domain, &campus, &mode, &placement); err != nil {
return err
}
if mode == "managed" {
return ErrAccessDenied
}
var allowed bool
err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM groups g JOIN domains d ON d.uuid=g.domain_uuid AND d.enabled=1 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 JOIN principals p ON p.uuid=m.principal_uuid WHERE d.campus_uuid=? AND g.builtin_key='campus_admin' AND g.state='active' AND m.principal_uuid=? AND m.state='active' AND p.state='active' AND gm.member_role IN ('owner','manager'))`, campus, actor).Scan(&allowed)
if err != nil {
return err
}
if !allowed {
return ErrAccessDenied
}
// Campus manifests are shared with every approved instance, not just the
// selected Domain destination. Do not strand an older peer on a v2 payload.
var incompatible bool
if err = tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM federation_instances i LEFT JOIN federation_instance_capabilities c ON c.instance_uuid=i.uuid WHERE i.campus_uuid=? AND i.status='approved' AND COALESCE(c.manifest_version,1)<2)`, campus).Scan(&incompatible); err != nil {
return err
}
if incompatible {
return ErrManifestCapability
}
if err = saveDomainEntryTx(tx, domain, e, placement == "local"); err != nil {
return err
}
return tx.Commit()
}