feat: Werkzeugkatalog-Pflege für die Plattform (Ebene 5)

Betreiber können den zentralen Werkzeugkatalog jetzt über die UI
pflegen (GET /betreiber/werkzeuge, GET/POST .../neu, GET/POST
.../{id}, POST .../{id}/loeschen) statt nur per SQL. Bearbeitet
ausschließlich zentrale (account_id IS NULL) Einträge — ein
mandantenspezifischer Katalogeintrag bleibt über diese Seiten
unerreichbar (404), das ist weiterhin Sache des jeweiligen Mandanten.
Ohne befüllten Katalog konnte bisher keine Bewertung tatsächlich zu
"genehmigt" mit einem echten Werkzeug führen.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

CLAUDE.md

@@ -72,6 +72,21 @@ ist der Nachfolger dessen, was früher (vor dem Produktwechsel)
 Rechte werden **als Prüfung an jeder Aktion** durchgesetzt (Middleware
 je Handler), nicht als grob unterschiedene Seitenbereiche.
 
+**Ebene 4 — Nutzerverwaltung ist umgesetzt** (`internal/web/admin_handlers.go`,
+Middleware `requireAdmin`): `GET /verwaltung/nutzer` listet alle Logins
+des eigenen Mandanten, `GET/POST /verwaltung/nutzer/neu` legt einen
+weiteren Login mit einer der vier Mandanten-Rollen an (`mitarbeiter`,
+`verantwortlicher`, `pruefer`, `admin` — `betreiber` kann kein
+Mandanten-Admin vergeben, das ist Ebene 5). Es gibt noch **keine**
+Einladungsmail — der Admin setzt das Initialpasswort direkt im
+Formular und gibt es auf einem anderen Weg weiter (konsistent mit dem
+Onboarding-Stand unten: Einladungslink/CSV-Import/SSO sind noch nicht
+gebaut). Das schließt die Lücke, dass Ebene 3 (Fachebene) bisher nur
+über einen manuellen SQL-Insert nutzbar war, weil die Firma-
+Registrierung ausschließlich einen `admin`-Nutzer erzeugt. Abteilungen-
+Verwaltung, Anmeldeverfahren, eigene Werkzeug-Freigaben/-Sperrungen und
+Rechnungsdaten (Ebene 4 laut Tabelle oben) sind weiterhin nicht gebaut.
+
 **Mandantenfähigkeit:** jede Tabelle trägt `account_id`. Aktuell wird
 Isolation in der Anwendungsschicht erzwungen (Handler vergleichen
 `AccountID` gegen den angemeldeten Account, wie bisher) — die
@@ -610,7 +625,15 @@ journalctl -u deklarix -f
   hat; `app_user.role` ist aktuell ein einzelner Wert. Muss geklärt
   werden: zwei Rollen pro Nutzer zulassen (Datenmodell-Änderung) oder
   zwei `app_user`-Zeilen für dieselbe Person?
-- **Zentraler Werkzeugkatalog ist leer** — "Werkzeugkatalog aus der
+- **Zentraler Werkzeugkatalog muss noch befüllt werden** — die
-  Plattform vorbelegt" beim Onboarding ist nicht automatisiert, es gibt
+  Ebene-5/Betreiber-UI zur Katalogpflege ist jetzt gebaut (`GET
-  noch keine Ebene-5/Betreiber-UI zur Katalogpflege.
+  /betreiber/werkzeuge` Liste, `GET/POST /betreiber/werkzeuge/neu`
+  anlegen, `GET/POST /betreiber/werkzeuge/{id}` bearbeiten, `POST
+  .../loeschen` löschen — siehe `internal/web/betreiber_werkzeug_handlers.go`.
+  Bearbeitet ausschließlich `account_id IS NULL`-Einträge, ein
+  mandantenspezifischer Eintrag ist über diese Seiten nicht erreichbar
+  [404]). "Werkzeugkatalog aus der Plattform vorbelegt" beim Firma-
+  Onboarding bleibt trotzdem nicht automatisiert — der Katalog ist
+  inhaltlich weiterhin leer, bis der Betreiber tatsächlich Einträge
+  pflegt.
 - Markenanmeldung Deklarix, sobald erster Kunde zahlt.

internal/web/admin_handlers.go

