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 }