Suche zeigt alle Arten, nur Arbeitsrollen öffnen die Akte

Punkt 1 und 2 der Wünsche, plus zwei Lücken, die dabei sichtbar wurden.

**Suche.** Wer nach Alvarez sucht, landet auf den Fallakten und erfährt nie,
dass es dazu auch eine Personalakte gibt: die Suche fand sie, aber hinter einem
Reiter, auf den nichts hindeutete. Die Reiter tragen jetzt ihre Trefferzahl,
und ein leeres Ergebnis nennt ausdrücklich, wo etwas liegt.

Dabei fiel auf, dass searchPersonnel das Recht personnel.read nicht prüfte. Die
Kommandopalette tat es, die Aktenseite tat es, die Suche nicht — über
/suche?kind=personnel kam jeder mit ausreichender Stufe an eine Liste aller
Personalakten mit Namen, Dienstgrad und Etiketten. Die Prüfung steht jetzt
dort, wo diese Akten herausgegeben werden. Die Trefferzahl einer Art, die es
für den Nutzer nicht gibt, ist null und nicht 0: eine Null wäre die Auskunft
„hier ist nichts", und die steht ihm nicht zu.

**Täter und Mittäter** als Beteiligtenrollen — und damit wurde eine ältere
Lücke offensichtlich: ein Beteiligter durfte die Akte lesen, gleich in welcher
Rolle. Bei „Betroffener" fiel das nicht auf, bei „Täter" wäre es offensichtlich
falsch. Der Beschuldigte hätte die Ermittlung gegen sich selbst mitgelesen.

Die Beteiligtenliste beantwortet zwei Fragen: wer bearbeitet den Fall, und um
wen geht es darin. Nur die erste ist eine Berechtigung. WORKING_ROLES nennt die
drei, die die Akte öffnen; Zeuge, Betroffener, Täter und Mittäter öffnen
nichts. Das gilt an allen vier Stellen, die auf Beteiligung prüften:
Aktenzugriff, Dokumentzugriff über die besitzende Akte, „meine Fälle" und der
Filter „nur meine".

Zwei bestehende Tests hatten die alte Annahme festgeschrieben und benutzten
WITNESS, um Zugriff zu belegen; sie prüfen jetzt mit INVESTIGATOR.

web/lib/access/caseFilter.ts

@@ -1,5 +1,6 @@
 import type { Prisma } from '@afis/db'
 import type { EffectivePermissions } from '@/lib/auth/permissions'
