Fix bond portfolios and add advisor chat

App/analysis/portfolio_advisor.py

@@ -0,0 +1,300 @@
+import asyncio
+import os
+from decimal import Decimal
+from typing import Any
+
+import requests
+
+from App.routers.funds.models import FundPerformance, MutualFund
+from App.routers.portfolio.service import PortfolioService
+
+
+def _safe_float(value: Any) -> float:
+    if value in (None, ""):
+        return 0.0
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return 0.0
+
+
+def _pct(value: Any) -> float:
+    numeric = _safe_float(value)
+    return numeric if numeric <= 1 else numeric / 100
+
+
+def _money(value: float) -> str:
+    return f"TZS {value:,.0f}"
+
+
+def _horizon_label(months: int | None) -> str:
+    if not months:
+        return "not specified"
+    if months < 12:
+        return f"{months} months"
+    years = months / 12
+    return f"{years:.1f} years"
+
+
+async def _fund_snapshot(limit: int = 18) -> list[dict[str, Any]]:
+    funds = await MutualFund.all().prefetch_related("manager")
+    rows: list[dict[str, Any]] = []
+    for fund in funds:
+        latest = await FundPerformance.filter(fund_id=fund.id).order_by("-record_date").first()
+        fund_type = str(fund.fund_type or "").lower()
+        name = str(fund.name or "")
+        is_liquid = (
+            "liquid" in fund_type
+            or "money" in fund_type
+            or "cash" in name.lower()
+            or (fund.redemption_days is not None and fund.redemption_days <= 3)
+        )
+        rows.append(
+            {
+                "id": fund.id,
+                "name": fund.name,
+                "manager": getattr(fund.manager, "name", None),
+                "fund_type": fund.fund_type,
+                "nav_per_unit": _safe_float(getattr(latest, "nav_per_unit", None)),
+                "entry_load": _safe_float(fund.entry_load),
+                "redemption_days": fund.redemption_days,
+                "pays_income": bool(fund.pays_income),
+                "income_frequency": fund.income_frequency,
+                "min_initial": fund.min_initial,
+                "liquidity_bucket": "liquid" if is_liquid else "standard",
+            }
+        )
+    return sorted(
+        rows,
+        key=lambda item: (
+            0 if item["liquidity_bucket"] == "liquid" else 1,
+            item["entry_load"],
+            item["name"] or "",
+        ),
+    )[:limit]
+
+
+async def _portfolio_context(portfolio_id: int) -> dict[str, Any]:
+    summary = await PortfolioService.get_portfolio_summary(portfolio_id)
+    total_value = _safe_float(summary.total_market_value)
+    total_cost = _safe_float(summary.total_cost_basis)
+    allocation = summary.asset_allocation
+    positions: list[dict[str, Any]] = []
+
+    for holding in summary.stock_holdings:
+        value = _safe_float(holding.market_value)
+        positions.append(
+            {
+                "asset_type": "STOCK",
+                "symbol": holding.stock_symbol,
+                "name": holding.stock_name,
+                "value": value,
+                "weight": value / total_value if total_value else 0,
+                "gain_loss_pct": _safe_float(holding.gain_loss_percentage),
+            }
+        )
+    for holding in summary.fund_holdings:
+        value = _safe_float(holding.market_value)
+        positions.append(
+            {
+                "asset_type": "FUND",
+                "symbol": holding.fund_name,
+                "name": holding.fund_name,
+                "value": value,
+                "weight": value / total_value if total_value else 0,
+                "gain_loss_pct": _safe_float(holding.gain_loss_percentage),
+            }
+        )
+    for holding in summary.bond_holdings:
+        value = _safe_float(holding.market_value)
+        positions.append(
+            {
+                "asset_type": "BOND",
+                "symbol": str(holding.auction_number or holding.bond_id),
+                "name": holding.instrument_type,
+                "value": value,
+                "weight": value / total_value if total_value else 0,
+                "maturity_date": str(holding.maturity_date),
+            }
+        )
+
+    return {
+        "portfolio_name": summary.portfolio.name,
+        "total_value": total_value,
+        "total_cost_basis": total_cost,
+        "unrealized_gain_loss": _safe_float(summary.unrealized_gain_loss),
+        "unrealized_gain_loss_pct": _safe_float(summary.unrealized_gain_loss_pct),
+        "allocation": {
+            "stocks": _pct(allocation.stocks_percentage),
+            "funds": _pct(allocation.funds_percentage),
+            "bonds": _pct(allocation.bonds_percentage),
+            "cash": _pct(getattr(allocation, "cash_percentage", Decimal("0"))),
+        },
+        "positions": sorted(positions, key=lambda item: item["weight"], reverse=True),
+    }
+
+
+def _heuristic_advice(
+    *,
+    message: str,
+    context: dict[str, Any],
+    funds: list[dict[str, Any]],
+    goal: str | None,
+    employment_status: str | None,
+    liquidity_need: str | None,
+    risk_profile: str | None,
+    horizon_months: int | None,
+) -> dict[str, Any]:
+    allocation = context["allocation"]
+    total_value = context["total_value"]
+    unemployed = "unemploy" in str(employment_status or message).lower()
+    high_liquidity = any(
+        word in str(liquidity_need or message).lower()
+        for word in ["high", "liquid", "emergency", "cash", "unemploy"]
+    )
+    growth_goal = any(
+        word in str(goal or message).lower()
+        for word in ["grow", "growth", "capital", "compound", "wealth"]
+    )
+
+    if unemployed or high_liquidity:
+        target = {"liquid_funds": 0.45, "bonds_income": 0.25, "stocks": 0.20, "opportunity_cash": 0.10}
+    elif growth_goal and (horizon_months or 0) >= 36:
+        target = {"liquid_funds": 0.15, "bonds_income": 0.20, "stocks": 0.45, "growth_funds": 0.20}
+    else:
+        target = {"liquid_funds": 0.25, "bonds_income": 0.25, "stocks": 0.30, "growth_funds": 0.20}
+
+    liquid_funds = [fund for fund in funds if fund["liquidity_bucket"] == "liquid"][:3]
+    income_funds = [fund for fund in funds if fund["pays_income"]][:3]
+    standard_funds = [fund for fund in funds if fund["liquidity_bucket"] != "liquid"][:3]
+
+    concentration = context["positions"][0] if context["positions"] else None
+    warnings = []
+    if concentration and concentration["weight"] > 0.55:
+        warnings.append(
+            f"{concentration['symbol']} is about {concentration['weight'] * 100:.1f}% of the portfolio, so one asset is driving most of the outcome."
+        )
+    if unemployed and allocation["stocks"] > 0.35:
+        warnings.append("Because income is uncertain, pure stock exposure above 35% may create liquidity stress during drawdowns.")
+    if high_liquidity and allocation["funds"] + allocation["cash"] < 0.30:
+        warnings.append("Your liquid bucket appears low for someone prioritising liquidity.")
+
+    key_actions = [
+        f"Build a liquid reserve first: target about {target['liquid_funds'] * 100:.0f}% in liquid or money-market style funds before adding more volatile assets.",
+        f"Use bonds or income funds for stability: target about {target['bonds_income'] * 100:.0f}% so capital growth is not forced to fund short-term spending.",
+        f"Keep growth exposure intentional: target about {target.get('stocks', 0) * 100:.0f}% in stocks if you can tolerate volatility and hold through market dips.",
+    ]
+    if liquid_funds:
+        key_actions.append(
+            "Liquid fund candidates to review: "
+            + ", ".join(f"{fund['name']} ({fund['manager'] or 'manager n/a'})" for fund in liquid_funds[:2])
+            + "."
+        )
+    if income_funds:
+        key_actions.append(
+            "Income/stability candidates to review: "
+            + ", ".join(f"{fund['name']}" for fund in income_funds[:2])
+            + "."
+        )
+
+    answer = (
+        f"For your stated goal ({goal or 'not specified'}) and horizon ({_horizon_label(horizon_months)}), "
+        f"I would arrange the portfolio around liquidity first, then controlled growth. "
+        f"Current tracked value is {_money(total_value)} with roughly stocks {allocation['stocks'] * 100:.1f}%, "
+        f"funds {allocation['funds'] * 100:.1f}%, and bonds {allocation['bonds'] * 100:.1f}%.\n\n"
+        "Suggested structure:\n"
+        + "\n".join(f"- {label.replace('_', ' ').title()}: {weight * 100:.0f}%" for label, weight in target.items())
+        + "\n\nNext steps:\n"
+        + "\n".join(f"- {action}" for action in key_actions[:5])
+    )
+    if warnings:
+        answer += "\n\nRisk flags:\n" + "\n".join(f"- {warning}" for warning in warnings)
+    answer += (
+        "\n\nThis is planning guidance, not a guaranteed outcome. Before acting, compare fees, minimum investments, "
+        "redemption days, tax treatment, and whether the fund/bond actually matches your cash-flow need."
+    )
+
+    return {
+        "reply": answer,
+        "provider": "heuristic_fallback",
+        "target_allocation": target,
+        "recommended_funds": {
+            "liquid": liquid_funds,
+            "income": income_funds,
+            "growth_or_standard": standard_funds,
+        },
+        "warnings": warnings,
+    }
+
+
+def _openrouter_reply(prompt: str) -> tuple[str | None, str | None]:
+    api_key = os.getenv("OPENROUTER_API_KEY")
+    if not api_key:
+        return None, None
+    model = os.getenv("PORTFOLIO_ADVISOR_MODEL", "openai/gpt-oss-20b:free")
+    try:
+        response = requests.post(
+            "https://openrouter.ai/api/v1/chat/completions",
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            },
+            json={
+                "model": model,
+                "messages": [
+                    {
+                        "role": "system",
+                        "content": (
+                            "You are a Tanzanian portfolio advisor for an investing app. "
+                            "Give practical allocation guidance, discuss liquidity, fees, funds, bonds, and stocks. "
+                            "Do not promise returns. Keep the answer concise and action-oriented."
+                        ),
+                    },
+                    {"role": "user", "content": prompt},
+                ],
+                "temperature": 0.35,
+            },
+            timeout=35,
+        )
+        response.raise_for_status()
+        data = response.json()
+        return data["choices"][0]["message"]["content"], model
+    except Exception:
+        return None, None
+
+
+async def generate_portfolio_advisor_reply(
+    portfolio_id: int,
+    request: dict[str, Any],
+) -> dict[str, Any]:
+    context, funds = await asyncio.gather(_portfolio_context(portfolio_id), _fund_snapshot())
+    heuristic = _heuristic_advice(
+        message=request.get("message") or "",
+        context=context,
+        funds=funds,
+        goal=request.get("goal"),
+        employment_status=request.get("employment_status"),
+        liquidity_need=request.get("liquidity_need"),
+        risk_profile=request.get("risk_profile"),
+        horizon_months=request.get("horizon_months"),
+    )
+
+    prompt = (
+        "User question:\n"
+        f"{request.get('message')}\n\n"
+        f"Goal: {request.get('goal') or 'not specified'}\n"
+        f"Employment status: {request.get('employment_status') or 'not specified'}\n"
+        f"Liquidity need: {request.get('liquidity_need') or 'not specified'}\n"
+        f"Risk profile: {request.get('risk_profile') or 'not specified'}\n"
+        f"Horizon months: {request.get('horizon_months') or 'not specified'}\n"
+        f"Hypothetical portfolio: {request.get('hypothetical_portfolio') or 'none'}\n\n"
+        f"Current portfolio context: {context}\n\n"
+        f"Available mutual fund candidates: {funds[:12]}\n\n"
+        f"Rule-based baseline advice to improve or refine: {heuristic['reply']}"
+    )
+    llm_reply, provider = await asyncio.to_thread(_openrouter_reply, prompt)
+    if llm_reply:
+        heuristic["reply"] = llm_reply
+        heuristic["provider"] = provider or "openrouter"
+    heuristic["portfolio_context"] = context
+    return heuristic