@@ -0,0 +1,108 @@
+// Ebene 4 (Mandanten-Verwaltung) — Nutzer/Rollen für GENAU EINEN
+// Mandanten, siehe CLAUDE.md, Fünf Ebenen. Aktuell nur Nutzerverwaltung
+// (Abteilungen, Anmeldeverfahren, Werkzeug-Freigaben, Rechnungsdaten
+// sind spätere Ausbaustufen). Es gibt noch keinen Einladungslink/CSV-
+// Import/SSO (siehe CLAUDE.md, Onboarding) — ein Admin setzt hier
+// direkt ein Initialpasswort, wie schon bei der Firma-Registrierung.
+package web
+
+import (
+	"net/http"
+
+	"github.com/netcell-it/deklarix/internal/auth"
+)
+
+// mandantenRollen sind die Rollen, die ein Admin innerhalb des eigenen
+// Mandanten vergeben darf — "betreiber" ist Ebene 5 (Plattform) und
+// kann von keinem Mandanten-Admin vergeben werden.
+var mandantenRollen = []string{"mitarbeiter", "verantwortlicher", "pruefer", "admin"}
+
+func istMandantenRolle(role string) bool {
+	for _, r := range mandantenRollen {
+		if r == role {
+			return true
+		}
+	}
+	return false
+}
+
+type nutzerListItem struct {
+	Email string
+	Role  string
+}
+
+type nutzerListeData struct {
+	Title  string
+	Nav    navData
+	Nutzer []nutzerListItem
+}
+
+// handleNutzerListe zeigt alle Logins des eigenen Mandanten.
+func (s *Server) handleNutzerListe(w http.ResponseWriter, r *http.Request) {
+	users, err := s.store.ListUsersForAccount(r.Context(), currentUser(r).AccountID)
+	if err != nil {
+		http.Error(w, "Nutzer konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	data := nutzerListeData{Title: "Nutzerverwaltung", Nav: navFor(r)}
+	for _, u := range users {
+		data.Nutzer = append(data.Nutzer, nutzerListItem{Email: u.Email, Role: u.Role})
+	}
+	if err := s.templates.ExecuteTemplate(w, "nutzer-liste", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+type nutzerNeuData struct {
+	Title  string
+	Nav    navData
+	Rollen []string
+	Error  string
+}
+
+func (s *Server) handleNutzerNeuForm(w http.ResponseWriter, r *http.Request) {
+	data := nutzerNeuData{Title: "Nutzer anlegen", Nav: navFor(r), Rollen: mandantenRollen}
+	if err := s.templates.ExecuteTemplate(w, "nutzer-neu", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+// handleNutzerCreate legt einen weiteren Login im eigenen Mandanten an.
+// Es gibt keine Einladungsmail (siehe CLAUDE.md, Onboarding — noch
+// nicht gebaut) — der Admin setzt das Initialpasswort direkt und gibt
+// es dem/der neuen Nutzer:in auf einem anderen Weg weiter.
+func (s *Server) handleNutzerCreate(w http.ResponseWriter, r *http.Request) {
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "ungültiges Formular", http.StatusBadRequest)
+		return
+	}
+	email := r.FormValue("email")
+	password := r.FormValue("password")
+	role := r.FormValue("role")
+	if email == "" || password == "" || !istMandantenRolle(role) {
+		data := nutzerNeuData{Title: "Nutzer anlegen", Nav: navFor(r), Rollen: mandantenRollen, Error: "E-Mail, Passwort und eine gültige Rolle sind Pflicht"}
+		if err := s.templates.ExecuteTemplate(w, "nutzer-neu", data); err != nil {
+			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+		}
+		return
+	}
+
+	passwordHash, err := auth.HashPassword(password)
+	if err != nil {
+		data := nutzerNeuData{Title: "Nutzer anlegen", Nav: navFor(r), Rollen: mandantenRollen, Error: err.Error()}
+		if err := s.templates.ExecuteTemplate(w, "nutzer-neu", data); err != nil {
+			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+		}
+		return
+	}
+
+	if _, err := s.store.CreateUser(r.Context(), currentUser(r).AccountID, email, passwordHash, role); err != nil {
+		data := nutzerNeuData{Title: "Nutzer anlegen", Nav: navFor(r), Rollen: mandantenRollen, Error: "Nutzer konnte nicht angelegt werden — E-Mail evtl. schon vergeben"}
+		if err := s.templates.ExecuteTemplate(w, "nutzer-neu", data); err != nil {
+			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+		}
+		return
+	}
+
+	http.Redirect(w, r, "/verwaltung/nutzer", http.StatusSeeOther)
+}

internal/web/admin_handlers_test.go

@@ -0,0 +1,75 @@
+package web_test
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+	"strings"
+	"testing"
+)
+
+func TestMitarbeiterCannotAccessNutzerverwaltung(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	cookie := seedAccountWithRole(t, fs, "Test-Mandant", "mitarbeiter@example.com", "mitarbeiter")
+
+	resp := getWithCookie(t, s, cookie, "/verwaltung/nutzer")
+	if resp.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404 for role mitarbeiter on /verwaltung/nutzer", resp.Code)
+	}
+}
+
+func TestAdminCanCreateUserWithMandantenRolle(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminCookie := seedAccountWithRole(t, fs, "Test-Mandant", "admin@example.com", "admin")
+
+	resp := postForm(t, s, adminCookie, "/verwaltung/nutzer", url.Values{
+		"email": {"neu@example.com"}, "password": {"ein-langes-passwort"}, "role": {"verantwortlicher"},
+	})
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("status = %d, want 303, body: %s", resp.Code, resp.Body.String())
+	}
+
+	u, err := fs.GetUserByEmail(context.Background(), "neu@example.com")
+	if err != nil {
+		t.Fatalf("GetUserByEmail: %v", err)
+	}
+	if u.Role != "verantwortlicher" {
+		t.Errorf("Role = %q, want verantwortlicher", u.Role)
+	}
+
+	list := getWithCookie(t, s, adminCookie, "/verwaltung/nutzer")
+	if !strings.Contains(list.Body.String(), "neu@example.com") {
+		t.Errorf("expected the new user in the Nutzerliste, got: %s", list.Body.String())
+	}
+}
+
+func TestAdminCannotCreateBetreiberUser(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminCookie := seedAccountWithRole(t, fs, "Test-Mandant", "admin@example.com", "admin")
+
+	resp := postForm(t, s, adminCookie, "/verwaltung/nutzer", url.Values{
+		"email": {"versuch@example.com"}, "password": {"ein-langes-passwort"}, "role": {"betreiber"},
+	})
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200 (Formular mit Fehler) for role betreiber", resp.Code)
+	}
+	if _, err := fs.GetUserByEmail(context.Background(), "versuch@example.com"); err == nil {
+		t.Error("expected no user to be created for an invalid role")
+	}
+}
+
+func TestAdminCreateUserRejectsDuplicateEmail(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	adminCookie := seedAccountWithRole(t, fs, "Test-Mandant", "admin@example.com", "admin")
+
+	resp := postForm(t, s, adminCookie, "/verwaltung/nutzer", url.Values{
+		"email": {"admin@example.com"}, "password": {"ein-langes-passwort"}, "role": {"mitarbeiter"},
+	})
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200 (Formular mit Fehler) for duplicate email", resp.Code)
+	}
+}

internal/web/betreiber_handlers.go

@@ -8,6 +8,7 @@ type betreiberDashboardData struct {
 	Title            string
 	Nav              navData
 	AccountCount     int
+	WerkzeugCount    int
 	RecentAuditCount int
 }
 