+import { WORKING_ROLES } from '@/lib/cases/terms'
 
 /**
  * Where-Fragment für alle Akten, die ein Nutzer lesen darf.
@@ -11,10 +12,15 @@ import type { EffectivePermissions } from '@/lib/auth/permissions'
  * Reihenfolge nach dem Dokument, erste zutreffende Regel gewinnt:
  *  1. Ausschluss → kein Zugriff, egal welche Stufe
  *  2. Admin → Zugriff
- *  3. Beteiligter → Zugriff
+ *  3. Beteiligter **in einer Arbeitsrolle** → Zugriff
  *  4. Stufe reicht → Zugriff
  *  5. sonst kein Zugriff
  *
+ * Zu 3.: Die Beteiligtenliste beantwortet zwei Fragen — wer bearbeitet den
+ * Fall, und um wen geht es darin. Nur die erste verschafft Zugang. Ein
+ * Betroffener, ein Zeuge oder ein Täter mit Discord-Konto läse sonst die
+ * Ermittlung gegen sich selbst mit. Siehe lib/cases/terms.ts.
+ *
  * Der Ausschluss steht auch über dem Admin. Das Codebeispiel im Dokument gibt
  * für Admins `{}` zurück und übergeht ihn damit — das widerspricht der
  * Reihenfolge eine Zeile darüber. Hier gilt die Reihenfolge: der Ausschluss
@@ -27,15 +33,16 @@ export function visibleCaseWhere(p: EffectivePermissions): Prisma.CaseWhereInput
     exclusions: { none: { userId: p.userId } },
   }
 
+  const arbeitetDaran: Prisma.CaseWhereInput = {
+    participants: { some: { userId: p.userId, role: { in: [...WORKING_ROLES] } } },
+  }
+
   if (p.isAdmin) return notExcluded
 
   const conditions: Prisma.CaseWhereInput[] = [
     notExcluded,
     {
-      OR: [
-        { participants: { some: { userId: p.userId } } },
-        { classification: { lte: p.clearanceLevel } },
-      ],
+      OR: [arbeitetDaran, { classification: { lte: p.clearanceLevel } }],
     },
   ]
 

web/lib/access/personnelFilter.ts

@@ -1,6 +1,7 @@
 import type { Prisma } from '@afis/db'
 import type { EffectivePermissions } from '@/lib/auth/permissions'
 import { visibleCaseWhere } from '@/lib/access/caseFilter'
+import { WORKING_ROLES } from '@/lib/cases/terms'
 
 /**
  * Where-Fragmente für Personalakten und Dokumente.
@@ -72,7 +73,11 @@ export function visibleDocumentWhere(p: EffectivePermissions): Prisma.DocumentWh
       {
         OR: [
           { classification: { lte: p.clearanceLevel } },
-          { case: { is: { participants: { some: { userId: p.userId } } } } },
+          {
+            case: {
+              is: { participants: { some: { userId: p.userId, role: { in: [...WORKING_ROLES] } } } },
+            },
+          },
         ],
       },
     ],

web/lib/cases/terms.ts

@@ -14,9 +14,11 @@
 export const PARTICIPANT_ROLES = [
   'LEAD',
   'INVESTIGATOR',
+  'OBSERVER',
   'WITNESS',
   'SUBJECT',
-  'OBSERVER',
+  'SUSPECT',
+  'ACCOMPLICE',
 ] as const
 
 export type ParticipantRoleName = (typeof PARTICIPANT_ROLES)[number]
@@ -25,6 +27,29 @@ export function isParticipantRole(value: string): value is ParticipantRoleName {
   return (PARTICIPANT_ROLES as readonly string[]).includes(value)
 }
 
+/**
+ * Wer an der Akte **arbeitet** — und nur diese drei Rollen öffnen sie auch.
+ *
+ * Die Beteiligtenliste beantwortet zwei ganz verschiedene Fragen: *wer bearbeitet
+ * diesen Fall* und *um wen geht es darin*. Sie standen bisher gleichberechtigt
+ * nebeneinander, und weil ein Beteiligter die Akte lesen darf, hätte ein
+ * Betroffener mit Discord-Konto die Ermittlung gegen sich selbst mitlesen
+ * können. Mit „Täter" und „Mittäter" wäre das offensichtlich falsch geworden,
+ * es war es vorher schon.
+ *
+ * Deshalb: **nur Arbeitsrollen öffnen die Akte.** Zeuge, Betroffener, Täter und
+ * Mittäter sind Angaben über den Fall, keine Berechtigung an ihm.
+ * Siehe docs/03-auth-und-rechte.md.
+ */
+export const WORKING_ROLES = ['LEAD', 'INVESTIGATOR', 'OBSERVER'] as const
+
+export type WorkingRoleName = (typeof WORKING_ROLES)[number]
+
+/** Ob diese Rolle Zugang zur Akte verschafft. */
+export function grantsCaseAccess(role: string): boolean {
+  return (WORKING_ROLES as readonly string[]).includes(role)
+}
+
 export const LINK_KINDS = ['RELATED', 'SUCCESSOR', 'MERGED_INTO'] as const
 
 export type LinkKindName = (typeof LINK_KINDS)[number]

web/lib/dashboard/load.ts

@@ -4,6 +4,7 @@ import { visibleMessageWhere } from '@/lib/access/chatFilter'
 import { visiblePersonnelWhere } from '@/lib/access/personnelFilter'
 import { listWatched } from '@/lib/cases/watch'
 import { listRecent } from '@/lib/recent/service'
+import { WORKING_ROLES } from '@/lib/cases/terms'
 import type { EffectivePermissions } from '@/lib/auth/permissions'
 import type { Prisma } from '@afis/db'
 
