Initial commit: FPT Financial Planning Tool

2026-07-08 19:19:39 +02:00
commit 4f990c9686
60 changed files with 12436 additions and 0 deletions
@@ -0,0 +1,120 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import { prisma } from "@/lib/db";
+import { phaseInclude, planInclude } from "@/lib/queries";
+
+const scenarioSchema = z.object({
+  name: z.string().min(1).max(120),
+  branchFromPhaseId: z.string().min(1),
+});
+
+// Erstellt ein neues Szenario als Kopie eines bestehenden Plans ab einer gewaehlten
+// Phase (inklusive). Die Phasenkette bis zu diesem Punkt wird per Deep-Copy dupliziert;
+// ab dort kann der Benutzer die Kette unabhaengig weiterentwickeln (TDD Kapitel 13).
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ planId: string }> }
+) {
+  const { planId } = await params;
+  const body = await request.json();
+  const parsed = scenarioSchema.safeParse(body);
+  if (!parsed.success) {
+    return NextResponse.json({ error: parsed.error.flatten() }, { status: 400 });
+  }
+
+  const sourcePlan = await prisma.plan.findUnique({ where: { id: planId }, include: planInclude });
+  if (!sourcePlan) {
+    return NextResponse.json({ error: "Ursprungsplan nicht gefunden." }, { status: 404 });
+  }
+
+  const branchPhase = sourcePlan.phases.find((p) => p.id === parsed.data.branchFromPhaseId);
+  if (!branchPhase) {
+    return NextResponse.json({ error: "Verzweigungsphase nicht gefunden." }, { status: 404 });
+  }
+
+  const phasesToCopy = sourcePlan.phases
+    .filter((p) => p.sequenceNumber <= branchPhase.sequenceNumber)
+    .sort((a, b) => a.sequenceNumber - b.sequenceNumber);
+
+  const newPlanId = await prisma.$transaction(async (tx) => {
+    const newPlan = await tx.plan.create({
+      data: {
+        householdId: sourcePlan.householdId,
+        name: parsed.data.name,
+        parentPlanId: sourcePlan.id,
+      },
+    });
+
+    let lastNewPhaseId = "";
+    for (const phase of phasesToCopy) {
+      const newPhase = await tx.phase.create({
+        data: {
+          planId: newPlan.id,
+          sequenceNumber: phase.sequenceNumber,
+          name: phase.name,
+          durationYears: phase.durationYears,
+          inflationRate: phase.inflationRate,
+          incomeMode: phase.incomeMode,
+          incomeEntries: {
+            create: phase.incomeEntries.map((e) => ({
+              personId: e.personId,
+              label: e.label,
+              amount: e.amount,
+            })),
+          },
+          expenseEntries: {
+            create: phase.expenseEntries.map((e) => ({ label: e.label, amount: e.amount })),
+          },
+          securities: {
+            create: phase.securities.map((s) => ({
+              name: s.name,
+              startValue: s.startValue,
+              expectedReturn: s.expectedReturn,
+              annualContribution: s.annualContribution,
+              ownerTag: s.ownerTag,
+              saleTaxRate: s.saleTaxRate,
+            })),
+          },
+          realEstates: {
+            create: phase.realEstates.map((re) => ({
+              name: re.name,
+              marketValue: re.marketValue,
+              mortgage: re.mortgage,
+              valueGrowth: re.valueGrowth,
+              amortization: re.amortization,
+              salePrice: re.salePrice,
+              saleTaxRate: re.saleTaxRate,
+            })),
+          },
+          oneTimeEvents: {
+            create: phase.oneTimeEvents.map((e) => ({
+              type: e.type,
+              amount: e.amount,
+              description: e.description,
+            })),
+          },
+          retirementInfos: {
+            create: phase.retirementInfos.map((r) => ({
+              personId: r.personId,
+              ahvAmount: r.ahvAmount,
+              pkPensionAmount: r.pkPensionAmount,
+              lumpSumAmount: r.lumpSumAmount,
+              lumpSumTaxRate: r.lumpSumTaxRate,
+            })),
+          },
+        },
+        include: phaseInclude,
+      });
+      lastNewPhaseId = newPhase.id;
+    }
+
+    await tx.plan.update({
+      where: { id: newPlan.id },
+      data: { branchFromPhaseId: lastNewPhaseId },
+    });
+
+    return newPlan.id;
+  });
+
+  return NextResponse.json({ planId: newPlanId }, { status: 201 });
+}