@@ -21,6 +22,11 @@ func (s *Server) handleBetreiberDashboard(w http.ResponseWriter, r *http.Request
 		http.Error(w, "Accounts konnten nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
+	werkzeuge, err := s.store.ListZentraleWerkzeuge(ctx)
+	if err != nil {
+		http.Error(w, "Werkzeugkatalog konnte nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
 	auditLog, err := s.store.ListAuditLog(ctx, 5)
 	if err != nil {
 		http.Error(w, "Audit-Log konnte nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
@@ -28,7 +34,8 @@ func (s *Server) handleBetreiberDashboard(w http.ResponseWriter, r *http.Request
 	}
 
 	data := betreiberDashboardData{
-		Title: "Plattform", Nav: navFor(r), AccountCount: len(accounts), RecentAuditCount: len(auditLog),
+		Title: "Plattform", Nav: navFor(r), AccountCount: len(accounts),
+		WerkzeugCount: len(werkzeuge), RecentAuditCount: len(auditLog),
 	}
 	if err := s.templates.ExecuteTemplate(w, "betreiber-dashboard", data); err != nil {
 		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)

internal/web/betreiber_werkzeug_handlers.go

@@ -0,0 +1,250 @@
+// Ebene 5 (Plattform) — Pflege des zentralen Werkzeugkatalogs
+// (`werkzeug.account_id IS NULL`). Mandantenspezifische Ergänzungen
+// (`account_id` gesetzt) sind NICHT Teil dieser Seiten — die bleiben
+// Sache des jeweiligen Mandanten (Ebene 4, "eigene Werkzeug-
+// Freigaben/-Sperrungen", noch nicht gebaut), siehe CLAUDE.md.
+package web
+
+import (
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/netcell-it/deklarix/internal/store"
+)
+
+var gueltigeVerarbeitungsorte = []string{"EU", "USA", "gemischt", "on-prem"}
+
+func istGueltigerVerarbeitungsort(v string) bool {
+	for _, o := range gueltigeVerarbeitungsorte {
+		if o == v {
+			return true
+		}
+	}
+	return false
+}
+
+// splitListe zerlegt ein kommasepariertes Formularfeld (Zertifizierungen,
+// geeignete Zwecke, Einschränkungen) in eine bereinigte Liste — ohne
+// führende/folgende Leerzeichen und ohne leere Einträge.
+func splitListe(s string) []string {
+	var out []string
+	for _, part := range strings.Split(s, ",") {
+		part = strings.TrimSpace(part)
+		if part != "" {
+			out = append(out, part)
+		}
+	}
+	return out
+}
+
+type werkzeugListItem struct {
+	ID               string
+	Name             string
+	Anbieter         string
+	Verarbeitungsort string
+	LetztePruefung   string
+}
+
+type werkzeugListeData struct {
+	Title     string
+	Nav       navData
+	Werkzeuge []werkzeugListItem
+}
+
+// handleBetreiberWerkzeugListe zeigt den zentralen Katalog.
+func (s *Server) handleBetreiberWerkzeugListe(w http.ResponseWriter, r *http.Request) {
+	werkzeuge, err := s.store.ListZentraleWerkzeuge(r.Context())
+	if err != nil {
+		http.Error(w, "Werkzeugkatalog konnte nicht geladen werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	data := werkzeugListeData{Title: "Werkzeugkatalog", Nav: navFor(r)}
+	for _, wz := range werkzeuge {
+		data.Werkzeuge = append(data.Werkzeuge, werkzeugListItem{
+			ID: wz.ID, Name: wz.Name, Anbieter: wz.Anbieter, Verarbeitungsort: wz.Verarbeitungsort,
+			LetztePruefung: wz.LetztePruefung.Format("02.01.2006"),
+		})
+	}
+	if err := s.templates.ExecuteTemplate(w, "betreiber-werkzeuge", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+type werkzeugFormData struct {
+	Title             string
+	Nav               navData
+	ID                string // leer bei "neu"
+	Name              string
+	Anbieter          string
+	Verarbeitungsorte []string
+	Verarbeitungsort  string
+	AVVVerfuegbar     bool
+	AVVURL            string
+	TrainingOptOut    bool
+	TrainingStandard  bool
+	AufbewahrungTage  int
+	Zertifizierungen  string
+	GeeigneteZwecke   string
+	Einschraenkungen  string
+	LetztePruefung    string
+	Quelle            string
+	Error             string
+}
+
+func (s *Server) handleBetreiberWerkzeugNeuForm(w http.ResponseWriter, r *http.Request) {
+	data := werkzeugFormData{Title: "Werkzeug anlegen", Nav: navFor(r), Verarbeitungsorte: gueltigeVerarbeitungsorte}
+	if err := s.templates.ExecuteTemplate(w, "betreiber-werkzeug-form", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+// werkzeugInputFromForm liest ein WerkzeugInput aus dem Formular.
+// AccountID ist immer nil — diese Seiten pflegen ausschließlich den
+// zentralen Katalog.
+func werkzeugInputFromForm(r *http.Request) (store.WerkzeugInput, string) {
+	letztePruefung, err := time.Parse("2006-01-02", r.FormValue("letzte_pruefung"))
+	if err != nil {
+		return store.WerkzeugInput{}, "Datum der letzten Prüfung ist ungültig oder fehlt"
+	}
+	verarbeitungsort := r.FormValue("verarbeitungsort")
+	if !istGueltigerVerarbeitungsort(verarbeitungsort) {
+		return store.WerkzeugInput{}, "ungültiger Verarbeitungsort"
+	}
+	name := r.FormValue("name")
+	anbieter := r.FormValue("anbieter")
+	quelle := r.FormValue("quelle")
+	if name == "" || anbieter == "" || quelle == "" {
+		return store.WerkzeugInput{}, "Name, Anbieter und Quelle sind Pflicht"
+	}
+	aufbewahrungTage, _ := strconv.Atoi(r.FormValue("aufbewahrung_tage"))
+
+	return store.WerkzeugInput{
+		AccountID:        nil,
+		Name:             name,
+		Anbieter:         anbieter,
+		Verarbeitungsort: verarbeitungsort,
+		AVVVerfuegbar:    r.FormValue("avv_verfuegbar") == "on",
+		AVVURL:           r.FormValue("avv_url"),
+		TrainingOptOut:   r.FormValue("training_opt_out") == "on",
+		TrainingStandard: r.FormValue("training_standard") == "on",
+		AufbewahrungTage: aufbewahrungTage,
+		Zertifizierungen: splitListe(r.FormValue("zertifizierungen")),
+		GeeigneteZwecke:  splitListe(r.FormValue("geeignete_zwecke")),
+		Einschraenkungen: splitListe(r.FormValue("einschraenkungen")),
+		LetztePruefung:   letztePruefung,
+		Quelle:           quelle,
+	}, ""
+}
+
+// formDataFromForm baut die Formular-Daten für eine erneute Anzeige bei
+// einem Validierungsfehler — die Eingaben des Nutzers bleiben erhalten,
+// statt das Formular zu leeren.
+func werkzeugFormDataFromRequest(r *http.Request, title, id, errMsg string) werkzeugFormData {
+	return werkzeugFormData{
+		Title: title, Nav: navFor(r), ID: id, Verarbeitungsorte: gueltigeVerarbeitungsorte,
+		Name: r.FormValue("name"), Anbieter: r.FormValue("anbieter"), Verarbeitungsort: r.FormValue("verarbeitungsort"),
+		AVVVerfuegbar: r.FormValue("avv_verfuegbar") == "on", AVVURL: r.FormValue("avv_url"),
+		TrainingOptOut: r.FormValue("training_opt_out") == "on", TrainingStandard: r.FormValue("training_standard") == "on",
+		Zertifizierungen: r.FormValue("zertifizierungen"), GeeigneteZwecke: r.FormValue("geeignete_zwecke"),
+		Einschraenkungen: r.FormValue("einschraenkungen"), LetztePruefung: r.FormValue("letzte_pruefung"),
+		Quelle: r.FormValue("quelle"), Error: errMsg,
+	}
+}
+
+// handleBetreiberWerkzeugCreate legt einen zentralen Katalogeintrag an.
+func (s *Server) handleBetreiberWerkzeugCreate(w http.ResponseWriter, r *http.Request) {
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "ungültiges Formular", http.StatusBadRequest)
+		return
+	}
+	in, errMsg := werkzeugInputFromForm(r)
+	if errMsg != "" {
+		data := werkzeugFormDataFromRequest(r, "Werkzeug anlegen", "", errMsg)
+		if err := s.templates.ExecuteTemplate(w, "betreiber-werkzeug-form", data); err != nil {
+			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+		}
+		return
+	}
+	if _, err := s.store.CreateWerkzeug(r.Context(), in); err != nil {
+		data := werkzeugFormDataFromRequest(r, "Werkzeug anlegen", "", "Werkzeug konnte nicht angelegt werden: "+err.Error())
+		if err := s.templates.ExecuteTemplate(w, "betreiber-werkzeug-form", data); err != nil {
+			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+		}
+		return
+	}
+	http.Redirect(w, r, "/betreiber/werkzeuge", http.StatusSeeOther)
+}
+
+// handleBetreiberWerkzeugEditForm zeigt einen zentralen Katalogeintrag
+// zum Bearbeiten. Ein mandantenspezifischer Eintrag (account_id
+// gesetzt) ist hier bewusst nicht erreichbar — das ist Sache des
+// jeweiligen Mandanten, nicht der Plattform.
+func (s *Server) handleBetreiberWerkzeugEditForm(w http.ResponseWriter, r *http.Request) {
+	wz, err := s.store.GetWerkzeug(r.Context(), r.PathValue("id"))
+	if err != nil || wz.AccountID != nil {
+		http.Error(w, "Werkzeug nicht gefunden", http.StatusNotFound)
+		return
+	}
+	data := werkzeugFormData{
+		Title: "Werkzeug bearbeiten", Nav: navFor(r), ID: wz.ID, Verarbeitungsorte: gueltigeVerarbeitungsorte,
+		Name: wz.Name, Anbieter: wz.Anbieter, Verarbeitungsort: wz.Verarbeitungsort,
+		AVVVerfuegbar: wz.AVVVerfuegbar, AVVURL: wz.AVVURL,
+		TrainingOptOut: wz.TrainingOptOut, TrainingStandard: wz.TrainingStandard, AufbewahrungTage: wz.AufbewahrungTage,
+		Zertifizierungen: strings.Join(wz.Zertifizierungen, ", "), GeeigneteZwecke: strings.Join(wz.GeeigneteZwecke, ", "),
+		Einschraenkungen: strings.Join(wz.Einschraenkungen, ", "), LetztePruefung: wz.LetztePruefung.Format("2006-01-02"),
+		Quelle: wz.Quelle,
+	}
+	if err := s.templates.ExecuteTemplate(w, "betreiber-werkzeug-form", data); err != nil {
+		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+	}
+}
+
+// handleBetreiberWerkzeugUpdate speichert Änderungen an einem zentralen
+// Katalogeintrag. Werkzeug ist nicht append-only (siehe store.UpdateWerkzeug)
+// — eine bereits getroffene Entscheidung hält ihren eigenen, zum
+// Entscheidungszeitpunkt eingefrorenen Snapshot (entscheidung.werkzeug_snapshot).
+func (s *Server) handleBetreiberWerkzeugUpdate(w http.ResponseWriter, r *http.Request) {
+	id := r.PathValue("id")
+	wz, err := s.store.GetWerkzeug(r.Context(), id)
+	if err != nil || wz.AccountID != nil {
+		http.Error(w, "Werkzeug nicht gefunden", http.StatusNotFound)
+		return
+	}
+	if err := r.ParseForm(); err != nil {
+		http.Error(w, "ungültiges Formular", http.StatusBadRequest)
+		return
+	}
+	in, errMsg := werkzeugInputFromForm(r)
+	if errMsg != "" {
+		data := werkzeugFormDataFromRequest(r, "Werkzeug bearbeiten", id, errMsg)
+		if err := s.templates.ExecuteTemplate(w, "betreiber-werkzeug-form", data); err != nil {
+			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+		}
+		return
+	}
+	if _, err := s.store.UpdateWerkzeug(r.Context(), id, in); err != nil {
+		data := werkzeugFormDataFromRequest(r, "Werkzeug bearbeiten", id, "Werkzeug konnte nicht gespeichert werden: "+err.Error())
+		if err := s.templates.ExecuteTemplate(w, "betreiber-werkzeug-form", data); err != nil {
+			http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
+		}
+		return
+	}
+	http.Redirect(w, r, "/betreiber/werkzeuge", http.StatusSeeOther)
+}
+
+// handleBetreiberWerkzeugDelete entfernt einen zentralen Katalogeintrag.
+func (s *Server) handleBetreiberWerkzeugDelete(w http.ResponseWriter, r *http.Request) {
+	id := r.PathValue("id")
+	wz, err := s.store.GetWerkzeug(r.Context(), id)
+	if err != nil || wz.AccountID != nil {
+		http.Error(w, "Werkzeug nicht gefunden", http.StatusNotFound)
+		return
+	}
+	if err := s.store.DeleteWerkzeug(r.Context(), id); err != nil {
+		http.Error(w, "Werkzeug konnte nicht gelöscht werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	http.Redirect(w, r, "/betreiber/werkzeuge", http.StatusSeeOther)
+}

internal/web/betreiber_werkzeug_handlers_test.go

@@ -0,0 +1,118 @@
+package web_test
+
+import (
+	"context"
+	"net/http"
+	"net/url"
+	"strings"
+	"testing"
+
+	"github.com/netcell-it/deklarix/internal/store"
+)
+
+func werkzeugForm() url.Values {
+	return url.Values{
+		"name": {"ChatGPT Enterprise"}, "anbieter": {"OpenAI"}, "verarbeitungsort": {"EU"},
+		"avv_verfuegbar": {"on"}, "avv_url": {"https://example.com/avv"},
+		"training_opt_out": {"on"}, "training_standard": {"on"}, "aufbewahrung_tage": {"30"},
+		"zertifizierungen": {"ISO 27001, SOC 2"}, "geeignete_zwecke": {"Textgenerierung"},
+		"einschraenkungen": {""}, "letzte_pruefung": {"2026-08-01"}, "quelle": {"https://example.com/beleg"},
+	}
+}
+
+func TestBetreiberCanCreateZentralesWerkzeug(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	betreiberCookie := seedAccountWithRole(t, fs, "Deklarix Betreiber", "betreiber@example.com", "betreiber")
+
+	resp := postForm(t, s, betreiberCookie, "/betreiber/werkzeuge", werkzeugForm())
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("status = %d, want 303, body: %s", resp.Code, resp.Body.String())
+	}
+
+	var w store.Werkzeug
+	for _, wz := range fs.werkzeuge {
+		w = wz
+	}
+	if w.Name != "ChatGPT Enterprise" || w.AccountID != nil {
+		t.Fatalf("Werkzeug = %+v, unerwartete Werte", w)
+	}
+	if len(w.Zertifizierungen) != 2 {
+		t.Errorf("Zertifizierungen = %v, want 2 Einträge", w.Zertifizierungen)
+	}
+
+	list := getWithCookie(t, s, betreiberCookie, "/betreiber/werkzeuge")
+	if !strings.Contains(list.Body.String(), "ChatGPT Enterprise") {
+		t.Errorf("expected the new werkzeug in the Katalogliste, got: %s", list.Body.String())
+	}
+}
+
+func TestBetreiberWerkzeugCreateRequiresLetztePruefungUndQuelle(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	betreiberCookie := seedAccountWithRole(t, fs, "Deklarix Betreiber", "betreiber@example.com", "betreiber")
+
+	form := werkzeugForm()
+	form.Set("letzte_pruefung", "")
+	resp := postForm(t, s, betreiberCookie, "/betreiber/werkzeuge", form)
+	if resp.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200 (Formular mit Fehler) ohne letzte_pruefung", resp.Code)
+	}
+	if len(fs.werkzeuge) != 0 {
+		t.Errorf("expected no werkzeug to be created, got %d", len(fs.werkzeuge))
+	}
+}
+
+func TestBetreiberCanUpdateAndDeleteZentralesWerkzeug(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	betreiberCookie := seedAccountWithRole(t, fs, "Deklarix Betreiber", "betreiber@example.com", "betreiber")
+	postForm(t, s, betreiberCookie, "/betreiber/werkzeuge", werkzeugForm())
+	var id string
+	for wid := range fs.werkzeuge {
+		id = wid
+	}
+
+	editResp := getWithCookie(t, s, betreiberCookie, "/betreiber/werkzeuge/"+id)
+	if editResp.Code != http.StatusOK || !strings.Contains(editResp.Body.String(), "ChatGPT Enterprise") {
+		t.Fatalf("edit form status = %d, body: %s", editResp.Code, editResp.Body.String())
+	}
+
+	updateForm := werkzeugForm()
+	updateForm.Set("name", "ChatGPT Enterprise (aktualisiert)")
+	updateResp := postForm(t, s, betreiberCookie, "/betreiber/werkzeuge/"+id, updateForm)
+	if updateResp.Code != http.StatusSeeOther {
+		t.Fatalf("update status = %d, body: %s", updateResp.Code, updateResp.Body.String())
+	}
+	if fs.werkzeuge[id].Name != "ChatGPT Enterprise (aktualisiert)" {
+		t.Errorf("Name = %q nach Update, unerwartet", fs.werkzeuge[id].Name)
+	}
+
+	deleteResp := postForm(t, s, betreiberCookie, "/betreiber/werkzeuge/"+id+"/loeschen", url.Values{})
+	if deleteResp.Code != http.StatusSeeOther {
+		t.Fatalf("delete status = %d, body: %s", deleteResp.Code, deleteResp.Body.String())
+	}
+	if _, ok := fs.werkzeuge[id]; ok {
+		t.Error("expected the werkzeug to be deleted")
+	}
+}
+
+// TestBetreiberCannotEditMandantenEigenesWerkzeug: ein mandantenspezifischer
+// Katalogeintrag (account_id gesetzt) ist über die Betreiber-Seiten
+// nicht erreichbar — das bleibt Sache des jeweiligen Mandanten.
+func TestBetreiberCannotEditMandantenEigenesWerkzeug(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	betreiberCookie := seedAccountWithRole(t, fs, "Deklarix Betreiber", "betreiber@example.com", "betreiber")
+	acc, err := fs.CreateAccount(context.Background(), "Mandant mit eigenem Werkzeug")
+	if err != nil {
+		t.Fatalf("CreateAccount: %v", err)
+	}
+	eigenesID := "eigenes-werkzeug"
+	fs.werkzeuge[eigenesID] = store.Werkzeug{ID: eigenesID, AccountID: &acc.ID, Name: "Mandanten-eigenes Tool"}
+
+	resp := getWithCookie(t, s, betreiberCookie, "/betreiber/werkzeuge/"+eigenesID)
+	if resp.Code != http.StatusNotFound {
+		t.Fatalf("status = %d, want 404 for a mandanten-eigenes werkzeug", resp.Code)
+	}
+}

internal/web/middleware.go

@@ -112,6 +112,24 @@ func (s *Server) requireFachebene(next http.HandlerFunc) http.HandlerFunc {
 	}
 }
 
+// requireAdmin schützt die Mandanten-Verwaltung (Ebene 4 — Nutzer/
+// Rollen für GENAU EINEN Mandanten, siehe CLAUDE.md). Wie bei
+// requireBetreiber/requireFachebene: 404 statt 403 bei falscher Rolle.
+func (s *Server) requireAdmin(next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		user, ok := s.authenticate(r)
+		if !ok {
+			http.Redirect(w, r, "/login", http.StatusSeeOther)
+			return
+		}
+		if user.Role != "admin" {
+			http.Error(w, "nicht gefunden", http.StatusNotFound)
+			return
+		}
+		next(w, r.WithContext(context.WithValue(r.Context(), userContextKey, user)))
+	}
+}
+
 // navData steuert die gemeinsame Navigation (layout.html, "nav"-Block).
 // Eigenes, kleines Struct statt jeder Seite Zugriff auf den vollen
 // currentUser zu geben — die Navigation braucht nur, ob ein
@@ -119,6 +137,7 @@ func (s *Server) requireFachebene(next http.HandlerFunc) http.HandlerFunc {
 type navData struct {
 	IsBetreiber bool
 	IsFachebene bool
+	IsAdmin     bool
 }
 
 // navFor liefert die Nav-Daten für den angemeldeten Nutzer der Anfrage.
@@ -126,7 +145,11 @@ type navData struct {
 // currentUser).
 func navFor(r *http.Request) navData {
 	role := currentUser(r).Role
-	return navData{IsBetreiber: role == "betreiber", IsFachebene: role == "verantwortlicher" || role == "pruefer"}
+	return navData{
+		IsBetreiber: role == "betreiber",
+		IsFachebene: role == "verantwortlicher" || role == "pruefer",
+		IsAdmin:     role == "admin",
+	}
 }
 
 // currentUser liest den Nutzer, den requirePage/requireAPI in den

internal/web/server.go

@@ -50,7 +50,11 @@ type Store interface {
 	ListAntraegeForAccount(ctx context.Context, accountID string) ([]store.Antrag, error)
 
 	ListWerkzeugeForAccount(ctx context.Context, accountID string) ([]store.Werkzeug, error)
+	ListZentraleWerkzeuge(ctx context.Context) ([]store.Werkzeug, error)
 	GetWerkzeug(ctx context.Context, id string) (store.Werkzeug, error)
+	CreateWerkzeug(ctx context.Context, in store.WerkzeugInput) (store.Werkzeug, error)
+	UpdateWerkzeug(ctx context.Context, id string, in store.WerkzeugInput) (store.Werkzeug, error)
+	DeleteWerkzeug(ctx context.Context, id string) error
 	CurrentKatalogVersion(ctx context.Context) (string, error)
 	CreateBewertung(ctx context.Context, in store.BewertungInput) (store.Bewertung, error)
 	GetLatestBewertungForAntrag(ctx context.Context, antragID string) (store.Bewertung, error)
@@ -106,10 +110,19 @@ func NewServer(st Store, regelwerk Regelwerk) (*Server, error) {
 	mux.HandleFunc("GET /faelle", s.requireFachebene(s.handleFaelleListe))
 	mux.HandleFunc("GET /faelle/{id}", s.requireFachebene(s.handleFallDetail))
 	mux.HandleFunc("POST /faelle/{id}/entscheiden", s.requireFachebene(s.handleFallEntscheiden))
+	mux.HandleFunc("GET /verwaltung/nutzer", s.requireAdmin(s.handleNutzerListe))
+	mux.HandleFunc("GET /verwaltung/nutzer/neu", s.requireAdmin(s.handleNutzerNeuForm))
+	mux.HandleFunc("POST /verwaltung/nutzer", s.requireAdmin(s.handleNutzerCreate))
 	mux.HandleFunc("GET /betreiber", s.requireBetreiber(s.handleBetreiberDashboard))
 	mux.HandleFunc("GET /betreiber/accounts", s.requireBetreiber(s.handleBetreiberAccountList))
 	mux.HandleFunc("GET /betreiber/accounts/{id}", s.requireBetreiber(s.handleBetreiberAccountDetail))
 	mux.HandleFunc("GET /betreiber/audit-log", s.requireBetreiber(s.handleBetreiberAuditLog))
+	mux.HandleFunc("GET /betreiber/werkzeuge", s.requireBetreiber(s.handleBetreiberWerkzeugListe))
+	mux.HandleFunc("GET /betreiber/werkzeuge/neu", s.requireBetreiber(s.handleBetreiberWerkzeugNeuForm))
+	mux.HandleFunc("POST /betreiber/werkzeuge", s.requireBetreiber(s.handleBetreiberWerkzeugCreate))
+	mux.HandleFunc("GET /betreiber/werkzeuge/{id}", s.requireBetreiber(s.handleBetreiberWerkzeugEditForm))
+	mux.HandleFunc("POST /betreiber/werkzeuge/{id}", s.requireBetreiber(s.handleBetreiberWerkzeugUpdate))
+	mux.HandleFunc("POST /betreiber/werkzeuge/{id}/loeschen", s.requireBetreiber(s.handleBetreiberWerkzeugDelete))
 	mux.Handle("GET /static/", http.FileServerFS(staticFS))
 	s.mux = mux
 

internal/web/server_test.go

@@ -269,6 +269,58 @@ func (f *fakeStore) ListWerkzeugeForAccount(ctx context.Context, accountID strin
 	return out, nil
 }
 
+func (f *fakeStore) ListZentraleWerkzeuge(ctx context.Context) ([]store.Werkzeug, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	var out []store.Werkzeug
+	for _, w := range f.werkzeuge {
+		if w.AccountID == nil {
+			out = append(out, w)
+		}
+	}
+	return out, nil
+}
+
+func (f *fakeStore) CreateWerkzeug(ctx context.Context, in store.WerkzeugInput) (store.Werkzeug, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	w := store.Werkzeug{
+		ID: f.newID(), AccountID: in.AccountID, Name: in.Name, Anbieter: in.Anbieter,
+		Verarbeitungsort: in.Verarbeitungsort, AVVVerfuegbar: in.AVVVerfuegbar, AVVURL: in.AVVURL,
+		TrainingOptOut: in.TrainingOptOut, TrainingStandard: in.TrainingStandard, AufbewahrungTage: in.AufbewahrungTage,
+		Zertifizierungen: in.Zertifizierungen, GeeigneteZwecke: in.GeeigneteZwecke, Einschraenkungen: in.Einschraenkungen,
+		LetztePruefung: in.LetztePruefung, Quelle: in.Quelle, CreatedAt: time.Now(), UpdatedAt: time.Now(),
+	}
+	f.werkzeuge[w.ID] = w
+	return w, nil
+}
+
+func (f *fakeStore) UpdateWerkzeug(ctx context.Context, id string, in store.WerkzeugInput) (store.Werkzeug, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	w, ok := f.werkzeuge[id]
+	if !ok {
+		return store.Werkzeug{}, store.ErrNotFound
+	}
+	w.Name, w.Anbieter, w.Verarbeitungsort = in.Name, in.Anbieter, in.Verarbeitungsort
+	w.AVVVerfuegbar, w.AVVURL = in.AVVVerfuegbar, in.AVVURL
+	w.TrainingOptOut, w.TrainingStandard, w.AufbewahrungTage = in.TrainingOptOut, in.TrainingStandard, in.AufbewahrungTage
+	w.Zertifizierungen, w.GeeigneteZwecke, w.Einschraenkungen = in.Zertifizierungen, in.GeeigneteZwecke, in.Einschraenkungen
+	w.LetztePruefung, w.Quelle, w.UpdatedAt = in.LetztePruefung, in.Quelle, time.Now()
+	f.werkzeuge[id] = w
+	return w, nil
+}
+
+func (f *fakeStore) DeleteWerkzeug(ctx context.Context, id string) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	if _, ok := f.werkzeuge[id]; !ok {
+		return store.ErrNotFound
+	}
+	delete(f.werkzeuge, id)
+	return nil
+}
+
 func (f *fakeStore) GetWerkzeug(ctx context.Context, id string) (store.Werkzeug, error) {
 	f.mu.Lock()
 	defer f.mu.Unlock()
@@ -666,7 +718,7 @@ func TestHandleIndexRendersForMitarbeiter(t *testing.T) {
 func TestBetreiberRoutesRejectNonBetreiberWith404(t *testing.T) {
 	s, _, cookie := newAuthedTestServer(t)
 
-	for _, path := range []string{"/betreiber", "/betreiber/accounts", "/betreiber/audit-log"} {
+	for _, path := range []string{"/betreiber", "/betreiber/accounts", "/betreiber/audit-log", "/betreiber/werkzeuge"} {
 		resp := getWithCookie(t, s, cookie, path)
 		if resp.Code != http.StatusNotFound {
 			t.Errorf("GET %s status = %d, want 404 for a non-betreiber user", path, resp.Code)

internal/web/templates/betreiber_dashboard.html

@@ -7,6 +7,7 @@
 <h1>Plattform</h1>
 <ul class="admin-kacheln">
   <li><a href="/betreiber/accounts">Accounts <span class="status">{{.AccountCount}}</span></a></li>
+  <li><a href="/betreiber/werkzeuge">Werkzeugkatalog <span class="status">{{.WerkzeugCount}}</span></a></li>
   <li><a href="/betreiber/audit-log">Audit-Log <span class="status">{{.RecentAuditCount}} neueste</span></a></li>
 </ul>
 </div>

internal/web/templates/betreiber_werkzeug_form.html

@@ -0,0 +1,65 @@
+{{define "betreiber-werkzeug-form"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+{{template "nav" .Nav}}
+<div class="page">
+<p><a href="/betreiber/werkzeuge">&larr; Werkzeugkatalog</a></p>
+<h1>{{.Title}}</h1>
+<p class="hinweis">
+  Jede Zusicherung hier (AVV, Verarbeitungsort, Training-Opt-out,
+  Zertifizierungen) muss belegbar sein — Quelle und letzte Prüfung sind
+  Pflicht.
+</p>
+{{if .Error}}<p class="fehler">{{.Error}}</p>{{end}}
+<form method="post" action="{{if .ID}}/betreiber/werkzeuge/{{.ID}}{{else}}/betreiber/werkzeuge{{end}}">
+  <label for="name">Name</label>
+  <input type="text" id="name" name="name" value="{{.Name}}" required>
+
+  <label for="anbieter">Anbieter</label>
+  <input type="text" id="anbieter" name="anbieter" value="{{.Anbieter}}" required>
+
+  <fieldset>
+    <legend>Verarbeitungsort</legend>
+    {{$gewaehlt := .Verarbeitungsort}}
+    {{range .Verarbeitungsorte}}
+    <label><input type="radio" name="verarbeitungsort" value="{{.}}" {{if eq . $gewaehlt}}checked{{end}} required> {{.}}</label>
+    {{end}}
+  </fieldset>
+
+  <label><input type="checkbox" name="avv_verfuegbar" {{if .AVVVerfuegbar}}checked{{end}}> AVV verfügbar</label>
+  <label for="avv_url">AVV-URL</label>
+  <input type="text" id="avv_url" name="avv_url" value="{{.AVVURL}}">
+
+  <label><input type="checkbox" name="training_opt_out" {{if .TrainingOptOut}}checked{{end}}> Training-Opt-out möglich</label>
+  <label><input type="checkbox" name="training_standard" {{if .TrainingStandard}}checked{{end}}> Training standardmäßig aus</label>
+
+  <label for="aufbewahrung_tage">Aufbewahrung (Tage)</label>
+  <input type="number" id="aufbewahrung_tage" name="aufbewahrung_tage" min="0" value="{{.AufbewahrungTage}}">
+
+  <label for="zertifizierungen">Zertifizierungen (kommagetrennt)</label>
+  <input type="text" id="zertifizierungen" name="zertifizierungen" value="{{.Zertifizierungen}}">
+
+  <label for="geeignete_zwecke">Geeignete Zwecke (kommagetrennt)</label>
+  <input type="text" id="geeignete_zwecke" name="geeignete_zwecke" value="{{.GeeigneteZwecke}}">
+
+  <label for="einschraenkungen">Einschränkungen (kommagetrennt)</label>
+  <input type="text" id="einschraenkungen" name="einschraenkungen" value="{{.Einschraenkungen}}">
+
+  <label for="letzte_pruefung">Letzte Prüfung</label>
+  <input type="date" id="letzte_pruefung" name="letzte_pruefung" value="{{.LetztePruefung}}" required>
+
+  <label for="quelle">Quelle (Beleg)</label>
+  <input type="text" id="quelle" name="quelle" value="{{.Quelle}}" required>
+
+  <button type="submit">Speichern</button>
+</form>
+{{if .ID}}
+<form method="post" action="/betreiber/werkzeuge/{{.ID}}/loeschen" onsubmit="return confirm('Werkzeug wirklich löschen?')">
+  <button type="submit">Werkzeug löschen</button>
+</form>
+{{end}}
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/betreiber_werkzeuge.html

@@ -0,0 +1,26 @@
+{{define "betreiber-werkzeuge"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+{{template "nav" .Nav}}
+<div class="page">
+<p><a href="/betreiber">&larr; Plattform</a></p>
+<h1>Werkzeugkatalog</h1>
+{{if not .Werkzeuge}}
+<p class="hinweis">Noch keine zentralen Katalogeinträge.</p>
+{{else}}
+<ul class="beitraege-liste">
+  {{range .Werkzeuge}}
+  <li>
+    <a href="/betreiber/werkzeuge/{{.ID}}">
+      <strong>{{.Name}}</strong> · {{.Anbieter}} · {{.Verarbeitungsort}} · zuletzt geprüft {{.LetztePruefung}}
+    </a>
+  </li>
+  {{end}}
+</ul>
+{{end}}
+<p><a href="/betreiber/werkzeuge/neu">Werkzeug anlegen</a></p>
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/layout.html

@@ -11,6 +11,7 @@
   <a href="/">Start</a>
   {{if not .IsBetreiber}}<a href="/antraege">Meine Anträge</a>{{end}}
   {{if .IsFachebene}}<a href="/faelle">Posteingang</a>{{end}}
+  {{if .IsAdmin}}<a href="/verwaltung/nutzer">Nutzerverwaltung</a>{{end}}
   {{if .IsBetreiber}}<a href="/betreiber">Plattform</a>{{end}}
   <form method="post" action="/logout" style="display:inline">
     <button type="submit">Abmelden</button>

internal/web/templates/nutzer_liste.html

@@ -0,0 +1,17 @@
+{{define "nutzer-liste"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+{{template "nav" .Nav}}
+<div class="page">
+<h1>Nutzerverwaltung</h1>
+<ul class="beitraege-liste">
+  {{range .Nutzer}}
+  <li>{{.Email}} <span class="status">{{.Role}}</span></li>
+  {{end}}
+</ul>
+<p><a href="/verwaltung/nutzer/neu">Nutzer anlegen</a></p>
+</div>
+</body>
+</html>
+{{end}}

internal/web/templates/nutzer_neu.html

@@ -0,0 +1,33 @@
+{{define "nutzer-neu"}}<!doctype html>
+<html lang="de">
+<head>{{template "head" .}}</head>
+<body>
+{{template "nav" .Nav}}
+<div class="page">
+<p><a href="/verwaltung/nutzer">&larr; Nutzerverwaltung</a></p>
+<h1>Nutzer anlegen</h1>
+<p class="hinweis">
+  Es gibt noch keine Einladungsmail — das hier gesetzte Passwort muss
+  auf einem anderen Weg an die neue Person weitergegeben werden.
+</p>
+{{if .Error}}<p class="fehler">{{.Error}}</p>{{end}}
+<form method="post" action="/verwaltung/nutzer">
+  <label for="email">E-Mail</label>
+  <input type="email" id="email" name="email" required>
+
+  <label for="password">Initialpasswort (mind. 8 Zeichen)</label>
+  <input type="password" id="password" name="password" minlength="8" required>
+
+  <fieldset>
+    <legend>Rolle</legend>
+    {{range .Rollen}}
+    <label><input type="radio" name="role" value="{{.}}" required> {{.}}</label>
+    {{end}}
+  </fieldset>
+
+  <button type="submit">Nutzer anlegen</button>
+</form>
+</div>
+</body>
+</html>
+{{end}}