Phase 4 abgeschlossen: Personalakten, Dokumente, Beteiligte, Verknüpfungen
Die Dokumentebene aus docs/13 ist gebaut, additiv: Document, DocumentSection und DocumentSectionVersion neben Case, CaseSection und CaseEntry. Ein Dokument hängt an einer Fallakte, an einer Personalakte oder an nichts, höchstens an einem — gesichert durch eine CHECK-Bedingung. Es gibt kein DELETE; eine Zurücknahme lässt einen Grabstein stehen, der auch für den Admin zu ist. Eine neue Dokumentart ist damit ein Datensatz, kein Deployment. Im Seed stehen vier: vermerk, vorfallsbericht, sonderarbeitsvertrag (mehrseitiger Vertragstext mit Platzhaltern und Unterschriftenzeilen) und bussgeld. Zwei Umbenennungen, beide von Hand migriert, damit die vorhandenen Zeilen und Zählerstände stehen bleiben: - CaseTemplate -> DocumentTemplate, plus uses[] und layout - CaseCounter -> NumberSeries, ein Nummernkreis je Präfix für Aktenzeichen und Dokumentnummern Die Regeln für Abschnitte stehen jetzt einmal in lib/sections/render.ts und gelten für Fallakten und Dokumente gleichermaßen. Die Frage aus docs/13, ob CaseSection langfristig in die Dokumentebene wandert, ist damit verneint und begründet. Rückverweise auf der Personalakte laufen durch visibleCaseWhere, die Zahl daneben entsteht aus dem gefilterten Ergebnis. Auch die Rollengruppe verschwindet mit, sonst verriete "Betroffener" ohne Eintrag die Ermittlung. Die eigene Personalakte ist keine Ausnahme von der Freigabestufe. Vier neue Rechte: document.create, .edit, .finalize, .retract. Das letzte steht bei den zurückgehaltenen, es greift in Geschriebenes ein. 91 Tests im Web-Paket, 15 in der Datenbank, 28 e2e. Größte Route 118 kB gegen das Budget von 120 kB — die Luft wird knapp. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Harlekin
co-authored by
Claude Opus 5
Claude Opus 5
parent
f5769ca58a
commit
d65cc95eb2
@@ -30,7 +30,7 @@ let templateId = ''
|
||||
suite('Abschnitte', () => {
|
||||
beforeAll(async () => {
|
||||
db = createPrismaClient(url)
|
||||
const vorlage = await db.caseTemplate.create({
|
||||
const vorlage = await db.documentTemplate.create({
|
||||
data: { key: `${marke}-vorlage`, version: 1, name: 'Prüfvorlage', fields: FELDER },
|
||||
})
|
||||
templateId = vorlage.id
|
||||
|
||||
@@ -0,0 +1,172 @@
|
||||
// @vitest-environment node
|
||||
import { afterAll, beforeAll, describe, expect, it } from 'vitest'
|
||||
import { db } from '@/lib/db'
|
||||
import { createPersonnelFile } from '@/lib/personnel/service'
|
||||
import {
|
||||
createDocument,
|
||||
finalizeDocument,
|
||||
listTemplatesFor,
|
||||
loadDocumentSections,
|
||||
loadVisibleDocument,
|
||||
retractDocument,
|
||||
saveDocumentSection,
|
||||
} from '@/lib/documents/service'
|
||||
import { AccessError } from '@/lib/errors'
|
||||
import type { EffectivePermissions, Permission } from '@/lib/auth/permissions'
|
||||
|
||||
/**
|
||||
* Der Weg, den ein Sonderarbeitsvertrag wirklich nimmt: Personalakte anlegen,
|
||||
* Dokument aus der Vorlage erzeugen, Felder füllen, ausfertigen, zurückziehen.
|
||||
*
|
||||
* Läuft gegen die Startvorlagen aus dem Seed. Wenn diese Prüfung bricht, ist
|
||||
* entweder die Vorlage kaputt oder die Dokumentebene.
|
||||
*/
|
||||
const url = process.env.DIRECT_DATABASE_URL ?? process.env.DATABASE_URL
|
||||
const suite = url ? describe : describe.skip
|
||||
|
||||
const marke = `ablauf-${Date.now()}`
|
||||
|
||||
function perms(
|
||||
userId: string,
|
||||
clearanceLevel: number,
|
||||
permissions: Permission[] = [],
|
||||
): EffectivePermissions {
|
||||
return {
|
||||
userId,
|
||||
clearanceLevel,
|
||||
permissions: new Set<Permission>(permissions),
|
||||
isAdmin: false,
|
||||
hasMembership: true,
|
||||
}
|
||||
}
|
||||
|
||||
suite('Ein Sonderarbeitsvertrag von Anfang bis Ende', () => {
|
||||
const leitung = perms(`${marke}-leitung`, 4, [
|
||||
'personnel.read',
|
||||
'personnel.edit',
|
||||
'document.create',
|
||||
'document.edit',
|
||||
'document.finalize',
|
||||
'document.retract',
|
||||
])
|
||||
const neuling = perms(`${marke}-neuling`, 1, ['personnel.read'])
|
||||
|
||||
let personalakteId = ''
|
||||
let documentNumber = ''
|
||||
|
||||
beforeAll(async () => {
|
||||
for (const p of [leitung, neuling]) {
|
||||
await db.user.create({
|
||||
data: { id: p.userId, username: p.userId, displayName: p.userId },
|
||||
})
|
||||
}
|
||||
const akte = await createPersonnelFile(leitung, {
|
||||
displayName: `${marke} Vertragspartner`,
|
||||
classification: 1,
|
||||
})
|
||||
personalakteId = akte.id
|
||||
})
|
||||
|
||||
afterAll(async () => {
|
||||
await db.$disconnect()
|
||||
})
|
||||
|
||||
it('bietet an einer Person nur die dafür vorgesehenen Vorlagen an', async () => {
|
||||
const schluessel = (await listTemplatesFor('PERSON_DOCUMENT')).map((t) => t.key)
|
||||
expect(schluessel).toContain('sonderarbeitsvertrag')
|
||||
expect(schluessel).toContain('vermerk')
|
||||
// Eine Fallart legt kein Dokument an.
|
||||
expect(schluessel).not.toContain('korruptionsverdacht')
|
||||
})
|
||||
|
||||
it('lehnt eine Vorlage ab, die an dieser Stelle nichts zu suchen hat', async () => {
|
||||
await expect(
|
||||
createDocument(leitung, {
|
||||
templateKey: 'korruptionsverdacht',
|
||||
classification: 1,
|
||||
owner: { kind: 'personnel', personnelFileId: personalakteId },
|
||||
}),
|
||||
).rejects.toThrow(AccessError)
|
||||
})
|
||||
|
||||
it('legt den Vertrag mit eigener Nummer aus dem Präfix der Vorlage an', async () => {
|
||||
const created = await createDocument(leitung, {
|
||||
templateKey: 'sonderarbeitsvertrag',
|
||||
title: 'Sonderarbeitsvertrag Testlauf',
|
||||
classification: 1,
|
||||
owner: { kind: 'personnel', personnelFileId: personalakteId },
|
||||
})
|
||||
documentNumber = created.documentNumber
|
||||
|
||||
// Das Präfix kommt aus der Vorlage, nicht aus dem Programm.
|
||||
expect(documentNumber).toMatch(/^SAV-\d{4}-\d{4}$/)
|
||||
})
|
||||
|
||||
it('ersetzt Platzhalter im festen Vertragstext aus den Eingabefeldern', async () => {
|
||||
await saveDocumentSection(leitung, {
|
||||
documentNumber,
|
||||
fieldKey: 'vertragspartner',
|
||||
value: 'Dr. Vogt',
|
||||
baseVersion: 0,
|
||||
})
|
||||
|
||||
const doc = await loadVisibleDocument(leitung, documentNumber)
|
||||
const sections = await loadDocumentSections(leitung, doc!)
|
||||
|
||||
const eingabe = sections.find((s) => s.fieldKey === 'vertragspartner')
|
||||
expect(eingabe?.visible && eingabe.value).toBe('Dr. Vogt')
|
||||
|
||||
// Der Textbaustein selbst bleibt roh; ersetzt wird beim Rendern, damit
|
||||
// eine spätere Korrektur des Namens überall durchschlägt.
|
||||
const praeambel = sections.find((s) => s.fieldKey === 'praeambel')
|
||||
expect(praeambel?.field.type).toBe('paragraph')
|
||||
expect((praeambel?.field as { text?: string }).text).toContain('{{vertragspartner}}')
|
||||
})
|
||||
|
||||
it('lässt einen Nutzer ohne Recht nichts daran ändern', async () => {
|
||||
await expect(
|
||||
saveDocumentSection(neuling, {
|
||||
documentNumber,
|
||||
fieldKey: 'taetigkeit',
|
||||
value: 'Fremdeingriff',
|
||||
baseVersion: 0,
|
||||
}),
|
||||
).rejects.toThrow(AccessError)
|
||||
})
|
||||
|
||||
it('macht aus dem Entwurf eine Ausfertigung und dann einen Grabstein', async () => {
|
||||
await finalizeDocument(leitung, documentNumber)
|
||||
const ausgefertigt = await loadVisibleDocument(leitung, documentNumber)
|
||||
expect(ausgefertigt?.status).toBe('FINAL')
|
||||
expect(ausgefertigt?.finalizedById).toBe(leitung.userId)
|
||||
|
||||
await retractDocument(leitung, documentNumber, 'Vertrag wurde nie unterzeichnet')
|
||||
const zurueckgezogen = await loadVisibleDocument(leitung, documentNumber)
|
||||
expect(zurueckgezogen?.status).toBe('RETRACTED')
|
||||
expect(zurueckgezogen?.retractionReason).toBe('Vertrag wurde nie unterzeichnet')
|
||||
|
||||
// Der Grabstein steht, das Dokument ist nicht verschwunden.
|
||||
expect(zurueckgezogen?.title).toBe('Sonderarbeitsvertrag Testlauf')
|
||||
|
||||
// Und er ist zu: auch die Leitung schreibt nicht mehr hinein.
|
||||
await expect(
|
||||
saveDocumentSection(leitung, {
|
||||
documentNumber,
|
||||
fieldKey: 'taetigkeit',
|
||||
value: 'Nachtrag',
|
||||
baseVersion: 0,
|
||||
}),
|
||||
).rejects.toThrow(AccessError)
|
||||
})
|
||||
|
||||
it('verlangt für die Zurücknahme eine Begründung', async () => {
|
||||
const zweiter = await createDocument(leitung, {
|
||||
templateKey: 'vermerk',
|
||||
classification: 1,
|
||||
owner: { kind: 'personnel', personnelFileId: personalakteId },
|
||||
})
|
||||
await expect(retractDocument(leitung, zweiter.documentNumber, 'kurz')).rejects.toThrow(
|
||||
AccessError,
|
||||
)
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,225 @@
|
||||
// @vitest-environment node
|
||||
import { afterAll, beforeAll, describe, expect, it } from 'vitest'
|
||||
import { createPrismaClient, loadEnvFromRepoRoot, type PrismaClient } from '@afis/db'
|
||||
import { visibleDocumentWhere } from '@/lib/access/personnelFilter'
|
||||
import {
|
||||
canCreateDocument,
|
||||
canEditDocument,
|
||||
canRetractDocument,
|
||||
} from '@/lib/access/documentWrite'
|
||||
import type { EffectivePermissions, Permission } from '@/lib/auth/permissions'
|
||||
|
||||
/**
|
||||
* Dokumente erben die Sichtbarkeit ihres Besitzers **und** haben eine eigene.
|
||||
* Beides muss zutreffen, sonst leckt entweder die Existenz der Akte oder der
|
||||
* Inhalt des Dokuments.
|
||||
*/
|
||||
loadEnvFromRepoRoot()
|
||||
const url = process.env.DIRECT_DATABASE_URL ?? process.env.DATABASE_URL
|
||||
const suite = url ? describe : describe.skip
|
||||
|
||||
let db: PrismaClient
|
||||
const marke = `dok-${Date.now()}`
|
||||
|
||||
function perms(
|
||||
userId: string,
|
||||
clearanceLevel: number,
|
||||
options: { isAdmin?: boolean; permissions?: Permission[] } = {},
|
||||
): EffectivePermissions {
|
||||
return {
|
||||
userId,
|
||||
clearanceLevel,
|
||||
permissions: new Set<Permission>(options.permissions ?? []),
|
||||
isAdmin: options.isAdmin ?? false,
|
||||
hasMembership: true,
|
||||
}
|
||||
}
|
||||
|
||||
suite('Sichtbarkeit von Dokumenten', () => {
|
||||
const nutzer = {
|
||||
stufe1: `${marke}-stufe1`,
|
||||
stufe4: `${marke}-stufe4`,
|
||||
beteiligt: `${marke}-beteiligt`,
|
||||
}
|
||||
const dok = {
|
||||
imOffenenFall: '',
|
||||
hochImOffenenFall: '',
|
||||
imGeheimenFall: '',
|
||||
anVerborgenerPerson: '',
|
||||
freistehend: '',
|
||||
}
|
||||
|
||||
beforeAll(async () => {
|
||||
db = createPrismaClient(url)
|
||||
|
||||
const template = await db.documentTemplate.create({
|
||||
data: {
|
||||
key: `${marke}-vorlage`,
|
||||
version: 1,
|
||||
name: 'Prüfvorlage',
|
||||
fields: [],
|
||||
uses: ['CASE_DOCUMENT', 'PERSON_DOCUMENT', 'STANDALONE'],
|
||||
},
|
||||
})
|
||||
|
||||
for (const id of Object.values(nutzer)) {
|
||||
await db.user.create({ data: { id, username: id, displayName: id } })
|
||||
}
|
||||
|
||||
const gemeinsam = {
|
||||
templateId: template.id,
|
||||
templateKey: template.key,
|
||||
createdById: nutzer.stufe4,
|
||||
}
|
||||
|
||||
const offen = await db.case.create({
|
||||
data: {
|
||||
...gemeinsam,
|
||||
caseNumber: `${marke}-offen`.slice(0, 40),
|
||||
title: 'Offen',
|
||||
classification: 1,
|
||||
status: 'OPEN',
|
||||
},
|
||||
})
|
||||
const geheim = await db.case.create({
|
||||
data: {
|
||||
...gemeinsam,
|
||||
caseNumber: `${marke}-geheim`.slice(0, 40),
|
||||
title: 'Geheim',
|
||||
classification: 4,
|
||||
status: 'OPEN',
|
||||
},
|
||||
})
|
||||
await db.caseParticipant.create({
|
||||
data: { caseId: geheim.id, userId: nutzer.beteiligt, role: 'INVESTIGATOR' },
|
||||
})
|
||||
|
||||
const person = await db.personnelFile.create({
|
||||
data: { displayName: `${marke} Verborgen`, classification: 4 },
|
||||
})
|
||||
|
||||
const anlegen = async (
|
||||
nummer: string,
|
||||
classification: number,
|
||||
besitzer: { caseId?: string; personnelFileId?: string },
|
||||
) =>
|
||||
(
|
||||
await db.document.create({
|
||||
data: {
|
||||
documentNumber: `${marke}-${nummer}`,
|
||||
title: nummer,
|
||||
templateId: template.id,
|
||||
templateKey: template.key,
|
||||
templateVersion: 1,
|
||||
classification,
|
||||
createdById: nutzer.stufe4,
|
||||
...besitzer,
|
||||
},
|
||||
select: { id: true },
|
||||
})
|
||||
).id
|
||||
|
||||
dok.imOffenenFall = await anlegen('offen-niedrig', 1, { caseId: offen.id })
|
||||
dok.hochImOffenenFall = await anlegen('offen-hoch', 4, { caseId: offen.id })
|
||||
dok.imGeheimenFall = await anlegen('geheim', 1, { caseId: geheim.id })
|
||||
dok.anVerborgenerPerson = await anlegen('person', 1, { personnelFileId: person.id })
|
||||
dok.freistehend = await anlegen('frei', 1, {})
|
||||
})
|
||||
|
||||
afterAll(async () => {
|
||||
await db.$disconnect()
|
||||
})
|
||||
|
||||
async function sichtbar(p: EffectivePermissions): Promise<string[]> {
|
||||
const rows = await db.document.findMany({
|
||||
where: { AND: [visibleDocumentWhere(p), { id: { in: Object.values(dok) } }] },
|
||||
select: { id: true },
|
||||
})
|
||||
return rows.map((r) => r.id).sort()
|
||||
}
|
||||
|
||||
it('zeigt einer Stufe 1 nur, was Besitzer und Dokument zugleich erlauben', async () => {
|
||||
const p = perms(nutzer.stufe1, 1)
|
||||
const treffer = await sichtbar(p)
|
||||
|
||||
expect(treffer).toContain(dok.imOffenenFall)
|
||||
expect(treffer).toContain(dok.freistehend)
|
||||
|
||||
// Das Dokument ist zu hoch eingestuft, obwohl die Akte offen liegt.
|
||||
expect(treffer).not.toContain(dok.hochImOffenenFall)
|
||||
// Das Dokument wäre lesbar, aber die Akte darüber nicht — die
|
||||
// Dokumentenliste verriete sonst ihre Existenz.
|
||||
expect(treffer).not.toContain(dok.imGeheimenFall)
|
||||
expect(treffer).not.toContain(dok.anVerborgenerPerson)
|
||||
|
||||
const anzahl = await db.document.count({
|
||||
where: { AND: [visibleDocumentWhere(p), { id: { in: Object.values(dok) } }] },
|
||||
})
|
||||
expect(anzahl).toBe(treffer.length)
|
||||
})
|
||||
|
||||
it('lässt einen Beteiligten die Dokumente seiner Akte lesen', async () => {
|
||||
// Ausnahmsweiser Zugang gilt auch für die Dokumente der Akte, sonst wäre
|
||||
// das Hinzuziehen wirkungslos. Siehe docs/03-auth-und-rechte.md.
|
||||
const treffer = await sichtbar(perms(nutzer.beteiligt, 1))
|
||||
expect(treffer).toContain(dok.imGeheimenFall)
|
||||
// Er bleibt aber ein Stufe-1-Nutzer: an fremden Personalakten ändert das nichts.
|
||||
expect(treffer).not.toContain(dok.anVerborgenerPerson)
|
||||
})
|
||||
|
||||
it('zeigt der Stufe 4 alles', async () => {
|
||||
expect(await sichtbar(perms(nutzer.stufe4, 4))).toHaveLength(Object.values(dok).length)
|
||||
})
|
||||
})
|
||||
|
||||
describe('Schreibgrenzen für Dokumente', () => {
|
||||
const alle: Permission[] = [
|
||||
'document.create',
|
||||
'document.edit',
|
||||
'document.finalize',
|
||||
'document.retract',
|
||||
]
|
||||
|
||||
it('lässt niemanden ein Dokument über der eigenen Stufe anlegen', () => {
|
||||
const p = perms('a', 2, { permissions: alle })
|
||||
expect(canCreateDocument(p, 2).ok).toBe(true)
|
||||
expect(canCreateDocument(p, 3)).toEqual({
|
||||
ok: false,
|
||||
reason: 'clearance-too-low',
|
||||
required: 3,
|
||||
})
|
||||
})
|
||||
|
||||
it('verlangt für das Ändern eines ausgefertigten Dokuments das Ausfertigungsrecht', () => {
|
||||
const nurEdit = perms('b', 5, { permissions: ['document.edit'] })
|
||||
expect(canEditDocument(nurEdit, { status: 'DRAFT', classification: 1 }).ok).toBe(true)
|
||||
expect(canEditDocument(nurEdit, { status: 'FINAL', classification: 1 })).toEqual({
|
||||
ok: false,
|
||||
reason: 'closed',
|
||||
})
|
||||
|
||||
const mitFinalize = perms('c', 5, { permissions: ['document.edit', 'document.finalize'] })
|
||||
expect(canEditDocument(mitFinalize, { status: 'FINAL', classification: 1 }).ok).toBe(true)
|
||||
})
|
||||
|
||||
it('hält ein zurückgezogenes Dokument auch für den Admin geschlossen', () => {
|
||||
// Der Grabstein bleibt stehen, wie er ist. Sonst liesse sich ein
|
||||
// zurückgezogenes Dokument nachträglich zu etwas anderem machen.
|
||||
const admin = perms('d', 5, { isAdmin: true })
|
||||
expect(canEditDocument(admin, { status: 'RETRACTED', classification: 1 })).toEqual({
|
||||
ok: false,
|
||||
reason: 'read-only',
|
||||
status: 'RETRACTED',
|
||||
})
|
||||
expect(canRetractDocument(admin, { status: 'RETRACTED', classification: 1 }).ok).toBe(false)
|
||||
})
|
||||
|
||||
it('verlangt für das Zurückziehen ein eigenes Recht', () => {
|
||||
const ohne = perms('e', 5, { permissions: ['document.edit'] })
|
||||
expect(canRetractDocument(ohne, { status: 'FINAL', classification: 1 })).toEqual({
|
||||
ok: false,
|
||||
reason: 'no-permission',
|
||||
permission: 'document.retract',
|
||||
})
|
||||
})
|
||||
})
|
||||
@@ -33,7 +33,7 @@ let caseNumber = ''
|
||||
suite('Nachträgliche Änderungen am Verlauf', () => {
|
||||
beforeAll(async () => {
|
||||
db = createPrismaClient(url)
|
||||
await db.caseTemplate.create({
|
||||
await db.documentTemplate.create({
|
||||
data: { key: `${marke}-vorlage`, version: 1, name: 'Prüfvorlage', fields: [] },
|
||||
})
|
||||
for (const id of [AUTOR, FREMD]) {
|
||||
|
||||
@@ -69,9 +69,11 @@ describe('Rechte-Enum', () => {
|
||||
}
|
||||
})
|
||||
|
||||
it('haelt drei davon im Auslieferungszustand zurueck', () => {
|
||||
it('haelt die nachtraeglichen Eingriffe im Auslieferungszustand zurueck', () => {
|
||||
// Der Leiter schaltet sie bewusst frei, siehe docs/03-auth-und-rechte.md.
|
||||
// Gemeinsames Merkmal: sie greifen in bereits Geschriebenes ein.
|
||||
expect([...OPT_IN_PERMISSIONS].sort()).toEqual([
|
||||
'document.retract',
|
||||
'entry.edit_any',
|
||||
'entry.edit_own',
|
||||
'entry.retract',
|
||||
|
||||
@@ -0,0 +1,175 @@
|
||||
// @vitest-environment node
|
||||
import { afterAll, beforeAll, describe, expect, it } from 'vitest'
|
||||
import { createPrismaClient, loadEnvFromRepoRoot, type PrismaClient } from '@afis/db'
|
||||
import { visiblePersonnelWhere } from '@/lib/access/personnelFilter'
|
||||
import { loadBacklinks } from '@/lib/personnel/service'
|
||||
import type { EffectivePermissions, Permission } from '@/lib/auth/permissions'
|
||||
|
||||
/**
|
||||
* Rückverweise sind der häufigste Ort, an dem ein Aktensystem leckt.
|
||||
*
|
||||
* Eine Personalakte der Stufe 1, auf der „3 Fälle" steht, verrät die Existenz
|
||||
* von Ermittlungen, die der Leser nicht sehen darf — auch dann, wenn kein
|
||||
* Titel danebensteht. Deshalb prüft dieser Test nicht nur die Liste, sondern
|
||||
* ausdrücklich auch die **Zahl**. Siehe docs/05-akten-und-vorlagen.md.
|
||||
*/
|
||||
loadEnvFromRepoRoot()
|
||||
const url = process.env.DIRECT_DATABASE_URL ?? process.env.DATABASE_URL
|
||||
const suite = url ? describe : describe.skip
|
||||
|
||||
let db: PrismaClient
|
||||
const marke = `personal-${Date.now()}`
|
||||
|
||||
function perms(
|
||||
userId: string,
|
||||
clearanceLevel: number,
|
||||
options: { isAdmin?: boolean; permissions?: Permission[] } = {},
|
||||
): EffectivePermissions {
|
||||
return {
|
||||
userId,
|
||||
clearanceLevel,
|
||||
permissions: new Set<Permission>(options.permissions ?? []),
|
||||
isAdmin: options.isAdmin ?? false,
|
||||
hasMembership: true,
|
||||
}
|
||||
}
|
||||
|
||||
suite('Personalakten und Rückverweise', () => {
|
||||
const nutzer = {
|
||||
stufe1: `${marke}-stufe1`,
|
||||
stufe3: `${marke}-stufe3`,
|
||||
betroffen: `${marke}-betroffen`,
|
||||
}
|
||||
const akten = {
|
||||
offen: `${marke}-fall-offen`,
|
||||
geheim: `${marke}-fall-geheim`,
|
||||
}
|
||||
let personalakteId = ''
|
||||
let hoheAkteId = ''
|
||||
|
||||
beforeAll(async () => {
|
||||
db = createPrismaClient(url)
|
||||
|
||||
const template = await db.documentTemplate.create({
|
||||
data: { key: `${marke}-vorlage`, version: 1, name: 'Prüfvorlage', fields: [] },
|
||||
})
|
||||
|
||||
for (const id of Object.values(nutzer)) {
|
||||
await db.user.create({ data: { id, username: id, displayName: id } })
|
||||
}
|
||||
|
||||
const person = await db.personnelFile.create({
|
||||
data: {
|
||||
displayName: `${marke} Betroffener`,
|
||||
userId: nutzer.betroffen,
|
||||
classification: 1,
|
||||
createdById: nutzer.stufe3,
|
||||
},
|
||||
})
|
||||
personalakteId = person.id
|
||||
|
||||
const verborgen = await db.personnelFile.create({
|
||||
data: { displayName: `${marke} Verborgen`, classification: 4, createdById: nutzer.stufe3 },
|
||||
})
|
||||
hoheAkteId = verborgen.id
|
||||
|
||||
const gemeinsam = {
|
||||
templateId: template.id,
|
||||
templateKey: template.key,
|
||||
createdById: nutzer.stufe3,
|
||||
}
|
||||
|
||||
await db.case.create({
|
||||
data: {
|
||||
...gemeinsam,
|
||||
id: akten.offen,
|
||||
caseNumber: `${marke}-1`.slice(0, 40),
|
||||
title: 'Für alle sichtbar',
|
||||
classification: 1,
|
||||
status: 'OPEN',
|
||||
},
|
||||
})
|
||||
|
||||
await db.case.create({
|
||||
data: {
|
||||
...gemeinsam,
|
||||
id: akten.geheim,
|
||||
caseNumber: `${marke}-2`.slice(0, 40),
|
||||
title: 'Nur ab Stufe 3',
|
||||
classification: 3,
|
||||
status: 'OPEN',
|
||||
},
|
||||
})
|
||||
|
||||
// Dieselbe Person, einmal über die Personalakte, einmal über das Konto.
|
||||
await db.caseParticipant.createMany({
|
||||
data: [
|
||||
{ caseId: akten.offen, personnelFileId: person.id, role: 'WITNESS' },
|
||||
{ caseId: akten.geheim, personnelFileId: person.id, role: 'SUBJECT' },
|
||||
{ caseId: akten.geheim, userId: nutzer.betroffen, role: 'WITNESS' },
|
||||
],
|
||||
})
|
||||
})
|
||||
|
||||
afterAll(async () => {
|
||||
await db.$disconnect()
|
||||
})
|
||||
|
||||
it('zeigt einer Stufe 1 auf der Personalakte keinen Hinweis auf den Stufe-3-Fall', async () => {
|
||||
const { total, byRole } = await loadBacklinks(perms(nutzer.stufe1, 1), {
|
||||
id: personalakteId,
|
||||
userId: nutzer.betroffen,
|
||||
})
|
||||
|
||||
const nummern = byRole.flatMap((gruppe) => gruppe.eintraege.map((e) => e.case.id))
|
||||
expect(nummern).toContain(akten.offen)
|
||||
expect(nummern).not.toContain(akten.geheim)
|
||||
|
||||
// Die Zahl ist selbst eine Information: sie darf den verborgenen Fall
|
||||
// nicht mitzählen, auch nicht als anonymen Platzhalter.
|
||||
expect(total).toBe(1)
|
||||
|
||||
// Und die Rolle taucht gar nicht erst auf, sonst verriete "Betroffener"
|
||||
// die Existenz einer Ermittlung gegen die Person.
|
||||
expect(byRole.map((gruppe) => gruppe.role)).not.toContain('SUBJECT')
|
||||
})
|
||||
|
||||
it('zeigt einer Stufe 3 beide Fälle und beide Wege zur Person', async () => {
|
||||
const { total, byRole } = await loadBacklinks(perms(nutzer.stufe3, 3), {
|
||||
id: personalakteId,
|
||||
userId: nutzer.betroffen,
|
||||
})
|
||||
|
||||
const rollen = byRole.map((gruppe) => gruppe.role).sort()
|
||||
expect(rollen).toEqual(['SUBJECT', 'WITNESS'])
|
||||
// Drei Einträge: einer über die Personalakte im offenen Fall, zwei im
|
||||
// geheimen — über die Personalakte und über das Discord-Konto.
|
||||
expect(total).toBe(3)
|
||||
})
|
||||
|
||||
it('verbirgt eine Personalakte oberhalb der Stufe, auch in der Zählung', async () => {
|
||||
const p = perms(nutzer.stufe1, 1)
|
||||
const wo = {
|
||||
AND: [visiblePersonnelWhere(p), { id: { in: [personalakteId, hoheAkteId] } }],
|
||||
}
|
||||
|
||||
const treffer = await db.personnelFile.findMany({ where: wo, select: { id: true } })
|
||||
const anzahl = await db.personnelFile.count({ where: wo })
|
||||
|
||||
expect(treffer.map((t) => t.id)).toEqual([personalakteId])
|
||||
expect(anzahl).toBe(1)
|
||||
})
|
||||
|
||||
it('gibt dem Admin die verborgene Personalakte', async () => {
|
||||
const treffer = await db.personnelFile.findMany({
|
||||
where: {
|
||||
AND: [
|
||||
visiblePersonnelWhere(perms(nutzer.stufe1, 1, { isAdmin: true })),
|
||||
{ id: hoheAkteId },
|
||||
],
|
||||
},
|
||||
select: { id: true },
|
||||
})
|
||||
expect(treffer).toHaveLength(1)
|
||||
})
|
||||
})
|
||||
@@ -34,7 +34,7 @@ const VOLL: Permission[] = ['case.create', 'case.edit', 'case.close', 'case.reop
|
||||
suite('Schreibgrenzen der Freigabestufe', () => {
|
||||
beforeAll(async () => {
|
||||
db = createPrismaClient(url)
|
||||
await db.caseTemplate.create({
|
||||
await db.documentTemplate.create({
|
||||
data: { key: `${marke}-vorlage`, version: 1, name: 'Prüfvorlage', fields: [] },
|
||||
})
|
||||
for (const level of [1, 2, 4, 5]) {
|
||||
@@ -93,7 +93,7 @@ suite('Schreibgrenzen der Freigabestufe', () => {
|
||||
// Die Abteilung nutzt gewachsene Präfixe wie AKT-PA neben dem AfiS aus dem
|
||||
// Glossar. Zwei Fallarten dürfen sich dabei nicht in die Quere kommen.
|
||||
const { createCase } = await import('@/lib/cases/service')
|
||||
await db.caseTemplate.create({
|
||||
await db.documentTemplate.create({
|
||||
data: {
|
||||
key: `${marke}-personal`,
|
||||
version: 1,
|
||||
@@ -119,9 +119,9 @@ suite('Schreibgrenzen der Freigabestufe', () => {
|
||||
expect(ersteA.caseNumber).toMatch(new RegExp(`^AKT-PA-${jahr}-\\d{5}$`))
|
||||
expect(zweiteA.caseNumber).toMatch(new RegExp(`^AKT-PA-${jahr}-\\d{5}$`))
|
||||
|
||||
const { parseCaseNumber } = await import('@/lib/cases/caseNumber')
|
||||
const eins = parseCaseNumber(ersteA.caseNumber)
|
||||
const zwei = parseCaseNumber(zweiteA.caseNumber)
|
||||
const { parseNumber } = await import('@/lib/numbering')
|
||||
const eins = parseNumber(ersteA.caseNumber)
|
||||
const zwei = parseNumber(zweiteA.caseNumber)
|
||||
expect(eins?.prefix).toBe('AKT-PA')
|
||||
expect(zwei!.number).toBe(eins!.number + 1)
|
||||
|
||||
@@ -131,7 +131,7 @@ suite('Schreibgrenzen der Freigabestufe', () => {
|
||||
classification: 1,
|
||||
templateKey: `${marke}-vorlage`,
|
||||
})
|
||||
expect(parseCaseNumber(afis.caseNumber)?.prefix).toBe('AfiS')
|
||||
expect(parseNumber(afis.caseNumber)?.prefix).toBe('AfiS')
|
||||
})
|
||||
|
||||
it('gibt einer zu niedrigen Stufe nicht einmal die Existenz preis', async () => {
|
||||
|
||||
@@ -0,0 +1,158 @@
|
||||
// @vitest-environment node
|
||||
import { afterAll, beforeAll, describe, expect, it } from 'vitest'
|
||||
import { createPrismaClient, loadEnvFromRepoRoot, type PrismaClient } from '@afis/db'
|
||||
import { listLinks } from '@/lib/cases/links'
|
||||
import { listParticipants } from '@/lib/cases/participants'
|
||||
import { visibleCaseWhere } from '@/lib/access/caseFilter'
|
||||
import type { EffectivePermissions, Permission } from '@/lib/auth/permissions'
|
||||
|
||||
/**
|
||||
* Verknüpfungen zeigen in beide Richtungen. Eine Akte, die der Leser nicht
|
||||
* sehen darf, darf auch von der Gegenseite aus nicht auftauchen — sonst
|
||||
* verrät die verknüpfte Akte ihre Existenz.
|
||||
*/
|
||||
loadEnvFromRepoRoot()
|
||||
const url = process.env.DIRECT_DATABASE_URL ?? process.env.DATABASE_URL
|
||||
const suite = url ? describe : describe.skip
|
||||
|
||||
let db: PrismaClient
|
||||
const marke = `link-${Date.now()}`
|
||||
|
||||
function perms(userId: string, clearanceLevel: number): EffectivePermissions {
|
||||
return {
|
||||
userId,
|
||||
clearanceLevel,
|
||||
permissions: new Set<Permission>(),
|
||||
isAdmin: false,
|
||||
hasMembership: true,
|
||||
}
|
||||
}
|
||||
|
||||
suite('Verknüpfungen zwischen Akten', () => {
|
||||
const nutzer = { stufe1: `${marke}-stufe1`, stufe4: `${marke}-stufe4` }
|
||||
let offenId = ''
|
||||
let geheimId = ''
|
||||
let zweitOffenId = ''
|
||||
|
||||
beforeAll(async () => {
|
||||
db = createPrismaClient(url)
|
||||
|
||||
const template = await db.documentTemplate.create({
|
||||
data: { key: `${marke}-vorlage`, version: 1, name: 'Prüfvorlage', fields: [] },
|
||||
})
|
||||
for (const id of Object.values(nutzer)) {
|
||||
await db.user.create({ data: { id, username: id, displayName: id } })
|
||||
}
|
||||
|
||||
const gemeinsam = {
|
||||
templateId: template.id,
|
||||
templateKey: template.key,
|
||||
createdById: nutzer.stufe4,
|
||||
}
|
||||
|
||||
const offen = await db.case.create({
|
||||
data: {
|
||||
...gemeinsam,
|
||||
caseNumber: `${marke}-a`.slice(0, 40),
|
||||
title: 'Offen',
|
||||
classification: 1,
|
||||
status: 'OPEN',
|
||||
},
|
||||
})
|
||||
const geheim = await db.case.create({
|
||||
data: {
|
||||
...gemeinsam,
|
||||
caseNumber: `${marke}-b`.slice(0, 40),
|
||||
title: 'Geheim',
|
||||
classification: 4,
|
||||
status: 'OPEN',
|
||||
},
|
||||
})
|
||||
const zweitOffen = await db.case.create({
|
||||
data: {
|
||||
...gemeinsam,
|
||||
caseNumber: `${marke}-c`.slice(0, 40),
|
||||
title: 'Auch offen',
|
||||
classification: 1,
|
||||
status: 'OPEN',
|
||||
},
|
||||
})
|
||||
offenId = offen.id
|
||||
geheimId = geheim.id
|
||||
zweitOffenId = zweitOffen.id
|
||||
|
||||
await db.caseLink.createMany({
|
||||
data: [
|
||||
// Hinaus: offen -> geheim
|
||||
{ fromId: offen.id, toId: geheim.id, kind: 'RELATED', createdById: nutzer.stufe4 },
|
||||
// Herein: geheim -> offen, dieselbe Falle aus der anderen Richtung
|
||||
{ fromId: geheim.id, toId: offen.id, kind: 'SUCCESSOR', createdById: nutzer.stufe4 },
|
||||
// Unverfänglich
|
||||
{ fromId: offen.id, toId: zweitOffen.id, kind: 'RELATED', createdById: nutzer.stufe4 },
|
||||
],
|
||||
})
|
||||
})
|
||||
|
||||
afterAll(async () => {
|
||||
await db.$disconnect()
|
||||
})
|
||||
|
||||
it('verbirgt eine zu hoch eingestufte Akte in beiden Richtungen', async () => {
|
||||
const links = await listLinks(perms(nutzer.stufe1, 1), offenId)
|
||||
const ziele = links.map((link) => link.other.id)
|
||||
|
||||
expect(ziele).toContain(zweitOffenId)
|
||||
expect(ziele).not.toContain(geheimId)
|
||||
// Auch die eingehende Verknüpfung darf nicht als leerer Platzhalter stehen.
|
||||
expect(links).toHaveLength(1)
|
||||
})
|
||||
|
||||
it('zeigt der Stufe 4 beide Richtungen mit ihrer jeweiligen Bedeutung', async () => {
|
||||
const links = await listLinks(perms(nutzer.stufe4, 4), offenId)
|
||||
const richtungen = links
|
||||
.filter((link) => link.other.id === geheimId)
|
||||
.map((link) => `${link.direction}:${link.kind}`)
|
||||
.sort()
|
||||
|
||||
expect(richtungen).toEqual(['in:SUCCESSOR', 'out:RELATED'])
|
||||
})
|
||||
|
||||
it('nennt den Namen eines Beteiligten, verweist aber nur auf sichtbare Personalakten', async () => {
|
||||
const verborgen = await db.personnelFile.create({
|
||||
data: { displayName: `${marke} Verborgene Person`, classification: 4 },
|
||||
})
|
||||
await db.caseParticipant.create({
|
||||
data: { caseId: offenId, personnelFileId: verborgen.id, role: 'SUBJECT' },
|
||||
})
|
||||
|
||||
const beteiligte = await listParticipants(perms(nutzer.stufe1, 1), offenId)
|
||||
const eintrag = beteiligte.find((b) => b.displayName?.includes('Verborgene Person'))
|
||||
|
||||
// Wer die Ermittlung lesen darf, muss wissen, gegen wen sie läuft.
|
||||
expect(eintrag).toBeDefined()
|
||||
// Was darüber hinaus über die Person aktenkundig ist, bleibt zu.
|
||||
expect(eintrag?.personnelFileId).toBeNull()
|
||||
|
||||
const fuerStufe4 = await listParticipants(perms(nutzer.stufe4, 4), offenId)
|
||||
expect(
|
||||
fuerStufe4.find((b) => b.displayName?.includes('Verborgene Person'))?.personnelFileId,
|
||||
).toBe(verborgen.id)
|
||||
})
|
||||
|
||||
it('gibt einem Beteiligten Zugriff auf die Akte über seiner Stufe', async () => {
|
||||
await db.caseParticipant.create({
|
||||
data: { caseId: geheimId, userId: nutzer.stufe1, role: 'WITNESS' },
|
||||
})
|
||||
|
||||
const p = perms(nutzer.stufe1, 1)
|
||||
const treffer = await db.case.findMany({
|
||||
where: { AND: [visibleCaseWhere(p), { id: geheimId }] },
|
||||
select: { id: true },
|
||||
})
|
||||
expect(treffer).toHaveLength(1)
|
||||
|
||||
// Und damit auch auf die Verknüpfung, die vorher verborgen war.
|
||||
const links = await listLinks(p, offenId)
|
||||
expect(links.map((link) => link.other.id)).toContain(geheimId)
|
||||
})
|
||||
})
|
||||
@@ -49,7 +49,7 @@ suite('Sichtbarkeit von Akten', () => {
|
||||
beforeAll(async () => {
|
||||
db = createPrismaClient(url)
|
||||
|
||||
const template = await db.caseTemplate.create({
|
||||
const template = await db.documentTemplate.create({
|
||||
data: { key: `${marke}-vorlage`, version: 1, name: 'Prüfvorlage', fields: [] },
|
||||
})
|
||||
|
||||
|
||||
Reference in New Issue
Block a user