Beteiligte in den Suchindex der Fallakte

Wer „Jonathan Fletcher" eingibt, will die Akten sehen, in denen er vorkommt -
auch die, in denen er weder im Titel steht noch im Text erwähnt wird, sondern
nur als Betroffener eingetragen ist. Genau das wurde nicht gefunden.

Die Namen der Beteiligten stehen jetzt im Vektor der Fallakte, Gewicht B: ein
Name sagt etwas über die Akte aus, aber weniger als ihr Titel. In allen sechs
Vektoren und nicht erst ab einer Stufe - das ist die Stelle, an der man zweimal
hinsehen muss, und sie war bereits entschieden: der Name eines Beteiligten
steht in der Beteiligtenliste jeder Akte, die man lesen darf, zurückgehalten
wird allein der Verweis auf seine Personalakte. Der Index gibt also nichts
heraus, was die Akte nicht ohnehin zeigt.

Die Akte selbst muss man weiterhin lesen dürfen. Ein Test prüft genau das: eine
Stufe-4-Akte wird über den Namen ihres Zeugen für Stufe 1 nicht auffindbar,
auch nicht als Trefferzahl.

Drei Auslöser halten den Index aktuell: geänderte Beteiligung, geänderter Name
in einer Personalakte, geänderter Anzeigename eines Kontos. Den letzten gleicht
der Worker mit Discord ab; ohne ihn fände die Suche nach einer Umbenennung
weiter den alten Namen.

Die Trefferzeile sagt dazu, warum sie passt: „Jonathan Fletcher als
Betroffener". Ohne den Hinweis sieht ein Treffer, dessen Begriff nirgends im
sichtbaren Text steht, wie ein Fehlgriff aus.

web/app/(app)/suche/page.tsx

