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

606 lines
14 KiB
Go

package store
import (
"context"
"database/sql"
"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 {
if s.sqlBackend == storePostgreSQL {
return s.ensurePostgreSQLCampusDefaults(context.Background())
}
_, 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) {
return s.GetDefaultCampusContext(context.Background())
}
func (s *Store) GetDefaultCampusContext(ctx context.Context) (*Campus, error) {
row := s.DB.QueryRowContext(ctx, `
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
`)
c, err := scanCampus(row)
return c, s.sqlError("read default campus", err)
}
func (s *Store) GetCampusByUUID(
campusUUID string,
) (*Campus, error) {
return s.GetCampusByUUIDContext(context.Background(), campusUUID)
}
func (s *Store) GetCampusByUUIDContext(ctx context.Context, campusUUID string) (*Campus, error) {
row := s.DB.QueryRowContext(ctx, `
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 = `+s.sqlParam(1)+`
AND enabled = 1
LIMIT 1
`, campusUUID)
c, err := scanCampus(row)
return c, s.sqlError("read campus", err)
}
func (s *Store) ListCampuses() ([]Campus, error) {
return s.ListCampusesContext(context.Background())
}
func (s *Store) ListCampusesContext(ctx context.Context) ([]Campus, error) {
rows, err := s.DB.QueryContext(ctx, `
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, s.sqlError("list campuses", err)
}
defer rows.Close()
var campuses []Campus
for rows.Next() {
campus, err := scanCampus(rows)
if err != nil {
return nil, s.sqlError("decode campus list", err)
}
campuses = append(campuses, *campus)
}
return campuses, s.sqlError("list 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 namespaceValidationError("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 namespaceValidationError(
"managed campus must be added through controller enrollment",
)
}
enabledValue := 0
if enabled {
enabledValue = 1
}
return s.namespaceWrite(context.Background(), func(ctx context.Context, tx *sql.Tx) error {
if err := s.ensureCampusFQDNAvailableFrom(ctx, tx, 0, fqdn); err != nil {
return err
}
_, err := tx.ExecContext(ctx, `INSERT INTO campuses(uuid,name,title,default_lang,authority_mode,fqdn,enabled,created_at) VALUES (`+s.sqlValues(8)+`)`, 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 namespaceValidationError("campus id is required")
}
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
defer cancel()
var existingMode string
if err := s.DB.QueryRowContext(ctx, `
SELECT authority_mode FROM campuses WHERE id = `+s.sqlParam(1)+`
`, id).Scan(&existingMode); err != nil {
return s.sqlError("read campus authority", err)
}
if existingMode == "managed" {
return namespaceValidationError("managed campus settings are inherited")
}
name = normalizeCampusName(name)
title = strings.TrimSpace(title)
if name == "" {
return namespaceValidationError("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
}
return s.namespaceWrite(ctx, func(ctx context.Context, tx *sql.Tx) error {
// Re-read inherited status under the same lock as the mutation.
if err := tx.QueryRowContext(ctx, `SELECT authority_mode FROM campuses WHERE id=`+s.sqlParam(1), id).Scan(&existingMode); err != nil {
return err
}
if existingMode == "managed" {
return namespaceValidationError("managed campus settings are inherited")
}
if err := s.ensureCampusFQDNAvailableFrom(ctx, tx, id, fqdn); err != nil {
return err
}
if !enabled {
var domainCount int
if err := tx.QueryRowContext(ctx, `
SELECT count(*)
FROM domains
WHERE campus_uuid = (
SELECT uuid
FROM campuses
WHERE id = `+s.sqlParam(1)+`
)
`, id).Scan(&domainCount); err != nil {
return err
}
if domainCount > 0 {
return namespaceValidationError("campus is referenced by domains")
}
var enabledCount int
if err := tx.QueryRowContext(ctx, `
SELECT count(*)
FROM campuses
WHERE enabled = 1
AND id != `+s.sqlParam(1)+`
`, id).Scan(&enabledCount); err != nil {
return err
}
if enabledCount == 0 {
return namespaceValidationError("at least one enabled campus is required")
}
}
enabledValue := 0
if enabled {
enabledValue = 1
}
_, err = tx.ExecContext(ctx, `
UPDATE campuses
SET
name = `+s.sqlParam(1)+`,
title = `+s.sqlParam(2)+`,
default_lang = `+s.sqlParam(3)+`,
authority_mode = `+s.sqlParam(4)+`,
fqdn = `+s.sqlParam(5)+`,
enabled = `+s.sqlParam(6)+`
WHERE id = `+s.sqlParam(7)+`
`,
name,
title,
defaultLang,
authorityMode,
fqdn,
enabledValue,
id,
)
return err
})
}
func (s *Store) DeleteCampus(
id int64,
) error {
if s.ReadOnly {
return ErrReadOnly
}
return s.namespaceWrite(context.Background(), func(ctx context.Context, tx *sql.Tx) error {
var err error
var targetEnabled int
var authorityMode string
if err := tx.QueryRowContext(ctx, `
SELECT enabled, authority_mode
FROM campuses
WHERE id = `+s.sqlParam(1)+`
`, id).Scan(&targetEnabled, &authorityMode); err != nil {
return err
}
var count int
if err := tx.QueryRowContext(ctx, `
SELECT count(*)
FROM campuses
`).Scan(&count); err != nil {
return err
}
if count <= 1 {
return namespaceValidationError("at least one campus is required")
}
if targetEnabled != 0 {
var enabledCount int
if err := tx.QueryRowContext(ctx, `
SELECT count(*)
FROM campuses
WHERE enabled = 1
AND id != `+s.sqlParam(1)+`
`, id).Scan(&enabledCount); err != nil {
return err
}
if enabledCount == 0 {
return namespaceValidationError("at least one enabled campus is required")
}
}
if authorityMode == "managed" {
return s.deleteManagedCampusTx(ctx, tx, id)
}
var domainCount int
if err := tx.QueryRowContext(ctx, `
SELECT count(*)
FROM domains
WHERE campus_uuid = (
SELECT uuid
FROM campuses
WHERE id = `+s.sqlParam(1)+`
)
`, id).Scan(&domainCount); err != nil {
return err
}
if domainCount > 0 {
return namespaceValidationError("campus is referenced by domains")
}
var campusUUID string
if err := tx.QueryRowContext(ctx, `
SELECT uuid FROM campuses WHERE id = `+s.sqlParam(1)+`
`, id).Scan(&campusUUID); err != nil {
return err
}
if err := s.deleteFederationCampusTx(ctx, tx, campusUUID); err != nil {
return err
}
result, err := tx.ExecContext(ctx, `
DELETE FROM campuses WHERE id = `+s.sqlParam(1)+`
`, id)
if err != nil {
return err
}
affected, err := result.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return sql.ErrNoRows
}
return nil
})
}
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 "", namespaceValidationError("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 "", "", namespaceValidationError("invalid campus authority mode")
}
if fqdn == "" {
return "", "", namespaceValidationError("campus FQDN is required")
}
if !strings.Contains(fqdn, ".") && fqdn != "localhost" {
return "", "", namespaceValidationError("invalid campus FQDN")
}
return mode, fqdn, nil
}
func (s *Store) ensureCampusFQDNAvailableFrom(ctx context.Context, q interface {
QueryRowContext(context.Context, string, ...any) *sql.Row
}, id int64, fqdn string) error {
var count int
if err := q.QueryRowContext(ctx, `
SELECT count(*) FROM campuses
WHERE id != `+s.sqlParam(1)+` AND lower(fqdn) = lower(`+s.sqlParam(2)+`)
`, id, fqdn).Scan(&count); err != nil {
return err
}
if count > 0 {
return namespaceValidationError("campus FQDN already exists")
}
if err := q.QueryRowContext(ctx, `
WITH effective_hosts AS (
SELECT lower(
CASE
WHEN d.domain = '' THEN
CASE WHEN c.id = `+s.sqlParam(1)+` THEN `+s.sqlParam(2)+` ELSE c.fqdn END
WHEN `+s.sqlHasDot("d.domain")+` THEN d.domain
ELSE d.domain || '.' ||
CASE WHEN c.id = `+s.sqlParam(3)+` THEN `+s.sqlParam(4)+` 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
) AS duplicate_hosts
`, id, fqdn, id, fqdn).Scan(&count); err != nil {
return err
}
if count > 0 {
return namespaceValidationError("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
}