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/phases/[phaseId]/route.ts

@@ -1,139 +1,75 @@
 import { NextRequest, NextResponse } from "next/server";
 import { z } from "zod";
 import { prisma } from "@/lib/db";
-import { phaseInclude, getOwnedPhase } from "@/lib/queries";
+import { getHouseholdOrNull, getOwnedPhase, getOwnedPlan, toPlanInput } from "@/lib/queries";
 import { getCurrentUserId } from "@/lib/session";
-
-const incomeEntrySchema = z.object({
-  personId: z.string().nullable().optional(),
-  label: z.string().nullable().optional(),
-  amount: z.number(),
-});
-const expenseEntrySchema = z.object({
-  label: z.string().nullable().optional(),
-  amount: z.number(),
-});
-const securitySchema = z.object({
-  name: z.string().min(1),
-  startValue: z.number(),
-  expectedReturn: z.number(),
-  annualContribution: z.number(),
-  ownerTag: z.enum(["PERSON_A", "PERSON_B", "HOUSEHOLD"]),
-  saleTaxRate: z.number().min(0).max(100),
-  carriedBaseValue: z.number().default(0),
-});
-const realEstateSchema = z.object({
-  name: z.string().min(1),
-  // Muss zwingend angegeben werden (siehe Anforderung: Kaufpreis ist Pflichtfeld).
-  purchasePrice: z.number().positive("Kaufpreis muss groesser als 0 sein."),
-  mortgage: z.number(),
-  amortization: z.number(),
-});
-const oneTimeEventSchema = z.object({
-  type: z.enum(["INCOME", "EXPENSE"]),
-  amount: z.number(),
-  description: z.string().nullable().optional(),
-});
-const retirementInfoSchema = z.object({
-  personId: z.string().min(1),
-  ahvAmount: z.number().min(0),
-  pkPensionAmount: z.number().min(0),
-  lumpSumAmount: z.number().min(0),
-  lumpSumTaxRate: z.number().min(0).max(100),
-});
+import { maxPhaseDuration } from "@/lib/calculations";
 
 const updatePhaseSchema = z.object({
-  name: z.string().min(1).max(120),
-  durationYears: z.number().int().min(1).max(80),
+  name: z.string().min(1).max(120).optional(),
+  durationYears: z.number().int().min(1).max(80).optional(),
   inflationRate: z.number().min(-20).max(50).nullable().optional(),
-  incomeMode: z.enum(["PER_PERSON", "HOUSEHOLD"]),
-  incomeEntries: z.array(incomeEntrySchema).default([]),
-  expenseEntries: z.array(expenseEntrySchema).default([]),
-  securities: z.array(securitySchema).default([]),
-  realEstates: z.array(realEstateSchema).default([]),
-  oneTimeEvents: z.array(oneTimeEventSchema).default([]),
-  retirementInfos: z.array(retirementInfoSchema).default([]),
 });
 
