feat: Admin-Bereich (Accounts, Kanzlei-Verzeichnis-Freigabe, Audit-Log)

Bislang gab es keine vom Nutzer-Rollenmodell (creator/agentur/marke/ kanzlei) getrennte Betreiber-Rolle — jede Verwaltungsaufgabe (welche Kanzlei darf im öffentlichen Verzeichnis stehen, wer sind unsere Accounts) wäre nur per Hand in der Datenbank möglich gewesen. Admin ist von Anfang an als fünfte app_user-Rolle im Datenmodell verankert, nicht nachträglich aufgesetzt. Migration 0004: - app_user.role erlaubt zusätzlich 'admin' (kein Self-Service-Weg dorthin — /register bietet die Rolle nicht an, erster Admin wird einmalig per SQL angelegt, siehe CLAUDE.md). - account.verified: Freigabe fürs kostenlose Kanzlei-Verzeichnis (§ 49b Abs. 3 BRAO: reine Auflistung, kein Routing/keine Vermittlung). - audit_log: append-only-Protokoll jeder Admin-Aktion (gleicher Trigger wie finding/extraction/evidence_package). Neue Routen: - GET /admin, /admin/accounts, /admin/accounts/{id}: Accounts-Übersicht und -Detail (Logins je Account), requireAdmin (404 statt 403 für angemeldete Nicht-Admins, wie beim bestehenden Mandanten-404-Muster). - POST /admin/accounts/{id}/verifizieren: Kanzlei-Freigabe umschalten, schreibt einen Audit-Log-Eintrag. - GET /admin/audit-log: Protokoll ansehen. - GET /kanzleien: öffentliches Verzeichnis (kein Login), zeigt nur Accounts, die sowohl verified sind als auch einen Nutzer der Rolle "kanzlei" haben. Volle Testsuite inkl. echter Postgres-Tests grün; End-to-End manuell gegen einen laufenden Server verifiziert (Admin-Login, Verify-Toggle, Erscheinen im öffentlichen Verzeichnis, Audit-Log-Eintrag, 404 für Nicht-Admin-Zugriff).
2026-08-27 18:17:45 +02:00
parent c9d71b0d54
commit 835ad9f0a7
18 changed files with 1151 additions and 12 deletions
--- a/internal/store/account.go
+++ b/internal/store/account.go
@@ -2,25 +2,32 @@ package store

 import (
 	"context"
+	"errors"
 	"fmt"
 	"time"
+
+	"github.com/jackc/pgx/v5"
 )

 // Account ist ein Mandant (Creator, Agentur, Marke oder Kanzlei als
 // eigene Organisation). Jeder Beitrag gehört genau einem Account.
+// Verified ist nur für Kanzlei-Accounts relevant: ob sie im öffentlichen
+// Kanzlei-Verzeichnis gelistet werden (siehe Migration 0004).
 type Account struct {
 	ID        string
 	Name      string
+	Verified  bool
 	CreatedAt time.Time
 }

-// CreateAccount legt einen neuen Mandanten an.
+// CreateAccount legt einen neuen Mandanten an (verified startet false —
+// jede Freigabe fürs Kanzlei-Verzeichnis ist eine bewusste Admin-Aktion).
 func (s *Store) CreateAccount(ctx context.Context, name string) (Account, error) {
 	var a Account
 	err := s.Pool.QueryRow(ctx, `
 		INSERT INTO account (name) VALUES ($1)
-		RETURNING id, name, created_at
-	`, name).Scan(&a.ID, &a.Name, &a.CreatedAt)
+		RETURNING id, name, verified, created_at
+	`, name).Scan(&a.ID, &a.Name, &a.Verified, &a.CreatedAt)
 	if err != nil {
 		return Account{}, fmt.Errorf("store: create account: %w", err)
 	}
@@ -31,10 +38,85 @@ func (s *Store) CreateAccount(ctx context.Context, name string) (Account, error)
 func (s *Store) GetAccount(ctx context.Context, id string) (Account, error) {
 	var a Account
 	err := s.Pool.QueryRow(ctx, `
-		SELECT id, name, created_at FROM account WHERE id = $1
-	`, id).Scan(&a.ID, &a.Name, &a.CreatedAt)
+		SELECT id, name, verified, created_at FROM account WHERE id = $1
+	`, id).Scan(&a.ID, &a.Name, &a.Verified, &a.CreatedAt)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return Account{}, ErrNotFound
+	}
 	if err != nil {
 		return Account{}, fmt.Errorf("store: get account: %w", err)
 	}
 	return a, nil
 }