@@ -39,7 +40,7 @@ export async function loadDashboard(p: EffectivePermissions) {
       where: {
         AND: [
           sichtbar,
-          { participants: { some: { userId: p.userId } } },
+          { participants: { some: { userId: p.userId, role: { in: [...WORKING_ROLES] } } } },
           { status: { in: ['DRAFT', 'OPEN', 'REVIEW'] } },
         ],
       },
@@ -105,7 +106,7 @@ async function ungeleseneChats(p: EffectivePermissions): Promise<UnreadChat[]> {
           visibleCaseWhere(p),
           {
             OR: [
-              { participants: { some: { userId: p.userId } } },
+              { participants: { some: { userId: p.userId, role: { in: [...WORKING_ROLES] } } } },
               { watches: { some: { userId: p.userId } } },
             ],
           },

web/lib/i18n/cases.ts

@@ -133,14 +133,18 @@ export const participantText = {
   pickUser: 'Mitglied',
   pickPersonnel: 'Personalakte',
   hint:
-    'Wer hier steht, liest die Akte unabhängig von seiner Freigabestufe. Das ist der Weg, jemanden ausnahmsweise hinzuzuziehen.',
+    'Ermittlungsführung, Ermittler und Beobachter lesen die Akte unabhängig von ihrer Freigabestufe. Das ist der Weg, jemanden ausnahmsweise hinzuzuziehen. Zeuge, Betroffener, Täter und Mittäter sind Angaben über den Fall und öffnen ihn nicht.',
   roles: {
     LEAD: 'Ermittlungsführung',
     INVESTIGATOR: 'Ermittler',
+    OBSERVER: 'Beobachter',
     WITNESS: 'Zeuge',
     SUBJECT: 'Betroffener',
-    OBSERVER: 'Beobachter',
+    SUSPECT: 'Täter',
+    ACCOMPLICE: 'Mittäter',
   } as Record<string, string>,
+  groupWorking: 'Bearbeitet die Akte',
+  groupSubject: 'Gegenstand der Akte',
 } as const
 
 export const linkText = {

web/lib/i18n/shell.ts

@@ -141,6 +141,8 @@ export const searchText = {
   empty: 'Kein Treffer. Anderen Begriff oder weniger Filter versuchen.',
   emptyNoQuery: 'Begriff eingeben oder einen Filter wählen.',
   countLabel: (n: number) => (n === 1 ? '1 Treffer' : `${n} Treffer`),
+  elsewhere: (label: string, n: number) =>
+    n === 1 ? `1 Treffer unter ${label}` : `${n} Treffer unter ${label}`,
   more: 'Weitere laden',
   truncated:
     'Sehr viele Treffer. Angezeigt werden die besten; mit einem genaueren Begriff wird die Liste vollständig.',

web/lib/search/service.ts

@@ -2,6 +2,7 @@ import { db } from '@/lib/db'
 import { visibleCaseWhere } from '@/lib/access/caseFilter'
 import { visibleDocumentWhere, visiblePersonnelWhere } from '@/lib/access/personnelFilter'
 import type { SearchFilters } from '@/lib/search/query'
+import { WORKING_ROLES } from '@/lib/cases/terms'
 import type { EffectivePermissions } from '@/lib/auth/permissions'
 import type { Prisma } from '@afis/db'
 
@@ -28,6 +29,19 @@ const FTS_LIMIT = 500
 
 export const PAGE_SIZE = 25
 
+/**
+ * Personalakten setzen neben der Freigabestufe ein eigenes Recht voraus.
+ *
+ * Das stand in der Kommandopalette und auf der Aktenseite, fehlte aber in der
+ * Suche — ein Nutzer mit hoher Stufe und ohne `personnel.read` konnte sich
+ * über `/suche?kind=personnel` eine Liste aller Personalakten holen. Die
+ * Prüfung gehört an **jede** Stelle, die diese Akten herausgibt, und deshalb
+ * in diese Datei und nicht in die Seite.
+ */
+function darfPersonalakten(p: EffectivePermissions): boolean {
+  return p.isAdmin || p.permissions.has('personnel.read')
+}
+
 export type Facet = { value: string; count: number }
 
 async function matchingIds(
@@ -64,7 +78,11 @@ function caseWhere(
   if (filters.classification !== undefined) {
     bedingungen.push({ classification: filters.classification })
   }
-  if (filters.mine) bedingungen.push({ participants: { some: { userId: p.userId } } })
+  if (filters.mine) {
+    bedingungen.push({
+      participants: { some: { userId: p.userId, role: { in: [...WORKING_ROLES] } } },
+    })
+  }
   if (filters.dueBefore) {
     bedingungen.push({ dueAt: { not: null, lte: new Date(filters.dueBefore) } })
   }
@@ -136,9 +154,12 @@ export async function searchCases(p: EffectivePermissions, filters: SearchFilter
   }
 }
 
-export async function searchDocuments(p: EffectivePermissions, filters: SearchFilters) {
-  const ids = await matchingIds('document', filters.q, p.clearanceLevel)
-  const where: Prisma.DocumentWhereInput = {
+function documentWhere(
+  p: EffectivePermissions,
+  filters: SearchFilters,
+  ids: string[] | null,
+): Prisma.DocumentWhereInput {
+  return {
     AND: [
       visibleDocumentWhere(p),
       ...(ids !== null ? [{ id: { in: ids } }] : []),
@@ -148,6 +169,11 @@ export async function searchDocuments(p: EffectivePermissions, filters: SearchFi
         : []),
     ],
   }
+}
+
+export async function searchDocuments(p: EffectivePermissions, filters: SearchFilters) {
+  const ids = await matchingIds('document', filters.q, p.clearanceLevel)
+  const where = documentWhere(p, filters, ids)
 
   const [hits, total] = await Promise.all([
     db.document.findMany({
@@ -170,9 +196,12 @@ export async function searchDocuments(p: EffectivePermissions, filters: SearchFi
   return { hits, total, truncated: ids !== null && ids.length === FTS_LIMIT }
 }
 
-export async function searchPersonnel(p: EffectivePermissions, filters: SearchFilters) {
-  const ids = await matchingIds('personnel', filters.q, p.clearanceLevel)
-  const where: Prisma.PersonnelFileWhereInput = {
+function personnelWhere(
+  p: EffectivePermissions,
+  filters: SearchFilters,
+  ids: string[] | null,
+): Prisma.PersonnelFileWhereInput {
+  return {
     AND: [
       visiblePersonnelWhere(p),
       ...(ids !== null ? [{ id: { in: ids } }] : []),
@@ -181,6 +210,16 @@ export async function searchPersonnel(p: EffectivePermissions, filters: SearchFi
         : []),
     ],
   }
+}
+
+export async function searchPersonnel(p: EffectivePermissions, filters: SearchFilters) {
+  // Ohne das Recht gibt es diese Akten für ihn nicht — auch nicht als Zahl.
+  if (!darfPersonalakten(p)) {
+    return { hits: [], total: 0, truncated: false }
+  }
+
+  const ids = await matchingIds('personnel', filters.q, p.clearanceLevel)
+  const where = personnelWhere(p, filters, ids)
 
   const [hits, total] = await Promise.all([
     db.personnelFile.findMany({
@@ -215,3 +254,39 @@ function zuFacet(rows: { _count: { _all: number } }[], key: string): Facet[] {
     }))
     .sort((a, b) => b.count - a.count)
 }
+
+/**
+ * Wie viele Treffer es je Art gibt.
+ *
+ * Der Anlass war eine Beobachtung aus dem Betrieb: wer nach einem Namen sucht,
+ * landet auf den Fallakten und **sieht nicht**, dass es zu demselben Namen
+ * auch eine Personalakte gibt. Die Suche fand sie, aber hinter einem Reiter,
+ * den niemand anklickt, wenn nichts darauf hindeutet.
+ *
+ * Die Zahlen entstehen mit **denselben** Bedingungen wie die Trefferlisten.
+ * Eine Zahl, die mehr zählt als die Liste hergibt, wäre selbst eine
+ * Information — siehe harte Regel 6.
+ *
+ * `null` heisst: diese Art gibt es für diesen Nutzer nicht. Nicht `0` — eine
+ * Null wäre die Auskunft „hier ist nichts", und die steht ihm nicht zu.
+ */
+export async function searchCounts(
+  p: EffectivePermissions,
+  filters: SearchFilters,
+): Promise<{ case: number; document: number; personnel: number | null }> {
+  const [fallIds, dokumentIds, personIds] = await Promise.all([
+    matchingIds('case', filters.q, p.clearanceLevel),
+    matchingIds('document', filters.q, p.clearanceLevel),
+    darfPersonalakten(p) ? matchingIds('personnel', filters.q, p.clearanceLevel) : null,
+  ])
+
+  const [faelle, dokumente, personen] = await Promise.all([
+    db.case.count({ where: caseWhere(p, filters, fallIds) }),
+    db.document.count({ where: documentWhere(p, filters, dokumentIds) }),
+    darfPersonalakten(p)
+      ? db.personnelFile.count({ where: personnelWhere(p, filters, personIds) })
+      : Promise.resolve(null),
+  ])
+
+  return { case: faelle, document: dokumente, personnel: personen }
+}