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 { return s.transaction(ctx, func(tx *sql.Tx) error { if _, err := tx.ExecContext(ctx, "DELETE FROM key_wrappers WHERE tenant_id=?", id); err != nil { return err } _, err := tx.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 } // CanManageSecrets reports whether the user may manage encrypted contacts and // SMTP credentials. Administrators are deliberately excluded: only editors // hold the keys for these scopes. func (s *Store) CanManageSecrets(ctx context.Context, user *User, tenantID string) bool { if user == nil || !user.Active || user.Role != RoleEditor { return false } return s.CanAccessTenant(ctx, user, tenantID) } // 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) }