Abteilungen als Ebene über der Personalakte
Punkt 3 der Wünsche. Die Abteilung stand als Freitext in der Personalakte. Damit liess sich nichts fragen: „SHD", „Shd" und „Sicherheitsdienst" waren drei Abteilungen. Sie ist jetzt ein eigenes Modell, im Adminbereich verwaltbar, und die drei vorhandenen Freitexte sind in der Migration zu Abteilungen geworden. **Eine Fallakte trägt keine Abteilung.** Sie gehört zu einer, wenn eine beteiligte Person ihr angehört - abgeleitet über CaseParticipant und die Personalakte. Eine eingetragene Zuordnung wäre nach zwei Wochen falsch: Leute wechseln, Beteiligte kommen dazu, und niemand pflegt das nach. Dasselbe gilt für die Dokumente: ein Dokument unmittelbar an der Abteilung wäre halb verdrahtet, weil die Vorlagen über TemplateUse nur Fall- und Personalakte kennen. Die Abteilungsseite zeigt Mitglieder, abgeleitete Fälle und Dokumente, Vermerke, Chat und ein Kreisdiagramm der Fallarten; die Übersicht eines über alle Abteilungen. Das Diagramm ist serverseitig gerendertes SVG - eine Bibliothek wäre das Teuerste auf der Seite gewesen. Die Segmente sind Abstufungen von --steel und nicht die Stufenfarben: ein Tortenstück in Oxidrot würde als „streng geheim" gelesen. Die Zusammenfassung ist die gefährliche Stelle. Eine Abteilungsseite fasst zusammen, was einzeln längst geschützt ist, und eine Zusammenfassung, die nicht filtert, verrät mehr als jede Einzelansicht. Deshalb läuft hier jede Liste und jede Zahl durch dieselben Fragmente wie überall; ein Test prüft, dass die Summe der Diagrammanteile mit der Länge der Liste übereinstimmt. Wo jemand Personalakten gar nicht sehen darf, steht null und keine Null. Vermerke erben Regel 2 unverändert: kein DELETE, Version bei jeder Änderung, Grabstein bei jeder Zurücknahme, als Regel und Trigger in der Datenbank. Ohne Korrekturkette, Anhänge und Karenzzeit - was Beweiswert hat, gehört in eine Fallakte. Nebenbei: das Zugriffsprotokoll hängt jetzt am dafür vorgesehenen Recht audit.read statt an admin.
This commit is contained in:
Harlekin
@@ -0,0 +1,290 @@
|
||||
// @vitest-environment node
|
||||
import { afterAll, beforeAll, describe, expect, it } from 'vitest'
|
||||
import { db } from '@/lib/db'
|
||||
import {
|
||||
assignToDepartment,
|
||||
caseTypesOfDepartment,
|
||||
casesPerDepartment,
|
||||
listDepartmentCases,
|
||||
listDepartments,
|
||||
listMembers,
|
||||
} from '@/lib/departments/service'
|
||||
import { createEntry, editEntry, listEntries, retractEntry } from '@/lib/departments/entries'
|
||||
import { AccessError } from '@/lib/errors'
|
||||
import type { EffectivePermissions, Permission } from '@/lib/auth/permissions'
|
||||
|
||||
/**
|
||||
* Die Abteilung ist die Ebene über der Personalakte, und sie fasst zusammen,
|
||||
* was einzeln bereits geschützt ist. Genau darin liegt die Gefahr: eine
|
||||
* Zusammenfassung, die nicht filtert, verrät mehr als jede Einzelansicht.
|
||||
* Geprüft wird deshalb jede Liste und jede Zahl gegen einen zu niedrig
|
||||
* eingestuften Leser.
|
||||
*/
|
||||
const url = process.env.DIRECT_DATABASE_URL ?? process.env.DATABASE_URL
|
||||
const suite = url ? describe : describe.skip
|
||||
|
||||
const marke = `abt-${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('Abteilungen', () => {
|
||||
const nutzer = { stufe1: `${marke}-s1`, stufe4: `${marke}-s4` }
|
||||
let abteilungId = ''
|
||||
let abteilungKey = ''
|
||||
let geheimeAbteilungKey = ''
|
||||
let personOffenId = ''
|
||||
let personGeheimId = ''
|
||||
let offenId = ''
|
||||
let geheimId = ''
|
||||
|
||||
beforeAll(async () => {
|
||||
for (const id of Object.values(nutzer)) {
|
||||
await db.user.create({ data: { id, username: id, displayName: id } })
|
||||
}
|
||||
const vorlage = await db.documentTemplate.create({
|
||||
data: { key: `${marke}-vorlage`, version: 1, name: 'Korruption', fields: [] },
|
||||
})
|
||||
const vorlage2 = await db.documentTemplate.create({
|
||||
data: { key: `${marke}-bussgeld`, version: 1, name: 'Bussgeld', fields: [] },
|
||||
})
|
||||
|
||||
const abteilung = await db.department.create({
|
||||
data: { key: `${marke}-SHD`.slice(0, 21).toUpperCase(), name: 'Sicherheitsdienst' },
|
||||
})
|
||||
abteilungId = abteilung.id
|
||||
abteilungKey = abteilung.key
|
||||
|
||||
const geheim = await db.department.create({
|
||||
data: { key: `${marke}-GEH`.slice(0, 21).toUpperCase(), name: 'Verdeckt', minClearance: 4 },
|
||||
})
|
||||
geheimeAbteilungKey = geheim.key
|
||||
|
||||
// Zwei Mitglieder: eines für jeden sichtbar, eines auf Stufe 4.
|
||||
const offenePerson = await db.personnelFile.create({
|
||||
data: {
|
||||
displayName: `${marke} Offene Person`,
|
||||
classification: 1,
|
||||
departmentId: abteilung.id,
|
||||
},
|
||||
})
|
||||
const geheimePerson = await db.personnelFile.create({
|
||||
data: {
|
||||
displayName: `${marke} Geheime Person`,
|
||||
classification: 4,
|
||||
departmentId: abteilung.id,
|
||||
},
|
||||
})
|
||||
personOffenId = offenePerson.id
|
||||
personGeheimId = geheimePerson.id
|
||||
|
||||
const gemeinsam = { createdById: nutzer.stufe4 }
|
||||
const offen = await db.case.create({
|
||||
data: {
|
||||
...gemeinsam,
|
||||
templateId: vorlage.id,
|
||||
templateKey: vorlage.key,
|
||||
caseNumber: `Abt-2026-${Date.now().toString(36)}o`,
|
||||
title: 'Offener Vorgang',
|
||||
classification: 1,
|
||||
status: 'OPEN',
|
||||
},
|
||||
})
|
||||
const geheimerFall = await db.case.create({
|
||||
data: {
|
||||
...gemeinsam,
|
||||
templateId: vorlage2.id,
|
||||
templateKey: vorlage2.key,
|
||||
caseNumber: `Abt-2026-${Date.now().toString(36)}g`,
|
||||
title: 'Streng vertraulich',
|
||||
classification: 4,
|
||||
status: 'OPEN',
|
||||
},
|
||||
})
|
||||
offenId = offen.id
|
||||
geheimId = geheimerFall.id
|
||||
|
||||
// Beide Fälle hängen über eine Person an der Abteilung.
|
||||
await db.caseParticipant.create({
|
||||
data: { caseId: offen.id, personnelFileId: offenePerson.id, role: 'SUBJECT' },
|
||||
})
|
||||
await db.caseParticipant.create({
|
||||
data: { caseId: geheimerFall.id, personnelFileId: offenePerson.id, role: 'SUSPECT' },
|
||||
})
|
||||
})
|
||||
|
||||
afterAll(async () => {
|
||||
await db.$disconnect()
|
||||
})
|
||||
|
||||
it('verbirgt eine Abteilung über der eigenen Stufe', async () => {
|
||||
const niedrig = await listDepartments(perms(nutzer.stufe1, 1))
|
||||
expect(niedrig.map((a) => a.key)).not.toContain(geheimeAbteilungKey)
|
||||
|
||||
const hoch = await listDepartments(perms(nutzer.stufe4, 4))
|
||||
expect(hoch.map((a) => a.key)).toContain(geheimeAbteilungKey)
|
||||
})
|
||||
|
||||
it('zählt als Mitglieder nur, was der Fragende sehen darf', async () => {
|
||||
const mitRecht = (stufe: number) =>
|
||||
listDepartments(perms(nutzer.stufe1, stufe, { permissions: ['personnel.read'] }))
|
||||
|
||||
const niedrig = (await mitRecht(1)).find((a) => a.key === abteilungKey)
|
||||
const hoch = (await mitRecht(4)).find((a) => a.key === abteilungKey)
|
||||
|
||||
// Sonst verriete die Zahl, wie viele Personalakten über seiner Stufe liegen.
|
||||
expect(niedrig?.memberCount).toBe(1)
|
||||
expect(hoch?.memberCount).toBe(2)
|
||||
|
||||
// Ohne das Recht auf Personalakten steht dort keine Zahl, auch keine Null:
|
||||
// eine Null wäre die Auskunft „hier ist niemand".
|
||||
const ohneRecht = await listDepartments(perms(nutzer.stufe4, 4))
|
||||
expect(ohneRecht.find((a) => a.key === abteilungKey)?.memberCount).toBeNull()
|
||||
})
|
||||
|
||||
it('zeigt Mitglieder nur mit dem Recht auf Personalakten', async () => {
|
||||
const ohneRecht = await listMembers(perms(nutzer.stufe4, 4), abteilungId)
|
||||
expect(ohneRecht).toHaveLength(0)
|
||||
|
||||
const mitRecht = await listMembers(
|
||||
perms(nutzer.stufe4, 4, { permissions: ['personnel.read'] }),
|
||||
abteilungId,
|
||||
)
|
||||
expect(mitRecht.map((m) => m.id)).toEqual(
|
||||
expect.arrayContaining([personOffenId, personGeheimId]),
|
||||
)
|
||||
})
|
||||
|
||||
it('hält eine zu hoch eingestufte Akte aus Liste und Diagramm heraus', async () => {
|
||||
const niedrig = perms(nutzer.stufe1, 1)
|
||||
|
||||
const liste = await listDepartmentCases(niedrig, abteilungId)
|
||||
expect(liste.map((a) => a.id)).toContain(offenId)
|
||||
expect(liste.map((a) => a.id)).not.toContain(geheimId)
|
||||
|
||||
// Und die Zahl im Diagramm stimmt mit der Liste überein — ein Zähler, der
|
||||
// mehr zählt als die Liste zeigt, wäre selbst eine Auskunft.
|
||||
const verteilung = await caseTypesOfDepartment(niedrig, abteilungId)
|
||||
const summe = verteilung.reduce((s, stueck) => s + stueck.value, 0)
|
||||
expect(summe).toBe(liste.length)
|
||||
expect(verteilung.map((s) => s.label)).not.toContain(`${marke}-bussgeld`)
|
||||
|
||||
// Stufe 4 sieht beide.
|
||||
const hoch = await caseTypesOfDepartment(perms(nutzer.stufe4, 4), abteilungId)
|
||||
expect(hoch.reduce((s, stueck) => s + stueck.value, 0)).toBe(2)
|
||||
})
|
||||
|
||||
it('zählt auch über Abteilungen hinweg nur Sichtbares', async () => {
|
||||
const niedrig = await casesPerDepartment(perms(nutzer.stufe1, 1))
|
||||
const eintrag = niedrig.find((s) => s.label === 'Sicherheitsdienst')
|
||||
expect(eintrag?.value).toBe(1)
|
||||
|
||||
const hoch = await casesPerDepartment(perms(nutzer.stufe4, 4))
|
||||
expect(hoch.find((s) => s.label === 'Sicherheitsdienst')?.value).toBe(2)
|
||||
})
|
||||
|
||||
it('lässt nur zuordnen, wer die Personalakte auch ändern darf', async () => {
|
||||
await expect(
|
||||
assignToDepartment(perms(nutzer.stufe1, 1, { permissions: ['personnel.read'] }), {
|
||||
personnelFileId: personOffenId,
|
||||
departmentId: abteilungId,
|
||||
}),
|
||||
).rejects.toThrow(AccessError)
|
||||
|
||||
await assignToDepartment(
|
||||
perms(nutzer.stufe4, 4, { permissions: ['personnel.read', 'personnel.edit'] }),
|
||||
{ personnelFileId: personOffenId, departmentId: null },
|
||||
)
|
||||
const danach = await db.personnelFile.findUniqueOrThrow({ where: { id: personOffenId } })
|
||||
expect(danach.departmentId).toBeNull()
|
||||
|
||||
// Wieder zurück, damit die übrigen Prüfungen ihre Grundlage behalten.
|
||||
await assignToDepartment(
|
||||
perms(nutzer.stufe4, 4, { permissions: ['personnel.read', 'personnel.edit'] }),
|
||||
{ personnelFileId: personOffenId, departmentId: abteilungId },
|
||||
)
|
||||
})
|
||||
|
||||
describe('Vermerke', () => {
|
||||
const schreiber = () =>
|
||||
perms(nutzer.stufe4, 4, {
|
||||
permissions: ['entry.create', 'entry.edit_own', 'entry.retract'],
|
||||
})
|
||||
|
||||
it('verbirgt einen Vermerk über der Stufe des Lesers', async () => {
|
||||
const id = `${marke}-v1`
|
||||
await createEntry(schreiber(), {
|
||||
id,
|
||||
departmentKey: abteilungKey,
|
||||
body: 'Nur für die Leitung',
|
||||
minClearance: 4,
|
||||
})
|
||||
|
||||
const niedrig = await listEntries(perms(nutzer.stufe1, 1), abteilungId)
|
||||
expect(niedrig.map((v) => v.id)).not.toContain(id)
|
||||
|
||||
const hoch = await listEntries(perms(nutzer.stufe4, 4), abteilungId)
|
||||
expect(hoch.map((v) => v.id)).toContain(id)
|
||||
})
|
||||
|
||||
it('lässt niemanden über seiner eigenen Stufe schreiben', async () => {
|
||||
await expect(
|
||||
createEntry(perms(nutzer.stufe1, 1, { permissions: ['entry.create'] }), {
|
||||
id: `${marke}-v2`,
|
||||
departmentKey: abteilungKey,
|
||||
body: 'Zu hoch gegriffen',
|
||||
minClearance: 4,
|
||||
}),
|
||||
).rejects.toThrow(AccessError)
|
||||
})
|
||||
|
||||
it('bewahrt bei einer Änderung den vorherigen Stand', async () => {
|
||||
const id = `${marke}-v3`
|
||||
await createEntry(schreiber(), {
|
||||
id,
|
||||
departmentKey: abteilungKey,
|
||||
body: 'Erster Stand',
|
||||
minClearance: 0,
|
||||
})
|
||||
await editEntry(schreiber(), { id, body: 'Zweiter Stand' })
|
||||
|
||||
const fassungen = await db.departmentEntryVersion.findMany({ where: { entryId: id } })
|
||||
expect(fassungen).toHaveLength(1)
|
||||
expect(fassungen[0]?.body).toBe('Erster Stand')
|
||||
|
||||
const jetzt = await db.departmentEntry.findUniqueOrThrow({ where: { id } })
|
||||
expect(jetzt.body).toBe('Zweiter Stand')
|
||||
expect(jetzt.version).toBe(2)
|
||||
})
|
||||
|
||||
it('lässt beim Zurückziehen einen Grabstein stehen', async () => {
|
||||
const id = `${marke}-v4`
|
||||
await createEntry(schreiber(), {
|
||||
id,
|
||||
departmentKey: abteilungKey,
|
||||
body: 'Wird zurückgezogen',
|
||||
minClearance: 0,
|
||||
})
|
||||
await retractEntry(schreiber(), { id, reason: 'Verwechslung mit einem anderen Vorgang' })
|
||||
|
||||
const danach = await db.departmentEntry.findUniqueOrThrow({ where: { id } })
|
||||
expect(danach.retractedAt).not.toBeNull()
|
||||
expect(danach.retractionReason).toContain('Verwechslung')
|
||||
|
||||
// Und er ist weiterhin da: es gibt kein Löschen.
|
||||
await db.departmentEntry.deleteMany({ where: { id } })
|
||||
expect(await db.departmentEntry.findUnique({ where: { id } })).not.toBeNull()
|
||||
})
|
||||
})
|
||||
})
|
||||
Reference in New Issue
Block a user