feat(stammdaten): Mitarbeiter, Abteilungen und Geraete (#25)
This commit was merged in pull request #25.
This commit is contained in:
@@ -0,0 +1,150 @@
|
||||
"use server";
|
||||
|
||||
import { revalidatePath } from "next/cache";
|
||||
import { z } from "@/lib/validierung";
|
||||
import { MandantFehler, type HandelnderBenutzer } from "@/server/mandant";
|
||||
import { RechteFehler, rechtErforderlich } from "@/server/auth/sitzungspflicht";
|
||||
import {
|
||||
AbteilungsFehler,
|
||||
abteilungAnlegen,
|
||||
abteilungArchivieren,
|
||||
abteilungBearbeiten,
|
||||
} from "@/server/services/abteilungen";
|
||||
|
||||
/**
|
||||
* Server Actions der Abteilungen (#011).
|
||||
*
|
||||
* Recht ist `verwaltung`: an einer Abteilung haengen Ziel-OU und
|
||||
* Standardgruppen — also das, was die spaeteren Befehle in ein Verzeichnis
|
||||
* schreiben. Ein Tippfehler dort legt ein Konto an der falschen Stelle an.
|
||||
*/
|
||||
|
||||
export type AktionsErgebnis = { readonly fehler?: string; readonly erfolg?: string };
|
||||
|
||||
const RECHTE_MELDUNG =
|
||||
"Deine Anmeldung gilt nicht mehr. Melde dich in einem zweiten Tab neu an und klicke dann hier " +
|
||||
"noch einmal — was du eingegeben hast, steht weiterhin auf dieser Seite.";
|
||||
|
||||
async function angemeldetOderMeldung(): Promise<
|
||||
{ readonly benutzer: HandelnderBenutzer } | { readonly fehler: string }
|
||||
> {
|
||||
try {
|
||||
const { benutzer } = await rechtErforderlich("verwaltung");
|
||||
return { benutzer: { id: benutzer.id, rolle: benutzer.rolle } };
|
||||
} catch (fehler) {
|
||||
if (fehler instanceof RechteFehler) return { fehler: RECHTE_MELDUNG };
|
||||
throw fehler;
|
||||
}
|
||||
}
|
||||
|
||||
function alsErgebnis(fehler: unknown, neutral: string): AktionsErgebnis {
|
||||
if (fehler instanceof AbteilungsFehler || fehler instanceof MandantFehler) {
|
||||
return { fehler: fehler.message };
|
||||
}
|
||||
console.error(`${neutral}:`, fehler instanceof Error ? `${fehler.name}: ${fehler.message}` : fehler);
|
||||
return { fehler: neutral };
|
||||
}
|
||||
|
||||
const AbteilungsSchema = z.object({
|
||||
name: z.string().trim().min(1, "Bitte einen Namen angeben."),
|
||||
zielOu: z.string().trim().optional(),
|
||||
standardGruppen: z.string().trim().optional(),
|
||||
mailDomain: z.string().trim().optional(),
|
||||
notizen: z.string().trim().optional(),
|
||||
kundeId: z.string().trim().optional(),
|
||||
});
|
||||
|
||||
function ausFormular(formular: FormData) {
|
||||
return AbteilungsSchema.safeParse({
|
||||
name: formular.get("name"),
|
||||
zielOu: formular.get("zielOu") ?? undefined,
|
||||
standardGruppen: formular.get("standardGruppen") ?? undefined,
|
||||
mailDomain: formular.get("mailDomain") ?? undefined,
|
||||
notizen: formular.get("notizen") ?? undefined,
|
||||
kundeId: formular.get("kundeId") ?? undefined,
|
||||
});
|
||||
}
|
||||
|
||||
/** Standardgruppen kommen als eine Zeile mit Kommas – so, wie sie im Befehl stehen. */
|
||||
function gruppenZerlegen(roh: string | undefined): string[] {
|
||||
return (roh ?? "")
|
||||
.split(",")
|
||||
.map((gruppe) => gruppe.trim())
|
||||
.filter(Boolean);
|
||||
}
|
||||
|
||||
export async function abteilungAnlegenAktion(
|
||||
_vorher: AktionsErgebnis,
|
||||
formular: FormData,
|
||||
): Promise<AktionsErgebnis> {
|
||||
const zugang = await angemeldetOderMeldung();
|
||||
if ("fehler" in zugang) return zugang;
|
||||
|
||||
const eingabe = ausFormular(formular);
|
||||
if (!eingabe.success) {
|
||||
return { fehler: eingabe.error.issues[0]?.message ?? "Die Eingabe ist unvollständig." };
|
||||
}
|
||||
|
||||
try {
|
||||
const abteilung = await abteilungAnlegen(
|
||||
{
|
||||
...eingabe.data,
|
||||
standardGruppen: gruppenZerlegen(eingabe.data.standardGruppen),
|
||||
kundeId: eingabe.data.kundeId || null,
|
||||
},
|
||||
zugang.benutzer,
|
||||
);
|
||||
revalidatePath("/admin/abteilungen");
|
||||
return { erfolg: `„${abteilung.name}“ wurde angelegt.` };
|
||||
} catch (fehler) {
|
||||
return alsErgebnis(fehler, "Die Abteilung konnte nicht angelegt werden.");
|
||||
}
|
||||
}
|
||||
|
||||
export async function abteilungBearbeitenAktion(
|
||||
_vorher: AktionsErgebnis,
|
||||
formular: FormData,
|
||||
): Promise<AktionsErgebnis> {
|
||||
const zugang = await angemeldetOderMeldung();
|
||||
if ("fehler" in zugang) return zugang;
|
||||
|
||||
const abteilungId = z.string().min(1).safeParse(formular.get("abteilungId"));
|
||||
if (!abteilungId.success) return { fehler: "Es fehlt die Abteilung." };
|
||||
const eingabe = ausFormular(formular);
|
||||
if (!eingabe.success) {
|
||||
return { fehler: eingabe.error.issues[0]?.message ?? "Die Eingabe ist unvollständig." };
|
||||
}
|
||||
|
||||
try {
|
||||
await abteilungBearbeiten(
|
||||
abteilungId.data,
|
||||
{ ...eingabe.data, standardGruppen: gruppenZerlegen(eingabe.data.standardGruppen) },
|
||||
zugang.benutzer,
|
||||
);
|
||||
revalidatePath("/admin/abteilungen");
|
||||
return { erfolg: "Gespeichert." };
|
||||
} catch (fehler) {
|
||||
return alsErgebnis(fehler, "Die Änderung konnte nicht gespeichert werden.");
|
||||
}
|
||||
}
|
||||
|
||||
export async function abteilungArchivierenAktion(
|
||||
_vorher: AktionsErgebnis,
|
||||
formular: FormData,
|
||||
): Promise<AktionsErgebnis> {
|
||||
const zugang = await angemeldetOderMeldung();
|
||||
if ("fehler" in zugang) return zugang;
|
||||
|
||||
const eingabe = z
|
||||
.object({ abteilungId: z.string().min(1), archiviert: z.enum(["true", "false"]) })
|
||||
.safeParse({ abteilungId: formular.get("abteilungId"), archiviert: formular.get("archiviert") });
|
||||
if (!eingabe.success) return { fehler: "Die Eingabe ist unvollständig." };
|
||||
|
||||
try {
|
||||
await abteilungArchivieren(eingabe.data.abteilungId, eingabe.data.archiviert === "true", zugang.benutzer);
|
||||
revalidatePath("/admin/abteilungen");
|
||||
return {};
|
||||
} catch (fehler) {
|
||||
return alsErgebnis(fehler, "Die Änderung konnte nicht gespeichert werden.");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,289 @@
|
||||
"use server";
|
||||
|
||||
import { revalidatePath } from "next/cache";
|
||||
import { GeraeteTyp } from "@/generated/prisma/enums";
|
||||
import { z } from "@/lib/validierung";
|
||||
import { RechteFehler, rechtErforderlich } from "@/server/auth/sitzungspflicht";
|
||||
import { MandantFehler, kundenEbeneSichtbar, type HandelnderBenutzer } from "@/server/mandant";
|
||||
import {
|
||||
GeraeteFehler,
|
||||
geraeteImportieren,
|
||||
geraetAnlegen,
|
||||
geraetArchivieren,
|
||||
geraetBearbeiten,
|
||||
geraetLoeschen,
|
||||
type ImportAbweisung,
|
||||
} from "@/server/services/geraete";
|
||||
|
||||
/**
|
||||
* Server Actions der Geraete (#011).
|
||||
*
|
||||
* Duenn: Recht pruefen, Zod anwenden, Dienst rufen. Das Recht ist
|
||||
* `geraeteBearbeiten` — ADMIN, REDAKTEUR und TECHNIKER. Lesen darf jeder
|
||||
* Angemeldete, das prueft die Seite selbst.
|
||||
*/
|
||||
|
||||
export type AktionsErgebnis = {
|
||||
readonly fehler?: string;
|
||||
readonly erfolg?: string;
|
||||
/** Nur beim CSV-Import: je abgewiesene Zeile eine Nummer und ein Grund. */
|
||||
readonly abgewiesen?: readonly ImportAbweisung[];
|
||||
};
|
||||
|
||||
const RECHTE_MELDUNG =
|
||||
"Deine Anmeldung gilt nicht mehr. Melde dich in einem zweiten Tab neu an und klicke dann hier " +
|
||||
"noch einmal — was du eingegeben hast, steht weiterhin auf dieser Seite.";
|
||||
|
||||
/**
|
||||
* Die Rechtepruefung so, dass ein abgelaufenes Cookie kein Datenverlust ist.
|
||||
*
|
||||
* `rechtErforderlich` wirft. Ungefangen landet der Wurf in Nexts Fehlergrenze,
|
||||
* die Seite wird ausgehaengt — und bei einem Formular mit halb eingetippten
|
||||
* Stammdaten oder einer eingelesenen CSV-Datei ist das genau die Arbeit, die weg
|
||||
* ist. Befund aus dem Review von #010, geloest wie dort (siehe
|
||||
* src/server/actions/vorlagen.ts).
|
||||
*/
|
||||
async function angemeldetOderMeldung(
|
||||
recht: "geraeteBearbeiten" | "verwaltung" = "geraeteBearbeiten",
|
||||
): Promise<{ readonly benutzer: HandelnderBenutzer } | { readonly fehler: string }> {
|
||||
try {
|
||||
const { benutzer } = await rechtErforderlich(recht);
|
||||
// Die Dienste brauchen von der Sitzung nur Kennung und Rolle.
|
||||
return { benutzer: { id: benutzer.id, rolle: benutzer.rolle } };
|
||||
} catch (fehler) {
|
||||
if (fehler instanceof RechteFehler) return { fehler: RECHTE_MELDUNG };
|
||||
throw fehler;
|
||||
}
|
||||
}
|
||||
|
||||
/** Uebersetzt die Fehler der Dienste in eine Meldung, alles andere in eine neutrale. */
|
||||
function alsErgebnis(fehler: unknown, neutral: string): AktionsErgebnis {
|
||||
if (fehler instanceof GeraeteFehler || fehler instanceof MandantFehler) {
|
||||
return { fehler: fehler.message };
|
||||
}
|
||||
if (fehler instanceof RechteFehler) {
|
||||
return { fehler: RECHTE_MELDUNG };
|
||||
}
|
||||
console.error(`${neutral}:`, fehler instanceof Error ? `${fehler.name}: ${fehler.message}` : fehler);
|
||||
return { fehler: neutral };
|
||||
}
|
||||
|
||||
const TypSchema = z.enum(GeraeteTyp);
|
||||
|
||||
const AnlegenSchema = z.object({
|
||||
hostname: z.string().trim().optional(),
|
||||
bezeichnung: z.string().trim().optional(),
|
||||
seriennummer: z.string().trim().optional(),
|
||||
inventarnummer: z.string().trim().optional(),
|
||||
typ: TypSchema.optional(),
|
||||
modell: z.string().trim().optional(),
|
||||
notizen: z.string().trim().optional(),
|
||||
mitarbeiterId: z.string().trim().optional(),
|
||||
kundeId: z.string().trim().optional(),
|
||||
});
|
||||
|
||||
/**
|
||||
* Ein Feld, das das Formular nicht mitschickt, ist `undefined` und heisst „nicht
|
||||
* angefasst“. Ein mitgeschicktes leeres Feld heisst „geleert“ — beim Bearbeiten
|
||||
* macht das den Unterschied.
|
||||
*/
|
||||
function feld(formular: FormData, name: string): string | undefined {
|
||||
const wert = formular.get(name);
|
||||
return typeof wert === "string" ? wert : undefined;
|
||||
}
|
||||
|
||||
export async function geraetAnlegenAktion(
|
||||
_vorher: AktionsErgebnis,
|
||||
formular: FormData,
|
||||
): Promise<AktionsErgebnis> {
|
||||
const zugang = await angemeldetOderMeldung();
|
||||
if ("fehler" in zugang) return zugang;
|
||||
|
||||
const eingabe = AnlegenSchema.safeParse({
|
||||
hostname: feld(formular, "hostname"),
|
||||
bezeichnung: feld(formular, "bezeichnung"),
|
||||
seriennummer: feld(formular, "seriennummer"),
|
||||
inventarnummer: feld(formular, "inventarnummer"),
|
||||
typ: feld(formular, "typ") || undefined,
|
||||
modell: feld(formular, "modell"),
|
||||
notizen: feld(formular, "notizen"),
|
||||
mitarbeiterId: feld(formular, "mitarbeiterId"),
|
||||
kundeId: feld(formular, "kundeId"),
|
||||
});
|
||||
if (!eingabe.success) {
|
||||
return { fehler: eingabe.error.issues[0]?.message ?? "Die Eingabe ist unvollständig." };
|
||||
}
|
||||
|
||||
// Eine Kundenwahl gibt es nur im Modus Dienstleistung; `kundeErmitteln`
|
||||
// verwirft eine mitgeschickte Kennung im Modus Intern ohnehin (#008).
|
||||
const kundeId = (await kundenEbeneSichtbar()) ? eingabe.data.kundeId || null : null;
|
||||
|
||||
try {
|
||||
const geraet = await geraetAnlegen(
|
||||
{
|
||||
hostname: eingabe.data.hostname ?? null,
|
||||
bezeichnung: eingabe.data.bezeichnung ?? null,
|
||||
seriennummer: eingabe.data.seriennummer ?? null,
|
||||
inventarnummer: eingabe.data.inventarnummer ?? null,
|
||||
...(eingabe.data.typ ? { typ: eingabe.data.typ } : {}),
|
||||
modell: eingabe.data.modell ?? null,
|
||||
notizen: eingabe.data.notizen ?? null,
|
||||
mitarbeiterId: eingabe.data.mitarbeiterId ?? null,
|
||||
kundeId,
|
||||
},
|
||||
zugang.benutzer,
|
||||
);
|
||||
revalidatePath("/geraete");
|
||||
return {
|
||||
erfolg: `„${geraet.hostname ?? geraet.bezeichnung ?? geraet.tagCode}“ wurde angelegt, Tag-Code ${geraet.tagCode}.`,
|
||||
};
|
||||
} catch (fehler) {
|
||||
return alsErgebnis(fehler, "Das Gerät konnte nicht angelegt werden.");
|
||||
}
|
||||
}
|
||||
|
||||
const BearbeitenSchema = AnlegenSchema.extend({
|
||||
geraetId: z.string().min(1),
|
||||
/** Kommt als verstecktes Feld mit, damit ein Aenderungsversuch auffaellt. */
|
||||
tagCode: z.string().trim().optional(),
|
||||
});
|
||||
|
||||
export async function geraetBearbeitenAktion(
|
||||
_vorher: AktionsErgebnis,
|
||||
formular: FormData,
|
||||
): Promise<AktionsErgebnis> {
|
||||
const zugang = await angemeldetOderMeldung();
|
||||
if ("fehler" in zugang) return zugang;
|
||||
|
||||
const eingabe = BearbeitenSchema.safeParse({
|
||||
geraetId: feld(formular, "geraetId"),
|
||||
hostname: feld(formular, "hostname"),
|
||||
bezeichnung: feld(formular, "bezeichnung"),
|
||||
seriennummer: feld(formular, "seriennummer"),
|
||||
inventarnummer: feld(formular, "inventarnummer"),
|
||||
typ: feld(formular, "typ") || undefined,
|
||||
modell: feld(formular, "modell"),
|
||||
notizen: feld(formular, "notizen"),
|
||||
mitarbeiterId: feld(formular, "mitarbeiterId"),
|
||||
tagCode: feld(formular, "tagCode"),
|
||||
});
|
||||
if (!eingabe.success) {
|
||||
return { fehler: eingabe.error.issues[0]?.message ?? "Die Eingabe ist unvollständig." };
|
||||
}
|
||||
|
||||
try {
|
||||
await geraetBearbeiten(
|
||||
eingabe.data.geraetId,
|
||||
{
|
||||
// Ein Feld, das das Formular nicht mitschickt, bleibt unberuehrt; ein
|
||||
// leeres Feld heisst „geleert“. Deshalb `?? null` und nicht `|| null`.
|
||||
...(eingabe.data.hostname === undefined ? {} : { hostname: eingabe.data.hostname }),
|
||||
...(eingabe.data.bezeichnung === undefined ? {} : { bezeichnung: eingabe.data.bezeichnung }),
|
||||
...(eingabe.data.seriennummer === undefined ? {} : { seriennummer: eingabe.data.seriennummer }),
|
||||
...(eingabe.data.inventarnummer === undefined ? {} : { inventarnummer: eingabe.data.inventarnummer }),
|
||||
...(eingabe.data.typ === undefined ? {} : { typ: eingabe.data.typ }),
|
||||
...(eingabe.data.modell === undefined ? {} : { modell: eingabe.data.modell }),
|
||||
...(eingabe.data.notizen === undefined ? {} : { notizen: eingabe.data.notizen }),
|
||||
...(eingabe.data.mitarbeiterId === undefined ? {} : { mitarbeiterId: eingabe.data.mitarbeiterId }),
|
||||
/*
|
||||
* Auch ein **leer** mitgeschickter tagCode ist ein Aenderungsversuch und
|
||||
* gehoert vor den Dienst. Mit `? :` auf den Wahrheitswert fiel er weg,
|
||||
* und damit lief genau das ins Leere, was `GeraeteAenderung.tagCode`
|
||||
* ausdruecklich sichtbar machen soll.
|
||||
*/
|
||||
...(eingabe.data.tagCode === undefined ? {} : { tagCode: eingabe.data.tagCode }),
|
||||
},
|
||||
zugang.benutzer,
|
||||
);
|
||||
revalidatePath("/geraete");
|
||||
return { erfolg: "Gespeichert." };
|
||||
} catch (fehler) {
|
||||
return alsErgebnis(fehler, "Die Änderung konnte nicht gespeichert werden.");
|
||||
}
|
||||
}
|
||||
|
||||
export async function geraetArchivierenAktion(
|
||||
_vorher: AktionsErgebnis,
|
||||
formular: FormData,
|
||||
): Promise<AktionsErgebnis> {
|
||||
const zugang = await angemeldetOderMeldung();
|
||||
if ("fehler" in zugang) return zugang;
|
||||
|
||||
const eingabe = z
|
||||
.object({ geraetId: z.string().min(1), archiviert: z.enum(["true", "false"]) })
|
||||
.safeParse({ geraetId: feld(formular, "geraetId"), archiviert: feld(formular, "archiviert") });
|
||||
if (!eingabe.success) return { fehler: "Die Eingabe ist unvollständig." };
|
||||
|
||||
try {
|
||||
await geraetArchivieren(eingabe.data.geraetId, eingabe.data.archiviert === "true", zugang.benutzer);
|
||||
revalidatePath("/geraete");
|
||||
return {};
|
||||
} catch (fehler) {
|
||||
return alsErgebnis(fehler, "Die Änderung konnte nicht gespeichert werden.");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Endgueltig loeschen — nur `verwaltung`.
|
||||
*
|
||||
* Archivieren ist der Normalfall und steht jedem offen, der Geraete pflegt.
|
||||
* Loeschen dagegen ist nicht ruecknehmbar und verbrennt den Tag-Code fuer immer:
|
||||
* er kommt nach der Regel des Projekts nie zurueck, der gedruckte Aufkleber ist
|
||||
* damit wertlos. Gebraucht wird es nur fuer den Vertipper von eben — und dafuer
|
||||
* darf man den Administrator fragen. Abteilungen und Mitarbeiter haben aus
|
||||
* demselben Grund gar keinen Loeschweg.
|
||||
*/
|
||||
export async function geraetLoeschenAktion(
|
||||
_vorher: AktionsErgebnis,
|
||||
formular: FormData,
|
||||
): Promise<AktionsErgebnis> {
|
||||
const zugang = await angemeldetOderMeldung("verwaltung");
|
||||
if ("fehler" in zugang) return zugang;
|
||||
|
||||
const geraetId = z.string().min(1).safeParse(feld(formular, "geraetId"));
|
||||
if (!geraetId.success) return { fehler: "Es fehlt das Gerät." };
|
||||
|
||||
try {
|
||||
await geraetLoeschen(geraetId.data, zugang.benutzer);
|
||||
revalidatePath("/geraete");
|
||||
return { erfolg: "Gelöscht. Der Tag-Code bleibt vergeben." };
|
||||
} catch (fehler) {
|
||||
return alsErgebnis(fehler, "Das Gerät konnte nicht gelöscht werden.");
|
||||
}
|
||||
}
|
||||
|
||||
export async function geraeteImportierenAktion(
|
||||
_vorher: AktionsErgebnis,
|
||||
formular: FormData,
|
||||
): Promise<AktionsErgebnis> {
|
||||
const zugang = await angemeldetOderMeldung();
|
||||
if ("fehler" in zugang) return zugang;
|
||||
|
||||
const eingabe = z
|
||||
.object({
|
||||
inhalt: z.string().min(1, "Bitte eine CSV-Datei auswählen oder den Inhalt einfügen."),
|
||||
kundeId: z.string().trim().optional(),
|
||||
})
|
||||
.safeParse({ inhalt: feld(formular, "inhalt"), kundeId: feld(formular, "kundeId") });
|
||||
if (!eingabe.success) {
|
||||
return { fehler: eingabe.error.issues[0]?.message ?? "Die Eingabe ist unvollständig." };
|
||||
}
|
||||
|
||||
const kundeId = (await kundenEbeneSichtbar()) ? eingabe.data.kundeId || null : null;
|
||||
|
||||
try {
|
||||
const ergebnis = await geraeteImportieren(eingabe.data.inhalt, zugang.benutzer, kundeId);
|
||||
revalidatePath("/geraete");
|
||||
const teile = [
|
||||
`${ergebnis.angelegt} von ${ergebnis.gesamt} ${ergebnis.gesamt === 1 ? "Zeile" : "Zeilen"} angelegt`,
|
||||
];
|
||||
if (ergebnis.abgewiesen.length > 0) {
|
||||
teile.push(
|
||||
`${ergebnis.abgewiesen.length} ${ergebnis.abgewiesen.length === 1 ? "Zeile" : "Zeilen"} abgewiesen`,
|
||||
);
|
||||
}
|
||||
return { erfolg: `${teile.join(", ")}.`, abgewiesen: ergebnis.abgewiesen };
|
||||
} catch (fehler) {
|
||||
return alsErgebnis(fehler, "Die Datei konnte nicht eingelesen werden.");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,155 @@
|
||||
"use server";
|
||||
|
||||
import { revalidatePath } from "next/cache";
|
||||
import { z } from "@/lib/validierung";
|
||||
import { MandantFehler } from "@/server/mandant";
|
||||
import { RechteFehler, rechtErforderlich } from "@/server/auth/sitzungspflicht";
|
||||
import {
|
||||
MitarbeiterFehler,
|
||||
mitarbeiterAktivSetzen,
|
||||
mitarbeiterAnlegen,
|
||||
mitarbeiterBearbeiten,
|
||||
} from "@/server/services/mitarbeiter";
|
||||
import type { HandelnderBenutzer } from "@/server/mandant";
|
||||
|
||||
/**
|
||||
* Server Actions der Mitarbeiter (#011).
|
||||
*
|
||||
* Duenn: Recht pruefen, Zod anwenden, Dienst rufen. Das Recht ist
|
||||
* `mitarbeiterBearbeiten` — dieselben Rollen wie bei den Geraeten, weil der
|
||||
* Techniker beim Onboarding vor der Person steht, bevor der naechste
|
||||
* Verzeichnisabgleich gelaufen ist.
|
||||
*/
|
||||
|
||||
export type AktionsErgebnis = { readonly fehler?: string; readonly erfolg?: string };
|
||||
|
||||
const RECHTE_MELDUNG =
|
||||
"Deine Anmeldung gilt nicht mehr. Melde dich in einem zweiten Tab neu an und klicke dann hier " +
|
||||
"noch einmal — was du eingegeben hast, steht weiterhin auf dieser Seite.";
|
||||
|
||||
/**
|
||||
* Faengt den Rechtefehler ab, statt ihn werfen zu lassen.
|
||||
*
|
||||
* Ein ungefangener Wurf landet in Nexts Fehlergrenze und haengt die Seite aus —
|
||||
* samt allem, was im Formular stand. Nach zwoelf Stunden laeuft die Sitzung von
|
||||
* selbst ab; das trifft sonst genau die Person, die gerade lange tippt (#010).
|
||||
*/
|
||||
async function angemeldetOderMeldung(): Promise<
|
||||
{ readonly benutzer: HandelnderBenutzer } | { readonly fehler: string }
|
||||
> {
|
||||
try {
|
||||
const { benutzer } = await rechtErforderlich("mitarbeiterBearbeiten");
|
||||
return { benutzer: { id: benutzer.id, rolle: benutzer.rolle } };
|
||||
} catch (fehler) {
|
||||
if (fehler instanceof RechteFehler) return { fehler: RECHTE_MELDUNG };
|
||||
throw fehler;
|
||||
}
|
||||
}
|
||||
|
||||
function alsErgebnis(fehler: unknown, neutral: string): AktionsErgebnis {
|
||||
if (fehler instanceof MitarbeiterFehler || fehler instanceof MandantFehler) {
|
||||
return { fehler: fehler.message };
|
||||
}
|
||||
console.error(`${neutral}:`, fehler instanceof Error ? `${fehler.name}: ${fehler.message}` : fehler);
|
||||
return { fehler: neutral };
|
||||
}
|
||||
|
||||
const StammdatenSchema = z.object({
|
||||
vorname: z.string().trim().min(1, "Bitte einen Vornamen angeben."),
|
||||
nachname: z.string().trim().min(1, "Bitte einen Nachnamen angeben."),
|
||||
anzeigename: z.string().trim().optional(),
|
||||
mail: z.string().trim().optional(),
|
||||
upn: z.string().trim().optional(),
|
||||
sam: z.string().trim().optional(),
|
||||
abteilung: z.string().trim().optional(),
|
||||
titel: z.string().trim().optional(),
|
||||
kundeId: z.string().trim().optional(),
|
||||
});
|
||||
|
||||
function ausFormular(formular: FormData) {
|
||||
return StammdatenSchema.safeParse({
|
||||
vorname: formular.get("vorname"),
|
||||
nachname: formular.get("nachname"),
|
||||
anzeigename: formular.get("anzeigename") ?? undefined,
|
||||
mail: formular.get("mail") ?? undefined,
|
||||
upn: formular.get("upn") ?? undefined,
|
||||
sam: formular.get("sam") ?? undefined,
|
||||
abteilung: formular.get("abteilung") ?? undefined,
|
||||
titel: formular.get("titel") ?? undefined,
|
||||
kundeId: formular.get("kundeId") ?? undefined,
|
||||
});
|
||||
}
|
||||
|
||||
export async function mitarbeiterAnlegenAktion(
|
||||
_vorher: AktionsErgebnis,
|
||||
formular: FormData,
|
||||
): Promise<AktionsErgebnis> {
|
||||
const zugang = await angemeldetOderMeldung();
|
||||
if ("fehler" in zugang) return zugang;
|
||||
|
||||
const eingabe = ausFormular(formular);
|
||||
if (!eingabe.success) {
|
||||
return { fehler: eingabe.error.issues[0]?.message ?? "Die Eingabe ist unvollständig." };
|
||||
}
|
||||
|
||||
try {
|
||||
const mitarbeiter = await mitarbeiterAnlegen(
|
||||
{ ...eingabe.data, kundeId: eingabe.data.kundeId || null },
|
||||
zugang.benutzer,
|
||||
);
|
||||
revalidatePath("/mitarbeiter");
|
||||
return { erfolg: `„${mitarbeiter.anzeigename}“ wurde angelegt.` };
|
||||
} catch (fehler) {
|
||||
return alsErgebnis(fehler, "Die Person konnte nicht angelegt werden.");
|
||||
}
|
||||
}
|
||||
|
||||
export async function mitarbeiterBearbeitenAktion(
|
||||
_vorher: AktionsErgebnis,
|
||||
formular: FormData,
|
||||
): Promise<AktionsErgebnis> {
|
||||
const zugang = await angemeldetOderMeldung();
|
||||
if ("fehler" in zugang) return zugang;
|
||||
|
||||
const mitarbeiterId = z.string().min(1).safeParse(formular.get("mitarbeiterId"));
|
||||
if (!mitarbeiterId.success) return { fehler: "Es fehlt die Person." };
|
||||
const eingabe = ausFormular(formular);
|
||||
if (!eingabe.success) {
|
||||
return { fehler: eingabe.error.issues[0]?.message ?? "Die Eingabe ist unvollständig." };
|
||||
}
|
||||
|
||||
try {
|
||||
await mitarbeiterBearbeiten(mitarbeiterId.data, eingabe.data, zugang.benutzer);
|
||||
revalidatePath("/mitarbeiter");
|
||||
revalidatePath(`/mitarbeiter/${mitarbeiterId.data}`);
|
||||
return { erfolg: "Gespeichert." };
|
||||
} catch (fehler) {
|
||||
return alsErgebnis(fehler, "Die Änderung konnte nicht gespeichert werden.");
|
||||
}
|
||||
}
|
||||
|
||||
export async function mitarbeiterAktivSetzenAktion(
|
||||
_vorher: AktionsErgebnis,
|
||||
formular: FormData,
|
||||
): Promise<AktionsErgebnis> {
|
||||
const zugang = await angemeldetOderMeldung();
|
||||
if ("fehler" in zugang) return zugang;
|
||||
|
||||
const eingabe = z
|
||||
.object({ mitarbeiterId: z.string().min(1), aktiv: z.enum(["true", "false"]) })
|
||||
.safeParse({ mitarbeiterId: formular.get("mitarbeiterId"), aktiv: formular.get("aktiv") });
|
||||
if (!eingabe.success) return { fehler: "Die Eingabe ist unvollständig." };
|
||||
|
||||
try {
|
||||
const mitarbeiter = await mitarbeiterAktivSetzen(
|
||||
eingabe.data.mitarbeiterId,
|
||||
eingabe.data.aktiv === "true",
|
||||
zugang.benutzer,
|
||||
);
|
||||
revalidatePath("/mitarbeiter");
|
||||
revalidatePath(`/mitarbeiter/${eingabe.data.mitarbeiterId}`);
|
||||
return { erfolg: mitarbeiter.aktiv ? "Wieder aktiv." : "Deaktiviert." };
|
||||
} catch (fehler) {
|
||||
return alsErgebnis(fehler, "Die Änderung konnte nicht gespeichert werden.");
|
||||
}
|
||||
}
|
||||
@@ -26,6 +26,16 @@ export const RECHTE = {
|
||||
laeufeBearbeiten: ["ADMIN", "REDAKTEUR", "TECHNIKER"],
|
||||
/** Geraete und deren Stammdaten pflegen, Tags registrieren. */
|
||||
geraeteBearbeiten: ["ADMIN", "REDAKTEUR", "TECHNIKER"],
|
||||
/**
|
||||
* Mitarbeiter von Hand anlegen, bearbeiten und deaktivieren (#011).
|
||||
*
|
||||
* Dieselben Rollen wie bei den Geraeten, und aus demselben Grund: beim
|
||||
* Onboarding steht der Techniker vor der Person, bevor der naechste
|
||||
* Verzeichnisabgleich gelaufen ist. Die **Abteilungen** bleiben dagegen bei
|
||||
* `verwaltung` — an ihnen haengen Ziel-OU und Standardgruppen, also das, was
|
||||
* die spaeteren PowerShell-Befehle in ein Verzeichnis schreiben.
|
||||
*/
|
||||
mitarbeiterBearbeiten: ["ADMIN", "REDAKTEUR", "TECHNIKER"],
|
||||
/** Vorlagen anlegen, bearbeiten und veroeffentlichen. */
|
||||
vorlagenBearbeiten: ["ADMIN", "REDAKTEUR"],
|
||||
/**
|
||||
|
||||
@@ -0,0 +1,110 @@
|
||||
import type { Prisma } from "@/generated/prisma/client";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { sichtbareKundenIds, type HandelnderBenutzer } from "@/server/mandant";
|
||||
|
||||
/**
|
||||
* Lesemodelle der Abteilungen (#011).
|
||||
*
|
||||
* Die Zahl der zugeordneten Personen kommt aus einer zweiten Abfrage statt aus
|
||||
* `_count`: die Zuordnung laeuft ueber den **Namen** im Freitextfeld
|
||||
* `Mitarbeiter.abteilung`, nicht ueber einen Fremdschluessel. So bleibt ein
|
||||
* Abteilungswert aus dem Verzeichnis erhalten, auch wenn es dazu (noch) keine
|
||||
* gepflegte Abteilung gibt — und genau diese Faelle will man sehen.
|
||||
*/
|
||||
|
||||
export type AbteilungsZeile = {
|
||||
readonly id: string;
|
||||
readonly name: string;
|
||||
readonly zielOu: string | null;
|
||||
readonly standardGruppen: readonly string[];
|
||||
readonly mailDomain: string | null;
|
||||
readonly notizen: string | null;
|
||||
readonly archiviert: boolean;
|
||||
readonly kundeId: string;
|
||||
readonly anzahlMitarbeiter: number;
|
||||
};
|
||||
|
||||
async function kundenBedingung(benutzer: HandelnderBenutzer): Promise<{ kundeId: { in: string[] } }[]> {
|
||||
const sichtbar = await sichtbareKundenIds(benutzer);
|
||||
return sichtbar === undefined ? [] : [{ kundeId: { in: [...sichtbar] } }];
|
||||
}
|
||||
|
||||
const AUSWAHL = {
|
||||
id: true,
|
||||
name: true,
|
||||
zielOu: true,
|
||||
standardGruppen: true,
|
||||
mailDomain: true,
|
||||
notizen: true,
|
||||
archiviert: true,
|
||||
kundeId: true,
|
||||
} satisfies Prisma.AbteilungSelect;
|
||||
|
||||
export async function abteilungsListe(
|
||||
benutzer: HandelnderBenutzer,
|
||||
auchArchivierte = true,
|
||||
): Promise<readonly AbteilungsZeile[]> {
|
||||
const mandant = await kundenBedingung(benutzer);
|
||||
const zeilen = await prisma.abteilung.findMany({
|
||||
where: { AND: [...(auchArchivierte ? [] : [{ archiviert: false }]), ...mandant] },
|
||||
orderBy: [{ archiviert: "asc" }, { name: "asc" }],
|
||||
select: AUSWAHL,
|
||||
});
|
||||
|
||||
// Eine Abfrage fuer alle Zaehlungen statt einer je Abteilung.
|
||||
const zaehlung = await prisma.mitarbeiter.groupBy({
|
||||
by: ["abteilung", "kundeId"],
|
||||
where: { AND: [{ aktiv: true }, { abteilung: { not: null } }, ...mandant] },
|
||||
_count: { _all: true },
|
||||
});
|
||||
const anzahlNach = new Map(
|
||||
zaehlung.map((eintrag) => [`${eintrag.kundeId}\u0000${eintrag.abteilung ?? ""}`, eintrag._count._all]),
|
||||
);
|
||||
|
||||
return zeilen.map((zeile) => ({
|
||||
...zeile,
|
||||
standardGruppen: zeile.standardGruppen,
|
||||
anzahlMitarbeiter: anzahlNach.get(`${zeile.kundeId}\u0000${zeile.name}`) ?? 0,
|
||||
}));
|
||||
}
|
||||
|
||||
/**
|
||||
* Abteilungsnamen, die bei Mitarbeitern vorkommen, aber nicht gepflegt sind.
|
||||
*
|
||||
* Das ist der Vorschlag fuer „Abteilung anlegen“ nach einem Verzeichnisabgleich:
|
||||
* die Namen stehen schon in den Daten, es fehlen nur Ziel-OU und Gruppen.
|
||||
*
|
||||
* Gruppiert wird nach **Kunde und Name**, nicht nach Name allein. Sonst gilt
|
||||
* „Vertrieb“ als gepflegt, sobald **irgendein** Kunde eine Abteilung dieses
|
||||
* Namens hat — und beim Kunden ohne sie blieben `{{ou}}` und `{{gruppen}}` im
|
||||
* Lauf leer, ohne dass diese Seite es je sagte. Genau so stand es hier, bis der
|
||||
* Review es gefunden hat; `abteilungsListe` darueber macht es seit jeher
|
||||
* richtig.
|
||||
*/
|
||||
export async function ungepflegteAbteilungen(
|
||||
benutzer: HandelnderBenutzer,
|
||||
): Promise<readonly { name: string; anzahl: number; kundeId: string }[]> {
|
||||
const mandant = await kundenBedingung(benutzer);
|
||||
const [vorhandene, benutzte] = await Promise.all([
|
||||
prisma.abteilung.findMany({ where: { AND: mandant }, select: { name: true, kundeId: true } }),
|
||||
prisma.mitarbeiter.groupBy({
|
||||
by: ["abteilung", "kundeId"],
|
||||
where: { AND: [{ aktiv: true }, { abteilung: { not: null } }, ...mandant] },
|
||||
_count: { _all: true },
|
||||
}),
|
||||
]);
|
||||
const schluessel = (kundeId: string, name: string) => `${kundeId}\u0000${name}`;
|
||||
const gepflegt = new Set(vorhandene.map((zeile) => schluessel(zeile.kundeId, zeile.name)));
|
||||
|
||||
return benutzte
|
||||
.filter(
|
||||
(eintrag) =>
|
||||
eintrag.abteilung !== null && !gepflegt.has(schluessel(eintrag.kundeId, eintrag.abteilung)),
|
||||
)
|
||||
.map((eintrag) => ({
|
||||
name: eintrag.abteilung as string,
|
||||
anzahl: eintrag._count._all,
|
||||
kundeId: eintrag.kundeId,
|
||||
}))
|
||||
.sort((a, b) => a.name.localeCompare(b.name, "de"));
|
||||
}
|
||||
@@ -0,0 +1,220 @@
|
||||
import type { Prisma } from "@/generated/prisma/client";
|
||||
import type { GeraeteTyp } from "@/generated/prisma/enums";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { sichtbareKundenIds, type HandelnderBenutzer } from "@/server/mandant";
|
||||
|
||||
/**
|
||||
* Lesemodelle der Geraete (#011).
|
||||
*
|
||||
* Die Mandantensicht wenden diese Funktionen **selbst** an. Im Review von #009
|
||||
* war genau das die Fundstelle fuer drei Blocker: ein Suchfilter brachte ein
|
||||
* zweites `OR` mit und ueberschrieb damit die Kundenbedingung, weil beide in
|
||||
* dasselbe Objektliteral gespreizt wurden. Deshalb liegt hier **jede**
|
||||
* Teilbedingung in einem `AND`-Array, wo keine die andere ueberschreiben kann.
|
||||
* `tests/geraete.test.ts` haelt das mit einem eigenen Test fest.
|
||||
*/
|
||||
|
||||
export type GeraeteZeile = {
|
||||
readonly id: string;
|
||||
readonly tagCode: string;
|
||||
readonly hostname: string | null;
|
||||
readonly bezeichnung: string | null;
|
||||
/** Hostname, sonst Bezeichnung, sonst der Tag-Code. Nie leer. */
|
||||
readonly anzeige: string;
|
||||
readonly typ: GeraeteTyp;
|
||||
readonly modell: string | null;
|
||||
readonly seriennummer: string | null;
|
||||
readonly inventarnummer: string | null;
|
||||
readonly notizen: string | null;
|
||||
readonly archiviert: boolean;
|
||||
/** Leer heisst: vorgedruckter Tag, noch keinem Objekt zugeordnet. */
|
||||
readonly registriertAm: Date | null;
|
||||
readonly kundeId: string;
|
||||
readonly kundeName: string;
|
||||
readonly besitzerId: string | null;
|
||||
readonly besitzerName: string | null;
|
||||
readonly besitzerAktiv: boolean | null;
|
||||
readonly anzahlLaeufe: number;
|
||||
};
|
||||
|
||||
export type GeraeteFilter = {
|
||||
readonly suche?: string;
|
||||
readonly typ?: GeraeteTyp;
|
||||
readonly auchArchivierte?: boolean;
|
||||
};
|
||||
|
||||
/**
|
||||
* Die Mandantenbedingung als **eigener** Ausdruck, nicht als Objekt zum
|
||||
* Hineinspreizen. `undefined` heisst „keine Einschraenkung“.
|
||||
*
|
||||
* Jede Geraetezeile traegt eine `kundeId` – auch im Modus INTERN, wo es die eine
|
||||
* eigene Organisation ist. Es gibt hier also kein „gilt fuer alle“ wie bei den
|
||||
* Vorlagen.
|
||||
*/
|
||||
async function kundenBedingung(benutzer: HandelnderBenutzer): Promise<Prisma.GeraetWhereInput | undefined> {
|
||||
const sichtbar = await sichtbareKundenIds(benutzer);
|
||||
if (sichtbar === undefined) return undefined;
|
||||
return { kundeId: { in: [...sichtbar] } };
|
||||
}
|
||||
|
||||
/**
|
||||
* Auswahl und Abbildung stehen getrennt, damit Liste und Einzelabruf garantiert
|
||||
* dieselben Felder liefern – zwei Modelle fuer dieselbe Zeile laufen mit der Zeit
|
||||
* auseinander.
|
||||
*/
|
||||
const ZEILEN_AUSWAHL = {
|
||||
id: true,
|
||||
tagCode: true,
|
||||
hostname: true,
|
||||
bezeichnung: true,
|
||||
typ: true,
|
||||
modell: true,
|
||||
seriennummer: true,
|
||||
inventarnummer: true,
|
||||
notizen: true,
|
||||
archiviert: true,
|
||||
registriertAm: true,
|
||||
kundeId: true,
|
||||
kunde: { select: { name: true } },
|
||||
mitarbeiter: { select: { id: true, anzeigename: true, aktiv: true } },
|
||||
_count: { select: { laeufe: true } },
|
||||
} satisfies Prisma.GeraetSelect;
|
||||
|
||||
type Rohzeile = Prisma.GeraetGetPayload<{ select: typeof ZEILEN_AUSWAHL }>;
|
||||
|
||||
function zeileBauen(zeile: Rohzeile): GeraeteZeile {
|
||||
return {
|
||||
id: zeile.id,
|
||||
tagCode: zeile.tagCode,
|
||||
hostname: zeile.hostname,
|
||||
bezeichnung: zeile.bezeichnung,
|
||||
anzeige: zeile.hostname ?? zeile.bezeichnung ?? zeile.tagCode,
|
||||
typ: zeile.typ,
|
||||
modell: zeile.modell,
|
||||
seriennummer: zeile.seriennummer,
|
||||
inventarnummer: zeile.inventarnummer,
|
||||
notizen: zeile.notizen,
|
||||
archiviert: zeile.archiviert,
|
||||
registriertAm: zeile.registriertAm,
|
||||
kundeId: zeile.kundeId,
|
||||
kundeName: zeile.kunde.name,
|
||||
besitzerId: zeile.mitarbeiter?.id ?? null,
|
||||
besitzerName: zeile.mitarbeiter?.anzeigename ?? null,
|
||||
besitzerAktiv: zeile.mitarbeiter?.aktiv ?? null,
|
||||
anzahlLaeufe: zeile._count.laeufe,
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Die Suche geht ueber Hostname, Bezeichnung, Seriennummer und `tagCode`.
|
||||
*
|
||||
* Der `tagCode` ist dabei der Notnagel: wer einen Aufkleber in der Hand hat und
|
||||
* die Kamera nicht benutzen kann, tippt ihn ab. Deshalb `contains` und nicht
|
||||
* `equals` – die sechs Zeichen ohne das Praefix sollen genuegen.
|
||||
*/
|
||||
function sucheBedingung(suche: string): Prisma.GeraetWhereInput {
|
||||
const wie = { contains: suche, mode: "insensitive" as const };
|
||||
return {
|
||||
OR: [
|
||||
{ hostname: wie },
|
||||
{ bezeichnung: wie },
|
||||
{ seriennummer: wie },
|
||||
{ inventarnummer: wie },
|
||||
{ tagCode: wie },
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
export async function geraeteListe(
|
||||
benutzer: HandelnderBenutzer,
|
||||
filter: GeraeteFilter = {},
|
||||
): Promise<readonly GeraeteZeile[]> {
|
||||
const suche = filter.suche?.trim();
|
||||
|
||||
const bedingungen = [
|
||||
await kundenBedingung(benutzer),
|
||||
filter.auchArchivierte ? undefined : { archiviert: false },
|
||||
filter.typ ? { typ: filter.typ } : undefined,
|
||||
suche ? sucheBedingung(suche) : undefined,
|
||||
].filter((bedingung): bedingung is Prisma.GeraetWhereInput => bedingung !== undefined);
|
||||
|
||||
const zeilen = await prisma.geraet.findMany({
|
||||
where: { AND: bedingungen },
|
||||
// Archivierte nach unten, dann nach Anzeigename. Prisma kann nicht nach
|
||||
// „Hostname, sonst Bezeichnung“ sortieren; die zwei Schluessel danach kommen
|
||||
// dem nahe genug und sind stabil.
|
||||
orderBy: [{ archiviert: "asc" }, { hostname: "asc" }, { bezeichnung: "asc" }],
|
||||
select: ZEILEN_AUSWAHL,
|
||||
});
|
||||
return zeilen.map(zeileBauen);
|
||||
}
|
||||
|
||||
/**
|
||||
* Ein einzelnes Geraet.
|
||||
*
|
||||
* `undefined` heisst „gibt es nicht oder darfst du nicht sehen“ — die
|
||||
* Unterscheidung waere schon die Auskunft, die wir nicht geben wollen.
|
||||
*/
|
||||
export async function geraetHolen(
|
||||
geraetId: string,
|
||||
benutzer: HandelnderBenutzer,
|
||||
): Promise<GeraeteZeile | undefined> {
|
||||
const mandant = await kundenBedingung(benutzer);
|
||||
const zeile = await prisma.geraet.findFirst({
|
||||
where: { AND: [{ id: geraetId }, ...(mandant ? [mandant] : [])] },
|
||||
select: ZEILEN_AUSWAHL,
|
||||
});
|
||||
return zeile ? zeileBauen(zeile) : undefined;
|
||||
}
|
||||
|
||||
export type BesitzerKandidat = {
|
||||
readonly id: string;
|
||||
readonly anzeigename: string;
|
||||
readonly aktiv: boolean;
|
||||
/** Ein Geraet kann nur einer Person desselben Kunden gehoeren. */
|
||||
readonly kundeId: string;
|
||||
};
|
||||
|
||||
export type BesitzerAuswahl = {
|
||||
readonly kandidaten: readonly BesitzerKandidat[];
|
||||
/** Waren es mehr als die Grenze? Dann sagt die Oberflaeche das auch. */
|
||||
readonly gekuerzt: boolean;
|
||||
};
|
||||
|
||||
/**
|
||||
* Die Personen, die als Besitzer in Frage kommen.
|
||||
*
|
||||
* Eigenes, schmales Lesemodell mit genau vier Feldern – die Geraeteseite braucht
|
||||
* nichts weiter, und die Mitarbeitersicht aus #011 wird an anderer Stelle
|
||||
* gebaut. Deaktivierte sind nicht dabei: wer offboardet, aendert den Besitzer
|
||||
* nicht mehr, sondern gibt das Geraet zurueck.
|
||||
*
|
||||
* Die Grenze ist da, damit ein Verzeichnis mit zehntausend Personen nicht in ein
|
||||
* Auswahlfeld gegossen wird. Dass gekuerzt wurde, bleibt nicht verborgen.
|
||||
*/
|
||||
export async function besitzerKandidaten(
|
||||
benutzer: HandelnderBenutzer,
|
||||
grenze = 500,
|
||||
): Promise<BesitzerAuswahl> {
|
||||
const sichtbar = await sichtbareKundenIds(benutzer);
|
||||
const zeilen = await prisma.mitarbeiter.findMany({
|
||||
where: {
|
||||
AND: [{ aktiv: true }, ...(sichtbar === undefined ? [] : [{ kundeId: { in: [...sichtbar] } }])],
|
||||
},
|
||||
select: { id: true, anzeigename: true, aktiv: true, kundeId: true },
|
||||
orderBy: { anzeigename: "asc" },
|
||||
take: grenze + 1,
|
||||
});
|
||||
return {
|
||||
/*
|
||||
* `kundeId` bleibt drin: ein Geraet kann nur einer Person **desselben**
|
||||
* Kunden gehoeren (zusammengesetzter Fremdschluessel, siehe
|
||||
* services/geraete.ts). Ohne das Feld boete die Auswahlliste Personen an,
|
||||
* die der Dienst danach abweist — eine Wahl, die sie nicht einloesen kann.
|
||||
*/
|
||||
kandidaten: zeilen
|
||||
.slice(0, grenze)
|
||||
.map(({ id, anzeigename, aktiv, kundeId }) => ({ id, anzeigename, aktiv, kundeId })),
|
||||
gekuerzt: zeilen.length > grenze,
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,216 @@
|
||||
import type { Prisma } from "@/generated/prisma/client";
|
||||
import { Herkunft } from "@/generated/prisma/enums";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { sichtbareKundenIds, type HandelnderBenutzer } from "@/server/mandant";
|
||||
|
||||
/**
|
||||
* Lesemodelle der Mitarbeiter (#011).
|
||||
*
|
||||
* Wie ueberall wenden sie die Mandantensicht **selbst** an. Im Review von #009
|
||||
* lag genau hier die Fundstelle fuer drei Blocker: ein Suchfilter brachte ein
|
||||
* zweites `OR` mit und ueberschrieb die Kundenbedingung — ein Buchstabe im
|
||||
* Suchfeld genuegte. Deshalb liegen alle Teilbedingungen in einem `AND`, wo
|
||||
* keine die andere erreichen kann.
|
||||
*/
|
||||
|
||||
export type MitarbeiterZeile = {
|
||||
readonly id: string;
|
||||
readonly anzeigename: string;
|
||||
readonly vorname: string;
|
||||
readonly nachname: string;
|
||||
readonly mail: string | null;
|
||||
readonly upn: string | null;
|
||||
readonly sam: string | null;
|
||||
readonly abteilung: string | null;
|
||||
readonly titel: string | null;
|
||||
readonly aktiv: boolean;
|
||||
readonly herkunft: Herkunft;
|
||||
readonly kundeId: string;
|
||||
readonly kundeName: string;
|
||||
readonly anzahlGeraete: number;
|
||||
readonly anzahlLaeufe: number;
|
||||
};
|
||||
|
||||
export type MitarbeiterFilter = {
|
||||
readonly suche?: string;
|
||||
readonly abteilung?: string;
|
||||
/** Standard ist „nur aktive“ – fuers Offboarding schaltet man es um. */
|
||||
readonly auchDeaktivierte?: boolean;
|
||||
};
|
||||
|
||||
/**
|
||||
* Die Mandantenbedingung als **Liste von Teilbedingungen**, nie als Objekt zum
|
||||
* Hineinspreizen: so kann kein zweiter Filter mit demselben Schluessel sie
|
||||
* ueberschreiben. `[]` heisst „keine Einschraenkung“.
|
||||
*
|
||||
* Dieselbe Form passt fuer Mitarbeiter und Geraete, weil beide `kundeId`
|
||||
* tragen — jede kundenbezogene Zeile tut das (#008).
|
||||
*/
|
||||
async function kundenBedingung(benutzer: HandelnderBenutzer): Promise<{ kundeId: { in: string[] } }[]> {
|
||||
const sichtbar = await sichtbareKundenIds(benutzer);
|
||||
return sichtbar === undefined ? [] : [{ kundeId: { in: [...sichtbar] } }];
|
||||
}
|
||||
|
||||
const ZEILEN_AUSWAHL = {
|
||||
id: true,
|
||||
anzeigename: true,
|
||||
vorname: true,
|
||||
nachname: true,
|
||||
mail: true,
|
||||
upn: true,
|
||||
sam: true,
|
||||
abteilung: true,
|
||||
titel: true,
|
||||
aktiv: true,
|
||||
herkunft: true,
|
||||
kundeId: true,
|
||||
kunde: { select: { name: true } },
|
||||
_count: { select: { geraete: true, laeufe: true } },
|
||||
} satisfies Prisma.MitarbeiterSelect;
|
||||
|
||||
type Rohzeile = Prisma.MitarbeiterGetPayload<{ select: typeof ZEILEN_AUSWAHL }>;
|
||||
|
||||
function zeileBauen(zeile: Rohzeile): MitarbeiterZeile {
|
||||
return {
|
||||
id: zeile.id,
|
||||
anzeigename: zeile.anzeigename,
|
||||
vorname: zeile.vorname,
|
||||
nachname: zeile.nachname,
|
||||
mail: zeile.mail,
|
||||
upn: zeile.upn,
|
||||
sam: zeile.sam,
|
||||
abteilung: zeile.abteilung,
|
||||
titel: zeile.titel,
|
||||
aktiv: zeile.aktiv,
|
||||
herkunft: zeile.herkunft,
|
||||
kundeId: zeile.kundeId,
|
||||
/*
|
||||
* Immer der Name, auch bei der eigenen Organisation. Ob er **gezeigt** wird,
|
||||
* entscheidet der Betriebsmodus — und das entscheidet die Seite mit
|
||||
* `kundenEbeneSichtbar()`, nicht das Lesemodell. Vorher haengte es hier an
|
||||
* `istEigeneOrganisation`, und im Modus Dienstleistung fehlte die Pille
|
||||
* ausgerechnet bei einem Kunden: „keine Pille“ hiess dann nicht „kein
|
||||
* Kunde“, sondern „ausgerechnet dieser eine“.
|
||||
*/
|
||||
kundeName: zeile.kunde.name,
|
||||
anzahlGeraete: zeile._count.geraete,
|
||||
anzahlLaeufe: zeile._count.laeufe,
|
||||
};
|
||||
}
|
||||
|
||||
export async function mitarbeiterListe(
|
||||
benutzer: HandelnderBenutzer,
|
||||
filter: MitarbeiterFilter = {},
|
||||
): Promise<readonly MitarbeiterZeile[]> {
|
||||
const suche = filter.suche?.trim();
|
||||
|
||||
const bedingungen = [
|
||||
...(await kundenBedingung(benutzer)),
|
||||
filter.auchDeaktivierte ? undefined : { aktiv: true },
|
||||
filter.abteilung ? { abteilung: filter.abteilung } : undefined,
|
||||
// Gesucht wird ueber die vier Felder, unter denen eine Person im Haus
|
||||
// bekannt ist. Der Anzeigename allein reicht nicht: im Ticket steht oft nur
|
||||
// die Mail-Adresse oder der sAMAccountName.
|
||||
suche
|
||||
? {
|
||||
OR: [
|
||||
{ anzeigename: { contains: suche, mode: "insensitive" as const } },
|
||||
{ mail: { contains: suche, mode: "insensitive" as const } },
|
||||
{ upn: { contains: suche, mode: "insensitive" as const } },
|
||||
{ sam: { contains: suche, mode: "insensitive" as const } },
|
||||
],
|
||||
}
|
||||
: undefined,
|
||||
].filter((bedingung) => bedingung !== undefined);
|
||||
|
||||
const zeilen = await prisma.mitarbeiter.findMany({
|
||||
where: { AND: bedingungen },
|
||||
orderBy: [{ aktiv: "desc" }, { nachname: "asc" }, { vorname: "asc" }],
|
||||
select: ZEILEN_AUSWAHL,
|
||||
});
|
||||
return zeilen.map(zeileBauen);
|
||||
}
|
||||
|
||||
/** `undefined` heisst „gibt es nicht oder darfst du nicht sehen“. */
|
||||
export async function mitarbeiterHolen(
|
||||
mitarbeiterId: string,
|
||||
benutzer: HandelnderBenutzer,
|
||||
): Promise<MitarbeiterZeile | undefined> {
|
||||
const zeile = await prisma.mitarbeiter.findFirst({
|
||||
where: { AND: [{ id: mitarbeiterId }, ...(await kundenBedingung(benutzer))] },
|
||||
select: ZEILEN_AUSWAHL,
|
||||
});
|
||||
return zeile ? zeileBauen(zeile) : undefined;
|
||||
}
|
||||
|
||||
export type MitarbeiterGeraet = {
|
||||
readonly id: string;
|
||||
readonly tagCode: string;
|
||||
readonly name: string;
|
||||
readonly typ: string;
|
||||
readonly archiviert: boolean;
|
||||
};
|
||||
|
||||
/** Die Geraete einer Person – fuer die Mitarbeiterseite. */
|
||||
export async function geraeteDesMitarbeiters(
|
||||
mitarbeiterId: string,
|
||||
benutzer: HandelnderBenutzer,
|
||||
): Promise<readonly MitarbeiterGeraet[]> {
|
||||
const zeilen = await prisma.geraet.findMany({
|
||||
where: { AND: [{ mitarbeiterId }, ...(await kundenBedingung(benutzer))] },
|
||||
orderBy: [{ archiviert: "asc" }, { hostname: "asc" }],
|
||||
select: { id: true, tagCode: true, hostname: true, bezeichnung: true, typ: true, archiviert: true },
|
||||
});
|
||||
return zeilen.map((zeile) => ({
|
||||
id: zeile.id,
|
||||
tagCode: zeile.tagCode,
|
||||
// Hostname zuerst: danach sucht man. Ohne Hostname traegt die Bezeichnung.
|
||||
name: zeile.hostname ?? zeile.bezeichnung ?? zeile.tagCode,
|
||||
typ: zeile.typ,
|
||||
archiviert: zeile.archiviert,
|
||||
}));
|
||||
}
|
||||
|
||||
/**
|
||||
* Der Vorgesetzte einer Person – oder `undefined`.
|
||||
*
|
||||
* Die Verknuepfung laeuft ueber `vorgesetzterExterneId` und die `externeId`
|
||||
* **derselben Verzeichnisquelle**: die Kennung ist nur innerhalb einer Quelle
|
||||
* eindeutig, und ohne diese Einschraenkung zoege ein zweites Verzeichnis
|
||||
* fremde Treffer herbei. Gefuellt wird das Feld vom Abgleich (#016); bei einer
|
||||
* von Hand angelegten Person steht hier nichts, und das ist richtig so.
|
||||
*/
|
||||
export async function vorgesetzterVon(
|
||||
mitarbeiterId: string,
|
||||
benutzer: HandelnderBenutzer,
|
||||
): Promise<{ readonly id: string; readonly anzeigename: string } | undefined> {
|
||||
const person = await prisma.mitarbeiter.findFirst({
|
||||
where: { AND: [{ id: mitarbeiterId }, ...(await kundenBedingung(benutzer))] },
|
||||
select: { quelleId: true, vorgesetzterExterneId: true },
|
||||
});
|
||||
if (!person?.vorgesetzterExterneId || !person.quelleId) return undefined;
|
||||
|
||||
const vorgesetzter = await prisma.mitarbeiter.findFirst({
|
||||
where: {
|
||||
AND: [
|
||||
{ quelleId: person.quelleId, externeId: person.vorgesetzterExterneId },
|
||||
...(await kundenBedingung(benutzer)),
|
||||
],
|
||||
},
|
||||
select: { id: true, anzeigename: true },
|
||||
});
|
||||
return vorgesetzter ?? undefined;
|
||||
}
|
||||
|
||||
/** Die vorkommenden Abteilungsnamen – fuer den Filter. */
|
||||
export async function abteilungsNamen(benutzer: HandelnderBenutzer): Promise<readonly string[]> {
|
||||
const zeilen = await prisma.mitarbeiter.findMany({
|
||||
where: { AND: [{ abteilung: { not: null } }, ...(await kundenBedingung(benutzer))] },
|
||||
select: { abteilung: true },
|
||||
distinct: ["abteilung"],
|
||||
});
|
||||
return zeilen
|
||||
.map((zeile) => zeile.abteilung)
|
||||
.filter((name): name is string => name !== null)
|
||||
.sort((a, b) => a.localeCompare(b, "de"));
|
||||
}
|
||||
@@ -0,0 +1,214 @@
|
||||
import type { Abteilung, Prisma } from "@/generated/prisma/client";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { kundeErmitteln, kundeZugriffPruefen, type HandelnderBenutzer } from "@/server/mandant";
|
||||
|
||||
/**
|
||||
* Abteilungen (#011).
|
||||
*
|
||||
* Eine Abteilung ist mehr als eine Beschriftung: an ihr haengen die Ziel-OU und
|
||||
* die Standardgruppen, also genau das, was die spaeteren PowerShell-Befehle in
|
||||
* ein Verzeichnis schreiben (#012). Ein Tippfehler in der Ziel-OU legt ein Konto
|
||||
* an der falschen Stelle an — deshalb gehoert das Pflegen zu `verwaltung` und
|
||||
* nicht zur taeglichen Technikerarbeit.
|
||||
*
|
||||
* Der Name ist **je Kunde** eindeutig (`@@unique([kundeId, name])`); im Modus
|
||||
* INTERN ist das die eine eigene Organisation.
|
||||
*/
|
||||
|
||||
export class AbteilungsFehler extends Error {
|
||||
constructor(nachricht: string) {
|
||||
super(nachricht);
|
||||
this.name = "AbteilungsFehler";
|
||||
}
|
||||
}
|
||||
|
||||
export type AbteilungsEingabe = {
|
||||
readonly name: string;
|
||||
readonly zielOu?: string | null;
|
||||
readonly standardGruppen?: readonly string[];
|
||||
readonly mailDomain?: string | null;
|
||||
readonly notizen?: string | null;
|
||||
readonly kundeId?: string | null;
|
||||
};
|
||||
|
||||
function leerAlsNull(wert: string | null | undefined): string | null {
|
||||
const sauber = wert?.trim();
|
||||
return sauber ? sauber : null;
|
||||
}
|
||||
|
||||
function namePruefen(roh: string): string {
|
||||
const name = roh.trim();
|
||||
if (!name) throw new AbteilungsFehler("Eine Abteilung braucht einen Namen.");
|
||||
return name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Eine Mail-Domain ist keine Adresse.
|
||||
*
|
||||
* Geprueft wird nur grob: kein `@`, mindestens ein Punkt. Strenger waere eine
|
||||
* Zusage, die wir nicht halten koennen — gueltige Domains gibt es in mehr Formen,
|
||||
* als ein Ausdruck sinnvoll abbildet.
|
||||
*/
|
||||
function mailDomainPruefen(wert: string | null): string | null {
|
||||
if (wert === null) return null;
|
||||
const domain = wert.replace(/^@/u, "");
|
||||
if (domain.includes("@") || !domain.includes(".")) {
|
||||
throw new AbteilungsFehler(
|
||||
`„${wert}“ sieht nicht wie eine Mail-Domain aus. Erwartet wird etwa „firma.de“, keine Adresse.`,
|
||||
);
|
||||
}
|
||||
return domain.toLowerCase();
|
||||
}
|
||||
|
||||
/** Leere Einträge und Doppelungen raus, Reihenfolge bleibt. */
|
||||
function gruppenSaeubern(gruppen: readonly string[] | undefined): string[] {
|
||||
const gesehen = new Set<string>();
|
||||
const sauber: string[] = [];
|
||||
for (const gruppe of gruppen ?? []) {
|
||||
const wert = gruppe.trim();
|
||||
if (!wert || gesehen.has(wert)) continue;
|
||||
gesehen.add(wert);
|
||||
sauber.push(wert);
|
||||
}
|
||||
return sauber;
|
||||
}
|
||||
|
||||
export async function abteilungAnlegen(
|
||||
eingabe: AbteilungsEingabe,
|
||||
benutzer: HandelnderBenutzer,
|
||||
): Promise<Abteilung> {
|
||||
const name = namePruefen(eingabe.name);
|
||||
const kundeId = await kundeErmitteln(eingabe.kundeId, benutzer);
|
||||
|
||||
const vorhanden = await prisma.abteilung.findUnique({ where: { kundeId_name: { kundeId, name } } });
|
||||
if (vorhanden) {
|
||||
// Die Datenbank wuerde es ohnehin abweisen; hier steht der Satz, den ein
|
||||
// Mensch lesen kann.
|
||||
throw new AbteilungsFehler(`Die Abteilung „${name}“ gibt es schon.`);
|
||||
}
|
||||
|
||||
return prisma.$transaction(async (tx) => {
|
||||
const abteilung = await tx.abteilung.create({
|
||||
data: {
|
||||
kundeId,
|
||||
name,
|
||||
zielOu: leerAlsNull(eingabe.zielOu),
|
||||
standardGruppen: gruppenSaeubern(eingabe.standardGruppen),
|
||||
mailDomain: mailDomainPruefen(leerAlsNull(eingabe.mailDomain)),
|
||||
notizen: leerAlsNull(eingabe.notizen),
|
||||
},
|
||||
});
|
||||
await tx.protokoll.create({
|
||||
data: {
|
||||
entitaet: "Abteilung",
|
||||
entitaetId: abteilung.id,
|
||||
aktion: "Abteilung angelegt",
|
||||
benutzerId: benutzer.id,
|
||||
nachher: { name: abteilung.name, zielOu: abteilung.zielOu },
|
||||
},
|
||||
});
|
||||
return abteilung;
|
||||
});
|
||||
}
|
||||
|
||||
export async function abteilungBearbeiten(
|
||||
abteilungId: string,
|
||||
aenderung: Partial<AbteilungsEingabe>,
|
||||
benutzer: HandelnderBenutzer,
|
||||
): Promise<Abteilung> {
|
||||
const vorher = await prisma.abteilung.findUnique({ where: { id: abteilungId } });
|
||||
if (!vorher) throw new AbteilungsFehler("Diese Abteilung gibt es nicht (mehr).");
|
||||
await kundeZugriffPruefen(vorher.kundeId, benutzer);
|
||||
|
||||
const daten: Prisma.AbteilungUpdateInput = {};
|
||||
const geaendert: string[] = [];
|
||||
|
||||
if (aenderung.name !== undefined) {
|
||||
const name = namePruefen(aenderung.name);
|
||||
if (name !== vorher.name) {
|
||||
const andere = await prisma.abteilung.findUnique({
|
||||
where: { kundeId_name: { kundeId: vorher.kundeId, name } },
|
||||
});
|
||||
if (andere) throw new AbteilungsFehler(`Die Abteilung „${name}“ gibt es schon.`);
|
||||
daten.name = name;
|
||||
geaendert.push("Name");
|
||||
}
|
||||
}
|
||||
if (aenderung.zielOu !== undefined) {
|
||||
const zielOu = leerAlsNull(aenderung.zielOu);
|
||||
if (zielOu !== vorher.zielOu) {
|
||||
daten.zielOu = zielOu;
|
||||
geaendert.push("Ziel-OU");
|
||||
}
|
||||
}
|
||||
if (aenderung.mailDomain !== undefined) {
|
||||
const mailDomain = mailDomainPruefen(leerAlsNull(aenderung.mailDomain));
|
||||
if (mailDomain !== vorher.mailDomain) {
|
||||
daten.mailDomain = mailDomain;
|
||||
geaendert.push("Mail-Domain");
|
||||
}
|
||||
}
|
||||
if (aenderung.notizen !== undefined) {
|
||||
const notizen = leerAlsNull(aenderung.notizen);
|
||||
if (notizen !== vorher.notizen) {
|
||||
daten.notizen = notizen;
|
||||
geaendert.push("Notizen");
|
||||
}
|
||||
}
|
||||
if (aenderung.standardGruppen !== undefined) {
|
||||
const gruppen = gruppenSaeubern(aenderung.standardGruppen);
|
||||
if (gruppen.join("\u0000") !== vorher.standardGruppen.join("\u0000")) {
|
||||
daten.standardGruppen = gruppen;
|
||||
geaendert.push("Standardgruppen");
|
||||
}
|
||||
}
|
||||
|
||||
if (geaendert.length === 0) return vorher;
|
||||
|
||||
return prisma.$transaction(async (tx) => {
|
||||
const nachher = await tx.abteilung.update({ where: { id: abteilungId }, data: daten });
|
||||
await tx.protokoll.create({
|
||||
data: {
|
||||
entitaet: "Abteilung",
|
||||
entitaetId: abteilungId,
|
||||
aktion: `${geaendert.join(" und ")} geändert`,
|
||||
benutzerId: benutzer.id,
|
||||
vorher: { name: vorher.name, zielOu: vorher.zielOu, standardGruppen: vorher.standardGruppen },
|
||||
nachher: { name: nachher.name, zielOu: nachher.zielOu, standardGruppen: nachher.standardGruppen },
|
||||
},
|
||||
});
|
||||
return nachher;
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Archivieren statt loeschen.
|
||||
*
|
||||
* An einer Abteilung haengen Laeufe, und ein archivierter Lauf muss auch in zehn
|
||||
* Jahren noch sagen koennen, fuer welche Abteilung er lief. Der Fremdschluessel
|
||||
* steht deshalb auf `Restrict`, und es gibt hier keinen Loeschweg.
|
||||
*/
|
||||
export async function abteilungArchivieren(
|
||||
abteilungId: string,
|
||||
archiviert: boolean,
|
||||
benutzer: HandelnderBenutzer,
|
||||
): Promise<Abteilung> {
|
||||
const vorher = await prisma.abteilung.findUnique({ where: { id: abteilungId } });
|
||||
if (!vorher) throw new AbteilungsFehler("Diese Abteilung gibt es nicht (mehr).");
|
||||
await kundeZugriffPruefen(vorher.kundeId, benutzer);
|
||||
if (vorher.archiviert === archiviert) return vorher;
|
||||
|
||||
return prisma.$transaction(async (tx) => {
|
||||
const nachher = await tx.abteilung.update({ where: { id: abteilungId }, data: { archiviert } });
|
||||
await tx.protokoll.create({
|
||||
data: {
|
||||
entitaet: "Abteilung",
|
||||
entitaetId: abteilungId,
|
||||
aktion: archiviert ? "Abteilung archiviert" : "Abteilung wieder freigegeben",
|
||||
benutzerId: benutzer.id,
|
||||
nachher: { archiviert },
|
||||
},
|
||||
});
|
||||
return nachher;
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,640 @@
|
||||
import { Prisma, type Geraet } from "@/generated/prisma/client";
|
||||
import { GeraeteTyp } from "@/generated/prisma/enums";
|
||||
import { CsvFehler, csvZerlegen, hatSpalte, wertAus, type CsvZeile } from "@/lib/csv";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { tagCodeEindeutigErzeugen } from "@/lib/tagcode";
|
||||
import { kundeErmitteln, kundeZugriffPruefen, type HandelnderBenutzer } from "@/server/mandant";
|
||||
|
||||
/**
|
||||
* Geraete und ihre Stammdaten (#011).
|
||||
*
|
||||
* Ein Geraet ist nicht nur ein PC: ein Serverschrank, ein Raum oder eine
|
||||
* Firewall bekommen genauso einen Aufkleber. Drei Regeln tragen das Ganze:
|
||||
*
|
||||
* 1. Der `tagCode` wird beim Anlegen erzeugt, nie geaendert und nie
|
||||
* wiederverwendet. Er landet zusaetzlich in `TagCodeVergabe`, damit er auch
|
||||
* nach dem Loeschen des Geraets vergeben bleibt.
|
||||
* 2. Ein **registriertes** Geraet braucht einen Hostname oder eine
|
||||
* Bezeichnung. Ein vorgedruckter, noch nicht zugeordneter Tag
|
||||
* (`registriertAm = null`) darf beides leer haben.
|
||||
* 3. Geloescht wird nur, solange kein Lauf am Geraet haengt. Sonst archiviert.
|
||||
*
|
||||
* Alle drei stehen zusaetzlich in der Datenbank (CHECK `Geraet_tagcode_form`,
|
||||
* CHECK `Geraet_registriert_braucht_namen`, Fremdschluessel auf `Restrict`).
|
||||
* Hier stehen sie fuer die verstaendliche Meldung.
|
||||
*/
|
||||
|
||||
export class GeraeteFehler extends Error {
|
||||
constructor(nachricht: string) {
|
||||
super(nachricht);
|
||||
this.name = "GeraeteFehler";
|
||||
}
|
||||
}
|
||||
|
||||
export type NeuesGeraet = {
|
||||
readonly hostname?: string | null;
|
||||
readonly bezeichnung?: string | null;
|
||||
readonly seriennummer?: string | null;
|
||||
readonly inventarnummer?: string | null;
|
||||
readonly typ?: GeraeteTyp;
|
||||
readonly modell?: string | null;
|
||||
readonly notizen?: string | null;
|
||||
/** Besitzer bzw. Hauptnutzer. Server, Raeume und Poolgeraete haben keinen. */
|
||||
readonly mitarbeiterId?: string | null;
|
||||
/** Nur im Modus DIENSTLEISTUNG beachtet; im Modus INTERN verworfen (#008). */
|
||||
readonly kundeId?: string | null;
|
||||
/**
|
||||
* `false` legt einen vorgedruckten Tag ohne Zuordnung an – dann sind Hostname
|
||||
* und Bezeichnung erlaubt leer. Standard ist `true`, weil jedes von Hand oder
|
||||
* per CSV angelegte Geraet ein echtes Objekt beschreibt.
|
||||
*/
|
||||
readonly registrieren?: boolean;
|
||||
};
|
||||
|
||||
export type GeraeteAenderung = {
|
||||
readonly hostname?: string | null;
|
||||
readonly bezeichnung?: string | null;
|
||||
readonly seriennummer?: string | null;
|
||||
readonly inventarnummer?: string | null;
|
||||
readonly typ?: GeraeteTyp;
|
||||
readonly modell?: string | null;
|
||||
readonly notizen?: string | null;
|
||||
readonly mitarbeiterId?: string | null;
|
||||
/**
|
||||
* Nimmt einen mitgeschickten `tagCode` nur an, um ihn abzuweisen, wenn er
|
||||
* abweicht. Ohne dieses Feld liefe ein Aenderungsversuch ins Leere und saehe
|
||||
* fuer den Aufrufer wie ein Erfolg aus.
|
||||
*/
|
||||
readonly tagCode?: string;
|
||||
/** Macht aus einem vorgedruckten Tag ein registriertes Geraet. */
|
||||
readonly registrieren?: boolean;
|
||||
};
|
||||
|
||||
/** Leer und „nur Leerraum“ sind dasselbe wie „nicht gesetzt“. */
|
||||
function text(wert: string | null | undefined): string | null {
|
||||
return wert?.trim() || null;
|
||||
}
|
||||
|
||||
/** Wie das Geraet in einer Meldung heisst. Der tagCode ist immer da. */
|
||||
function geraetName(geraet: {
|
||||
readonly hostname: string | null;
|
||||
readonly bezeichnung: string | null;
|
||||
readonly tagCode: string;
|
||||
}): string {
|
||||
return geraet.hostname ?? geraet.bezeichnung ?? geraet.tagCode;
|
||||
}
|
||||
|
||||
/**
|
||||
* Die Pflichtregel aus dem Auftrag, an einer Stelle.
|
||||
*
|
||||
* Geprueft wird der **Zustand danach**, nicht die Eingabe: wer den Hostname
|
||||
* leert, ohne eine Bezeichnung zu setzen, faellt genauso hierauf wie wer ohne
|
||||
* beides anlegt.
|
||||
*/
|
||||
function namenPflichtPruefen(
|
||||
hostname: string | null,
|
||||
bezeichnung: string | null,
|
||||
registriert: boolean,
|
||||
): void {
|
||||
if (registriert && !hostname && !bezeichnung) {
|
||||
throw new GeraeteFehler(
|
||||
"Ein registriertes Gerät braucht einen Hostname oder eine Bezeichnung — " +
|
||||
"sonst steht es in jeder Liste nur als Aufkleber.",
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Der Besitzer muss zum selben Kunden gehoeren.
|
||||
*
|
||||
* Die Datenbank erzwingt das ueber den zusammengesetzten Fremdschluessel
|
||||
* `Geraet_besitzer_gleicher_kunde`. Hier steht es fuer die Meldung — „Foreign key
|
||||
* constraint violated“ hilft niemandem.
|
||||
*
|
||||
* Ein **deaktivierter** Mitarbeiter wird bewusst nicht abgewiesen: beim
|
||||
* Offboarding bleibt das Notebook der Person zugeordnet, bis es zurueck ist.
|
||||
*/
|
||||
async function besitzerPruefen(mitarbeiterId: string, kundeId: string): Promise<void> {
|
||||
const person = await prisma.mitarbeiter.findUnique({
|
||||
where: { id: mitarbeiterId },
|
||||
select: { id: true, kundeId: true, anzeigename: true },
|
||||
});
|
||||
if (!person) throw new GeraeteFehler("Diese Person gibt es nicht.");
|
||||
if (person.kundeId !== kundeId) {
|
||||
throw new GeraeteFehler(
|
||||
`„${person.anzeigename}“ gehört zu einem anderen Kunden und kann dieses Gerät nicht besitzen.`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Zieht einen noch freien `tagCode`.
|
||||
*
|
||||
* Gefragt wird in beiden Buechern: `TagCodeVergabe` ist das Verzeichnis aller je
|
||||
* vergebenen Codes, `Geraet.tagCode` der eindeutige Index, der im Zweifel
|
||||
* entscheidet. Ein Code, der nur in einem von beiden steht, ist trotzdem
|
||||
* vergeben.
|
||||
*/
|
||||
async function freienTagCodeZiehen(): Promise<string> {
|
||||
return tagCodeEindeutigErzeugen(async (code) => {
|
||||
const [vergabe, geraet] = await Promise.all([
|
||||
prisma.tagCodeVergabe.findUnique({ where: { tagCode: code }, select: { tagCode: true } }),
|
||||
prisma.geraet.findUnique({ where: { tagCode: code }, select: { id: true } }),
|
||||
]);
|
||||
return vergabe !== null || geraet !== null;
|
||||
});
|
||||
}
|
||||
|
||||
type SchreibAuftrag = {
|
||||
readonly eingabe: NeuesGeraet;
|
||||
readonly kundeId: string;
|
||||
readonly durchBenutzerId: string;
|
||||
readonly aktion: string;
|
||||
/** Kommt in `Protokoll.nachher` mit – beim Import die Zeilennummer. */
|
||||
readonly zusatz?: Readonly<Record<string, string | number>>;
|
||||
};
|
||||
|
||||
/**
|
||||
* Das Anlegen selbst, ohne Mandantenermittlung.
|
||||
*
|
||||
* Getrennt, weil der CSV-Import den Kunden **einmal** ermittelt und dann Zeile
|
||||
* fuer Zeile schreibt. Zweimal denselben Weg zu bauen waere der sichere Weg,
|
||||
* dass eine Regel nur in einem von beiden landet.
|
||||
*/
|
||||
async function geraetSchreiben(auftrag: SchreibAuftrag): Promise<Geraet> {
|
||||
const { eingabe, kundeId, durchBenutzerId } = auftrag;
|
||||
const registriert = eingabe.registrieren ?? true;
|
||||
const hostname = text(eingabe.hostname);
|
||||
const bezeichnung = text(eingabe.bezeichnung);
|
||||
namenPflichtPruefen(hostname, bezeichnung, registriert);
|
||||
|
||||
const mitarbeiterId = text(eingabe.mitarbeiterId);
|
||||
if (mitarbeiterId) await besitzerPruefen(mitarbeiterId, kundeId);
|
||||
|
||||
const tagCode = await freienTagCodeZiehen();
|
||||
|
||||
try {
|
||||
return await prisma.$transaction(async (tx) => {
|
||||
// Beides in einer Transaktion: ein Geraet mit einem Code, der nicht im
|
||||
// Vergabebuch steht, waere nach dem Loeschen des Geraets wieder frei – und
|
||||
// ein alter Aufkleber im Regal zeigte auf ein fremdes Objekt.
|
||||
await tx.tagCodeVergabe.create({ data: { tagCode } });
|
||||
const geraet = await tx.geraet.create({
|
||||
data: {
|
||||
kundeId,
|
||||
tagCode,
|
||||
hostname,
|
||||
bezeichnung,
|
||||
seriennummer: text(eingabe.seriennummer),
|
||||
inventarnummer: text(eingabe.inventarnummer),
|
||||
typ: eingabe.typ ?? GeraeteTyp.SONSTIGES,
|
||||
modell: text(eingabe.modell),
|
||||
notizen: text(eingabe.notizen),
|
||||
mitarbeiterId,
|
||||
registriertAm: registriert ? new Date() : null,
|
||||
},
|
||||
});
|
||||
await tx.protokoll.create({
|
||||
data: {
|
||||
entitaet: "Geraet",
|
||||
entitaetId: geraet.id,
|
||||
aktion: auftrag.aktion,
|
||||
benutzerId: durchBenutzerId,
|
||||
nachher: {
|
||||
tagCode: geraet.tagCode,
|
||||
hostname: geraet.hostname,
|
||||
bezeichnung: geraet.bezeichnung,
|
||||
typ: geraet.typ,
|
||||
...(auftrag.zusatz ?? {}),
|
||||
},
|
||||
},
|
||||
});
|
||||
return geraet;
|
||||
});
|
||||
} catch (fehler) {
|
||||
// Zwei Anfragen haben in derselben Sekunde denselben Code gezogen. Bei 32^6
|
||||
// Moeglichkeiten praktisch unmoeglich, aber wenn doch, dann lieber mit einer
|
||||
// Meldung, die zum Wiederholen auffordert, als mit dem rohen Indexfehler.
|
||||
if (fehler instanceof Prisma.PrismaClientKnownRequestError && fehler.code === "P2002") {
|
||||
throw new GeraeteFehler("Der erzeugte Tag-Code war schon vergeben. Bitte noch einmal versuchen.");
|
||||
}
|
||||
throw fehler;
|
||||
}
|
||||
}
|
||||
|
||||
/** Legt ein Geraet an und erzeugt seinen `tagCode`. */
|
||||
export async function geraetAnlegen(eingabe: NeuesGeraet, benutzer: HandelnderBenutzer): Promise<Geraet> {
|
||||
const kundeId = await kundeErmitteln(eingabe.kundeId, benutzer);
|
||||
return geraetSchreiben({
|
||||
eingabe,
|
||||
kundeId,
|
||||
durchBenutzerId: benutzer.id,
|
||||
aktion: "Gerät angelegt",
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Aendert die Stammdaten eines Geraets.
|
||||
*
|
||||
* Der Kunde bleibt, wie er ist: ein Geraet zu einem anderen Kunden zu schieben
|
||||
* wuerde die Laeufe, die daran haengen, mandantenfremd machen. Wer sich vertan
|
||||
* hat, legt das Geraet beim richtigen Kunden neu an — der alte Tag-Code bleibt
|
||||
* dann vergeben, und genau das ist richtig.
|
||||
*/
|
||||
export async function geraetBearbeiten(
|
||||
geraetId: string,
|
||||
aenderung: GeraeteAenderung,
|
||||
benutzer: HandelnderBenutzer,
|
||||
): Promise<Geraet> {
|
||||
const vorher = await prisma.geraet.findUnique({ where: { id: geraetId } });
|
||||
if (!vorher) throw new GeraeteFehler("Dieses Gerät gibt es nicht.");
|
||||
await kundeZugriffPruefen(vorher.kundeId, benutzer);
|
||||
|
||||
if (aenderung.tagCode !== undefined && aenderung.tagCode.trim() !== vorher.tagCode) {
|
||||
throw new GeraeteFehler(
|
||||
`Der Tag-Code ${vorher.tagCode} bleibt, wie er ist. Er steht auf einem Aufkleber, ` +
|
||||
"der schon am Gerät klebt — und wird nie geändert und nie neu vergeben.",
|
||||
);
|
||||
}
|
||||
|
||||
const daten: Prisma.GeraetUpdateInput = {};
|
||||
const geaendert: string[] = [];
|
||||
|
||||
const felder = [
|
||||
["hostname", "Hostname", aenderung.hostname],
|
||||
["bezeichnung", "Bezeichnung", aenderung.bezeichnung],
|
||||
["seriennummer", "Seriennummer", aenderung.seriennummer],
|
||||
["inventarnummer", "Inventarnummer", aenderung.inventarnummer],
|
||||
["modell", "Modell", aenderung.modell],
|
||||
["notizen", "Notizen", aenderung.notizen],
|
||||
] as const;
|
||||
|
||||
for (const [feld, beschriftung, roh] of felder) {
|
||||
if (roh === undefined) continue;
|
||||
const wert = text(roh);
|
||||
if (wert !== vorher[feld]) {
|
||||
daten[feld] = wert;
|
||||
geaendert.push(beschriftung);
|
||||
}
|
||||
}
|
||||
|
||||
if (aenderung.typ !== undefined && aenderung.typ !== vorher.typ) {
|
||||
daten.typ = aenderung.typ;
|
||||
geaendert.push("Typ");
|
||||
}
|
||||
|
||||
if (aenderung.mitarbeiterId !== undefined) {
|
||||
const wert = text(aenderung.mitarbeiterId);
|
||||
if (wert !== vorher.mitarbeiterId) {
|
||||
if (wert) await besitzerPruefen(wert, vorher.kundeId);
|
||||
daten.mitarbeiter = wert ? { connect: { id: wert } } : { disconnect: true };
|
||||
geaendert.push("Besitzer");
|
||||
}
|
||||
}
|
||||
|
||||
// Registrieren geht nur in eine Richtung: ein Geraet, das einmal gescannt und
|
||||
// benannt wurde, wieder zum leeren Aufkleber zu machen, hiesse seine Geschichte
|
||||
// zu verlieren.
|
||||
const registriertNachher = vorher.registriertAm !== null || aenderung.registrieren === true;
|
||||
if (aenderung.registrieren === true && vorher.registriertAm === null) {
|
||||
daten.registriertAm = new Date();
|
||||
geaendert.push("Registrierung");
|
||||
}
|
||||
|
||||
namenPflichtPruefen(
|
||||
aenderung.hostname === undefined ? vorher.hostname : text(aenderung.hostname),
|
||||
aenderung.bezeichnung === undefined ? vorher.bezeichnung : text(aenderung.bezeichnung),
|
||||
registriertNachher,
|
||||
);
|
||||
|
||||
if (geaendert.length === 0) return vorher;
|
||||
|
||||
return prisma.$transaction(async (tx) => {
|
||||
const nachher = await tx.geraet.update({ where: { id: geraetId }, data: daten });
|
||||
await tx.protokoll.create({
|
||||
data: {
|
||||
entitaet: "Geraet",
|
||||
entitaetId: geraetId,
|
||||
aktion: `${geaendert.join(" und ")} geändert`,
|
||||
benutzerId: benutzer.id,
|
||||
// Nur das, was sich geaendert hat – ein Protokoll, das jedes Mal alle
|
||||
// Felder wiederholt, liest niemand mehr.
|
||||
vorher: protokollAuszug(vorher, geaendert),
|
||||
nachher: protokollAuszug(nachher, geaendert),
|
||||
},
|
||||
});
|
||||
return nachher;
|
||||
});
|
||||
}
|
||||
|
||||
/** Die Felder zu den genannten Beschriftungen – fuer `Protokoll.vorher`/`nachher`. */
|
||||
function protokollAuszug(geraet: Geraet, geaendert: readonly string[]): Prisma.InputJsonValue {
|
||||
const auszug: Record<string, string | null> = { tagCode: geraet.tagCode };
|
||||
const abbildung: Readonly<Record<string, string | null>> = {
|
||||
Hostname: geraet.hostname,
|
||||
Bezeichnung: geraet.bezeichnung,
|
||||
Seriennummer: geraet.seriennummer,
|
||||
Inventarnummer: geraet.inventarnummer,
|
||||
Modell: geraet.modell,
|
||||
Notizen: geraet.notizen,
|
||||
Typ: geraet.typ,
|
||||
Besitzer: geraet.mitarbeiterId,
|
||||
Registrierung: geraet.registriertAm?.toISOString() ?? null,
|
||||
};
|
||||
for (const beschriftung of geaendert) {
|
||||
if (beschriftung in abbildung) auszug[beschriftung] = abbildung[beschriftung] ?? null;
|
||||
}
|
||||
return auszug;
|
||||
}
|
||||
|
||||
/**
|
||||
* Archivieren statt Loeschen.
|
||||
*
|
||||
* Ein archiviertes Geraet erscheint nicht mehr in der Auswahl, seine Laeufe aber
|
||||
* weiter im Archiv. Der `tagCode` bleibt vergeben.
|
||||
*/
|
||||
export async function geraetArchivieren(
|
||||
geraetId: string,
|
||||
archiviert: boolean,
|
||||
benutzer: HandelnderBenutzer,
|
||||
): Promise<void> {
|
||||
const geraet = await prisma.geraet.findUnique({
|
||||
where: { id: geraetId },
|
||||
select: { id: true, kundeId: true, archiviert: true, hostname: true, bezeichnung: true, tagCode: true },
|
||||
});
|
||||
if (!geraet) throw new GeraeteFehler("Dieses Gerät gibt es nicht.");
|
||||
await kundeZugriffPruefen(geraet.kundeId, benutzer);
|
||||
if (geraet.archiviert === archiviert) return;
|
||||
|
||||
await prisma.$transaction(async (tx) => {
|
||||
await tx.geraet.update({ where: { id: geraetId }, data: { archiviert } });
|
||||
await tx.protokoll.create({
|
||||
data: {
|
||||
entitaet: "Geraet",
|
||||
entitaetId: geraetId,
|
||||
aktion: archiviert ? "Gerät archiviert" : "Gerät wieder freigegeben",
|
||||
benutzerId: benutzer.id,
|
||||
vorher: { archiviert: geraet.archiviert },
|
||||
nachher: { archiviert, tagCode: geraet.tagCode },
|
||||
},
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Loescht ein Geraet – nur, solange kein Lauf daran haengt.
|
||||
*
|
||||
* Der `tagCode` bleibt in `TagCodeVergabe` stehen und wird nie wieder vergeben.
|
||||
* Das ist der Zweck dieses Buches: ohne es waere der Code nach dem Loeschen frei,
|
||||
* und ein uebrig gebliebener Aufkleber zeigte irgendwann auf ein fremdes Objekt.
|
||||
*/
|
||||
export async function geraetLoeschen(geraetId: string, benutzer: HandelnderBenutzer): Promise<void> {
|
||||
const geraet = await prisma.geraet.findUnique({
|
||||
where: { id: geraetId },
|
||||
select: {
|
||||
id: true,
|
||||
kundeId: true,
|
||||
tagCode: true,
|
||||
hostname: true,
|
||||
bezeichnung: true,
|
||||
typ: true,
|
||||
_count: { select: { laeufe: true } },
|
||||
},
|
||||
});
|
||||
if (!geraet) throw new GeraeteFehler("Dieses Gerät gibt es nicht.");
|
||||
await kundeZugriffPruefen(geraet.kundeId, benutzer);
|
||||
|
||||
if (geraet._count.laeufe > 0) {
|
||||
const anzahl = geraet._count.laeufe;
|
||||
throw new GeraeteFehler(
|
||||
`An „${geraetName(geraet)}“ ${anzahl === 1 ? "hängt ein Lauf" : `hängen ${anzahl} Läufe`}. ` +
|
||||
"Das Gerät lässt sich deshalb nur archivieren — ein Lauf muss für immer nachvollziehbar bleiben.",
|
||||
);
|
||||
}
|
||||
|
||||
try {
|
||||
await prisma.$transaction(async (tx) => {
|
||||
await tx.geraet.delete({ where: { id: geraetId } });
|
||||
await tx.protokoll.create({
|
||||
data: {
|
||||
entitaet: "Geraet",
|
||||
entitaetId: geraetId,
|
||||
aktion: "Gerät gelöscht",
|
||||
benutzerId: benutzer.id,
|
||||
vorher: {
|
||||
tagCode: geraet.tagCode,
|
||||
hostname: geraet.hostname,
|
||||
bezeichnung: geraet.bezeichnung,
|
||||
typ: geraet.typ,
|
||||
},
|
||||
},
|
||||
});
|
||||
});
|
||||
} catch (fehler) {
|
||||
// Zwischen Zaehlung und Loeschen kann ein Lauf entstanden sein; dann greift
|
||||
// der Fremdschluessel auf Restrict.
|
||||
if (
|
||||
fehler instanceof Prisma.PrismaClientKnownRequestError &&
|
||||
(fehler.code === "P2003" || fehler.code === "P2014")
|
||||
) {
|
||||
throw new GeraeteFehler(
|
||||
`An „${geraetName(geraet)}“ hängt inzwischen ein Lauf. Das Gerät lässt sich nur archivieren.`,
|
||||
);
|
||||
}
|
||||
throw fehler;
|
||||
}
|
||||
}
|
||||
|
||||
// ---- CSV-Import ------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Obergrenze je Datei.
|
||||
*
|
||||
* Ohne Grenze belegt eine versehentlich exportierte 50-MB-Tabelle die Datenbank
|
||||
* mit Zeilen, die niemand wollte, und der Import laeuft minutenlang. 500 ist
|
||||
* grosszuegig fuer einen Bestand, der von Hand gepflegt wird, und die Oberflaeche
|
||||
* nennt die Zahl, **bevor** jemand dagegen laeuft.
|
||||
*/
|
||||
export const GERAETE_IMPORT_HOECHSTZEILEN = 500;
|
||||
|
||||
/**
|
||||
* Die Spalten aus dem Auftrag – englisch, wie dort genannt – und jeweils die
|
||||
* deutsche Entsprechung. Gross- und Kleinschreibung, Leerraum, Unterstriche und
|
||||
* Bindestriche sind unerheblich, dafuer sorgt `spaltenName` in src/lib/csv.ts.
|
||||
*/
|
||||
export const GERAETE_IMPORT_SPALTEN = {
|
||||
hostname: ["hostname"],
|
||||
bezeichnung: ["label", "bezeichnung"],
|
||||
seriennummer: ["serialNumber", "seriennummer"],
|
||||
inventarnummer: ["inventoryNumber", "inventarnummer"],
|
||||
typ: ["type", "typ"],
|
||||
modell: ["model", "modell"],
|
||||
} as const;
|
||||
|
||||
/**
|
||||
* Woerter, die auf einen `GeraeteTyp` fuehren.
|
||||
*
|
||||
* Die Enum-Werte selbst kommen aus dem Enum, damit ein neuer Typ nicht in zwei
|
||||
* Listen eingetragen werden muss. Dazu die Woerter, die in echten Exporten
|
||||
* stehen — englisch und deutsch.
|
||||
*/
|
||||
const TYP_WOERTER: ReadonlyMap<string, GeraeteTyp> = new Map<string, GeraeteTyp>([
|
||||
...Object.values(GeraeteTyp).map((typ) => [typ.toLowerCase(), typ] as const),
|
||||
["laptop", GeraeteTyp.NOTEBOOK],
|
||||
["nb", GeraeteTyp.NOTEBOOK],
|
||||
["desktop", GeraeteTyp.PC],
|
||||
["workstation", GeraeteTyp.PC],
|
||||
["printer", GeraeteTyp.DRUCKER],
|
||||
["room", GeraeteTyp.RAUM],
|
||||
["other", GeraeteTyp.SONSTIGES],
|
||||
["sonstige", GeraeteTyp.SONSTIGES],
|
||||
]);
|
||||
|
||||
/** Die erlaubten Typen als Aufzaehlung – fuer die Fehlermeldung und die Oberflaeche. */
|
||||
export const GERAETE_TYPEN: readonly GeraeteTyp[] = Object.values(GeraeteTyp);
|
||||
|
||||
export type ImportAbweisung = {
|
||||
/** Zeilennummer in der Datei, wie sie ein Editor anzeigt. */
|
||||
readonly zeile: number;
|
||||
readonly grund: string;
|
||||
};
|
||||
|
||||
export type ImportErgebnis = {
|
||||
/** Datenzeilen in der Datei, ohne Kopfzeile und ohne Leerzeilen. */
|
||||
readonly gesamt: number;
|
||||
readonly angelegt: number;
|
||||
readonly abgewiesen: readonly ImportAbweisung[];
|
||||
};
|
||||
|
||||
/**
|
||||
* Liest einen Typ aus der Spalte `type`.
|
||||
*
|
||||
* Ein unbekannter Wert ist ein Zeilenfehler und **kein** stiller Standardwert:
|
||||
* „Tablet“ als SONSTIGES durchzuwinken heisst, den Bestand still falsch zu
|
||||
* fuellen. Eine leere Zelle ist etwas anderes — dort steht nichts, also gilt
|
||||
* SONSTIGES.
|
||||
*/
|
||||
function typLesen(roh: string): GeraeteTyp {
|
||||
if (!roh) return GeraeteTyp.SONSTIGES;
|
||||
const typ = TYP_WOERTER.get(roh.trim().toLowerCase());
|
||||
if (!typ) {
|
||||
throw new GeraeteFehler(
|
||||
`„${roh}“ ist kein bekannter Gerätetyp. Erlaubt sind: ${GERAETE_TYPEN.join(", ")}.`,
|
||||
);
|
||||
}
|
||||
return typ;
|
||||
}
|
||||
|
||||
/** Eine Zeile der Datei zu einer Geraeteeingabe. Wirft bei einem Zeilenfehler. */
|
||||
function zeileLesen(zeile: CsvZeile): NeuesGeraet {
|
||||
const hostname = wertAus(zeile, ...GERAETE_IMPORT_SPALTEN.hostname);
|
||||
const bezeichnung = wertAus(zeile, ...GERAETE_IMPORT_SPALTEN.bezeichnung);
|
||||
if (!hostname && !bezeichnung) {
|
||||
throw new GeraeteFehler("Weder ein Hostname noch eine Bezeichnung steht in dieser Zeile.");
|
||||
}
|
||||
return {
|
||||
hostname,
|
||||
bezeichnung,
|
||||
seriennummer: wertAus(zeile, ...GERAETE_IMPORT_SPALTEN.seriennummer),
|
||||
inventarnummer: wertAus(zeile, ...GERAETE_IMPORT_SPALTEN.inventarnummer),
|
||||
typ: typLesen(wertAus(zeile, ...GERAETE_IMPORT_SPALTEN.typ)),
|
||||
modell: wertAus(zeile, ...GERAETE_IMPORT_SPALTEN.modell),
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Spielt eine CSV-Datei mit Geraeten ein.
|
||||
*
|
||||
* **Je Zeile ein Ergebnis.** Eine fehlerhafte Zeile bricht den Import nicht ab;
|
||||
* sie wird mit Zeilennummer und Grund gemeldet, die uebrigen werden angelegt.
|
||||
* Deshalb hat jede Zeile ihre eigene Transaktion: eine gemeinsame haette am Ende
|
||||
* alles zurueckgerollt, was vor dem Fehler gelungen war.
|
||||
*
|
||||
* Der `tagCode` wird je Zeile erzeugt, genau wie beim Anlegen von Hand.
|
||||
*/
|
||||
export async function geraeteImportieren(
|
||||
csvText: string,
|
||||
benutzer: HandelnderBenutzer,
|
||||
kundeIdAusEingabe?: string | null,
|
||||
): Promise<ImportErgebnis> {
|
||||
const kundeId = await kundeErmitteln(kundeIdAusEingabe, benutzer);
|
||||
|
||||
let tabelle;
|
||||
try {
|
||||
tabelle = csvZerlegen(csvText, { hoechstZeilen: GERAETE_IMPORT_HOECHSTZEILEN });
|
||||
} catch (fehler) {
|
||||
if (fehler instanceof CsvFehler) throw new GeraeteFehler(fehler.message);
|
||||
throw fehler;
|
||||
}
|
||||
|
||||
// Ohne eine der Namensspalten koennte keine einzige Zeile gelingen. Das als
|
||||
// 500 gleichlautende Zeilenfehler zu melden waere richtig, aber nutzlos.
|
||||
const alleNamen = Object.values(GERAETE_IMPORT_SPALTEN).flat();
|
||||
if (!hatSpalte(tabelle, ...GERAETE_IMPORT_SPALTEN.hostname, ...GERAETE_IMPORT_SPALTEN.bezeichnung)) {
|
||||
throw new GeraeteFehler(
|
||||
"In der Kopfzeile fehlen „hostname“ und „label“ — eine davon muss es geben. " +
|
||||
`Gelesen wurden diese Spalten: ${alleNamen.join(", ")}.`,
|
||||
);
|
||||
}
|
||||
|
||||
const abgewiesen: ImportAbweisung[] = [];
|
||||
let angelegt = 0;
|
||||
|
||||
/*
|
||||
* Doppelte Hostnamen in derselben Datei faengt diese Menge ab. Dieselbe Datei
|
||||
* zweimal einzulesen verdoppelte sonst den Bestand — und weil ein tagCode nie
|
||||
* zurueckkommt, waeren die Aufkleber dafuer schon gedruckt.
|
||||
*/
|
||||
const gesehene = new Set<string>();
|
||||
|
||||
for (const zeile of tabelle.zeilen) {
|
||||
if (zeile.fehler !== undefined) {
|
||||
abgewiesen.push({ zeile: zeile.nummer, grund: zeile.fehler });
|
||||
continue;
|
||||
}
|
||||
try {
|
||||
const eingabe = zeileLesen(zeile);
|
||||
const hostname = eingabe.hostname?.trim().toLowerCase();
|
||||
if (hostname) {
|
||||
if (gesehene.has(hostname)) {
|
||||
abgewiesen.push({
|
||||
zeile: zeile.nummer,
|
||||
grund: `„${eingabe.hostname?.trim()}“ steht in dieser Datei schon weiter oben.`,
|
||||
});
|
||||
continue;
|
||||
}
|
||||
const schonDa = await prisma.geraet.findFirst({
|
||||
where: { kundeId, hostname: { equals: eingabe.hostname?.trim(), mode: "insensitive" } },
|
||||
select: { tagCode: true },
|
||||
});
|
||||
if (schonDa) {
|
||||
abgewiesen.push({
|
||||
zeile: zeile.nummer,
|
||||
grund: `„${eingabe.hostname?.trim()}“ gibt es schon — Tag-Code ${schonDa.tagCode}.`,
|
||||
});
|
||||
continue;
|
||||
}
|
||||
gesehene.add(hostname);
|
||||
}
|
||||
|
||||
await geraetSchreiben({
|
||||
eingabe,
|
||||
kundeId,
|
||||
durchBenutzerId: benutzer.id,
|
||||
aktion: "Gerät aus CSV angelegt",
|
||||
zusatz: { zeile: zeile.nummer },
|
||||
});
|
||||
angelegt += 1;
|
||||
} catch (fehler) {
|
||||
if (fehler instanceof GeraeteFehler) {
|
||||
abgewiesen.push({ zeile: zeile.nummer, grund: fehler.message });
|
||||
continue;
|
||||
}
|
||||
// Alles Uebrige – ein Verbindungsabbruch etwa – ist kein Zeilenproblem und
|
||||
// wuerde in den folgenden Zeilen genauso auftreten.
|
||||
throw fehler;
|
||||
}
|
||||
}
|
||||
|
||||
return { gesamt: tabelle.zeilen.length, angelegt, abgewiesen };
|
||||
}
|
||||
@@ -0,0 +1,252 @@
|
||||
import type { Mitarbeiter, Prisma } from "@/generated/prisma/client";
|
||||
import { Herkunft } from "@/generated/prisma/enums";
|
||||
import { prisma } from "@/lib/db";
|
||||
import { kundeErmitteln, kundeZugriffPruefen, type HandelnderBenutzer } from "@/server/mandant";
|
||||
|
||||
/**
|
||||
* Mitarbeiter (#011).
|
||||
*
|
||||
* Die Personen, an denen die Historie haengt. Zwei Regeln tragen das:
|
||||
*
|
||||
* 1. **Nichts wird geloescht.** Ein Mitarbeiter wird auf `aktiv = false`
|
||||
* gesetzt. Ein archivierter Lauf zeigt auf ihn, und dieser Verweis muss in
|
||||
* zehn Jahren noch aufloesbar sein — deshalb steht der Fremdschluessel auf
|
||||
* `Restrict` und es gibt hier gar keinen Loeschweg.
|
||||
* 2. **Was aus dem Verzeichnis kommt, wird nicht von Hand ueberschrieben.** Bei
|
||||
* `herkunft = ABGLEICH` sind die abgeglichenen Felder gesperrt: der naechste
|
||||
* Abgleich wuerde die Aenderung ohnehin zurueckdrehen, und ein Wert, der
|
||||
* zwischen zwei Laeufen hin- und herspringt, ist schlimmer als ein falscher.
|
||||
* Was **nicht** aus dem Verzeichnis kommt, bleibt aenderbar (#016 fuellt die
|
||||
* Gegenseite).
|
||||
*/
|
||||
|
||||
export class MitarbeiterFehler extends Error {
|
||||
constructor(nachricht: string) {
|
||||
super(nachricht);
|
||||
this.name = "MitarbeiterFehler";
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Felder, die der Verzeichnisabgleich fuellt.
|
||||
*
|
||||
* Als Daten und nicht als Kette von `if`s, damit die Sperre und die Oberflaeche
|
||||
* aus derselben Liste lesen — sonst zeigt das Formular ein Feld als aenderbar,
|
||||
* das der Dienst danach abweist.
|
||||
*/
|
||||
export const ABGEGLICHENE_FELDER = [
|
||||
"vorname",
|
||||
"nachname",
|
||||
"anzeigename",
|
||||
"mail",
|
||||
"upn",
|
||||
"sam",
|
||||
"abteilung",
|
||||
"titel",
|
||||
] as const;
|
||||
|
||||
export type AbgeglichenesFeld = (typeof ABGEGLICHENE_FELDER)[number];
|
||||
|
||||
export type MitarbeiterEingabe = {
|
||||
readonly vorname: string;
|
||||
readonly nachname: string;
|
||||
/** Leer: wird aus Vor- und Nachname gebildet. */
|
||||
readonly anzeigename?: string | null;
|
||||
readonly mail?: string | null;
|
||||
readonly upn?: string | null;
|
||||
readonly sam?: string | null;
|
||||
readonly abteilung?: string | null;
|
||||
readonly titel?: string | null;
|
||||
readonly kundeId?: string | null;
|
||||
};
|
||||
|
||||
function pflicht(wert: string, was: string): string {
|
||||
const sauber = wert.trim();
|
||||
if (!sauber) throw new MitarbeiterFehler(`${was} darf nicht leer sein.`);
|
||||
return sauber;
|
||||
}
|
||||
|
||||
function leerAlsNull(wert: string | null | undefined): string | null {
|
||||
const sauber = wert?.trim();
|
||||
return sauber ? sauber : null;
|
||||
}
|
||||
|
||||
/**
|
||||
* `sam` ist im Active Directory auf 20 Zeichen begrenzt.
|
||||
*
|
||||
* Die Regel steht hier, weil ein zu langer Wert erst beim `New-ADUser` im
|
||||
* Gesicht des Technikers explodieren wuerde — und dann vor dem Kunden.
|
||||
*/
|
||||
function samPruefen(wert: string | null): string | null {
|
||||
if (wert && wert.length > 20) {
|
||||
throw new MitarbeiterFehler(
|
||||
`„${wert}“ ist ${wert.length} Zeichen lang. Ein sAMAccountName fasst höchstens 20.`,
|
||||
);
|
||||
}
|
||||
return wert;
|
||||
}
|
||||
|
||||
function anzeigenameBilden(eingabe: MitarbeiterEingabe, vorname: string, nachname: string): string {
|
||||
const gewuenscht = leerAlsNull(eingabe.anzeigename);
|
||||
return gewuenscht ?? `${vorname} ${nachname}`.trim();
|
||||
}
|
||||
|
||||
/** Legt einen Mitarbeiter von Hand an — `herkunft = MANUELL`. */
|
||||
export async function mitarbeiterAnlegen(
|
||||
eingabe: MitarbeiterEingabe,
|
||||
benutzer: HandelnderBenutzer,
|
||||
): Promise<Mitarbeiter> {
|
||||
const vorname = pflicht(eingabe.vorname, "Der Vorname");
|
||||
const nachname = pflicht(eingabe.nachname, "Der Nachname");
|
||||
const kundeId = await kundeErmitteln(eingabe.kundeId, benutzer);
|
||||
|
||||
return prisma.$transaction(async (tx) => {
|
||||
const mitarbeiter = await tx.mitarbeiter.create({
|
||||
data: {
|
||||
kundeId,
|
||||
vorname,
|
||||
nachname,
|
||||
anzeigename: anzeigenameBilden(eingabe, vorname, nachname),
|
||||
mail: leerAlsNull(eingabe.mail),
|
||||
upn: leerAlsNull(eingabe.upn),
|
||||
sam: samPruefen(leerAlsNull(eingabe.sam)),
|
||||
abteilung: leerAlsNull(eingabe.abteilung),
|
||||
titel: leerAlsNull(eingabe.titel),
|
||||
herkunft: Herkunft.MANUELL,
|
||||
},
|
||||
});
|
||||
await tx.protokoll.create({
|
||||
data: {
|
||||
entitaet: "Mitarbeiter",
|
||||
entitaetId: mitarbeiter.id,
|
||||
aktion: "Mitarbeiter angelegt",
|
||||
benutzerId: benutzer.id,
|
||||
nachher: { anzeigename: mitarbeiter.anzeigename, herkunft: mitarbeiter.herkunft },
|
||||
},
|
||||
});
|
||||
return mitarbeiter;
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Aendert die Stammdaten.
|
||||
*
|
||||
* Bei `herkunft = ABGLEICH` sind die abgeglichenen Felder gesperrt — abgewiesen
|
||||
* wird aber nur, was sich wirklich aendern soll. Ein Formular, das alle Felder
|
||||
* mitschickt, darf deshalb weiterhin die freien Felder aendern, ohne an einem
|
||||
* unveraenderten gesperrten Feld zu scheitern.
|
||||
*/
|
||||
export async function mitarbeiterBearbeiten(
|
||||
mitarbeiterId: string,
|
||||
aenderung: Partial<MitarbeiterEingabe>,
|
||||
benutzer: HandelnderBenutzer,
|
||||
): Promise<Mitarbeiter> {
|
||||
const vorher = await prisma.mitarbeiter.findUnique({ where: { id: mitarbeiterId } });
|
||||
if (!vorher) throw new MitarbeiterFehler("Diese Person gibt es nicht (mehr).");
|
||||
await kundeZugriffPruefen(vorher.kundeId, benutzer);
|
||||
|
||||
const daten: Record<string, string | null> = {};
|
||||
const geaendert: string[] = [];
|
||||
|
||||
function uebernehmen(feld: AbgeglichenesFeld | "anzeigename", neu: string | null) {
|
||||
if (neu === vorher![feld]) return;
|
||||
if (vorher!.herkunft === Herkunft.ABGLEICH && (ABGEGLICHENE_FELDER as readonly string[]).includes(feld)) {
|
||||
throw new MitarbeiterFehler(
|
||||
`„${vorher!.anzeigename}“ kommt aus dem Verzeichnis. ${feldName(feld)} wird dort gepflegt und ` +
|
||||
"beim nächsten Abgleich ohnehin zurückgesetzt.",
|
||||
);
|
||||
}
|
||||
daten[feld] = neu;
|
||||
geaendert.push(feldName(feld));
|
||||
}
|
||||
|
||||
if (aenderung.vorname !== undefined) uebernehmen("vorname", pflicht(aenderung.vorname, "Der Vorname"));
|
||||
if (aenderung.nachname !== undefined) uebernehmen("nachname", pflicht(aenderung.nachname, "Der Nachname"));
|
||||
if (aenderung.anzeigename !== undefined) {
|
||||
const gewuenscht = leerAlsNull(aenderung.anzeigename);
|
||||
uebernehmen(
|
||||
"anzeigename",
|
||||
gewuenscht ??
|
||||
`${(daten["vorname"] as string) ?? vorher.vorname} ${(daten["nachname"] as string) ?? vorher.nachname}`.trim(),
|
||||
);
|
||||
}
|
||||
if (aenderung.mail !== undefined) uebernehmen("mail", leerAlsNull(aenderung.mail));
|
||||
if (aenderung.upn !== undefined) uebernehmen("upn", leerAlsNull(aenderung.upn));
|
||||
if (aenderung.sam !== undefined) uebernehmen("sam", samPruefen(leerAlsNull(aenderung.sam)));
|
||||
if (aenderung.abteilung !== undefined) uebernehmen("abteilung", leerAlsNull(aenderung.abteilung));
|
||||
if (aenderung.titel !== undefined) uebernehmen("titel", leerAlsNull(aenderung.titel));
|
||||
|
||||
if (geaendert.length === 0) return vorher;
|
||||
|
||||
return prisma.$transaction(async (tx) => {
|
||||
const nachher = await tx.mitarbeiter.update({ where: { id: mitarbeiterId }, data: daten });
|
||||
await tx.protokoll.create({
|
||||
data: {
|
||||
entitaet: "Mitarbeiter",
|
||||
entitaetId: mitarbeiterId,
|
||||
aktion: `${geaendert.join(" und ")} geändert`,
|
||||
benutzerId: benutzer.id,
|
||||
vorher: auszug(vorher, Object.keys(daten)),
|
||||
nachher: auszug(nachher, Object.keys(daten)),
|
||||
},
|
||||
});
|
||||
return nachher;
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Deaktivieren und wieder aktivieren.
|
||||
*
|
||||
* Es gibt keinen Loeschweg — auch nicht fuer eine Person ohne Laeufe. Waere
|
||||
* Loeschen manchmal moeglich, muesste jeder Aufrufer die Bedingung kennen, und
|
||||
* beim Offboarding entscheidet sich niemand bewusst zwischen zwei Wegen.
|
||||
*/
|
||||
export async function mitarbeiterAktivSetzen(
|
||||
mitarbeiterId: string,
|
||||
aktiv: boolean,
|
||||
benutzer: HandelnderBenutzer,
|
||||
): Promise<Mitarbeiter> {
|
||||
const vorher = await prisma.mitarbeiter.findUnique({ where: { id: mitarbeiterId } });
|
||||
if (!vorher) throw new MitarbeiterFehler("Diese Person gibt es nicht (mehr).");
|
||||
await kundeZugriffPruefen(vorher.kundeId, benutzer);
|
||||
if (vorher.aktiv === aktiv) return vorher;
|
||||
|
||||
return prisma.$transaction(async (tx) => {
|
||||
const nachher = await tx.mitarbeiter.update({ where: { id: mitarbeiterId }, data: { aktiv } });
|
||||
await tx.protokoll.create({
|
||||
data: {
|
||||
entitaet: "Mitarbeiter",
|
||||
entitaetId: mitarbeiterId,
|
||||
aktion: aktiv ? "Mitarbeiter wieder aktiviert" : "Mitarbeiter deaktiviert",
|
||||
benutzerId: benutzer.id,
|
||||
vorher: { aktiv: vorher.aktiv },
|
||||
nachher: { aktiv },
|
||||
},
|
||||
});
|
||||
return nachher;
|
||||
});
|
||||
}
|
||||
|
||||
const FELD_NAMEN: Record<string, string> = {
|
||||
vorname: "Vorname",
|
||||
nachname: "Nachname",
|
||||
anzeigename: "Anzeigename",
|
||||
mail: "Mail-Adresse",
|
||||
upn: "UPN",
|
||||
sam: "sAMAccountName",
|
||||
abteilung: "Abteilung",
|
||||
titel: "Titel",
|
||||
};
|
||||
|
||||
function feldName(feld: string): string {
|
||||
return FELD_NAMEN[feld] ?? feld;
|
||||
}
|
||||
|
||||
/** Nur die geaenderten Felder ins Protokoll – ein ganzer Datensatz waere Rauschen. */
|
||||
function auszug(zeile: Mitarbeiter, felder: readonly string[]): Prisma.InputJsonObject {
|
||||
const ausschnitt: Record<string, string | null> = {};
|
||||
for (const feld of felder) {
|
||||
ausschnitt[feld] = (zeile as unknown as Record<string, string | null>)[feld] ?? null;
|
||||
}
|
||||
return ausschnitt;
|
||||
}
|
||||
Reference in New Issue
Block a user