252 lines
6.9 KiB
Go
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)
|
|
}
|