98 lines
3.5 KiB
TypeScript
98 lines
3.5 KiB
TypeScript
import { NextRequest, NextResponse } from "next/server";
|
|
import { z } from "zod";
|
|
import { prisma } from "@/lib/db";
|
|
import { getOwnedPlan } from "@/lib/queries";
|
|
import { getCurrentUserId } from "@/lib/session";
|
|
|
|
const scenarioSchema = z.object({
|
|
name: z.string().min(1).max(120),
|
|
branchFromPhaseId: z.string().min(1),
|
|
});
|
|
|
|
// Erstellt ein Szenario als Deep-Copy eines Plans bis zur Verzweigungsphase (inkl.).
|
|
export async function POST(
|
|
request: NextRequest,
|
|
{ params }: { params: Promise<{ planId: string }> }
|
|
) {
|
|
const userId = await getCurrentUserId();
|
|
if (!userId) return NextResponse.json({ error: "Nicht authentifiziert." }, { status: 401 });
|
|
const { planId } = await params;
|
|
|
|
const body = await request.json();
|
|
const parsed = scenarioSchema.safeParse(body);
|
|
if (!parsed.success) return NextResponse.json({ error: "Ungueltige Eingabe." }, { status: 400 });
|
|
|
|
const source = await getOwnedPlan(planId, userId);
|
|
if (!source) return NextResponse.json({ error: "Ursprungsplan nicht gefunden." }, { status: 404 });
|
|
|
|
const branchPhase = source.phases.find((p) => p.id === parsed.data.branchFromPhaseId);
|
|
if (!branchPhase) return NextResponse.json({ error: "Verzweigungsphase nicht gefunden." }, { status: 404 });
|
|
|
|
const copiedPhases = source.phases
|
|
.filter((p) => p.sequenceNumber <= branchPhase.sequenceNumber)
|
|
.sort((a, b) => a.sequenceNumber - b.sequenceNumber);
|
|
const copiedPhaseIds = new Set(copiedPhases.map((p) => p.id));
|
|
|
|
const newPlanId = await prisma.$transaction(async (tx) => {
|
|
const newPlan = await tx.plan.create({
|
|
data: {
|
|
householdId: source.householdId,
|
|
name: parsed.data.name,
|
|
retirementAgeA: source.retirementAgeA,
|
|
retirementAgeB: source.retirementAgeB,
|
|
parentPlanId: source.id,
|
|
},
|
|
});
|
|
|
|
// Phasen kopieren (alte -> neue Id).
|
|
const phaseIdMap = new Map<string, string>();
|
|
let lastNewPhaseId = "";
|
|
for (const phase of copiedPhases) {
|
|
const created = await tx.phase.create({
|
|
data: {
|
|
planId: newPlan.id,
|
|
sequenceNumber: phase.sequenceNumber,
|
|
name: phase.name,
|
|
durationYears: phase.durationYears,
|
|
inflationRate: phase.inflationRate,
|
|
},
|
|
});
|
|
phaseIdMap.set(phase.id, created.id);
|
|
lastNewPhaseId = created.id;
|
|
}
|
|
|
|
// Elemente + deren Phasen-/Uebergangswerte kopieren.
|
|
for (const el of source.elements) {
|
|
const newEl = await tx.financialElement.create({
|
|
data: {
|
|
planId: newPlan.id,
|
|
category: el.category,
|
|
name: el.name,
|
|
ownerRole: el.ownerRole,
|
|
orderIndex: el.orderIndex,
|
|
},
|
|
});
|
|
for (const pv of el.phaseValues) {
|
|
const newPhaseId = phaseIdMap.get(pv.phaseId);
|
|
if (!newPhaseId) continue;
|
|
await tx.elementPhaseValue.create({
|
|
data: { elementId: newEl.id, phaseId: newPhaseId, data: pv.data as object },
|
|
});
|
|
}
|
|
for (const tv of el.transitionValues) {
|
|
if (!copiedPhaseIds.has(tv.fromPhaseId)) continue;
|
|
const newFromId = phaseIdMap.get(tv.fromPhaseId);
|
|
if (!newFromId) continue;
|
|
await tx.elementTransitionValue.create({
|
|
data: { elementId: newEl.id, fromPhaseId: newFromId, data: tv.data as object },
|
|
});
|
|
}
|
|
}
|
|
|
|
await tx.plan.update({ where: { id: newPlan.id }, data: { branchFromPhaseId: lastNewPhaseId } });
|
|
return newPlan.id;
|
|
});
|
|
|
|
return NextResponse.json({ planId: newPlanId }, { status: 201 });
|
|
}
|