App/routers/portfolio/routes.py

@@ -12,6 +12,7 @@ import calendar as month_calendar
 import re
 
 from tortoise.contrib.pydantic import pydantic_model_creator
+from tortoise.exceptions import IntegrityError
 from tortoise.expressions import Q
 
 from App.schemas import ResponseModel, AppException
@@ -19,6 +20,7 @@ from App.routers.users.utils import get_current_user
 from App.routers.stocks.models import Dividend, Stock, StockPriceData
 from App.routers.funds.models import MutualFund, FundPerformance, FundIncomeOption
 from App.routers.bonds.models import Bond
+from App.analysis.portfolio_advisor import generate_portfolio_advisor_reply
 from App.analysis.portfolio_optimizer import run_portfolio_analysis_task
 from App.routers.tasks.models import ImportTask, TaskStatus
 
@@ -33,6 +35,7 @@ from .models import (
 )
 from .schemas import (
     PortfolioCreate,
+    PortfolioAdvisorChatRequest,
     PortfolioUpdate,
     StockHoldingCreate,
     StockHoldingUpdate,
@@ -543,6 +546,24 @@ async def get_growth_allocation_analysis(
     )
 
 
+@router.post("/{portfolio_id}/advisor-chat", summary="Chat with portfolio advisor")
+async def chat_with_portfolio_advisor(
+    portfolio_id: int,
+    payload: PortfolioAdvisorChatRequest,
+    current_user=Depends(get_current_user),
+):
+    await _verify_ownership(portfolio_id, current_user, active_only=True)
+    result = await generate_portfolio_advisor_reply(
+        portfolio_id=portfolio_id,
+        request=payload.model_dump(exclude_none=True),
+    )
+    return ResponseModel(
+        success=True,
+        message="Portfolio advisor response generated",
+        data=result,
+    )
+
+
 @router.put("/{portfolio_id}", summary="Update portfolio")
 async def update_portfolio(
     portfolio_id: int,
@@ -973,8 +994,107 @@ async def update_bond_holding(
         raise AppException(status_code=404, message="Bond holding not found")
 
     update_data = payload.model_dump(exclude_unset=True)
+    holding_fields = {
+        "holding_number",
+        "holding_status",
+        "face_value_held",
+        "purchase_price",
+        "purchase_date",
+        "notes",
+    }
+
     if update_data:
-        await holding.update_from_dict(update_data).save()
+        target_bond = None
+        if payload.bond_id is not None:
+            target_bond = await Bond.get_or_none(id=payload.bond_id)
+            if not target_bond:
+                raise AppException(status_code=404, message="Target bond not found")
+        elif payload.auction_number is not None:
+            bond_query = Bond.filter(auction_number=payload.auction_number)
+            if payload.effective_date:
+                bond_query = bond_query.filter(effective_date=payload.effective_date)
+            if payload.maturity_date:
+                bond_query = bond_query.filter(maturity_date=payload.maturity_date)
+            if payload.coupon_rate is not None:
+                bond_query = bond_query.filter(coupon_rate=float(payload.coupon_rate))
+            target_bond = await bond_query.first()
+
+            if not target_bond:
+                source_bond = holding.bond
+                effective_date = payload.effective_date or source_bond.effective_date
+                maturity_date = payload.maturity_date or source_bond.maturity_date
+                if not effective_date or not maturity_date:
+                    raise AppException(
+                        status_code=400,
+                        message="Provide effective_date and maturity_date when creating a missing reissue bond",
+                    )
+
+                synthetic_isin = (
+                    payload.isin
+                    or f"{payload.auction_number}{effective_date.strftime('%y%m%d')}"
+                )[:12]
+                existing_by_isin = await Bond.get_or_none(isin=synthetic_isin)
+                if existing_by_isin:
+                    target_bond = existing_by_isin
+                else:
+                    try:
+                        target_bond = await Bond.create(
+                            instrument_type=payload.instrument_type or source_bond.instrument_type,
+                            auction_number=payload.auction_number,
+                            auction_date=effective_date,
+                            maturity_years=payload.maturity_years or source_bond.maturity_years,
+                            maturity_date=maturity_date,
+                            effective_date=effective_date,
+                            dtm=payload.dtm if payload.dtm is not None else source_bond.dtm,
+                            bond_auction_number=payload.bond_auction_number
+                            or payload.auction_number
+                            or source_bond.bond_auction_number,
+                            holding_number=payload.holding_number
+                            if payload.holding_number is not None
+                            else source_bond.holding_number,
+                            face_value=int(payload.face_value_held or holding.face_value_held),
+                            price_per_100=float(
+                                payload.price_per_100
+                                if payload.price_per_100 is not None
+                                else source_bond.price_per_100
+                            ),
+                            coupon_rate=float(
+                                payload.coupon_rate
+                                if payload.coupon_rate is not None
+                                else source_bond.coupon_rate
+                            ),
+                            isin=synthetic_isin,
+                        )
+                    except IntegrityError:
+                        target_bond = await Bond.filter(
+                            auction_number=payload.auction_number,
+                            auction_date=effective_date,
+                        ).first()
+                        if not target_bond:
+                            raise AppException(
+                                status_code=400,
+                                message="A matching reissue bond already exists but could not be resolved",
+                            )
+
+        holding_update_data = {
+            key: value for key, value in update_data.items() if key in holding_fields
+        }
+        if target_bond and target_bond.id != holding.bond_id:
+            existing_holding = await PortfolioBond.get_or_none(
+                portfolio_id=portfolio_id,
+                bond_id=target_bond.id,
+            )
+            if existing_holding and existing_holding.id != holding.id:
+                raise AppException(
+                    status_code=400,
+                    message="Portfolio already has a holding for the target auction bond",
+                )
+            holding.bond_id = target_bond.id
+
+        if holding_update_data:
+            await holding.update_from_dict(holding_update_data)
+        await holding.save()
+        await holding.fetch_related("bond")
         unit_price = (
             holding.purchase_price / Decimal(str(holding.face_value_held))
             if holding.face_value_held
@@ -983,7 +1103,7 @@ async def update_bond_holding(
         await _replace_position_transactions(
             portfolio_id=portfolio_id,
             asset_type="BOND",
-            asset_id=bond_id,
+            asset_id=holding.bond_id,
             quantity=Decimal(str(holding.face_value_held)),
             unit_price=unit_price,
             txn_date=holding.purchase_date,

App/routers/portfolio/schemas.py

@@ -3,7 +3,7 @@ Portfolio schemas — ONLY pydantic/stdlib imports.
 NEVER import from .models, .service, .routes, or .utils
 """
 from pydantic import BaseModel, Field, ConfigDict
-from typing import Optional, Dict
+from typing import Any, Optional, Dict
 from datetime import date, datetime
 from decimal import Decimal
 
@@ -33,6 +33,16 @@ class PortfolioUpdate(BaseModel):
     is_active: Optional[bool] = None
 
 
+class PortfolioAdvisorChatRequest(BaseModel):
+    message: str = Field(..., min_length=2, max_length=3000)
+    goal: Optional[str] = Field(None, max_length=500)
+    employment_status: Optional[str] = Field(None, max_length=80)
+    liquidity_need: Optional[str] = Field(None, max_length=80)
+    risk_profile: Optional[str] = Field(None, max_length=80)
+    horizon_months: Optional[int] = Field(None, ge=1, le=600)
+    hypothetical_portfolio: Optional[Dict[str, Any]] = None
+
+
 # ──────────────── STOCK HOLDINGS ────────────────
 
 
@@ -150,6 +160,17 @@ class BondHoldingCreate(BaseModel):
 
 
 class BondHoldingUpdate(BaseModel):
+    bond_id: Optional[int] = None
+    auction_number: Optional[int] = None
+    instrument_type: Optional[str] = None
+    maturity_years: Optional[str] = None
+    maturity_date: Optional[date] = None
+    effective_date: Optional[date] = None
+    dtm: Optional[int] = None
+    bond_auction_number: Optional[int] = None
+    price_per_100: Optional[Decimal] = Field(None, gt=0)
+    coupon_rate: Optional[Decimal] = Field(None, gt=0)
+    isin: Optional[str] = None
     holding_number: Optional[int] = None
     holding_status: Optional[str] = None
     face_value_held: Optional[Decimal] = Field(None, gt=0)

App/routers/portfolio/service.py

@@ -7,6 +7,7 @@ from decimal import Decimal
 from datetime import date, timedelta
 from typing import Optional, Generator
 
+from tortoise.exceptions import IntegrityError
 from tortoise.transactions import in_transaction
 
 from App.schemas import AppException
@@ -48,6 +49,12 @@ def _pct(part: Decimal, total: Decimal) -> Decimal:
     return (part / total * HUNDRED) if total > 0 else ZERO
 
 
+def _to_decimal(value, default: Decimal = ZERO) -> Decimal:
+    if value in (None, ""):
+        return default
+    return Decimal(str(value))
+
+
 def _gain(market_value: Optional[Decimal], cost: Decimal):
     if market_value is None:
         return None, None
@@ -535,8 +542,8 @@ class PortfolioService:
         )
         results = []
         for h in holdings:
-            price_pct = getattr(h.bond, "price_per_100", None) or HUNDRED
-            market_value = Decimal(h.face_value_held) * price_pct / HUNDRED
+            price_pct = _to_decimal(getattr(h.bond, "price_per_100", None), HUNDRED)
+            market_value = Decimal(str(h.face_value_held)) * price_pct / HUNDRED
             gl, _ = _gain(market_value, h.purchase_price)
 
             results.append(
@@ -770,20 +777,33 @@ class PortfolioService:
             total_cost += h.purchase_price
 
         total_value = stock_val + utt_val + bond_val
+        defaults = {
+            "total_value": total_value,
+            "stock_value": stock_val,
+            "bond_value": bond_val,
+            "fund_value": utt_val,
+            "cash_value": ZERO,
+            "total_cost": total_cost,
+            "unrealized_gain_loss": total_value - total_cost,
+        }
 
-        snapshot, _ = await PortfolioSnapshot.update_or_create(
-            portfolio_id=portfolio_id,
-            snapshot_date=target,
-            defaults={
-                "total_value": total_value,
-                "stock_value": stock_val,
-                "bond_value": bond_val,
-                "fund_value": utt_val,
-                "cash_value": ZERO,
-                "total_cost": total_cost,
-                "unrealized_gain_loss": total_value - total_cost,
-            },
-        )
+        try:
+            snapshot, _ = await PortfolioSnapshot.update_or_create(
+                portfolio_id=portfolio_id,
+                snapshot_date=target,
+                defaults=defaults,
+            )
+        except IntegrityError:
+            # Another task may have inserted the same portfolio/day snapshot
+            # between the lookup and insert phases. Treat that as an update.
+            await PortfolioSnapshot.filter(
+                portfolio_id=portfolio_id,
+                snapshot_date=target,
+            ).update(**defaults)
+            snapshot = await PortfolioSnapshot.get(
+                portfolio_id=portfolio_id,
+                snapshot_date=target,
+            )
         return snapshot
 
     # ──────────────── REGENERATE SNAPSHOTS ────────────────