@@ -10,6 +10,7 @@ import {
 } from '@/lib/search/query'
 import {
   PREVIEW_SIZE,
+  matchingParticipants,
   searchCases,
   searchCounts,
   searchDocuments,
@@ -85,6 +86,13 @@ export default async function SearchPage({
   const statusTags =
     alle || filters.kind === 'personnel' ? await listStatusTags() : []
 
+  // Warum ein Fall zu einem Namen passt: seit die Beteiligten im Index stehen,
+  // trifft die Suche auch Akten, in denen der Name nirgends im Text steht.
+  const beteiligungen = await matchingParticipants(
+    (faelle?.hits ?? []).map((treffer) => treffer.id),
+    filters.q,
+  )
+
   return (
     <main className="mx-auto max-w-5xl px-6 py-10">
       <div className="flex flex-wrap items-baseline justify-between gap-4">
@@ -191,7 +199,12 @@ export default async function SearchPage({
                   <ul className="mt-3 border-t border-line">
                     {teil.hits.map((treffer) => (
                       <li key={treffer.id} className="border-b border-line">
-                        <Treffer treffer={treffer} levelName={levelName} statusTags={statusTags} />
+                        <Treffer
+                          treffer={treffer}
+                          levelName={levelName}
+                          statusTags={statusTags}
+                          beteiligung={beteiligungen.get(treffer.id)}
+                        />
                       </li>
                     ))}
                   </ul>
@@ -225,7 +238,12 @@ export default async function SearchPage({
         <ul className="mt-6 border-t border-line">
           {ergebnis!.hits.map((treffer) => (
             <li key={treffer.id} className="border-b border-line">
-              <Treffer treffer={treffer} levelName={levelName} statusTags={statusTags} />
+              <Treffer
+                treffer={treffer}
+                levelName={levelName}
+                statusTags={statusTags}
+                beteiligung={beteiligungen.get(treffer.id)}
+              />
             </li>
           ))}
         </ul>
@@ -268,10 +286,13 @@ function Treffer({
   treffer,
   levelName,
   statusTags,
+  beteiligung,
 }: {
   treffer: TrefferView
   levelName: Map<number, string>
   statusTags: { key: string; name: string; colorToken: string }[]
+  /** Gesetzt, wenn der Treffer an einem Beteiligten hängt und nicht am Text. */
+  beteiligung?: { name: string; role: string }[]
 }) {
   const zeile = 'flex flex-wrap items-baseline gap-x-4 gap-y-1 py-3 pl-3 text-text no-underline'
 
@@ -284,7 +305,21 @@ function Treffer({
         style={classificationEdgeStyle(treffer.classification)}
       >
         <span className="font-mono text-xs text-text-dim">{treffer.caseNumber}</span>
-        <span className="grow">{treffer.title}</span>
+        <span className="grow">
+          {treffer.title}
+          {beteiligung && beteiligung.length > 0 ? (
+            <span className="mt-0.5 block text-2xs text-text-dim">
+              {beteiligung
+                .map((eintrag) =>
+                  de.search.asParticipant(
+                    eintrag.name,
+                    de.participant.roles[eintrag.role] ?? eintrag.role,
+                  ),
+                )
+                .join(' · ')}
+            </span>
+          ) : null}
+        </span>
         <span className="font-condensed text-2xs text-text-dim">
           {de.case.statusNames[treffer.status] ?? treffer.status}
         </span>

web/lib/i18n/shell.ts

@@ -139,6 +139,7 @@ export const searchText = {
     personnel: 'Personalakten',
   } as Record<string, string>,
   showAllOfKind: (label: string) => `Alle ${label} zeigen`,
+  asParticipant: (name: string, rolle: string) => `${name} als ${rolle}`,
   filters: 'Filter',
   reset: 'Filter zurücksetzen',
   empty: 'Kein Treffer. Anderen Begriff oder weniger Filter versuchen.',

web/lib/search/service.ts

@@ -310,3 +310,65 @@ export async function searchCounts(
 
   return { case: faelle, document: dokumente, personnel: personen }
 }
+
+/**
+ * Warum ein Fall zu einem Namen passt.
+ *
+ * Seit die Beteiligten im Index stehen, findet die Suche nach „Jonathan
+ * Fletcher" auch Akten, in denen der Name nirgends im Text vorkommt. Ohne
+ * einen Hinweis sieht das aus wie ein Fehlgriff — die Trefferzeile zeigt
+ * deshalb, in welcher Rolle die Person dort steht.
+ *
+ * Gesucht wird nur unter den Akten, die als Treffer ohnehin schon durch die
+ * Sichtbarkeitsprüfung gekommen sind. Name und Rolle eines Beteiligten darf
+ * jeder lesen, der die Akte lesen darf; zurückgehalten wird allein der Verweis
+ * auf seine Personalakte, und den gibt es hier gar nicht.
+ */
+export type Beteiligung = { name: string; role: string }
+
+export async function matchingParticipants(
+  caseIds: string[],
+  q: string,
+): Promise<Map<string, Beteiligung[]>> {
+  const woerter = q
+    .replace(/["']/g, ' ')
+    .split(/\s+/)
+    .map((wort) => wort.trim())
+    .filter((wort) => wort.length >= 3)
+    .slice(0, 5)
+
+  if (caseIds.length === 0 || woerter.length === 0) return new Map()
+
+  const rows = await db.caseParticipant.findMany({
+    where: {
+      caseId: { in: caseIds },
+      OR: woerter.flatMap((wort) => [
+        { user: { is: { displayName: { contains: wort, mode: 'insensitive' as const } } } },
+        {
+          personnelFile: {
+            is: { displayName: { contains: wort, mode: 'insensitive' as const } },
+          },
+        },
+      ]),
+    },
+    select: {
+      caseId: true,
+      role: true,
+      user: { select: { displayName: true } },
+      personnelFile: { select: { displayName: true } },
+    },
+  })
+
+  const karte = new Map<string, Beteiligung[]>()
+  for (const row of rows) {
+    const name = row.user?.displayName ?? row.personnelFile?.displayName
+    if (!name) continue
+    const bisher = karte.get(row.caseId) ?? []
+    // Dieselbe Person kann in mehreren Rollen eingetragen sein; jede zählt.
+    if (!bisher.some((e) => e.name === name && e.role === row.role)) {
+      bisher.push({ name, role: row.role })
+    }
+    karte.set(row.caseId, bisher)
+  }
+  return karte
+}

web/tests/suche.test.ts

@@ -1,7 +1,12 @@
 // @vitest-environment node
 import { afterAll, beforeAll, describe, expect, it } from 'vitest'
 import { db } from '@/lib/db'
-import { searchCases, searchCounts, searchPersonnel } from '@/lib/search/service'
+import {
+  matchingParticipants,
+  searchCases,
+  searchCounts,
+  searchPersonnel,
+} from '@/lib/search/service'
 import { parseFilters, toSearchParams } from '@/lib/search/query'
 import type { EffectivePermissions, Permission } from '@/lib/auth/permissions'
 
@@ -217,6 +222,70 @@ suite('Volltextsuche', () => {
     expect(ohneRecht.personnel).toBeNull()
   })
 
+  it('findet eine Akte über den Namen eines Beteiligten', async () => {
+    // Der eigentliche Fall: der Name steht weder im Titel noch im Text, die
+    // Person ist nur als Betroffene eingetragen.
+    const name = `Jonathan Feldmann ${Date.now().toString(36)}`
+    const person = await db.personnelFile.create({
+      data: { displayName: name, classification: 1 },
+    })
+    const vorlage = await db.documentTemplate.findFirstOrThrow({
+      where: { key: { startsWith: marke } },
+    })
+    const akte = await db.case.create({
+      data: {
+        templateId: vorlage.id,
+        templateKey: vorlage.key,
+        createdById: nutzer.stufe4,
+        caseNumber: `Btl-2026-${Date.now().toString(36)}`,
+        title: 'Vorgang ohne Namen im Titel',
+        classification: 1,
+        status: 'OPEN',
+      },
+    })
+
+    // Vorher: nichts zu finden.
+    const vorher = await searchCases(perms(nutzer.stufe1, 1), filter(name))
+    expect(vorher.hits.map((h) => h.id)).not.toContain(akte.id)
+
+    await db.caseParticipant.create({
+      data: { caseId: akte.id, personnelFileId: person.id, role: 'SUBJECT' },
+    })
+
+    // Nachher: der Auslöser hat den Index nachgezogen.
+    const nachher = await searchCases(perms(nutzer.stufe1, 1), filter(name))
+    expect(nachher.hits.map((h) => h.id)).toContain(akte.id)
+
+    // Und die Trefferzeile kann sagen, warum.
+    const warum = await matchingParticipants([akte.id], name)
+    expect(warum.get(akte.id)).toEqual([{ name, role: 'SUBJECT' }])
+
+    // Wird die Beteiligung wieder aufgehoben, verschwindet der Treffer.
+    await db.caseParticipant.deleteMany({ where: { caseId: akte.id, personnelFileId: person.id } })
+    const danach = await searchCases(perms(nutzer.stufe1, 1), filter(name))
+    expect(danach.hits.map((h) => h.id)).not.toContain(akte.id)
+  })
+
+  it('macht über einen Beteiligten keine zu hoch eingestufte Akte auffindbar', async () => {
+    // Der Name eines Beteiligten steht in jeder Akte, die man lesen darf —
+    // aber die Akte selbst muss man lesen dürfen. Sonst wäre die Suche nach
+    // einem Namen ein Weg, die Existenz einer Akte zu erraten.
+    const name = `Verdeckte Person ${Date.now().toString(36)}`
+    const person = await db.personnelFile.create({
+      data: { displayName: name, classification: 1 },
+    })
+    await db.caseParticipant.create({
+      data: { caseId: geheimId, personnelFileId: person.id, role: 'WITNESS' },
+    })
+
+    const niedrig = await searchCases(perms(nutzer.stufe1, 1), filter(name))
+    expect(niedrig.hits.map((h) => h.id)).not.toContain(geheimId)
+    expect(niedrig.total).toBe(0)
+
+    const hoch = await searchCases(perms(nutzer.stufe4, 4), filter(name))
+    expect(hoch.hits.map((h) => h.id)).toContain(geheimId)
+  })
+
   it('aktualisiert den Index, wenn ein Eintrag geändert wird', async () => {
     const neu = `Umgeschrieben${Date.now()}`
     await db.caseEntry.update({