feat: Planungs- und Szenario-API mit Projektion und Vorschlaegen

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

finance/app/services/projection_service.py

@@ -0,0 +1,58 @@
+from datetime import date, timedelta
+from datetime import datetime, timezone
+from decimal import Decimal
+
+from sqlalchemy import delete, select
+from sqlalchemy.orm import Session
+
+from app.config import get_settings
+from app.engine.loans import loan_schedule
+from app.engine.projection import project
+from app.engine.scenario import (PlainModifier, PlainPlanned, PlainRecurring,
+                                 build_cashflows)
+from app.models.tables import (Loan, PlannedItem, ProjectionPoint,
+                               ProjectionResult, RecurringItem, Scenario,
+                               ScenarioLoan, ScenarioModifier)
+from app.services.balances import total_balance
+
+
+def run_projection(session: Session, scenario: Scenario, horizon_days: int,
+                   start_date: date) -> ProjectionResult:
+    end = start_date + timedelta(days=horizon_days)
+    recurring = []
+    if scenario.include_recurring:
+        recurring = [PlainRecurring(r.id, r.name, Decimal(r.amount), r.rhythm,
+                                    r.due_day, r.start_date, r.end_date, r.category_id)
+                     for r in session.execute(select(RecurringItem)).scalars()]
+    planned = []
+    if scenario.include_planned:
+        planned = [PlainPlanned(p.name, Decimal(p.amount), p.due, p.category_id)
+                   for p in session.execute(select(PlannedItem)).scalars()]
+    loans = session.execute(
+        select(Loan).join(ScenarioLoan, ScenarioLoan.loan_id == Loan.id)
+        .where(ScenarioLoan.scenario_id == scenario.id)).scalars().all()
+    schedules = [loan_schedule(Decimal(l.principal), Decimal(l.annual_rate_pct),
+                               l.term_months, l.payout_date, l.repayment_type)
+                 for l in loans]
+    payouts = [(l.payout_date, Decimal(l.principal)) for l in loans]
+    modifiers = [PlainModifier(m.target_type, m.target_id, m.kind, Decimal(m.value))
+                 for m in session.execute(select(ScenarioModifier).where(
+                     ScenarioModifier.scenario_id == scenario.id)).scalars()]
+    flows = build_cashflows(recurring, planned, schedules, payouts, modifiers,
+                            start_date, end)
+    proj = project(total_balance(session), start_date, flows, horizon_days,
+                   threshold=get_settings().warn_threshold)
+    session.execute(delete(ProjectionPoint).where(
+        ProjectionPoint.scenario_id == scenario.id))
+    for d, bal in proj.series:
+        session.add(ProjectionPoint(scenario_id=scenario.id, day=d, balance=bal))
+    result = session.get(ProjectionResult, scenario.id) or ProjectionResult(
+        scenario_id=scenario.id, computed_at=datetime.now(timezone.utc),
+        low_point_date=proj.low_point[0], low_point_balance=proj.low_point[1])
+    result.computed_at = datetime.now(timezone.utc)
+    result.low_point_date, result.low_point_balance = proj.low_point
+    result.below_zero_date = proj.first_below_zero
+    result.below_threshold_date = proj.first_below_threshold
+    session.add(result)
+    session.commit()
+    return result

finance/app/services/suggestions.py

@@ -0,0 +1,52 @@
+import statistics
+from collections import Counter, defaultdict
+from decimal import Decimal
+
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from app.models.tables import RecurringItem, Transaction
+
+
+def _max_consecutive_months(months: list[tuple[int, int]]) -> int:
+    if not months:
+        return 0
+    best = current = 1
+    for prev, cur in zip(months, months[1:]):
+        prev_idx = prev[0] * 12 + prev[1]
+        cur_idx = cur[0] * 12 + cur[1]
+        current = current + 1 if cur_idx == prev_idx + 1 else 1
+        best = max(best, current)
+    return best
+
+
+def suggest_recurring(session: Session) -> list[dict]:
+    txs = session.execute(
+        select(Transaction).where(Transaction.status == "confirmed")
+    ).scalars().all()
+    groups: dict[tuple, list[Transaction]] = defaultdict(list)
+    for t in txs:
+        groups[(t.account_id, t.counterparty, t.amount)].append(t)
+
+    existing = {(r.name, Decimal(r.amount))
+               for r in session.execute(select(RecurringItem)).scalars()}
+
+    suggestions: list[dict] = []
+    for (_account_id, counterparty, amount), items in groups.items():
+        months = sorted({(t.booking_date.year, t.booking_date.month) for t in items})
+        if _max_consecutive_months(months) < 3:
+            continue
+        name = counterparty
+        if (name, Decimal(amount)) in existing:
+            continue
+        due_day = int(statistics.median(sorted(t.booking_date.day for t in items)))
+        cat_counts = Counter(t.category_id for t in items if t.category_id is not None)
+        category_id = cat_counts.most_common(1)[0][0] if cat_counts else None
+        suggestions.append({
+            "name": name,
+            "amount": Decimal(amount),
+            "rhythm": "monthly",
+            "due_day": due_day,
+            "category_id": category_id,
+        })
+    return suggestions