feat!: Produktwechsel zu KI-Antragsprüfung — Phase 1 (Datenmodell, Regelwerk, Katalog)
Deklarix war eine Pre-Publish-Kennzeichnungsprüfung für Werbe-Content
(UWG/MStV). Dieser Scope wird komplett verworfen und durch eine
KI-Antragsprüfung ersetzt: Mitarbeitende beschreiben ein KI-Vorhaben,
das System leitet Datenklasse und KI-VO-Einstufung ab, gleicht sie
gegen einen Werkzeugkatalog ab und erzeugt einen Entscheidungsvorschlag
mit Herleitung — ein Mensch entscheidet, das System bereitet nur vor.
BREAKING CHANGE: Migration 0008 droppt alle werberechtsspezifischen
Tabellen (submission, finding, extraction, evidence_package,
participant, platform_connection, asset). account/app_user/session/
audit_log bleiben (Mandantentrennung, Login, Protokollierung sind
produktunabhängig) — app_user.role wechselt von
creator/agentur/marke/kanzlei/admin zu den fünf neuen Rollen
mitarbeiter/verantwortlicher/pruefer/admin/betreiber (vier
Mandanten-Rollen + eine plattformweite, siehe CLAUDE.md).
Entfernt: internal/extract, internal/dossier, internal/evidence,
internal/socialconnect, alte rules/*.yaml (UWG-Regeln), testdata/golden
— alles ausschließlich für das alte Produkt.
Neu, Phase 1 der Baureihenfolge ("Datenmodell, Regelwerk als YAML,
Katalogstruktur"):
- Store: abteilung (Stammdaten), werkzeug + werkzeug_sperre (der
eigentliche Wert des Produkts — zentral gepflegter Katalog mit
mandantenspezifischen Ergänzungen/Sperrungen, Pflichtfelder
letzte_pruefung/quelle für jede Zusicherung), antrag (Fragebogen-
Grundgerüst, Antworten als JSONB für den adaptiven Fragebogen aus
Phase 2).
- internal/rules komplett neu: lädt und validiert drei YAML-
Regelwerke (Datenklasse-Ableitung, KI-VO-Einstufung, Anforderungs-
profil) aus rules/*.yaml — noch ohne Auswertungslogik gegen echte
Fragebogen-Antworten (das ist Phase 3, bewusst erst nach dem
Fragebogen aus Phase 2, der die exakten Fakten-Feldnamen festlegt).
Offene fachliche Annahmen (Rangfolge der Datenklassen, Fragebogen-
Lücke für die "verboten"-Varianten) explizit in rules/OPEN.md
dokumentiert statt geraten.
- Web-Layer auf Minimalgerüst reduziert, das kompiliert und die neue
Rollenwelt trägt: Firma-Registrierung (Ebene 1, erster Nutzer wird
admin), Login/Logout, Plattform-Bereich (Ebene 5, nur betreiber:
Dashboard, Accounts-Übersicht, Audit-Log) — Fragebogen (Ebene 2) und
Fachebene (Ebene 3) folgen in den nächsten Phasen.
- CLAUDE.md komplett neu geschrieben: Produktbeschreibung, Fünf-Ebenen-
Rollenmodell, Fragebogen-Spezifikation, Ableitungstabellen,
Werkzeugkatalog, Bewertungslogik (geplant), Onboarding, offene
Punkte (u. a. Postgres-RLS-Frage aus der Frontend-Spezifikation
noch nicht entschieden, "Admin und Verantwortlicher gleichzeitig"
beim Onboarding noch nicht datenmodelliert).
Volle Testsuite inkl. echter Postgres-Tests grün. End-to-End gegen
einen laufenden Server verifiziert: Firma-Registrierung legt Account +
admin-Nutzer an, Betreiber-Login leitet zu /betreiber, mandanten-
übergreifende Accounts-Liste sichtbar für betreiber, 404 für
mitarbeiter auf /betreiber, 303 zu /login ohne Sitzung.
This commit is contained in:
noroot
@@ -1,42 +0,0 @@
|
||||
package rules
|
||||
|
||||
// Finding ist das Ergebnis einer einzelnen zutreffenden Regel.
|
||||
type Finding struct {
|
||||
RuleID string
|
||||
RuleVersion int
|
||||
Severity Severity
|
||||
Title string
|
||||
Fix string
|
||||
Sources []string
|
||||
}
|
||||
|
||||
// Evaluate prüft alle Regeln gegen f und liefert ein Finding für jede
|
||||
// zutreffende Regel. Reihenfolge folgt der Reihenfolge von rules.
|
||||
//
|
||||
// Ist f.Consideration "unklar", wird KEINE Bewertung abgegeben —
|
||||
// needsClarification ist dann true und findings ist immer leer. Das ist
|
||||
// Absicht (Kernprinzip): eine unsichere Extraktion erzeugt eine
|
||||
// Rückfrage an den Nutzer, niemals eine stille "keine Findings"-
|
||||
// Bewertung, die wie "alles in Ordnung" aussähe.
|
||||
func Evaluate(rules []Rule, f Facts) (findings []Finding, needsClarification bool) {
|
||||
if f.Consideration == ConsiderationUnclear {
|
||||
return nil, true
|
||||
}
|
||||
|
||||
for _, r := range rules {
|
||||
if r.Jurisdiction != f.Jurisdiction {
|
||||
continue
|
||||
}
|
||||
if r.Condition.Matches(f) {
|
||||
findings = append(findings, Finding{
|
||||
RuleID: r.ID,
|
||||
RuleVersion: r.Version,
|
||||
Severity: r.Severity,
|
||||
Title: r.Title,
|
||||
Fix: r.Fix,
|
||||
Sources: r.Sources,
|
||||
})
|
||||
}
|
||||
}
|
||||
return findings, false
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
package rules
|
||||
|
||||
// Consideration ist die Gegenleistung für einen Beitrag, wie sie die
|
||||
// Extraktion (Stufe 1) liefert.
|
||||
type Consideration string
|
||||
|
||||
const (
|
||||
ConsiderationPaid Consideration = "bezahlt"
|
||||
ConsiderationInKind Consideration = "sachbezug"
|
||||
ConsiderationNone Consideration = "keine"
|
||||
ConsiderationUnclear Consideration = "unklar"
|
||||
)
|
||||
|
||||
// Facts sind die Fakten aus der Extraktion (Stufe 1), auf denen die
|
||||
// Regelauswertung (Stufe 2) urteilt. Die Extraktion liefert diese Werte,
|
||||
// sie bewertet sie nicht — das Urteil fällt ausschließlich das Regelwerk.
|
||||
//
|
||||
// Jurisdiction ist keine vom Modell extrahierte Tatsache (aus Caption/
|
||||
// Bild lässt sich keine Rechtsordnung ablesen), sondern kommt vom
|
||||
// Aufrufer — analog zu Platform. Aktuell ist "DE" der einzig unterstützte
|
||||
// Wert; siehe Rule.Jurisdiction.
|
||||
type Facts struct {
|
||||
Platform string `json:"platform"`
|
||||
Jurisdiction string `json:"jurisdiction"`
|
||||
Consideration Consideration `json:"consideration"`
|
||||
DisclosurePresent bool `json:"disclosure_present"`
|
||||
DisclosureWording string `json:"disclosure_wording"`
|
||||
DisclosureBeforeCut bool `json:"disclosure_before_cut"`
|
||||
}
|
||||
@@ -1,106 +0,0 @@
|
||||
package rules_test
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sort"
|
||||
"strconv"
|
||||
"testing"
|
||||
|
||||
"github.com/netcell-it/deklarix/internal/rules"
|
||||
)
|
||||
|
||||
// goldenCase spiegelt eine Datei aus testdata/golden/: die extrahierten
|
||||
// Fakten eines Beispielbeitrags plus die Findings, die das Regelwerk
|
||||
// dafür liefern muss. Das ist das eigentliche Asset des Projekts, nicht
|
||||
// die UI — siehe CLAUDE.md.
|
||||
type goldenCase struct {
|
||||
Name string `json:"name"`
|
||||
Facts rules.Facts `json:"facts"`
|
||||
ExpectedFindings []goldenFinding `json:"expected_findings"`
|
||||
ExpectNeedsClarification bool `json:"expect_needs_clarification"`
|
||||
}
|
||||
|
||||
type goldenFinding struct {
|
||||
RuleID string `json:"rule_id"`
|
||||
RuleVersion int `json:"rule_version"`
|
||||
Severity string `json:"severity"`
|
||||
}
|
||||
|
||||
const (
|
||||
rulesDir = "../../rules"
|
||||
goldenDir = "../../testdata/golden"
|
||||
)
|
||||
|
||||
func TestGolden(t *testing.T) {
|
||||
ruleSet, err := rules.Load(os.DirFS(rulesDir))
|
||||
if err != nil {
|
||||
t.Fatalf("Load rules: %v", err)
|
||||
}
|
||||
|
||||
entries, err := os.ReadDir(goldenDir)
|
||||
if err != nil {
|
||||
t.Fatalf("read golden dir: %v", err)
|
||||
}
|
||||
|
||||
found := 0
|
||||
for _, entry := range entries {
|
||||
if entry.IsDir() || filepath.Ext(entry.Name()) != ".json" {
|
||||
continue
|
||||
}
|
||||
found++
|
||||
entry := entry
|
||||
t.Run(entry.Name(), func(t *testing.T) {
|
||||
data, err := os.ReadFile(filepath.Join(goldenDir, entry.Name()))
|
||||
if err != nil {
|
||||
t.Fatalf("read %s: %v", entry.Name(), err)
|
||||
}
|
||||
var gc goldenCase
|
||||
if err := json.Unmarshal(data, &gc); err != nil {
|
||||
t.Fatalf("parse %s: %v", entry.Name(), err)
|
||||
}
|
||||
|
||||
got, needsClarification := rules.Evaluate(ruleSet, gc.Facts)
|
||||
|
||||
if needsClarification != gc.ExpectNeedsClarification {
|
||||
t.Fatalf("%s: needsClarification = %v, want %v", gc.Name, needsClarification, gc.ExpectNeedsClarification)
|
||||
}
|
||||
|
||||
gotKeys := make([]string, 0, len(got))
|
||||
for _, f := range got {
|
||||
gotKeys = append(gotKeys, findingKey(f.RuleID, f.RuleVersion, string(f.Severity)))
|
||||
}
|
||||
wantKeys := make([]string, 0, len(gc.ExpectedFindings))
|
||||
for _, ef := range gc.ExpectedFindings {
|
||||
wantKeys = append(wantKeys, findingKey(ef.RuleID, ef.RuleVersion, ef.Severity))
|
||||
}
|
||||
sort.Strings(gotKeys)
|
||||
sort.Strings(wantKeys)
|
||||
|
||||
if !equalStrings(gotKeys, wantKeys) {
|
||||
t.Fatalf("%s: got findings %v, want %v", gc.Name, gotKeys, wantKeys)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
if found == 0 {
|
||||
t.Fatal("no golden cases found in " + goldenDir)
|
||||
}
|
||||
}
|
||||
|
||||
func findingKey(ruleID string, version int, severity string) string {
|
||||
return ruleID + "/" + strconv.Itoa(version) + "/" + severity
|
||||
}
|
||||
|
||||
func equalStrings(a, b []string) bool {
|
||||
if len(a) != len(b) {
|
||||
return false
|
||||
}
|
||||
for i := range a {
|
||||
if a[i] != b[i] {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
@@ -3,50 +3,109 @@ package rules
|
||||
import (
|
||||
"fmt"
|
||||
"io/fs"
|
||||
"path/filepath"
|
||||
|
||||
"gopkg.in/yaml.v3"
|
||||
)
|
||||
|
||||
// Load liest alle *.yaml-Dateien aus fsys (nicht rekursiv) und parst sie
|
||||
// als Regeln. Ein Fehler in einer Datei (Parse-Fehler, fehlende ID/
|
||||
// Version) bricht das Laden komplett ab, statt die Datei stillschweigend
|
||||
// zu überspringen — ein halb geladenes Regelwerk ist gefährlicher als
|
||||
// ein Start, der mit einem klaren Fehler abbricht.
|
||||
func Load(fsys fs.FS) ([]Rule, error) {
|
||||
entries, err := fs.ReadDir(fsys, ".")
|
||||
// LoadDatenklasse lädt und validiert die Datenklasse-Ableitungstabelle.
|
||||
func LoadDatenklasse(fsys fs.FS, path string) (DatenklasseRegelwerk, error) {
|
||||
var rw DatenklasseRegelwerk
|
||||
data, err := fs.ReadFile(fsys, path)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("rules: read dir: %w", err)
|
||||
return DatenklasseRegelwerk{}, fmt.Errorf("rules: datenklasse lesen: %w", err)
|
||||
}
|
||||
|
||||
seen := make(map[string]bool)
|
||||
var result []Rule
|
||||
for _, entry := range entries {
|
||||
if entry.IsDir() || filepath.Ext(entry.Name()) != ".yaml" {
|
||||
continue
|
||||
}
|
||||
data, err := fs.ReadFile(fsys, entry.Name())
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("rules: read %s: %w", entry.Name(), err)
|
||||
}
|
||||
var r Rule
|
||||
if err := yaml.Unmarshal(data, &r); err != nil {
|
||||
return nil, fmt.Errorf("rules: parse %s: %w", entry.Name(), err)
|
||||
}
|
||||
if r.ID == "" {
|
||||
return nil, fmt.Errorf("rules: %s: missing id", entry.Name())
|
||||
}
|
||||
if r.Version == 0 {
|
||||
return nil, fmt.Errorf("rules: %s: missing version", entry.Name())
|
||||
}
|
||||
if r.Jurisdiction == "" {
|
||||
return nil, fmt.Errorf("rules: %s: missing land (jurisdiction)", entry.Name())
|
||||
}
|
||||
if seen[r.ID] {
|
||||
return nil, fmt.Errorf("rules: %s: duplicate rule id %s", entry.Name(), r.ID)
|
||||
}
|
||||
seen[r.ID] = true
|
||||
result = append(result, r)
|
||||
if err := yaml.Unmarshal(data, &rw); err != nil {
|
||||
return DatenklasseRegelwerk{}, fmt.Errorf("rules: datenklasse parsen: %w", err)
|
||||
}
|
||||
return result, nil
|
||||
if rw.Version < 1 {
|
||||
return DatenklasseRegelwerk{}, fmt.Errorf("rules: datenklasse: version fehlt oder ungültig")
|
||||
}
|
||||
if len(rw.Stufen) == 0 {
|
||||
return DatenklasseRegelwerk{}, fmt.Errorf("rules: datenklasse: keine stufen definiert")
|
||||
}
|
||||
seenIDs := map[string]bool{}
|
||||
seenRaenge := map[int]string{}
|
||||
for _, st := range rw.Stufen {
|
||||
if st.ID == "" {
|
||||
return DatenklasseRegelwerk{}, fmt.Errorf("rules: datenklasse: stufe ohne id")
|
||||
}
|
||||
if seenIDs[st.ID] {
|
||||
return DatenklasseRegelwerk{}, fmt.Errorf("rules: datenklasse: doppelte stufe-id %q", st.ID)
|
||||
}
|
||||
seenIDs[st.ID] = true
|
||||
if other, ok := seenRaenge[st.Rang]; ok {
|
||||
return DatenklasseRegelwerk{}, fmt.Errorf("rules: datenklasse: stufen %q und %q teilen sich rang %d — \"höchste Stufe gewinnt\" braucht eindeutige Ränge", st.ID, other, st.Rang)
|
||||
}
|
||||
seenRaenge[st.Rang] = st.ID
|
||||
if len(st.Ausloeser) == 0 {
|
||||
return DatenklasseRegelwerk{}, fmt.Errorf("rules: datenklasse: stufe %q hat keine ausloeser", st.ID)
|
||||
}
|
||||
}
|
||||
return rw, nil
|
||||
}
|
||||
|
||||
// LoadEinstufung lädt und validiert die KI-VO-Einstufungstabelle.
|
||||
func LoadEinstufung(fsys fs.FS, path string) (EinstufungRegelwerk, error) {
|
||||
var rw EinstufungRegelwerk
|
||||
data, err := fs.ReadFile(fsys, path)
|
||||
if err != nil {
|
||||
return EinstufungRegelwerk{}, fmt.Errorf("rules: einstufung lesen: %w", err)
|
||||
}
|
||||
if err := yaml.Unmarshal(data, &rw); err != nil {
|
||||
return EinstufungRegelwerk{}, fmt.Errorf("rules: einstufung parsen: %w", err)
|
||||
}
|
||||
if rw.Version < 1 {
|
||||
return EinstufungRegelwerk{}, fmt.Errorf("rules: einstufung: version fehlt oder ungültig")
|
||||
}
|
||||
if len(rw.Stufen) == 0 {
|
||||
return EinstufungRegelwerk{}, fmt.Errorf("rules: einstufung: keine stufen definiert")
|
||||
}
|
||||
seenIDs := map[string]bool{}
|
||||
for i, st := range rw.Stufen {
|
||||
if st.ID == "" {
|
||||
return EinstufungRegelwerk{}, fmt.Errorf("rules: einstufung: stufe ohne id")
|
||||
}
|
||||
if seenIDs[st.ID] {
|
||||
return EinstufungRegelwerk{}, fmt.Errorf("rules: einstufung: doppelte stufe-id %q", st.ID)
|
||||
}
|
||||
seenIDs[st.ID] = true
|
||||
// Die letzte Stufe darf eine Auffangregel ohne Bedingungen sein
|
||||
// (z. B. "minimal"), alle davor brauchen mindestens eine Variante.
|
||||
if len(st.Varianten) == 0 && i != len(rw.Stufen)-1 {
|
||||
return EinstufungRegelwerk{}, fmt.Errorf("rules: einstufung: stufe %q hat keine varianten (nur die letzte Stufe darf eine Auffangregel sein)", st.ID)
|
||||
}
|
||||
}
|
||||
return rw, nil
|
||||
}
|
||||
|
||||
// LoadAnforderungen lädt und validiert die Anforderungsprofil-Tabelle.
|
||||
func LoadAnforderungen(fsys fs.FS, path string) (AnforderungsRegelwerk, error) {
|
||||
var rw AnforderungsRegelwerk
|
||||
data, err := fs.ReadFile(fsys, path)
|
||||
if err != nil {
|
||||
return AnforderungsRegelwerk{}, fmt.Errorf("rules: anforderungen lesen: %w", err)
|
||||
}
|
||||
if err := yaml.Unmarshal(data, &rw); err != nil {
|
||||
return AnforderungsRegelwerk{}, fmt.Errorf("rules: anforderungen parsen: %w", err)
|
||||
}
|
||||
if rw.Version < 1 {
|
||||
return AnforderungsRegelwerk{}, fmt.Errorf("rules: anforderungen: version fehlt oder ungültig")
|
||||
}
|
||||
if len(rw.Anforderungen) == 0 {
|
||||
return AnforderungsRegelwerk{}, fmt.Errorf("rules: anforderungen: keine anforderungen definiert")
|
||||
}
|
||||
seenIDs := map[string]bool{}
|
||||
for _, a := range rw.Anforderungen {
|
||||
if a.ID == "" {
|
||||
return AnforderungsRegelwerk{}, fmt.Errorf("rules: anforderungen: anforderung ohne id")
|
||||
}
|
||||
if seenIDs[a.ID] {
|
||||
return AnforderungsRegelwerk{}, fmt.Errorf("rules: anforderungen: doppelte anforderung-id %q", a.ID)
|
||||
}
|
||||
seenIDs[a.ID] = true
|
||||
if len(a.AusDatenklassen) == 0 && len(a.AusEinstufungen) == 0 {
|
||||
return AnforderungsRegelwerk{}, fmt.Errorf("rules: anforderungen: anforderung %q hat weder aus_datenklassen noch aus_einstufungen", a.ID)
|
||||
}
|
||||
}
|
||||
return rw, nil
|
||||
}
|
||||
|
||||
132
internal/rules/loader_test.go
Normal file
132
internal/rules/loader_test.go
Normal file
@@ -0,0 +1,132 @@
|
||||
package rules_test
|
||||
|
||||
import (
|
||||
"io/fs"
|
||||
"os"
|
||||
"testing"
|
||||
"testing/fstest"
|
||||
|
||||
"github.com/netcell-it/deklarix/internal/rules"
|
||||
)
|
||||
|
||||
func realRulesFS(t *testing.T) fs.FS {
|
||||
t.Helper()
|
||||
return os.DirFS("../../rules")
|
||||
}
|
||||
|
||||
func TestLoadDatenklasseRealFile(t *testing.T) {
|
||||
rw, err := rules.LoadDatenklasse(realRulesFS(t), "datenklasse.yaml")
|
||||
if err != nil {
|
||||
t.Fatalf("LoadDatenklasse: %v", err)
|
||||
}
|
||||
if rw.Version != 1 {
|
||||
t.Fatalf("Version = %d, want 1", rw.Version)
|
||||
}
|
||||
if len(rw.Stufen) != 6 {
|
||||
t.Fatalf("expected 6 Stufen, got %d", len(rw.Stufen))
|
||||
}
|
||||
byID := map[string]rules.DatenklasseStufe{}
|
||||
for _, st := range rw.Stufen {
|
||||
byID[st.ID] = st
|
||||
}
|
||||
for _, id := range []string{"oeffentlich", "intern", "auftragsdaten", "personenbezogen", "berufsgeheimnis", "besondere_kategorie"} {
|
||||
if _, ok := byID[id]; !ok {
|
||||
t.Errorf("expected Stufe %q to be defined", id)
|
||||
}
|
||||
}
|
||||
if byID["besondere_kategorie"].Rang <= byID["personenbezogen"].Rang {
|
||||
t.Error("expected besondere_kategorie to outrank personenbezogen")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadDatenklasseRejectsDuplicateRang(t *testing.T) {
|
||||
fsys := fstest.MapFS{
|
||||
"datenklasse.yaml": &fstest.MapFile{Data: []byte(`
|
||||
version: 1
|
||||
stufen:
|
||||
- {id: a, rang: 1, ausloeser: [b1]}
|
||||
- {id: b, rang: 1, ausloeser: [b2]}
|
||||
`)},
|
||||
}
|
||||
if _, err := rules.LoadDatenklasse(fsys, "datenklasse.yaml"); err == nil {
|
||||
t.Fatal("expected an error for duplicate rang values")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadDatenklasseRejectsMissingVersion(t *testing.T) {
|
||||
fsys := fstest.MapFS{
|
||||
"datenklasse.yaml": &fstest.MapFile{Data: []byte(`
|
||||
stufen:
|
||||
- {id: a, rang: 1, ausloeser: [b1]}
|
||||
`)},
|
||||
}
|
||||
if _, err := rules.LoadDatenklasse(fsys, "datenklasse.yaml"); err == nil {
|
||||
t.Fatal("expected an error for a missing version")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadEinstufungRealFile(t *testing.T) {
|
||||
rw, err := rules.LoadEinstufung(realRulesFS(t), "kivo_einstufung.yaml")
|
||||
if err != nil {
|
||||
t.Fatalf("LoadEinstufung: %v", err)
|
||||
}
|
||||
if len(rw.Stufen) != 4 {
|
||||
t.Fatalf("expected 4 Stufen, got %d", len(rw.Stufen))
|
||||
}
|
||||
if rw.Stufen[0].ID != "verboten" {
|
||||
t.Fatalf("expected 'verboten' to be checked first (K.-o.-Prüfung), got %q", rw.Stufen[0].ID)
|
||||
}
|
||||
if rw.Stufen[len(rw.Stufen)-1].ID != "minimal" {
|
||||
t.Fatalf("expected 'minimal' as the last (catch-all) Stufe, got %q", rw.Stufen[len(rw.Stufen)-1].ID)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadEinstufungRejectsNonLastStufeWithoutVarianten(t *testing.T) {
|
||||
fsys := fstest.MapFS{
|
||||
"kivo_einstufung.yaml": &fstest.MapFile{Data: []byte(`
|
||||
version: 1
|
||||
stufen:
|
||||
- {id: verboten, varianten: []}
|
||||
- {id: minimal, varianten: []}
|
||||
`)},
|
||||
}
|
||||
if _, err := rules.LoadEinstufung(fsys, "kivo_einstufung.yaml"); err == nil {
|
||||
t.Fatal("expected an error when a non-last Stufe has no Varianten")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadAnforderungenRealFile(t *testing.T) {
|
||||
rw, err := rules.LoadAnforderungen(realRulesFS(t), "anforderungen.yaml")
|
||||
if err != nil {
|
||||
t.Fatalf("LoadAnforderungen: %v", err)
|
||||
}
|
||||
wantIDs := []string{
|
||||
"avv_erforderlich", "eu_verarbeitung", "kein_training_auf_eingabe",
|
||||
"loeschfrist_max_tage", "menschliche_aufsicht", "kennzeichnungspflicht", "dsfa_erforderlich",
|
||||
}
|
||||
if len(rw.Anforderungen) != len(wantIDs) {
|
||||
t.Fatalf("expected %d Anforderungen, got %d", len(wantIDs), len(rw.Anforderungen))
|
||||
}
|
||||
byID := map[string]bool{}
|
||||
for _, a := range rw.Anforderungen {
|
||||
byID[a.ID] = true
|
||||
}
|
||||
for _, id := range wantIDs {
|
||||
if !byID[id] {
|
||||
t.Errorf("expected Anforderung %q to be defined", id)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadAnforderungenRejectsAnforderungWithoutTrigger(t *testing.T) {
|
||||
fsys := fstest.MapFS{
|
||||
"anforderungen.yaml": &fstest.MapFile{Data: []byte(`
|
||||
version: 1
|
||||
anforderungen:
|
||||
- {id: x}
|
||||
`)},
|
||||
}
|
||||
if _, err := rules.LoadAnforderungen(fsys, "anforderungen.yaml"); err == nil {
|
||||
t.Fatal("expected an error for an Anforderung without any trigger")
|
||||
}
|
||||
}
|
||||
68
internal/rules/regelwerk.go
Normal file
68
internal/rules/regelwerk.go
Normal file
@@ -0,0 +1,68 @@
|
||||
// Package rules lädt das Bewertungsregelwerk (Datenklasse-Ableitung,
|
||||
// KI-VO-Einstufung, Anforderungsprofil) aus versionierten YAML-Dateien.
|
||||
// Regelbasiert, nicht ML — die Regeln liegen als Daten vor, nicht im
|
||||
// Code (siehe CLAUDE.md). Dieses Paket lädt und validiert nur die
|
||||
// Struktur; die eigentliche Auswertung gegen Fragebogen-Antworten ist
|
||||
// bewusst noch nicht Teil von Phase 1 (siehe rules/OPEN.md und die
|
||||
// Baureihenfolge in CLAUDE.md — "Ableitungen und harte Filter" ist ein
|
||||
// eigener, späterer Schritt, sobald der Fragebogen aus Phase 2 die
|
||||
// exakten Fakten-Feldnamen festlegt).
|
||||
package rules
|
||||
|
||||
// DatenklasseStufe ist eine mögliche Datenklasse mit ihren Auslösern aus
|
||||
// Fragebogen-Abschnitt B. Rang bestimmt, welche Stufe gewinnt, wenn
|
||||
// mehrere Auslöser gleichzeitig zutreffen ("höchste zutreffende Stufe
|
||||
// gewinnt") — höherer Rang gewinnt.
|
||||
type DatenklasseStufe struct {
|
||||
ID string `yaml:"id"`
|
||||
Rang int `yaml:"rang"`
|
||||
Ausloeser []string `yaml:"ausloeser"`
|
||||
Folge string `yaml:"folge"`
|
||||
}
|
||||
|
||||
// DatenklasseRegelwerk ist die vollständige Ableitungstabelle für
|
||||
// Fragebogen-Abschnitt B.
|
||||
type DatenklasseRegelwerk struct {
|
||||
Version int `yaml:"version"`
|
||||
Stufen []DatenklasseStufe `yaml:"stufen"`
|
||||
}
|
||||
|
||||
// EinstufungVariante ist eine mögliche Kombination von Fragebogen-Fakten
|
||||
// (Abschnitt C), die zu einer KI-VO-Einstufung führt — mehrere Varianten
|
||||
// sind ODER-verknüpft, die Felder innerhalb einer Variante UND-verknüpft.
|
||||
// Bewusst als freie Schlüssel-Werte-Paare statt fester Go-Felder: welche
|
||||
// Fakten-Schlüssel es gibt, legt der Fragebogen aus Phase 2 fest, nicht
|
||||
// dieses Paket.
|
||||
type EinstufungVariante map[string]any
|
||||
|
||||
// EinstufungStufe ist eine mögliche KI-VO-Einstufung.
|
||||
type EinstufungStufe struct {
|
||||
ID string `yaml:"id"`
|
||||
Quelle string `yaml:"quelle,omitempty"`
|
||||
Varianten []EinstufungVariante `yaml:"varianten"`
|
||||
}
|
||||
|
||||
// EinstufungRegelwerk ist die vollständige Ableitungstabelle für
|
||||
// Fragebogen-Abschnitt C. Die Reihenfolge der Stufen ist Prüfreihenfolge
|
||||
// (erste zutreffende Stufe gewinnt) — siehe Bewertungslogik, Schritt 1
|
||||
// (K.-o.-Prüfung: "verboten" muss zuerst geprüft werden).
|
||||
type EinstufungRegelwerk struct {
|
||||
Version int `yaml:"version"`
|
||||
Stufen []EinstufungStufe `yaml:"stufen"`
|
||||
}
|
||||
|
||||
// AnforderungsRegel leitet eine einzelne Anforderung aus Datenklasse
|
||||
// und/oder KI-VO-Einstufung ab (z. B. avv_erforderlich).
|
||||
type AnforderungsRegel struct {
|
||||
ID string `yaml:"id"`
|
||||
AusDatenklassen []string `yaml:"aus_datenklassen,omitempty"`
|
||||
AusEinstufungen []string `yaml:"aus_einstufungen,omitempty"`
|
||||
Beschreibung string `yaml:"beschreibung,omitempty"`
|
||||
}
|
||||
|
||||
// AnforderungsRegelwerk ist die vollständige Mapping-Tabelle
|
||||
// Datenklasse/Einstufung -> Anforderungsprofil.
|
||||
type AnforderungsRegelwerk struct {
|
||||
Version int `yaml:"version"`
|
||||
Anforderungen []AnforderungsRegel `yaml:"anforderungen"`
|
||||
}
|
||||
@@ -1,62 +0,0 @@
|
||||
package rules
|
||||
|
||||
// Severity ist die Schwere eines Findings.
|
||||
type Severity string
|
||||
|
||||
const (
|
||||
SeverityLow Severity = "niedrig"
|
||||
SeverityMedium Severity = "mittel"
|
||||
SeverityHigh Severity = "hoch"
|
||||
)
|
||||
|
||||
// Rule ist eine versionierte Regel aus einer YAML-Datei in rules/.
|
||||
// Regel-IDs werden nie umbenannt oder wiederverwendet — Änderungen an
|
||||
// einer Regel erhöhen die Version.
|
||||
//
|
||||
// Jurisdiction ordnet eine Regel genau einer Rechtsordnung zu (aktuell
|
||||
// nur "DE" — deutsche Rechtslage zuerst). Damit lassen sich künftige
|
||||
// AT/CH-Regeln als zusätzliche Dateien ergänzen, ohne bestehende Regeln
|
||||
// anzufassen: eine Regel gilt nie für mehrere Rechtsordnungen gleichzeitig,
|
||||
// auch wenn sich Gesetzestexte ähneln — jede Rechtsordnung bekommt ihre
|
||||
// eigene, einzeln geprüfte Fundstelle.
|
||||
type Rule struct {
|
||||
ID string `yaml:"id"`
|
||||
Version int `yaml:"version"`
|
||||
Jurisdiction string `yaml:"land"`
|
||||
Title string `yaml:"titel"`
|
||||
Condition Condition `yaml:"bedingung"`
|
||||
Severity Severity `yaml:"schwere"`
|
||||
Sources []string `yaml:"fundstelle"`
|
||||
Fix string `yaml:"korrektur"`
|
||||
}
|
||||
|
||||
// Condition ist eine flache UND-Bedingung über Facts. Ein nil/leeres
|
||||
// Feld bedeutet "keine Einschränkung durch dieses Feld".
|
||||
type Condition struct {
|
||||
Consideration []Consideration `yaml:"gegenleistung,omitempty"`
|
||||
DisclosurePresent *bool `yaml:"kennzeichnung_vorhanden,omitempty"`
|
||||
DisclosureBeforeCut *bool `yaml:"kennzeichnung_vor_kuerzung,omitempty"`
|
||||
}
|
||||
|
||||
// Matches prüft, ob f alle gesetzten Bedingungsfelder erfüllt.
|
||||
func (c Condition) Matches(f Facts) bool {
|
||||
if len(c.Consideration) > 0 {
|
||||
found := false
|
||||
for _, allowed := range c.Consideration {
|
||||
if allowed == f.Consideration {
|
||||
found = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
return false
|
||||
}
|
||||
}
|
||||
if c.DisclosurePresent != nil && *c.DisclosurePresent != f.DisclosurePresent {
|
||||
return false
|
||||
}
|
||||
if c.DisclosureBeforeCut != nil && *c.DisclosureBeforeCut != f.DisclosureBeforeCut {
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
@@ -1,133 +0,0 @@
|
||||
package rules_test
|
||||
|
||||
import (
|
||||
"testing"
|
||||
"testing/fstest"
|
||||
|
||||
"github.com/netcell-it/deklarix/internal/rules"
|
||||
)
|
||||
|
||||
func TestLoadRejectsMissingID(t *testing.T) {
|
||||
fsys := fstest.MapFS{
|
||||
"bad.yaml": &fstest.MapFile{Data: []byte("version: 1\ntitel: x\nschwere: hoch\n")},
|
||||
}
|
||||
if _, err := rules.Load(fsys); err == nil {
|
||||
t.Fatal("expected error for rule without id, got nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadRejectsMissingVersion(t *testing.T) {
|
||||
fsys := fstest.MapFS{
|
||||
"bad.yaml": &fstest.MapFile{Data: []byte("id: WK-999\ntitel: x\nschwere: hoch\n")},
|
||||
}
|
||||
if _, err := rules.Load(fsys); err == nil {
|
||||
t.Fatal("expected error for rule without version, got nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadRejectsMissingJurisdiction(t *testing.T) {
|
||||
fsys := fstest.MapFS{
|
||||
"bad.yaml": &fstest.MapFile{Data: []byte("id: WK-999\nversion: 1\ntitel: x\nschwere: hoch\n")},
|
||||
}
|
||||
if _, err := rules.Load(fsys); err == nil {
|
||||
t.Fatal("expected error for rule without land (jurisdiction), got nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadRejectsDuplicateID(t *testing.T) {
|
||||
fsys := fstest.MapFS{
|
||||
"a.yaml": &fstest.MapFile{Data: []byte("id: WK-999\nversion: 1\nland: DE\ntitel: x\nschwere: hoch\n")},
|
||||
"b.yaml": &fstest.MapFile{Data: []byte("id: WK-999\nversion: 2\nland: DE\ntitel: y\nschwere: hoch\n")},
|
||||
}
|
||||
if _, err := rules.Load(fsys); err == nil {
|
||||
t.Fatal("expected error for duplicate rule id, got nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadIgnoresNonYAMLFiles(t *testing.T) {
|
||||
fsys := fstest.MapFS{
|
||||
"a.yaml": &fstest.MapFile{Data: []byte("id: WK-999\nversion: 1\nland: DE\ntitel: x\nschwere: hoch\n")},
|
||||
"README.md": &fstest.MapFile{Data: []byte("not a rule")},
|
||||
}
|
||||
got, err := rules.Load(fsys)
|
||||
if err != nil {
|
||||
t.Fatalf("Load: %v", err)
|
||||
}
|
||||
if len(got) != 1 {
|
||||
t.Fatalf("expected 1 rule, got %d", len(got))
|
||||
}
|
||||
}
|
||||
|
||||
func TestConditionMatches(t *testing.T) {
|
||||
yes := true
|
||||
no := false
|
||||
|
||||
cases := []struct {
|
||||
name string
|
||||
cond rules.Condition
|
||||
fact rules.Facts
|
||||
want bool
|
||||
}{
|
||||
{
|
||||
name: "consideration list matches",
|
||||
cond: rules.Condition{Consideration: []rules.Consideration{rules.ConsiderationPaid}},
|
||||
fact: rules.Facts{Consideration: rules.ConsiderationPaid},
|
||||
want: true,
|
||||
},
|
||||
{
|
||||
name: "consideration list does not match",
|
||||
cond: rules.Condition{Consideration: []rules.Consideration{rules.ConsiderationPaid}},
|
||||
fact: rules.Facts{Consideration: rules.ConsiderationNone},
|
||||
want: false,
|
||||
},
|
||||
{
|
||||
name: "disclosure present must match",
|
||||
cond: rules.Condition{DisclosurePresent: &no},
|
||||
fact: rules.Facts{DisclosurePresent: true},
|
||||
want: false,
|
||||
},
|
||||
{
|
||||
name: "unset fields impose no constraint",
|
||||
cond: rules.Condition{},
|
||||
fact: rules.Facts{Consideration: rules.ConsiderationUnclear},
|
||||
want: true,
|
||||
},
|
||||
{
|
||||
name: "all constraints must hold (AND)",
|
||||
cond: rules.Condition{
|
||||
Consideration: []rules.Consideration{rules.ConsiderationPaid},
|
||||
DisclosurePresent: &yes,
|
||||
DisclosureBeforeCut: &no,
|
||||
},
|
||||
fact: rules.Facts{Consideration: rules.ConsiderationPaid, DisclosurePresent: true, DisclosureBeforeCut: false},
|
||||
want: true,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
if got := tc.cond.Matches(tc.fact); got != tc.want {
|
||||
t.Fatalf("Matches() = %v, want %v", got, tc.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestEvaluateFiltersByJurisdiction(t *testing.T) {
|
||||
rule := rules.Rule{
|
||||
ID: "WK-TEST",
|
||||
Version: 1,
|
||||
Jurisdiction: "AT",
|
||||
Condition: rules.Condition{Consideration: []rules.Consideration{rules.ConsiderationPaid}},
|
||||
Severity: rules.SeverityHigh,
|
||||
}
|
||||
fact := rules.Facts{Jurisdiction: "DE", Consideration: rules.ConsiderationPaid}
|
||||
|
||||
findings, needsClarification := rules.Evaluate([]rules.Rule{rule}, fact)
|
||||
if needsClarification {
|
||||
t.Fatal("needsClarification = true, want false")
|
||||
}
|
||||
if len(findings) != 0 {
|
||||
t.Fatalf("expected no findings for a rule from a different jurisdiction, got %v", findings)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user