Files
pages/internal/store/districts.go
T

470 lines
5.7 KiB
Go

package store
import (
"database/sql"
"errors"
"strings"
"time"
"github.com/google/uuid"
)
type District struct {
ID int64
UUID string
Name string
Title string
Domain string
Enabled bool
CreatedAt int64
}
func (s *Store) EnsureDistrictsSchema() error {
_, err := s.DB.Exec(`
CREATE TABLE IF NOT EXISTS districts (
id INTEGER PRIMARY KEY AUTOINCREMENT,
uuid TEXT NOT NULL UNIQUE,
name TEXT NOT NULL UNIQUE,
title TEXT NOT NULL,
domain TEXT NOT NULL DEFAULT '',
enabled INTEGER NOT NULL DEFAULT 1,
created_at INTEGER NOT NULL
)
`)
if err != nil {
return err
}
return s.EnsureAtLeastOneDistrict()
}
func (s *Store) EnsureAtLeastOneDistrict() error {
var count int
err := s.DB.QueryRow(`
SELECT count(*)
FROM districts
`).Scan(&count)
if err != nil {
return err
}
if count > 0 {
return nil
}
_, err = s.DB.Exec(`
INSERT INTO districts (
uuid,
name,
title,
domain,
enabled,
created_at
)
VALUES (?, 'default', 'Default District', '', 1, ?)
`,
uuid.NewString(),
time.Now().Unix(),
)
return err
}
func (s *Store) GetDefaultDistrict() (*District, error) {
row := s.DB.QueryRow(`
SELECT
id,
uuid,
name,
title,
domain,
enabled,
created_at
FROM districts
WHERE enabled = 1
ORDER BY
CASE WHEN name = 'default' THEN 0 ELSE 1 END,
id
LIMIT 1
`)
return scanDistrict(row)
}
func (s *Store) GetDistrictByHost(
host string,
) (*District, error) {
host =
normalizeDistrictHost(
host,
)
if host == "" {
return s.GetDefaultDistrict()
}
subdomain :=
host
if i := strings.IndexByte(host, '.'); i > 0 {
subdomain = host[:i]
}
row := s.DB.QueryRow(`
SELECT
id,
uuid,
name,
title,
domain,
enabled,
created_at
FROM districts
WHERE enabled = 1
AND (
lower(domain) = ?
OR lower(domain) = ?
OR lower(name) = ?
)
ORDER BY
CASE WHEN lower(domain) = ? THEN 0 ELSE 1 END,
id
LIMIT 1
`,
host,
subdomain,
subdomain,
host,
)
d, err :=
scanDistrict(
row,
)
if errors.Is(err, sql.ErrNoRows) {
return s.GetDefaultDistrict()
}
return d, err
}
func (s *Store) ListDistricts() ([]District, error) {
rows, err := s.DB.Query(`
SELECT
id,
uuid,
name,
title,
domain,
enabled,
created_at
FROM districts
ORDER BY
CASE WHEN name = 'default' THEN 0 ELSE 1 END,
name,
id
`)
if err != nil {
return nil, err
}
defer rows.Close()
var out []District
for rows.Next() {
d, err :=
scanDistrict(
rows,
)
if err != nil {
return nil, err
}
out = append(
out,
*d,
)
}
return out, rows.Err()
}
func (s *Store) CreateDistrict(
name string,
title string,
domain string,
enabled bool,
) error {
name =
normalizeDistrictName(
name,
)
title =
strings.TrimSpace(
title,
)
domain =
normalizeDistrictHost(
domain,
)
if name == "" {
return errors.New("district name is required")
}
if title == "" {
title = name
}
if err := s.ensureDistrictUnique(0, name, domain); err != nil {
return err
}
enabledValue := 0
if enabled {
enabledValue = 1
}
_, err := s.DB.Exec(`
INSERT INTO districts (
uuid,
name,
title,
domain,
enabled,
created_at
)
VALUES (?, ?, ?, ?, ?, ?)
`,
uuid.NewString(),
name,
title,
domain,
enabledValue,
time.Now().Unix(),
)
return err
}
func (s *Store) UpdateDistrict(
id int64,
name string,
title string,
domain string,
enabled bool,
) error {
name =
normalizeDistrictName(
name,
)
title =
strings.TrimSpace(
title,
)
domain =
normalizeDistrictHost(
domain,
)
if id <= 0 {
return errors.New("district id is required")
}
if name == "" {
return errors.New("district name is required")
}
if title == "" {
title = name
}
if err := s.ensureDistrictUnique(id, name, domain); err != nil {
return err
}
enabledValue := 0
if enabled {
enabledValue = 1
}
_, err := s.DB.Exec(`
UPDATE districts
SET
name = ?,
title = ?,
domain = ?,
enabled = ?
WHERE id = ?
`,
name,
title,
domain,
enabledValue,
id,
)
return err
}
func (s *Store) CountDistricts() (int, error) {
var count int
err := s.DB.QueryRow(`
SELECT count(*)
FROM districts
`).Scan(&count)
return count, err
}
func (s *Store) DeleteDistrict(
id int64,
) error {
count, err :=
s.CountDistricts()
if err != nil {
return err
}
if count <= 1 {
return sql.ErrNoRows
}
_, err = s.DB.Exec(`
DELETE FROM districts
WHERE id = ?
`, id)
return err
}
func scanDistrict(row interface {
Scan(dest ...any) error
}) (*District, error) {
var d District
var enabled int
err := row.Scan(
&d.ID,
&d.UUID,
&d.Name,
&d.Title,
&d.Domain,
&enabled,
&d.CreatedAt,
)
if err != nil {
return nil, err
}
d.Enabled = enabled != 0
return &d, nil
}
func normalizeDistrictName(
name string,
) string {
name =
strings.TrimSpace(
strings.ToLower(
name,
),
)
name =
strings.ReplaceAll(
name,
" ",
"-",
)
return name
}
func normalizeDistrictHost(
host string,
) string {
host =
strings.TrimSpace(
strings.ToLower(
host,
),
)
if host == "" {
return ""
}
if i := strings.IndexByte(host, ':'); i > 0 {
host = host[:i]
}
return strings.Trim(
host,
".",
)
}
func (s *Store) ensureDistrictUnique(
excludeID int64,
name string,
domain string,
) error {
var count int
err := s.DB.QueryRow(`
SELECT count(*)
FROM districts
WHERE id != ?
AND (
lower(name) = ?
OR (? != '' AND lower(domain) = ?)
)
`,
excludeID,
name,
domain,
domain,
).Scan(&count)
if err != nil {
return err
}
if count > 0 {
return errors.New("district name or domain already exists")
}
return nil
}