diff --git a/src/app/(app)/notifications/page.tsx b/src/app/(app)/notifications/page.tsx
index dceecbf..498ae23 100644
--- a/src/app/(app)/notifications/page.tsx
+++ b/src/app/(app)/notifications/page.tsx
@@ -1,5 +1,134 @@
-import { ModulePlaceholder } from "@/components/module-placeholder";
+import Link from "next/link";
+import { redirect } from "next/navigation";
+import { BellDot, CheckCheck } from "lucide-react";
+import { getFormatter, getTranslations } from "next-intl/server";
+import { EVENT_TYPES } from "@/lib/events";
+import { PageHead, Pill } from "@/components/mockup-ui";
+import { Button } from "@/components/ui/button";
+import { markAllNotificationsRead, markNotificationRead, openNotification } from "@/server/actions/notifications/inbox";
+import { listNotifications } from "@/server/services/notifications/inbox";
+import { pageCtx } from "@/server/services/notifications/page-ctx";
+import { eventKey } from "@/server/services/notifications/texts";
-export default function Page() {
- return
;
+const selectCls = "h-11 rounded-md border border-input bg-card px-3 text-sm";
+
+export default async function NotificationsPage({
+ searchParams,
+}: {
+ searchParams: Promise
>;
+}) {
+ const ctx = await pageCtx();
+ if (!ctx.permissions.has("notification:read")) redirect("/dashboard");
+ const sp = await searchParams;
+ const one = (v: string | string[] | undefined) => (Array.isArray(v) ? v[0] : v);
+ const data = await listNotifications(ctx, { status: one(sp.status), type: one(sp.type), page: one(sp.page) });
+ const [t, format] = await Promise.all([getTranslations("notifications"), getFormatter()]);
+
+ const pageHref = (page: number) => {
+ const q = new URLSearchParams();
+ if (data.filter.status !== "all") q.set("status", data.filter.status);
+ if (data.filter.type) q.set("type", data.filter.type);
+ q.set("page", String(page));
+ return `/notifications?${q.toString()}`;
+ };
+
+ return (
+
+
+
+
+ }
+ />
+
+
+
+ {data.rows.length === 0 ? (
+ {t("list.empty")}
+ ) : (
+
+ )}
+
+ {data.pages > 1 && (
+
+ )}
+
+ );
}
diff --git a/src/app/(app)/settings/audit/page.tsx b/src/app/(app)/settings/audit/page.tsx
new file mode 100644
index 0000000..e0ebfc5
--- /dev/null
+++ b/src/app/(app)/settings/audit/page.tsx
@@ -0,0 +1,201 @@
+import Link from "next/link";
+import { redirect } from "next/navigation";
+import { ArrowLeft, CircleCheck, CircleX } from "lucide-react";
+import { getFormatter, getTranslations } from "next-intl/server";
+import { Modal } from "@/components/modal";
+import { PageHead, Pill } from "@/components/mockup-ui";
+import { Button } from "@/components/ui/button";
+import { getAuditEntry, queryAuditLog, type AuditFilter } from "@/server/services/audit/viewer";
+import { ServiceError } from "@/server/services/context";
+import { pageCtx } from "@/server/services/notifications/page-ctx";
+
+const fieldCls = "h-11 rounded-md border border-input bg-card px-3 text-sm";
+
+type SP = Record;
+
+export default async function AuditLogPage({ searchParams }: { searchParams: Promise }) {
+ const ctx = await pageCtx();
+ if (!ctx.permissions.has("audit:read")) redirect("/dashboard");
+ const sp = await searchParams;
+ const one = (v: string | string[] | undefined) => (Array.isArray(v) ? v[0] : v);
+
+ const data = await queryAuditLog(ctx, {
+ from: one(sp.from), to: one(sp.to), actorId: one(sp.actorId), action: one(sp.action),
+ entity: one(sp.entity), entityId: one(sp.entityId), page: one(sp.page),
+ });
+ const detailId = one(sp.detail);
+ let detail: Awaited> | null = null;
+ if (detailId) {
+ try {
+ detail = await getAuditEntry(ctx, detailId);
+ } catch (err) {
+ if (!(err instanceof ServiceError)) throw err;
+ }
+ }
+
+ const [t, format] = await Promise.all([getTranslations("notifications"), getFormatter()]);
+ const actorNames = new Map(data.actors.map((a) => [a.id, a.name]));
+ const actionLabel = (a: string) => (t.has(`audit.actions.${a}`) ? t(`audit.actions.${a}`) : a);
+ const entityLabel = (e: string) => (t.has(`audit.entities.${e}`) ? t(`audit.entities.${e}`) : e);
+
+ const href = (patch: Partial>) => {
+ const q = new URLSearchParams();
+ const merged = { ...data.filter, detail: undefined, ...patch } as Record;
+ for (const [k, v] of Object.entries(merged)) if (v !== undefined && v !== "" && !(k === "page" && v === 1)) q.set(k, String(v));
+ const s = q.toString();
+ return `/settings/audit${s ? `?${s}` : ""}`;
+ };
+ const f = data.filter;
+
+ return (
+
+
+ {t("audit.back")}
+
+
+
+
+
+ {t("audit.total", { count: data.total })}
+
+ {data.rows.length === 0 ? (
+ {t("audit.empty")}
+ ) : (
+
+
+
+
+ | {t("audit.time")} |
+ {t("audit.actor")} |
+ {t("audit.action")} |
+ {t("audit.object")} |
+ {t("audit.result")} |
+ {t("audit.details")} |
+
+
+
+ {data.rows.map((r) => (
+
+ |
+ {format.dateTime(r.createdAt, { dateStyle: "medium", timeStyle: "medium" })}
+ |
+ {r.actorId ? (actorNames.get(r.actorId) ?? r.actorId.slice(0, 8)) : t("audit.system")} |
+ {actionLabel(r.action)} |
+
+ {entityLabel(r.entity)}
+ {r.entityId && #{r.entityId.slice(0, 12)}}
+ {r.scope === "platform" && · {t("audit.platform")}}
+ |
+
+ {r.action === "denied" ? (
+ {t("audit.resultDenied")}
+ ) : (
+ {t("audit.resultOk")}
+ )}
+ |
+
+
+ {t("audit.details")}
+
+ |
+
+ ))}
+
+
+
+
+ - {t("audit.time")}
- {format.dateTime(detail.createdAt, { dateStyle: "medium", timeStyle: "medium" })}
+ - {t("audit.actor")}
- {detail.actorName ?? (detail.actorId ?? t("audit.system"))}
+ - {t("audit.entity")}
- {entityLabel(detail.entity)}{detail.scope === "platform" ? ` · ${t("audit.platform")}` : ""}
+ - {t("audit.entityId")}
- {detail.entityId ?? "—"}
+ - {t("audit.result")}
- {detail.action === "denied" ? t("audit.resultDenied") : t("audit.resultOk")}
+ - {t("audit.ip")}
- {detail.ip ?? t("audit.notCaptured")}
+ - {t("audit.userAgent")}
- {detail.userAgent ?? t("audit.notCaptured")}
+
+
+ {detail.diff.length === 0 ? (
+
{t("audit.noValues")}
+ ) : (
+
+
+
+
+ | {t("audit.field")} |
+ {t("audit.before")} |
+ {t("audit.after")} |
+
+
+
+ {detail.diff.map((d) => (
+
+ |
+ {d.key}
+ {d.changed && {t("audit.changed")}}
+ |
+ {d.before ?? "—"} |
+ {d.after ?? "—"} |
+
+ ))}
+
+
+
+ )}
+
+ ✓ {t("mailSettings.saved")}
+
+ )}
+ {sp.error && (
+
+ ⚠ {t("mailSettings.invalid", { detail: sp.error.split(",").map((f) => t.has(`mailSettings.${f}`) ? t(`mailSettings.${f}`) : f).join(", ") })}
+
+ )}
+
+
+
+ );
+}
diff --git a/src/components/audit-trail.tsx b/src/components/audit-trail.tsx
index b9d10d6..6d4fadc 100644
--- a/src/components/audit-trail.tsx
+++ b/src/components/audit-trail.tsx
@@ -65,6 +65,17 @@ const ENTITY_LABEL: Record = {
import: "Auftragsimport",
report: "Bericht",
emergency: "Notdienst",
+ signature: "Unterschrift",
+ import_job: "Auftragsimport",
+ material_usage: "Material",
+ time_entry: "Arbeitszeit",
+ work_session: "Einsatzzeit",
+ photo: "Foto",
+ voice_note: "Sprachnotiz",
+ notification: "Benachrichtigung",
+ notification_settings: "Benachrichtigungseinstellungen",
+ tenant_mail_settings: "E-Mail-Versand",
+ sync_operation: "Synchronisation",
document: "Dokument",
};
diff --git a/src/components/notifications/bell.tsx b/src/components/notifications/bell.tsx
new file mode 100644
index 0000000..fde5920
--- /dev/null
+++ b/src/components/notifications/bell.tsx
@@ -0,0 +1,94 @@
+import Link from "next/link";
+import { Bell } from "lucide-react";
+import { getFormatter, getTranslations } from "next-intl/server";
+import { markAllNotificationsRead, openNotification } from "@/server/actions/notifications/inbox";
+import { bellSummary } from "@/server/services/notifications/inbox";
+import { isNotificationsModuleEnabled, pageCtx } from "@/server/services/notifications/page-ctx";
+import { cn } from "@/lib/utils";
+
+/**
+ * Notification bell for the back office header and the mobile header (L4 embeds
+ * ``). Server component, no client JS: the dropdown is a
+ * native . Hidden without `notification:read` or with the module disabled.
+ */
+export async function NotificationBell({ variant = "desktop" }: { variant?: "desktop" | "mobile" }) {
+ const ctx = await pageCtx();
+ if (!ctx.permissions.has("notification:read") || !(await isNotificationsModuleEnabled(ctx))) return null;
+
+ const [{ unread, latest }, t, format] = await Promise.all([bellSummary(ctx), getTranslations("notifications"), getFormatter()]);
+ const touch = variant === "mobile" ? "size-12" : "size-11";
+
+ return (
+
+
+
+ {unread > 0 && (
+
+ {unread > 99 ? "99+" : unread}
+
+ )}
+
+
+
+
+
+
{t("bell.label")}
+
{t("bell.unreadCount", { count: unread })}
+
+ {unread > 0 && (
+
+ )}
+
+
+ {latest.length === 0 ? (
+
{t("bell.empty")}
+ ) : (
+
+ {latest.map((n) => (
+ -
+
+
+ ))}
+
+ )}
+
+
+
+ {t("bell.showAll")}
+
+
+
+ );
+}
diff --git a/src/components/notifications/preferences-form.tsx b/src/components/notifications/preferences-form.tsx
new file mode 100644
index 0000000..a96fa33
--- /dev/null
+++ b/src/components/notifications/preferences-form.tsx
@@ -0,0 +1,57 @@
+"use client";
+
+import { useActionState } from "react";
+import { Button } from "@/components/ui/button";
+import { saveNotificationPreferences, type PreferencesState } from "@/server/actions/notifications/preferences";
+
+export type PreferenceItem = { type: string; label: string; email: boolean; mandatory: boolean };
+
+/** E-mail opt-out per notification type (in-app notifications are always on). */
+export function NotificationPreferencesForm({
+ items,
+ labels,
+}: {
+ items: PreferenceItem[];
+ labels: { email: string; mandatory: string; save: string; saved: string; error: string };
+}) {
+ const [state, action, pending] = useActionState(saveNotificationPreferences, { status: "idle" } as PreferencesState);
+
+ return (
+
+ );
+}
diff --git a/src/components/notifications/preferences-section.tsx b/src/components/notifications/preferences-section.tsx
new file mode 100644
index 0000000..7d52264
--- /dev/null
+++ b/src/components/notifications/preferences-section.tsx
@@ -0,0 +1,31 @@
+import { getTranslations } from "next-intl/server";
+import { getPreferences } from "@/server/services/notifications/preferences";
+import { isNotificationsModuleEnabled, pageCtx } from "@/server/services/notifications/page-ctx";
+import { eventKey } from "@/server/services/notifications/texts";
+import { NotificationPreferencesForm } from "./preferences-form";
+
+/** "Benachrichtigungen" section of /account (self-contained: loads its own data). */
+export async function NotificationPreferencesSection() {
+ const ctx = await pageCtx();
+ if (!ctx.permissions.has("notification:read") || !(await isNotificationsModuleEnabled(ctx))) return null;
+ const [prefs, t, tc] = await Promise.all([getPreferences(ctx), getTranslations("notifications"), getTranslations("common")]);
+
+ return (
+
+
+ {t("preferences.title")}
+
+ {t("preferences.sub")}
+ ({ type: p.type, label: t(`types.${eventKey(p.type)}`), email: p.email, mandatory: p.mandatory }))}
+ labels={{
+ email: t("preferences.email"),
+ mandatory: t("preferences.mandatory"),
+ save: t("preferences.save"),
+ saved: t("preferences.saved"),
+ error: tc("readOnly"),
+ }}
+ />
+
+ );
+}
diff --git a/src/lib/nav.ts b/src/lib/nav.ts
index 94985ce..714f4bb 100644
--- a/src/lib/nav.ts
+++ b/src/lib/nav.ts
@@ -8,6 +8,9 @@ import {
FileText,
FolderOpen,
Settings,
+ Bell,
+ History,
+ Mail,
type LucideIcon,
} from "lucide-react";
import type { ModuleKey } from "@/lib/modules";
@@ -49,7 +52,10 @@ export const NAV_ITEMS: readonly NavItem[] = [
{ href: "/teams", label: "teams", icon: UsersRound, module: "teams", permissions: ["team:read"], section: "main" },
{ href: "/reports", label: "reports", icon: FileText, module: "reports", permissions: ["report:read"], section: "main" },
{ href: "/documents", label: "documents", icon: FolderOpen, module: "documents", permissions: ["document:read"], section: "main" },
+ { href: "/notifications", label: "notifications", icon: Bell, module: "notifications", permissions: ["notification:read"], section: "main" },
{ href: "/settings", label: "settings", icon: Settings, permissions: ["tenant:manage"], section: "admin" },
+ { href: "/settings/email", label: "email", icon: Mail, module: "notifications", permissions: ["tenant:manage"], section: "admin" },
+ { href: "/settings/audit", label: "audit", icon: History, permissions: ["audit:read"], section: "admin" },
];
/** Filtert die Navigation nach aktiven Modulen und Rechten der Session. */
diff --git a/src/server/actions/notifications/inbox.ts b/src/server/actions/notifications/inbox.ts
new file mode 100644
index 0000000..cf03e08
--- /dev/null
+++ b/src/server/actions/notifications/inbox.ts
@@ -0,0 +1,36 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { redirect } from "next/navigation";
+import { moduleGuard } from "@/server/action-guard";
+import { ctxFromGuard, ServiceError } from "@/server/services/context";
+import { markAllRead, markRead } from "@/server/services/notifications/inbox";
+
+const guard = moduleGuard("notifications");
+
+/** Mark one own notification as read. */
+export async function markNotificationRead(formData: FormData) {
+ const g = await guard("notification:read");
+ await markRead(ctxFromGuard(g), formData.get("id"));
+ revalidatePath("/", "layout");
+}
+
+/** Mark as read and open the linked entity (relative links only). */
+export async function openNotification(formData: FormData) {
+ const g = await guard("notification:read");
+ let target = "/notifications";
+ try {
+ const { link } = await markRead(ctxFromGuard(g), formData.get("id"));
+ if (link) target = link;
+ } catch (err) {
+ if (!(err instanceof ServiceError)) throw err;
+ }
+ revalidatePath("/", "layout");
+ redirect(target);
+}
+
+export async function markAllNotificationsRead() {
+ const g = await guard("notification:read");
+ await markAllRead(ctxFromGuard(g));
+ revalidatePath("/", "layout");
+}
diff --git a/src/server/actions/notifications/mail-settings.ts b/src/server/actions/notifications/mail-settings.ts
new file mode 100644
index 0000000..174a00c
--- /dev/null
+++ b/src/server/actions/notifications/mail-settings.ts
@@ -0,0 +1,30 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { redirect } from "next/navigation";
+import { ZodError } from "zod";
+import { moduleGuard } from "@/server/action-guard";
+import { ctxFromGuard } from "@/server/services/context";
+import { updateMailSettings } from "@/server/services/notifications/mail-settings";
+
+const guard = moduleGuard("notifications");
+
+/** Tenant mail settings (§33.2) — tenant:manage. Result is reported via query string. */
+export async function saveMailSettings(formData: FormData) {
+ const g = await guard("tenant:manage");
+ let target = "/settings/email?saved=1";
+ try {
+ await updateMailSettings(ctxFromGuard(g), {
+ mailFromName: String(formData.get("mailFromName") ?? ""),
+ mailReplyTo: String(formData.get("mailReplyTo") ?? ""),
+ emergencyRecipients: String(formData.get("emergencyRecipients") ?? ""),
+ billingRecipients: String(formData.get("billingRecipients") ?? ""),
+ });
+ } catch (err) {
+ if (!(err instanceof ZodError)) throw err;
+ const fields = [...new Set(err.issues.map((i) => String(i.path[0] ?? "")))].filter(Boolean).join(",");
+ target = `/settings/email?error=${encodeURIComponent(fields || "input")}`;
+ }
+ revalidatePath("/settings/email");
+ redirect(target);
+}
diff --git a/src/server/actions/notifications/preferences.ts b/src/server/actions/notifications/preferences.ts
new file mode 100644
index 0000000..6a96cef
--- /dev/null
+++ b/src/server/actions/notifications/preferences.ts
@@ -0,0 +1,23 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { moduleGuard } from "@/server/action-guard";
+import { ctxFromGuard } from "@/server/services/context";
+import { setPreferences } from "@/server/services/notifications/preferences";
+
+const guard = moduleGuard("notifications");
+
+export type PreferencesState = { status: "idle" | "saved" | "error" };
+
+/** Save the current user's e-mail opt-outs (checked boxes = e-mail on). */
+export async function saveNotificationPreferences(_prev: PreferencesState, formData: FormData): Promise {
+ const g = await guard("notification:read");
+ try {
+ await setPreferences(ctxFromGuard(g), { emailOn: formData.getAll("emailOn").map(String) });
+ } catch (err) {
+ console.error("[notifications] saving preferences failed:", (err as Error).message);
+ return { status: "error" };
+ }
+ revalidatePath("/account");
+ return { status: "saved" };
+}
diff --git a/src/server/mail/templates.ts b/src/server/mail/templates.ts
index 19399c3..1a962ad 100644
--- a/src/server/mail/templates.ts
+++ b/src/server/mail/templates.ts
@@ -40,8 +40,33 @@ export type TemplateVars = {
eventType: string;
};
test: { name: string; when: string };
+ // ---- Craftvia domain notifications (lane L6). `name` may be "" for configured external recipients.
+ craftvia_team_assigned: {
+ name: string; number: string; title: string; customer: string;
+ site?: string; plannedStart?: string; team?: string; actionUrl: string; footer?: CraftviaFooter;
+ };
+ craftvia_report_review: {
+ name: string; number: string; title: string; customer: string;
+ submittedBy?: string; reportType?: "daily" | "completion"; actionUrl: string; footer?: CraftviaFooter;
+ };
+ craftvia_billing_release: {
+ name: string; number: string; title: string; customer: string; actionUrl: string; footer?: CraftviaFooter;
+ };
+ craftvia_emergency: {
+ name: string; phase: "created" | "completed"; number: string; technician: string; customer: string;
+ start: string; end?: string; actionUrl: string; footer?: CraftviaFooter;
+ };
+ craftvia_document_failed: {
+ name: string; fileName: string; error?: string; actionUrl: string; footer?: CraftviaFooter;
+ };
+ craftvia_notification: {
+ name: string; subject: string; body: string; actionUrl?: string; footer?: CraftviaFooter;
+ };
};
+/** Why the recipient gets a Craftvia notification — controls the footer line. */
+export type CraftviaFooter = "user" | "mandatory" | "configured";
+
export type TemplateKey = keyof TemplateVars;
export const TEMPLATE_KEYS = [
@@ -55,6 +80,16 @@ export const TEMPLATE_KEYS = [
"test",
] as const satisfies readonly TemplateKey[];
+/** Craftvia domain templates (lane L6) — kept separate so SEC1 fixtures stay unchanged. */
+export const CRAFTVIA_TEMPLATE_KEYS = [
+ "craftvia_team_assigned",
+ "craftvia_report_review",
+ "craftvia_billing_release",
+ "craftvia_emergency",
+ "craftvia_document_failed",
+ "craftvia_notification",
+] as const satisfies readonly TemplateKey[];
+
/** Abmelde-/Präferenzhinweis — nur für Benachrichtigungen, nie für Transaktionsmails. */
const FOOTER_NOTE: Record = {
de: "Sie erhalten diese Benachrichtigung aufgrund Ihrer Rolle in Ihrem Betrieb. Die Einstellungen dazu finden Sie in Ihrem Profil.",
@@ -63,6 +98,169 @@ const FOOTER_NOTE: Record = {
type Builder = (vars: TemplateVars[K]) => EmailContent;
+// ---- Craftvia domain notifications (lane L6) ----
+type CraftviaKey = (typeof CRAFTVIA_TEMPLATE_KEYS)[number];
+
+const CRAFTVIA_FOOTER: Record> = {
+ de: {
+ user: FOOTER_NOTE.de,
+ mandatory: "Pflichtbenachrichtigung zum Notdienst – sie lässt sich nicht abbestellen.",
+ configured: "Sie erhalten diese Nachricht, weil Ihre Adresse im Betrieb als fester Empfänger hinterlegt ist.",
+ },
+ en: {
+ user: FOOTER_NOTE.en,
+ mandatory: "Mandatory emergency call-out notification – it cannot be turned off.",
+ configured: "You are receiving this message because your address is set up as a fixed recipient in your company.",
+ },
+};
+
+const greetDe = (name: string) => (name ? `Hallo ${name},` : "Guten Tag,");
+const greetEn = (name: string) => (name ? `Hello ${name},` : "Hello,");
+
+const craftviaDe: { [K in CraftviaKey]: Builder } = {
+ craftvia_team_assigned: (v) => ({
+ subject: `${BRAND.name}: Neuer Auftrag ${v.number}`,
+ heading: "Neuer Auftrag für Ihr Team",
+ paragraphs: [
+ greetDe(v.name),
+ `der Auftrag ${v.number} „${v.title}" wurde ${v.team ? `dem Team ${v.team}` : "Ihnen"} zugewiesen.`,
+ `Kunde: ${v.customer}`,
+ ...(v.site ? [`Objekt: ${v.site}`] : []),
+ ...(v.plannedStart ? [`Geplanter Beginn: ${v.plannedStart}`] : []),
+ ],
+ action: { label: "Auftrag öffnen", url: v.actionUrl },
+ footerNote: CRAFTVIA_FOOTER.de[v.footer ?? "user"],
+ }),
+ craftvia_report_review: (v) => ({
+ subject: `${BRAND.name}: Bericht zur Prüfung – ${v.number}`,
+ heading: "Bericht zur Prüfung",
+ paragraphs: [
+ greetDe(v.name),
+ `${v.submittedBy ?? "Das Team"} hat ${v.reportType === "daily" ? "einen Tagesbericht" : v.reportType === "completion" ? "einen Abschlussbericht" : "einen Bericht"} zu ${v.number} „${v.title}" eingereicht.`,
+ `Kunde: ${v.customer}`,
+ "Bitte prüfen und freigeben oder eine Korrektur anfordern.",
+ ],
+ action: { label: "Bericht prüfen", url: v.actionUrl },
+ footerNote: CRAFTVIA_FOOTER.de[v.footer ?? "user"],
+ }),
+ craftvia_billing_release: (v) => ({
+ subject: `${BRAND.name}: Auftrag ${v.number} zur Abrechnung`,
+ heading: "Auftrag bereit zur Abrechnung",
+ paragraphs: [
+ greetDe(v.name),
+ `der Auftrag ${v.number} „${v.title}" ist geprüft und zur Abrechnung freigegeben.`,
+ `Kunde: ${v.customer}`,
+ ],
+ action: { label: "Auftrag öffnen", url: v.actionUrl },
+ footerNote: CRAFTVIA_FOOTER.de[v.footer ?? "user"],
+ }),
+ craftvia_emergency: (v) => ({
+ subject: `${BRAND.name}: Notdiensteinsatz ${v.number} ${v.phase === "completed" ? "abgeschlossen" : "erstellt"}`,
+ heading: v.phase === "completed" ? "Neuer Notdiensteinsatz abgeschlossen" : "Neuer Notdiensteinsatz erstellt",
+ paragraphs: [
+ greetDe(v.name),
+ `Monteur: ${v.technician}`,
+ `Kunde: ${v.customer}`,
+ `Einsatzbeginn: ${v.start}`,
+ ...(v.end ? [`Einsatzende: ${v.end}`] : []),
+ `Status: ${v.phase === "completed" ? "Zur Prüfung und Abrechnung" : "In Arbeit"}`,
+ ],
+ action: { label: "Einsatz öffnen", url: v.actionUrl },
+ footerNote: CRAFTVIA_FOOTER.de[v.footer ?? "mandatory"],
+ }),
+ craftvia_document_failed: (v) => ({
+ subject: `${BRAND.name}: Fehler bei der Dokumentverarbeitung`,
+ heading: "Dokument konnte nicht verarbeitet werden",
+ paragraphs: [
+ greetDe(v.name),
+ `die Datei „${v.fileName}" konnte nicht automatisch ausgelesen werden.`,
+ ...(v.error ? [`Grund: ${v.error}`] : []),
+ "Die Datei bleibt gespeichert. Den Auftrag bitte manuell erfassen oder die Datei erneut hochladen.",
+ ],
+ action: { label: "Import öffnen", url: v.actionUrl },
+ footerNote: CRAFTVIA_FOOTER.de[v.footer ?? "user"],
+ }),
+ craftvia_notification: (v) => ({
+ subject: `${BRAND.name}: ${v.subject}`,
+ heading: v.subject,
+ paragraphs: [greetDe(v.name), v.body],
+ action: v.actionUrl ? { label: `In ${BRAND.name} öffnen`, url: v.actionUrl } : undefined,
+ footerNote: CRAFTVIA_FOOTER.de[v.footer ?? "user"],
+ }),
+};
+
+const craftviaEn: { [K in CraftviaKey]: Builder } = {
+ craftvia_team_assigned: (v) => ({
+ subject: `${BRAND.name}: New work order ${v.number}`,
+ heading: "New work order for your team",
+ paragraphs: [
+ greetEn(v.name),
+ `work order ${v.number} "${v.title}" was assigned to ${v.team ? `team ${v.team}` : "you"}.`,
+ `Customer: ${v.customer}`,
+ ...(v.site ? [`Site: ${v.site}`] : []),
+ ...(v.plannedStart ? [`Planned start: ${v.plannedStart}`] : []),
+ ],
+ action: { label: "Open work order", url: v.actionUrl },
+ footerNote: CRAFTVIA_FOOTER.en[v.footer ?? "user"],
+ }),
+ craftvia_report_review: (v) => ({
+ subject: `${BRAND.name}: Report for review – ${v.number}`,
+ heading: "Report for review",
+ paragraphs: [
+ greetEn(v.name),
+ `${v.submittedBy ?? "The team"} submitted ${v.reportType === "daily" ? "a daily report" : v.reportType === "completion" ? "a completion report" : "a report"} for ${v.number} "${v.title}".`,
+ `Customer: ${v.customer}`,
+ "Please review and approve it or request a correction.",
+ ],
+ action: { label: "Review report", url: v.actionUrl },
+ footerNote: CRAFTVIA_FOOTER.en[v.footer ?? "user"],
+ }),
+ craftvia_billing_release: (v) => ({
+ subject: `${BRAND.name}: Work order ${v.number} ready for billing`,
+ heading: "Work order ready for billing",
+ paragraphs: [
+ greetEn(v.name),
+ `work order ${v.number} "${v.title}" has been reviewed and released for billing.`,
+ `Customer: ${v.customer}`,
+ ],
+ action: { label: "Open work order", url: v.actionUrl },
+ footerNote: CRAFTVIA_FOOTER.en[v.footer ?? "user"],
+ }),
+ craftvia_emergency: (v) => ({
+ subject: `${BRAND.name}: Emergency call-out ${v.number} ${v.phase === "completed" ? "completed" : "created"}`,
+ heading: v.phase === "completed" ? "New emergency call-out completed" : "New emergency call-out created",
+ paragraphs: [
+ greetEn(v.name),
+ `Technician: ${v.technician}`,
+ `Customer: ${v.customer}`,
+ `Start: ${v.start}`,
+ ...(v.end ? [`End: ${v.end}`] : []),
+ `Status: ${v.phase === "completed" ? "Ready for review and billing" : "In progress"}`,
+ ],
+ action: { label: "Open call-out", url: v.actionUrl },
+ footerNote: CRAFTVIA_FOOTER.en[v.footer ?? "mandatory"],
+ }),
+ craftvia_document_failed: (v) => ({
+ subject: `${BRAND.name}: Document processing failed`,
+ heading: "Document could not be processed",
+ paragraphs: [
+ greetEn(v.name),
+ `the file "${v.fileName}" could not be read automatically.`,
+ ...(v.error ? [`Reason: ${v.error}`] : []),
+ "The file stays stored. Please enter the work order manually or upload the file again.",
+ ],
+ action: { label: "Open import", url: v.actionUrl },
+ footerNote: CRAFTVIA_FOOTER.en[v.footer ?? "user"],
+ }),
+ craftvia_notification: (v) => ({
+ subject: `${BRAND.name}: ${v.subject}`,
+ heading: v.subject,
+ paragraphs: [greetEn(v.name), v.body],
+ action: v.actionUrl ? { label: `Open in ${BRAND.name}`, url: v.actionUrl } : undefined,
+ footerNote: CRAFTVIA_FOOTER.en[v.footer ?? "user"],
+ }),
+};
+
const de: { [K in TemplateKey]: Builder } = {
invitation: (v) => ({
subject: `Ihr Zugang zu ${BRAND.name}`,
@@ -139,6 +337,7 @@ const de: { [K in TemplateKey]: Builder } = {
"Erreicht sie Sie, sind SMTP-Konfiguration und Versandweg in Ordnung.",
],
}),
+ ...craftviaDe,
};
const en: { [K in TemplateKey]: Builder } = {
@@ -217,6 +416,7 @@ const en: { [K in TemplateKey]: Builder } = {
"If it reaches you, SMTP configuration and delivery path are working.",
],
}),
+ ...craftviaEn,
};
const CATALOG: Record }> = { de, en };
diff --git a/src/server/services/audit/viewer.ts b/src/server/services/audit/viewer.ts
new file mode 100644
index 0000000..e91d53d
--- /dev/null
+++ b/src/server/services/audit/viewer.ts
@@ -0,0 +1,128 @@
+import type { Prisma } from "@prisma/client";
+import { z } from "zod";
+import { assertCan, ServiceError, type ServiceCtx } from "@/server/services/context";
+
+/**
+ * Read-only audit log viewer (spec §26). Requires `audit:read`; always tenant-bound via ctx.db
+ * (the tenant client filters AuditLog by tenantId). Audit rows are never modified here.
+ */
+
+export const AUDIT_PAGE_SIZE = 50;
+
+const dateStr = z
+ .string()
+ .regex(/^\d{4}-\d{2}-\d{2}$/)
+ .optional()
+ .catch(undefined);
+const optStr = (max: number) =>
+ z
+ .string()
+ .trim()
+ .max(max)
+ .transform((v) => v || undefined)
+ .optional()
+ .catch(undefined);
+
+export const auditFilterSchema = z.object({
+ from: dateStr,
+ to: dateStr,
+ actorId: optStr(64),
+ action: optStr(40),
+ entity: optStr(60),
+ entityId: optStr(128),
+ page: z.coerce.number().int().min(1).max(100_000).catch(1),
+});
+export type AuditFilter = z.infer;
+
+export function auditWhere(f: AuditFilter): Prisma.AuditLogWhereInput {
+ const createdAt: Prisma.DateTimeFilter = {};
+ if (f.from) createdAt.gte = new Date(`${f.from}T00:00:00.000Z`);
+ if (f.to) createdAt.lt = new Date(new Date(`${f.to}T00:00:00.000Z`).getTime() + 86_400_000);
+ return {
+ ...(f.from || f.to ? { createdAt } : {}),
+ ...(f.actorId ? { actorId: f.actorId } : {}),
+ ...(f.action ? { action: f.action } : {}),
+ ...(f.entity ? { entity: f.entity } : {}),
+ ...(f.entityId ? { entityId: { contains: f.entityId } } : {}),
+ };
+}
+
+export async function queryAuditLog(ctx: ServiceCtx, input: unknown) {
+ assertCan(ctx, "audit:read");
+ const filter = auditFilterSchema.parse(input ?? {});
+ const where = auditWhere(filter);
+ const [rows, total, actions, entities, users] = await Promise.all([
+ ctx.db.auditLog.findMany({
+ where,
+ orderBy: { createdAt: "desc" },
+ skip: (filter.page - 1) * AUDIT_PAGE_SIZE,
+ take: AUDIT_PAGE_SIZE,
+ select: { id: true, createdAt: true, actorId: true, action: true, entity: true, entityId: true, scope: true },
+ }),
+ ctx.db.auditLog.count({ where }),
+ ctx.db.auditLog.findMany({ distinct: ["action"], select: { action: true }, orderBy: { action: "asc" } }),
+ ctx.db.auditLog.findMany({ distinct: ["entity"], select: { entity: true }, orderBy: { entity: "asc" } }),
+ ctx.db.user.findMany({ select: { id: true, name: true }, orderBy: { name: "asc" } }),
+ ]);
+ return {
+ rows,
+ total,
+ page: filter.page,
+ pages: Math.max(1, Math.ceil(total / AUDIT_PAGE_SIZE)),
+ filter,
+ facets: { actions: actions.map((a) => a.action), entities: entities.map((e) => e.entity) },
+ actors: users,
+ };
+}
+
+export type DiffRow = { key: string; before: string | null; after: string | null; changed: boolean };
+
+function show(v: unknown): string | null {
+ if (v === undefined) return null;
+ if (v === null) return "null";
+ return typeof v === "string" ? v : JSON.stringify(v);
+}
+
+/** Field-wise before/after comparison (top-level keys; nested values rendered as JSON). */
+export function diffAudit(before: unknown, after: unknown): DiffRow[] {
+ const b = before && typeof before === "object" && !Array.isArray(before) ? (before as Record) : null;
+ const a = after && typeof after === "object" && !Array.isArray(after) ? (after as Record) : null;
+ if (!b && !a) {
+ if (before === undefined && after === undefined) return [];
+ if (before == null && after == null) return [];
+ return [{ key: "value", before: show(before ?? undefined), after: show(after ?? undefined), changed: show(before) !== show(after) }];
+ }
+ const keys = [...new Set([...Object.keys(b ?? {}), ...Object.keys(a ?? {})])].sort();
+ return keys.map((key) => {
+ const bv = show(b?.[key]);
+ const av = show(a?.[key]);
+ return { key, before: bv, after: av, changed: bv !== av };
+ });
+}
+
+/** Extract request metadata if a writer stored it (writeAuditLog does not capture it yet). */
+function requestMeta(...sources: unknown[]): { ip: string | null; userAgent: string | null } {
+ for (const s of sources) {
+ if (s && typeof s === "object") {
+ const o = s as Record;
+ const ip = typeof o.ip === "string" ? o.ip : null;
+ const userAgent = typeof o.userAgent === "string" ? o.userAgent : null;
+ if (ip || userAgent) return { ip, userAgent };
+ }
+ }
+ return { ip: null, userAgent: null };
+}
+
+export async function getAuditEntry(ctx: ServiceCtx, id: unknown) {
+ assertCan(ctx, "audit:read");
+ const entryId = z.string().min(1).max(64).parse(id);
+ const row = await ctx.db.auditLog.findFirst({ where: { id: entryId } });
+ if (!row) throw new ServiceError("not_found", "audit entry not found");
+ const actor = row.actorId ? await ctx.db.user.findFirst({ where: { id: row.actorId }, select: { name: true } }) : null;
+ return {
+ ...row,
+ actorName: actor?.name ?? null,
+ diff: diffAudit(row.before ?? undefined, row.after ?? undefined),
+ ...requestMeta(row.after, row.before),
+ };
+}
diff --git a/src/server/services/notifications/handle-event.ts b/src/server/services/notifications/handle-event.ts
index 6338513..aa09d5e 100644
--- a/src/server/services/notifications/handle-event.ts
+++ b/src/server/services/notifications/handle-event.ts
@@ -1,10 +1,224 @@
import type { DomainEvent } from "@/lib/events";
+import { absoluteUrl } from "@/server/mail/config";
+import { enqueueMail, type EnqueueInput } from "@/server/mail/service";
+import { formatWhen, normalizeLocale, type CraftviaFooter, type Locale, type TemplateKey } from "@/server/mail/templates";
import type { ServiceCtx } from "@/server/services/context";
+import { resolveRecipients, type EventFacts, type Target } from "./recipients";
+import { eventText, fallbackText } from "./texts";
/**
- * Placeholder — replaced by lane "notifications" (recipient rules, in-app Notification rows,
- * e-mail via the mail queue). Keeps emitEvent() callable for all other lanes meanwhile.
+ * Domain event → in-app notifications + e-mails (ARCHITEKTUR §4.1). Called only via emitEvent().
+ *
+ * - Never throws: every failure is logged, business data is never rolled back.
+ * - In-app rows via ctx.db (tenant guard). An identical unread notification (same user, type,
+ * entity) is refreshed instead of duplicated.
+ * - E-mail via the mail queue with dedupeKey `event:entity:user` (+ optional `data.occurrenceId`
+ * for repeatable events such as daily reports), so the same event twice sends one mail.
+ * - NotificationPreference.email=false opts out per event type — except mandatory events
+ * (emergency call-outs).
*/
-export async function handleEvent(_ctx: ServiceCtx, _event: DomainEvent): Promise {
- // intentionally empty
+export async function handleEvent(ctx: ServiceCtx, event: DomainEvent): Promise {
+ try {
+ await dispatch(ctx, event);
+ } catch (err) {
+ console.error(`[notifications] ${event.type} for ${event.entityType}:${event.entityId} failed:`, (err as Error)?.message ?? err);
+ }
+}
+
+async function dispatch(ctx: ServiceCtx, event: DomainEvent): Promise {
+ const settings = await ctx.db.tenantSettings.findFirst({
+ select: { locale: true, emergencyRecipients: true, billingRecipients: true },
+ });
+ const plan = await resolveRecipients(ctx, event, settings);
+ if (!plan) return;
+
+ const occurrence = typeof event.data?.occurrenceId === "string" || typeof event.data?.occurrenceId === "number"
+ ? `:${event.data.occurrenceId}`
+ : "";
+ const optedOut = await optedOutUserIds(ctx, event, plan.users);
+
+ for (const user of plan.users) {
+ try {
+ const link = linkFor(event, plan.facts, user.permissions);
+ const text = eventText(user.locale, event.type, textVars(user.locale, plan.facts));
+ const notificationId = await upsertInApp(ctx, event, user.userId, text, link);
+
+ const wantsMail = plan.mailUserIds.has(user.userId) && (plan.mandatory || !optedOut.has(user.userId));
+ if (!wantsMail) continue;
+ const result = await enqueueMail(
+ buildMail(ctx, event, plan.facts, {
+ to: user.email,
+ name: user.name,
+ locale: user.locale,
+ link,
+ footer: plan.mandatory ? "mandatory" : "user",
+ dedupeKey: `${event.type}:${event.entityId}:${user.userId}${occurrence}`,
+ text,
+ }),
+ );
+ if (result.status === "queued" || result.status === "sent") {
+ await ctx.db.notification.update({ where: { id: notificationId }, data: { emailedAt: new Date() } });
+ }
+ } catch (err) {
+ console.error(`[notifications] ${event.type} → user ${user.userId} failed:`, (err as Error)?.message ?? err);
+ }
+ }
+
+ const tenantLocale = normalizeLocale(settings?.locale);
+ for (const email of plan.externalEmails) {
+ try {
+ const link = linkFor(event, plan.facts, new Set(["work_order:read_all", "report:approve"]));
+ await enqueueMail(
+ buildMail(ctx, event, plan.facts, {
+ to: email,
+ name: "",
+ locale: tenantLocale,
+ link,
+ footer: plan.mandatory ? "mandatory" : "configured",
+ dedupeKey: `${event.type}:${event.entityId}:ext:${email}${occurrence}`,
+ text: eventText(tenantLocale, event.type, textVars(tenantLocale, plan.facts)),
+ }),
+ );
+ } catch (err) {
+ console.error(`[notifications] ${event.type} → configured recipient failed:`, (err as Error)?.message ?? err);
+ }
+ }
+}
+
+async function optedOutUserIds(ctx: ServiceCtx, event: DomainEvent, users: Target[]): Promise> {
+ if (!users.length) return new Set();
+ const prefs = await ctx.db.notificationPreference.findMany({
+ where: { eventType: event.type, email: false, userId: { in: users.map((u) => u.userId) } },
+ select: { userId: true },
+ });
+ return new Set(prefs.map((p) => p.userId));
+}
+
+async function upsertInApp(
+ ctx: ServiceCtx,
+ event: DomainEvent,
+ userId: string,
+ text: { title: string; message: string },
+ link: string | null,
+): Promise {
+ const existing = await ctx.db.notification.findFirst({
+ where: { userId, type: event.type, entityType: event.entityType, entityId: event.entityId, readAt: null },
+ select: { id: true },
+ });
+ if (existing) {
+ await ctx.db.notification.update({
+ where: { id: existing.id },
+ data: { title: text.title, message: text.message, link, createdAt: new Date() },
+ });
+ return existing.id;
+ }
+ const row = await ctx.db.notification.create({
+ data: {
+ tenantId: ctx.tenantId,
+ userId,
+ type: event.type,
+ title: text.title,
+ message: text.message,
+ entityType: event.entityType,
+ entityId: event.entityId,
+ link,
+ },
+ select: { id: true },
+ });
+ return row.id;
+}
+
+function textVars(locale: Locale, f: EventFacts): Record {
+ return {
+ number: f.number,
+ title: f.title,
+ customer: f.customer,
+ actor: f.actorName ?? fallbackText(locale, "system"),
+ fileName: f.fileName ?? fallbackText(locale, "document"),
+ reason: f.syncErrorCode,
+ };
+}
+
+/** Relative in-app link, chosen by what the recipient can open (back office vs. mobile). */
+export function linkFor(event: DomainEvent, f: EventFacts, permissions: ReadonlySet): string | null {
+ const backoffice = permissions.has("work_order:read_all");
+ switch (event.entityType) {
+ case "work_order":
+ return backoffice ? `/work-orders/${event.entityId}` : `/m/orders/${event.entityId}`;
+ case "report":
+ if (backoffice) return `/reports/${event.entityId}`;
+ return f.workOrderId ? `/m/orders/${f.workOrderId}/report` : null;
+ case "import_job":
+ return `/imports/${event.entityId}`;
+ case "sync_operation":
+ return backoffice ? "/work-orders/conflicts" : "/m/sync";
+ default:
+ return null;
+ }
+}
+
+type MailTarget = {
+ to: string;
+ name: string;
+ locale: Locale;
+ link: string | null;
+ footer: CraftviaFooter;
+ dedupeKey: string;
+ text: { title: string; message: string };
+};
+
+function buildMail(ctx: ServiceCtx, event: DomainEvent, f: EventFacts, t: MailTarget): EnqueueInput {
+ const unknown = fallbackText(t.locale, "unknown");
+ const actionUrl = absoluteUrl(t.link ?? "/notifications");
+ const base = { to: t.to, tenantId: ctx.tenantId, locale: t.locale, dedupeKey: t.dedupeKey };
+ const order = { number: f.number ?? unknown, title: f.title ?? unknown, customer: f.customer ?? unknown };
+
+ switch (event.type) {
+ case "work_order.assigned":
+ return {
+ ...base,
+ template: "craftvia_team_assigned",
+ vars: {
+ name: t.name, ...order, site: f.site, team: f.team, actionUrl, footer: t.footer,
+ plannedStart: f.plannedStart ? formatWhen(f.plannedStart, t.locale) : undefined,
+ },
+ };
+ case "report.submitted":
+ return {
+ ...base,
+ template: "craftvia_report_review",
+ vars: { name: t.name, ...order, submittedBy: f.actorName, reportType: f.reportType, actionUrl, footer: t.footer },
+ };
+ case "work_order.released_for_billing":
+ return { ...base, template: "craftvia_billing_release", vars: { name: t.name, ...order, actionUrl, footer: t.footer } };
+ case "emergency.created":
+ case "emergency.completed":
+ return {
+ ...base,
+ template: "craftvia_emergency",
+ vars: {
+ name: t.name,
+ phase: event.type === "emergency.completed" ? "completed" : "created",
+ number: order.number,
+ technician: f.actorName ?? unknown,
+ customer: order.customer,
+ start: f.emergencyStart ? formatWhen(f.emergencyStart, t.locale) : unknown,
+ end: f.emergencyEnd ? formatWhen(f.emergencyEnd, t.locale) : undefined,
+ actionUrl,
+ footer: t.footer,
+ },
+ };
+ case "import.failed":
+ return {
+ ...base,
+ template: "craftvia_document_failed",
+ vars: { name: t.name, fileName: f.fileName ?? unknown, error: f.errorMessage, actionUrl, footer: t.footer },
+ };
+ default:
+ return {
+ ...base,
+ template: "craftvia_notification",
+ vars: { name: t.name, subject: t.text.title, body: t.text.message, actionUrl, footer: t.footer },
+ };
+ }
}
diff --git a/src/server/services/notifications/inbox.ts b/src/server/services/notifications/inbox.ts
new file mode 100644
index 0000000..c610c4e
--- /dev/null
+++ b/src/server/services/notifications/inbox.ts
@@ -0,0 +1,103 @@
+import { z } from "zod";
+import { EVENT_TYPES } from "@/lib/events";
+import { writeAuditLog } from "@/server/audit";
+import { assertCan, ServiceError, type ServiceCtx } from "@/server/services/context";
+
+/**
+ * Personal notification inbox. A user only ever sees/changes their OWN notifications
+ * (userId filter) inside their tenant (ctx.db). Foreign ids → not_found (no existence leak).
+ */
+
+export const PAGE_SIZE = 25;
+
+export const listFilterSchema = z.object({
+ status: z.enum(["all", "unread", "read"]).catch("all"),
+ type: z.enum(EVENT_TYPES).optional().catch(undefined),
+ page: z.coerce.number().int().min(1).max(10_000).catch(1),
+});
+export type ListFilter = z.infer;
+
+export async function listNotifications(ctx: ServiceCtx, input: unknown) {
+ assertCan(ctx, "notification:read");
+ const filter = listFilterSchema.parse(input ?? {});
+ const where = {
+ userId: ctx.userId,
+ ...(filter.status === "unread" ? { readAt: null } : filter.status === "read" ? { readAt: { not: null } } : {}),
+ ...(filter.type ? { type: filter.type } : {}),
+ };
+ const [rows, total] = await Promise.all([
+ ctx.db.notification.findMany({
+ where,
+ orderBy: { createdAt: "desc" },
+ skip: (filter.page - 1) * PAGE_SIZE,
+ take: PAGE_SIZE,
+ select: { id: true, type: true, title: true, message: true, link: true, readAt: true, createdAt: true, entityType: true, entityId: true },
+ }),
+ ctx.db.notification.count({ where }),
+ ]);
+ return { rows, total, page: filter.page, pages: Math.max(1, Math.ceil(total / PAGE_SIZE)), filter };
+}
+
+/** Unread counter + latest 10 for the bell. */
+export async function bellSummary(ctx: ServiceCtx) {
+ assertCan(ctx, "notification:read");
+ const [unread, latest] = await Promise.all([
+ ctx.db.notification.count({ where: { userId: ctx.userId, readAt: null } }),
+ ctx.db.notification.findMany({
+ where: { userId: ctx.userId },
+ orderBy: { createdAt: "desc" },
+ take: 10,
+ select: { id: true, type: true, title: true, message: true, link: true, readAt: true, createdAt: true },
+ }),
+ ]);
+ return { unread, latest };
+}
+
+const idSchema = z.string().min(1).max(64);
+
+/** Mark one own notification as read; returns its link (safe relative path or null). */
+export async function markRead(ctx: ServiceCtx, id: unknown): Promise<{ link: string | null }> {
+ assertCan(ctx, "notification:read");
+ const notificationId = idSchema.parse(id);
+ const row = await ctx.db.notification.findFirst({
+ where: { id: notificationId, userId: ctx.userId },
+ select: { id: true, readAt: true, link: true },
+ });
+ if (!row) throw new ServiceError("not_found", "notification not found");
+ if (!row.readAt) {
+ const readAt = new Date();
+ await ctx.db.notification.update({ where: { id: row.id }, data: { readAt } });
+ await writeAuditLog({
+ tenantId: ctx.tenantId,
+ actorId: ctx.userId,
+ action: "update",
+ entity: "notification",
+ entityId: row.id,
+ before: { readAt: null },
+ after: { readAt: readAt.toISOString() },
+ });
+ }
+ return { link: safeLink(row.link) };
+}
+
+export async function markAllRead(ctx: ServiceCtx): Promise<{ count: number }> {
+ assertCan(ctx, "notification:read");
+ const res = await ctx.db.notification.updateMany({ where: { userId: ctx.userId, readAt: null }, data: { readAt: new Date() } });
+ if (res.count > 0) {
+ await writeAuditLog({
+ tenantId: ctx.tenantId,
+ actorId: ctx.userId,
+ action: "update",
+ entity: "notification",
+ before: { unread: res.count },
+ after: { unread: 0 },
+ });
+ }
+ return { count: res.count };
+}
+
+/** Only same-origin relative paths are followed (no open redirect). */
+export function safeLink(link: string | null | undefined): string | null {
+ if (!link || !link.startsWith("/") || link.startsWith("//") || link.includes("\\")) return null;
+ return link;
+}
diff --git a/src/server/services/notifications/mail-settings.ts b/src/server/services/notifications/mail-settings.ts
new file mode 100644
index 0000000..9717925
--- /dev/null
+++ b/src/server/services/notifications/mail-settings.ts
@@ -0,0 +1,96 @@
+import { z } from "zod";
+import { writeAuditLog } from "@/server/audit";
+import { assertCan, type ServiceCtx } from "@/server/services/context";
+
+/**
+ * Tenant mail settings (spec §33.2). The sender ADDRESS stays the platform domain (SPF/DKIM);
+ * per tenant only the display name and reply-to address are configurable, plus fixed recipient
+ * lists for emergency call-outs and billing.
+ */
+
+export const MAX_RECIPIENTS = 20;
+
+/** Split a textarea/comma list into trimmed, lower-cased, unique entries. */
+export function splitAddressList(raw: unknown): string[] {
+ if (Array.isArray(raw)) return [...new Set(raw.map((x) => String(x).trim().toLowerCase()).filter(Boolean))];
+ if (typeof raw !== "string") return [];
+ return [...new Set(raw.split(/[\s,;]+/).map((x) => x.trim().toLowerCase()).filter(Boolean))];
+}
+
+const email = z.string().trim().toLowerCase().email().max(254);
+
+export const mailSettingsSchema = z.object({
+ // No CR/LF or angle brackets/quotes: the name ends up in a mail header (header injection).
+ mailFromName: z
+ .string()
+ .trim()
+ .max(100)
+ .regex(/^[^\r\n<>"]*$/, "invalid characters")
+ .transform((v) => v || null),
+ mailReplyTo: z
+ .union([z.literal(""), email])
+ .transform((v) => v || null),
+ emergencyRecipients: z.preprocess(splitAddressList, z.array(email).max(MAX_RECIPIENTS)),
+ billingRecipients: z.preprocess(splitAddressList, z.array(email).max(MAX_RECIPIENTS)),
+});
+
+export type MailSettings = {
+ mailFromName: string | null;
+ mailReplyTo: string | null;
+ emergencyRecipients: string[];
+ billingRecipients: string[];
+};
+
+const SELECT = { mailFromName: true, mailReplyTo: true, emergencyRecipients: true, billingRecipients: true, orgName: true } as const;
+
+export async function getMailSettings(ctx: ServiceCtx): Promise {
+ assertCan(ctx, "tenant:manage");
+ const s = await ctx.db.tenantSettings.findFirst({ select: SELECT });
+ return {
+ mailFromName: s?.mailFromName ?? null,
+ mailReplyTo: s?.mailReplyTo ?? null,
+ emergencyRecipients: s?.emergencyRecipients ?? [],
+ billingRecipients: s?.billingRecipients ?? [],
+ orgName: s?.orgName ?? null,
+ };
+}
+
+export async function updateMailSettings(ctx: ServiceCtx, input: unknown): Promise {
+ assertCan(ctx, "tenant:manage");
+ const data = mailSettingsSchema.parse(input);
+ const before = await ctx.db.tenantSettings.findFirst({ select: SELECT });
+
+ if (before) {
+ await ctx.db.tenantSettings.update({ where: { tenantId: ctx.tenantId }, data });
+ } else {
+ const tenant = await ctx.db.tenant.findUnique({ where: { id: ctx.tenantId }, select: { name: true } });
+ await ctx.db.tenantSettings.create({ data: { tenantId: ctx.tenantId, orgName: tenant?.name ?? "", ...data } });
+ }
+
+ await writeAuditLog({
+ tenantId: ctx.tenantId,
+ actorId: ctx.userId,
+ action: "update",
+ entity: "tenant_mail_settings",
+ before: before
+ ? {
+ mailFromName: before.mailFromName,
+ mailReplyTo: before.mailReplyTo,
+ emergencyRecipients: before.emergencyRecipients,
+ billingRecipients: before.billingRecipients,
+ }
+ : undefined,
+ after: data,
+ });
+ return data;
+}
+
+/**
+ * Sender override for tenant mails — ready for the mail core once it accepts per-mail
+ * `fromName`/`replyTo` (reported as foundation requirement; deliver.ts currently uses the
+ * global MAIL_FROM_NAME/MAIL_REPLY_TO only).
+ */
+export async function tenantMailSender(ctx: ServiceCtx): Promise<{ fromName: string | null; replyTo: string | null }> {
+ const s = await ctx.db.tenantSettings.findFirst({ select: { mailFromName: true, mailReplyTo: true, orgName: true } });
+ return { fromName: s?.mailFromName || s?.orgName || null, replyTo: s?.mailReplyTo ?? null };
+}
diff --git a/src/server/services/notifications/page-ctx.ts b/src/server/services/notifications/page-ctx.ts
new file mode 100644
index 0000000..8f6bed8
--- /dev/null
+++ b/src/server/services/notifications/page-ctx.ts
@@ -0,0 +1,26 @@
+import { requireSession } from "@/server/auth";
+import { dbForTenant } from "@/server/db";
+import type { ServiceCtx } from "@/server/services/context";
+
+/**
+ * Read-path context for server components (pages, bell). Permissions come from the session
+ * (JWT copy), which is accepted for READ paths (AGENTS.md); mutations go through moduleGuard,
+ * which re-checks permissions against the database.
+ */
+export async function pageCtx(): Promise {
+ const session = await requireSession();
+ return {
+ db: dbForTenant(session.user.tenantId),
+ tenantId: session.user.tenantId,
+ userId: session.user.id,
+ permissions: new Set(session.user.permissions ?? []),
+ };
+}
+
+export async function isNotificationsModuleEnabled(ctx: ServiceCtx): Promise {
+ const row = await ctx.db.tenantModule.findUnique({
+ where: { tenantId_moduleKey: { tenantId: ctx.tenantId, moduleKey: "notifications" } },
+ select: { enabled: true },
+ });
+ return !row || row.enabled;
+}
diff --git a/src/server/services/notifications/preferences.ts b/src/server/services/notifications/preferences.ts
new file mode 100644
index 0000000..c553923
--- /dev/null
+++ b/src/server/services/notifications/preferences.ts
@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { EVENT_TYPES, type EventType } from "@/lib/events";
+import { writeAuditLog } from "@/server/audit";
+import { assertCan, type ServiceCtx } from "@/server/services/context";
+import { MANDATORY_EMAIL_EVENTS } from "./recipients";
+
+/**
+ * Per-user e-mail opt-out per event type (NotificationPreference, default opt-in).
+ * Mandatory events (emergency call-outs) are always on and cannot be stored as opted out.
+ */
+
+export type PreferenceRow = { type: EventType; email: boolean; mandatory: boolean };
+
+export async function getPreferences(ctx: ServiceCtx): Promise {
+ assertCan(ctx, "notification:read");
+ const rows = await ctx.db.notificationPreference.findMany({
+ where: { userId: ctx.userId },
+ select: { eventType: true, email: true },
+ });
+ const map = new Map(rows.map((r) => [r.eventType, r.email]));
+ return EVENT_TYPES.map((type) => {
+ const mandatory = MANDATORY_EMAIL_EVENTS.has(type);
+ return { type, mandatory, email: mandatory ? true : (map.get(type) ?? true) };
+ });
+}
+
+export const setPreferencesSchema = z.object({
+ /** event types that should still send e-mail; everything else (non-mandatory) is opted out */
+ emailOn: z.array(z.enum(EVENT_TYPES)).max(EVENT_TYPES.length),
+});
+
+export async function setPreferences(ctx: ServiceCtx, input: unknown): Promise {
+ assertCan(ctx, "notification:read");
+ const { emailOn } = setPreferencesSchema.parse(input);
+ const on = new Set(emailOn);
+ const before = await getPreferences(ctx);
+
+ for (const type of EVENT_TYPES) {
+ const email = MANDATORY_EMAIL_EVENTS.has(type) ? true : on.has(type);
+ await ctx.db.notificationPreference.upsert({
+ where: { userId_eventType: { userId: ctx.userId, eventType: type } },
+ update: { email },
+ create: { tenantId: ctx.tenantId, userId: ctx.userId, eventType: type, email },
+ });
+ }
+
+ const after = await getPreferences(ctx);
+ await writeAuditLog({
+ tenantId: ctx.tenantId,
+ actorId: ctx.userId,
+ action: "update",
+ entity: "notification_settings",
+ entityId: ctx.userId,
+ before: Object.fromEntries(before.map((p) => [p.type, p.email])),
+ after: Object.fromEntries(after.map((p) => [p.type, p.email])),
+ });
+ return after;
+}
diff --git a/src/server/services/notifications/recipients.ts b/src/server/services/notifications/recipients.ts
new file mode 100644
index 0000000..52a6034
--- /dev/null
+++ b/src/server/services/notifications/recipients.ts
@@ -0,0 +1,319 @@
+import type { Prisma } from "@prisma/client";
+import type { DomainEvent, EventType } from "@/lib/events";
+import { normalizeLocale, type Locale } from "@/server/mail/templates";
+import type { ServiceCtx } from "@/server/services/context";
+
+/**
+ * Recipient rules per domain event (spec §19.4, §20, §33.1; ARCHITEKTUR §4.1).
+ *
+ * Tenant separation: every lookup runs through `ctx.db` (tenant guard + RLS). User ids coming
+ * from entity rows are re-resolved via `ctx.db.user` with status ACTIVE, so ids of other tenants
+ * (or deactivated users) can never become recipients.
+ */
+
+/** Events whose e-mail cannot be turned off by the user (spec §19.4). */
+export const MANDATORY_EMAIL_EVENTS: ReadonlySet = new Set(["emergency.created", "emergency.completed"]);
+
+/**
+ * System-result events: the affected user is informed even if the event was emitted in their own
+ * context (a worker/sync run on their behalf) — the "actor excluded" rule does not apply to them.
+ */
+const SYSTEM_RESULT_EVENTS: ReadonlySet = new Set(["import.ready_for_review", "import.failed", "sync.failed"]);
+
+export type Target = {
+ userId: string;
+ email: string;
+ name: string;
+ locale: Locale;
+ permissions: ReadonlySet;
+};
+
+/** Facts about the entity, used for texts, templates and links. */
+export type EventFacts = {
+ workOrderId?: string;
+ number?: string;
+ title?: string;
+ customer?: string;
+ site?: string;
+ team?: string;
+ plannedStart?: Date | null;
+ isEmergency?: boolean;
+ reportId?: string;
+ reportType?: "daily" | "completion";
+ importJobId?: string;
+ fileName?: string;
+ errorMessage?: string;
+ syncErrorCode?: string;
+ actorName?: string;
+ emergencyStart?: Date | null;
+ emergencyEnd?: Date | null;
+};
+
+export type RecipientPlan = {
+ /** Users receiving an in-app notification (actor already removed where applicable). */
+ users: Target[];
+ /** Users who additionally get an e-mail (subject to preferences unless mandatory). */
+ mailUserIds: ReadonlySet;
+ /** Configured external addresses (tenant mail settings) — e-mail only. */
+ externalEmails: string[];
+ mandatory: boolean;
+ facts: EventFacts;
+};
+
+const USER_SELECT = {
+ id: true,
+ email: true,
+ name: true,
+ identity: { select: { uiLocale: true } },
+ userRoles: { select: { role: { select: { rolePermissions: { select: { permission: { select: { key: true } } } } } } } },
+} satisfies Prisma.UserSelect;
+
+function hasPermissionWhere(key: string): Prisma.UserWhereInput {
+ return { userRoles: { some: { role: { rolePermissions: { some: { permission: { key } } } } } } };
+}
+
+/** Load active users of the current tenant matching `where` (always via the tenant client). */
+export async function loadTargets(ctx: ServiceCtx, where: Prisma.UserWhereInput, fallbackLocale: string | null | undefined): Promise {
+ const rows = await ctx.db.user.findMany({ where: { AND: [where, { status: "ACTIVE" }] }, select: USER_SELECT });
+ return rows.map((u) => ({
+ userId: u.id,
+ email: u.email,
+ name: u.name,
+ locale: normalizeLocale(u.identity?.uiLocale ?? fallbackLocale),
+ permissions: new Set(u.userRoles.flatMap((ur) => ur.role.rolePermissions.map((rp) => rp.permission.key))),
+ }));
+}
+
+/** Back office responsible for reviews: users with work_order:read_all AND report:approve. */
+export function backofficeWhere(): Prisma.UserWhereInput {
+ return { AND: [hasPermissionWhere("work_order:read_all"), hasPermissionWhere("report:approve")] };
+}
+
+export function billingWhere(): Prisma.UserWhereInput {
+ return hasPermissionWhere("work_order:release_billing");
+}
+
+type LoadedWorkOrder = {
+ id: string;
+ number: string;
+ title: string;
+ isEmergency: boolean;
+ plannedStart: Date | null;
+ createdAt: Date;
+ teamLeadUserId: string | null;
+ customer: { companyName: string | null; firstName: string | null; lastName: string | null } | null;
+ site: { name: string | null } | null;
+ team: { id: string; name: string; leaderUserId: string | null } | null;
+ assignees: { userId: string }[];
+};
+
+async function loadWorkOrder(ctx: ServiceCtx, id: string): Promise {
+ return ctx.db.workOrder.findFirst({
+ where: { id, deletedAt: null },
+ select: {
+ id: true,
+ number: true,
+ title: true,
+ isEmergency: true,
+ plannedStart: true,
+ createdAt: true,
+ teamLeadUserId: true,
+ customer: { select: { companyName: true, firstName: true, lastName: true } },
+ site: { select: { name: true } },
+ team: { select: { id: true, name: true, leaderUserId: true } },
+ assignees: { select: { userId: true } },
+ },
+ }) as Promise;
+}
+
+export function customerLabel(c: LoadedWorkOrder["customer"]): string | undefined {
+ if (!c) return undefined;
+ return c.companyName || [c.firstName, c.lastName].filter(Boolean).join(" ") || undefined;
+}
+
+/** Active team members + team leader + order team lead + individual assignees. */
+async function participantIds(ctx: ServiceCtx, wo: LoadedWorkOrder): Promise {
+ const ids = new Set();
+ if (wo.team) {
+ const now = new Date();
+ const members = await ctx.db.teamMember.findMany({
+ where: { teamId: wo.team.id, validFrom: { lte: now }, OR: [{ validTo: null }, { validTo: { gt: now } }] },
+ select: { userId: true },
+ });
+ members.forEach((m) => ids.add(m.userId));
+ if (wo.team.leaderUserId) ids.add(wo.team.leaderUserId);
+ }
+ if (wo.teamLeadUserId) ids.add(wo.teamLeadUserId);
+ wo.assignees.forEach((a) => ids.add(a.userId));
+ return [...ids];
+}
+
+function teamLeadIds(wo: LoadedWorkOrder): string[] {
+ return [...new Set([wo.teamLeadUserId, wo.team?.leaderUserId].filter((x): x is string => !!x))];
+}
+
+function workOrderFacts(wo: LoadedWorkOrder): EventFacts {
+ return {
+ workOrderId: wo.id,
+ number: wo.number,
+ title: wo.title,
+ customer: customerLabel(wo.customer),
+ site: wo.site?.name ?? undefined,
+ team: wo.team?.name,
+ plannedStart: wo.plannedStart,
+ isEmergency: wo.isEmergency,
+ };
+}
+
+function dateFromData(v: unknown): Date | null {
+ if (typeof v !== "string" && typeof v !== "number") return null;
+ const d = new Date(v);
+ return Number.isNaN(d.getTime()) ? null : d;
+}
+
+type Rule = {
+ users: Prisma.UserWhereInput[];
+ /** ids from entity rows — re-resolved through ctx.db.user */
+ userIds: string[];
+ /** false = in-app only for the users (e-mail goes to `external`); default true */
+ mailToUsers?: boolean;
+ external?: string[];
+};
+
+/**
+ * Resolve recipients for an event. Returns null when the entity is not visible in this tenant
+ * (unknown id, other tenant, soft-deleted) — then nothing is sent.
+ */
+export async function resolveRecipients(
+ ctx: ServiceCtx,
+ event: DomainEvent,
+ settings: { locale?: string | null; emergencyRecipients?: string[]; billingRecipients?: string[] } | null,
+): Promise {
+ const facts: EventFacts = {};
+ let rule: Rule;
+
+ switch (event.type) {
+ case "work_order.assigned":
+ case "work_order.changed":
+ case "work_order.cancelled": {
+ const wo = await loadWorkOrder(ctx, event.entityId);
+ if (!wo) return null;
+ Object.assign(facts, workOrderFacts(wo));
+ rule = { users: [], userIds: await participantIds(ctx, wo) };
+ break;
+ }
+ case "work_order.started":
+ case "work_order.daily_report_created":
+ case "work_order.technically_completed":
+ case "work_order.signature_missing":
+ case "work_order.missing_required": {
+ const wo = await loadWorkOrder(ctx, event.entityId);
+ if (!wo) return null;
+ Object.assign(facts, workOrderFacts(wo));
+ rule = { users: [backofficeWhere()], userIds: [] };
+ break;
+ }
+ case "work_order.released_for_billing": {
+ const wo = await loadWorkOrder(ctx, event.entityId);
+ if (!wo) return null;
+ Object.assign(facts, workOrderFacts(wo));
+ const configured = settings?.billingRecipients ?? [];
+ // In-app for billing staff; e-mail to the configured billing recipients, or — if none are
+ // configured — to the billing staff themselves.
+ rule = {
+ users: [billingWhere()],
+ userIds: [],
+ mailToUsers: configured.length === 0,
+ external: configured,
+ };
+ break;
+ }
+ case "emergency.created":
+ case "emergency.completed": {
+ const wo = await loadWorkOrder(ctx, event.entityId);
+ if (!wo) return null;
+ Object.assign(facts, workOrderFacts(wo));
+ facts.emergencyStart = dateFromData(event.data?.startedAt) ?? wo.plannedStart ?? wo.createdAt;
+ facts.emergencyEnd = event.type === "emergency.completed" ? (dateFromData(event.data?.endedAt) ?? new Date()) : null;
+ rule = { users: [backofficeWhere()], userIds: [], external: settings?.emergencyRecipients ?? [] };
+ break;
+ }
+ case "report.submitted":
+ case "report.approved":
+ case "report.rejected": {
+ const report = await ctx.db.report.findFirst({
+ where: { id: event.entityId },
+ select: { id: true, type: true, workOrderId: true, createdById: true },
+ });
+ if (!report) return null;
+ const wo = await loadWorkOrder(ctx, report.workOrderId);
+ if (!wo) return null;
+ Object.assign(facts, workOrderFacts(wo), { reportId: report.id, reportType: report.type });
+ if (event.type === "report.submitted") {
+ // data.approvalStage (set by the reports lane): "team" → team leads only,
+ // "backoffice" → back office only, unset → both.
+ const stage = event.data?.approvalStage;
+ const leadsWhere: Prisma.UserWhereInput = {
+ AND: [hasPermissionWhere("report:approve_team"), { id: { in: teamLeadIds(wo) } }],
+ };
+ if (stage === "team") rule = { users: [leadsWhere], userIds: [] };
+ else if (stage === "backoffice") rule = { users: [backofficeWhere()], userIds: [] };
+ else rule = { users: [backofficeWhere(), leadsWhere], userIds: [] };
+ } else {
+ const ids = await participantIds(ctx, wo);
+ if (report.createdById) ids.push(report.createdById);
+ rule = { users: [], userIds: ids };
+ }
+ break;
+ }
+ case "import.ready_for_review":
+ case "import.failed": {
+ const job = await ctx.db.importJob.findFirst({
+ where: { id: event.entityId },
+ select: { id: true, importedById: true, errorMessage: true, documentId: true },
+ });
+ if (!job) return null;
+ const doc = await ctx.db.document.findFirst({ where: { id: job.documentId }, select: { fileName: true } });
+ Object.assign(facts, { importJobId: job.id, fileName: doc?.fileName, errorMessage: job.errorMessage ?? undefined });
+ rule = { users: [], userIds: job.importedById ? [job.importedById] : [] };
+ break;
+ }
+ case "sync.failed": {
+ const op = await ctx.db.syncOperation.findFirst({
+ where: { id: event.entityId },
+ select: { id: true, userId: true, errorCode: true, entityType: true, entityId: true },
+ });
+ if (!op) return null;
+ facts.syncErrorCode = op.errorCode ?? (typeof event.data?.reason === "string" ? event.data.reason : undefined);
+ if (op.entityType === "work_order" && op.entityId) {
+ const wo = await loadWorkOrder(ctx, op.entityId);
+ if (wo) Object.assign(facts, workOrderFacts(wo));
+ }
+ rule = { users: [backofficeWhere()], userIds: [op.userId] };
+ break;
+ }
+ default:
+ return null;
+ }
+
+ const or: Prisma.UserWhereInput[] = [...rule.users];
+ if (rule.userIds.length) or.push({ id: { in: [...new Set(rule.userIds)] } });
+ let users = or.length ? await loadTargets(ctx, { OR: or }, settings?.locale) : [];
+
+ const keepActor = SYSTEM_RESULT_EVENTS.has(event.type);
+ if (!keepActor) users = users.filter((u) => u.userId !== ctx.userId);
+
+ const mailUserIds = new Set(rule.mailToUsers === false ? [] : users.map((u) => u.userId));
+
+ // Configured external addresses: skip those already covered by a user mail (no double mail).
+ const userMails = new Set(users.filter((u) => mailUserIds.has(u.userId)).map((u) => u.email.toLowerCase()));
+ const externalEmails = [...new Set((rule.external ?? []).map((e) => e.trim().toLowerCase()).filter(Boolean))].filter(
+ (e) => !userMails.has(e),
+ );
+
+ // Actor display name (for "{actor} hat …" texts) — tenant-bound lookup.
+ const actor = await ctx.db.user.findFirst({ where: { id: ctx.userId }, select: { name: true } });
+ facts.actorName = typeof event.data?.technician === "string" ? event.data.technician : actor?.name;
+
+ return { users, mailUserIds, externalEmails, mandatory: MANDATORY_EMAIL_EVENTS.has(event.type), facts };
+}
diff --git a/src/server/services/notifications/texts.ts b/src/server/services/notifications/texts.ts
new file mode 100644
index 0000000..23cf1d8
--- /dev/null
+++ b/src/server/services/notifications/texts.ts
@@ -0,0 +1,45 @@
+import type { EventType } from "@/lib/events";
+import type { Locale } from "@/server/mail/templates";
+// Single source for notification texts: the UI message catalog (namespace "notifications").
+// Imported statically so the same texts work in requests, workers and test scripts
+// (next-intl's request scope is not available outside a request).
+import de from "../../../../messages/de/notifications.json";
+import en from "../../../../messages/en/notifications.json";
+
+const CATALOG = { de, en } as const;
+
+export type EventKey = keyof typeof de.events;
+
+/** "work_order.assigned" → "work_order_assigned" (next-intl keys must not contain dots). */
+export function eventKey(type: EventType): EventKey {
+ return type.replace(".", "_") as EventKey;
+}
+
+function fill(template: string, vars: Record, unknown: string): string {
+ return template.replace(/\{(\w+)\}/g, (_m, key: string) => {
+ const value = vars[key];
+ return value != null && value !== "" ? value : unknown;
+ });
+}
+
+/** In-app title/message for an event in the recipient's language. */
+export function eventText(
+ locale: Locale,
+ type: EventType,
+ vars: Record,
+): { title: string; message: string } {
+ const cat = CATALOG[locale];
+ const entry = cat.events[eventKey(type)];
+ return {
+ title: fill(entry.title, vars, cat.fallback.unknown),
+ message: fill(entry.message, vars, cat.fallback.unknown),
+ };
+}
+
+export function typeLabel(locale: Locale, type: EventType): string {
+ return CATALOG[locale].types[eventKey(type)];
+}
+
+export function fallbackText(locale: Locale, key: keyof typeof de.fallback): string {
+ return CATALOG[locale].fallback[key];
+}