+
+// ListAccounts liefert alle Mandanten, neueste zuerst — für den
+// Admin-Bereich (Accounts-Verwaltung).
+func (s *Store) ListAccounts(ctx context.Context) ([]Account, error) {
+	rows, err := s.Pool.Query(ctx, `
+		SELECT id, name, verified, created_at FROM account ORDER BY created_at DESC
+	`)
+	if err != nil {
+		return nil, fmt.Errorf("store: list accounts: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Account
+	for rows.Next() {
+		var a Account
+		if err := rows.Scan(&a.ID, &a.Name, &a.Verified, &a.CreatedAt); err != nil {
+			return nil, fmt.Errorf("store: scan account: %w", err)
+		}
+		out = append(out, a)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("store: list accounts: %w", err)
+	}
+	return out, nil
+}
+
+// ListVerifiedKanzleien liefert alle Accounts, die fürs öffentliche
+// Kanzlei-Verzeichnis freigegeben sind UND mindestens einen Nutzer der
+// Rolle "kanzlei" haben — verified allein reicht nicht, falls ein Admin
+// versehentlich einen Nicht-Kanzlei-Account markiert.
+func (s *Store) ListVerifiedKanzleien(ctx context.Context) ([]Account, error) {
+	rows, err := s.Pool.Query(ctx, `
+		SELECT DISTINCT a.id, a.name, a.verified, a.created_at
+		FROM account a
+		JOIN app_user u ON u.account_id = a.id
+		WHERE a.verified = true AND u.role = 'kanzlei'
+		ORDER BY a.name
+	`)
+	if err != nil {
+		return nil, fmt.Errorf("store: list verified kanzleien: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Account
+	for rows.Next() {
+		var a Account
+		if err := rows.Scan(&a.ID, &a.Name, &a.Verified, &a.CreatedAt); err != nil {
+			return nil, fmt.Errorf("store: scan account: %w", err)
+		}
+		out = append(out, a)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("store: list verified kanzleien: %w", err)
+	}
+	return out, nil
+}
+
+// SetAccountVerified setzt die Freigabe fürs Kanzlei-Verzeichnis.
+func (s *Store) SetAccountVerified(ctx context.Context, id string, verified bool) (Account, error) {
+	var a Account
+	err := s.Pool.QueryRow(ctx, `
+		UPDATE account SET verified = $2 WHERE id = $1
+		RETURNING id, name, verified, created_at
+	`, id, verified).Scan(&a.ID, &a.Name, &a.Verified, &a.CreatedAt)
+	if errors.Is(err, pgx.ErrNoRows) {
+		return Account{}, ErrNotFound
+	}
+	if err != nil {
+		return Account{}, fmt.Errorf("store: set account verified: %w", err)
+	}
+	return a, nil
+}
--- a/internal/store/admin_test.go
+++ b/internal/store/admin_test.go
@@ -0,0 +1,221 @@
+package store_test
+
+import (
+	"context"
+	"testing"
+)
+
+func TestAppUserRoleAllowsAdmin(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accID := testAccountID(t, s)
+
+	u, err := s.CreateUser(ctx, accID, "admin@example.com", "hash", "admin")
+	if err != nil {
+		t.Fatalf("CreateUser mit role=admin: %v", err)
+	}
+	if u.Role != "admin" {
+		t.Fatalf("Role = %q, want admin", u.Role)
+	}
+}
+
+func TestAccountVerifiedDefaultsFalseAndCanBeSet(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+
+	acc, err := s.CreateAccount(ctx, "Kanzlei Musterfrau")
+	if err != nil {
+		t.Fatalf("CreateAccount: %v", err)
+	}
+	if acc.Verified {
+		t.Fatal("expected a new account to be unverified by default")
+	}
+
+	updated, err := s.SetAccountVerified(ctx, acc.ID, true)
+	if err != nil {
+		t.Fatalf("SetAccountVerified: %v", err)
+	}
+	if !updated.Verified {
+		t.Fatal("expected the account to be verified after SetAccountVerified(true)")
+	}
+
+	got, err := s.GetAccount(ctx, acc.ID)
+	if err != nil {
+		t.Fatalf("GetAccount: %v", err)
+	}
+	if !got.Verified {
+		t.Fatal("expected verified=true to persist")
+	}
+}
+
+func TestSetAccountVerifiedNotFound(t *testing.T) {
+	s := openTestStore(t)
+	_, err := s.SetAccountVerified(context.Background(), "00000000-0000-0000-0000-000000000000", true)
+	if err == nil {
+		t.Fatal("expected an error for an unknown account")
+	}
+}
+
+func TestListAccounts(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+
+	before, err := s.ListAccounts(ctx)
+	if err != nil {
+		t.Fatalf("ListAccounts: %v", err)
+	}
+	acc, err := s.CreateAccount(ctx, "Neuer Mandant fuer ListAccounts")
+	if err != nil {
+		t.Fatalf("CreateAccount: %v", err)
+	}
+
+	after, err := s.ListAccounts(ctx)
+	if err != nil {
+		t.Fatalf("ListAccounts: %v", err)
+	}
+	if len(after) != len(before)+1 {
+		t.Fatalf("expected exactly one more account, got %d -> %d", len(before), len(after))
+	}
+	found := false
+	for _, a := range after {
+		if a.ID == acc.ID {
+			found = true
+		}
+	}
+	if !found {
+		t.Fatal("expected the newly created account in ListAccounts")
+	}
+}
+
+func TestListVerifiedKanzleienRequiresBothVerifiedAndKanzleiRole(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+
+	// Verifiziert, aber kein Kanzlei-Nutzer -> darf nicht auftauchen.
+	verifiedNonKanzlei, err := s.CreateAccount(ctx, "Verifizierte Marke")
+	if err != nil {
+		t.Fatalf("CreateAccount: %v", err)
+	}
+	if _, err := s.CreateUser(ctx, verifiedNonKanzlei.ID, "marke@example.com", "hash", "marke"); err != nil {
+		t.Fatalf("CreateUser: %v", err)
+	}
+	if _, err := s.SetAccountVerified(ctx, verifiedNonKanzlei.ID, true); err != nil {
+		t.Fatalf("SetAccountVerified: %v", err)
+	}
+
+	// Kanzlei-Nutzer, aber nicht verifiziert -> darf nicht auftauchen.
+	unverifiedKanzlei, err := s.CreateAccount(ctx, "Unverifizierte Kanzlei")
+	if err != nil {
+		t.Fatalf("CreateAccount: %v", err)
+	}
+	if _, err := s.CreateUser(ctx, unverifiedKanzlei.ID, "unverifiziert@example.com", "hash", "kanzlei"); err != nil {
+		t.Fatalf("CreateUser: %v", err)
+	}
+
+	// Beides erfuellt -> muss auftauchen.
+	verifiedKanzlei, err := s.CreateAccount(ctx, "Verifizierte Kanzlei")
+	if err != nil {
+		t.Fatalf("CreateAccount: %v", err)
+	}
+	if _, err := s.CreateUser(ctx, verifiedKanzlei.ID, "verifiziert@example.com", "hash", "kanzlei"); err != nil {
+		t.Fatalf("CreateUser: %v", err)
+	}
+	if _, err := s.SetAccountVerified(ctx, verifiedKanzlei.ID, true); err != nil {
+		t.Fatalf("SetAccountVerified: %v", err)
+	}
+
+	list, err := s.ListVerifiedKanzleien(ctx)
+	if err != nil {
+		t.Fatalf("ListVerifiedKanzleien: %v", err)
+	}
+	byID := map[string]bool{}
+	for _, a := range list {
+		byID[a.ID] = true
+	}
+	if byID[verifiedNonKanzlei.ID] {
+		t.Error("verified non-kanzlei account should not appear in the directory")
+	}
+	if byID[unverifiedKanzlei.ID] {
+		t.Error("unverified kanzlei account should not appear in the directory")
+	}
+	if !byID[verifiedKanzlei.ID] {
+		t.Error("expected the verified kanzlei account in the directory")
+	}
+}
+
+func TestListUsersForAccount(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accID := testAccountID(t, s)
+	otherAccID := testAccountID(t, s)
+
+	if _, err := s.CreateUser(ctx, accID, "eins@example.com", "hash", "creator"); err != nil {
+		t.Fatalf("CreateUser: %v", err)
+	}
+	if _, err := s.CreateUser(ctx, accID, "zwei@example.com", "hash", "agentur"); err != nil {
+		t.Fatalf("CreateUser: %v", err)
+	}
+	if _, err := s.CreateUser(ctx, otherAccID, "fremd@example.com", "hash", "marke"); err != nil {
+		t.Fatalf("CreateUser: %v", err)
+	}
+
+	list, err := s.ListUsersForAccount(ctx, accID)
+	if err != nil {
+		t.Fatalf("ListUsersForAccount: %v", err)
+	}
+	if len(list) != 2 {
+		t.Fatalf("expected exactly 2 users for this account, got %d: %+v", len(list), list)
+	}
+}
+
+func TestAuditLogCreateAndList(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accID := testAccountID(t, s)
+	admin, err := s.CreateUser(ctx, accID, "admin-audit@example.com", "hash", "admin")
+	if err != nil {
+		t.Fatalf("CreateUser: %v", err)
+	}
+
+	entry, err := s.CreateAuditEntry(ctx, admin.ID, "account.verified", "account", accID, "manuell freigegeben")
+	if err != nil {
+		t.Fatalf("CreateAuditEntry: %v", err)
+	}
+	if entry.ActorUserID != admin.ID {
+		t.Fatalf("ActorUserID = %q, want %q", entry.ActorUserID, admin.ID)
+	}
+
+	list, err := s.ListAuditLog(ctx, 10)
+	if err != nil {
+		t.Fatalf("ListAuditLog: %v", err)
+	}
+	if len(list) == 0 {
+		t.Fatal("expected at least one audit entry")
+	}
+	if list[0].ID != entry.ID {
+		t.Fatalf("expected the newest entry first, got %+v", list[0])
+	}
+}
+
+func TestAuditLogIsAppendOnly(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accID := testAccountID(t, s)
+	admin, err := s.CreateUser(ctx, accID, "admin-appendonly@example.com", "hash", "admin")
+	if err != nil {
+		t.Fatalf("CreateUser: %v", err)
+	}
+	entry, err := s.CreateAuditEntry(ctx, admin.ID, "account.verified", "account", accID, "")
+	if err != nil {
+		t.Fatalf("CreateAuditEntry: %v", err)
+	}
+
+	_, err = s.Pool.Exec(ctx, `UPDATE audit_log SET action = 'geaendert' WHERE id = $1`, entry.ID)
+	if err == nil {
+		t.Fatal("expected UPDATE on audit_log to be rejected by the append-only trigger")
+	}
+	_, err = s.Pool.Exec(ctx, `DELETE FROM audit_log WHERE id = $1`, entry.ID)
+	if err == nil {
+		t.Fatal("expected DELETE on audit_log to be rejected by the append-only trigger")
+	}
+}
--- a/internal/store/auditlog.go
+++ b/internal/store/auditlog.go
@@ -0,0 +1,61 @@
+package store
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+// AuditEntry ist ein Protokolleintrag einer Admin-Aktion. Append-only:
+// siehe Migration 0004 — ein Protokoll, das man ändern kann, ist kein
+// Nachweis mehr, aus demselben Grund wie bei finding/extraction.
+type AuditEntry struct {
+	ID          string
+	ActorUserID string
+	Action      string
+	TargetType  string
+	TargetID    string
+	Details     string
+	CreatedAt   time.Time
+}
+
+// CreateAuditEntry protokolliert eine Admin-Aktion.
+func (s *Store) CreateAuditEntry(ctx context.Context, actorUserID, action, targetType, targetID, details string) (AuditEntry, error) {
+	var e AuditEntry
+	err := s.Pool.QueryRow(ctx, `
+		INSERT INTO audit_log (actor_user_id, action, target_type, target_id, details)
+		VALUES ($1, $2, $3, $4, $5)
+		RETURNING id, actor_user_id, action, target_type, target_id, details, created_at
+	`, actorUserID, action, targetType, targetID, details).Scan(
+		&e.ID, &e.ActorUserID, &e.Action, &e.TargetType, &e.TargetID, &e.Details, &e.CreatedAt,
+	)
+	if err != nil {
+		return AuditEntry{}, fmt.Errorf("store: create audit entry: %w", err)
+	}
+	return e, nil
+}
+
+// ListAuditLog liefert die letzten Protokolleinträge, neueste zuerst.
+func (s *Store) ListAuditLog(ctx context.Context, limit int) ([]AuditEntry, error) {
+	rows, err := s.Pool.Query(ctx, `
+		SELECT id, actor_user_id, action, target_type, target_id, details, created_at
+		FROM audit_log ORDER BY created_at DESC LIMIT $1
+	`, limit)
+	if err != nil {
+		return nil, fmt.Errorf("store: list audit log: %w", err)
+	}
+	defer rows.Close()
+
+	var out []AuditEntry
+	for rows.Next() {
+		var e AuditEntry
+		if err := rows.Scan(&e.ID, &e.ActorUserID, &e.Action, &e.TargetType, &e.TargetID, &e.Details, &e.CreatedAt); err != nil {
+			return nil, fmt.Errorf("store: scan audit entry: %w", err)
+		}
+		out = append(out, e)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("store: list audit log: %w", err)
+	}
+	return out, nil
+}
--- a/internal/store/migrations/0004_admin.down.sql
+++ b/internal/store/migrations/0004_admin.down.sql
@@ -0,0 +1,6 @@
+DROP TRIGGER audit_log_append_only ON audit_log;
+DROP TABLE audit_log;
+ALTER TABLE account DROP COLUMN verified;
+ALTER TABLE app_user DROP CONSTRAINT app_user_role_check;
+ALTER TABLE app_user ADD CONSTRAINT app_user_role_check
+    CHECK (role IN ('creator', 'agentur', 'marke', 'kanzlei'));
--- a/internal/store/migrations/0004_admin.up.sql
+++ b/internal/store/migrations/0004_admin.up.sql
@@ -0,0 +1,36 @@
+-- "admin" ist eine fünfte app_user-Rolle: Betreiber-Personal (Netcell-IT),
+-- nicht an einen Mandanten-Geschäftszweck (creator/agentur/marke/kanzlei)
+-- gebunden, sondern zuständig für die Plattform selbst (Accounts,
+-- Kanzlei-Verzeichnis, Audit-Log). Bewusst KEIN eigenes account_role-Feld
+-- getrennt von app_user.role — ein Admin-Login ist genauso ein app_user
+-- wie jeder andere, nur mit einer anderen Rolle. Es gibt bewusst keine
+-- Selbstregistrierung für "admin" über /register (siehe internal/web) —
+-- der erste Admin wird per SQL angelegt (siehe CLAUDE.md).
+ALTER TABLE app_user DROP CONSTRAINT app_user_role_check;
+ALTER TABLE app_user ADD CONSTRAINT app_user_role_check
+    CHECK (role IN ('creator', 'agentur', 'marke', 'kanzlei', 'admin'));
+
+-- verified markiert eine Kanzlei-Account als für das öffentliche,
+-- kostenlose Kanzlei-Verzeichnis freigegeben (siehe CLAUDE.md, § 49b
+-- Abs. 3 BRAO: keine Sachvorteile, kein Routing — das Verzeichnis ist
+-- eine reine Auflistung, keine Vermittlung). Nur für Accounts mit
+-- mindestens einem Nutzer der Rolle "kanzlei" sinnvoll; das erzwingt die
+-- Anwendungsschicht, nicht die Datenbank.
+ALTER TABLE account ADD COLUMN verified BOOLEAN NOT NULL DEFAULT false;
+
+-- Audit-Log für Admin-Aktionen: append-only aus demselben Grund wie
+-- finding/extraction/evidence_package — ein Protokoll, das man ändern
+-- kann, ist kein Nachweis mehr.
+CREATE TABLE audit_log (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    actor_user_id UUID NOT NULL REFERENCES app_user (id),
+    action TEXT NOT NULL,
+    target_type TEXT NOT NULL,
+    target_id TEXT NOT NULL,
+    details TEXT NOT NULL DEFAULT '',
+    created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
+CREATE TRIGGER audit_log_append_only
+    BEFORE UPDATE OR DELETE ON audit_log
+    FOR EACH ROW EXECUTE FUNCTION forbid_update_delete();
--- a/internal/store/user.go
+++ b/internal/store/user.go
@@ -75,3 +75,29 @@ func (s *Store) GetUser(ctx context.Context, id string) (User, error) {
 	}
 	return u, nil
 }
+
+// ListUsersForAccount liefert alle Logins eines Mandanten — für den
+// Admin-Bereich (Account-Detailansicht).
+func (s *Store) ListUsersForAccount(ctx context.Context, accountID string) ([]User, error) {
+	rows, err := s.Pool.Query(ctx, `
+		SELECT id, account_id, email, password_hash, role, created_at
+		FROM app_user WHERE account_id = $1 ORDER BY created_at
+	`, accountID)
+	if err != nil {
+		return nil, fmt.Errorf("store: list users for account: %w", err)
+	}
+	defer rows.Close()
+
+	var out []User
+	for rows.Next() {
+		var u User
+		if err := rows.Scan(&u.ID, &u.AccountID, &u.Email, &u.PasswordHash, &u.Role, &u.CreatedAt); err != nil {
+			return nil, fmt.Errorf("store: scan user: %w", err)
+		}
+		out = append(out, u)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, fmt.Errorf("store: list users for account: %w", err)
+	}
+	return out, nil
+}