314 lines
11 KiB
TypeScript
314 lines
11 KiB
TypeScript
import Link from "next/link";
|
|
import { addMonths, getYear, getMonth, format } from "date-fns";
|
|
import { de } from "date-fns/locale";
|
|
import { ChevronLeft, ChevronRight } from "lucide-react";
|
|
|
|
import { prisma } from "@/lib/prisma";
|
|
import {
|
|
formatUtcDateKey,
|
|
getWorkingDaysOfMonth,
|
|
getTargetMonthData,
|
|
} from "@/lib/date-utils";
|
|
import { loadNotdienstDays } from "@/lib/notdienst-planning";
|
|
import { getNotdienstEmailStatus } from "@/lib/notdienst-notifications";
|
|
import { EmailStatusCard } from "./_components/email-status-card";
|
|
import { PlanView } from "./plan-view";
|
|
import { SettingsModal } from "./_components/settings-modal";
|
|
import { requireAlarmActor } from "@/lib/alarms/auth";
|
|
import { todayKey } from "@/lib/alarms/format";
|
|
|
|
export const metadata = { title: "Plan-Generierung · Kita-Planer" };
|
|
|
|
export default async function PlanungsZentralePage({
|
|
searchParams,
|
|
}: {
|
|
searchParams: Promise<{ year?: string; month?: string }>;
|
|
}) {
|
|
const actor = await requireAlarmActor();
|
|
const kitaId = actor.kitaId;
|
|
|
|
const resolvedSearchParams = await searchParams;
|
|
const now = new Date();
|
|
const defaultTarget = getTargetMonthData(now);
|
|
const targetYear = resolvedSearchParams.year
|
|
? parseInt(resolvedSearchParams.year, 10)
|
|
: defaultTarget.targetYear;
|
|
const targetMonth = resolvedSearchParams.month
|
|
? parseInt(resolvedSearchParams.month, 10)
|
|
: defaultTarget.targetMonth;
|
|
|
|
const monthDate = new Date(targetYear, targetMonth - 1, 1);
|
|
const monthName = format(monthDate, "MMMM", { locale: de });
|
|
|
|
const monthStart = new Date(Date.UTC(targetYear, targetMonth - 1, 1));
|
|
const monthEnd = new Date(Date.UTC(targetYear, targetMonth, 1));
|
|
|
|
const [plan, families, rawAvailabilities, workingDays, kita] =
|
|
await Promise.all([
|
|
prisma.notdienstPlan.findUnique({
|
|
where: {
|
|
kitaId_year_month: { kitaId, year: targetYear, month: targetMonth },
|
|
},
|
|
select: {
|
|
id: true,
|
|
status: true,
|
|
publishedAt: true,
|
|
assignments: {
|
|
select: {
|
|
id: true,
|
|
childId: true,
|
|
date: true,
|
|
createdAt: true,
|
|
alarms: {
|
|
where: { activeAssignmentId: { not: null } },
|
|
select: { id: true },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}),
|
|
prisma.family.findMany({
|
|
where: {
|
|
kitaId,
|
|
children: { some: { active: true } },
|
|
},
|
|
select: {
|
|
id: true,
|
|
name: true,
|
|
children: {
|
|
where: { active: true },
|
|
select: { id: true },
|
|
},
|
|
},
|
|
orderBy: { name: "asc" },
|
|
}),
|
|
prisma.notdienstAvailability.findMany({
|
|
where: {
|
|
kitaId,
|
|
child: { kitaId, active: true },
|
|
date: {
|
|
gte: monthStart,
|
|
lt: monthEnd,
|
|
},
|
|
},
|
|
select: {
|
|
date: true,
|
|
child: {
|
|
select: {
|
|
familyId: true,
|
|
},
|
|
},
|
|
},
|
|
orderBy: { date: "asc" },
|
|
}),
|
|
loadNotdienstDays(prisma, kitaId, targetYear, targetMonth),
|
|
prisma.kita.findUniqueOrThrow({
|
|
where: { id: kitaId },
|
|
select: {
|
|
notdienstMinPerChildPerMonth: true,
|
|
notdienstReminderDaysBefore: true,
|
|
},
|
|
}),
|
|
]);
|
|
|
|
// Wir laden auch alle aktiven Kinder (inkl. Eltern-Namen) für das manuelle Dropdown.
|
|
const allChildrenRaw = await prisma.child.findMany({
|
|
where: { kitaId, active: true },
|
|
select: {
|
|
id: true,
|
|
firstName: true,
|
|
lastName: true,
|
|
familyId: true,
|
|
family: {
|
|
select: {
|
|
name: true,
|
|
users: {
|
|
select: {
|
|
firstName: true,
|
|
lastName: true,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
orderBy: { lastName: "asc" },
|
|
});
|
|
|
|
const allChildren = allChildrenRaw.map((c) => {
|
|
const parentName =
|
|
c.family.users
|
|
.map((parent) => `${parent.firstName} ${parent.lastName}`)
|
|
.join(", ") || c.family.name;
|
|
return {
|
|
id: c.id,
|
|
name: `${c.firstName} ${c.lastName}`,
|
|
parentName,
|
|
familyId: c.familyId,
|
|
};
|
|
});
|
|
|
|
const validDateKeys = new Set(workingDays.map(formatUtcDateKey));
|
|
const availabilities = rawAvailabilities.filter((a) =>
|
|
validDateKeys.has(formatUtcDateKey(a.date)),
|
|
);
|
|
const closureCount =
|
|
getWorkingDaysOfMonth(targetYear, targetMonth).length - workingDays.length;
|
|
|
|
const availabilityDatesByFamily = new Map<string, Set<string>>();
|
|
availabilities.forEach((availability) => {
|
|
const familyId = availability.child.familyId;
|
|
const dates = availabilityDatesByFamily.get(familyId) ?? new Set<string>();
|
|
dates.add(availability.date.toISOString());
|
|
availabilityDatesByFamily.set(familyId, dates);
|
|
});
|
|
|
|
const familyStatuses = families.map((family) => {
|
|
const dates = Array.from(availabilityDatesByFamily.get(family.id) ?? []);
|
|
return {
|
|
id: family.id,
|
|
name: family.name,
|
|
selectedDays: dates.map((date) => ({
|
|
iso: date,
|
|
label: new Intl.DateTimeFormat("de-DE", {
|
|
weekday: "short",
|
|
day: "2-digit",
|
|
month: "2-digit",
|
|
}).format(new Date(date)),
|
|
})),
|
|
childCount: family.children.length,
|
|
requiredDays: family.children.length * kita.notdienstMinPerChildPerMonth,
|
|
};
|
|
});
|
|
|
|
const respondedFamilies = familyStatuses.filter(
|
|
(family) => family.selectedDays.length >= family.requiredDays,
|
|
).length;
|
|
const openFamilies = Math.max(familyStatuses.length - respondedFamilies, 0);
|
|
const totalAvailabilitySlots = availabilities.length;
|
|
const requiredDays = workingDays.length;
|
|
const coverageFactor =
|
|
requiredDays > 0 ? totalAvailabilitySlots / requiredDays : 0;
|
|
|
|
// Wir mappen die Assignments auf die Werktage
|
|
// Keep obsolete assignments visible so the coordinator can remove them.
|
|
const displayedDays = new Map(
|
|
workingDays.map((day) => [formatUtcDateKey(day), day]),
|
|
);
|
|
for (const assignment of plan?.assignments ?? []) {
|
|
displayedDays.set(formatUtcDateKey(assignment.date), assignment.date);
|
|
}
|
|
const activeChildIds = new Set(allChildren.map((child) => child.id));
|
|
const daysWithAssignments = Array.from(displayedDays.values())
|
|
.sort((a, b) => a.getTime() - b.getTime())
|
|
.map((day) => {
|
|
const assignment = plan?.assignments.find(
|
|
(a) => a.date.getTime() === day.getTime(),
|
|
);
|
|
const isOriginallyUnassigned =
|
|
!assignment ||
|
|
(plan?.publishedAt && assignment.createdAt > plan.publishedAt);
|
|
|
|
const isInvalid =
|
|
!validDateKeys.has(formatUtcDateKey(day)) ||
|
|
(!!assignment && !activeChildIds.has(assignment.childId));
|
|
return {
|
|
date: day.toISOString(),
|
|
isInvalid,
|
|
assignmentId: assignment?.id || null,
|
|
childId: assignment?.childId || null,
|
|
isOriginallyUnassigned: !!isOriginallyUnassigned,
|
|
activeAlarmId: assignment?.alarms[0]?.id ?? null,
|
|
canAlarm:
|
|
!!assignment &&
|
|
!isInvalid &&
|
|
plan?.status === "PUBLISHED" &&
|
|
day.toISOString().slice(0, 10) >= todayKey(),
|
|
};
|
|
});
|
|
|
|
const mailStatus = await getNotdienstEmailStatus(
|
|
kitaId,
|
|
targetYear,
|
|
targetMonth,
|
|
);
|
|
const target = getTargetMonthData(now);
|
|
const remindersOpen =
|
|
!target.isLocked &&
|
|
target.targetYear === targetYear &&
|
|
target.targetMonth === targetMonth &&
|
|
plan?.status !== "PUBLISHED";
|
|
|
|
return (
|
|
<div className="mx-auto max-w-[1280px] px-11 py-9 pb-16 max-[760px]:px-5">
|
|
<header className="mb-7 flex items-end justify-between gap-8 max-[900px]:items-start max-[900px]:flex-col">
|
|
<div>
|
|
<p className="text-[11px] font-semibold uppercase text-[var(--accent-deep)] [letter-spacing:0.18em]">
|
|
NOTDIENST · PLANUNG
|
|
</p>
|
|
<h1 className="mt-2 text-[36px] font-normal leading-tight tracking-[-0.025em] text-[var(--ink)]">
|
|
Notdienst{" "}
|
|
<em className="font-normal italic text-[var(--accent-deep)]">
|
|
zuweisen
|
|
</em>
|
|
</h1>
|
|
<p className="mt-2 max-w-2xl text-[15px] leading-6 text-[var(--ink-soft)]">
|
|
Koordiniere und generiere den Notdienst-Plan.
|
|
</p>
|
|
</div>
|
|
|
|
<div className="print:hidden flex flex-wrap items-center gap-2">
|
|
<div className="inline-flex overflow-hidden rounded-full border border-[var(--hairline)] bg-[var(--surface)]">
|
|
<Link
|
|
href={`/dashboard/notdienst/plan?year=${getYear(addMonths(monthDate, -1))}&month=${getMonth(addMonths(monthDate, -1)) + 1}`}
|
|
className="inline-flex h-9 w-9 items-center justify-center border-r border-[var(--hairline-soft)] text-[var(--ink-soft)] hover:bg-[var(--surface-2)] hover:text-[var(--ink)] transition"
|
|
>
|
|
<ChevronLeft className="h-4 w-4 [stroke-width:1.7]" />
|
|
</Link>
|
|
<div className="flex h-9 min-w-36 items-center justify-center px-4 text-[13px] font-semibold text-[var(--ink)]">
|
|
{monthName} {targetYear}
|
|
</div>
|
|
<Link
|
|
href={`/dashboard/notdienst/plan?year=${getYear(addMonths(monthDate, 1))}&month=${getMonth(addMonths(monthDate, 1)) + 1}`}
|
|
className="inline-flex h-9 w-9 items-center justify-center border-l border-[var(--hairline-soft)] text-[var(--ink-soft)] hover:bg-[var(--surface-2)] hover:text-[var(--ink)] transition"
|
|
>
|
|
<ChevronRight className="h-4 w-4 [stroke-width:1.7]" />
|
|
</Link>
|
|
</div>
|
|
<SettingsModal
|
|
initialMinPerChild={kita.notdienstMinPerChildPerMonth}
|
|
initialReminderDays={kita.notdienstReminderDaysBefore}
|
|
/>
|
|
</div>
|
|
</header>
|
|
|
|
<EmailStatusCard
|
|
status={mailStatus}
|
|
year={targetYear}
|
|
month={targetMonth}
|
|
remindersOpen={remindersOpen}
|
|
daysBefore={kita.notdienstReminderDaysBefore}
|
|
jobConfigured={(process.env.NOTDIENST_JOB_SECRET?.length ?? 0) >= 32}
|
|
/>
|
|
|
|
<PlanView
|
|
planId={plan?.id}
|
|
remindersOpen={remindersOpen}
|
|
status={plan?.status}
|
|
days={daysWithAssignments}
|
|
allChildren={allChildren}
|
|
familyStatuses={familyStatuses}
|
|
requiredDays={requiredDays}
|
|
respondedFamilies={respondedFamilies}
|
|
openFamilies={openFamilies}
|
|
totalFamilies={familyStatuses.length}
|
|
totalAvailabilitySlots={totalAvailabilitySlots}
|
|
coverageFactor={coverageFactor}
|
|
closureCount={closureCount}
|
|
monthName={monthName}
|
|
year={targetYear}
|
|
month={targetMonth}
|
|
/>
|
|
</div>
|
|
);
|
|
}
|