Files
LektorenPlan/web/store/tenants.go
T
2026-11-12 20:00:33 +01:00

252 lines
6.9 KiB
Go

package store
import (
"context"
"database/sql"
"errors"
"strings"
"time"
"lektorenplan/domain"
)
// Tenant is an independent parish or planning group. All planning data is
// scoped by tenant.
type Tenant struct {
ID string `json:"id"`
Name string `json:"name"`
Slug string `json:"slug"`
Notes string `json:"notes"`
CreatedAt time.Time `json:"createdAt"`
}
// Tenants returns every tenant ordered by name.
func (s *Store) Tenants(ctx context.Context) ([]Tenant, error) {
rows, err := s.db.QueryContext(ctx,
"SELECT id, name, slug, notes, created_at FROM tenants ORDER BY name COLLATE NOCASE")
if err != nil {
return nil, err
}
defer rows.Close()
var out []Tenant
for rows.Next() {
var tenant Tenant
var created string
if err := rows.Scan(&tenant.ID, &tenant.Name, &tenant.Slug, &tenant.Notes, &created); err != nil {
return nil, err
}
tenant.CreatedAt = parseTime(created)
out = append(out, tenant)
}
return out, rows.Err()
}
// Tenant loads one tenant by id.
func (s *Store) Tenant(ctx context.Context, id string) (*Tenant, error) {
var tenant Tenant
var created string
err := s.db.QueryRowContext(ctx,
"SELECT id, name, slug, notes, created_at FROM tenants WHERE id=?", id).
Scan(&tenant.ID, &tenant.Name, &tenant.Slug, &tenant.Notes, &created)
if errors.Is(err, sql.ErrNoRows) {
return nil, ErrNotFound
}
if err != nil {
return nil, err
}
tenant.CreatedAt = parseTime(created)
return &tenant, nil
}
// TenantBySlug loads one tenant by its URL slug.
func (s *Store) TenantBySlug(ctx context.Context, slug string) (*Tenant, error) {
var tenant Tenant
var created string
err := s.db.QueryRowContext(ctx,
"SELECT id, name, slug, notes, created_at FROM tenants WHERE slug=? COLLATE NOCASE", slug).
Scan(&tenant.ID, &tenant.Name, &tenant.Slug, &tenant.Notes, &created)
if errors.Is(err, sql.ErrNoRows) {
return nil, ErrNotFound
}
if err != nil {
return nil, err
}
tenant.CreatedAt = parseTime(created)
return &tenant, nil
}
// CreateTenant adds a new planning group.
func (s *Store) CreateTenant(ctx context.Context, name, slug, notes string) (*Tenant, error) {
name = strings.TrimSpace(name)
slug = slugify(slug)
if slug == "" {
slug = slugify(name)
}
if name == "" || slug == "" {
return nil, errors.New("Name und Kennung sind erforderlich")
}
tenant := &Tenant{
ID: domain.NewID(), Name: name, Slug: slug, Notes: strings.TrimSpace(notes),
CreatedAt: time.Now().UTC(),
}
_, err := s.db.ExecContext(ctx,
"INSERT INTO tenants(id, name, slug, notes, created_at) VALUES(?, ?, ?, ?, ?)",
tenant.ID, tenant.Name, tenant.Slug, tenant.Notes, tenant.CreatedAt.Format(time.RFC3339))
if err != nil {
if isUniqueViolation(err) {
return nil, ErrConflict
}
return nil, err
}
return tenant, nil
}
// UpdateTenant saves name, slug and notes.
func (s *Store) UpdateTenant(ctx context.Context, tenant *Tenant) error {
tenant.Name = strings.TrimSpace(tenant.Name)
tenant.Slug = slugify(tenant.Slug)
tenant.Notes = strings.TrimSpace(tenant.Notes)
if tenant.ID == "" || tenant.Name == "" || tenant.Slug == "" {
return errors.New("Name und Kennung sind erforderlich")
}
_, err := s.db.ExecContext(ctx,
"UPDATE tenants SET name=?, slug=?, notes=? WHERE id=?",
tenant.Name, tenant.Slug, tenant.Notes, tenant.ID)
if err != nil {
if isUniqueViolation(err) {
return ErrConflict
}
return err
}
return nil
}
// DeleteTenant removes a tenant and, through cascades, its planning data.
func (s *Store) DeleteTenant(ctx context.Context, id string) error {
_, err := s.db.ExecContext(ctx, "DELETE FROM tenants WHERE id=?", id)
return err
}
func slugify(value string) string {
value = strings.ToLower(strings.TrimSpace(value))
replacer := strings.NewReplacer(
"ä", "ae", "ö", "oe", "ü", "ue", "ß", "ss",
" ", "-", "_", "-", ".", "-", "/", "-", ",", "",
)
value = replacer.Replace(value)
var b strings.Builder
lastDash := false
for _, r := range value {
switch {
case r >= 'a' && r <= 'z', r >= '0' && r <= '9':
b.WriteRune(r)
lastDash = false
case r == '-':
if !lastDash && b.Len() > 0 {
b.WriteRune('-')
lastDash = true
}
}
}
return strings.Trim(b.String(), "-")
}
// Memberships lists the tenant IDs assigned to a user.
func (s *Store) Memberships(ctx context.Context, userID string) ([]string, error) {
rows, err := s.db.QueryContext(ctx,
"SELECT tenant_id FROM memberships WHERE user_id=? ORDER BY tenant_id", userID)
if err != nil {
return nil, err
}
defer rows.Close()
var out []string
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
return nil, err
}
out = append(out, id)
}
return out, rows.Err()
}
// SetMemberships replaces the tenants assigned to a user.
func (s *Store) SetMemberships(ctx context.Context, userID string, tenantIDs []string) error {
return s.transaction(ctx, func(tx *sql.Tx) error {
if _, err := tx.ExecContext(ctx, "DELETE FROM memberships WHERE user_id=?", userID); err != nil {
return err
}
seen := map[string]bool{}
for _, tenantID := range tenantIDs {
if tenantID == "" || seen[tenantID] {
continue
}
seen[tenantID] = true
if _, err := tx.ExecContext(ctx,
"INSERT INTO memberships(user_id, tenant_id) VALUES(?, ?)", userID, tenantID); err != nil {
return err
}
}
return nil
})
}
// TenantsForUser returns the tenants a user may open. Admins see all.
func (s *Store) TenantsForUser(ctx context.Context, user *User) ([]Tenant, error) {
if user == nil {
return nil, nil
}
if user.Role == RoleAdmin {
return s.Tenants(ctx)
}
rows, err := s.db.QueryContext(ctx, `
SELECT t.id, t.name, t.slug, t.notes, t.created_at
FROM tenants t JOIN memberships m ON m.tenant_id = t.id
WHERE m.user_id=? ORDER BY t.name COLLATE NOCASE`, user.ID)
if err != nil {
return nil, err
}
defer rows.Close()
var out []Tenant
for rows.Next() {
var tenant Tenant
var created string
if err := rows.Scan(&tenant.ID, &tenant.Name, &tenant.Slug, &tenant.Notes, &created); err != nil {
return nil, err
}
tenant.CreatedAt = parseTime(created)
out = append(out, tenant)
}
return out, rows.Err()
}
// CanAccessTenant reports whether the user may read the tenant.
func (s *Store) CanAccessTenant(ctx context.Context, user *User, tenantID string) bool {
if user == nil || !user.Active {
return false
}
if user.Role == RoleAdmin {
return true
}
var count int
if err := s.db.QueryRowContext(ctx,
"SELECT COUNT(*) FROM memberships WHERE user_id=? AND tenant_id=?", user.ID, tenantID).Scan(&count); err != nil {
return false
}
return count > 0
}
// CanEditTenant reports whether the user may change planning data.
func (s *Store) CanEditTenant(ctx context.Context, user *User, tenantID string) bool {
if user == nil || !user.Active {
return false
}
if user.Role == RoleAdmin {
return true
}
if user.Role != RoleEditor {
return false
}
return s.CanAccessTenant(ctx, user, tenantID)
}