480 lines
13 KiB
TypeScript
480 lines
13 KiB
TypeScript
"use server";
|
|
|
|
import { revalidatePath } from "next/cache";
|
|
import { Prisma, UserRole } from "@prisma/client";
|
|
import { z } from "zod";
|
|
|
|
import { requireRole } from "@/lib/auth-utils";
|
|
import {
|
|
deliverFamilyInvitations,
|
|
queueFamilyInvitation,
|
|
resendFamilyInvitation,
|
|
} from "@/lib/family-invitations";
|
|
import { prisma } from "@/lib/prisma";
|
|
|
|
const childSchema = z.object({
|
|
firstName: z.string().trim().min(1, "Vorname des Kindes fehlt.").max(100),
|
|
lastName: z.string().trim().min(1, "Nachname des Kindes fehlt.").max(100),
|
|
});
|
|
|
|
const parentInputSchema = z.object({
|
|
firstName: z.string().trim().min(1, "Vorname ist erforderlich.").max(100),
|
|
lastName: z.string().trim().min(1, "Nachname ist erforderlich.").max(100),
|
|
email: z
|
|
.string()
|
|
.trim()
|
|
.toLowerCase()
|
|
.email("Bitte eine gültige E-Mail-Adresse angeben."),
|
|
});
|
|
|
|
const addFamilySchema = z.object({
|
|
familyName: z
|
|
.string()
|
|
.trim()
|
|
.min(1, "Familienname ist erforderlich.")
|
|
.max(120),
|
|
parent1FirstName: z
|
|
.string()
|
|
.trim()
|
|
.min(1, "Vorname ist erforderlich.")
|
|
.max(100),
|
|
parent1LastName: z
|
|
.string()
|
|
.trim()
|
|
.min(1, "Nachname ist erforderlich.")
|
|
.max(100),
|
|
parent1Email: z
|
|
.string()
|
|
.trim()
|
|
.toLowerCase()
|
|
.email("Bitte eine gültige E-Mail-Adresse angeben."),
|
|
parent2FirstName: z.string().max(100).trim().optional(),
|
|
parent2LastName: z.string().max(100).trim().optional(),
|
|
parent2Email: z.string().trim().optional(),
|
|
childCount: z.coerce
|
|
.number()
|
|
.int()
|
|
.min(1, "Mindestens ein Kind erforderlich.")
|
|
.max(10),
|
|
});
|
|
|
|
const updateFamilySchema = z.object({
|
|
familyId: z.string().min(1),
|
|
familyName: z
|
|
.string()
|
|
.trim()
|
|
.min(1, "Familienname ist erforderlich.")
|
|
.max(120),
|
|
parents: z
|
|
.array(
|
|
parentInputSchema.extend({
|
|
id: z.string().min(1),
|
|
}),
|
|
)
|
|
.min(1)
|
|
.max(2),
|
|
newParents: z.array(parentInputSchema).max(1).default([]),
|
|
children: z
|
|
.array(
|
|
childSchema.extend({
|
|
id: z.string().min(1),
|
|
}),
|
|
)
|
|
.max(20),
|
|
newChildren: z.array(childSchema).max(10).default([]),
|
|
removedChildIds: z.array(z.string().min(1)).max(20).default([]),
|
|
});
|
|
|
|
export type AddFamilyState = {
|
|
errors?: {
|
|
familyName?: string[];
|
|
parent1FirstName?: string[];
|
|
parent1LastName?: string[];
|
|
parent1Email?: string[];
|
|
parent2FirstName?: string[];
|
|
parent2LastName?: string[];
|
|
parent2Email?: string[];
|
|
children?: string[];
|
|
_form?: string[];
|
|
};
|
|
success?: boolean;
|
|
warning?: string;
|
|
};
|
|
|
|
function optionalParentFromForm(data: z.infer<typeof addFamilySchema>) {
|
|
const firstName = data.parent2FirstName?.trim() ?? "";
|
|
const lastName = data.parent2LastName?.trim() ?? "";
|
|
const email = data.parent2Email?.trim() ?? "";
|
|
|
|
if (!firstName && !lastName && !email) {
|
|
return { ok: true as const, parent: null };
|
|
}
|
|
|
|
const parsed = parentInputSchema.safeParse({ firstName, lastName, email });
|
|
if (!parsed.success) {
|
|
return {
|
|
ok: false as const,
|
|
errors: {
|
|
parent2FirstName: parsed.error.flatten().fieldErrors.firstName,
|
|
parent2LastName: parsed.error.flatten().fieldErrors.lastName,
|
|
parent2Email: parsed.error.flatten().fieldErrors.email,
|
|
},
|
|
};
|
|
}
|
|
|
|
return { ok: true as const, parent: parsed.data };
|
|
}
|
|
|
|
async function sendInviteJobs(ids: string[]) {
|
|
try {
|
|
const result = await deliverFamilyInvitations(ids);
|
|
if (!result.failed) return undefined;
|
|
} catch {
|
|
// A committed family remains successful even if delivery/status storage fails.
|
|
}
|
|
return "Familie gespeichert. Mindestens eine Einladung konnte nicht versendet werden. Den Versand kannst du beim jeweiligen Elternteil erneut versuchen.";
|
|
}
|
|
|
|
export async function addFamilyAction(
|
|
_prev: AddFamilyState,
|
|
formData: FormData,
|
|
): Promise<AddFamilyState> {
|
|
const session = await requireRole([UserRole.ADMIN]);
|
|
const kitaId = session.user.kitaId;
|
|
|
|
if (!kitaId) {
|
|
return { errors: { _form: ["Kein Mandant zugeordnet."] } };
|
|
}
|
|
|
|
const parsedFamily = addFamilySchema.safeParse(Object.fromEntries(formData));
|
|
if (!parsedFamily.success) {
|
|
return { errors: parsedFamily.error.flatten().fieldErrors };
|
|
}
|
|
|
|
const optionalParent = optionalParentFromForm(parsedFamily.data);
|
|
if (!optionalParent.ok) {
|
|
return { errors: optionalParent.errors };
|
|
}
|
|
|
|
const childrenRaw: z.infer<typeof childSchema>[] = [];
|
|
for (let i = 0; i < parsedFamily.data.childCount; i++) {
|
|
const parsed = childSchema.safeParse({
|
|
firstName: formData.get(`childFirstName_${i}`),
|
|
lastName: formData.get(`childLastName_${i}`),
|
|
});
|
|
|
|
if (!parsed.success) {
|
|
return {
|
|
errors: {
|
|
children: [
|
|
`Kind ${i + 1}: ${Object.values(parsed.error.flatten().fieldErrors).flat().join(", ")}`,
|
|
],
|
|
},
|
|
};
|
|
}
|
|
childrenRaw.push(parsed.data);
|
|
}
|
|
|
|
const kita = await prisma.kita.findUnique({
|
|
where: { id: kitaId },
|
|
select: { name: true },
|
|
});
|
|
|
|
if (!kita) {
|
|
return { errors: { _form: ["Kita wurde nicht gefunden."] } };
|
|
}
|
|
|
|
const parents = [
|
|
{
|
|
firstName: parsedFamily.data.parent1FirstName,
|
|
lastName: parsedFamily.data.parent1LastName,
|
|
email: parsedFamily.data.parent1Email,
|
|
},
|
|
...(optionalParent.parent ? [optionalParent.parent] : []),
|
|
];
|
|
const emailSet = new Set(parents.map((parent) => parent.email));
|
|
if (emailSet.size !== parents.length) {
|
|
return {
|
|
errors: {
|
|
_form: [
|
|
"Die E-Mail-Adressen der Elternteile müssen unterschiedlich sein.",
|
|
],
|
|
},
|
|
};
|
|
}
|
|
|
|
const inviteJobs: string[] = [];
|
|
|
|
try {
|
|
await prisma.$transaction(async (tx) => {
|
|
const family = await tx.family.create({
|
|
data: {
|
|
kitaId,
|
|
name: parsedFamily.data.familyName,
|
|
},
|
|
});
|
|
|
|
for (const parent of parents) {
|
|
const createdParent = await tx.user.create({
|
|
data: {
|
|
kitaId,
|
|
familyId: family.id,
|
|
email: parent.email,
|
|
firstName: parent.firstName,
|
|
lastName: parent.lastName,
|
|
passwordHash: "",
|
|
role: UserRole.ELTERN,
|
|
},
|
|
});
|
|
const invite = await queueFamilyInvitation(
|
|
tx,
|
|
createdParent.id,
|
|
session.user.id,
|
|
);
|
|
inviteJobs.push(invite.id);
|
|
}
|
|
|
|
await tx.child.createMany({
|
|
data: childrenRaw.map((child) => ({
|
|
kitaId,
|
|
familyId: family.id,
|
|
firstName: child.firstName,
|
|
lastName: child.lastName,
|
|
})),
|
|
});
|
|
});
|
|
} catch (err) {
|
|
if (
|
|
err instanceof Prisma.PrismaClientKnownRequestError &&
|
|
err.code === "P2002"
|
|
) {
|
|
return {
|
|
errors: {
|
|
_form: ["Mindestens eine E-Mail-Adresse existiert bereits."],
|
|
},
|
|
};
|
|
}
|
|
console.error("Familie konnte nicht angelegt werden:", err);
|
|
return {
|
|
errors: {
|
|
_form: [
|
|
"Familie konnte nicht angelegt werden. Bitte erneut versuchen.",
|
|
],
|
|
},
|
|
};
|
|
}
|
|
|
|
const warning = await sendInviteJobs(inviteJobs);
|
|
revalidatePath("/dashboard/families");
|
|
revalidatePath("/dashboard");
|
|
return { success: true, warning };
|
|
}
|
|
|
|
export async function updateFamilyAction(
|
|
rawPayload: unknown,
|
|
): Promise<{ success?: boolean; error?: string; warning?: string }> {
|
|
const session = await requireRole([UserRole.ADMIN]);
|
|
const kitaId = session.user.kitaId;
|
|
|
|
if (!kitaId) {
|
|
return { error: "Kein Mandant zugeordnet." };
|
|
}
|
|
|
|
const parsed = updateFamilySchema.safeParse(rawPayload);
|
|
if (!parsed.success) {
|
|
return { error: "Ungültige Eingabedaten." };
|
|
}
|
|
|
|
const {
|
|
familyId,
|
|
familyName,
|
|
parents,
|
|
newParents,
|
|
children,
|
|
newChildren,
|
|
removedChildIds,
|
|
} = parsed.data;
|
|
|
|
const parentEmails = [...parents, ...newParents].map(
|
|
(parent) => parent.email,
|
|
);
|
|
if (new Set(parentEmails).size !== parentEmails.length) {
|
|
return {
|
|
error: "Die E-Mail-Adressen der Elternteile müssen unterschiedlich sein.",
|
|
};
|
|
}
|
|
|
|
const removedChildIdSet = new Set(removedChildIds);
|
|
const activeChildren = children.filter(
|
|
(child) => !removedChildIdSet.has(child.id),
|
|
);
|
|
if (activeChildren.length + newChildren.length === 0) {
|
|
return { error: "Eine Familie benötigt mindestens ein Kind." };
|
|
}
|
|
|
|
const kita = await prisma.kita.findUnique({
|
|
where: { id: kitaId },
|
|
select: { name: true },
|
|
});
|
|
|
|
if (!kita) {
|
|
return { error: "Kita wurde nicht gefunden." };
|
|
}
|
|
|
|
const inviteJobs: string[] = [];
|
|
|
|
try {
|
|
const existingFamily = await prisma.family.findFirst({
|
|
where: { id: familyId, kitaId },
|
|
select: {
|
|
id: true,
|
|
users: { select: { id: true } },
|
|
children: { select: { id: true } },
|
|
},
|
|
});
|
|
|
|
if (!existingFamily) {
|
|
return { error: "Familie wurde nicht gefunden." };
|
|
}
|
|
|
|
const existingParentIds = new Set(
|
|
existingFamily.users.map((user) => user.id),
|
|
);
|
|
const existingChildIds = new Set(
|
|
existingFamily.children.map((child) => child.id),
|
|
);
|
|
|
|
if (!parents.every((parent) => existingParentIds.has(parent.id))) {
|
|
return {
|
|
error: "Mindestens ein Elternteil gehört nicht zu dieser Familie.",
|
|
};
|
|
}
|
|
|
|
if (!children.every((child) => existingChildIds.has(child.id))) {
|
|
return { error: "Mindestens ein Kind gehört nicht zu dieser Familie." };
|
|
}
|
|
|
|
if (!removedChildIds.every((childId) => existingChildIds.has(childId))) {
|
|
return { error: "Mindestens ein Kind gehört nicht zu dieser Familie." };
|
|
}
|
|
|
|
if (existingParentIds.size + newParents.length > 2) {
|
|
return { error: "Pro Familie sind maximal zwei Elternteile vorgesehen." };
|
|
}
|
|
|
|
await prisma.$transaction(async (tx) => {
|
|
await tx.family.update({
|
|
where: { id: familyId },
|
|
data: { name: familyName },
|
|
});
|
|
|
|
for (const parent of parents) {
|
|
const previous = await tx.user.findUniqueOrThrow({
|
|
where: { id: parent.id },
|
|
});
|
|
await tx.user.update({
|
|
where: { id: parent.id },
|
|
data: {
|
|
firstName: parent.firstName,
|
|
lastName: parent.lastName,
|
|
email: parent.email,
|
|
},
|
|
});
|
|
if (!previous.emailVerifiedAt && previous.email !== parent.email) {
|
|
const invite = await queueFamilyInvitation(
|
|
tx,
|
|
parent.id,
|
|
session.user.id,
|
|
);
|
|
inviteJobs.push(invite.id);
|
|
}
|
|
}
|
|
|
|
for (const parent of newParents) {
|
|
const createdParent = await tx.user.create({
|
|
data: {
|
|
kitaId,
|
|
familyId,
|
|
email: parent.email,
|
|
firstName: parent.firstName,
|
|
lastName: parent.lastName,
|
|
passwordHash: "",
|
|
role: UserRole.ELTERN,
|
|
},
|
|
});
|
|
const invite = await queueFamilyInvitation(
|
|
tx,
|
|
createdParent.id,
|
|
session.user.id,
|
|
);
|
|
inviteJobs.push(invite.id);
|
|
}
|
|
|
|
for (const child of activeChildren) {
|
|
await tx.child.update({
|
|
where: { id: child.id },
|
|
data: {
|
|
firstName: child.firstName,
|
|
lastName: child.lastName,
|
|
},
|
|
});
|
|
}
|
|
|
|
for (const childId of removedChildIds) {
|
|
await tx.child.delete({ where: { id: childId } });
|
|
}
|
|
|
|
for (const child of newChildren) {
|
|
await tx.child.create({
|
|
data: {
|
|
kitaId,
|
|
familyId,
|
|
firstName: child.firstName,
|
|
lastName: child.lastName,
|
|
},
|
|
});
|
|
}
|
|
});
|
|
} catch (error) {
|
|
if (
|
|
error instanceof Prisma.PrismaClientKnownRequestError &&
|
|
error.code === "P2002"
|
|
) {
|
|
return { error: "Mindestens eine E-Mail-Adresse existiert bereits." };
|
|
}
|
|
|
|
console.error("Fehler beim Aktualisieren der Familie:", error);
|
|
return { error: "Familie konnte nicht aktualisiert werden." };
|
|
}
|
|
|
|
const warning = await sendInviteJobs(inviteJobs);
|
|
revalidatePath("/dashboard/families");
|
|
revalidatePath("/dashboard/profil");
|
|
revalidatePath("/dashboard/notdienst");
|
|
revalidatePath("/dashboard");
|
|
return { success: true, warning };
|
|
}
|
|
|
|
export async function resendFamilyInvitationAction(
|
|
userId: string,
|
|
): Promise<{ success?: boolean; error?: string; warning?: string }> {
|
|
const session = await requireRole([UserRole.ADMIN]);
|
|
if (!session.user.kitaId || typeof userId !== "string" || !userId)
|
|
return { error: "Ungültiges Elternkonto." };
|
|
let result;
|
|
try {
|
|
result = await resendFamilyInvitation(
|
|
session.user.kitaId,
|
|
userId,
|
|
session.user.id,
|
|
);
|
|
} catch {
|
|
result = {
|
|
error:
|
|
"Einladung konnte nicht erneut versendet werden. Bitte den Status prüfen und erneut versuchen.",
|
|
};
|
|
}
|
|
revalidatePath("/dashboard/families");
|
|
return result;
|
|
}
|