Rework core model: financial elements as plan-wide entities across phases; derived phase types (Erwerb/Pension/Misch) with retirement-capped durations and per-plan retirement age; AHV (gap years + couple ceiling), PK payout/annuity, 3a, real estate, other assets/debts; horizontal timeline with retirement markers; phase x element matrix with detail panel; savings/consumption quota + available-capital key figures with red status

src/app/api/plans/[planId]/elements/route.ts

@@ -0,0 +1,69 @@
+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";
+import { PERSON_ONLY_CATEGORIES } from "@/lib/elements";
+
+const createSchema = z.object({
+  category: z.enum([
+    "INCOME",
+    "EXPENSE",
+    "AHV",
+    "PENSION_FUND",
+    "PILLAR_3A",
+    "REAL_ESTATE",
+    "OTHER_ASSET",
+    "OTHER_DEBT",
+  ]),
+  name: z.string().min(1).max(120),
+  ownerRole: z.enum(["PERSON_A", "PERSON_B", "HOUSEHOLD"]).nullable().optional(),
+});
+
+// Legt ein neues finanzielles Element (plan-weit) an. Personen-Pflicht je Kategorie.
+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 plan = await getOwnedPlan(planId, userId);
+  if (!plan) return NextResponse.json({ error: "Plan nicht gefunden." }, { status: 404 });
+
+  const body = await request.json();
+  const parsed = createSchema.safeParse(body);
+  if (!parsed.success) return NextResponse.json({ error: "Ungueltige Eingabe." }, { status: 400 });
+
+  const { category, name } = parsed.data;
+  let ownerRole = parsed.data.ownerRole ?? null;
+
+  if (PERSON_ONLY_CATEGORIES.includes(category)) {
+    if (ownerRole !== "PERSON_A" && ownerRole !== "PERSON_B") {
+      return NextResponse.json(
+        { error: "Diese Kategorie muss einer Person zugeordnet werden." },
+        { status: 400 }
+      );
+    }
+  } else if (ownerRole == null) {
+    ownerRole = "HOUSEHOLD";
+  }
+
+  const maxOrder = await prisma.financialElement.aggregate({
+    where: { planId: plan.id },
+    _max: { orderIndex: true },
+  });
+
+  const element = await prisma.financialElement.create({
+    data: {
+      planId: plan.id,
+      category,
+      name,
+      ownerRole,
+      orderIndex: (maxOrder._max.orderIndex ?? 0) + 1,
+    },
+  });
+
+  return NextResponse.json({ element: { id: element.id } }, { status: 201 });
+}

src/app/api/plans/[planId]/phases/route.ts

@@ -1,72 +1,116 @@
 import { NextRequest, NextResponse } from "next/server";
 import { z } from "zod";
 import { prisma } from "@/lib/db";
-import { phaseInclude } from "@/lib/queries";
+import { getHouseholdOrNull, getOwnedPlan, toHouseholdInput, toPlanInput } from "@/lib/queries";
 import { getCurrentUserId } from "@/lib/session";
+import { Prisma } from "@/generated/prisma/client";
+import { computePlan, maxPhaseDuration } from "@/lib/calculations";
+import { num, type PhaseData } from "@/lib/elements";
 
 const createPhaseSchema = z.object({
-  name: z.string().min(1).max(120),
-  durationYears: z.number().int().min(1).max(80),
-  inflationRate: z.number().min(-20).max(50).nullable().optional(),
-  incomeMode: z.enum(["PER_PERSON", "HOUSEHOLD"]).default("HOUSEHOLD"),
+  name: z.string().min(1).max(120).optional(),
+  durationYears: z.number().int().min(1).max(80).optional(),
 });
 
-// Fuegt eine neue Lebensabschnittsphase am Ende der Phasenkette eines Plans an
-// (TDD Kapitel 3: Phasen werden chronologisch aneinandergereiht).
+// Legt eine neue Lebensphase am Ende der Kette an. Die Dauer wird ans naechste
+// Pensionsereignis gekappt. Fuer bestehende Elemente werden die Werte 1:1 bzw. mit
+// den fortgeschriebenen Endbestaenden aus der Vorphase vorbelegt.
 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 });
