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

604 lines
11 KiB
Go

package store
import (
"database/sql"
"errors"
"strings"
"time"
"github.com/google/uuid"
"golang.org/x/text/language"
)
type Campus struct {
ID int64
UUID string
Name string
Title string
DefaultLang string
AuthorityMode string
FQDN string
Transport string
LastContactAt int64
LastContactError string
Enabled bool
CreatedAt int64
}
func (s *Store) EnsureCampusesSchema() error {
_, err := s.DB.Exec(`
CREATE TABLE IF NOT EXISTS campuses (
id INTEGER PRIMARY KEY AUTOINCREMENT,
uuid TEXT NOT NULL UNIQUE,
name TEXT NOT NULL UNIQUE,
title TEXT NOT NULL,
default_lang TEXT NOT NULL DEFAULT 'en',
authority_mode TEXT NOT NULL DEFAULT 'standalone',
fqdn TEXT NOT NULL DEFAULT 'localhost',
controller_transport TEXT NOT NULL DEFAULT 'https',
last_contact_at INTEGER NOT NULL DEFAULT 0,
last_contact_error TEXT NOT NULL DEFAULT '',
enabled INTEGER NOT NULL DEFAULT 1,
created_at INTEGER NOT NULL
)
`)
if err != nil {
return err
}
_, _ = s.DB.Exec(`ALTER TABLE campuses ADD COLUMN authority_mode TEXT NOT NULL DEFAULT 'standalone'`)
_, _ = s.DB.Exec(`ALTER TABLE campuses ADD COLUMN fqdn TEXT NOT NULL DEFAULT ''`)
_, _ = s.DB.Exec(`ALTER TABLE campuses ADD COLUMN controller_transport TEXT NOT NULL DEFAULT 'https'`)
_, _ = s.DB.Exec(`ALTER TABLE campuses ADD COLUMN last_contact_at INTEGER NOT NULL DEFAULT 0`)
_, _ = s.DB.Exec(`ALTER TABLE campuses ADD COLUMN last_contact_error TEXT NOT NULL DEFAULT ''`)
_, _ = s.DB.Exec(`
UPDATE campuses
SET fqdn = lower(trim(
replace(replace(replace(controller_url, 'https://', ''), 'http://', ''), '/', '')
))
WHERE fqdn = '' AND controller_url != ''
`)
_, _ = s.DB.Exec(`
UPDATE campuses
SET fqdn = CASE
WHEN id = (
SELECT id FROM campuses
WHERE enabled = 1
ORDER BY
CASE WHEN name = 'default' THEN 0 ELSE 1 END,
id
LIMIT 1
)
THEN 'localhost'
ELSE name || '.localhost'
END
WHERE fqdn = ''
`)
var count int
if err := s.DB.QueryRow(`
SELECT count(*)
FROM campuses
`).Scan(&count); err != nil {
return err
}
if count == 0 {
_, err = s.DB.Exec(`
INSERT INTO campuses (
uuid,
name,
title,
default_lang,
enabled,
created_at
)
VALUES (?, 'default', 'Default Campus', 'en', 1, ?)
`,
uuid.NewString(),
time.Now().Unix(),
)
if err != nil {
return err
}
}
_, _ = s.DB.Exec(`
ALTER TABLE domains
ADD COLUMN campus_uuid TEXT
`)
defaultCampus, err := s.GetDefaultCampus()
if err != nil {
return err
}
_, err = s.DB.Exec(`
UPDATE domains
SET campus_uuid = ?
WHERE campus_uuid IS NULL
OR campus_uuid = ''
OR campus_uuid NOT IN (
SELECT uuid
FROM campuses
WHERE enabled = 1
)
`, defaultCampus.UUID)
if err != nil {
return err
}
_, err = s.DB.Exec(`
CREATE INDEX IF NOT EXISTS idx_domains_campus_uuid
ON domains(campus_uuid)
`)
return err
}
func (s *Store) GetDefaultCampus() (*Campus, error) {
row := s.DB.QueryRow(`
SELECT
id,
uuid,
name,
title,
default_lang,
authority_mode,
fqdn,
controller_transport,
last_contact_at,
last_contact_error,
enabled,
created_at
FROM campuses
WHERE enabled = 1
ORDER BY
CASE WHEN name = 'default' THEN 0 ELSE 1 END,
id
LIMIT 1
`)
return scanCampus(row)
}
func (s *Store) GetCampusByUUID(
campusUUID string,
) (*Campus, error) {
row := s.DB.QueryRow(`
SELECT
id,
uuid,
name,
title,
default_lang,
authority_mode,
fqdn,
controller_transport,
last_contact_at,
last_contact_error,
enabled,
created_at
FROM campuses
WHERE uuid = ?
AND enabled = 1
LIMIT 1
`, campusUUID)
return scanCampus(row)
}
func (s *Store) ListCampuses() ([]Campus, error) {
rows, err := s.DB.Query(`
SELECT
id,
uuid,
name,
title,
default_lang,
authority_mode,
fqdn,
controller_transport,
last_contact_at,
last_contact_error,
enabled,
created_at
FROM campuses
ORDER BY
CASE WHEN name = 'default' THEN 0 ELSE 1 END,
name,
id
`)
if err != nil {
return nil, err
}
defer rows.Close()
var campuses []Campus
for rows.Next() {
campus, err := scanCampus(rows)
if err != nil {
return nil, err
}
campuses = append(campuses, *campus)
}
return campuses, rows.Err()
}
func (s *Store) CreateCampus(
name string,
title string,
defaultLang string,
authorityMode string,
fqdn string,
enabled bool,
) error {
name = normalizeCampusName(name)
title = strings.TrimSpace(title)
if name == "" {
return errors.New("campus name is required")
}
if title == "" {
title = name
}
defaultLang, err :=
normalizeCampusLanguage(
defaultLang,
)
if err != nil {
return err
}
authorityMode, fqdn, err = normalizeCampusAuthority(
authorityMode,
fqdn,
)
if err != nil {
return err
}
if authorityMode == "managed" {
return errors.New(
"managed campus must be added through controller enrollment",
)
}
if err := s.ensureCampusFQDNAvailable(0, fqdn); err != nil {
return err
}
enabledValue := 0
if enabled {
enabledValue = 1
}
_, err = s.DB.Exec(`
INSERT INTO campuses (
uuid,
name,
title,
default_lang,
authority_mode,
fqdn,
enabled,
created_at
)
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
`,
uuid.NewString(),
name,
title,
defaultLang,
authorityMode,
fqdn,
enabledValue,
time.Now().Unix(),
)
return err
}
func (s *Store) UpdateCampus(
id int64,
name string,
title string,
defaultLang string,
authorityMode string,
fqdn string,
enabled bool,
) error {
if id <= 0 {
return errors.New("campus id is required")
}
var existingMode string
if err := s.DB.QueryRow(`
SELECT authority_mode FROM campuses WHERE id = ?
`, id).Scan(&existingMode); err != nil {
return err
}
if existingMode == "managed" {
return errors.New("managed campus settings are inherited")
}
name = normalizeCampusName(name)
title = strings.TrimSpace(title)
if name == "" {
return errors.New("campus name is required")
}
if title == "" {
title = name
}
defaultLang, err :=
normalizeCampusLanguage(
defaultLang,
)
if err != nil {
return err
}
authorityMode, fqdn, err = normalizeCampusAuthority(
authorityMode,
fqdn,
)
if err != nil {
return err
}
if err := s.ensureCampusFQDNAvailable(id, fqdn); err != nil {
return err
}
if !enabled {
var domainCount int
if err := s.DB.QueryRow(`
SELECT count(*)
FROM domains
WHERE campus_uuid = (
SELECT uuid
FROM campuses
WHERE id = ?
)
`, id).Scan(&domainCount); err != nil {
return err
}
if domainCount > 0 {
return errors.New("campus is referenced by domains")
}
var enabledCount int
if err := s.DB.QueryRow(`
SELECT count(*)
FROM campuses
WHERE enabled = 1
AND id != ?
`, id).Scan(&enabledCount); err != nil {
return err
}
if enabledCount == 0 {
return errors.New("at least one enabled campus is required")
}
}
enabledValue := 0
if enabled {
enabledValue = 1
}
_, err = s.DB.Exec(`
UPDATE campuses
SET
name = ?,
title = ?,
default_lang = ?,
authority_mode = ?,
fqdn = ?,
enabled = ?
WHERE id = ?
`,
name,
title,
defaultLang,
authorityMode,
fqdn,
enabledValue,
id,
)
return err
}
func (s *Store) DeleteCampus(
id int64,
) error {
var targetEnabled int
var authorityMode string
if err := s.DB.QueryRow(`
SELECT enabled, authority_mode
FROM campuses
WHERE id = ?
`, id).Scan(&targetEnabled, &authorityMode); err != nil {
return err
}
var count int
if err := s.DB.QueryRow(`
SELECT count(*)
FROM campuses
`).Scan(&count); err != nil {
return err
}
if count <= 1 {
return errors.New("at least one campus is required")
}
if targetEnabled != 0 {
var enabledCount int
if err := s.DB.QueryRow(`
SELECT count(*)
FROM campuses
WHERE enabled = 1
AND id != ?
`, id).Scan(&enabledCount); err != nil {
return err
}
if enabledCount == 0 {
return errors.New("at least one enabled campus is required")
}
}
if authorityMode == "managed" {
return s.deleteManagedCampus(id)
}
var domainCount int
if err := s.DB.QueryRow(`
SELECT count(*)
FROM domains
WHERE campus_uuid = (
SELECT uuid
FROM campuses
WHERE id = ?
)
`, id).Scan(&domainCount); err != nil {
return err
}
if domainCount > 0 {
return errors.New("campus is referenced by domains")
}
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
var campusUUID string
if err := tx.QueryRow(`
SELECT uuid FROM campuses WHERE id = ?
`, id).Scan(&campusUUID); err != nil {
return err
}
if _, err := tx.Exec(`
DELETE FROM federation_instances WHERE campus_uuid = ?
`, campusUUID); err != nil {
return err
}
if _, err := tx.Exec(`
DELETE FROM campus_tokens WHERE campus_uuid = ?
`, campusUUID); err != nil {
return err
}
result, err := tx.Exec(`
DELETE FROM campuses WHERE id = ?
`, id)
if err != nil {
return err
}
affected, err := result.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return sql.ErrNoRows
}
return tx.Commit()
}
func normalizeCampusName(name string) string {
name = strings.TrimSpace(strings.ToLower(name))
return strings.ReplaceAll(name, " ", "-")
}
func normalizeCampusLanguage(raw string) (string, error) {
raw = strings.TrimSpace(raw)
if raw == "" {
raw = "en"
}
tag, err := language.Parse(raw)
if err != nil {
return "", errors.New("invalid campus default language")
}
return tag.String(), nil
}
func normalizeCampusAuthority(mode, fqdn string) (string, string, error) {
mode = strings.ToLower(strings.TrimSpace(mode))
fqdn = normalizeDomainHost(fqdn)
if mode == "" {
mode = "standalone"
}
switch mode {
case "standalone", "controller":
case "managed":
default:
return "", "", errors.New("invalid campus authority mode")
}
if fqdn == "" {
return "", "", errors.New("campus FQDN is required")
}
if !strings.Contains(fqdn, ".") && fqdn != "localhost" {
return "", "", errors.New("invalid campus FQDN")
}
return mode, fqdn, nil
}
func (s *Store) ensureCampusFQDNAvailable(id int64, fqdn string) error {
var count int
if err := s.DB.QueryRow(`
SELECT count(*) FROM campuses
WHERE id != ? AND lower(fqdn) = lower(?)
`, id, fqdn).Scan(&count); err != nil {
return err
}
if count > 0 {
return errors.New("campus FQDN already exists")
}
if err := s.DB.QueryRow(`
WITH effective_hosts AS (
SELECT lower(
CASE
WHEN d.domain = '' THEN
CASE WHEN c.id = ? THEN ? ELSE c.fqdn END
WHEN instr(d.domain, '.') > 0 THEN d.domain
ELSE d.domain || '.' ||
CASE WHEN c.id = ? THEN ? ELSE c.fqdn END
END
) AS host
FROM domains d
JOIN campuses c ON c.uuid = d.campus_uuid
)
SELECT count(*) FROM (
SELECT host FROM effective_hosts
GROUP BY host HAVING count(*) > 1
)
`, id, fqdn, id, fqdn).Scan(&count); err != nil {
return err
}
if count > 0 {
return errors.New("campus FQDN conflicts with a domain host")
}
return nil
}
func scanCampus(row interface {
Scan(dest ...any) error
}) (*Campus, error) {
var campus Campus
var enabled int
err := row.Scan(
&campus.ID,
&campus.UUID,
&campus.Name,
&campus.Title,
&campus.DefaultLang,
&campus.AuthorityMode,
&campus.FQDN,
&campus.Transport,
&campus.LastContactAt,
&campus.LastContactError,
&enabled,
&campus.CreatedAt,
)
if err != nil {
return nil, err
}
campus.Enabled = enabled != 0
return &campus, nil
}