feat: Ergebnisdarstellung mit Herleitung (Schritt 4 der Baureihenfolge)

POST /antraege berechnet und speichert direkt beim Einreichen eine append-only bewertung (Datenklasse, KI-VO-Einstufung, Anforderungen, zulässige/ausgeschlossene Werkzeuge), GET /antraege/{id} zeigt sie inklusive Herleitung und dem Pflicht-Hinweis, dass das System nicht entscheidet, sondern nur vorbereitet. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-08-29 10:22:24 +02:00
parent b1b121bb23
commit e968cf9761
13 changed files with 835 additions and 54 deletions
--- a/internal/web/antrag_handlers.go
+++ b/internal/web/antrag_handlers.go
@@ -1,9 +1,11 @@
 package web

 import (
+	"context"
 	"encoding/json"
 	"net/http"

+	"github.com/netcell-it/deklarix/internal/rules"
 	"github.com/netcell-it/deklarix/internal/store"
 )

@@ -118,12 +120,14 @@ func (s *Server) handleAntragCreate(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 	user := currentUser(r)

+	antworten := antwortenFromForm(r)
+
 	antrag, err := s.store.CreateAntrag(ctx, user.AccountID, user.ID, abteilungID, titel)
 	if err != nil {
 		http.Error(w, "Antrag konnte nicht angelegt werden: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
-	if _, err := s.store.UpdateAntragFelder(ctx, antrag.ID, titel, beschreibung, ergebnis, haeufigkeit, antwortenFromForm(r)); err != nil {
+	if _, err := s.store.UpdateAntragFelder(ctx, antrag.ID, titel, beschreibung, ergebnis, haeufigkeit, antworten); err != nil {
 		http.Error(w, "Antrag konnte nicht gespeichert werden: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
@@ -131,10 +135,83 @@ func (s *Server) handleAntragCreate(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "Antrag konnte nicht eingereicht werden: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
+	if err := s.bewerteAntrag(ctx, antrag.ID, user.AccountID, antworten); err != nil {
+		http.Error(w, "Bewertung konnte nicht berechnet werden: "+err.Error(), http.StatusInternalServerError)
+		return
+	}

 	http.Redirect(w, r, "/antraege/"+antrag.ID, http.StatusSeeOther)
 }

+// bewerteAntrag berechnet die Bewertung für einen eingereichten Antrag
+// (Schritt 3: Ableitungen und harte Filter) und speichert sie. Bei
+// "verboten" erfolgt die K.-o.-Prüfung — keine Werkzeugsuche, siehe
+// CLAUDE.md, Bewertungslogik.
+func (s *Server) bewerteAntrag(ctx context.Context, antragID, accountID string, antwortenJSON []byte) error {
+	antworten, err := rules.ParseAntworten(antwortenJSON)
+	if err != nil {
+		return err
+	}
+
+	datenklasse := rules.EvaluateDatenklasse(s.regelwerk.Datenklasse, antworten)
+	einstufung, err := rules.EvaluateEinstufung(s.regelwerk.Einstufung, antworten)
+	if err != nil {
+		return err
+	}
+	verboten := rules.IstVerboten(einstufung.ID)
+
+	in := store.BewertungInput{
+		AntragID: antragID, Datenklasse: datenklasse.ID, DatenklasseHerleitung: datenklasse.Herleitung,
+		Einstufung: einstufung.ID, EinstufungHerleitung: einstufungHerleitungText(einstufung), Verboten: verboten,
+		KatalogVersion: "n/a (K.-o.-Prüfung, keine Werkzeugsuche)",
+	}
+
+	if !verboten {
+		anforderungen := rules.DeriveAnforderungen(s.regelwerk.Anforderungen, datenklasse.ID, einstufung.ID)
+		anforderungIDs := make([]string, len(anforderungen))
+		for i, a := range anforderungen {
+			in.Anforderungen = append(in.Anforderungen, store.BewertungAnforderung{ID: a.ID, Beschreibung: a.Beschreibung, Herleitung: a.Herleitung})
+			anforderungIDs[i] = a.ID
+		}
+
+		werkzeuge, err := s.store.ListWerkzeugeForAccount(ctx, accountID)
+		if err != nil {
+			return err
+		}
+		kandidaten := make([]rules.WerkzeugKandidat, len(werkzeuge))
+		for i, w := range werkzeuge {
+			kandidaten[i] = rules.WerkzeugKandidat{ID: w.ID, Eigenschaften: rules.WerkzeugEigenschaften{
+				AVVVerfuegbar: w.AVVVerfuegbar, Verarbeitungsort: w.Verarbeitungsort,
+				TrainingOptOut: w.TrainingOptOut, TrainingStandard: w.TrainingStandard, AufbewahrungTage: w.AufbewahrungTage,
+			}}
+		}
+		zulaessig, ausgeschlossen := rules.FilterWerkzeuge(kandidaten, anforderungIDs)
+		in.ZulaessigeWerkzeuge = zulaessig
+		for _, a := range ausgeschlossen {
+			in.AusgeschlosseneWerkzeuge = append(in.AusgeschlosseneWerkzeuge, store.BewertungAusschluss{WerkzeugID: a.WerkzeugID, NichtErfuellt: a.NichtErfuellt})
+		}
+
+		katalogVersion, err := s.store.CurrentKatalogVersion(ctx)
+		if err != nil {
+			return err
+		}
+		in.KatalogVersion = katalogVersion
+	}
+	in.RegelwerkVersion = rules.RegelwerkVersion(s.regelwerk.Datenklasse, s.regelwerk.Einstufung, s.regelwerk.Anforderungen)
+
+	_, err = s.store.CreateBewertung(ctx, in)
+	return err
+}
+
+// einstufungHerleitungText fügt die Quelle (z. B. "Art. 5 KI-VO") mit
+// an, falls das Regelwerk eine nennt.
+func einstufungHerleitungText(e rules.EinstufungErgebnis) string {
+	if e.Quelle == "" {
+		return e.Herleitung
+	}
+	return e.Herleitung + " (" + e.Quelle + ")"
+}
+
 type antragListItem struct {
 	ID          string
 	Titel       string
@@ -173,6 +250,31 @@ func (s *Server) handleAntragList(w http.ResponseWriter, r *http.Request) {
 	}
 }

+type anforderungView struct {
+	ID           string
+	Beschreibung string
+	Herleitung   string
+}
+
+type werkzeugAusschlussView struct {
+	Name          string
+	NichtErfuellt []string
+}
+
+type bewertungView struct {
+	Datenklasse              string
+	DatenklasseHerleitung    string
+	Einstufung               string
+	EinstufungHerleitung     string
+	Verboten                 bool
+	Anforderungen            []anforderungView
+	ZulaessigeWerkzeuge      []string // Namen, nicht IDs
+	AusgeschlosseneWerkzeuge []werkzeugAusschlussView
+	RegelwerkVersion         string
+	KatalogVersion           string
+	CreatedAt                string
+}
+
 type antragDetailData struct {
 	Title        string
 	Nav          navData
@@ -184,6 +286,7 @@ type antragDetailData struct {
 	Status       string
 	CreatedAt    string
 	Antworten    map[string]any
+	Bewertung    *bewertungView
 }

 // handleAntragDetail zeigt einen einzelnen Antrag mit allen Antworten.
@@ -207,7 +310,46 @@ func (s *Server) handleAntragDetail(w http.ResponseWriter, r *http.Request) {
 		Beschreibung: antrag.Beschreibung, Ergebnis: antrag.Ergebnis, Haeufigkeit: antrag.Haeufigkeit,
 		Status: antrag.Status, CreatedAt: antrag.CreatedAt.Format("02.01.2006 15:04"), Antworten: antworten,
 	}
+
+	bewertung, err := s.store.GetLatestBewertungForAntrag(r.Context(), antrag.ID)
+	if err == nil {
+		data.Bewertung = s.toBewertungView(r.Context(), bewertung)
+	}
+
 	if err := s.templates.ExecuteTemplate(w, "antrag-detail", data); err != nil {
 		http.Error(w, "Seite konnte nicht gerendert werden", http.StatusInternalServerError)
 	}
 }
+
+// toBewertungView löst die in der Bewertung nur als ID gespeicherten
+// Werkzeuge zu Anzeigenamen auf. Ein Werkzeug, das seit der Berechnung
+// gelöscht wurde, wird mit seiner ID statt eines Namens angezeigt,
+// statt den ganzen Antrag unanzeigbar zu machen.
+func (s *Server) toBewertungView(ctx context.Context, b store.Bewertung) *bewertungView {
+	v := &bewertungView{
+		Datenklasse: b.Datenklasse, DatenklasseHerleitung: b.DatenklasseHerleitung,
+		Einstufung: b.Einstufung, EinstufungHerleitung: b.EinstufungHerleitung, Verboten: b.Verboten,
+		RegelwerkVersion: b.RegelwerkVersion, KatalogVersion: b.KatalogVersion,
+		CreatedAt: b.CreatedAt.Format("02.01.2006 15:04"),
+	}
+	for _, a := range b.Anforderungen {
+		v.Anforderungen = append(v.Anforderungen, anforderungView{ID: a.ID, Beschreibung: a.Beschreibung, Herleitung: a.Herleitung})
+	}
+	for _, id := range b.ZulaessigeWerkzeuge {
+		v.ZulaessigeWerkzeuge = append(v.ZulaessigeWerkzeuge, s.werkzeugName(ctx, id))
+	}
+	for _, a := range b.AusgeschlosseneWerkzeuge {
+		v.AusgeschlosseneWerkzeuge = append(v.AusgeschlosseneWerkzeuge, werkzeugAusschlussView{
+			Name: s.werkzeugName(ctx, a.WerkzeugID), NichtErfuellt: a.NichtErfuellt,
+		})
+	}
+	return v
+}
+
+func (s *Server) werkzeugName(ctx context.Context, id string) string {
+	w, err := s.store.GetWerkzeug(ctx, id)
+	if err != nil {
+		return id
+	}
+	return w.Name
+}
--- a/internal/web/antrag_handlers_test.go
+++ b/internal/web/antrag_handlers_test.go
@@ -7,6 +7,8 @@ import (
 	"net/url"
 	"strings"
 	"testing"
+
+	"github.com/netcell-it/deklarix/internal/store"
 )

 func fullAntragForm() url.Values {
@@ -122,6 +124,123 @@ func TestAntragDetailRejectsForeignUser(t *testing.T) {
 	}
 }

+// fullAntragForm liefert b1=ja (Datenklasse personenbezogen) und
+// c1..c3=nein (keine der verboten/hochrisiko/transparenzpflicht-
+// Varianten trifft zu) — die Einstufung fällt damit auf die
+// Auffangregel "minimal" zurück (siehe rules/kivo_einstufung.yaml).
+func TestAntragCreateComputesBewertung(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	cookie := seedAccount(t, fs, "Test-Mandant", "test@example.com")
+
+	resp := postForm(t, s, cookie, "/antraege", fullAntragForm())
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	var antragID string
+	for id := range fs.antraege {
+		antragID = id
+	}
+	b, err := fs.GetLatestBewertungForAntrag(context.Background(), antragID)
+	if err != nil {
+		t.Fatalf("GetLatestBewertungForAntrag: %v", err)
+	}
+	if b.Datenklasse != "personenbezogen" {
+		t.Errorf("Datenklasse = %q, want personenbezogen", b.Datenklasse)
+	}
+	if b.Einstufung != "minimal" {
+		t.Errorf("Einstufung = %q, want minimal", b.Einstufung)
+	}
+	if b.Verboten {
+		t.Error("Verboten = true, want false")
+	}
+
+	detail := getWithCookie(t, s, cookie, resp.Header().Get("Location"))
+	if !strings.Contains(detail.Body.String(), "Das System entscheidet nicht") {
+		t.Errorf("expected the mandatory disclaimer on the detail page, got: %s", detail.Body.String())
+	}
+}
+
+// TestAntragCreateVerbotenSkipsWerkzeugSearch prüft die K.-o.-Prüfung:
+// c3=ja mit c3_art=social_scoring löst "verboten" aus (Art. 5 KI-VO) —
+// dann darf keine Werkzeugsuche stattfinden (siehe CLAUDE.md,
+// Bewertungslogik).
+func TestAntragCreateVerbotenSkipsWerkzeugSearch(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	cookie := seedAccount(t, fs, "Test-Mandant", "test@example.com")
+
+	form := fullAntragForm()
+	form.Set("c3", "ja")
+	form.Set("c3_art", "social_scoring")
+
+	resp := postForm(t, s, cookie, "/antraege", form)
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	var antragID string
+	for id := range fs.antraege {
+		antragID = id
+	}
+	b, err := fs.GetLatestBewertungForAntrag(context.Background(), antragID)
+	if err != nil {
+		t.Fatalf("GetLatestBewertungForAntrag: %v", err)
+	}
+	if !b.Verboten || b.Einstufung != "verboten" {
+		t.Fatalf("Bewertung = %+v, want Verboten=true, Einstufung=verboten", b)
+	}
+	if len(b.ZulaessigeWerkzeuge) != 0 || len(b.AusgeschlosseneWerkzeuge) != 0 {
+		t.Errorf("expected no werkzeug search for a verboten Bewertung, got %+v", b)
+	}
+}
+
+// TestAntragCreateFiltersWerkzeugeByAnforderungen prüft den harten
+// Filter: personenbezogen verlangt avv_erforderlich — ein Werkzeug ohne
+// AVV wird ausgeschlossen und im Ergebnis mit Begründung genannt statt
+// stillschweigend wegzufallen, ein Werkzeug mit AVV bleibt zulässig.
+func TestAntragCreateFiltersWerkzeugeByAnforderungen(t *testing.T) {
+	fs := newFakeStore()
+	s := newServer(t, fs)
+	cookie := seedAccount(t, fs, "Test-Mandant", "test@example.com")
+
+	fs.werkzeuge["werkzeug-ok"] = store.Werkzeug{
+		ID: "werkzeug-ok", Name: "ChatGPT Enterprise",
+		AVVVerfuegbar: true, TrainingStandard: true,
+	}
+	fs.werkzeuge["werkzeug-ohne-avv"] = store.Werkzeug{
+		ID: "werkzeug-ohne-avv", Name: "Freies KI-Tool",
+		AVVVerfuegbar: false, TrainingStandard: true,
+	}
+
+	resp := postForm(t, s, cookie, "/antraege", fullAntragForm())
+	if resp.Code != http.StatusSeeOther {
+		t.Fatalf("status = %d, body: %s", resp.Code, resp.Body.String())
+	}
+	var antragID string
+	for id := range fs.antraege {
+		antragID = id
+	}
+	b, err := fs.GetLatestBewertungForAntrag(context.Background(), antragID)
+	if err != nil {
+		t.Fatalf("GetLatestBewertungForAntrag: %v", err)
+	}
+	if len(b.ZulaessigeWerkzeuge) != 1 || b.ZulaessigeWerkzeuge[0] != "werkzeug-ok" {
+		t.Errorf("ZulaessigeWerkzeuge = %v, want [werkzeug-ok]", b.ZulaessigeWerkzeuge)
+	}
+	if len(b.AusgeschlosseneWerkzeuge) != 1 || b.AusgeschlosseneWerkzeuge[0].WerkzeugID != "werkzeug-ohne-avv" {
+		t.Fatalf("AusgeschlosseneWerkzeuge = %+v, want [werkzeug-ohne-avv]", b.AusgeschlosseneWerkzeuge)
+	}
+	if got := b.AusgeschlosseneWerkzeuge[0].NichtErfuellt; len(got) != 1 || got[0] != "avv_erforderlich" {
+		t.Errorf("NichtErfuellt = %v, want [avv_erforderlich]", got)
+	}
+
+	detail := getWithCookie(t, s, cookie, resp.Header().Get("Location"))
+	body := detail.Body.String()
+	if !strings.Contains(body, "ChatGPT Enterprise") || !strings.Contains(body, "Freies KI-Tool") {
+		t.Errorf("expected both werkzeuge (by name) on the detail page, got: %s", body)
+	}
+}
+
 func TestBetreiberRedirectedAwayFromAntragPages(t *testing.T) {
 	fs := newFakeStore()
 	s := newServer(t, fs)
--- a/internal/web/server.go
+++ b/internal/web/server.go
@@ -13,6 +13,7 @@ import (
 	"net/http"
 	"time"

+	"github.com/netcell-it/deklarix/internal/rules"
 	"github.com/netcell-it/deklarix/internal/store"
 )

@@ -46,17 +47,35 @@ type Store interface {
 	UpdateAntragFelder(ctx context.Context, id, titel, beschreibung, ergebnis, haeufigkeit string, antworten []byte) (store.Antrag, error)
 	SetAntragStatus(ctx context.Context, id, status string) error
 	ListAntraegeForUser(ctx context.Context, erstellerUserID string) ([]store.Antrag, error)
+
+	ListWerkzeugeForAccount(ctx context.Context, accountID string) ([]store.Werkzeug, error)
+	GetWerkzeug(ctx context.Context, id string) (store.Werkzeug, 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)
+}
+
+// Regelwerk bündelt die drei geladenen Regelwerk-Dateien, die die
+// Bewertung eines Antrags braucht (siehe internal/rules). Ein eigener
+// Typ statt drei einzelne Server-Felder, damit main.go sie an einer
+// Stelle zusammenstellt.
+type Regelwerk struct {
+	Datenklasse   rules.DatenklasseRegelwerk
+	Einstufung    rules.EinstufungRegelwerk
+	Anforderungen rules.AnforderungsRegelwerk
 }

 // Server bündelt Routing und Abhängigkeiten der Web-Schicht.
 type Server struct {
 	mux       *http.ServeMux
 	store     Store
+	regelwerk Regelwerk
 	templates *template.Template
 }

-// NewServer erstellt den Server.
-func NewServer(st Store) (*Server, error) {
+// NewServer erstellt den Server. regelwerk kommt von rules.Load* und
+// wird einmal beim Start geladen, nicht pro Request.
+func NewServer(st Store, regelwerk Regelwerk) (*Server, error) {
 	tmpl, err := template.ParseFS(templatesFS, "templates/*.html")
 	if err != nil {
 		return nil, fmt.Errorf("web: templates parsen: %w", err)
@@ -64,6 +83,7 @@ func NewServer(st Store) (*Server, error) {

 	s := &Server{
 		store:     st,
+		regelwerk: regelwerk,
 		templates: tmpl,
 	}

--- a/internal/web/server_test.go
+++ b/internal/web/server_test.go
@@ -7,12 +7,14 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"net/url"
+	"os"
 	"strings"
 	"sync"
 	"testing"
 	"time"

 	"github.com/netcell-it/deklarix/internal/auth"
+	"github.com/netcell-it/deklarix/internal/rules"
 	"github.com/netcell-it/deklarix/internal/store"
 	"github.com/netcell-it/deklarix/internal/web"
 )
@@ -31,6 +33,8 @@ type fakeStore struct {
 	auditLog     []store.AuditEntry
 	abteilungen  map[string][]store.Abteilung // accountID -> Abteilungen
 	antraege     map[string]store.Antrag
+	werkzeuge    map[string]store.Werkzeug
+	bewertungen  map[string][]store.Bewertung // antragID -> Bewertungen, älteste zuerst
 }

 func newFakeStore() *fakeStore {
@@ -41,6 +45,8 @@ func newFakeStore() *fakeStore {
 		sessions:     map[string]store.Session{},
 		abteilungen:  map[string][]store.Abteilung{},
 		antraege:     map[string]store.Antrag{},
+		werkzeuge:    map[string]store.Werkzeug{},
+		bewertungen:  map[string][]store.Bewertung{},
 	}
 }

@@ -237,11 +243,87 @@ func (f *fakeStore) ListAntraegeForUser(ctx context.Context, erstellerUserID str
 	return out, nil
 }

+func (f *fakeStore) ListWerkzeugeForAccount(ctx context.Context, accountID string) ([]store.Werkzeug, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	var out []store.Werkzeug
+	for _, w := range f.werkzeuge {
+		if w.AccountID == nil || *w.AccountID == accountID {
+			out = append(out, w)
+		}
+	}
+	return out, nil
+}
+
+func (f *fakeStore) GetWerkzeug(ctx context.Context, id string) (store.Werkzeug, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	w, ok := f.werkzeuge[id]
+	if !ok {
+		return store.Werkzeug{}, store.ErrNotFound
+	}
+	return w, nil
+}
+
+func (f *fakeStore) CurrentKatalogVersion(ctx context.Context) (string, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return fmt.Sprintf("fake-%d", len(f.werkzeuge)), nil
+}
+
+func (f *fakeStore) CreateBewertung(ctx context.Context, in store.BewertungInput) (store.Bewertung, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	b := store.Bewertung{
+		ID: f.newID(), AntragID: in.AntragID,
+		Datenklasse: in.Datenklasse, DatenklasseHerleitung: in.DatenklasseHerleitung,
+		Einstufung: in.Einstufung, EinstufungHerleitung: in.EinstufungHerleitung,
+		Verboten: in.Verboten, Anforderungen: in.Anforderungen,
+		ZulaessigeWerkzeuge: in.ZulaessigeWerkzeuge, AusgeschlosseneWerkzeuge: in.AusgeschlosseneWerkzeuge,
+		RegelwerkVersion: in.RegelwerkVersion, KatalogVersion: in.KatalogVersion,
+		CreatedAt: time.Now(),
+	}
+	f.bewertungen[in.AntragID] = append(f.bewertungen[in.AntragID], b)
+	return b, nil
+}
+
+func (f *fakeStore) GetLatestBewertungForAntrag(ctx context.Context, antragID string) (store.Bewertung, error) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	bs := f.bewertungen[antragID]
+	if len(bs) == 0 {
+		return store.Bewertung{}, store.ErrNotFound
+	}
+	return bs[len(bs)-1], nil
+}
+
 // ─── Test-Setup ───────────────────────────────────────────────────────

+// loadTestRegelwerk lädt die echten rules/*.yaml-Dateien — dieselben,
+// die auch main.go beim Start lädt. Handler-Tests laufen so gegen das
+// tatsächliche Regelwerk statt gegen ein Test-Fixture, das getrennt
+// von rules/ gepflegt werden müsste.
+func loadTestRegelwerk(t *testing.T) web.Regelwerk {
+	t.Helper()
+	fsys := os.DirFS("../../rules")
+	dk, err := rules.LoadDatenklasse(fsys, "datenklasse.yaml")
+	if err != nil {
+		t.Fatalf("LoadDatenklasse: %v", err)
+	}
+	ei, err := rules.LoadEinstufung(fsys, "kivo_einstufung.yaml")
+	if err != nil {
+		t.Fatalf("LoadEinstufung: %v", err)
+	}
+	an, err := rules.LoadAnforderungen(fsys, "anforderungen.yaml")
+	if err != nil {
+		t.Fatalf("LoadAnforderungen: %v", err)
+	}
+	return web.Regelwerk{Datenklasse: dk, Einstufung: ei, Anforderungen: an}
+}
+
 func newServer(t *testing.T, fs *fakeStore) *web.Server {
 	t.Helper()
-	s, err := web.NewServer(fs)
+	s, err := web.NewServer(fs, loadTestRegelwerk(t))
 	if err != nil {
 		t.Fatalf("NewServer: %v", err)
 	}
--- a/internal/web/templates/antrag_detail.html
+++ b/internal/web/templates/antrag_detail.html
@@ -13,11 +13,64 @@
 <p><strong>Was soll herauskommen?</strong><br>{{.Ergebnis}}</p>
 <p><strong>Häufigkeit:</strong> {{.Haeufigkeit}}</p>

-<p class="hinweis">
-  Die Bewertung (Datenklasse, KI-VO-Einstufung, Werkzeugvorschlag) folgt
-  in einer späteren Ausbaustufe — dieser Antrag ist gespeichert und
-  eingereicht.
+{{if .Bewertung}}
+<h2>Bewertung</h2>
+
+{{if .Bewertung.Verboten}}
+<p class="fehler"><strong>Verboten.</strong> Diese Nutzung fällt laut Einstufung unter ein verbotenes KI-Praktiken-Muster der KI-VO ({{.Bewertung.Einstufung}}). {{.Bewertung.EinstufungHerleitung}}</p>
+{{end}}
+
+<p><strong>Datenklasse:</strong> {{.Bewertung.Datenklasse}}<br>
+<span class="hinweis">{{.Bewertung.DatenklasseHerleitung}}</span></p>
+
+<p><strong>KI-VO-Einstufung:</strong> {{.Bewertung.Einstufung}}<br>
+<span class="hinweis">{{.Bewertung.EinstufungHerleitung}}</span></p>
+
+{{if .Bewertung.Anforderungen}}
+<h3>Anforderungen</h3>
+<ul class="findings">
+  {{range .Bewertung.Anforderungen}}
+  <li class="finding finding-mittel">
+    <strong>{{.Beschreibung}}</strong>
+    <p>{{.Herleitung}}</p>
+  </li>
+  {{end}}
+</ul>
+{{end}}
+
+{{if not .Bewertung.Verboten}}
+<h3>Zulässige Werkzeuge</h3>
+{{if .Bewertung.ZulaessigeWerkzeuge}}
+<ul>
+  {{range .Bewertung.ZulaessigeWerkzeuge}}<li>{{.}}</li>{{end}}
+</ul>
+{{else}}
+<p class="rueckfrage">Kein Werkzeug im Katalog erfüllt aktuell alle Anforderungen dieses Antrags.</p>
+{{end}}
+
+{{if .Bewertung.AusgeschlosseneWerkzeuge}}
+<h3>Ausgeschlossene Werkzeuge</h3>
+<ul class="findings">
+  {{range .Bewertung.AusgeschlosseneWerkzeuge}}
+  <li class="finding finding-niedrig">
+    <strong>{{.Name}}</strong>
+    <p>Nicht erfüllt: {{range $i, $a := .NichtErfuellt}}{{if $i}}, {{end}}{{$a}}{{end}}</p>
+  </li>
+  {{end}}
+</ul>
+{{end}}
+{{end}}
+
+<p class="disclaimer">
+  Das System entscheidet nicht. Es bereitet vor. Diese Einstufung ist ein
+  Vorschlag zur Herleitung von Datenklasse, KI-VO-Einstufung und
+  Anforderungen (Regelwerk {{.Bewertung.RegelwerkVersion}}, Katalog
+  {{.Bewertung.KatalogVersion}}, berechnet am {{.Bewertung.CreatedAt}}) —
+  die Entscheidung trifft ein Mensch.
 </p>
+{{else}}
+<p class="hinweis">Die Bewertung wird berechnet, sobald der Antrag eingereicht ist.</p>
+{{end}}
 </div>
 </body>
 </html>