-  }
+  if (!userId) return NextResponse.json({ error: "Nicht authentifiziert." }, { status: 401 });
   const { planId } = await params;
-  const body = await request.json();
+
+  const household = await getHouseholdOrNull(userId);
+  if (!household) return NextResponse.json({ error: "Kein Haushalt vorhanden." }, { status: 400 });
+  const plan = await getOwnedPlan(planId, userId);
+  if (!plan) return NextResponse.json({ error: "Plan nicht gefunden." }, { status: 404 });
+
+  const body = await request.json().catch(() => ({}));
   const parsed = createPhaseSchema.safeParse(body);
-  if (!parsed.success) {
-    return NextResponse.json({ error: parsed.error.flatten() }, { status: 400 });
-  }
+  if (!parsed.success) return NextResponse.json({ error: "Ungueltige Eingabe." }, { status: 400 });
 
-  const plan = await prisma.plan.findFirst({ where: { id: planId, household: { userId } } });
-  if (!plan) {
-    return NextResponse.json({ error: "Plan nicht gefunden." }, { status: 404 });
-  }
+  const householdInput = toHouseholdInput(household);
+  const planInput = toPlanInput(plan);
+  const yearsBefore = planInput.phases.reduce((s, p) => s + p.durationYears, 0);
+  const cap = maxPhaseDuration(household.persons, planInput, yearsBefore);
 
