feat: konfigurierbaren Freigabe-Workflow mit Genehmiger-Rollen einführen

Mandanten können jetzt selbst festlegen, wer bei welcher abgeleiteten
Bedingung (Anforderung/Einstufung/Datenklasse) zusätzlich zur
Fachebene-Entscheidung zustimmen muss (z. B. Datenschutzbeauftragter,
Geschäftsführung) - Genehmiger-Rollen sind orthogonal zu den fünf
bestehenden Zugriffsrollen. Alle ausgelösten Rollen müssen zustimmen,
eine Ablehnung kippt kaskadierend den gesamten Antrag. Mandanten ohne
Freigabe-Regeln (aktuell alle) sind unverändert vom alten Direktpfad
betroffen, siehe TestOhneFreigabeRegelnVerhaeltSichWieVorher.

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

internal/store/freigabe_test.go

@@ -0,0 +1,174 @@
+package store_test
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/netcell-it/deklarix/internal/store"
+)
+
+func TestGenehmigerRolleCRUDAndMitgliedschaft(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accID := testAccountID(t, s)
+
+	g, err := s.CreateGenehmigerRolle(ctx, accID, "Datenschutzbeauftragter")
+	if err != nil {
+		t.Fatalf("CreateGenehmigerRolle: %v", err)
+	}
+	if g.AccountID != accID || g.Name != "Datenschutzbeauftragter" {
+		t.Fatalf("GenehmigerRolle = %+v, unerwartete Werte", g)
+	}
+
+	got, err := s.GetGenehmigerRolle(ctx, g.ID)
+	if err != nil || got.Name != "Datenschutzbeauftragter" {
+		t.Fatalf("GetGenehmigerRolle = %+v, err=%v", got, err)
+	}
+
+	liste, err := s.ListGenehmigerRollenForAccount(ctx, accID)
+	if err != nil || len(liste) != 1 {
+		t.Fatalf("ListGenehmigerRollenForAccount = %+v, err=%v", liste, err)
+	}
+
+	user := testUserID(t, s, accID)
+	if err := s.AddNutzerGenehmigerRolle(ctx, user, g.ID); err != nil {
+		t.Fatalf("AddNutzerGenehmigerRolle: %v", err)
+	}
+	// Erneutes Hinzufügen derselben Zuordnung ist ein No-op (ON CONFLICT),
+	// kein Fehler.
+	if err := s.AddNutzerGenehmigerRolle(ctx, user, g.ID); err != nil {
+		t.Fatalf("AddNutzerGenehmigerRolle (erneut): %v", err)
+	}
+
+	rollenDesNutzers, err := s.ListGenehmigerRollenForUser(ctx, user)
+	if err != nil || len(rollenDesNutzers) != 1 || rollenDesNutzers[0].ID != g.ID {
+		t.Fatalf("ListGenehmigerRollenForUser = %+v, err=%v", rollenDesNutzers, err)
+	}
+
+	mitglieder, err := s.ListNutzerForGenehmigerRolle(ctx, g.ID)
+	if err != nil || len(mitglieder) != 1 || mitglieder[0].UserID != user {
+		t.Fatalf("ListNutzerForGenehmigerRolle = %+v, err=%v", mitglieder, err)
+	}
+
+	if err := s.RemoveNutzerGenehmigerRolle(ctx, user, g.ID); err != nil {
+		t.Fatalf("RemoveNutzerGenehmigerRolle: %v", err)
+	}
+	rollenNachEntfernen, err := s.ListGenehmigerRollenForUser(ctx, user)
+	if err != nil || len(rollenNachEntfernen) != 0 {
+		t.Fatalf("ListGenehmigerRollenForUser nach Entfernen = %+v, err=%v", rollenNachEntfernen, err)
+	}
+
+	if err := s.DeleteGenehmigerRolle(ctx, g.ID); err != nil {
+		t.Fatalf("DeleteGenehmigerRolle: %v", err)
+	}
+	if _, err := s.GetGenehmigerRolle(ctx, g.ID); !errors.Is(err, store.ErrNotFound) {
+		t.Fatalf("err nach Delete = %v, want ErrNotFound", err)
+	}
+}
+
+func TestFreigabeRegelCRUD(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accID := testAccountID(t, s)
+	g, err := s.CreateGenehmigerRolle(ctx, accID, "Geschaeftsfuehrung")
+	if err != nil {
+		t.Fatalf("CreateGenehmigerRolle: %v", err)
+	}
+
+	regel, err := s.CreateFreigabeRegel(ctx, accID, "einstufung", "hochrisiko", g.ID)
+	if err != nil {
+		t.Fatalf("CreateFreigabeRegel: %v", err)
+	}
+	if regel.BedingungTyp != "einstufung" || regel.BedingungWert != "hochrisiko" {
+		t.Fatalf("FreigabeRegel = %+v, unerwartete Werte", regel)
+	}
+
+	liste, err := s.ListFreigabeRegelnForAccount(ctx, accID)
+	if err != nil || len(liste) != 1 {
+		t.Fatalf("ListFreigabeRegelnForAccount = %+v, err=%v", liste, err)
+	}
+
+	got, err := s.GetFreigabeRegel(ctx, regel.ID)
+	if err != nil || got.ID != regel.ID {
+		t.Fatalf("GetFreigabeRegel = %+v, err=%v", got, err)
+	}
+
+	if err := s.DeleteFreigabeRegel(ctx, regel.ID); err != nil {
+		t.Fatalf("DeleteFreigabeRegel: %v", err)
+	}
+	if _, err := s.GetFreigabeRegel(ctx, regel.ID); !errors.Is(err, store.ErrNotFound) {
+		t.Fatalf("err nach Delete = %v, want ErrNotFound", err)
+	}
+}
+
+func TestFreigabeschrittLifecycleUndKaskade(t *testing.T) {
+	s := openTestStore(t)
+	ctx := context.Background()
+	accID := testAccountID(t, s)
+	user := testUserID(t, s, accID)
+	antrag, err := s.CreateAntrag(ctx, accID, user, nil, "Test-Antrag für Freigabeschritte")
+	if err != nil {
+		t.Fatalf("CreateAntrag: %v", err)
+	}
+	antragID := antrag.ID
+
+	dsb, _ := s.CreateGenehmigerRolle(ctx, accID, "Datenschutzbeauftragter")
+	gf, _ := s.CreateGenehmigerRolle(ctx, accID, "Geschaeftsfuehrung")
+
+	schrittDSB, err := s.CreateFreigabeschritt(ctx, antragID, dsb.ID)
+	if err != nil {
+		t.Fatalf("CreateFreigabeschritt: %v", err)
+	}
+	if schrittDSB.Status != "ausstehend" {
+		t.Fatalf("Status = %q, want ausstehend", schrittDSB.Status)
+	}
+	schrittGF, err := s.CreateFreigabeschritt(ctx, antragID, gf.ID)
+	if err != nil {
+		t.Fatalf("CreateFreigabeschritt: %v", err)
+	}
+
+	alle, err := s.ListFreigabeschritteForAntrag(ctx, antragID)
+	if err != nil || len(alle) != 2 {
+		t.Fatalf("ListFreigabeschritteForAntrag = %+v, err=%v", alle, err)
+	}
+
+	ausstehend, err := s.ListAusstehendeFreigabeschritteForUser(ctx, user)
+	if err != nil {
+		t.Fatalf("ListAusstehendeFreigabeschritteForUser: %v", err)
+	}
+	if len(ausstehend) != 0 {
+		t.Fatalf("erwartet 0 ausstehende Freigaben ohne Genehmiger-Rollen-Zuordnung, got %d", len(ausstehend))
+	}
+	if err := s.AddNutzerGenehmigerRolle(ctx, user, dsb.ID); err != nil {
+		t.Fatalf("AddNutzerGenehmigerRolle: %v", err)
+	}
+	ausstehend, err = s.ListAusstehendeFreigabeschritteForUser(ctx, user)
+	if err != nil || len(ausstehend) != 1 || ausstehend[0].ID != schrittDSB.ID {
+		t.Fatalf("ListAusstehendeFreigabeschritteForUser = %+v, err=%v", ausstehend, err)
+	}
+
+	entschieden, err := s.EntscheideFreigabeschritt(ctx, schrittDSB.ID, "abgelehnt", user, "nicht ausreichend")
+	if err != nil {
+		t.Fatalf("EntscheideFreigabeschritt: %v", err)
+	}
+	if entschieden.Status != "abgelehnt" || entschieden.EntschiedenVon == nil || *entschieden.EntschiedenVon != user {
+		t.Fatalf("Freigabeschritt nach Entscheidung = %+v, unerwartete Werte", entschieden)
+	}
+
+	// Ein bereits entschiedener Schritt kann nicht erneut entschieden werden.
+	if _, err := s.EntscheideFreigabeschritt(ctx, schrittDSB.ID, "genehmigt", user, ""); !errors.Is(err, store.ErrNotFound) {
+		t.Fatalf("erneute Entscheidung err = %v, want ErrNotFound", err)
+	}
+
+	if err := s.KaskadiereAblehnung(ctx, antragID, schrittDSB.ID); err != nil {
+		t.Fatalf("KaskadiereAblehnung: %v", err)
+	}
+	nachKaskade, err := s.GetFreigabeschritt(ctx, schrittGF.ID)
+	if err != nil {
+		t.Fatalf("GetFreigabeschritt: %v", err)
+	}
+	if nachKaskade.Status != "abgelehnt" {
+		t.Fatalf("Status nach Kaskade = %q, want abgelehnt", nachKaskade.Status)
+	}
+}