-// Ersetzt eine Phase vollstaendig (Basisfelder + alle Unter-Sammlungen). Fuer ein
-// Single-User-Tool ohne nennenswerte Nebenlaeufigkeit ist ein "delete + recreate" der
-// Kindobjekte einfacher und robuster als granulares Diffing pro Zeile.
 export async function PUT(
   request: NextRequest,
   { params }: { params: Promise<{ phaseId: 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 { phaseId } = await params;
-  const body = await request.json();
-  const parsed = updatePhaseSchema.safeParse(body);
-  if (!parsed.success) {
-    return NextResponse.json({ error: parsed.error.flatten() }, { status: 400 });
-  }
-  const data = parsed.data;
 
   const existing = await getOwnedPhase(phaseId, userId);
-  if (!existing) {
-    return NextResponse.json({ error: "Phase nicht gefunden." }, { status: 404 });
+  if (!existing) return NextResponse.json({ error: "Phase nicht gefunden." }, { status: 404 });
+
+  const body = await request.json();
+  const parsed = updatePhaseSchema.safeParse(body);
+  if (!parsed.success) return NextResponse.json({ error: "Ungueltige Eingabe." }, { status: 400 });
+
+  let duration = parsed.data.durationYears;
+  if (duration != null) {
+    // Dauer ans naechste Pensionsereignis kappen (Jahre vor dieser Phase).
+    const household = await getHouseholdOrNull(userId);
+    const plan = await getOwnedPlan(existing.planId, userId);
+    if (household && plan) {
+      const planInput = toPlanInput(plan);
+      const yearsBefore = planInput.phases
+        .filter((p) => p.sequenceNumber < existing.sequenceNumber)
+        .reduce((s, p) => s + p.durationYears, 0);
+      const cap = maxPhaseDuration(household.persons, planInput, yearsBefore);
+      if (cap != null) duration = Math.min(duration, cap);
+      duration = Math.max(1, duration);
+    }
   }
 
-  const phase = await prisma.$transaction(async (tx) => {
-    await Promise.all([
-      tx.incomeEntry.deleteMany({ where: { phaseId } }),
-      tx.expenseEntry.deleteMany({ where: { phaseId } }),
-      tx.security.deleteMany({ where: { phaseId } }),
-      tx.realEstate.deleteMany({ where: { phaseId } }),
-      tx.oneTimeEvent.deleteMany({ where: { phaseId } }),
-      tx.retirementInfo.deleteMany({ where: { phaseId } }),
-    ]);
-
-    return tx.phase.update({
-      where: { id: phaseId },
-      data: {
-        name: data.name,
-        durationYears: data.durationYears,
-        inflationRate: data.inflationRate ?? null,
-        incomeMode: data.incomeMode,
-        incomeEntries: { create: data.incomeEntries.map((e) => ({ ...e, label: e.label ?? null, personId: e.personId ?? null })) },
-        expenseEntries: { create: data.expenseEntries.map((e) => ({ ...e, label: e.label ?? null })) },
-        securities: { create: data.securities },
-        realEstates: { create: data.realEstates },
-        oneTimeEvents: { create: data.oneTimeEvents.map((e) => ({ ...e, description: e.description ?? null })) },
-        retirementInfos: { create: data.retirementInfos },
-      },
-      include: phaseInclude,
-    });
+  const phase = await prisma.phase.update({
+    where: { id: phaseId },
+    data: {
+      name: parsed.data.name ?? undefined,
+      durationYears: duration ?? undefined,
+      inflationRate: parsed.data.inflationRate === undefined ? undefined : parsed.data.inflationRate,
+    },
   });
-
-  return NextResponse.json({ phase });
+  return NextResponse.json({ phase: { id: phase.id } });
 }
 
-// Eine Phase kann nur geloescht werden, wenn sie die letzte in der Kette ist -- so
-// bleibt die Verkettung (Schlussvermoegen = Startvermoegen der Folgephase) immer intakt.
+// Nur die letzte Phase kann geloescht werden (Verkettung bleibt intakt).
 export async function DELETE(
   _request: NextRequest,
   { params }: { params: Promise<{ phaseId: 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 { phaseId } = await params;
-  const phase = await getOwnedPhase(phaseId, userId);
-  if (!phase) {
-    return NextResponse.json({ error: "Phase nicht gefunden." }, { status: 404 });
-  }
 
-  const laterPhase = await prisma.phase.findFirst({
+  const phase = await getOwnedPhase(phaseId, userId);
+  if (!phase) return NextResponse.json({ error: "Phase nicht gefunden." }, { status: 404 });
+
+  const later = await prisma.phase.findFirst({
     where: { planId: phase.planId, sequenceNumber: { gt: phase.sequenceNumber } },
   });
-  if (laterPhase) {
-    return NextResponse.json(
-      { error: "Nur die letzte Phase eines Plans kann geloescht werden." },
-      { status: 400 }
-    );
+  if (later) {
+    return NextResponse.json({ error: "Nur die letzte Phase kann geloescht werden." }, { status: 400 });
   }
 
   await prisma.phase.delete({ where: { id: phaseId } });

src/app/api/phases/[phaseId]/transition/route.ts

@@ -1,237 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-import { z } from "zod";
-import { prisma } from "@/lib/db";
-import { computeMortgageYearly, computeSecurityYearlyValues } from "@/lib/calculations";
-import { floorToThousand } from "@/lib/format";
-import { getCurrentUserId } from "@/lib/session";
-
-const transitionItemSchema = z.object({
-  positionType: z.enum(["SECURITY", "REAL_ESTATE"]),
-  securityId: z.string().nullable().optional(),
-  realEstateId: z.string().nullable().optional(),
-  decision: z.enum(["CARRY_OVER", "SELL"]),
-  salePrice: z.number().nullable().optional(),
-  // Nur bei Immobilien-Verkauf relevant (Grundstueckgewinnsteuer in %).
-  saleTaxRate: z.number().min(0).max(100).nullable().optional(),
-});
-
-const putTransitionSchema = z.object({
-  items: z.array(transitionItemSchema),
-});
-
-// Liefert die aktuellen Positionen der Phase (Wertschriften + Immobilien) sowie eine
-// evtl. bereits vorhandene Entscheidung, damit die UI den Uebergangs-Screen (TDD 4.4)
-// rendern kann.
-export async function GET(
-  _request: NextRequest,
-  { params }: { params: Promise<{ phaseId: string }> }
-) {
-  const userId = await getCurrentUserId();
-  if (!userId) {
-    return NextResponse.json({ error: "Nicht authentifiziert." }, { status: 401 });
-  }
-  const { phaseId } = await params;
-  const phase = await prisma.phase.findFirst({
-    where: { id: phaseId, plan: { household: { userId } } },
-    include: { securities: true, realEstates: true },
-  });
-  if (!phase) {
-    return NextResponse.json({ error: "Phase nicht gefunden." }, { status: 404 });
-  }
-
-  const nextPhase = await prisma.phase.findFirst({
-    where: { planId: phase.planId, sequenceNumber: phase.sequenceNumber + 1 },
-  });
-
-  const transition = await prisma.phaseTransition.findUnique({
-    where: { fromPhaseId: phaseId },
-    include: { items: true },
-  });
-
-  return NextResponse.json({
-    positions: {
-      securities: phase.securities,
-      realEstates: phase.realEstates,
-    },
-    nextPhase,
-    transition,
-  });
-}
-
-// Speichert die Entscheidungen (Uebernehmen/Verkaufen bzw. Halten/Verkaufen) fuer jede
-// Position der Vorphase. Uebernommene/gehaltene Positionen werden automatisch 1:1 (mit
-// zurueckgesetztem Sparbeitrag/Amortisation) in der Folgephase angelegt. Verkaufte
-// Positionen fliessen als "verfuegbares Startkapital" (Phase.incomingCapital) ein.
-export async function PUT(
-  request: NextRequest,
-  { params }: { params: Promise<{ phaseId: string }> }
-) {
-  const userId = await getCurrentUserId();
-  if (!userId) {
-    return NextResponse.json({ error: "Nicht authentifiziert." }, { status: 401 });
-  }
-  const { phaseId } = await params;
-  const body = await request.json();
-  const parsed = putTransitionSchema.safeParse(body);
-  if (!parsed.success) {
-    return NextResponse.json({ error: parsed.error.flatten() }, { status: 400 });
-  }
-
-  const phase = await prisma.phase.findFirst({
-    where: { id: phaseId, plan: { household: { userId } } },
-    include: { securities: true, realEstates: true },
-  });
-  if (!phase) {
-    return NextResponse.json({ error: "Phase nicht gefunden." }, { status: 404 });
-  }
-
-  const nextPhase = await prisma.phase.findFirst({
-    where: { planId: phase.planId, sequenceNumber: phase.sequenceNumber + 1 },
-  });
-  if (!nextPhase) {
-    return NextResponse.json(
-      { error: "Es existiert noch keine Folgephase fuer diesen Uebergang." },
-      { status: 400 }
-    );
-  }
-
-  const requiredIds = new Set([
-    ...phase.securities.map((s) => `SECURITY:${s.id}`),
-    ...phase.realEstates.map((re) => `REAL_ESTATE:${re.id}`),
-  ]);
-  const providedIds = new Set(
-    parsed.data.items.map((i) => `${i.positionType}:${i.securityId ?? i.realEstateId}`)
-  );
-  const missing = [...requiredIds].filter((id) => !providedIds.has(id));
-  if (missing.length > 0) {
-    return NextResponse.json(
-      { error: "Fuer jede bestehende Position muss Uebernehmen/Halten oder Verkaufen gewaehlt werden." },
-      { status: 400 }
-    );
-  }
-
-  const securityById = new Map(phase.securities.map((s) => [s.id, s]));
-  const realEstateById = new Map(phase.realEstates.map((re) => [re.id, re]));
-
-  let incomingCapital = 0;
-  const securitiesToCarry: { source: (typeof phase.securities)[number]; endValue: number }[] = [];
-  const realEstatesToCarry: { source: (typeof phase.realEstates)[number]; remainingMortgage: number }[] = [];
-
-  for (const item of parsed.data.items) {
-    if (item.positionType === "SECURITY" && item.securityId) {
-      const security = securityById.get(item.securityId);
-      if (!security) continue;
-      const endValue = computeSecurityYearlyValues(
-        security.startValue,
-        security.expectedReturn,
-        security.annualContribution,
-        phase.durationYears
-      )[phase.durationYears];
-
-      if (item.decision === "CARRY_OVER") {
-        securitiesToCarry.push({ source: security, endValue });
-      } else {
-        const gain = Math.max(0, endValue - security.startValue);
-        const tax = gain * (security.saleTaxRate / 100);
-        incomingCapital += endValue - tax;
-      }
-    } else if (item.positionType === "REAL_ESTATE" && item.realEstateId) {
-      const realEstate = realEstateById.get(item.realEstateId);
-      if (!realEstate) continue;
-      const remainingMortgage = computeMortgageYearly(
-        realEstate.mortgage,
-        realEstate.amortization,
-        phase.durationYears
-      )[phase.durationYears];
-
-      if (item.decision === "CARRY_OVER") {
-        realEstatesToCarry.push({ source: realEstate, remainingMortgage });
-      } else {
-        const salePrice = item.salePrice ?? 0;
-        const saleTaxRate = item.saleTaxRate ?? 0;
-        const gain = Math.max(0, salePrice - realEstate.purchasePrice);
-        const tax = gain * (saleTaxRate / 100);
-        incomingCapital += salePrice - remainingMortgage - tax;
-      }
-    }
-  }
-
-  // Auf ein Vielfaches von 1'000 abrunden, damit der Betrag ueber Wertschriften
-  // (die nur in 1'000er-Schritten Sparbeitraege/Startwerte annehmen) vollstaendig
-  // verteilbar bleibt.
-  incomingCapital = floorToThousand(incomingCapital);
-
-  const transition = await prisma.$transaction(async (tx) => {
-    await tx.phaseTransition.deleteMany({ where: { fromPhaseId: phaseId } });
-
-    // Vorherige automatisch uebernommene Positionen aus einem frueheren Speichern
-    // dieses Uebergangs entfernen, damit sie nicht dupliziert werden. Manuell vom
-    // Benutzer angelegte Positionen (carriedFrom...Id = null) bleiben unberuehrt.
-    await tx.security.deleteMany({
-      where: {
-        phaseId: nextPhase.id,
-        carriedFromSecurityId: { in: phase.securities.map((s) => s.id) },
-      },
-    });
-    await tx.realEstate.deleteMany({
-      where: {
-        phaseId: nextPhase.id,
-        carriedFromRealEstateId: { in: phase.realEstates.map((re) => re.id) },
-      },
-    });
-
-    for (const { source, endValue } of securitiesToCarry) {
-      await tx.security.create({
-        data: {
-          phaseId: nextPhase.id,
-          name: source.name,
-          startValue: endValue,
-          carriedBaseValue: endValue,
-          expectedReturn: source.expectedReturn,
-          annualContribution: 0,
-          ownerTag: source.ownerTag,
-          saleTaxRate: source.saleTaxRate,
-          carriedFromSecurityId: source.id,
-        },
-      });
-    }
-
-    for (const { source, remainingMortgage } of realEstatesToCarry) {
-      await tx.realEstate.create({
-        data: {
-          phaseId: nextPhase.id,
-          name: source.name,
-          purchasePrice: source.purchasePrice,
-          mortgage: remainingMortgage,
-          amortization: 0,
-          carriedFromRealEstateId: source.id,
-        },
-      });
-    }
-
-    await tx.phase.update({
-      where: { id: nextPhase.id },
-      data: { incomingCapital },
-    });
-
-    return tx.phaseTransition.create({
-      data: {
-        fromPhaseId: phaseId,
-        toPhaseId: nextPhase.id,
-        items: {
-          create: parsed.data.items.map((i) => ({
-            positionType: i.positionType,
-            securityId: i.securityId ?? null,
-            realEstateId: i.realEstateId ?? null,
-            decision: i.decision,
-            salePrice: i.salePrice ?? null,
-            saleTaxRate: i.saleTaxRate ?? null,
-          })),
-        },
-      },
-      include: { items: true },
-    });
-  });
-
-  return NextResponse.json({ transition, incomingCapital });
-}