-  const lastPhase = await prisma.phase.findFirst({
-    where: { planId },
-    orderBy: { sequenceNumber: "desc" },
-    include: { incomeEntries: true, expenseEntries: true },
+  let duration = parsed.data.durationYears ?? (cap ?? 10);
+  if (cap != null) duration = Math.min(duration, cap);
+  duration = Math.max(1, duration);
+
+  const nextSequence = planInput.phases.length + 1;
+
+  // Phasentyp der neuen Phase fuer den Default-Namen bestimmen.
+  const anyRetiredAtStart = household.persons.some((p) => {
+    const ra = p.role === "PERSON_A" ? planInput.retirementAgeA ?? p.retirementAge : planInput.retirementAgeB ?? p.retirementAge;
+    return p.age + yearsBefore >= ra;
   });
-  const nextSequence = (lastPhase?.sequenceNumber ?? 0) + 1;
+  const defaultName =
+    parsed.data.name ?? (nextSequence === 1 ? "Erste Lebensphase" : anyRetiredAtStart ? "Pensionsphase" : "Erwerbsphase");
 
-  // Einkommen und Ausgaben werden 1:1 aus der letzten Phase uebernommen (manuell
-  // anpassbar), damit man sie nicht bei jeder neuen Phase erneut eintippen muss.
-  const phase = await prisma.phase.create({
-    data: {
-      planId,
-      sequenceNumber: nextSequence,
-      name: parsed.data.name,
-      durationYears: parsed.data.durationYears,
-      inflationRate: parsed.data.inflationRate ?? null,
-      incomeMode: lastPhase?.incomeMode ?? parsed.data.incomeMode,
-      incomeEntries: lastPhase
-        ? {
-            create: lastPhase.incomeEntries.map((e) => ({
-              personId: e.personId,
-              label: e.label,
-              amount: e.amount,
-            })),
-          }
-        : undefined,
-      expenseEntries: lastPhase
-        ? {
-            create: lastPhase.expenseEntries.map((e) => ({ label: e.label, amount: e.amount })),
-          }
-        : undefined,
-    },
-    include: phaseInclude,
+  // Endbestaende der bisher letzten Phase (fuer Carry-Vorbelegung).
+  const prevComputed = planInput.phases.length > 0 ? computePlan(planInput, householdInput) : null;
+  const lastPhaseId = planInput.phases.at(-1)?.id;
+  const prevPhase = prevComputed?.phases.find((p) => p.id === lastPhaseId) ?? null;
+  const prevElemById = new Map((prevPhase?.elements ?? []).map((e) => [e.elementId, e]));
+
+  const phase = await prisma.$transaction(async (tx) => {
+    const created = await tx.phase.create({
+      data: {
+        planId: plan.id,
+        sequenceNumber: nextSequence,
+        name: defaultName,
+        durationYears: duration,
+      },
+    });
+
+    // Carry-Vorbelegung fuer bestehende Elemente.
+    for (const e of planInput.elements) {
+      const prev = prevElemById.get(e.id);
+      if (prev && prev.status !== "ACTIVE") continue; // verkauft/getilgt -> nicht mehr fortfuehren
+      const prevData: PhaseData = e.phaseValues[lastPhaseId ?? ""] ?? {};
+      const data: PhaseData = buildCarryData(e.category, prevData, prev?.endValue);
+      await tx.elementPhaseValue.create({
+        data: { elementId: e.id, phaseId: created.id, data: data as Prisma.InputJsonValue },
+      });
+    }
+
+    return created;
   });
 
-  return NextResponse.json({ phase }, { status: 201 });
+  return NextResponse.json({ phase: { id: phase.id } }, { status: 201 });
+}
+
+function buildCarryData(
+  category: string,
+  prev: PhaseData,
+  prevEndValue: number | undefined
+): PhaseData {
+  const endVal = Math.max(0, Math.round(prevEndValue ?? 0));
+  switch (category) {
+    case "INCOME":
+    case "EXPENSE":
+      return { amount: num(prev.amount) };
+    case "AHV":
+      return { gapYears: 0 };
+    case "PENSION_FUND":
+    case "PILLAR_3A":
+      return { currentValue: endVal, annualContribution: num(prev.annualContribution), expectedReturn: num(prev.expectedReturn) };
+    case "OTHER_ASSET":
+      return { startValue: endVal, annualContribution: num(prev.annualContribution), expectedReturn: num(prev.expectedReturn) };
+    case "REAL_ESTATE":
+      // endValue = purchase - mortgage; Hypothek fortschreiben ueber purchasePrice - endValue.
+      return {
+        purchasePrice: num(prev.purchasePrice),
+        mortgage: Math.max(0, num(prev.purchasePrice) - endVal),
+        amortization: num(prev.amortization),
+      };
+    case "OTHER_DEBT":
+      return { startValue: Math.abs(endVal), annualRepayment: num(prev.annualRepayment) };
+    default:
+      return {};
+  }
 }

src/app/api/plans/[planId]/route.ts

@@ -1,4 +1,5 @@
 import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
 import { prisma } from "@/lib/db";
 import { toHouseholdInput, toPlanInput, getHouseholdOrNull, getOwnedPlan } from "@/lib/queries";
 import { getCurrentUserId } from "@/lib/session";
@@ -9,19 +10,14 @@ export async function GET(
   { params }: { params: Promise<{ planId: string }> }
 ) {
   const userId = await getCurrentUserId();
-  if (!userId) {
-    return NextResponse.json({ error: "Nicht authentifiziert." }, { status: 401 });
-  }
+  if (!userId) return NextResponse.json({ error: "Nicht authentifiziert." }, { status: 401 });
   const { planId } = await params;
+
   const household = await getHouseholdOrNull(userId);
-  if (!household) {
-    return NextResponse.json({ error: "Kein Haushalt vorhanden." }, { status: 400 });
-  }
+  if (!household) return NextResponse.json({ error: "Kein Haushalt vorhanden." }, { status: 400 });
 
   const plan = await getOwnedPlan(planId, userId);
-  if (!plan) {
-    return NextResponse.json({ error: "Plan nicht gefunden." }, { status: 404 });
-  }
+  if (!plan) return NextResponse.json({ error: "Plan nicht gefunden." }, { status: 404 });
 
   const householdInput = toHouseholdInput(household);
   const planInput = toPlanInput(plan);
@@ -30,19 +26,47 @@ export async function GET(
   return NextResponse.json({ plan: planInput, computed });
 }
 
+const patchSchema = z.object({
+  name: z.string().min(1).max(120).optional(),
+  retirementAgeA: z.number().int().min(30).max(100).nullable().optional(),
+  retirementAgeB: z.number().int().min(30).max(100).nullable().optional(),
+});
+
+export async function PATCH(
+  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 plan = await prisma.plan.findFirst({ where: { id: planId, household: { userId } } });
+  if (!plan) return NextResponse.json({ error: "Plan nicht gefunden." }, { status: 404 });
+
+  const body = await request.json();
+  const parsed = patchSchema.safeParse(body);
+  if (!parsed.success) return NextResponse.json({ error: "Ungueltige Eingabe." }, { status: 400 });
+
+  const updated = await prisma.plan.update({
+    where: { id: plan.id },
+    data: {
+      name: parsed.data.name ?? undefined,
+      retirementAgeA: parsed.data.retirementAgeA === undefined ? undefined : parsed.data.retirementAgeA,
+      retirementAgeB: parsed.data.retirementAgeB === undefined ? undefined : parsed.data.retirementAgeB,
+    },
+  });
+  return NextResponse.json({ plan: { id: updated.id, name: updated.name } });
+}
+
 export async function DELETE(
   _request: NextRequest,
   { params }: { params: Promise<{ planId: string }> }
 ) {
   const userId = await getCurrentUserId();
-  if (!userId) {
-    return NextResponse.json({ error: "Nicht authentifiziert." }, { status: 401 });
-  }
+  if (!userId) return NextResponse.json({ error: "Nicht authentifiziert." }, { status: 401 });
   const { planId } = await params;
   const plan = await prisma.plan.findFirst({ where: { id: planId, household: { userId } } });
-  if (!plan) {
-    return NextResponse.json({ error: "Plan nicht gefunden." }, { status: 404 });
-  }
+  if (!plan) return NextResponse.json({ error: "Plan nicht gefunden." }, { status: 404 });
   await prisma.plan.delete({ where: { id: plan.id } });
   return NextResponse.json({ ok: true });
 }

src/app/api/plans/[planId]/scenario/route.ts

@@ -1,7 +1,7 @@
 import { NextRequest, NextResponse } from "next/server";
 import { z } from "zod";
 import { prisma } from "@/lib/db";
-import { phaseInclude, getOwnedPlan } from "@/lib/queries";
+import { getOwnedPlan } from "@/lib/queries";
 import { getCurrentUserId } from "@/lib/session";
 
 const scenarioSchema = z.object({
@@ -9,114 +9,87 @@ const scenarioSchema = z.object({
   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).
+// 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 });
-  }
+  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: parsed.error.flatten() }, { status: 400 });
-  }
+  if (!parsed.success) return NextResponse.json({ error: "Ungueltige Eingabe." }, { status: 400 });
 
-  const sourcePlan = await getOwnedPlan(planId, userId);
-  if (!sourcePlan) {
-    return NextResponse.json({ error: "Ursprungsplan nicht gefunden." }, { status: 404 });
-  }
+  const source = await getOwnedPlan(planId, userId);
+  if (!source) 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 branchPhase = source.phases.find((p) => p.id === parsed.data.branchFromPhaseId);
+  if (!branchPhase) return NextResponse.json({ error: "Verzweigungsphase nicht gefunden." }, { status: 404 });
 
-  const phasesToCopy = sourcePlan.phases
+  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: sourcePlan.householdId,
+        householdId: source.householdId,
         name: parsed.data.name,
-        parentPlanId: sourcePlan.id,
+        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 phasesToCopy) {
-      const newPhase = await tx.phase.create({
+    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,
-          incomeMode: phase.incomeMode,
-          incomingCapital: phase.incomingCapital,
-          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,
-              carriedBaseValue: s.carriedBaseValue,
-            })),
-          },
-          realEstates: {
-            create: phase.realEstates.map((re) => ({
-              name: re.name,
-              purchasePrice: re.purchasePrice,
-              mortgage: re.mortgage,
-              amortization: re.amortization,
-            })),
-          },
-          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;
+      phaseIdMap.set(phase.id, created.id);
+      lastNewPhaseId = created.id;
     }
 
-    await tx.plan.update({
-      where: { id: newPlan.id },
-      data: { branchFromPhaseId: lastNewPhaseId },
-    });
+    // 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;
   });