470 lines
5.7 KiB
Go
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
|
|
}
|